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>
  • 相关阅读:
    三元表达式 列表和字典推导式 函数对象 名称空间 作用域 global和nonlocal 函数装饰器 枚举对象
    函数参数 打散机制 字符串比较 返回值
    函数简介
    三种字符串的介绍 文件的读写
    字符编码
    数据类型及其常用方法 数据类型转换 可变与不可变 值拷贝与深浅拷贝
    流程控制 while和for循环
    变量命名规范 常量 输入和输出 注释 数据类型 运算符 逻辑运算符
    语言分类 编译型和解释型语言分析 环境变量 代码执行的方式 pip介绍 变量
    Python django tests
  • 原文地址:https://www.cnblogs.com/yasepix/p/5138239.html
Copyright © 2011-2022 走看看