| 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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239 | 1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
| define(["require", "exports"], function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var _TripleDataEncryptionStandardCipher = (function () {
function _TripleDataEncryptionStandardCipher(key, isEncryption) {
if (isEncryption === void 0) { isEncryption = true; }
this._blockSize = 8;
this._isEncryption = true;
this._sp1 = [0x01010400, 0x00000000, 0x00010000, 0x01010404, 0x01010004, 0x00010404,
0x00000004, 0x00010000, 0x00000400, 0x01010400, 0x01010404, 0x00000400, 0x01000404,
0x01010004, 0x01000000, 0x00000004, 0x00000404, 0x01000400, 0x01000400, 0x00010400,
0x00010400, 0x01010000, 0x01010000, 0x01000404, 0x00010004, 0x01000004, 0x01000004,
0x00010004, 0x00000000, 0x00000404, 0x00010404, 0x01000000, 0x00010000, 0x01010404,
0x00000004, 0x01010000, 0x01010400, 0x01000000, 0x01000000, 0x00000400, 0x01010004,
0x00010000, 0x00010400, 0x01000004, 0x00000400, 0x00000004, 0x01000404, 0x00010404,
0x01010404, 0x00010004, 0x01010000, 0x01000404, 0x01000004, 0x00000404, 0x00010404,
0x01010400, 0x00000404, 0x01000400, 0x01000400, 0x00000000, 0x00010004, 0x00010400,
0x00000000, 0x01010004];
this._sp2 = [0x80108020, 0x80008000, 0x00008000, 0x00108020, 0x00100000, 0x00000020,
0x80100020, 0x80008020, 0x80000020, 0x80108020, 0x80108000, 0x80000000, 0x80008000,
0x00100000, 0x00000020, 0x80100020, 0x00108000, 0x00100020, 0x80008020, 0x00000000,
0x80000000, 0x00008000, 0x00108020, 0x80100000, 0x00100020, 0x80000020, 0x00000000,
0x00108000, 0x00008020, 0x80108000, 0x80100000, 0x00008020, 0x00000000, 0x00108020,
0x80100020, 0x00100000, 0x80008020, 0x80100000, 0x80108000, 0x00008000, 0x80100000,
0x80008000, 0x00000020, 0x80108020, 0x00108020, 0x00000020, 0x00008000, 0x80000000,
0x00008020, 0x80108000, 0x00100000, 0x80000020, 0x00100020, 0x80008020, 0x80000020,
0x00100020, 0x00108000, 0x00000000, 0x80008000, 0x00008020, 0x80000000, 0x80100020,
0x80108020, 0x00108000];
this._sp3 = [0x00000208, 0x08020200, 0x00000000, 0x08020008, 0x08000200, 0x00000000,
0x00020208, 0x08000200, 0x00020008, 0x08000008, 0x08000008, 0x00020000, 0x08020208,
0x00020008, 0x08020000, 0x00000208, 0x08000000, 0x00000008, 0x08020200, 0x00000200,
0x00020200, 0x08020000, 0x08020008, 0x00020208, 0x08000208, 0x00020200, 0x00020000,
0x08000208, 0x00000008, 0x08020208, 0x00000200, 0x08000000, 0x08020200, 0x08000000,
0x00020008, 0x00000208, 0x00020000, 0x08020200, 0x08000200, 0x00000000, 0x00000200,
0x00020008, 0x08020208, 0x08000200, 0x08000008, 0x00000200, 0x00000000, 0x08020008,
0x08000208, 0x00020000, 0x08000000, 0x08020208, 0x00000008, 0x00020208, 0x00020200,
0x08000008, 0x08020000, 0x08000208, 0x00000208, 0x08020000, 0x00020208, 0x00000008,
0x08020008, 0x00020200];
this._sp4 = [0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802080, 0x00800081,
0x00800001, 0x00002001, 0x00000000, 0x00802000, 0x00802000, 0x00802081, 0x00000081,
0x00000000, 0x00800080, 0x00800001, 0x00000001, 0x00002000, 0x00800000, 0x00802001,
0x00000080, 0x00800000, 0x00002001, 0x00002080, 0x00800081, 0x00000001, 0x00002080,
0x00800080, 0x00002000, 0x00802080, 0x00802081, 0x00000081, 0x00800080, 0x00800001,
0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00000000, 0x00802000, 0x00002080,
0x00800080, 0x00800081, 0x00000001, 0x00802001, 0x00002081, 0x00002081, 0x00000080,
0x00802081, 0x00000081, 0x00000001, 0x00002000, 0x00800001, 0x00002001, 0x00802080,
0x00800081, 0x00002001, 0x00002080, 0x00800000, 0x00802001, 0x00000080, 0x00800000,
0x00002000, 0x00802080];
this._sp5 = [0x00000100, 0x02080100, 0x02080000, 0x42000100, 0x00080000, 0x00000100,
0x40000000, 0x02080000, 0x40080100, 0x00080000, 0x02000100, 0x40080100, 0x42000100,
0x42080000, 0x00080100, 0x40000000, 0x02000000, 0x40080000, 0x40080000, 0x00000000,
0x40000100, 0x42080100, 0x42080100, 0x02000100, 0x42080000, 0x40000100, 0x00000000,
0x42000000, 0x02080100, 0x02000000, 0x42000000, 0x00080100, 0x00080000, 0x42000100,
0x00000100, 0x02000000, 0x40000000, 0x02080000, 0x42000100, 0x40080100, 0x02000100,
0x40000000, 0x42080000, 0x02080100, 0x40080100, 0x00000100, 0x02000000, 0x42080000,
0x42080100, 0x00080100, 0x42000000, 0x42080100, 0x02080000, 0x00000000, 0x40080000,
0x42000000, 0x00080100, 0x02000100, 0x40000100, 0x00080000, 0x00000000, 0x40080000,
0x02080100, 0x40000100];
this._sp6 = [0x20000010, 0x20400000, 0x00004000, 0x20404010, 0x20400000, 0x00000010,
0x20404010, 0x00400000, 0x20004000, 0x00404010, 0x00400000, 0x20000010, 0x00400010,
0x20004000, 0x20000000, 0x00004010, 0x00000000, 0x00400010, 0x20004010, 0x00004000,
0x00404000, 0x20004010, 0x00000010, 0x20400010, 0x20400010, 0x00000000, 0x00404010,
0x20404000, 0x00004010, 0x00404000, 0x20404000, 0x20000000, 0x20004000, 0x00000010,
0x20400010, 0x00404000, 0x20404010, 0x00400000, 0x00004010, 0x20000010, 0x00400000,
0x20004000, 0x20000000, 0x00004010, 0x20000010, 0x20404010, 0x00404000, 0x20400000,
0x00404010, 0x20404000, 0x00000000, 0x20400010, 0x00000010, 0x00004000, 0x20400000,
0x00404010, 0x00004000, 0x00400010, 0x20004010, 0x00000000, 0x20404000, 0x20000000,
0x00400010, 0x20004010];
this._sp7 = [0x00200000, 0x04200002, 0x04000802, 0x00000000, 0x00000800, 0x04000802,
0x00200802, 0x04200800, 0x04200802, 0x00200000, 0x00000000, 0x04000002, 0x00000002,
0x04000000, 0x04200002, 0x00000802, 0x04000800, 0x00200802, 0x00200002, 0x04000800,
0x04000002, 0x04200000, 0x04200800, 0x00200002, 0x04200000, 0x00000800, 0x00000802,
0x04200802, 0x00200800, 0x00000002, 0x04000000, 0x00200800, 0x04000000, 0x00200800,
0x00200000, 0x04000802, 0x04000802, 0x04200002, 0x04200002, 0x00000002, 0x00200002,
0x04000000, 0x04000800, 0x00200000, 0x04200800, 0x00000802, 0x00200802, 0x04200800,
0x00000802, 0x04000002, 0x04200802, 0x04200000, 0x00200800, 0x00000000, 0x00000002,
0x04200802, 0x00000000, 0x00200802, 0x04200000, 0x00000800, 0x04000002, 0x04000800,
0x00000800, 0x00200002];
this._sp8 = [0x10001040, 0x00001000, 0x00040000, 0x10041040, 0x10000000, 0x10001040,
0x00000040, 0x10000000, 0x00040040, 0x10040000, 0x10041040, 0x00041000, 0x10041000,
0x00041040, 0x00001000, 0x00000040, 0x10040000, 0x10000040, 0x10001000, 0x00001040,
0x00041000, 0x00040040, 0x10040040, 0x10041000, 0x00001040, 0x00000000, 0x00000000,
0x10040040, 0x10000040, 0x10001000, 0x00041040, 0x00040000, 0x00041040, 0x00040000,
0x10041000, 0x00001000, 0x00000040, 0x10040040, 0x00001000, 0x00041040, 0x10001000,
0x00000040, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x00040000, 0x10001040,
0x00000000, 0x10041040, 0x00040040, 0x10000040, 0x10040000, 0x10001000, 0x10001040,
0x00000000, 0x10041040, 0x00041000, 0x00041000, 0x00001040, 0x00001040, 0x00040040,
0x10000000, 0x10041000];
if (!(key instanceof Uint8Array) || (key.length !== 16 && key.length !== 24)) {
throw new Error('Triple DES key must be 16 or 24 bytes.');
}
this._isEncryption = isEncryption;
var key1 = key.subarray(0, 8);
var key2 = key.subarray(8, 16);
var key3 = (key.length === 24) ? key.subarray(16, 24) : key1;
this._key1 = this._generateWorkingKey(isEncryption, key1);
this._key2 = this._generateWorkingKey(!isEncryption, key2);
this._key3 = this._generateWorkingKey(isEncryption, key3);
}
_TripleDataEncryptionStandardCipher.prototype._beToUint32 = function (b, off) {
return ((b[off] << 24) | (b[off + 1] << 16) | (b[off + 2] << 8) | b[off + 3]) >>> 0;
};
_TripleDataEncryptionStandardCipher.prototype._uint32ToBe = function (v, b, off) {
b[off] = (v >>> 24) & 0xff;
b[off + 1] = (v >>> 16) & 0xff;
b[off + 2] = (v >>> 8) & 0xff;
b[off + 3] = v & 0xff;
};
_TripleDataEncryptionStandardCipher.prototype._generateWorkingKey = function (isEncrypt, keyBytes) {
var ByteBit = [0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01];
var BigByte = [
0x800000, 0x400000, 0x200000, 0x100000, 0x80000, 0x40000, 0x20000, 0x10000,
0x8000, 0x4000, 0x2000, 0x1000, 0x800, 0x400, 0x200, 0x100,
0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
];
var Pc1 = [56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17,
9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 62, 54, 46, 38, 30,
22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 60, 52, 44, 36, 28, 20, 12, 4,
27, 19, 11, 3];
var Totrot = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
var Pc2 = [13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9, 22, 18, 11, 3, 25,
7, 15, 6, 26, 19, 12, 1, 40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47, 43, 48,
38, 55, 33, 52, 45, 41, 49, 35, 28, 31];
var newKeys = new Int32Array(32);
var bytes1 = new Array(56).fill(false);
var bytes2 = new Array(56).fill(false);
for (var j = 0; j < 56; j++) {
var length_1 = Pc1[j];
bytes1[j] = ((keyBytes[length_1 >> 3] & ByteBit[length_1 & 7]) !== 0);
}
for (var i = 0; i < 16; i++) {
var b = isEncrypt ? i << 1 : (15 - i) << 1;
var c = b + 1;
newKeys[b] = newKeys[c] = 0;
for (var j = 0; j < 28; j++) {
var a = j + Totrot[i];
bytes2[j] = (a < 28) ? bytes1[a] : bytes1[a - 28];
}
for (var j = 28; j < 56; j++) {
var a = j + Totrot[i];
bytes2[j] = (a < 56) ? bytes1[a] : bytes1[a - 28];
}
for (var j = 0; j < 24; j++) {
if (bytes2[Pc2[j]]) {
newKeys[b] |= BigByte[j];
}
if (bytes2[Pc2[j + 24]]) {
newKeys[c] |= BigByte[j];
}
}
}
for (var i = 0; i !== 32; i += 2) {
var value1 = newKeys[i];
var value2 = newKeys[i + 1];
newKeys[i] = ((value1 & 0x00fc0000) << 6) | ((value1 & 0x00000fc0) << 10) |
((value2 & 0x00fc0000) >>> 10) | ((value2 & 0x00000fc0) >>> 6);
newKeys[i + 1] = ((value1 & 0x0003f000) << 12) | ((value1 & 0x0000003f) << 16) |
((value2 & 0x0003f000) >>> 4) | (value2 & 0x0000003f);
}
return newKeys;
};
_TripleDataEncryptionStandardCipher.prototype._processEncryptionBlock = function (keys, inBytes, inOffset, outBytes, outOffset) {
var left = this._beToUint32(inBytes, inOffset) >>> 0;
var right = this._beToUint32(inBytes, inOffset + 4) >>> 0;
var data = ((left >>> 4) ^ right) & 0x0f0f0f0f;
right ^= data;
left ^= (data << 4);
data = ((left >>> 16) ^ right) & 0x0000ffff;
right ^= data;
left ^= (data << 16);
data = ((right >>> 2) ^ left) & 0x33333333;
left ^= data;
right ^= (data << 2);
data = ((right >>> 8) ^ left) & 0x00ff00ff;
left ^= data;
right ^= (data << 8);
right = ((right << 1) | (right >>> 31)) >>> 0;
data = (left ^ right) & 0xaaaaaaaa;
left ^= data;
right ^= data;
left = ((left << 1) | (left >>> 31)) >>> 0;
for (var round = 0; round < 8; round++) {
data = ((right << 28) | (right >>> 4)) >>> 0;
data = data ^ keys[round * 4 + 0];
var value = this._sp7[data & 0x3f] | this._sp5[(data >>> 8) & 0x3f] |
this._sp3[(data >>> 16) & 0x3f] | this._sp1[(data >>> 24) & 0x3f];
data = (right ^ keys[round * 4 + 1]) >>> 0;
value |= this._sp8[data & 0x3f] | this._sp6[(data >>> 8) & 0x3f] |
this._sp4[(data >>> 16) & 0x3f] | this._sp2[(data >>> 24) & 0x3f];
left ^= value;
data = ((left << 28) | (left >>> 4)) >>> 0;
data = data ^ keys[round * 4 + 2];
value = this._sp7[data & 0x3f] | this._sp5[(data >>> 8) & 0x3f] |
this._sp3[(data >>> 16) & 0x3f] | this._sp1[(data >>> 24) & 0x3f];
data = (left ^ keys[round * 4 + 3]) >>> 0;
value |= this._sp8[data & 0x3f] | this._sp6[(data >>> 8) & 0x3f] |
this._sp4[(data >>> 16) & 0x3f] | this._sp2[(data >>> 24) & 0x3f];
right ^= value;
}
right = ((right << 31) | (right >>> 1)) >>> 0;
data = (left ^ right) & 0xaaaaaaaa;
left ^= data;
right ^= data;
left = ((left << 31) | (left >>> 1)) >>> 0;
data = ((left >>> 8) ^ right) & 0x00ff00ff;
right ^= data;
left ^= (data << 8);
data = ((left >>> 2) ^ right) & 0x33333333;
right ^= data;
left ^= (data << 2);
data = ((right >>> 16) ^ left) & 0x0000ffff;
left ^= data;
right ^= (data << 16);
data = ((right >>> 4) ^ left) & 0x0f0f0f0f;
left ^= data;
right ^= (data << 4);
this._uint32ToBe(right, outBytes, outOffset);
this._uint32ToBe(left, outBytes, outOffset + 4);
};
_TripleDataEncryptionStandardCipher.prototype._processBlock = function (input, inOffset, output, outOffset) {
var blockSize = this._blockSize;
var tempBytes = new Uint8Array(blockSize);
if (this._isEncryption) {
this._processEncryptionBlock(this._key1, input, inOffset, tempBytes, 0);
this._processEncryptionBlock(this._key2, tempBytes, 0, tempBytes, 0);
this._processEncryptionBlock(this._key3, tempBytes, 0, output, outOffset);
}
else {
this._processEncryptionBlock(this._key3, input, inOffset, tempBytes, 0);
this._processEncryptionBlock(this._key2, tempBytes, 0, tempBytes, 0);
this._processEncryptionBlock(this._key1, tempBytes, 0, output, outOffset);
}
return blockSize;
};
return _TripleDataEncryptionStandardCipher;
}());
exports._TripleDataEncryptionStandardCipher = _TripleDataEncryptionStandardCipher;
});
|