zoukankan      html  css  js  c++  java
  • 加密html

    2009年4月4日 周六 22:18
    
    <HTML>
    <HEAD>
    <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
    
    <TITLE>文本加密</TITLE>
    
    <SCRIPT LANGUAGE="JavaScript">
    function TEAencrypt(plaintext, password)
    {
         if (plaintext.length == 0) return('');   // nothing to encrypt
         // 'escape' plaintext so chars outside ISO-8859-1 work in single-byte packing, but keep
         // spaces as spaces (not '%20') so encrypted text doesn't grow too long (quick & dirty)
         var asciitext = escape(plaintext).replace(/%20/g,' ');
         var v = strToLongs(asciitext);   // convert string to array of longs
         if (v.length <= 1) v[1] = 0;   // algorithm doesn't work for n<2 so fudge by adding a null
         var k = strToLongs(password.slice(0,16));   // simply convert first 16 chars of password as key
         var n = v.length;
    
         var z = v[n-1], y = v[0], delta = 0x9E3779B9;
         var mx, e, q = Math.floor(6 + 52/n), sum = 0;
    
         while (q-- > 0) {   // 6 + 52/n operations gives between 6 & 32 mixes on each word
             sum += delta;
             e = sum>>>2 & 3;
             for (var p = 0; p < n; p++) {
                 y = v[(p+1)%n];
                 mx = (z>>>5 ^ y<<2) + (y>>>3 ^ z<<4) ^ (sum^y) + (k[p&3 ^ e] ^ z);
                 z = v[p] += mx;
             }
         }
    
         var ciphertext = longsToStr(v);
    
         return escCtrlCh(ciphertext);
    }
    
    //
    // TEAdecrypt: Use Corrected Block TEA to decrypt ciphertext using password
    //
    function TEAdecrypt(ciphertext, password)
    {
         if (ciphertext.length == 0) return('');
         var v = strToLongs(unescCtrlCh(ciphertext));
         var k = strToLongs(password.slice(0,16)); 
         var n = v.length;
    
         var z = v[n-1], y = v[0], delta = 0x9E3779B9;
         var mx, e, q = Math.floor(6 + 52/n), sum = q*delta;
    
         while (sum != 0) {
             e = sum>>>2 & 3;
             for (var p = n-1; p >= 0; p--) {
                 z = v[p>0 ? p-1 : n-1];
                 mx = (z>>>5 ^ y<<2) + (y>>>3 ^ z<<4) ^ (sum^y) + (k[p&3 ^ e] ^ z);
                 y = v[p] -= mx;
             }
             sum -= delta;
         }
    
         var plaintext = longsToStr(v);
    
         // strip trailing null chars resulting from filling 4-char blocks:
         plaintext = plaintext.replace(/+$/,'');
    
         return unescape(plaintext);
    }
    
    
    // supporting functions
    
    function strToLongs(s) {   // convert string to array of longs, each containing 4 chars
         // note chars must be within ISO-8859-1 (with Unicode code-point < 256) to fit 4/long
         var l = new Array(Math.ceil(s.length/4));
         for (var i=0; i<l.length; i++) {
             // note little-endian encoding - endianness is irrelevant as long as 
             // it is the same in longsToStr() 
             l[i] = s.charCodeAt(i*4) + (s.charCodeAt(i*4+1)<<8) + 
                    (s.charCodeAt(i*4+2)<<16) + (s.charCodeAt(i*4+3)<<24);
         }
         return l;   // note running off the end of the string generates nulls since 
    }               // bitwise operators treat NaN as 0
    
    function longsToStr(l) {   // convert array of longs back to string
         var a = new Array(l.length);
         for (var i=0; i<l.length; i++) {
             a[i] = String.fromCharCode(l[i] & 0xFF, l[i]>>>8 & 0xFF, 
                                        l[i]>>>16 & 0xFF, l[i]>>>24 & 0xFF);
         }
         return a.join('');   // use Array.join() rather than repeated string appends for efficiency
    }
    
    function escCtrlCh(str) {   // escape control chars etc which might cause problems with encrypted texts
         return str.replace(/[	
    vf
    xa0'"!]/g, function(c) { return '!' + c.charCodeAt(0) + '!'; });
    }
    
    function unescCtrlCh(str) {   // unescape potentially problematic nulls and control characters
         return str.replace(/!dd?d?!/g, function(c) { return String.fromCharCode(c.slice(1,-1)); });
    }
    
    var Base64 = function(){}
    Base64.encodeChars =
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    Base64.decodeChars = new Array( - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,
         - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,
         - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,
         - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1, 62,   - 1,   - 1,   - 1,
         63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,   - 1,   - 1,   - 1,   - 1,   - 1,
         - 1,   - 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
         19, 20, 21, 22, 23, 24, 25,   - 1,   - 1,   - 1,   - 1,   - 1,   - 1, 26, 27, 28,
         29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
         48, 49, 50, 51,   - 1,   - 1,   - 1,   - 1,   - 1);
    
    Base64.encode = function(str)
    {
         var out, i, len;
         var c1, c2, c3;
    
         len = str.length;
         i = 0;
         out = "";
         while (i < len)
         {
             c1 = str.charCodeAt(i++) & 0xff;
             if (i == len)
             {
                 out += Base64.encodeChars.charAt(c1 >> 2);
                 out += Base64.encodeChars.charAt((c1 & 0x3) << 4);
                 out += "==";
                 break;
             }
             c2 = str.charCodeAt(i++);
             if (i == len)
             {
                 out += Base64.encodeChars.charAt(c1 >> 2);
                 out += Base64.encodeChars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0)
                     >> 4));
                 out += Base64.encodeChars.charAt((c2 & 0xF) << 2);
                 out += "=";
                 break;
             }
             c3 = str.charCodeAt(i++);
             out += Base64.encodeChars.charAt(c1 >> 2);
             out += Base64.encodeChars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4))
                 ;
             out += Base64.encodeChars.charAt(((c2 & 0xF) << 2) | ((c3 & 0xC0) >> 6))
                 ;
             out += Base64.encodeChars.charAt(c3 & 0x3F);
         }
         return out;
    }
    
    Base64.decode = function(str)
    {
         var c1, c2, c3, c4;
         var i, len, out;
    
         len = str.length;
         i = 0;
         out = "";
         while (i < len)
         {
             /* c1 */
             do
             {
                 c1 = Base64.decodeChars[str.charCodeAt(i++) & 0xff];
             }
             while (i < len && c1 ==   - 1);
             if (c1 ==   - 1)
                 break;
    
             /* c2 */
             do
             {
                 c2 = Base64.decodeChars[str.charCodeAt(i++) & 0xff];
             }
             while (i < len && c2 ==   - 1);
             if (c2 ==   - 1)
                 break;
    
             out += String.fromCharCode((c1 << 2) | ((c2 & 0x30) >> 4));
    
             /* c3 */
             do
             {
                 c3 = str.charCodeAt(i++) & 0xff;
                 if (c3 == 61)
                     return out;
                 c3 = Base64.decodeChars[c3];
             }
             while (i < len && c3 ==   - 1);
             if (c3 ==   - 1)
                 break;
    
             out += String.fromCharCode(((c2 & 0XF) << 4) | ((c3 & 0x3C) >> 2));
    
             /* c4 */
             do
             {
                 c4 = str.charCodeAt(i++) & 0xff;
                 if (c4 == 61)
                     return out;
                 c4 = Base64.decodeChars[c4];
             }
             while (i < len && c4 ==   - 1);
             if (c4 ==   - 1)
                 break;
             out += String.fromCharCode(((c3 & 0x03) << 6) | c4);
         }
         return out;
    }
    
    Base64.utf16to8 = function(str)
    {
         var out, i, len, c;
    
         out = "";
         len = str.length;
         for (i = 0; i < len; i++)
         {
             c = str.charCodeAt(i);
             if ((c >= 0x0001) && (c <= 0x007F))
             {
                 out += str.charAt(i);
             }
             else if (c > 0x07FF)
             {
                 out += String.fromCharCode(0xE0 | ((c >> 12) & 0x0F));
                 out += String.fromCharCode(0x80 | ((c >> 6) & 0x3F));
                 out += String.fromCharCode(0x80 | ((c >> 0) & 0x3F));
             }
             else
             {
                 out += String.fromCharCode(0xC0 | ((c >> 6) & 0x1F));
                 out += String.fromCharCode(0x80 | ((c >> 0) & 0x3F));
             }
         }
         return out;
    }
    
    Base64.utf8to16 = function(str)
    {
         var out, i, len, c;
         var char2, char3;
    
         out = "";
         len = str.length;
         i = 0;
         while (i < len)
         {
             c = str.charCodeAt(i++);
             switch (c >> 4)
             {
                 case 0:
                 case 1:
                 case 2:
                 case 3:
                 case 4:
                 case 5:
                 case 6:
                 case 7:
                     // 0xxxxxxx
                     out += str.charAt(i - 1);
                     break;
                 case 12:
                 case 13:
                     // 110x xxxx    10xx xxxx
                     char2 = str.charCodeAt(i++);
                     out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
                     break;
                 case 14:
                     // 1110 xxxx   10xx xxxx   10xx xxxx
                     char2 = str.charCodeAt(i++);
                     char3 = str.charCodeAt(i++);
                     out += String.fromCharCode(((c & 0x0F) << 12) | ((char2 & 0x3F)
                         << 6) | ((char3 & 0x3F) << 0));
                     break;
             }
         }
    
         return out;
    }
    
    
    function doSecure()
    {
    var str = TEAencrypt(document.getElementById("txtUnsecure").value, document.getElementById("txtPassw").value);
    document.getElementById("txtSecure").value   = Base64.encode(Base64.utf16to8(str));
    }
    
    function doUnsecure()
    {
    var str = Base64.utf8to16(Base64.decode(document.getElementById("txtSecure").value));
    document.getElementById("txtUnsecure").value = TEAdecrypt(str, document.getElementById("txtPassw").value);
    
    }
    </script>
    
    
    </HEAD>
    <BODY >
    
    <center>
    <table border=1 width="571">
    <tr>
    <td>
    <form name=frmSecurity>
    <p><font color=#ff0000>密码:</font> 
    <input type=password id=txtPassw size=20 value="">
    <table border=0>
    <tr>
    <p><font color=#0000ff>原文</font>
    </tr>
    <tr>
    <textarea rows=20 id=txtUnsecure cols=120 wrap=virtual>我是一个美女!</textarea>
    </tr>
    <tr align=center>
    <input type=button value="             加密               "
    name=btnSecure onclick="doSecure()">
    <br>
    <input type=button value="             解密               "
    name=btnUnsecure onclick="doUnsecure()">
    </tr>
    <tr>
    <p><font color=#0000ff>加密之后</font>
    </tr>
    <tr>
    <textarea rows=20 id=txtSecure cols=120 wrap=virtual></textarea></td>
    </tr>
    </table>
    </form>
    </td>
    </tr>
    </table>
    </center>
    </BODY></HTML>
  • 相关阅读:
    MySQL >>> 存储引擎
    MySQL >>> 基本操作语句
    MySQL >>> 使用安装
    协程 *单线程实现并发
    进程池 & 线程池
    线程 *知识点扩充
    进程 & 线程
    DRF单表序列化
    DRF
    接口规范
  • 原文地址:https://www.cnblogs.com/yasepix/p/5138239.html
Copyright © 2011-2022 走看看