首先我们来假设一个情况。

　　我们要做一个flash，里面存了一段话，只想给知道密码的人看。通常的做法是检测用户的输入是否等于密码，然后显示。但是由于Flash是开放结构，所以swf文件可以反汇编然后看到密码，这时候就可以非法的看到要保护的东西了。

　　但是假如通过一个不可逆的算法把密码加密，然后存在swf里面。然后把用户输入的密码也同样加密，然后比对加密以后的字串是否相等就可以了。因为swf里面保存的密码是不可逆的嘛~~

　　不可逆的加密算法有很多种，最流行的就是md系列了，现在的是md5。md5可以计算认可字串的特征，然后归结到一个32字节长的字串里面，源字串一点点的改动就会造成特称字串巨大的变化。

　　据个例子：

　　"abc"的md5是900150983cd24fb0d6963f7d28e17f72
　　"abb"的md5是ea01e5fd8e4d8832825acdd20eac5104

　　为什么说不可逆呢？

　　据个例子

　　问题:1000是由什么数字相加而成的呢？
　　答案是不知道~
　　假如说是两个数字，那么我们可以有1+999或者500+500或者……但是三个、四个、直到n个数字呢？也就是说我们不可能知道原来的数字是什么，猜中的机会很小。而md5也是同样的原理，将每个字符的特征值相加再相加，自然就很难猜到原来是什么东西了~

　　那么我们有了密码检测了~着时候需要一个可逆的加密算法来处理我们要保存的东西，因为要还原嘛~~这类算法很多，我选择了较流行的des算法

　　des函数的定义是这样的
　　des ("密码", "加密文本", 模式)

　　模式=1的时候，des返回加密后的值
　　模式=0的时候，des返回解密后的值

　　但是由于des返回的值不一定是通用字符集里面的，所以我就做了一点处理，将des的值转成16进制字串，防止错误的产生。

　　道理很明白了，怎么用呢~~首先，我们来创建密码的md5值，使用下面的函数：

[color=#6495ED[B]]/*E-mail: tsxy@21cn.comMoon.Blue*/var hexcase = 0;var b64pad  = "";var strsize   = 8; function md5(s){ return binl2hex(core_md5(str2binl(s), s.length * strsize));}function b64_md5(s){ return binl2b64(core_md5(str2binl(s), s.length * strsize));}function str_md5(s){ return binl2str(core_md5(str2binl(s), s.length * strsize));}function hex_hmac_md5(key, data) { return binl2hex(core_hmac_md5(key, data)); }function b64_hmac_md5(key, data) { return binl2b64(core_hmac_md5(key, data)); }function str_hmac_md5(key, data) { return binl2str(core_hmac_md5(key, data)); }function core_md5(x, len){  x[len >> 5] |= 0x80 << ((len) % 32);  x[(((len + 64) >>> 9) << 4) + 14] = len;    var a =  1732584193;  var b = -271733879;  var c = -1732584194;  var d =  271733878;  for(var i = 0; i < x.length; i += 16) {    var olda = a;    var oldb = b;    var oldc = c;    var oldd = d;    a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);    d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);    c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);    b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);    a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);    d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);    c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);    b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);    a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);    d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);    c = md5_ff(c, d, a, b, x[i+10], 17, -42063);    b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);    a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);    d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);    c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);    b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);    a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);    d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);    c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);    b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);    a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);    d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);    c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);    b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);    a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);    d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);    c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);    b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);    a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);    d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);    c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);    b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);    a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);    d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);    c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);    b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);    a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);    d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);    c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);    b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);    a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);    d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);    c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);    b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);    a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);    d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);    c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);    b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);    a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);    d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);    c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);    b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);    a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);    d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);    c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);    b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);    a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);    d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);    c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);    b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);    a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);    d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);    c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);    b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);    a = safe_add(a, olda);    b = safe_add(b, oldb);    c = safe_add(c, oldc);    d = safe_add(d, oldd);  }  return Array(a, b, c, d);}function md5_cmn(q, a, b, x, s, t){  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);}function md5_ff(a, b, c, d, x, s, t){  return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);}function md5_gg(a, b, c, d, x, s, t){  return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);}function md5_hh(a, b, c, d, x, s, t){  return md5_cmn(b ^ c ^ d, a, b, x, s, t);}function md5_ii(a, b, c, d, x, s, t){  return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);}function core_hmac_md5(key, data){  var bkey = str2binl(key);  if(bkey.length > 16) bkey = core_md5(bkey, key.length * strsize);  var ipad = Array(16), opad = Array(16);  for(var i = 0; i < 16; i++) {    ipad[i] = bkey[i] ^ 0x36363636;    opad[i] = bkey[i] ^ 0x5C5C5C5C;  }  var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * strsize);  return core_md5(opad.concat(hash), 512 + 128);}function safe_add(x, y){  var lsw = (x & 0xFFFF) + (y & 0xFFFF);  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);  return (msw << 16) | (lsw & 0xFFFF);}function bit_rol(num, cnt){  return (num << cnt) | (num >>> (32 - cnt));}function str2binl(str){  var bin = Array();  var mask = (1 << strsize) - 1;  for(var i = 0; i < str.length * strsize; i += strsize)    bin[i>>5] |= (str.charCodeAt(i / strsize) & mask) << (i%32);  return bin;}function binl2str(bin){  var str = "";  var mask = (1 << strsize) - 1;  for(var i = 0; i < bin.length * 32; i += strsize)    str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);  return str;}function binl2hex(binarray){  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";  var str = "";  for(var i = 0; i < binarray.length * 4; i++){    str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +           hex_tab.charAt((binarray[i>>2] >> ((i%4)*8  )) & 0xF);  }  return str;}function binl2b64(binarray){  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";  var str = "";  for(var i = 0; i < binarray.length * 4; i += 3){    var triplet = (((binarray[i   >> 2] >> 8 * ( i   %4)) & 0xFF) << 16)                | (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )                |  ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);    for(var j = 0; j < 4; j++){      if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;      else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);    }  }  return str;}trace(md5("abb"));[/B][/color]

　　将这个程序放到flash的第一帧，这里的abb应该换成你的密码，然后运行。把显示出来的字串复制下来，然后去掉trace那一行。
加入passd="刚才复制的字串";

　　这时候，再加入另外一段代码（拷贝代码的时候请注重有些折行需要更改－－颜色较淡的部分）：
[color=#6495ED][B]function des(key, message, encrypt, mode, iv) {    //declaring this locally speeds things up a bit    var spfunction1 = new Array(0x1010400, 0, 0x10000, 0x1010404, 0x1010004, 0x10404,
 0x4, 0x10000, 0x400, 0x1010400, 0x1010404, 0x400, 0x1000404, 0x1010004, 0x1000000, 0x4,
 0x404, 0x1000400, 0x1000400, 0x10400, 0x10400, 0x1010000, 0x1010000, 0x1000404, 0x10004,
 0x1000004, 0x1000004, 0x10004, 0, 0x404, 0x10404, 0x1000000, 0x10000, 0x1010404, 0x4,
 0x1010000, 0x1010400, 0x1000000, 0x1000000, 0x400, 0x1010004, 0x10000, 0x10400, 0x1000004,
 0x400, 0x4, 0x1000404, 0x10404, 0x1010404, 0x10004, 0x1010000, 0x1000404, 0x1000004, 0x404,
 0x10404, 0x1010400, 0x404, 0x1000400, 0x1000400, 0, 0x10004, 0x10400, 0, 0x1010004);    var spfunction2 = new Array(0x80108020, 0x80008000, 0x8000, 0x108020, 0x100000,
 0x20, 0x80100020, 0x80008020, 0x80000020, 0x80108020, 0x80108000, 0x80000000, 0x80008000,
 0x100000, 0x20, 0x80100020, 0x108000, 0x100020, 0x80008020, 0, 0x80000000, 0x8000, 0x108020,
 0x80100000, 0x100020, 0x80000020, 0, 0x108000, 0x8020, 0x80108000, 0x80100000, 0x8020, 0,
 0x108020, 0x80100020, 0x100000, 0x80008020, 0x80100000, 0x80108000, 0x8000, 0x80100000,
 0x80008000, 0x20, 0x80108020, 0x108020, 0x20, 0x8000, 0x80000000, 0x8020, 0x80108000, 0x100000,
 0x80000020, 0x100020, 0x80008020, 0x80000020, 0x100020, 0x108000, 0, 0x80008000, 0x8020,
 0x80000000, 0x80100020, 0x80108020, 0x108000);    var spfunction3 = new Array(0x208, 0x8020200, 0, 0x8020008, 0x8000200, 0, 0x20208,
0x8000200, 0x20008, 0x8000008, 0x8000008, 0x20000, 0x8020208, 0x20008, 0x8020000, 0x208,
 0x8000000, 0x8, 0x8020200, 0x200, 0x20200, 0x8020000, 0x8020008, 0x20208, 0x8000208,
 0x20200, 0x20000, 0x8000208, 0x8, 0x8020208, 0x200, 0x8000000, 0x8020200, 0x8000000,
 0x20008, 0x208, 0x20000, 0x8020200, 0x8000200, 0, 0x200, 0x20008, 0x8020208, 0x8000200,
 0x8000008, 0x200, 0, 0x8020008, 0x8000208, 0x20000, 0x8000000, 0x8020208, 0x8, 0x20208,
 0x20200, 0x8000008, 0x8020000, 0x8000208, 0x208, 0x8020000, 0x20208, 0x8, 0x8020008, 0x20200);    var spfunction4 = new Array(0x802001, 0x2081, 0x2081, 0x80, 0x802080, 0x800081,
 0x800001, 0x2001, 0, 0x802000, 0x802000, 0x802081, 0x81, 0, 0x800080, 0x800001, 0x1,
 0x2000, 0x800000, 0x802001, 0x80, 0x800000, 0x2001, 0x2080, 0x800081, 0x1, 0x2080,
 0x800080, 0x2000, 0x802080, 0x802081, 0x81, 0x800080, 0x800001, 0x802000, 0x802081,
 0x81, 0, 0, 0x802000, 0x2080, 0x800080, 0x800081, 0x1, 0x802001, 0x2081, 0x2081, 0x80,
 0x802081, 0x81, 0x1, 0x2000, 0x800001, 0x2001, 0x802080, 0x800081, 0x2001, 0x2080, 0x800000,
 0x802001, 0x80, 0x800000, 0x2000, 0x802080);    var spfunction5 = new Array(0x100, 0x2080100, 0x2080000, 0x42000100, 0x80000, 0x100,
 0x40000000, 0x2080000, 0x40080100, 0x80000, 0x2000100, 0x40080100, 0x42000100, 0x42080000,
 0x80100, 0x40000000, 0x2000000, 0x40080000, 0x40080000, 0, 0x40000100, 0x42080100, 0x42080100,
 0x2000100, 0x42080000, 0x40000100, 0, 0x42000000, 0x2080100, 0x2000000, 0x42000000, 0x80100,
 0x80000, 0x42000100, 0x100, 0x2000000, 0x40000000, 0x2080000, 0x42000100, 0x40080100,
 0x2000100, 0x40000000, 0x42080000, 0x2080100, 0x40080100, 0x100, 0x2000000, 0x42080000,
 0x42080100, 0x80100, 0x42000000, 0x42080100, 0x2080000, 0, 0x40080000, 0x42000000, 0x80100,
 0x2000100, 0x40000100, 0x80000, 0, 0x40080000, 0x2080100, 0x40000100);    var spfunction6 = new Array(0x20000010, 0x20400000, 0x4000, 0x20404010, 0x20400000, 0x10,
 0x20404010, 0x400000, 0x20004000, 0x404010, 0x400000, 0x20000010, 0x400010, 0x20004000,
 0x20000000, 0x4010, 0, 0x400010, 0x20004010, 0x4000, 0x404000, 0x20004010, 0x10, 0x20400010,
 0x20400010, 0, 0x404010, 0x20404000, 0x4010, 0x404000, 0x20404000, 0x20000000, 0x20004000,
 0x10, 0x20400010, 0x404000, 0x20404010, 0x400000, 0x4010, 0x20000010, 0x400000, 0x20004000,
 0x20000000, 0x4010, 0x20000010, 0x20404010, 0x404000, 0x20400000, 0x404010, 0x20404000, 0,
 0x20400010, 0x10, 0x4000, 0x20400000, 0x404010, 0x4000, 0x400010, 0x20004010, 0, 0x20404000,
 0x20000000, 0x400010, 0x20004010);    var spfunction7 = new Array(0x200000, 0x4200002, 0x4000802, 0, 0x800, 0x4000802, 0x200802,
 0x4200800, 0x4200802, 0x200000, 0, 0x4000002, 0x2, 0x4000000, 0x4200002, 0x802, 0x4000800,
 0x200802, 0x200002, 0x4000800, 0x4000002, 0x4200000, 0x4200800, 0x200002, 0x4200000, 0x800,
 0x802, 0x4200802, 0x200800, 0x2, 0x4000000, 0x200800, 0x4000000, 0x200800, 0x200000, 0x4000802,
&n

bsp;0x4000802, 0x4200002, 0x4200002, 0x2, 0x200002, 0x4000000, 0x4000800, 0x200000, 0x4200800,
 0x802, 0x200802, 0x4200800, 0x802, 0x4000002, 0x4200802, 0x4200000, 0x200800, 0, 0x2, 0x4200802,
 0, 0x200802, 0x4200000, 0x800, 0x4000002, 0x4000800, 0x800, 0x200002);    var spfunction8 = new Array(0x10001040, 0x1000, 0x40000, 0x10041040, 0x10000000,
 0x10001040, 0x40, 0x10000000, 0x40040, 0x10040000, 0x10041040, 0x41000, 0x10041000,
 0x41040, 0x1000, 0x40, 0x10040000, 0x10000040, 0x10001000, 0x1040, 0x41000, 0x40040,
 0x10040040, 0x10041000, 0x1040, 0, 0, 0x10040040, 0x10000040, 0x10001000, 0x41040, 0x40000,
 0x41040, 0x40000, 0x10041000, 0x1000, 0x40, 0x10040040, 0x1000, 0x41040, 0x10001000, 0x40,
 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x40000, 0x10001040, 0, 0x10041040, 0x40040,
 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0, 0x10041040, 0x41000, 0x41000, 0x1040,
 0x1040, 0x40040, 0x10000000, 0x10041000);
    //create the 16 or 48 subkeys we will need    var keys = des_createKeys(key);    var m = 0, i, j, temp, temp2, right1, right2, left, right, looping;    var cbcleft, cbcleft2, cbcright, cbcright2;    var endloop, loopinc;    var len = message.length;    var chunk = 0;
    //set up the loops for single and triple des    var iterations = keys.length == 32 ? 3 : 9;
    //single or triple des    if (iterations == 3) {        looping = encrypt ? new Array(0, 32, 2) : new Array(30, -2, -2);    } else {        looping = encrypt ? new Array(0, 32, 2, 62, 30, -2, 64, 96, 2) :
 new Array(94, 62, -2, 32, 64, 2, 30, -2, -2);    }    message += "";
    //pad the message out with null bytes    //store the result here    result = "";    tempresult = "";    if (mode == 1) {        //CBC mode        cbcleft = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16)
 | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);        cbcright = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16)
 | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);        m = 0;    }
    //loop through each 64 bit chunk of the message    while (m<len) {        left = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16)
 | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);        right = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16)
 | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);        //for Cipher Block Chaining mode, xor the message with the previous result        if (mode == 1) {            if (encrypt) {                left ^= cbcleft;                right ^= cbcright;            } else {                cbcleft2 = cbcleft;                cbcright2 = cbcright;                cbcleft = left;                cbcright = right;            }        }
        //first each 64 but chunk of the message must be permuted according to IP        temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;        right ^= temp;        left ^= (temp << 4);        temp = ((left >>> 16) ^ right) & 0x0000ffff;        right ^= temp;        left ^= (temp << 16);        temp = ((right >>> 2) ^ left) & 0x33333333;        left ^= temp; &

nbsp;      right ^= (temp << 2);        temp = ((right >>> 8) ^ left) & 0x00ff00ff;        left ^= temp;        right ^= (temp << 8);        temp = ((left >>> 1) ^ right) & 0x55555555;        right ^= temp;        left ^= (temp << 1);        left = ((left << 1) | (left >>> 31));        right = ((right << 1) | (right >>> 31));
        //do this either 1 or 3 times for each chunk of the message        for (j=0; j<iterations; j += 3) {            endloop = looping[j+1];            loopinc = looping[j+2];            //now go through and perform the encryption or decryption              for (i=looping[j]; i != endloop; i += loopinc) {                //for efficiency                right1 = right ^ keys[i];                right2 = ((right >>> 4) | (right << 28)) ^ keys[i+1];                //the result is attained by passing these bytes through the S selection functions                temp = left;                left = right;                right = temp ^ (spfunction2[(right1 >>> 24) & 0x3f] |
 spfunction4[(right1 >>> 16) & 0x3f] | spfunction6[(right1 >>> 8) & 0x3f] |
 spfunction8[right1 & 0x3f] | spfunction1[(right2 >>> 24) & 0x3f] |
 spfunction3[(right2 >>> 16) & 0x3f] | spfunction5[(right2 >>> 8) & 0x3f] |
 spfunction7[right2 & 0x3f]);            }            temp = left;            left = right;            right = temp;            //unreverse left and right        }
        //for either 1 or 3 iterations        //move then each one bit to the right        left = ((left >>> 1) | (left << 31));        right = ((right >>> 1) | (right << 31));        //now perform IP-1, which is IP in the opposite direction        temp = ((left >>> 1) ^ right) & 0x55555555;        right ^= temp;        left ^= (temp << 1);        temp = ((right >>> 8) ^ left) & 0x00ff00ff;        left ^= temp;        right ^= (temp << 8);        temp = ((right >>> 2) ^ left) & 0x33333333;        left ^= temp;        right ^= (temp << 2);        temp = ((left >>> 16) ^ right) & 0x0000ffff;        right ^= temp;        left ^= (temp << 16);        temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;        right ^= temp;        left ^= (temp << 4);        //for Cipher Block Chaining mode, xor the message with the previous result        if (mode == 1) {            if (encrypt) {                cbcleft = left;   &nb

sp;            cbcright = right;            } else {                left ^= cbcleft2;                right ^= cbcright2;            }        }        tempresult += String.fromCharCode((left >>> 24), ((left >>> 16) & 0xff),
 ((left >>> 8) & 0xff), (left & 0xff), (right >>> 24), ((right >>> 16) & 0xff),
 ((right >>> 8) & 0xff), (right & 0xff));        chunk += 8;        if (chunk == 512) {            result += tempresult;            tempresult = "";            chunk = 0;        }    }    //for every 8 characters, or 64 bits in the message    //return the result as an array    return result+tempresult;}//end of des//des_createKeys//this takes as input a 64 bit key (even though only 56 bits are used)//as an array of 2 integers, and returns 16 48 bit keysfunction des_createKeys(key) {    //declaring this locally speeds things up a bit    pc2bytes0 = new Array(0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000, 0x20010004,
 0x200, 0x204, 0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200, 0x20010204);    pc2bytes1 = new Array(0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000, 0x4100001,
 0x100, 0x101, 0x100100, 0x100101, 0x4000100, 0x4000101, 0x4100100, 0x4100101);    pc2bytes2 = new Array(0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808, 0,
 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808);    pc2bytes3 = new Array(0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000, 0x8202000,
 0x20000, 0x220000, 0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000, 0x8222000);    pc2bytes4 = new Array(0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000, 0x41000,
 0x1010, 0x41010, 0x1000, 0x41000, 0x1010, 0x41010);    pc2bytes5 = new Array(0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400,
 0x2000020, 0x2000420, 0x2000000, 0x2000400, 0x2000020, 0x2000420);    pc2bytes6 = new Array(0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002,
 0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002);    pc2bytes7 = new Array(0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800, 0x20010800,
 0x20000, 0x30000, 0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800, 0x20030800);    pc2bytes8 = new Array(0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000, 0x2040000,
 0x2000000, 0x2040000, 0x2000002, 0x2040002, 0x2000002, 0x2040002);    pc2bytes9 = new Array(0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008, 0x400,
 0x10000400, 0x408, 0x10000408, 0x400, 0x10000400, 0x408, 0x10000408);    pc2bytes10 = new Array(0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000, 0x2020,
 0x2000, 0x2020, 0x102000, 0x102020, 0x102000, 0x102020);    pc2bytes11 = new Array(0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200, 0x1200200,
 0x4000000, 0x5000000, 0x4000200, 0x5000200, 0x4200000, 0x5200000, 0x4200200, 0x5200200);    pc2bytes12 = new Array(0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000, 0x8081000,
 0x10, 0x1010, 0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010);    pc2bytes13 = new Array(0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101, 0x105,
 0x1, 0x5, 0x101, 0x105);    //how many iterations (1 for des, 3 for triple des)    var iterations = key.length>=24 ? 3 : 1;    //stores the return keys    var keys = new Array(32*iterations);    //now define the left shifts which need to be done    var shifts = new Array(0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);    //other variables    var lefttemp, righttemp, m = 0, n = 0, temp;    for (var j = 0; j<iterations; j++) {        //either 1 or 3 iterations        lef

t = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16)
 | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);        right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16)
 | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);        temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;        right ^= temp;        left ^= (temp << 4);        temp = ((right >>> -16) ^ left) & 0x0000ffff;        left ^= temp;        right ^= (temp << -16);        temp = ((left >>> 2) ^ right) & 0x33333333;        right ^= temp;        left ^= (temp << 2);        temp = ((right >>> -16) ^ left) & 0x0000ffff;        left ^= temp;        right ^= (temp << -16);        temp = ((left >>> 1) ^ right) & 0x55555555;        right ^= temp;        left ^= (temp << 1);        temp = ((right >>> 8) ^ left) & 0x00ff00ff;        left ^= temp;        right ^= (temp << 8);        temp = ((left >>> 1) ^ right) & 0x55555555;        right ^= temp;        left ^= (temp << 1);        //the right side needs to be shifted and to get the last four bits of the left side        temp = (left << 8) | ((right >>> 20) & 0x000000f0);        //left needs to be put upside down        left = (right << 24) | ((right << 8) & 0xff0000) |
 ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);        right = temp;        //now go through and perform these shifts on the left and right keys        for (i=0; i<shifts.length; i++) {            //shift the keys either one or two bits to the left            if (shifts[i]) {                left = (left << 2) | (left >>> 26);                right = (right << 2) | (right >>> 26);            } else {                left = (left << 1) | (left >>> 27);                right = (right << 1) | (right >>> 27);            }            left &= 0xfffffff0;            right &= 0xfffffff0;            //now apply PC-2, in such a way that E is easier when encrypting or decrypting            //this conversion will look like PC-2 except only the last 6 bits of each byte are used            //rather than 48 consecutive bits and the order of lines will be according to             //how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7            lefttemp = pc2bytes0[left >>> 28] | pc2bytes1[(left >>> 24) & 0xf] |
 pc2bytes2[(left >>> 20) & 0xf] | pc2bytes3[(left >>> 16) & 0xf] | pc2bytes4[(left >>> 12)
 & 0xf] | pc2bytes5[(left >>> 8) & 0xf] | pc2bytes6[(left >>> 4) & 0xf];            righttemp = pc2bytes7[right >>> 28] | pc2bytes8[(right >>> 24) & 0xf]
 | pc2bytes9[(right >>> 20) & 0xf] | pc2bytes10[(right >>> 16) & 0xf] |
 pc2bytes11[(right >>> 12) & 0xf] | pc2bytes12[(right >>> 8) & 0xf] |
 pc2bytes13[(right >>> 4) & 0xf];            temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;            keys[n++] = lefttemp ^ temp;            keys[n++] = righttemp ^ (temp << 16);        }    }    //for each iterations    //return the keys we\\'ve created    return keys;}//end of des_createKeys////////////////////////////// TEST ////////////////////////////////printHexArrayfunction printHex(s) {    var r = "0x";    var hexes = new Array("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f");    for (var i = 0; i<s.length; i++) {        r += hexes[s.charCodeAt(i) >> 4]+hexes[s.charCodeAt(i) & 0xf];    }    return r;}function unHex(s) {    var r = "";    for (var i = 2; i<s.length; i += 2) {        x1 = s.charCodeAt(i);        x1 = x1>=48 && x1<58 ? x1-48 : x1-97+10;        x2 = s.charCodeAt(i+1);        x2 = x2>=48 && x2<58 ? x2-48 : x2-97+10;        r += String.fromCharCode(((x1 << 4) & 0xF0) | (x2 & 0x0F));    }    return r;}test=printHex(des ("没有md5的密码", "要保护的字串", 1));trace(test);trace(unHex(des ("没有md5的密码", test, 0)));[/B][/color]

这时候再运行，然后把显示出来的字串（0x开头）copy下来。

　　然后删除

　　test=printHex(des ("没有md5的密码", "要保护的字串", 1));
　　trace(test);
　　trace(unHex(des ("没有md5的密码", test, 0)));

　　写入

　　test="刚才copy的字串";

　　这时候你的作品就差不多完成了

　　然后你要做的就是将用户输入的密码读入，假设你读入到了input这个变量里面。那么程序就应该写
[color=#6495ED]
if(md5(input)==pass){     trace(unHex(des (pass, test, 0)));}else{
     trace("密码错误");}
 
 [/color]　怎么样？其实总共要写得代码就只有七行~~很简朴吧。

　　到底有多安全？我只敢说和钱没有关系就很安全。