| 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
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260 | 1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
1×
| define(["require", "exports", "../../decrypt-stream", "../../utils", "./cipher"], function (require, exports, decrypt_stream_1, utils_1, cipher_1) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var _CipherTransform = (function () {
function _CipherTransform(stringCipher, streamCipher) {
this._stringCipher = stringCipher;
this._streamCipher = streamCipher;
}
_CipherTransform.prototype.createStream = function (stream, length) {
return new decrypt_stream_1._PdfDecryptStream(stream, length, this._streamCipher);
};
_CipherTransform.prototype.decryptString = function (s) {
var stringBytes = utils_1._stringToBytes(s, false, true);
var decryptedBytes = this._stringCipher._decryptBlock(stringBytes, true);
return utils_1._bytesToString(decryptedBytes);
};
_CipherTransform.prototype.encryptString = function (s) {
if (this._stringCipher instanceof cipher_1._AdvancedEncryptionBaseCipher) {
var length_1 = s.length;
var pad = 16 - (length_1 % 16);
s += String.fromCharCode(pad).repeat(pad);
var iv = new Uint8Array(16);
if (typeof crypto !== 'undefined' && crypto !== null) {
crypto.getRandomValues(iv);
}
else {
for (var i = 0; i < 16; i++) {
iv[i] = Math.floor(256 * Math.random());
}
}
var data = this._stringCipher._encrypt(utils_1._stringToBytes(s, false, true), iv);
var buffer = new Uint8Array(16 + data.length);
buffer.set(iv);
buffer.set(data, 16);
return utils_1._bytesToString(buffer);
}
return utils_1._bytesToString(this._stringCipher._encrypt(utils_1._stringToBytes(s, false, true)));
};
return _CipherTransform;
}());
exports._CipherTransform = _CipherTransform;
var _DataEncryptionStandardCipher = (function () {
function _DataEncryptionStandardCipher(key, isEncrypt) {
if (isEncrypt === void 0) { isEncrypt = true; }
this.blockSize = 8;
this._byteBit = [128, 64, 32, 16, 8, 4, 2, 1];
this._bigByte = [
0x800000, 0x400000, 0x200000, 0x100000, 0x80000, 0x40000, 0x20000, 0x10000,
0x8000, 0x4000, 0x2000, 0x1000, 0x800, 0x400, 0x200, 0x100,
0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1
];
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];
this._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];
this._rotationTable = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
this._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];
this._keys = [];
this._keys = this._generateWorkingKey(isEncrypt, key);
}
_DataEncryptionStandardCipher.prototype._beToUint32 = function (b, offset) {
return ((b[offset] << 24) | (b[offset + 1] << 16) | (b[offset + 2] << 8) | b[offset + 3]) >>> 0;
};
_DataEncryptionStandardCipher.prototype._uint32ToBe = function (v, b, offset) {
b[offset] = (v >>> 24) & 0xff;
b[offset + 1] = (v >>> 16) & 0xff;
b[offset + 2] = (v >>> 8) & 0xff;
b[offset + 3] = v & 0xff;
};
_DataEncryptionStandardCipher.prototype._generateWorkingKey = function (isEncrypt, bytes) {
var newKeys = new Array(32).fill(0);
var bytes1 = new Array(56).fill(false);
var bytes2 = new Array(56).fill(false);
for (var j = 0; j < 56; j++) {
var len = this._pc1[j];
bytes1[j] = ((bytes[(len >> 3)] & this._byteBit[len & 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 + this._rotationTable[i];
bytes2[j] = a < 28 ? bytes1[a] : bytes1[a - 28];
}
for (var j = 28; j < 56; j++) {
var a = j + this._rotationTable[i];
bytes2[j] = a < 56 ? bytes1[a] : bytes1[a - 28];
}
for (var j = 0; j < 24; j++) {
if (bytes2[this._pc2[j]]) {
newKeys[b] |= this._bigByte[j];
}
if (bytes2[this._pc2[j + 24]]) {
newKeys[c] |= this._bigByte[j];
}
}
}
for (var i = 0; i !== 32; i += 2) {
var v1 = newKeys[i];
var v2 = newKeys[i + 1];
newKeys[i] =
((v1 & 0x00fc0000) << 6) |
((v1 & 0x00000fc0) << 10) |
((v2 & 0x00fc0000) >>> 10) |
((v2 & 0x00000fc0) >>> 6);
newKeys[i + 1] =
((v1 & 0x0003f000) << 12) |
((v1 & 0x0000003f) << 16) |
((v2 & 0x0003f000) >>> 4) |
(v2 & 0x0000003f);
}
return newKeys;
};
_DataEncryptionStandardCipher.prototype._processBlock = function (input, inputOffset, output, outputOffset) {
var left = this._beToUint32(input, inputOffset) >>> 0;
var right = this._beToUint32(input, inputOffset + 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 ^ this._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 ^ this._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 ^ this._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 ^ this._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, output, outputOffset);
this._uint32ToBe(left, output, outputOffset + 4);
};
return _DataEncryptionStandardCipher;
}());
exports._DataEncryptionStandardCipher = _DataEncryptionStandardCipher;
});
|