复制代码代码如下 :
// 2001 년 7 월 Paul Tero
//http://www.tero.co.uk/des/
//
// 2001 년 11 월 Michael Hayworth의 큰 블록으로 성능을 최적화했습니다.
//http://www.netdealing.com
//
//이 소프트웨어는 "있는 그대로"및
//
// 상업성 및 특정 목적에 대한 체력에 대한 묵시적 보증
// 부인됩니다. 어떠한 경우에도 저자 나 기고자는 책임을지지 않습니다.
// 직접, 간접적, 부수적, 특별, 모범적이거나 결과적으로
// 손상 (대체 상품의 조달을 포함하지만 제한되지 않습니다.
// 또는 서비스; 사용 손실, 데이터 또는 이익; 또는 비즈니스 중단)
// 그러나 계약에 관계없이 모든 책임 이론에 의한 것은 엄격합니다.
// 어떤 식 으로든 발생하는 책임 또는 불법 행위 (태만 또는 기타 포함)
// 가능성에 대해 조언 하더라도이 소프트웨어 사용에서
// 그런 손상.
// des
// 이것은 키, 메시지 및 암호화 또는 해독 여부를 가져옵니다.
함수 des (키, 메시지, 암호화, 모드, iv, 패딩) {
// 로컬로 선언하면 속도가 약간 떨어집니다
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,0x10004,0x10400,0x101004).
var spfunction2 = 새로운 배열 (-0x7fef7fe0, -0x7fff8000,0x8000,0x108020,0x100000,0x20, -0x7fefffe0, -0x7fff7fe0, -0x7fffffe0, -0x7fef7fe0, -0x7fef8000, -0x8000000000000000000000000000000000000000000000000000000000fef8000 , 0x20, -0x7fefffe0,0x108000, 0x100020, -0x7fff7fe0,0, -0x80000000,0x8000,0x108020, -0x7ff00000,0x100020, -0x7fffffe0,0,0x108000,0x8020, -0x7fef8000, -0x7000,0000,0000,000020, 0001000020, 000100020202020102010202010202010201020201020102010202020202020202020 0x7fff7fe0, -0x7ff00000 ,-0x7fef8000,0x8000,-0x7ff00000,-0x7fff8000,0x20,-0x7fef7fe0,0x108020,0x20,0x8000,-0x80000000,0x8020,-0x7fef8000,0x100000,-0x7fffffe0,0x100020,-0x7fff7fe0,-0x7fffffe0,0x100020,0x108000,0, -0x7fff8000,0x8020, -0x80000000, -0x7fefffe0, -0x7fef7fe0,0x108000);
var spfunction3 = 새 배열 (0x208,0x8020200,0x8020008,0x8000200,0x20208,0x8000200,0x20008,0x8000008,0x8000008,0x20000,0x8020208,0x80,000,000,0x80000200020002000200020002000002 x8020200,0x200,0x20200,0x8020000, 0x8020008,0x20208,0x8000208,0x20200,0x20000,0x8000208,0x8,0x80208,0x200,0x8000000,0x8020200,0x800000000,0x20008,0X208,0000,000,00020020020020202020202020202020202020202020202020202020202020200200200200200200200200,000200200,000200200,000200200200200200200200200200200200200200200200200200200200200200200200200200 , 0x80208,0x8000200,0x8000008,0x200,0, 0x8020008,0x8000208,0x20000,0x8000000,0x8020208,0x8,0x20208,0x20200,0x8000008,0x8020000,0x8000208,0X208,0X8020000,0X208,0X80X80200020002000200020002000200020002000200020002000
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,0x8081,0x80,0x80,0000,000,000,0000,0000,0000,0000,000,0000,0000,0000,0000,0000,000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,000 00081,0x1,0x802001,0x2081,0x2081, 0x80,0x802081,0x81,0x1,0x2000,0x8001,0x2001,0x802080,0x800081,0x2001,0x2080,0x800000,0x802001,0x80,0x800000,0x2000,080 x80208020802080
var spfunction5 = 새 배열 (0x100,0x2080100,0x2080000,0x42000100,0x80000,0x100,0x40000000,0x2080000,0x40080100,0x80000,0x2000100,0x40080100,00000000000000000000000000042000100,0x420400042000100,0x420400042000 40000000,0x2000000,0x40080000,0x40080000,0,0x40000100,0x42080100, 0x42080100,0x2000100,0x42080000,0x40000100,0x42000000,0x2080100,0x20000,0x42000000,0x80100,0x80000,0x42000100,0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000까지 0080100,0x2000100,0x40000000,0x42080000,0x2080100,0x40080100,0x100,0x2000000, 0x42080000,0x42080100,0x80100,0x42000000,0x42080100,0x2080000,0x40080000,0x42000000,0x80100,0x2000100,0x40000100,0000000,00000800800800800800800800800800800800800800800800800800800800800800;
var spfunction6 = 새 배열 (0x200000,0x20400000,0x4000,0x20404010,0x20400000,0x10,0x20404010,0x400000,0x20004000,0x404010,0x400000,0x20010,0000,0000,0000,0004000,0x2000200020004000,0004000 , 0x400010,0x20004010,0x4000,0x404000,0x20004010, 0x10,0x20400010,0x20400010,0x404010,0x20404000,0x4010,0x404000,0x20404000,0x20000000,0x20004000,0x10,0x204000,0x404000,0000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 0x20004000,0x20000000,0x4010,0x20000010,0x20404010,0x404000, 0x20400000,0x404010,0x20404000,0x20400010,0x4000,0x20400000,0x404010,0x4000,0x400010,0x20004010,0x20404000,0x2000000,0004040x200040x200020002000200020002040101404040404040
var spfunction7 = 새로운 배열 (0x200000,0x4200002,0x4000802,0x800,0x4000802,0x200802,0x4200800,0x4200802,0x200000,0x4000002,0x40000,0x400200200200200200200200200200200000000 0x200802,0x200002,0x4000800,0x4000002,0x4200000, 0x4200800,0x200002,0x4200000,0x800,0x802,0x4200802,0x200800,0x2,0x4000000,0x200800,0x4000000,0x200800,0x200000,0x4000802,0x4000802,0x4200002,0x4200002,0x2,0x200002,0x4000000,0x4000800,0x200000,0x4200800,0x802,0x200802, 0x4200800,0x802,0x4000002,0x4200802,0x4200000,0x200800,0x2,0x4200802,0x200802,0x4200000,0x800,0x4000002,0x4000800,0x800,0x2002002).
var spfunction8 = 새 배열 (0x10001040,0x1000,0x40000,0x10041040,0x10000000,0x100040,0x40,0x100000,0x40040,0x10040000,0x10041040,0x41000,0x40,0x1000,0x10001000, 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,0x10041040,0x40040040,0x10000040,0x10040000,0x10001000,0x10001040,0x10041040,0x41000,0x41000,0x1040,0x1040,0x40040,0x1000000000100000001000001000001000001000001000100000100010000010001000001000001000001000001000001000001000100010001000001000100040
// 필요한 16 또는 48 서브 키를 만듭니다
var 키 = des_createkeys (키);
var m = 0, i, j, temp, temp2, right1, right2, 왼쪽, 오른쪽, 루핑;
var cbcleft, cbcleft2, cbcright, cbcright2
var endloop, loopinc;
var len = message.length;
var chunk = 0;
// 단일 및 트리플 DES 용 루프를 설정합니다
var iterations = keys.length == 32? 3 : 9; // 단일 또는 트리플 디스
if (반복 == 3) {루핑 = 암호화? 새 배열 (0, 32, 2) : 새 배열 (30, -2, -2);}
else {looping = encrypt? 새 배열 (0, 32, 2, 62, 30, -2, 64, 96, 2) : 새 배열 (94, 62, -2, 32, 64, 2, 30, -2, -2);}
// 패딩 매개 변수에 따라 메시지를 패드합니다
if (padding == 2) 메시지 += ""; // 메시지를 공백으로 채 웁니다
else if (padding == 1) {temp = 8- (len%8); message += string.fromcharcode (온도, 온도, 온도, 온도, 온도, 온도, 온도, 온도); if (temp == 8) len+= 8;} // pkcs7 padding
else if (! padding) 메시지 += "/0/0/0/0/0/0/0/0"; // 메시지를 null 바이트로 패드합니다
// 결과를 여기에 저장하십시오
결과 = "";
tempresult = "";
if (mode == 1) {// CBC 모드
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;
}
// 메시지의 각 64 비트 덩어리를 루프합니다
while (m <len) {
왼쪽 = (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 ++);
// 암호 블록 체인 모드의 경우 이전 결과와 함께 메시지를 xor
if (mode == 1) {if (encrypt) {left ^= cbcleft; 오른쪽 ^= cbcright;} else {cbcleft2 = cbcleft; cbcright2 = cbcright; cbcleft = 왼쪽; cbcright = 오른쪽;}}
// 먼저 64시하지만 메시지의 청크는 IP에 따라 퍼져야합니다.
temp = ((왼쪽 >>> 4) ^ 오른쪽) & 0x0f0f0f0f; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 4);
temp = ((왼쪽 >>> 16) ^ 오른쪽) & 0x0000ffff; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 16);
temp = ((오른쪽 >>> 2) ^ 왼쪽) & 0x33333333; 왼쪽 ^= 온도; 오른쪽 ^= (temp << 2);
temp = ((오른쪽 >>> 8) ^ 왼쪽) & 0x00ff00ff; 왼쪽 ^= 온도; 오른쪽 ^= (temp << 8);
temp = ((왼쪽 >>> 1) ^ 오른쪽) & 0x55555555; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 1);
왼쪽 = ((왼쪽 << 1) | (왼쪽 >>> 31);
오른쪽 = ((오른쪽 << 1) | (오른쪽 >>> 31);
// 메시지의 각 덩어리에 대해 1 ~ 3 회 수행합니다.
for (j = 0; j <반복; j+= 3) {
endloop = 루핑 [j+1];
loopinc = 루핑 [j+2];
// 이제 암호화 또는 암호 해독을 수행하고 수행하십시오
for (i = 루핑 [j]; i! = endloop; i+= loopinc) {// 효율성
right1 = right ^ 키 [i];
right2 = ((오른쪽 >>> 4) | (오른쪽 << 28)) ^ 키 [i+1];
// 결과는 S 선택 함수를 통해 이러한 바이트를 전달하여 달성됩니다.
온도 = 왼쪽;
왼쪽 = 오른쪽;
right = temp ^ (spfunction2 [(오른쪽 1 >>> 24) & 0x3f] | spfunction4 [(Right1 >>> 16) & 0x3f]
| spfunction6 [(오른쪽 1 >>> 8) & 0x3f] | spfunction8 [right1 & 0x3f]
| spfunction1 [(Right2 >>> 24) & 0x3f] | spfunction3 [(Right2 >>> 16) & 0x3f]
| spfunction5 [(Right2 >>> 8) & 0x3f] | spfunction7 [right2 & 0x3f]);
}
온도 = 왼쪽; 왼쪽 = 오른쪽; 오른쪽 = 온도; // 반복해서 왼쪽과 오른쪽으로
} // 1 또는 3 반복의 경우
// 그런 다음 각각 오른쪽으로 움직입니다
왼쪽 = ((왼쪽 >>> 1) | (왼쪽 << 31));
오른쪽 = ((오른쪽 >>> 1) | (오른쪽 << 31));
// 이제 반대 방향으로 IP-1을 수행합니다.
temp = ((왼쪽 >>> 1) ^ 오른쪽) & 0x55555555; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 1);
temp = ((오른쪽 >>> 8) ^ 왼쪽) & 0x00ff00ff; 왼쪽 ^= 온도; 오른쪽 ^= (temp << 8);
temp = ((오른쪽 >>> 2) ^ 왼쪽) & 0x33333333; 왼쪽 ^= 온도; 오른쪽 ^= (temp << 2);
temp = ((왼쪽 >>> 16) ^ 오른쪽) & 0x0000ffff; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 16);
temp = ((왼쪽 >>> 4) ^ 오른쪽) & 0x0f0f0f0f; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 4);
// 암호 블록 체인 모드의 경우 이전 결과와 함께 메시지를 xor
if (mode == 1) {if (encrypt) {cbcleft = left; cbcright = right;} else {왼쪽 ^= cbcleft2; 오른쪽 ^= cbcright2;}}
tempresult += string.fromcharcode ((왼쪽 >>> 24), ((왼쪽 >>> 16) & 0xff), ((왼쪽 >>> 8) & 0xff), (왼쪽 & 0xff), (오른쪽 >>> 24), ((오른쪽 >>> 16) & 0xff), ((오른쪽 >>> 8) & 0xff), (오른쪽 & 0xff));
청크 += 8;
if (chunk == 512) {result += tempresult; tempresult = ""; 청크 = 0;}
} // 메시지의 8 자 또는 64 비트마다 64 비트마다
// 결과를 배열로 반환합니다
반환 결과 + tempresult;
} // des의 끝
// des_createkeys
// 이것은 64 비트 키를 입력하는 데 사용됩니다 (56 비트 만 사용하더라도)
// 2 정수 배열로, 16 48 비트 키를 반환합니다.
함수 des_createkeys (키) {
// 로컬로 선언하면 속도가 약간 떨어집니다
PC2BYTES0 = 새로운 어레이 (0,0X4,0X20000000,0X200004,0X10000,0X10004,0X20010000,0X20010004,0X200,0X204,0X20000200,0X20000204,0X10200,0X10204,0X20010X20010X20010X20010X20010X20010X20010X20010X20010X20010X20010X200020010
pc2bytes1 = new Array (0,0x1,0x100000,0x100001,0x4000000,0x4000001,0x4100000,0x4100001,0x100,0x101,0x100100,0x100101,0x4000100,0x4000101,0x4100100,0x4100101);
PC2BYTES2 = 새로운 배열 (0,0X8,0X800,0X808,0X10000,0X1000008,0X1000800,0X1000808,0X8,0X800,0X808,0X1000000,0X1000008,0X1000800,0X1000808);
PC2BYTES3 = 새로운 배열 (0,0X200000,0X800000000,0X8200000,0X2000,0X202000,0X8002000,0X8202000,0X20000,0X20000,0X8020000,0X8220000,0X2200,0X80200022000,0X80200022200
PC2BYTES4 = 새로운 배열 (0,0X40000,0X10,0X40010,0X40000,0X10,0X40010,0X1000,0X41000,0X1010,0X410,0X1000,0X41000,0X10,0X41010);
PC2BYTES5 = 새로운 배열 (0,0x400,0x20,0x420,0x400,0x20,0x420,0x2000000000000000000000000000000000000000000,0x2000400,0x20020,0x2000420);
PC2BYTES6 = 새로운 배열 (0,0X10000000,0X80000,0X10080000,0X2,0X100002,0X80002,0X10080002,0X100000,0X80000,0X100800000000000000002,0X80002,0X10080002).
PC2BYTES7 = 새로운 배열 (0,0X10000,0X800,0X10800,0X200000,0X20010000,0X20000800,0X20010800,0X20000,0X30000,0X20800,0X30800,0X2000000,0X200300,000X200000000000300300,00020000000,000000000300300
PC2BYTES8 = 새로운 배열 (0,0X40000,0X40000,0X2,0X40002,0X2,0X40002,0X20000,0X2040000,0X20000,0X2040000,0X2000002,2040002,0X2002,2040002);
PC2BYTES9 = 새로운 배열 (0,0X10000000,0X8,0X100008,0X10000000,0X8,0X100008,0X400,0X100400,0X408,0X10000408,0X400,0X10000400,0X408,0X1004088);
PC2BYTES10 = 새로운 어레이 (0,0X20,0X20,0X100000,0X1000,0X100000,0X100020,0X2000,0X2020,0X20,0X102000,0X102020,0X102000,0X102020);
PC2BYTES11 = 새 배열 (0,0X1000000,0X200,0X1000200,0X200000,0X1200000,0X200200200,0X1200200,0X4000000,0X5000000,0X4000200,0X5000200,0X4200000,0X5200,0000,000,000200200,000,000,000,000,000,000,000,000,0X5200
PC2BYTES12 = 새로운 배열 (0,0X1000,0X8000000,0X8001000,0X80000,0X81000,0X8080000,0X8081000,0X10,0X1010,0X8000010,0X80010,0X80010,0X81010,0X8080010,0X801010,0X808010,0X81010
PC2BYTES13 = 새로운 배열 (0,0x4,0x100,0x104,0x4,0x100,0x104,0x1,0x5,0x101,0x105,0x5,0x101,0x105);
// 반복 수 (1의 경우 1, 트리플 DE의 경우 3)
var 반복 = key.length> 8? 3 : 1; // 2007 년 16/6/2007에 의해 변경되었습니다.
// 리턴 키를 저장합니다
var 키 = 새로운 배열 (32 * 반복);
// 이제 수행 해야하는 왼쪽 교대를 정의합니다.
var shifts = 새로운 배열 (0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
// 다른 변수
var lefttemp, righttemp, m = 0, n = 0, 임시;
for (var j = 0; j <반복; j ++) {// 1 또는 3 반복
왼쪽 = (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 = ((왼쪽 >>> 4) ^ 오른쪽) & 0x0f0f0f0f; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 4);
temp = ((오른쪽 >>> -16) ^ 왼쪽) & 0x0000ffff; 왼쪽 ^= 온도; 오른쪽 ^= (온도 << -16);
temp = ((왼쪽 >>> 2) ^ 오른쪽) & 0x33333333; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 2);
temp = ((오른쪽 >>> -16) ^ 왼쪽) & 0x0000ffff; 왼쪽 ^= 온도; 오른쪽 ^= (온도 << -16);
temp = ((왼쪽 >>> 1) ^ 오른쪽) & 0x55555555; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 1);
temp = ((오른쪽 >>> 8) ^ 왼쪽) & 0x00ff00ff; 왼쪽 ^= 온도; 오른쪽 ^= (temp << 8);
temp = ((왼쪽 >>> 1) ^ 오른쪽) & 0x55555555; 오른쪽 ^= 온도; 왼쪽 ^= (temp << 1);
// 오른쪽을 바꾸고 왼쪽의 마지막 네 비트를 얻으려면
온도 = (왼쪽 << 8) | ((오른쪽 >>> 20) & 0x000000f0);
// 왼쪽을 뒤집어야합니다
왼쪽 = (오른쪽 << 24) | ((오른쪽 << 8) & 0xff0000) | ((오른쪽 >>> 8) & 0xff00) | ((오른쪽 >>> 24) & 0xf0);
오른쪽 = 온도;
// 이제 왼쪽과 오른쪽 키에서 이러한 변화를 수행하고 수행합니다.
for (var i = 0; i <shifts.length; i ++) {
// 키를 왼쪽으로 한 ~ 두 비트로 바꿉니다.
if (shifts [i]) {왼쪽 = (왼쪽 << 2) | (왼쪽 >>> 26); 오른쪽 = (오른쪽 << 2) | (오른쪽 >>> 26);}
else {왼쪽 = (왼쪽 << 1) | (왼쪽 >>> 27); 오른쪽 = (오른쪽 << 1) | (오른쪽 >>> 27);}
왼쪽 & = -0xf; 오른쪽 & = -0xf;
// 이제 암호화 또는 해독 할 때 E가 더 쉬워지는 방식으로 PC-2를 적용합니다.
//이 변환은 각 바이트의 마지막 6 비트 만 사용하는 것을 제외하고 PC-2처럼 보입니다.
// 48 연속 비트가 아닌 라인 순서는 다음과 같습니다.
// S 선택 기능이 적용되는 방법 : S2, S4, S6, S8, S1, S3, S5, S7
LEFTTEMP = PC2BYTES0 [왼쪽 >>> 28] | pc2bytes1 [(왼쪽 >>> 24) & 0xf]
| pc2bytes2 [(왼쪽 >>> 20) & 0xf] | pc2bytes3 [(왼쪽 >>> 16) & 0xf]
| pc2bytes4 [(왼쪽 >>> 12) & 0xf] | PC2BYTES5 [(왼쪽 >>> 8) & 0XF]
| pc2bytes6 [(왼쪽 >>> 4) & 0xf];
RightTemp = pc2bytes7 [Right >>> 28] | pc2bytes8 [(오른쪽 >>> 24) & 0xf]
| pc2bytes9 [(오른쪽 >>> 20) & 0xf] | PC2Bytes10 [(오른쪽 >>> 16) & 0xf]
| PC2BYTES11 [(오른쪽 >>> 12) & 0xf] | PC2BYTES12 [(오른쪽 >>> 8) & 0XF]
| pc2bytes13 [(오른쪽 >>> 4) & 0xf];
temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;
키 [n ++] = LeftTemp ^ temp; 키 [n ++] = RightTemp ^ (temp << 16);
}
} // 각 반복에 대해
// 우리가 만든 키를 반환합니다
리턴 키;
} // des_createkeys의 끝
////////////////////////////// 시험 /////////////////// ///////////
함수 stringtoHex (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];}
RETOR R;
}
함수 hextoString (h) {
var r = "";
for (var i = (h.substr (0, 2) == "0x")? 2 : 0; i <h.length; i += 2) {r += string.fromcharcode (parseint (h.substr (i) , 2), 16);}
RETOR R;
}
var key = "이것은 24 바이트 키입니다 !!";
var message = "이것은 테스트 메시지입니다";
var ciphertext = des (키, 메시지, 1, 0);
document.writeln ( "des test :" + stringtohex (ciphertext));