You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3664 lines
66 KiB
3664 lines
66 KiB
8 years ago
|
/* Copyright 2017 Mozilla Foundation
|
||
|
*
|
||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
* you may not use this file except in compliance with the License.
|
||
|
* You may obtain a copy of the License at
|
||
|
*
|
||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
*
|
||
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
* See the License for the specific language governing permissions and
|
||
|
* limitations under the License.
|
||
|
*/
|
||
|
'use strict';
|
||
|
var sharedUtil = require('../shared/util.js');
|
||
|
var corePrimitives = require('./primitives.js');
|
||
|
var coreStream = require('./stream.js');
|
||
|
var PasswordException = sharedUtil.PasswordException;
|
||
|
var PasswordResponses = sharedUtil.PasswordResponses;
|
||
|
var bytesToString = sharedUtil.bytesToString;
|
||
|
var warn = sharedUtil.warn;
|
||
|
var error = sharedUtil.error;
|
||
|
var assert = sharedUtil.assert;
|
||
|
var isInt = sharedUtil.isInt;
|
||
|
var stringToBytes = sharedUtil.stringToBytes;
|
||
|
var utf8StringToString = sharedUtil.utf8StringToString;
|
||
|
var Name = corePrimitives.Name;
|
||
|
var isName = corePrimitives.isName;
|
||
|
var isDict = corePrimitives.isDict;
|
||
|
var DecryptStream = coreStream.DecryptStream;
|
||
|
var ARCFourCipher = function ARCFourCipherClosure() {
|
||
|
function ARCFourCipher(key) {
|
||
|
this.a = 0;
|
||
|
this.b = 0;
|
||
|
var s = new Uint8Array(256);
|
||
|
var i, j = 0, tmp, keyLength = key.length;
|
||
|
for (i = 0; i < 256; ++i) {
|
||
|
s[i] = i;
|
||
|
}
|
||
|
for (i = 0; i < 256; ++i) {
|
||
|
tmp = s[i];
|
||
|
j = j + tmp + key[i % keyLength] & 0xFF;
|
||
|
s[i] = s[j];
|
||
|
s[j] = tmp;
|
||
|
}
|
||
|
this.s = s;
|
||
|
}
|
||
|
ARCFourCipher.prototype = {
|
||
|
encryptBlock: function ARCFourCipher_encryptBlock(data) {
|
||
|
var i, n = data.length, tmp, tmp2;
|
||
|
var a = this.a, b = this.b, s = this.s;
|
||
|
var output = new Uint8Array(n);
|
||
|
for (i = 0; i < n; ++i) {
|
||
|
a = a + 1 & 0xFF;
|
||
|
tmp = s[a];
|
||
|
b = b + tmp & 0xFF;
|
||
|
tmp2 = s[b];
|
||
|
s[a] = tmp2;
|
||
|
s[b] = tmp;
|
||
|
output[i] = data[i] ^ s[tmp + tmp2 & 0xFF];
|
||
|
}
|
||
|
this.a = a;
|
||
|
this.b = b;
|
||
|
return output;
|
||
|
}
|
||
|
};
|
||
|
ARCFourCipher.prototype.decryptBlock = ARCFourCipher.prototype.encryptBlock;
|
||
|
return ARCFourCipher;
|
||
|
}();
|
||
|
var calculateMD5 = function calculateMD5Closure() {
|
||
|
var r = new Uint8Array([
|
||
|
7,
|
||
|
12,
|
||
|
17,
|
||
|
22,
|
||
|
7,
|
||
|
12,
|
||
|
17,
|
||
|
22,
|
||
|
7,
|
||
|
12,
|
||
|
17,
|
||
|
22,
|
||
|
7,
|
||
|
12,
|
||
|
17,
|
||
|
22,
|
||
|
5,
|
||
|
9,
|
||
|
14,
|
||
|
20,
|
||
|
5,
|
||
|
9,
|
||
|
14,
|
||
|
20,
|
||
|
5,
|
||
|
9,
|
||
|
14,
|
||
|
20,
|
||
|
5,
|
||
|
9,
|
||
|
14,
|
||
|
20,
|
||
|
4,
|
||
|
11,
|
||
|
16,
|
||
|
23,
|
||
|
4,
|
||
|
11,
|
||
|
16,
|
||
|
23,
|
||
|
4,
|
||
|
11,
|
||
|
16,
|
||
|
23,
|
||
|
4,
|
||
|
11,
|
||
|
16,
|
||
|
23,
|
||
|
6,
|
||
|
10,
|
||
|
15,
|
||
|
21,
|
||
|
6,
|
||
|
10,
|
||
|
15,
|
||
|
21,
|
||
|
6,
|
||
|
10,
|
||
|
15,
|
||
|
21,
|
||
|
6,
|
||
|
10,
|
||
|
15,
|
||
|
21
|
||
|
]);
|
||
|
var k = new Int32Array([
|
||
|
-680876936,
|
||
|
-389564586,
|
||
|
606105819,
|
||
|
-1044525330,
|
||
|
-176418897,
|
||
|
1200080426,
|
||
|
-1473231341,
|
||
|
-45705983,
|
||
|
1770035416,
|
||
|
-1958414417,
|
||
|
-42063,
|
||
|
-1990404162,
|
||
|
1804603682,
|
||
|
-40341101,
|
||
|
-1502002290,
|
||
|
1236535329,
|
||
|
-165796510,
|
||
|
-1069501632,
|
||
|
643717713,
|
||
|
-373897302,
|
||
|
-701558691,
|
||
|
38016083,
|
||
|
-660478335,
|
||
|
-405537848,
|
||
|
568446438,
|
||
|
-1019803690,
|
||
|
-187363961,
|
||
|
1163531501,
|
||
|
-1444681467,
|
||
|
-51403784,
|
||
|
1735328473,
|
||
|
-1926607734,
|
||
|
-378558,
|
||
|
-2022574463,
|
||
|
1839030562,
|
||
|
-35309556,
|
||
|
-1530992060,
|
||
|
1272893353,
|
||
|
-155497632,
|
||
|
-1094730640,
|
||
|
681279174,
|
||
|
-358537222,
|
||
|
-722521979,
|
||
|
76029189,
|
||
|
-640364487,
|
||
|
-421815835,
|
||
|
530742520,
|
||
|
-995338651,
|
||
|
-198630844,
|
||
|
1126891415,
|
||
|
-1416354905,
|
||
|
-57434055,
|
||
|
1700485571,
|
||
|
-1894986606,
|
||
|
-1051523,
|
||
|
-2054922799,
|
||
|
1873313359,
|
||
|
-30611744,
|
||
|
-1560198380,
|
||
|
1309151649,
|
||
|
-145523070,
|
||
|
-1120210379,
|
||
|
718787259,
|
||
|
-343485551
|
||
|
]);
|
||
|
function hash(data, offset, length) {
|
||
|
var h0 = 1732584193, h1 = -271733879, h2 = -1732584194, h3 = 271733878;
|
||
|
var paddedLength = length + 72 & ~63;
|
||
|
var padded = new Uint8Array(paddedLength);
|
||
|
var i, j, n;
|
||
|
for (i = 0; i < length; ++i) {
|
||
|
padded[i] = data[offset++];
|
||
|
}
|
||
|
padded[i++] = 0x80;
|
||
|
n = paddedLength - 8;
|
||
|
while (i < n) {
|
||
|
padded[i++] = 0;
|
||
|
}
|
||
|
padded[i++] = length << 3 & 0xFF;
|
||
|
padded[i++] = length >> 5 & 0xFF;
|
||
|
padded[i++] = length >> 13 & 0xFF;
|
||
|
padded[i++] = length >> 21 & 0xFF;
|
||
|
padded[i++] = length >>> 29 & 0xFF;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
var w = new Int32Array(16);
|
||
|
for (i = 0; i < paddedLength;) {
|
||
|
for (j = 0; j < 16; ++j, i += 4) {
|
||
|
w[j] = padded[i] | padded[i + 1] << 8 | padded[i + 2] << 16 | padded[i + 3] << 24;
|
||
|
}
|
||
|
var a = h0, b = h1, c = h2, d = h3, f, g;
|
||
|
for (j = 0; j < 64; ++j) {
|
||
|
if (j < 16) {
|
||
|
f = b & c | ~b & d;
|
||
|
g = j;
|
||
|
} else if (j < 32) {
|
||
|
f = d & b | ~d & c;
|
||
|
g = 5 * j + 1 & 15;
|
||
|
} else if (j < 48) {
|
||
|
f = b ^ c ^ d;
|
||
|
g = 3 * j + 5 & 15;
|
||
|
} else {
|
||
|
f = c ^ (b | ~d);
|
||
|
g = 7 * j & 15;
|
||
|
}
|
||
|
var tmp = d, rotateArg = a + f + k[j] + w[g] | 0, rotate = r[j];
|
||
|
d = c;
|
||
|
c = b;
|
||
|
b = b + (rotateArg << rotate | rotateArg >>> 32 - rotate) | 0;
|
||
|
a = tmp;
|
||
|
}
|
||
|
h0 = h0 + a | 0;
|
||
|
h1 = h1 + b | 0;
|
||
|
h2 = h2 + c | 0;
|
||
|
h3 = h3 + d | 0;
|
||
|
}
|
||
|
return new Uint8Array([
|
||
|
h0 & 0xFF,
|
||
|
h0 >> 8 & 0xFF,
|
||
|
h0 >> 16 & 0xFF,
|
||
|
h0 >>> 24 & 0xFF,
|
||
|
h1 & 0xFF,
|
||
|
h1 >> 8 & 0xFF,
|
||
|
h1 >> 16 & 0xFF,
|
||
|
h1 >>> 24 & 0xFF,
|
||
|
h2 & 0xFF,
|
||
|
h2 >> 8 & 0xFF,
|
||
|
h2 >> 16 & 0xFF,
|
||
|
h2 >>> 24 & 0xFF,
|
||
|
h3 & 0xFF,
|
||
|
h3 >> 8 & 0xFF,
|
||
|
h3 >> 16 & 0xFF,
|
||
|
h3 >>> 24 & 0xFF
|
||
|
]);
|
||
|
}
|
||
|
return hash;
|
||
|
}();
|
||
|
var Word64 = function Word64Closure() {
|
||
|
function Word64(highInteger, lowInteger) {
|
||
|
this.high = highInteger | 0;
|
||
|
this.low = lowInteger | 0;
|
||
|
}
|
||
|
Word64.prototype = {
|
||
|
and: function Word64_and(word) {
|
||
|
this.high &= word.high;
|
||
|
this.low &= word.low;
|
||
|
},
|
||
|
xor: function Word64_xor(word) {
|
||
|
this.high ^= word.high;
|
||
|
this.low ^= word.low;
|
||
|
},
|
||
|
or: function Word64_or(word) {
|
||
|
this.high |= word.high;
|
||
|
this.low |= word.low;
|
||
|
},
|
||
|
shiftRight: function Word64_shiftRight(places) {
|
||
|
if (places >= 32) {
|
||
|
this.low = this.high >>> places - 32 | 0;
|
||
|
this.high = 0;
|
||
|
} else {
|
||
|
this.low = this.low >>> places | this.high << 32 - places;
|
||
|
this.high = this.high >>> places | 0;
|
||
|
}
|
||
|
},
|
||
|
shiftLeft: function Word64_shiftLeft(places) {
|
||
|
if (places >= 32) {
|
||
|
this.high = this.low << places - 32;
|
||
|
this.low = 0;
|
||
|
} else {
|
||
|
this.high = this.high << places | this.low >>> 32 - places;
|
||
|
this.low = this.low << places;
|
||
|
}
|
||
|
},
|
||
|
rotateRight: function Word64_rotateRight(places) {
|
||
|
var low, high;
|
||
|
if (places & 32) {
|
||
|
high = this.low;
|
||
|
low = this.high;
|
||
|
} else {
|
||
|
low = this.low;
|
||
|
high = this.high;
|
||
|
}
|
||
|
places &= 31;
|
||
|
this.low = low >>> places | high << 32 - places;
|
||
|
this.high = high >>> places | low << 32 - places;
|
||
|
},
|
||
|
not: function Word64_not() {
|
||
|
this.high = ~this.high;
|
||
|
this.low = ~this.low;
|
||
|
},
|
||
|
add: function Word64_add(word) {
|
||
|
var lowAdd = (this.low >>> 0) + (word.low >>> 0);
|
||
|
var highAdd = (this.high >>> 0) + (word.high >>> 0);
|
||
|
if (lowAdd > 0xFFFFFFFF) {
|
||
|
highAdd += 1;
|
||
|
}
|
||
|
this.low = lowAdd | 0;
|
||
|
this.high = highAdd | 0;
|
||
|
},
|
||
|
copyTo: function Word64_copyTo(bytes, offset) {
|
||
|
bytes[offset] = this.high >>> 24 & 0xFF;
|
||
|
bytes[offset + 1] = this.high >> 16 & 0xFF;
|
||
|
bytes[offset + 2] = this.high >> 8 & 0xFF;
|
||
|
bytes[offset + 3] = this.high & 0xFF;
|
||
|
bytes[offset + 4] = this.low >>> 24 & 0xFF;
|
||
|
bytes[offset + 5] = this.low >> 16 & 0xFF;
|
||
|
bytes[offset + 6] = this.low >> 8 & 0xFF;
|
||
|
bytes[offset + 7] = this.low & 0xFF;
|
||
|
},
|
||
|
assign: function Word64_assign(word) {
|
||
|
this.high = word.high;
|
||
|
this.low = word.low;
|
||
|
}
|
||
|
};
|
||
|
return Word64;
|
||
|
}();
|
||
|
var calculateSHA256 = function calculateSHA256Closure() {
|
||
|
function rotr(x, n) {
|
||
|
return x >>> n | x << 32 - n;
|
||
|
}
|
||
|
function ch(x, y, z) {
|
||
|
return x & y ^ ~x & z;
|
||
|
}
|
||
|
function maj(x, y, z) {
|
||
|
return x & y ^ x & z ^ y & z;
|
||
|
}
|
||
|
function sigma(x) {
|
||
|
return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
|
||
|
}
|
||
|
function sigmaPrime(x) {
|
||
|
return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
|
||
|
}
|
||
|
function littleSigma(x) {
|
||
|
return rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3;
|
||
|
}
|
||
|
function littleSigmaPrime(x) {
|
||
|
return rotr(x, 17) ^ rotr(x, 19) ^ x >>> 10;
|
||
|
}
|
||
|
var k = [
|
||
|
0x428a2f98,
|
||
|
0x71374491,
|
||
|
0xb5c0fbcf,
|
||
|
0xe9b5dba5,
|
||
|
0x3956c25b,
|
||
|
0x59f111f1,
|
||
|
0x923f82a4,
|
||
|
0xab1c5ed5,
|
||
|
0xd807aa98,
|
||
|
0x12835b01,
|
||
|
0x243185be,
|
||
|
0x550c7dc3,
|
||
|
0x72be5d74,
|
||
|
0x80deb1fe,
|
||
|
0x9bdc06a7,
|
||
|
0xc19bf174,
|
||
|
0xe49b69c1,
|
||
|
0xefbe4786,
|
||
|
0x0fc19dc6,
|
||
|
0x240ca1cc,
|
||
|
0x2de92c6f,
|
||
|
0x4a7484aa,
|
||
|
0x5cb0a9dc,
|
||
|
0x76f988da,
|
||
|
0x983e5152,
|
||
|
0xa831c66d,
|
||
|
0xb00327c8,
|
||
|
0xbf597fc7,
|
||
|
0xc6e00bf3,
|
||
|
0xd5a79147,
|
||
|
0x06ca6351,
|
||
|
0x14292967,
|
||
|
0x27b70a85,
|
||
|
0x2e1b2138,
|
||
|
0x4d2c6dfc,
|
||
|
0x53380d13,
|
||
|
0x650a7354,
|
||
|
0x766a0abb,
|
||
|
0x81c2c92e,
|
||
|
0x92722c85,
|
||
|
0xa2bfe8a1,
|
||
|
0xa81a664b,
|
||
|
0xc24b8b70,
|
||
|
0xc76c51a3,
|
||
|
0xd192e819,
|
||
|
0xd6990624,
|
||
|
0xf40e3585,
|
||
|
0x106aa070,
|
||
|
0x19a4c116,
|
||
|
0x1e376c08,
|
||
|
0x2748774c,
|
||
|
0x34b0bcb5,
|
||
|
0x391c0cb3,
|
||
|
0x4ed8aa4a,
|
||
|
0x5b9cca4f,
|
||
|
0x682e6ff3,
|
||
|
0x748f82ee,
|
||
|
0x78a5636f,
|
||
|
0x84c87814,
|
||
|
0x8cc70208,
|
||
|
0x90befffa,
|
||
|
0xa4506ceb,
|
||
|
0xbef9a3f7,
|
||
|
0xc67178f2
|
||
|
];
|
||
|
function hash(data, offset, length) {
|
||
|
var h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a, h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
|
||
|
var paddedLength = Math.ceil((length + 9) / 64) * 64;
|
||
|
var padded = new Uint8Array(paddedLength);
|
||
|
var i, j, n;
|
||
|
for (i = 0; i < length; ++i) {
|
||
|
padded[i] = data[offset++];
|
||
|
}
|
||
|
padded[i++] = 0x80;
|
||
|
n = paddedLength - 8;
|
||
|
while (i < n) {
|
||
|
padded[i++] = 0;
|
||
|
}
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = length >>> 29 & 0xFF;
|
||
|
padded[i++] = length >> 21 & 0xFF;
|
||
|
padded[i++] = length >> 13 & 0xFF;
|
||
|
padded[i++] = length >> 5 & 0xFF;
|
||
|
padded[i++] = length << 3 & 0xFF;
|
||
|
var w = new Uint32Array(64);
|
||
|
for (i = 0; i < paddedLength;) {
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
w[j] = padded[i] << 24 | padded[i + 1] << 16 | padded[i + 2] << 8 | padded[i + 3];
|
||
|
i += 4;
|
||
|
}
|
||
|
for (j = 16; j < 64; ++j) {
|
||
|
w[j] = littleSigmaPrime(w[j - 2]) + w[j - 7] + littleSigma(w[j - 15]) + w[j - 16] | 0;
|
||
|
}
|
||
|
var a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7, t1, t2;
|
||
|
for (j = 0; j < 64; ++j) {
|
||
|
t1 = h + sigmaPrime(e) + ch(e, f, g) + k[j] + w[j];
|
||
|
t2 = sigma(a) + maj(a, b, c);
|
||
|
h = g;
|
||
|
g = f;
|
||
|
f = e;
|
||
|
e = d + t1 | 0;
|
||
|
d = c;
|
||
|
c = b;
|
||
|
b = a;
|
||
|
a = t1 + t2 | 0;
|
||
|
}
|
||
|
h0 = h0 + a | 0;
|
||
|
h1 = h1 + b | 0;
|
||
|
h2 = h2 + c | 0;
|
||
|
h3 = h3 + d | 0;
|
||
|
h4 = h4 + e | 0;
|
||
|
h5 = h5 + f | 0;
|
||
|
h6 = h6 + g | 0;
|
||
|
h7 = h7 + h | 0;
|
||
|
}
|
||
|
return new Uint8Array([
|
||
|
h0 >> 24 & 0xFF,
|
||
|
h0 >> 16 & 0xFF,
|
||
|
h0 >> 8 & 0xFF,
|
||
|
h0 & 0xFF,
|
||
|
h1 >> 24 & 0xFF,
|
||
|
h1 >> 16 & 0xFF,
|
||
|
h1 >> 8 & 0xFF,
|
||
|
h1 & 0xFF,
|
||
|
h2 >> 24 & 0xFF,
|
||
|
h2 >> 16 & 0xFF,
|
||
|
h2 >> 8 & 0xFF,
|
||
|
h2 & 0xFF,
|
||
|
h3 >> 24 & 0xFF,
|
||
|
h3 >> 16 & 0xFF,
|
||
|
h3 >> 8 & 0xFF,
|
||
|
h3 & 0xFF,
|
||
|
h4 >> 24 & 0xFF,
|
||
|
h4 >> 16 & 0xFF,
|
||
|
h4 >> 8 & 0xFF,
|
||
|
h4 & 0xFF,
|
||
|
h5 >> 24 & 0xFF,
|
||
|
h5 >> 16 & 0xFF,
|
||
|
h5 >> 8 & 0xFF,
|
||
|
h5 & 0xFF,
|
||
|
h6 >> 24 & 0xFF,
|
||
|
h6 >> 16 & 0xFF,
|
||
|
h6 >> 8 & 0xFF,
|
||
|
h6 & 0xFF,
|
||
|
h7 >> 24 & 0xFF,
|
||
|
h7 >> 16 & 0xFF,
|
||
|
h7 >> 8 & 0xFF,
|
||
|
h7 & 0xFF
|
||
|
]);
|
||
|
}
|
||
|
return hash;
|
||
|
}();
|
||
|
var calculateSHA512 = function calculateSHA512Closure() {
|
||
|
function ch(result, x, y, z, tmp) {
|
||
|
result.assign(x);
|
||
|
result.and(y);
|
||
|
tmp.assign(x);
|
||
|
tmp.not();
|
||
|
tmp.and(z);
|
||
|
result.xor(tmp);
|
||
|
}
|
||
|
function maj(result, x, y, z, tmp) {
|
||
|
result.assign(x);
|
||
|
result.and(y);
|
||
|
tmp.assign(x);
|
||
|
tmp.and(z);
|
||
|
result.xor(tmp);
|
||
|
tmp.assign(y);
|
||
|
tmp.and(z);
|
||
|
result.xor(tmp);
|
||
|
}
|
||
|
function sigma(result, x, tmp) {
|
||
|
result.assign(x);
|
||
|
result.rotateRight(28);
|
||
|
tmp.assign(x);
|
||
|
tmp.rotateRight(34);
|
||
|
result.xor(tmp);
|
||
|
tmp.assign(x);
|
||
|
tmp.rotateRight(39);
|
||
|
result.xor(tmp);
|
||
|
}
|
||
|
function sigmaPrime(result, x, tmp) {
|
||
|
result.assign(x);
|
||
|
result.rotateRight(14);
|
||
|
tmp.assign(x);
|
||
|
tmp.rotateRight(18);
|
||
|
result.xor(tmp);
|
||
|
tmp.assign(x);
|
||
|
tmp.rotateRight(41);
|
||
|
result.xor(tmp);
|
||
|
}
|
||
|
function littleSigma(result, x, tmp) {
|
||
|
result.assign(x);
|
||
|
result.rotateRight(1);
|
||
|
tmp.assign(x);
|
||
|
tmp.rotateRight(8);
|
||
|
result.xor(tmp);
|
||
|
tmp.assign(x);
|
||
|
tmp.shiftRight(7);
|
||
|
result.xor(tmp);
|
||
|
}
|
||
|
function littleSigmaPrime(result, x, tmp) {
|
||
|
result.assign(x);
|
||
|
result.rotateRight(19);
|
||
|
tmp.assign(x);
|
||
|
tmp.rotateRight(61);
|
||
|
result.xor(tmp);
|
||
|
tmp.assign(x);
|
||
|
tmp.shiftRight(6);
|
||
|
result.xor(tmp);
|
||
|
}
|
||
|
var k = [
|
||
|
new Word64(0x428a2f98, 0xd728ae22),
|
||
|
new Word64(0x71374491, 0x23ef65cd),
|
||
|
new Word64(0xb5c0fbcf, 0xec4d3b2f),
|
||
|
new Word64(0xe9b5dba5, 0x8189dbbc),
|
||
|
new Word64(0x3956c25b, 0xf348b538),
|
||
|
new Word64(0x59f111f1, 0xb605d019),
|
||
|
new Word64(0x923f82a4, 0xaf194f9b),
|
||
|
new Word64(0xab1c5ed5, 0xda6d8118),
|
||
|
new Word64(0xd807aa98, 0xa3030242),
|
||
|
new Word64(0x12835b01, 0x45706fbe),
|
||
|
new Word64(0x243185be, 0x4ee4b28c),
|
||
|
new Word64(0x550c7dc3, 0xd5ffb4e2),
|
||
|
new Word64(0x72be5d74, 0xf27b896f),
|
||
|
new Word64(0x80deb1fe, 0x3b1696b1),
|
||
|
new Word64(0x9bdc06a7, 0x25c71235),
|
||
|
new Word64(0xc19bf174, 0xcf692694),
|
||
|
new Word64(0xe49b69c1, 0x9ef14ad2),
|
||
|
new Word64(0xefbe4786, 0x384f25e3),
|
||
|
new Word64(0x0fc19dc6, 0x8b8cd5b5),
|
||
|
new Word64(0x240ca1cc, 0x77ac9c65),
|
||
|
new Word64(0x2de92c6f, 0x592b0275),
|
||
|
new Word64(0x4a7484aa, 0x6ea6e483),
|
||
|
new Word64(0x5cb0a9dc, 0xbd41fbd4),
|
||
|
new Word64(0x76f988da, 0x831153b5),
|
||
|
new Word64(0x983e5152, 0xee66dfab),
|
||
|
new Word64(0xa831c66d, 0x2db43210),
|
||
|
new Word64(0xb00327c8, 0x98fb213f),
|
||
|
new Word64(0xbf597fc7, 0xbeef0ee4),
|
||
|
new Word64(0xc6e00bf3, 0x3da88fc2),
|
||
|
new Word64(0xd5a79147, 0x930aa725),
|
||
|
new Word64(0x06ca6351, 0xe003826f),
|
||
|
new Word64(0x14292967, 0x0a0e6e70),
|
||
|
new Word64(0x27b70a85, 0x46d22ffc),
|
||
|
new Word64(0x2e1b2138, 0x5c26c926),
|
||
|
new Word64(0x4d2c6dfc, 0x5ac42aed),
|
||
|
new Word64(0x53380d13, 0x9d95b3df),
|
||
|
new Word64(0x650a7354, 0x8baf63de),
|
||
|
new Word64(0x766a0abb, 0x3c77b2a8),
|
||
|
new Word64(0x81c2c92e, 0x47edaee6),
|
||
|
new Word64(0x92722c85, 0x1482353b),
|
||
|
new Word64(0xa2bfe8a1, 0x4cf10364),
|
||
|
new Word64(0xa81a664b, 0xbc423001),
|
||
|
new Word64(0xc24b8b70, 0xd0f89791),
|
||
|
new Word64(0xc76c51a3, 0x0654be30),
|
||
|
new Word64(0xd192e819, 0xd6ef5218),
|
||
|
new Word64(0xd6990624, 0x5565a910),
|
||
|
new Word64(0xf40e3585, 0x5771202a),
|
||
|
new Word64(0x106aa070, 0x32bbd1b8),
|
||
|
new Word64(0x19a4c116, 0xb8d2d0c8),
|
||
|
new Word64(0x1e376c08, 0x5141ab53),
|
||
|
new Word64(0x2748774c, 0xdf8eeb99),
|
||
|
new Word64(0x34b0bcb5, 0xe19b48a8),
|
||
|
new Word64(0x391c0cb3, 0xc5c95a63),
|
||
|
new Word64(0x4ed8aa4a, 0xe3418acb),
|
||
|
new Word64(0x5b9cca4f, 0x7763e373),
|
||
|
new Word64(0x682e6ff3, 0xd6b2b8a3),
|
||
|
new Word64(0x748f82ee, 0x5defb2fc),
|
||
|
new Word64(0x78a5636f, 0x43172f60),
|
||
|
new Word64(0x84c87814, 0xa1f0ab72),
|
||
|
new Word64(0x8cc70208, 0x1a6439ec),
|
||
|
new Word64(0x90befffa, 0x23631e28),
|
||
|
new Word64(0xa4506ceb, 0xde82bde9),
|
||
|
new Word64(0xbef9a3f7, 0xb2c67915),
|
||
|
new Word64(0xc67178f2, 0xe372532b),
|
||
|
new Word64(0xca273ece, 0xea26619c),
|
||
|
new Word64(0xd186b8c7, 0x21c0c207),
|
||
|
new Word64(0xeada7dd6, 0xcde0eb1e),
|
||
|
new Word64(0xf57d4f7f, 0xee6ed178),
|
||
|
new Word64(0x06f067aa, 0x72176fba),
|
||
|
new Word64(0x0a637dc5, 0xa2c898a6),
|
||
|
new Word64(0x113f9804, 0xbef90dae),
|
||
|
new Word64(0x1b710b35, 0x131c471b),
|
||
|
new Word64(0x28db77f5, 0x23047d84),
|
||
|
new Word64(0x32caab7b, 0x40c72493),
|
||
|
new Word64(0x3c9ebe0a, 0x15c9bebc),
|
||
|
new Word64(0x431d67c4, 0x9c100d4c),
|
||
|
new Word64(0x4cc5d4be, 0xcb3e42b6),
|
||
|
new Word64(0x597f299c, 0xfc657e2a),
|
||
|
new Word64(0x5fcb6fab, 0x3ad6faec),
|
||
|
new Word64(0x6c44198c, 0x4a475817)
|
||
|
];
|
||
|
function hash(data, offset, length, mode384) {
|
||
|
mode384 = !!mode384;
|
||
|
var h0, h1, h2, h3, h4, h5, h6, h7;
|
||
|
if (!mode384) {
|
||
|
h0 = new Word64(0x6a09e667, 0xf3bcc908);
|
||
|
h1 = new Word64(0xbb67ae85, 0x84caa73b);
|
||
|
h2 = new Word64(0x3c6ef372, 0xfe94f82b);
|
||
|
h3 = new Word64(0xa54ff53a, 0x5f1d36f1);
|
||
|
h4 = new Word64(0x510e527f, 0xade682d1);
|
||
|
h5 = new Word64(0x9b05688c, 0x2b3e6c1f);
|
||
|
h6 = new Word64(0x1f83d9ab, 0xfb41bd6b);
|
||
|
h7 = new Word64(0x5be0cd19, 0x137e2179);
|
||
|
} else {
|
||
|
h0 = new Word64(0xcbbb9d5d, 0xc1059ed8);
|
||
|
h1 = new Word64(0x629a292a, 0x367cd507);
|
||
|
h2 = new Word64(0x9159015a, 0x3070dd17);
|
||
|
h3 = new Word64(0x152fecd8, 0xf70e5939);
|
||
|
h4 = new Word64(0x67332667, 0xffc00b31);
|
||
|
h5 = new Word64(0x8eb44a87, 0x68581511);
|
||
|
h6 = new Word64(0xdb0c2e0d, 0x64f98fa7);
|
||
|
h7 = new Word64(0x47b5481d, 0xbefa4fa4);
|
||
|
}
|
||
|
var paddedLength = Math.ceil((length + 17) / 128) * 128;
|
||
|
var padded = new Uint8Array(paddedLength);
|
||
|
var i, j, n;
|
||
|
for (i = 0; i < length; ++i) {
|
||
|
padded[i] = data[offset++];
|
||
|
}
|
||
|
padded[i++] = 0x80;
|
||
|
n = paddedLength - 16;
|
||
|
while (i < n) {
|
||
|
padded[i++] = 0;
|
||
|
}
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = 0;
|
||
|
padded[i++] = length >>> 29 & 0xFF;
|
||
|
padded[i++] = length >> 21 & 0xFF;
|
||
|
padded[i++] = length >> 13 & 0xFF;
|
||
|
padded[i++] = length >> 5 & 0xFF;
|
||
|
padded[i++] = length << 3 & 0xFF;
|
||
|
var w = new Array(80);
|
||
|
for (i = 0; i < 80; i++) {
|
||
|
w[i] = new Word64(0, 0);
|
||
|
}
|
||
|
var a = new Word64(0, 0), b = new Word64(0, 0), c = new Word64(0, 0);
|
||
|
var d = new Word64(0, 0), e = new Word64(0, 0), f = new Word64(0, 0);
|
||
|
var g = new Word64(0, 0), h = new Word64(0, 0);
|
||
|
var t1 = new Word64(0, 0), t2 = new Word64(0, 0);
|
||
|
var tmp1 = new Word64(0, 0), tmp2 = new Word64(0, 0), tmp3;
|
||
|
for (i = 0; i < paddedLength;) {
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
w[j].high = padded[i] << 24 | padded[i + 1] << 16 | padded[i + 2] << 8 | padded[i + 3];
|
||
|
w[j].low = padded[i + 4] << 24 | padded[i + 5] << 16 | padded[i + 6] << 8 | padded[i + 7];
|
||
|
i += 8;
|
||
|
}
|
||
|
for (j = 16; j < 80; ++j) {
|
||
|
tmp3 = w[j];
|
||
|
littleSigmaPrime(tmp3, w[j - 2], tmp2);
|
||
|
tmp3.add(w[j - 7]);
|
||
|
littleSigma(tmp1, w[j - 15], tmp2);
|
||
|
tmp3.add(tmp1);
|
||
|
tmp3.add(w[j - 16]);
|
||
|
}
|
||
|
a.assign(h0);
|
||
|
b.assign(h1);
|
||
|
c.assign(h2);
|
||
|
d.assign(h3);
|
||
|
e.assign(h4);
|
||
|
f.assign(h5);
|
||
|
g.assign(h6);
|
||
|
h.assign(h7);
|
||
|
for (j = 0; j < 80; ++j) {
|
||
|
t1.assign(h);
|
||
|
sigmaPrime(tmp1, e, tmp2);
|
||
|
t1.add(tmp1);
|
||
|
ch(tmp1, e, f, g, tmp2);
|
||
|
t1.add(tmp1);
|
||
|
t1.add(k[j]);
|
||
|
t1.add(w[j]);
|
||
|
sigma(t2, a, tmp2);
|
||
|
maj(tmp1, a, b, c, tmp2);
|
||
|
t2.add(tmp1);
|
||
|
tmp3 = h;
|
||
|
h = g;
|
||
|
g = f;
|
||
|
f = e;
|
||
|
d.add(t1);
|
||
|
e = d;
|
||
|
d = c;
|
||
|
c = b;
|
||
|
b = a;
|
||
|
tmp3.assign(t1);
|
||
|
tmp3.add(t2);
|
||
|
a = tmp3;
|
||
|
}
|
||
|
h0.add(a);
|
||
|
h1.add(b);
|
||
|
h2.add(c);
|
||
|
h3.add(d);
|
||
|
h4.add(e);
|
||
|
h5.add(f);
|
||
|
h6.add(g);
|
||
|
h7.add(h);
|
||
|
}
|
||
|
var result;
|
||
|
if (!mode384) {
|
||
|
result = new Uint8Array(64);
|
||
|
h0.copyTo(result, 0);
|
||
|
h1.copyTo(result, 8);
|
||
|
h2.copyTo(result, 16);
|
||
|
h3.copyTo(result, 24);
|
||
|
h4.copyTo(result, 32);
|
||
|
h5.copyTo(result, 40);
|
||
|
h6.copyTo(result, 48);
|
||
|
h7.copyTo(result, 56);
|
||
|
} else {
|
||
|
result = new Uint8Array(48);
|
||
|
h0.copyTo(result, 0);
|
||
|
h1.copyTo(result, 8);
|
||
|
h2.copyTo(result, 16);
|
||
|
h3.copyTo(result, 24);
|
||
|
h4.copyTo(result, 32);
|
||
|
h5.copyTo(result, 40);
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
return hash;
|
||
|
}();
|
||
|
var calculateSHA384 = function calculateSHA384Closure() {
|
||
|
function hash(data, offset, length) {
|
||
|
return calculateSHA512(data, offset, length, true);
|
||
|
}
|
||
|
return hash;
|
||
|
}();
|
||
|
var NullCipher = function NullCipherClosure() {
|
||
|
function NullCipher() {
|
||
|
}
|
||
|
NullCipher.prototype = {
|
||
|
decryptBlock: function NullCipher_decryptBlock(data) {
|
||
|
return data;
|
||
|
}
|
||
|
};
|
||
|
return NullCipher;
|
||
|
}();
|
||
|
var AES128Cipher = function AES128CipherClosure() {
|
||
|
var rcon = new Uint8Array([
|
||
|
0x8d,
|
||
|
0x01,
|
||
|
0x02,
|
||
|
0x04,
|
||
|
0x08,
|
||
|
0x10,
|
||
|
0x20,
|
||
|
0x40,
|
||
|
0x80,
|
||
|
0x1b,
|
||
|
0x36,
|
||
|
0x6c,
|
||
|
0xd8,
|
||
|
0xab,
|
||
|
0x4d,
|
||
|
0x9a,
|
||
|
0x2f,
|
||
|
0x5e,
|
||
|
0xbc,
|
||
|
0x63,
|
||
|
0xc6,
|
||
|
0x97,
|
||
|
0x35,
|
||
|
0x6a,
|
||
|
0xd4,
|
||
|
0xb3,
|
||
|
0x7d,
|
||
|
0xfa,
|
||
|
0xef,
|
||
|
0xc5,
|
||
|
0x91,
|
||
|
0x39,
|
||
|
0x72,
|
||
|
0xe4,
|
||
|
0xd3,
|
||
|
0xbd,
|
||
|
0x61,
|
||
|
0xc2,
|
||
|
0x9f,
|
||
|
0x25,
|
||
|
0x4a,
|
||
|
0x94,
|
||
|
0x33,
|
||
|
0x66,
|
||
|
0xcc,
|
||
|
0x83,
|
||
|
0x1d,
|
||
|
0x3a,
|
||
|
0x74,
|
||
|
0xe8,
|
||
|
0xcb,
|
||
|
0x8d,
|
||
|
0x01,
|
||
|
0x02,
|
||
|
0x04,
|
||
|
0x08,
|
||
|
0x10,
|
||
|
0x20,
|
||
|
0x40,
|
||
|
0x80,
|
||
|
0x1b,
|
||
|
0x36,
|
||
|
0x6c,
|
||
|
0xd8,
|
||
|
0xab,
|
||
|
0x4d,
|
||
|
0x9a,
|
||
|
0x2f,
|
||
|
0x5e,
|
||
|
0xbc,
|
||
|
0x63,
|
||
|
0xc6,
|
||
|
0x97,
|
||
|
0x35,
|
||
|
0x6a,
|
||
|
0xd4,
|
||
|
0xb3,
|
||
|
0x7d,
|
||
|
0xfa,
|
||
|
0xef,
|
||
|
0xc5,
|
||
|
0x91,
|
||
|
0x39,
|
||
|
0x72,
|
||
|
0xe4,
|
||
|
0xd3,
|
||
|
0xbd,
|
||
|
0x61,
|
||
|
0xc2,
|
||
|
0x9f,
|
||
|
0x25,
|
||
|
0x4a,
|
||
|
0x94,
|
||
|
0x33,
|
||
|
0x66,
|
||
|
0xcc,
|
||
|
0x83,
|
||
|
0x1d,
|
||
|
0x3a,
|
||
|
0x74,
|
||
|
0xe8,
|
||
|
0xcb,
|
||
|
0x8d,
|
||
|
0x01,
|
||
|
0x02,
|
||
|
0x04,
|
||
|
0x08,
|
||
|
0x10,
|
||
|
0x20,
|
||
|
0x40,
|
||
|
0x80,
|
||
|
0x1b,
|
||
|
0x36,
|
||
|
0x6c,
|
||
|
0xd8,
|
||
|
0xab,
|
||
|
0x4d,
|
||
|
0x9a,
|
||
|
0x2f,
|
||
|
0x5e,
|
||
|
0xbc,
|
||
|
0x63,
|
||
|
0xc6,
|
||
|
0x97,
|
||
|
0x35,
|
||
|
0x6a,
|
||
|
0xd4,
|
||
|
0xb3,
|
||
|
0x7d,
|
||
|
0xfa,
|
||
|
0xef,
|
||
|
0xc5,
|
||
|
0x91,
|
||
|
0x39,
|
||
|
0x72,
|
||
|
0xe4,
|
||
|
0xd3,
|
||
|
0xbd,
|
||
|
0x61,
|
||
|
0xc2,
|
||
|
0x9f,
|
||
|
0x25,
|
||
|
0x4a,
|
||
|
0x94,
|
||
|
0x33,
|
||
|
0x66,
|
||
|
0xcc,
|
||
|
0x83,
|
||
|
0x1d,
|
||
|
0x3a,
|
||
|
0x74,
|
||
|
0xe8,
|
||
|
0xcb,
|
||
|
0x8d,
|
||
|
0x01,
|
||
|
0x02,
|
||
|
0x04,
|
||
|
0x08,
|
||
|
0x10,
|
||
|
0x20,
|
||
|
0x40,
|
||
|
0x80,
|
||
|
0x1b,
|
||
|
0x36,
|
||
|
0x6c,
|
||
|
0xd8,
|
||
|
0xab,
|
||
|
0x4d,
|
||
|
0x9a,
|
||
|
0x2f,
|
||
|
0x5e,
|
||
|
0xbc,
|
||
|
0x63,
|
||
|
0xc6,
|
||
|
0x97,
|
||
|
0x35,
|
||
|
0x6a,
|
||
|
0xd4,
|
||
|
0xb3,
|
||
|
0x7d,
|
||
|
0xfa,
|
||
|
0xef,
|
||
|
0xc5,
|
||
|
0x91,
|
||
|
0x39,
|
||
|
0x72,
|
||
|
0xe4,
|
||
|
0xd3,
|
||
|
0xbd,
|
||
|
0x61,
|
||
|
0xc2,
|
||
|
0x9f,
|
||
|
0x25,
|
||
|
0x4a,
|
||
|
0x94,
|
||
|
0x33,
|
||
|
0x66,
|
||
|
0xcc,
|
||
|
0x83,
|
||
|
0x1d,
|
||
|
0x3a,
|
||
|
0x74,
|
||
|
0xe8,
|
||
|
0xcb,
|
||
|
0x8d,
|
||
|
0x01,
|
||
|
0x02,
|
||
|
0x04,
|
||
|
0x08,
|
||
|
0x10,
|
||
|
0x20,
|
||
|
0x40,
|
||
|
0x80,
|
||
|
0x1b,
|
||
|
0x36,
|
||
|
0x6c,
|
||
|
0xd8,
|
||
|
0xab,
|
||
|
0x4d,
|
||
|
0x9a,
|
||
|
0x2f,
|
||
|
0x5e,
|
||
|
0xbc,
|
||
|
0x63,
|
||
|
0xc6,
|
||
|
0x97,
|
||
|
0x35,
|
||
|
0x6a,
|
||
|
0xd4,
|
||
|
0xb3,
|
||
|
0x7d,
|
||
|
0xfa,
|
||
|
0xef,
|
||
|
0xc5,
|
||
|
0x91,
|
||
|
0x39,
|
||
|
0x72,
|
||
|
0xe4,
|
||
|
0xd3,
|
||
|
0xbd,
|
||
|
0x61,
|
||
|
0xc2,
|
||
|
0x9f,
|
||
|
0x25,
|
||
|
0x4a,
|
||
|
0x94,
|
||
|
0x33,
|
||
|
0x66,
|
||
|
0xcc,
|
||
|
0x83,
|
||
|
0x1d,
|
||
|
0x3a,
|
||
|
0x74,
|
||
|
0xe8,
|
||
|
0xcb,
|
||
|
0x8d
|
||
|
]);
|
||
|
var s = new Uint8Array([
|
||
|
0x63,
|
||
|
0x7c,
|
||
|
0x77,
|
||
|
0x7b,
|
||
|
0xf2,
|
||
|
0x6b,
|
||
|
0x6f,
|
||
|
0xc5,
|
||
|
0x30,
|
||
|
0x01,
|
||
|
0x67,
|
||
|
0x2b,
|
||
|
0xfe,
|
||
|
0xd7,
|
||
|
0xab,
|
||
|
0x76,
|
||
|
0xca,
|
||
|
0x82,
|
||
|
0xc9,
|
||
|
0x7d,
|
||
|
0xfa,
|
||
|
0x59,
|
||
|
0x47,
|
||
|
0xf0,
|
||
|
0xad,
|
||
|
0xd4,
|
||
|
0xa2,
|
||
|
0xaf,
|
||
|
0x9c,
|
||
|
0xa4,
|
||
|
0x72,
|
||
|
0xc0,
|
||
|
0xb7,
|
||
|
0xfd,
|
||
|
0x93,
|
||
|
0x26,
|
||
|
0x36,
|
||
|
0x3f,
|
||
|
0xf7,
|
||
|
0xcc,
|
||
|
0x34,
|
||
|
0xa5,
|
||
|
0xe5,
|
||
|
0xf1,
|
||
|
0x71,
|
||
|
0xd8,
|
||
|
0x31,
|
||
|
0x15,
|
||
|
0x04,
|
||
|
0xc7,
|
||
|
0x23,
|
||
|
0xc3,
|
||
|
0x18,
|
||
|
0x96,
|
||
|
0x05,
|
||
|
0x9a,
|
||
|
0x07,
|
||
|
0x12,
|
||
|
0x80,
|
||
|
0xe2,
|
||
|
0xeb,
|
||
|
0x27,
|
||
|
0xb2,
|
||
|
0x75,
|
||
|
0x09,
|
||
|
0x83,
|
||
|
0x2c,
|
||
|
0x1a,
|
||
|
0x1b,
|
||
|
0x6e,
|
||
|
0x5a,
|
||
|
0xa0,
|
||
|
0x52,
|
||
|
0x3b,
|
||
|
0xd6,
|
||
|
0xb3,
|
||
|
0x29,
|
||
|
0xe3,
|
||
|
0x2f,
|
||
|
0x84,
|
||
|
0x53,
|
||
|
0xd1,
|
||
|
0x00,
|
||
|
0xed,
|
||
|
0x20,
|
||
|
0xfc,
|
||
|
0xb1,
|
||
|
0x5b,
|
||
|
0x6a,
|
||
|
0xcb,
|
||
|
0xbe,
|
||
|
0x39,
|
||
|
0x4a,
|
||
|
0x4c,
|
||
|
0x58,
|
||
|
0xcf,
|
||
|
0xd0,
|
||
|
0xef,
|
||
|
0xaa,
|
||
|
0xfb,
|
||
|
0x43,
|
||
|
0x4d,
|
||
|
0x33,
|
||
|
0x85,
|
||
|
0x45,
|
||
|
0xf9,
|
||
|
0x02,
|
||
|
0x7f,
|
||
|
0x50,
|
||
|
0x3c,
|
||
|
0x9f,
|
||
|
0xa8,
|
||
|
0x51,
|
||
|
0xa3,
|
||
|
0x40,
|
||
|
0x8f,
|
||
|
0x92,
|
||
|
0x9d,
|
||
|
0x38,
|
||
|
0xf5,
|
||
|
0xbc,
|
||
|
0xb6,
|
||
|
0xda,
|
||
|
0x21,
|
||
|
0x10,
|
||
|
0xff,
|
||
|
0xf3,
|
||
|
0xd2,
|
||
|
0xcd,
|
||
|
0x0c,
|
||
|
0x13,
|
||
|
0xec,
|
||
|
0x5f,
|
||
|
0x97,
|
||
|
0x44,
|
||
|
0x17,
|
||
|
0xc4,
|
||
|
0xa7,
|
||
|
0x7e,
|
||
|
0x3d,
|
||
|
0x64,
|
||
|
0x5d,
|
||
|
0x19,
|
||
|
0x73,
|
||
|
0x60,
|
||
|
0x81,
|
||
|
0x4f,
|
||
|
0xdc,
|
||
|
0x22,
|
||
|
0x2a,
|
||
|
0x90,
|
||
|
0x88,
|
||
|
0x46,
|
||
|
0xee,
|
||
|
0xb8,
|
||
|
0x14,
|
||
|
0xde,
|
||
|
0x5e,
|
||
|
0x0b,
|
||
|
0xdb,
|
||
|
0xe0,
|
||
|
0x32,
|
||
|
0x3a,
|
||
|
0x0a,
|
||
|
0x49,
|
||
|
0x06,
|
||
|
0x24,
|
||
|
0x5c,
|
||
|
0xc2,
|
||
|
0xd3,
|
||
|
0xac,
|
||
|
0x62,
|
||
|
0x91,
|
||
|
0x95,
|
||
|
0xe4,
|
||
|
0x79,
|
||
|
0xe7,
|
||
|
0xc8,
|
||
|
0x37,
|
||
|
0x6d,
|
||
|
0x8d,
|
||
|
0xd5,
|
||
|
0x4e,
|
||
|
0xa9,
|
||
|
0x6c,
|
||
|
0x56,
|
||
|
0xf4,
|
||
|
0xea,
|
||
|
0x65,
|
||
|
0x7a,
|
||
|
0xae,
|
||
|
0x08,
|
||
|
0xba,
|
||
|
0x78,
|
||
|
0x25,
|
||
|
0x2e,
|
||
|
0x1c,
|
||
|
0xa6,
|
||
|
0xb4,
|
||
|
0xc6,
|
||
|
0xe8,
|
||
|
0xdd,
|
||
|
0x74,
|
||
|
0x1f,
|
||
|
0x4b,
|
||
|
0xbd,
|
||
|
0x8b,
|
||
|
0x8a,
|
||
|
0x70,
|
||
|
0x3e,
|
||
|
0xb5,
|
||
|
0x66,
|
||
|
0x48,
|
||
|
0x03,
|
||
|
0xf6,
|
||
|
0x0e,
|
||
|
0x61,
|
||
|
0x35,
|
||
|
0x57,
|
||
|
0xb9,
|
||
|
0x86,
|
||
|
0xc1,
|
||
|
0x1d,
|
||
|
0x9e,
|
||
|
0xe1,
|
||
|
0xf8,
|
||
|
0x98,
|
||
|
0x11,
|
||
|
0x69,
|
||
|
0xd9,
|
||
|
0x8e,
|
||
|
0x94,
|
||
|
0x9b,
|
||
|
0x1e,
|
||
|
0x87,
|
||
|
0xe9,
|
||
|
0xce,
|
||
|
0x55,
|
||
|
0x28,
|
||
|
0xdf,
|
||
|
0x8c,
|
||
|
0xa1,
|
||
|
0x89,
|
||
|
0x0d,
|
||
|
0xbf,
|
||
|
0xe6,
|
||
|
0x42,
|
||
|
0x68,
|
||
|
0x41,
|
||
|
0x99,
|
||
|
0x2d,
|
||
|
0x0f,
|
||
|
0xb0,
|
||
|
0x54,
|
||
|
0xbb,
|
||
|
0x16
|
||
|
]);
|
||
|
var inv_s = new Uint8Array([
|
||
|
0x52,
|
||
|
0x09,
|
||
|
0x6a,
|
||
|
0xd5,
|
||
|
0x30,
|
||
|
0x36,
|
||
|
0xa5,
|
||
|
0x38,
|
||
|
0xbf,
|
||
|
0x40,
|
||
|
0xa3,
|
||
|
0x9e,
|
||
|
0x81,
|
||
|
0xf3,
|
||
|
0xd7,
|
||
|
0xfb,
|
||
|
0x7c,
|
||
|
0xe3,
|
||
|
0x39,
|
||
|
0x82,
|
||
|
0x9b,
|
||
|
0x2f,
|
||
|
0xff,
|
||
|
0x87,
|
||
|
0x34,
|
||
|
0x8e,
|
||
|
0x43,
|
||
|
0x44,
|
||
|
0xc4,
|
||
|
0xde,
|
||
|
0xe9,
|
||
|
0xcb,
|
||
|
0x54,
|
||
|
0x7b,
|
||
|
0x94,
|
||
|
0x32,
|
||
|
0xa6,
|
||
|
0xc2,
|
||
|
0x23,
|
||
|
0x3d,
|
||
|
0xee,
|
||
|
0x4c,
|
||
|
0x95,
|
||
|
0x0b,
|
||
|
0x42,
|
||
|
0xfa,
|
||
|
0xc3,
|
||
|
0x4e,
|
||
|
0x08,
|
||
|
0x2e,
|
||
|
0xa1,
|
||
|
0x66,
|
||
|
0x28,
|
||
|
0xd9,
|
||
|
0x24,
|
||
|
0xb2,
|
||
|
0x76,
|
||
|
0x5b,
|
||
|
0xa2,
|
||
|
0x49,
|
||
|
0x6d,
|
||
|
0x8b,
|
||
|
0xd1,
|
||
|
0x25,
|
||
|
0x72,
|
||
|
0xf8,
|
||
|
0xf6,
|
||
|
0x64,
|
||
|
0x86,
|
||
|
0x68,
|
||
|
0x98,
|
||
|
0x16,
|
||
|
0xd4,
|
||
|
0xa4,
|
||
|
0x5c,
|
||
|
0xcc,
|
||
|
0x5d,
|
||
|
0x65,
|
||
|
0xb6,
|
||
|
0x92,
|
||
|
0x6c,
|
||
|
0x70,
|
||
|
0x48,
|
||
|
0x50,
|
||
|
0xfd,
|
||
|
0xed,
|
||
|
0xb9,
|
||
|
0xda,
|
||
|
0x5e,
|
||
|
0x15,
|
||
|
0x46,
|
||
|
0x57,
|
||
|
0xa7,
|
||
|
0x8d,
|
||
|
0x9d,
|
||
|
0x84,
|
||
|
0x90,
|
||
|
0xd8,
|
||
|
0xab,
|
||
|
0x00,
|
||
|
0x8c,
|
||
|
0xbc,
|
||
|
0xd3,
|
||
|
0x0a,
|
||
|
0xf7,
|
||
|
0xe4,
|
||
|
0x58,
|
||
|
0x05,
|
||
|
0xb8,
|
||
|
0xb3,
|
||
|
0x45,
|
||
|
0x06,
|
||
|
0xd0,
|
||
|
0x2c,
|
||
|
0x1e,
|
||
|
0x8f,
|
||
|
0xca,
|
||
|
0x3f,
|
||
|
0x0f,
|
||
|
0x02,
|
||
|
0xc1,
|
||
|
0xaf,
|
||
|
0xbd,
|
||
|
0x03,
|
||
|
0x01,
|
||
|
0x13,
|
||
|
0x8a,
|
||
|
0x6b,
|
||
|
0x3a,
|
||
|
0x91,
|
||
|
0x11,
|
||
|
0x41,
|
||
|
0x4f,
|
||
|
0x67,
|
||
|
0xdc,
|
||
|
0xea,
|
||
|
0x97,
|
||
|
0xf2,
|
||
|
0xcf,
|
||
|
0xce,
|
||
|
0xf0,
|
||
|
0xb4,
|
||
|
0xe6,
|
||
|
0x73,
|
||
|
0x96,
|
||
|
0xac,
|
||
|
0x74,
|
||
|
0x22,
|
||
|
0xe7,
|
||
|
0xad,
|
||
|
0x35,
|
||
|
0x85,
|
||
|
0xe2,
|
||
|
0xf9,
|
||
|
0x37,
|
||
|
0xe8,
|
||
|
0x1c,
|
||
|
0x75,
|
||
|
0xdf,
|
||
|
0x6e,
|
||
|
0x47,
|
||
|
0xf1,
|
||
|
0x1a,
|
||
|
0x71,
|
||
|
0x1d,
|
||
|
0x29,
|
||
|
0xc5,
|
||
|
0x89,
|
||
|
0x6f,
|
||
|
0xb7,
|
||
|
0x62,
|
||
|
0x0e,
|
||
|
0xaa,
|
||
|
0x18,
|
||
|
0xbe,
|
||
|
0x1b,
|
||
|
0xfc,
|
||
|
0x56,
|
||
|
0x3e,
|
||
|
0x4b,
|
||
|
0xc6,
|
||
|
0xd2,
|
||
|
0x79,
|
||
|
0x20,
|
||
|
0x9a,
|
||
|
0xdb,
|
||
|
0xc0,
|
||
|
0xfe,
|
||
|
0x78,
|
||
|
0xcd,
|
||
|
0x5a,
|
||
|
0xf4,
|
||
|
0x1f,
|
||
|
0xdd,
|
||
|
0xa8,
|
||
|
0x33,
|
||
|
0x88,
|
||
|
0x07,
|
||
|
0xc7,
|
||
|
0x31,
|
||
|
0xb1,
|
||
|
0x12,
|
||
|
0x10,
|
||
|
0x59,
|
||
|
0x27,
|
||
|
0x80,
|
||
|
0xec,
|
||
|
0x5f,
|
||
|
0x60,
|
||
|
0x51,
|
||
|
0x7f,
|
||
|
0xa9,
|
||
|
0x19,
|
||
|
0xb5,
|
||
|
0x4a,
|
||
|
0x0d,
|
||
|
0x2d,
|
||
|
0xe5,
|
||
|
0x7a,
|
||
|
0x9f,
|
||
|
0x93,
|
||
|
0xc9,
|
||
|
0x9c,
|
||
|
0xef,
|
||
|
0xa0,
|
||
|
0xe0,
|
||
|
0x3b,
|
||
|
0x4d,
|
||
|
0xae,
|
||
|
0x2a,
|
||
|
0xf5,
|
||
|
0xb0,
|
||
|
0xc8,
|
||
|
0xeb,
|
||
|
0xbb,
|
||
|
0x3c,
|
||
|
0x83,
|
||
|
0x53,
|
||
|
0x99,
|
||
|
0x61,
|
||
|
0x17,
|
||
|
0x2b,
|
||
|
0x04,
|
||
|
0x7e,
|
||
|
0xba,
|
||
|
0x77,
|
||
|
0xd6,
|
||
|
0x26,
|
||
|
0xe1,
|
||
|
0x69,
|
||
|
0x14,
|
||
|
0x63,
|
||
|
0x55,
|
||
|
0x21,
|
||
|
0x0c,
|
||
|
0x7d
|
||
|
]);
|
||
|
var mixCol = new Uint8Array(256);
|
||
|
for (var i = 0; i < 256; i++) {
|
||
|
if (i < 128) {
|
||
|
mixCol[i] = i << 1;
|
||
|
} else {
|
||
|
mixCol[i] = i << 1 ^ 0x1b;
|
||
|
}
|
||
|
}
|
||
|
var mix = new Uint32Array([
|
||
|
0x00000000,
|
||
|
0x0e090d0b,
|
||
|
0x1c121a16,
|
||
|
0x121b171d,
|
||
|
0x3824342c,
|
||
|
0x362d3927,
|
||
|
0x24362e3a,
|
||
|
0x2a3f2331,
|
||
|
0x70486858,
|
||
|
0x7e416553,
|
||
|
0x6c5a724e,
|
||
|
0x62537f45,
|
||
|
0x486c5c74,
|
||
|
0x4665517f,
|
||
|
0x547e4662,
|
||
|
0x5a774b69,
|
||
|
0xe090d0b0,
|
||
|
0xee99ddbb,
|
||
|
0xfc82caa6,
|
||
|
0xf28bc7ad,
|
||
|
0xd8b4e49c,
|
||
|
0xd6bde997,
|
||
|
0xc4a6fe8a,
|
||
|
0xcaaff381,
|
||
|
0x90d8b8e8,
|
||
|
0x9ed1b5e3,
|
||
|
0x8ccaa2fe,
|
||
|
0x82c3aff5,
|
||
|
0xa8fc8cc4,
|
||
|
0xa6f581cf,
|
||
|
0xb4ee96d2,
|
||
|
0xbae79bd9,
|
||
|
0xdb3bbb7b,
|
||
|
0xd532b670,
|
||
|
0xc729a16d,
|
||
|
0xc920ac66,
|
||
|
0xe31f8f57,
|
||
|
0xed16825c,
|
||
|
0xff0d9541,
|
||
|
0xf104984a,
|
||
|
0xab73d323,
|
||
|
0xa57ade28,
|
||
|
0xb761c935,
|
||
|
0xb968c43e,
|
||
|
0x9357e70f,
|
||
|
0x9d5eea04,
|
||
|
0x8f45fd19,
|
||
|
0x814cf012,
|
||
|
0x3bab6bcb,
|
||
|
0x35a266c0,
|
||
|
0x27b971dd,
|
||
|
0x29b07cd6,
|
||
|
0x038f5fe7,
|
||
|
0x0d8652ec,
|
||
|
0x1f9d45f1,
|
||
|
0x119448fa,
|
||
|
0x4be30393,
|
||
|
0x45ea0e98,
|
||
|
0x57f11985,
|
||
|
0x59f8148e,
|
||
|
0x73c737bf,
|
||
|
0x7dce3ab4,
|
||
|
0x6fd52da9,
|
||
|
0x61dc20a2,
|
||
|
0xad766df6,
|
||
|
0xa37f60fd,
|
||
|
0xb16477e0,
|
||
|
0xbf6d7aeb,
|
||
|
0x955259da,
|
||
|
0x9b5b54d1,
|
||
|
0x894043cc,
|
||
|
0x87494ec7,
|
||
|
0xdd3e05ae,
|
||
|
0xd33708a5,
|
||
|
0xc12c1fb8,
|
||
|
0xcf2512b3,
|
||
|
0xe51a3182,
|
||
|
0xeb133c89,
|
||
|
0xf9082b94,
|
||
|
0xf701269f,
|
||
|
0x4de6bd46,
|
||
|
0x43efb04d,
|
||
|
0x51f4a750,
|
||
|
0x5ffdaa5b,
|
||
|
0x75c2896a,
|
||
|
0x7bcb8461,
|
||
|
0x69d0937c,
|
||
|
0x67d99e77,
|
||
|
0x3daed51e,
|
||
|
0x33a7d815,
|
||
|
0x21bccf08,
|
||
|
0x2fb5c203,
|
||
|
0x058ae132,
|
||
|
0x0b83ec39,
|
||
|
0x1998fb24,
|
||
|
0x1791f62f,
|
||
|
0x764dd68d,
|
||
|
0x7844db86,
|
||
|
0x6a5fcc9b,
|
||
|
0x6456c190,
|
||
|
0x4e69e2a1,
|
||
|
0x4060efaa,
|
||
|
0x527bf8b7,
|
||
|
0x5c72f5bc,
|
||
|
0x0605bed5,
|
||
|
0x080cb3de,
|
||
|
0x1a17a4c3,
|
||
|
0x141ea9c8,
|
||
|
0x3e218af9,
|
||
|
0x302887f2,
|
||
|
0x223390ef,
|
||
|
0x2c3a9de4,
|
||
|
0x96dd063d,
|
||
|
0x98d40b36,
|
||
|
0x8acf1c2b,
|
||
|
0x84c61120,
|
||
|
0xaef93211,
|
||
|
0xa0f03f1a,
|
||
|
0xb2eb2807,
|
||
|
0xbce2250c,
|
||
|
0xe6956e65,
|
||
|
0xe89c636e,
|
||
|
0xfa877473,
|
||
|
0xf48e7978,
|
||
|
0xdeb15a49,
|
||
|
0xd0b85742,
|
||
|
0xc2a3405f,
|
||
|
0xccaa4d54,
|
||
|
0x41ecdaf7,
|
||
|
0x4fe5d7fc,
|
||
|
0x5dfec0e1,
|
||
|
0x53f7cdea,
|
||
|
0x79c8eedb,
|
||
|
0x77c1e3d0,
|
||
|
0x65daf4cd,
|
||
|
0x6bd3f9c6,
|
||
|
0x31a4b2af,
|
||
|
0x3fadbfa4,
|
||
|
0x2db6a8b9,
|
||
|
0x23bfa5b2,
|
||
|
0x09808683,
|
||
|
0x07898b88,
|
||
|
0x15929c95,
|
||
|
0x1b9b919e,
|
||
|
0xa17c0a47,
|
||
|
0xaf75074c,
|
||
|
0xbd6e1051,
|
||
|
0xb3671d5a,
|
||
|
0x99583e6b,
|
||
|
0x97513360,
|
||
|
0x854a247d,
|
||
|
0x8b432976,
|
||
|
0xd134621f,
|
||
|
0xdf3d6f14,
|
||
|
0xcd267809,
|
||
|
0xc32f7502,
|
||
|
0xe9105633,
|
||
|
0xe7195b38,
|
||
|
0xf5024c25,
|
||
|
0xfb0b412e,
|
||
|
0x9ad7618c,
|
||
|
0x94de6c87,
|
||
|
0x86c57b9a,
|
||
|
0x88cc7691,
|
||
|
0xa2f355a0,
|
||
|
0xacfa58ab,
|
||
|
0xbee14fb6,
|
||
|
0xb0e842bd,
|
||
|
0xea9f09d4,
|
||
|
0xe49604df,
|
||
|
0xf68d13c2,
|
||
|
0xf8841ec9,
|
||
|
0xd2bb3df8,
|
||
|
0xdcb230f3,
|
||
|
0xcea927ee,
|
||
|
0xc0a02ae5,
|
||
|
0x7a47b13c,
|
||
|
0x744ebc37,
|
||
|
0x6655ab2a,
|
||
|
0x685ca621,
|
||
|
0x42638510,
|
||
|
0x4c6a881b,
|
||
|
0x5e719f06,
|
||
|
0x5078920d,
|
||
|
0x0a0fd964,
|
||
|
0x0406d46f,
|
||
|
0x161dc372,
|
||
|
0x1814ce79,
|
||
|
0x322bed48,
|
||
|
0x3c22e043,
|
||
|
0x2e39f75e,
|
||
|
0x2030fa55,
|
||
|
0xec9ab701,
|
||
|
0xe293ba0a,
|
||
|
0xf088ad17,
|
||
|
0xfe81a01c,
|
||
|
0xd4be832d,
|
||
|
0xdab78e26,
|
||
|
0xc8ac993b,
|
||
|
0xc6a59430,
|
||
|
0x9cd2df59,
|
||
|
0x92dbd252,
|
||
|
0x80c0c54f,
|
||
|
0x8ec9c844,
|
||
|
0xa4f6eb75,
|
||
|
0xaaffe67e,
|
||
|
0xb8e4f163,
|
||
|
0xb6edfc68,
|
||
|
0x0c0a67b1,
|
||
|
0x02036aba,
|
||
|
0x10187da7,
|
||
|
0x1e1170ac,
|
||
|
0x342e539d,
|
||
|
0x3a275e96,
|
||
|
0x283c498b,
|
||
|
0x26354480,
|
||
|
0x7c420fe9,
|
||
|
0x724b02e2,
|
||
|
0x605015ff,
|
||
|
0x6e5918f4,
|
||
|
0x44663bc5,
|
||
|
0x4a6f36ce,
|
||
|
0x587421d3,
|
||
|
0x567d2cd8,
|
||
|
0x37a10c7a,
|
||
|
0x39a80171,
|
||
|
0x2bb3166c,
|
||
|
0x25ba1b67,
|
||
|
0x0f853856,
|
||
|
0x018c355d,
|
||
|
0x13972240,
|
||
|
0x1d9e2f4b,
|
||
|
0x47e96422,
|
||
|
0x49e06929,
|
||
|
0x5bfb7e34,
|
||
|
0x55f2733f,
|
||
|
0x7fcd500e,
|
||
|
0x71c45d05,
|
||
|
0x63df4a18,
|
||
|
0x6dd64713,
|
||
|
0xd731dcca,
|
||
|
0xd938d1c1,
|
||
|
0xcb23c6dc,
|
||
|
0xc52acbd7,
|
||
|
0xef15e8e6,
|
||
|
0xe11ce5ed,
|
||
|
0xf307f2f0,
|
||
|
0xfd0efffb,
|
||
|
0xa779b492,
|
||
|
0xa970b999,
|
||
|
0xbb6bae84,
|
||
|
0xb562a38f,
|
||
|
0x9f5d80be,
|
||
|
0x91548db5,
|
||
|
0x834f9aa8,
|
||
|
0x8d4697a3
|
||
|
]);
|
||
|
function expandKey128(cipherKey) {
|
||
|
var b = 176, result = new Uint8Array(b);
|
||
|
result.set(cipherKey);
|
||
|
for (var j = 16, i = 1; j < b; ++i) {
|
||
|
var t1 = result[j - 3], t2 = result[j - 2], t3 = result[j - 1], t4 = result[j - 4];
|
||
|
t1 = s[t1];
|
||
|
t2 = s[t2];
|
||
|
t3 = s[t3];
|
||
|
t4 = s[t4];
|
||
|
t1 = t1 ^ rcon[i];
|
||
|
for (var n = 0; n < 4; ++n) {
|
||
|
result[j] = t1 ^= result[j - 16];
|
||
|
j++;
|
||
|
result[j] = t2 ^= result[j - 16];
|
||
|
j++;
|
||
|
result[j] = t3 ^= result[j - 16];
|
||
|
j++;
|
||
|
result[j] = t4 ^= result[j - 16];
|
||
|
j++;
|
||
|
}
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
function decrypt128(input, key) {
|
||
|
var state = new Uint8Array(16);
|
||
|
state.set(input);
|
||
|
var i, j, k;
|
||
|
var t, u, v;
|
||
|
for (j = 0, k = 160; j < 16; ++j, ++k) {
|
||
|
state[j] ^= key[k];
|
||
|
}
|
||
|
for (i = 9; i >= 1; --i) {
|
||
|
t = state[13];
|
||
|
state[13] = state[9];
|
||
|
state[9] = state[5];
|
||
|
state[5] = state[1];
|
||
|
state[1] = t;
|
||
|
t = state[14];
|
||
|
u = state[10];
|
||
|
state[14] = state[6];
|
||
|
state[10] = state[2];
|
||
|
state[6] = t;
|
||
|
state[2] = u;
|
||
|
t = state[15];
|
||
|
u = state[11];
|
||
|
v = state[7];
|
||
|
state[15] = state[3];
|
||
|
state[11] = t;
|
||
|
state[7] = u;
|
||
|
state[3] = v;
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] = inv_s[state[j]];
|
||
|
}
|
||
|
for (j = 0, k = i * 16; j < 16; ++j, ++k) {
|
||
|
state[j] ^= key[k];
|
||
|
}
|
||
|
for (j = 0; j < 16; j += 4) {
|
||
|
var s0 = mix[state[j]], s1 = mix[state[j + 1]], s2 = mix[state[j + 2]], s3 = mix[state[j + 3]];
|
||
|
t = s0 ^ s1 >>> 8 ^ s1 << 24 ^ s2 >>> 16 ^ s2 << 16 ^ s3 >>> 24 ^ s3 << 8;
|
||
|
state[j] = t >>> 24 & 0xFF;
|
||
|
state[j + 1] = t >> 16 & 0xFF;
|
||
|
state[j + 2] = t >> 8 & 0xFF;
|
||
|
state[j + 3] = t & 0xFF;
|
||
|
}
|
||
|
}
|
||
|
t = state[13];
|
||
|
state[13] = state[9];
|
||
|
state[9] = state[5];
|
||
|
state[5] = state[1];
|
||
|
state[1] = t;
|
||
|
t = state[14];
|
||
|
u = state[10];
|
||
|
state[14] = state[6];
|
||
|
state[10] = state[2];
|
||
|
state[6] = t;
|
||
|
state[2] = u;
|
||
|
t = state[15];
|
||
|
u = state[11];
|
||
|
v = state[7];
|
||
|
state[15] = state[3];
|
||
|
state[11] = t;
|
||
|
state[7] = u;
|
||
|
state[3] = v;
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] = inv_s[state[j]];
|
||
|
state[j] ^= key[j];
|
||
|
}
|
||
|
return state;
|
||
|
}
|
||
|
function encrypt128(input, key) {
|
||
|
var t, u, v, k;
|
||
|
var state = new Uint8Array(16);
|
||
|
state.set(input);
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] ^= key[j];
|
||
|
}
|
||
|
for (i = 1; i < 10; i++) {
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] = s[state[j]];
|
||
|
}
|
||
|
v = state[1];
|
||
|
state[1] = state[5];
|
||
|
state[5] = state[9];
|
||
|
state[9] = state[13];
|
||
|
state[13] = v;
|
||
|
v = state[2];
|
||
|
u = state[6];
|
||
|
state[2] = state[10];
|
||
|
state[6] = state[14];
|
||
|
state[10] = v;
|
||
|
state[14] = u;
|
||
|
v = state[3];
|
||
|
u = state[7];
|
||
|
t = state[11];
|
||
|
state[3] = state[15];
|
||
|
state[7] = v;
|
||
|
state[11] = u;
|
||
|
state[15] = t;
|
||
|
for (var j = 0; j < 16; j += 4) {
|
||
|
var s0 = state[j + 0], s1 = state[j + 1];
|
||
|
var s2 = state[j + 2], s3 = state[j + 3];
|
||
|
t = s0 ^ s1 ^ s2 ^ s3;
|
||
|
state[j + 0] ^= t ^ mixCol[s0 ^ s1];
|
||
|
state[j + 1] ^= t ^ mixCol[s1 ^ s2];
|
||
|
state[j + 2] ^= t ^ mixCol[s2 ^ s3];
|
||
|
state[j + 3] ^= t ^ mixCol[s3 ^ s0];
|
||
|
}
|
||
|
for (j = 0, k = i * 16; j < 16; ++j, ++k) {
|
||
|
state[j] ^= key[k];
|
||
|
}
|
||
|
}
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] = s[state[j]];
|
||
|
}
|
||
|
v = state[1];
|
||
|
state[1] = state[5];
|
||
|
state[5] = state[9];
|
||
|
state[9] = state[13];
|
||
|
state[13] = v;
|
||
|
v = state[2];
|
||
|
u = state[6];
|
||
|
state[2] = state[10];
|
||
|
state[6] = state[14];
|
||
|
state[10] = v;
|
||
|
state[14] = u;
|
||
|
v = state[3];
|
||
|
u = state[7];
|
||
|
t = state[11];
|
||
|
state[3] = state[15];
|
||
|
state[7] = v;
|
||
|
state[11] = u;
|
||
|
state[15] = t;
|
||
|
for (j = 0, k = 160; j < 16; ++j, ++k) {
|
||
|
state[j] ^= key[k];
|
||
|
}
|
||
|
return state;
|
||
|
}
|
||
|
function AES128Cipher(key) {
|
||
|
this.key = expandKey128(key);
|
||
|
this.buffer = new Uint8Array(16);
|
||
|
this.bufferPosition = 0;
|
||
|
}
|
||
|
function decryptBlock2(data, finalize) {
|
||
|
var i, j, ii, sourceLength = data.length, buffer = this.buffer, bufferLength = this.bufferPosition, result = [], iv = this.iv;
|
||
|
for (i = 0; i < sourceLength; ++i) {
|
||
|
buffer[bufferLength] = data[i];
|
||
|
++bufferLength;
|
||
|
if (bufferLength < 16) {
|
||
|
continue;
|
||
|
}
|
||
|
var plain = decrypt128(buffer, this.key);
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
plain[j] ^= iv[j];
|
||
|
}
|
||
|
iv = buffer;
|
||
|
result.push(plain);
|
||
|
buffer = new Uint8Array(16);
|
||
|
bufferLength = 0;
|
||
|
}
|
||
|
this.buffer = buffer;
|
||
|
this.bufferLength = bufferLength;
|
||
|
this.iv = iv;
|
||
|
if (result.length === 0) {
|
||
|
return new Uint8Array([]);
|
||
|
}
|
||
|
var outputLength = 16 * result.length;
|
||
|
if (finalize) {
|
||
|
var lastBlock = result[result.length - 1];
|
||
|
var psLen = lastBlock[15];
|
||
|
if (psLen <= 16) {
|
||
|
for (i = 15, ii = 16 - psLen; i >= ii; --i) {
|
||
|
if (lastBlock[i] !== psLen) {
|
||
|
psLen = 0;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
outputLength -= psLen;
|
||
|
result[result.length - 1] = lastBlock.subarray(0, 16 - psLen);
|
||
|
}
|
||
|
}
|
||
|
var output = new Uint8Array(outputLength);
|
||
|
for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
|
||
|
output.set(result[i], j);
|
||
|
}
|
||
|
return output;
|
||
|
}
|
||
|
AES128Cipher.prototype = {
|
||
|
decryptBlock: function AES128Cipher_decryptBlock(data, finalize) {
|
||
|
var i, sourceLength = data.length;
|
||
|
var buffer = this.buffer, bufferLength = this.bufferPosition;
|
||
|
for (i = 0; bufferLength < 16 && i < sourceLength; ++i, ++bufferLength) {
|
||
|
buffer[bufferLength] = data[i];
|
||
|
}
|
||
|
if (bufferLength < 16) {
|
||
|
this.bufferLength = bufferLength;
|
||
|
return new Uint8Array([]);
|
||
|
}
|
||
|
this.iv = buffer;
|
||
|
this.buffer = new Uint8Array(16);
|
||
|
this.bufferLength = 0;
|
||
|
this.decryptBlock = decryptBlock2;
|
||
|
return this.decryptBlock(data.subarray(16), finalize);
|
||
|
},
|
||
|
encrypt: function AES128Cipher_encrypt(data, iv) {
|
||
|
var i, j, ii, sourceLength = data.length, buffer = this.buffer, bufferLength = this.bufferPosition, result = [];
|
||
|
if (!iv) {
|
||
|
iv = new Uint8Array(16);
|
||
|
}
|
||
|
for (i = 0; i < sourceLength; ++i) {
|
||
|
buffer[bufferLength] = data[i];
|
||
|
++bufferLength;
|
||
|
if (bufferLength < 16) {
|
||
|
continue;
|
||
|
}
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
buffer[j] ^= iv[j];
|
||
|
}
|
||
|
var cipher = encrypt128(buffer, this.key);
|
||
|
iv = cipher;
|
||
|
result.push(cipher);
|
||
|
buffer = new Uint8Array(16);
|
||
|
bufferLength = 0;
|
||
|
}
|
||
|
this.buffer = buffer;
|
||
|
this.bufferLength = bufferLength;
|
||
|
this.iv = iv;
|
||
|
if (result.length === 0) {
|
||
|
return new Uint8Array([]);
|
||
|
}
|
||
|
var outputLength = 16 * result.length;
|
||
|
var output = new Uint8Array(outputLength);
|
||
|
for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
|
||
|
output.set(result[i], j);
|
||
|
}
|
||
|
return output;
|
||
|
}
|
||
|
};
|
||
|
return AES128Cipher;
|
||
|
}();
|
||
|
var AES256Cipher = function AES256CipherClosure() {
|
||
|
var s = new Uint8Array([
|
||
|
0x63,
|
||
|
0x7c,
|
||
|
0x77,
|
||
|
0x7b,
|
||
|
0xf2,
|
||
|
0x6b,
|
||
|
0x6f,
|
||
|
0xc5,
|
||
|
0x30,
|
||
|
0x01,
|
||
|
0x67,
|
||
|
0x2b,
|
||
|
0xfe,
|
||
|
0xd7,
|
||
|
0xab,
|
||
|
0x76,
|
||
|
0xca,
|
||
|
0x82,
|
||
|
0xc9,
|
||
|
0x7d,
|
||
|
0xfa,
|
||
|
0x59,
|
||
|
0x47,
|
||
|
0xf0,
|
||
|
0xad,
|
||
|
0xd4,
|
||
|
0xa2,
|
||
|
0xaf,
|
||
|
0x9c,
|
||
|
0xa4,
|
||
|
0x72,
|
||
|
0xc0,
|
||
|
0xb7,
|
||
|
0xfd,
|
||
|
0x93,
|
||
|
0x26,
|
||
|
0x36,
|
||
|
0x3f,
|
||
|
0xf7,
|
||
|
0xcc,
|
||
|
0x34,
|
||
|
0xa5,
|
||
|
0xe5,
|
||
|
0xf1,
|
||
|
0x71,
|
||
|
0xd8,
|
||
|
0x31,
|
||
|
0x15,
|
||
|
0x04,
|
||
|
0xc7,
|
||
|
0x23,
|
||
|
0xc3,
|
||
|
0x18,
|
||
|
0x96,
|
||
|
0x05,
|
||
|
0x9a,
|
||
|
0x07,
|
||
|
0x12,
|
||
|
0x80,
|
||
|
0xe2,
|
||
|
0xeb,
|
||
|
0x27,
|
||
|
0xb2,
|
||
|
0x75,
|
||
|
0x09,
|
||
|
0x83,
|
||
|
0x2c,
|
||
|
0x1a,
|
||
|
0x1b,
|
||
|
0x6e,
|
||
|
0x5a,
|
||
|
0xa0,
|
||
|
0x52,
|
||
|
0x3b,
|
||
|
0xd6,
|
||
|
0xb3,
|
||
|
0x29,
|
||
|
0xe3,
|
||
|
0x2f,
|
||
|
0x84,
|
||
|
0x53,
|
||
|
0xd1,
|
||
|
0x00,
|
||
|
0xed,
|
||
|
0x20,
|
||
|
0xfc,
|
||
|
0xb1,
|
||
|
0x5b,
|
||
|
0x6a,
|
||
|
0xcb,
|
||
|
0xbe,
|
||
|
0x39,
|
||
|
0x4a,
|
||
|
0x4c,
|
||
|
0x58,
|
||
|
0xcf,
|
||
|
0xd0,
|
||
|
0xef,
|
||
|
0xaa,
|
||
|
0xfb,
|
||
|
0x43,
|
||
|
0x4d,
|
||
|
0x33,
|
||
|
0x85,
|
||
|
0x45,
|
||
|
0xf9,
|
||
|
0x02,
|
||
|
0x7f,
|
||
|
0x50,
|
||
|
0x3c,
|
||
|
0x9f,
|
||
|
0xa8,
|
||
|
0x51,
|
||
|
0xa3,
|
||
|
0x40,
|
||
|
0x8f,
|
||
|
0x92,
|
||
|
0x9d,
|
||
|
0x38,
|
||
|
0xf5,
|
||
|
0xbc,
|
||
|
0xb6,
|
||
|
0xda,
|
||
|
0x21,
|
||
|
0x10,
|
||
|
0xff,
|
||
|
0xf3,
|
||
|
0xd2,
|
||
|
0xcd,
|
||
|
0x0c,
|
||
|
0x13,
|
||
|
0xec,
|
||
|
0x5f,
|
||
|
0x97,
|
||
|
0x44,
|
||
|
0x17,
|
||
|
0xc4,
|
||
|
0xa7,
|
||
|
0x7e,
|
||
|
0x3d,
|
||
|
0x64,
|
||
|
0x5d,
|
||
|
0x19,
|
||
|
0x73,
|
||
|
0x60,
|
||
|
0x81,
|
||
|
0x4f,
|
||
|
0xdc,
|
||
|
0x22,
|
||
|
0x2a,
|
||
|
0x90,
|
||
|
0x88,
|
||
|
0x46,
|
||
|
0xee,
|
||
|
0xb8,
|
||
|
0x14,
|
||
|
0xde,
|
||
|
0x5e,
|
||
|
0x0b,
|
||
|
0xdb,
|
||
|
0xe0,
|
||
|
0x32,
|
||
|
0x3a,
|
||
|
0x0a,
|
||
|
0x49,
|
||
|
0x06,
|
||
|
0x24,
|
||
|
0x5c,
|
||
|
0xc2,
|
||
|
0xd3,
|
||
|
0xac,
|
||
|
0x62,
|
||
|
0x91,
|
||
|
0x95,
|
||
|
0xe4,
|
||
|
0x79,
|
||
|
0xe7,
|
||
|
0xc8,
|
||
|
0x37,
|
||
|
0x6d,
|
||
|
0x8d,
|
||
|
0xd5,
|
||
|
0x4e,
|
||
|
0xa9,
|
||
|
0x6c,
|
||
|
0x56,
|
||
|
0xf4,
|
||
|
0xea,
|
||
|
0x65,
|
||
|
0x7a,
|
||
|
0xae,
|
||
|
0x08,
|
||
|
0xba,
|
||
|
0x78,
|
||
|
0x25,
|
||
|
0x2e,
|
||
|
0x1c,
|
||
|
0xa6,
|
||
|
0xb4,
|
||
|
0xc6,
|
||
|
0xe8,
|
||
|
0xdd,
|
||
|
0x74,
|
||
|
0x1f,
|
||
|
0x4b,
|
||
|
0xbd,
|
||
|
0x8b,
|
||
|
0x8a,
|
||
|
0x70,
|
||
|
0x3e,
|
||
|
0xb5,
|
||
|
0x66,
|
||
|
0x48,
|
||
|
0x03,
|
||
|
0xf6,
|
||
|
0x0e,
|
||
|
0x61,
|
||
|
0x35,
|
||
|
0x57,
|
||
|
0xb9,
|
||
|
0x86,
|
||
|
0xc1,
|
||
|
0x1d,
|
||
|
0x9e,
|
||
|
0xe1,
|
||
|
0xf8,
|
||
|
0x98,
|
||
|
0x11,
|
||
|
0x69,
|
||
|
0xd9,
|
||
|
0x8e,
|
||
|
0x94,
|
||
|
0x9b,
|
||
|
0x1e,
|
||
|
0x87,
|
||
|
0xe9,
|
||
|
0xce,
|
||
|
0x55,
|
||
|
0x28,
|
||
|
0xdf,
|
||
|
0x8c,
|
||
|
0xa1,
|
||
|
0x89,
|
||
|
0x0d,
|
||
|
0xbf,
|
||
|
0xe6,
|
||
|
0x42,
|
||
|
0x68,
|
||
|
0x41,
|
||
|
0x99,
|
||
|
0x2d,
|
||
|
0x0f,
|
||
|
0xb0,
|
||
|
0x54,
|
||
|
0xbb,
|
||
|
0x16
|
||
|
]);
|
||
|
var inv_s = new Uint8Array([
|
||
|
0x52,
|
||
|
0x09,
|
||
|
0x6a,
|
||
|
0xd5,
|
||
|
0x30,
|
||
|
0x36,
|
||
|
0xa5,
|
||
|
0x38,
|
||
|
0xbf,
|
||
|
0x40,
|
||
|
0xa3,
|
||
|
0x9e,
|
||
|
0x81,
|
||
|
0xf3,
|
||
|
0xd7,
|
||
|
0xfb,
|
||
|
0x7c,
|
||
|
0xe3,
|
||
|
0x39,
|
||
|
0x82,
|
||
|
0x9b,
|
||
|
0x2f,
|
||
|
0xff,
|
||
|
0x87,
|
||
|
0x34,
|
||
|
0x8e,
|
||
|
0x43,
|
||
|
0x44,
|
||
|
0xc4,
|
||
|
0xde,
|
||
|
0xe9,
|
||
|
0xcb,
|
||
|
0x54,
|
||
|
0x7b,
|
||
|
0x94,
|
||
|
0x32,
|
||
|
0xa6,
|
||
|
0xc2,
|
||
|
0x23,
|
||
|
0x3d,
|
||
|
0xee,
|
||
|
0x4c,
|
||
|
0x95,
|
||
|
0x0b,
|
||
|
0x42,
|
||
|
0xfa,
|
||
|
0xc3,
|
||
|
0x4e,
|
||
|
0x08,
|
||
|
0x2e,
|
||
|
0xa1,
|
||
|
0x66,
|
||
|
0x28,
|
||
|
0xd9,
|
||
|
0x24,
|
||
|
0xb2,
|
||
|
0x76,
|
||
|
0x5b,
|
||
|
0xa2,
|
||
|
0x49,
|
||
|
0x6d,
|
||
|
0x8b,
|
||
|
0xd1,
|
||
|
0x25,
|
||
|
0x72,
|
||
|
0xf8,
|
||
|
0xf6,
|
||
|
0x64,
|
||
|
0x86,
|
||
|
0x68,
|
||
|
0x98,
|
||
|
0x16,
|
||
|
0xd4,
|
||
|
0xa4,
|
||
|
0x5c,
|
||
|
0xcc,
|
||
|
0x5d,
|
||
|
0x65,
|
||
|
0xb6,
|
||
|
0x92,
|
||
|
0x6c,
|
||
|
0x70,
|
||
|
0x48,
|
||
|
0x50,
|
||
|
0xfd,
|
||
|
0xed,
|
||
|
0xb9,
|
||
|
0xda,
|
||
|
0x5e,
|
||
|
0x15,
|
||
|
0x46,
|
||
|
0x57,
|
||
|
0xa7,
|
||
|
0x8d,
|
||
|
0x9d,
|
||
|
0x84,
|
||
|
0x90,
|
||
|
0xd8,
|
||
|
0xab,
|
||
|
0x00,
|
||
|
0x8c,
|
||
|
0xbc,
|
||
|
0xd3,
|
||
|
0x0a,
|
||
|
0xf7,
|
||
|
0xe4,
|
||
|
0x58,
|
||
|
0x05,
|
||
|
0xb8,
|
||
|
0xb3,
|
||
|
0x45,
|
||
|
0x06,
|
||
|
0xd0,
|
||
|
0x2c,
|
||
|
0x1e,
|
||
|
0x8f,
|
||
|
0xca,
|
||
|
0x3f,
|
||
|
0x0f,
|
||
|
0x02,
|
||
|
0xc1,
|
||
|
0xaf,
|
||
|
0xbd,
|
||
|
0x03,
|
||
|
0x01,
|
||
|
0x13,
|
||
|
0x8a,
|
||
|
0x6b,
|
||
|
0x3a,
|
||
|
0x91,
|
||
|
0x11,
|
||
|
0x41,
|
||
|
0x4f,
|
||
|
0x67,
|
||
|
0xdc,
|
||
|
0xea,
|
||
|
0x97,
|
||
|
0xf2,
|
||
|
0xcf,
|
||
|
0xce,
|
||
|
0xf0,
|
||
|
0xb4,
|
||
|
0xe6,
|
||
|
0x73,
|
||
|
0x96,
|
||
|
0xac,
|
||
|
0x74,
|
||
|
0x22,
|
||
|
0xe7,
|
||
|
0xad,
|
||
|
0x35,
|
||
|
0x85,
|
||
|
0xe2,
|
||
|
0xf9,
|
||
|
0x37,
|
||
|
0xe8,
|
||
|
0x1c,
|
||
|
0x75,
|
||
|
0xdf,
|
||
|
0x6e,
|
||
|
0x47,
|
||
|
0xf1,
|
||
|
0x1a,
|
||
|
0x71,
|
||
|
0x1d,
|
||
|
0x29,
|
||
|
0xc5,
|
||
|
0x89,
|
||
|
0x6f,
|
||
|
0xb7,
|
||
|
0x62,
|
||
|
0x0e,
|
||
|
0xaa,
|
||
|
0x18,
|
||
|
0xbe,
|
||
|
0x1b,
|
||
|
0xfc,
|
||
|
0x56,
|
||
|
0x3e,
|
||
|
0x4b,
|
||
|
0xc6,
|
||
|
0xd2,
|
||
|
0x79,
|
||
|
0x20,
|
||
|
0x9a,
|
||
|
0xdb,
|
||
|
0xc0,
|
||
|
0xfe,
|
||
|
0x78,
|
||
|
0xcd,
|
||
|
0x5a,
|
||
|
0xf4,
|
||
|
0x1f,
|
||
|
0xdd,
|
||
|
0xa8,
|
||
|
0x33,
|
||
|
0x88,
|
||
|
0x07,
|
||
|
0xc7,
|
||
|
0x31,
|
||
|
0xb1,
|
||
|
0x12,
|
||
|
0x10,
|
||
|
0x59,
|
||
|
0x27,
|
||
|
0x80,
|
||
|
0xec,
|
||
|
0x5f,
|
||
|
0x60,
|
||
|
0x51,
|
||
|
0x7f,
|
||
|
0xa9,
|
||
|
0x19,
|
||
|
0xb5,
|
||
|
0x4a,
|
||
|
0x0d,
|
||
|
0x2d,
|
||
|
0xe5,
|
||
|
0x7a,
|
||
|
0x9f,
|
||
|
0x93,
|
||
|
0xc9,
|
||
|
0x9c,
|
||
|
0xef,
|
||
|
0xa0,
|
||
|
0xe0,
|
||
|
0x3b,
|
||
|
0x4d,
|
||
|
0xae,
|
||
|
0x2a,
|
||
|
0xf5,
|
||
|
0xb0,
|
||
|
0xc8,
|
||
|
0xeb,
|
||
|
0xbb,
|
||
|
0x3c,
|
||
|
0x83,
|
||
|
0x53,
|
||
|
0x99,
|
||
|
0x61,
|
||
|
0x17,
|
||
|
0x2b,
|
||
|
0x04,
|
||
|
0x7e,
|
||
|
0xba,
|
||
|
0x77,
|
||
|
0xd6,
|
||
|
0x26,
|
||
|
0xe1,
|
||
|
0x69,
|
||
|
0x14,
|
||
|
0x63,
|
||
|
0x55,
|
||
|
0x21,
|
||
|
0x0c,
|
||
|
0x7d
|
||
|
]);
|
||
|
var mixCol = new Uint8Array(256);
|
||
|
for (var i = 0; i < 256; i++) {
|
||
|
if (i < 128) {
|
||
|
mixCol[i] = i << 1;
|
||
|
} else {
|
||
|
mixCol[i] = i << 1 ^ 0x1b;
|
||
|
}
|
||
|
}
|
||
|
var mix = new Uint32Array([
|
||
|
0x00000000,
|
||
|
0x0e090d0b,
|
||
|
0x1c121a16,
|
||
|
0x121b171d,
|
||
|
0x3824342c,
|
||
|
0x362d3927,
|
||
|
0x24362e3a,
|
||
|
0x2a3f2331,
|
||
|
0x70486858,
|
||
|
0x7e416553,
|
||
|
0x6c5a724e,
|
||
|
0x62537f45,
|
||
|
0x486c5c74,
|
||
|
0x4665517f,
|
||
|
0x547e4662,
|
||
|
0x5a774b69,
|
||
|
0xe090d0b0,
|
||
|
0xee99ddbb,
|
||
|
0xfc82caa6,
|
||
|
0xf28bc7ad,
|
||
|
0xd8b4e49c,
|
||
|
0xd6bde997,
|
||
|
0xc4a6fe8a,
|
||
|
0xcaaff381,
|
||
|
0x90d8b8e8,
|
||
|
0x9ed1b5e3,
|
||
|
0x8ccaa2fe,
|
||
|
0x82c3aff5,
|
||
|
0xa8fc8cc4,
|
||
|
0xa6f581cf,
|
||
|
0xb4ee96d2,
|
||
|
0xbae79bd9,
|
||
|
0xdb3bbb7b,
|
||
|
0xd532b670,
|
||
|
0xc729a16d,
|
||
|
0xc920ac66,
|
||
|
0xe31f8f57,
|
||
|
0xed16825c,
|
||
|
0xff0d9541,
|
||
|
0xf104984a,
|
||
|
0xab73d323,
|
||
|
0xa57ade28,
|
||
|
0xb761c935,
|
||
|
0xb968c43e,
|
||
|
0x9357e70f,
|
||
|
0x9d5eea04,
|
||
|
0x8f45fd19,
|
||
|
0x814cf012,
|
||
|
0x3bab6bcb,
|
||
|
0x35a266c0,
|
||
|
0x27b971dd,
|
||
|
0x29b07cd6,
|
||
|
0x038f5fe7,
|
||
|
0x0d8652ec,
|
||
|
0x1f9d45f1,
|
||
|
0x119448fa,
|
||
|
0x4be30393,
|
||
|
0x45ea0e98,
|
||
|
0x57f11985,
|
||
|
0x59f8148e,
|
||
|
0x73c737bf,
|
||
|
0x7dce3ab4,
|
||
|
0x6fd52da9,
|
||
|
0x61dc20a2,
|
||
|
0xad766df6,
|
||
|
0xa37f60fd,
|
||
|
0xb16477e0,
|
||
|
0xbf6d7aeb,
|
||
|
0x955259da,
|
||
|
0x9b5b54d1,
|
||
|
0x894043cc,
|
||
|
0x87494ec7,
|
||
|
0xdd3e05ae,
|
||
|
0xd33708a5,
|
||
|
0xc12c1fb8,
|
||
|
0xcf2512b3,
|
||
|
0xe51a3182,
|
||
|
0xeb133c89,
|
||
|
0xf9082b94,
|
||
|
0xf701269f,
|
||
|
0x4de6bd46,
|
||
|
0x43efb04d,
|
||
|
0x51f4a750,
|
||
|
0x5ffdaa5b,
|
||
|
0x75c2896a,
|
||
|
0x7bcb8461,
|
||
|
0x69d0937c,
|
||
|
0x67d99e77,
|
||
|
0x3daed51e,
|
||
|
0x33a7d815,
|
||
|
0x21bccf08,
|
||
|
0x2fb5c203,
|
||
|
0x058ae132,
|
||
|
0x0b83ec39,
|
||
|
0x1998fb24,
|
||
|
0x1791f62f,
|
||
|
0x764dd68d,
|
||
|
0x7844db86,
|
||
|
0x6a5fcc9b,
|
||
|
0x6456c190,
|
||
|
0x4e69e2a1,
|
||
|
0x4060efaa,
|
||
|
0x527bf8b7,
|
||
|
0x5c72f5bc,
|
||
|
0x0605bed5,
|
||
|
0x080cb3de,
|
||
|
0x1a17a4c3,
|
||
|
0x141ea9c8,
|
||
|
0x3e218af9,
|
||
|
0x302887f2,
|
||
|
0x223390ef,
|
||
|
0x2c3a9de4,
|
||
|
0x96dd063d,
|
||
|
0x98d40b36,
|
||
|
0x8acf1c2b,
|
||
|
0x84c61120,
|
||
|
0xaef93211,
|
||
|
0xa0f03f1a,
|
||
|
0xb2eb2807,
|
||
|
0xbce2250c,
|
||
|
0xe6956e65,
|
||
|
0xe89c636e,
|
||
|
0xfa877473,
|
||
|
0xf48e7978,
|
||
|
0xdeb15a49,
|
||
|
0xd0b85742,
|
||
|
0xc2a3405f,
|
||
|
0xccaa4d54,
|
||
|
0x41ecdaf7,
|
||
|
0x4fe5d7fc,
|
||
|
0x5dfec0e1,
|
||
|
0x53f7cdea,
|
||
|
0x79c8eedb,
|
||
|
0x77c1e3d0,
|
||
|
0x65daf4cd,
|
||
|
0x6bd3f9c6,
|
||
|
0x31a4b2af,
|
||
|
0x3fadbfa4,
|
||
|
0x2db6a8b9,
|
||
|
0x23bfa5b2,
|
||
|
0x09808683,
|
||
|
0x07898b88,
|
||
|
0x15929c95,
|
||
|
0x1b9b919e,
|
||
|
0xa17c0a47,
|
||
|
0xaf75074c,
|
||
|
0xbd6e1051,
|
||
|
0xb3671d5a,
|
||
|
0x99583e6b,
|
||
|
0x97513360,
|
||
|
0x854a247d,
|
||
|
0x8b432976,
|
||
|
0xd134621f,
|
||
|
0xdf3d6f14,
|
||
|
0xcd267809,
|
||
|
0xc32f7502,
|
||
|
0xe9105633,
|
||
|
0xe7195b38,
|
||
|
0xf5024c25,
|
||
|
0xfb0b412e,
|
||
|
0x9ad7618c,
|
||
|
0x94de6c87,
|
||
|
0x86c57b9a,
|
||
|
0x88cc7691,
|
||
|
0xa2f355a0,
|
||
|
0xacfa58ab,
|
||
|
0xbee14fb6,
|
||
|
0xb0e842bd,
|
||
|
0xea9f09d4,
|
||
|
0xe49604df,
|
||
|
0xf68d13c2,
|
||
|
0xf8841ec9,
|
||
|
0xd2bb3df8,
|
||
|
0xdcb230f3,
|
||
|
0xcea927ee,
|
||
|
0xc0a02ae5,
|
||
|
0x7a47b13c,
|
||
|
0x744ebc37,
|
||
|
0x6655ab2a,
|
||
|
0x685ca621,
|
||
|
0x42638510,
|
||
|
0x4c6a881b,
|
||
|
0x5e719f06,
|
||
|
0x5078920d,
|
||
|
0x0a0fd964,
|
||
|
0x0406d46f,
|
||
|
0x161dc372,
|
||
|
0x1814ce79,
|
||
|
0x322bed48,
|
||
|
0x3c22e043,
|
||
|
0x2e39f75e,
|
||
|
0x2030fa55,
|
||
|
0xec9ab701,
|
||
|
0xe293ba0a,
|
||
|
0xf088ad17,
|
||
|
0xfe81a01c,
|
||
|
0xd4be832d,
|
||
|
0xdab78e26,
|
||
|
0xc8ac993b,
|
||
|
0xc6a59430,
|
||
|
0x9cd2df59,
|
||
|
0x92dbd252,
|
||
|
0x80c0c54f,
|
||
|
0x8ec9c844,
|
||
|
0xa4f6eb75,
|
||
|
0xaaffe67e,
|
||
|
0xb8e4f163,
|
||
|
0xb6edfc68,
|
||
|
0x0c0a67b1,
|
||
|
0x02036aba,
|
||
|
0x10187da7,
|
||
|
0x1e1170ac,
|
||
|
0x342e539d,
|
||
|
0x3a275e96,
|
||
|
0x283c498b,
|
||
|
0x26354480,
|
||
|
0x7c420fe9,
|
||
|
0x724b02e2,
|
||
|
0x605015ff,
|
||
|
0x6e5918f4,
|
||
|
0x44663bc5,
|
||
|
0x4a6f36ce,
|
||
|
0x587421d3,
|
||
|
0x567d2cd8,
|
||
|
0x37a10c7a,
|
||
|
0x39a80171,
|
||
|
0x2bb3166c,
|
||
|
0x25ba1b67,
|
||
|
0x0f853856,
|
||
|
0x018c355d,
|
||
|
0x13972240,
|
||
|
0x1d9e2f4b,
|
||
|
0x47e96422,
|
||
|
0x49e06929,
|
||
|
0x5bfb7e34,
|
||
|
0x55f2733f,
|
||
|
0x7fcd500e,
|
||
|
0x71c45d05,
|
||
|
0x63df4a18,
|
||
|
0x6dd64713,
|
||
|
0xd731dcca,
|
||
|
0xd938d1c1,
|
||
|
0xcb23c6dc,
|
||
|
0xc52acbd7,
|
||
|
0xef15e8e6,
|
||
|
0xe11ce5ed,
|
||
|
0xf307f2f0,
|
||
|
0xfd0efffb,
|
||
|
0xa779b492,
|
||
|
0xa970b999,
|
||
|
0xbb6bae84,
|
||
|
0xb562a38f,
|
||
|
0x9f5d80be,
|
||
|
0x91548db5,
|
||
|
0x834f9aa8,
|
||
|
0x8d4697a3
|
||
|
]);
|
||
|
function expandKey256(cipherKey) {
|
||
|
var b = 240, result = new Uint8Array(b);
|
||
|
var r = 1;
|
||
|
result.set(cipherKey);
|
||
|
for (var j = 32, i = 1; j < b; ++i) {
|
||
|
if (j % 32 === 16) {
|
||
|
t1 = s[t1];
|
||
|
t2 = s[t2];
|
||
|
t3 = s[t3];
|
||
|
t4 = s[t4];
|
||
|
} else if (j % 32 === 0) {
|
||
|
var t1 = result[j - 3], t2 = result[j - 2], t3 = result[j - 1], t4 = result[j - 4];
|
||
|
t1 = s[t1];
|
||
|
t2 = s[t2];
|
||
|
t3 = s[t3];
|
||
|
t4 = s[t4];
|
||
|
t1 = t1 ^ r;
|
||
|
if ((r <<= 1) >= 256) {
|
||
|
r = (r ^ 0x1b) & 0xFF;
|
||
|
}
|
||
|
}
|
||
|
for (var n = 0; n < 4; ++n) {
|
||
|
result[j] = t1 ^= result[j - 32];
|
||
|
j++;
|
||
|
result[j] = t2 ^= result[j - 32];
|
||
|
j++;
|
||
|
result[j] = t3 ^= result[j - 32];
|
||
|
j++;
|
||
|
result[j] = t4 ^= result[j - 32];
|
||
|
j++;
|
||
|
}
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
function decrypt256(input, key) {
|
||
|
var state = new Uint8Array(16);
|
||
|
state.set(input);
|
||
|
var i, j, k;
|
||
|
var t, u, v;
|
||
|
for (j = 0, k = 224; j < 16; ++j, ++k) {
|
||
|
state[j] ^= key[k];
|
||
|
}
|
||
|
for (i = 13; i >= 1; --i) {
|
||
|
t = state[13];
|
||
|
state[13] = state[9];
|
||
|
state[9] = state[5];
|
||
|
state[5] = state[1];
|
||
|
state[1] = t;
|
||
|
t = state[14];
|
||
|
u = state[10];
|
||
|
state[14] = state[6];
|
||
|
state[10] = state[2];
|
||
|
state[6] = t;
|
||
|
state[2] = u;
|
||
|
t = state[15];
|
||
|
u = state[11];
|
||
|
v = state[7];
|
||
|
state[15] = state[3];
|
||
|
state[11] = t;
|
||
|
state[7] = u;
|
||
|
state[3] = v;
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] = inv_s[state[j]];
|
||
|
}
|
||
|
for (j = 0, k = i * 16; j < 16; ++j, ++k) {
|
||
|
state[j] ^= key[k];
|
||
|
}
|
||
|
for (j = 0; j < 16; j += 4) {
|
||
|
var s0 = mix[state[j]], s1 = mix[state[j + 1]], s2 = mix[state[j + 2]], s3 = mix[state[j + 3]];
|
||
|
t = s0 ^ s1 >>> 8 ^ s1 << 24 ^ s2 >>> 16 ^ s2 << 16 ^ s3 >>> 24 ^ s3 << 8;
|
||
|
state[j] = t >>> 24 & 0xFF;
|
||
|
state[j + 1] = t >> 16 & 0xFF;
|
||
|
state[j + 2] = t >> 8 & 0xFF;
|
||
|
state[j + 3] = t & 0xFF;
|
||
|
}
|
||
|
}
|
||
|
t = state[13];
|
||
|
state[13] = state[9];
|
||
|
state[9] = state[5];
|
||
|
state[5] = state[1];
|
||
|
state[1] = t;
|
||
|
t = state[14];
|
||
|
u = state[10];
|
||
|
state[14] = state[6];
|
||
|
state[10] = state[2];
|
||
|
state[6] = t;
|
||
|
state[2] = u;
|
||
|
t = state[15];
|
||
|
u = state[11];
|
||
|
v = state[7];
|
||
|
state[15] = state[3];
|
||
|
state[11] = t;
|
||
|
state[7] = u;
|
||
|
state[3] = v;
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] = inv_s[state[j]];
|
||
|
state[j] ^= key[j];
|
||
|
}
|
||
|
return state;
|
||
|
}
|
||
|
function encrypt256(input, key) {
|
||
|
var t, u, v, k;
|
||
|
var state = new Uint8Array(16);
|
||
|
state.set(input);
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] ^= key[j];
|
||
|
}
|
||
|
for (i = 1; i < 14; i++) {
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] = s[state[j]];
|
||
|
}
|
||
|
v = state[1];
|
||
|
state[1] = state[5];
|
||
|
state[5] = state[9];
|
||
|
state[9] = state[13];
|
||
|
state[13] = v;
|
||
|
v = state[2];
|
||
|
u = state[6];
|
||
|
state[2] = state[10];
|
||
|
state[6] = state[14];
|
||
|
state[10] = v;
|
||
|
state[14] = u;
|
||
|
v = state[3];
|
||
|
u = state[7];
|
||
|
t = state[11];
|
||
|
state[3] = state[15];
|
||
|
state[7] = v;
|
||
|
state[11] = u;
|
||
|
state[15] = t;
|
||
|
for (var j = 0; j < 16; j += 4) {
|
||
|
var s0 = state[j + 0], s1 = state[j + 1];
|
||
|
var s2 = state[j + 2], s3 = state[j + 3];
|
||
|
t = s0 ^ s1 ^ s2 ^ s3;
|
||
|
state[j + 0] ^= t ^ mixCol[s0 ^ s1];
|
||
|
state[j + 1] ^= t ^ mixCol[s1 ^ s2];
|
||
|
state[j + 2] ^= t ^ mixCol[s2 ^ s3];
|
||
|
state[j + 3] ^= t ^ mixCol[s3 ^ s0];
|
||
|
}
|
||
|
for (j = 0, k = i * 16; j < 16; ++j, ++k) {
|
||
|
state[j] ^= key[k];
|
||
|
}
|
||
|
}
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
state[j] = s[state[j]];
|
||
|
}
|
||
|
v = state[1];
|
||
|
state[1] = state[5];
|
||
|
state[5] = state[9];
|
||
|
state[9] = state[13];
|
||
|
state[13] = v;
|
||
|
v = state[2];
|
||
|
u = state[6];
|
||
|
state[2] = state[10];
|
||
|
state[6] = state[14];
|
||
|
state[10] = v;
|
||
|
state[14] = u;
|
||
|
v = state[3];
|
||
|
u = state[7];
|
||
|
t = state[11];
|
||
|
state[3] = state[15];
|
||
|
state[7] = v;
|
||
|
state[11] = u;
|
||
|
state[15] = t;
|
||
|
for (j = 0, k = 224; j < 16; ++j, ++k) {
|
||
|
state[j] ^= key[k];
|
||
|
}
|
||
|
return state;
|
||
|
}
|
||
|
function AES256Cipher(key) {
|
||
|
this.key = expandKey256(key);
|
||
|
this.buffer = new Uint8Array(16);
|
||
|
this.bufferPosition = 0;
|
||
|
}
|
||
|
function decryptBlock2(data, finalize) {
|
||
|
var i, j, ii, sourceLength = data.length, buffer = this.buffer, bufferLength = this.bufferPosition, result = [], iv = this.iv;
|
||
|
for (i = 0; i < sourceLength; ++i) {
|
||
|
buffer[bufferLength] = data[i];
|
||
|
++bufferLength;
|
||
|
if (bufferLength < 16) {
|
||
|
continue;
|
||
|
}
|
||
|
var plain = decrypt256(buffer, this.key);
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
plain[j] ^= iv[j];
|
||
|
}
|
||
|
iv = buffer;
|
||
|
result.push(plain);
|
||
|
buffer = new Uint8Array(16);
|
||
|
bufferLength = 0;
|
||
|
}
|
||
|
this.buffer = buffer;
|
||
|
this.bufferLength = bufferLength;
|
||
|
this.iv = iv;
|
||
|
if (result.length === 0) {
|
||
|
return new Uint8Array([]);
|
||
|
}
|
||
|
var outputLength = 16 * result.length;
|
||
|
if (finalize) {
|
||
|
var lastBlock = result[result.length - 1];
|
||
|
var psLen = lastBlock[15];
|
||
|
if (psLen <= 16) {
|
||
|
for (i = 15, ii = 16 - psLen; i >= ii; --i) {
|
||
|
if (lastBlock[i] !== psLen) {
|
||
|
psLen = 0;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
outputLength -= psLen;
|
||
|
result[result.length - 1] = lastBlock.subarray(0, 16 - psLen);
|
||
|
}
|
||
|
}
|
||
|
var output = new Uint8Array(outputLength);
|
||
|
for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
|
||
|
output.set(result[i], j);
|
||
|
}
|
||
|
return output;
|
||
|
}
|
||
|
AES256Cipher.prototype = {
|
||
|
decryptBlock: function AES256Cipher_decryptBlock(data, finalize, iv) {
|
||
|
var i, sourceLength = data.length;
|
||
|
var buffer = this.buffer, bufferLength = this.bufferPosition;
|
||
|
if (iv) {
|
||
|
this.iv = iv;
|
||
|
} else {
|
||
|
for (i = 0; bufferLength < 16 && i < sourceLength; ++i, ++bufferLength) {
|
||
|
buffer[bufferLength] = data[i];
|
||
|
}
|
||
|
if (bufferLength < 16) {
|
||
|
this.bufferLength = bufferLength;
|
||
|
return new Uint8Array([]);
|
||
|
}
|
||
|
this.iv = buffer;
|
||
|
data = data.subarray(16);
|
||
|
}
|
||
|
this.buffer = new Uint8Array(16);
|
||
|
this.bufferLength = 0;
|
||
|
this.decryptBlock = decryptBlock2;
|
||
|
return this.decryptBlock(data, finalize);
|
||
|
},
|
||
|
encrypt: function AES256Cipher_encrypt(data, iv) {
|
||
|
var i, j, ii, sourceLength = data.length, buffer = this.buffer, bufferLength = this.bufferPosition, result = [];
|
||
|
if (!iv) {
|
||
|
iv = new Uint8Array(16);
|
||
|
}
|
||
|
for (i = 0; i < sourceLength; ++i) {
|
||
|
buffer[bufferLength] = data[i];
|
||
|
++bufferLength;
|
||
|
if (bufferLength < 16) {
|
||
|
continue;
|
||
|
}
|
||
|
for (j = 0; j < 16; ++j) {
|
||
|
buffer[j] ^= iv[j];
|
||
|
}
|
||
|
var cipher = encrypt256(buffer, this.key);
|
||
|
this.iv = cipher;
|
||
|
result.push(cipher);
|
||
|
buffer = new Uint8Array(16);
|
||
|
bufferLength = 0;
|
||
|
}
|
||
|
this.buffer = buffer;
|
||
|
this.bufferLength = bufferLength;
|
||
|
this.iv = iv;
|
||
|
if (result.length === 0) {
|
||
|
return new Uint8Array([]);
|
||
|
}
|
||
|
var outputLength = 16 * result.length;
|
||
|
var output = new Uint8Array(outputLength);
|
||
|
for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
|
||
|
output.set(result[i], j);
|
||
|
}
|
||
|
return output;
|
||
|
}
|
||
|
};
|
||
|
return AES256Cipher;
|
||
|
}();
|
||
|
var PDF17 = function PDF17Closure() {
|
||
|
function compareByteArrays(array1, array2) {
|
||
|
if (array1.length !== array2.length) {
|
||
|
return false;
|
||
|
}
|
||
|
for (var i = 0; i < array1.length; i++) {
|
||
|
if (array1[i] !== array2[i]) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
function PDF17() {
|
||
|
}
|
||
|
PDF17.prototype = {
|
||
|
checkOwnerPassword: function PDF17_checkOwnerPassword(password, ownerValidationSalt, userBytes, ownerPassword) {
|
||
|
var hashData = new Uint8Array(password.length + 56);
|
||
|
hashData.set(password, 0);
|
||
|
hashData.set(ownerValidationSalt, password.length);
|
||
|
hashData.set(userBytes, password.length + ownerValidationSalt.length);
|
||
|
var result = calculateSHA256(hashData, 0, hashData.length);
|
||
|
return compareByteArrays(result, ownerPassword);
|
||
|
},
|
||
|
checkUserPassword: function PDF17_checkUserPassword(password, userValidationSalt, userPassword) {
|
||
|
var hashData = new Uint8Array(password.length + 8);
|
||
|
hashData.set(password, 0);
|
||
|
hashData.set(userValidationSalt, password.length);
|
||
|
var result = calculateSHA256(hashData, 0, hashData.length);
|
||
|
return compareByteArrays(result, userPassword);
|
||
|
},
|
||
|
getOwnerKey: function PDF17_getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
|
||
|
var hashData = new Uint8Array(password.length + 56);
|
||
|
hashData.set(password, 0);
|
||
|
hashData.set(ownerKeySalt, password.length);
|
||
|
hashData.set(userBytes, password.length + ownerKeySalt.length);
|
||
|
var key = calculateSHA256(hashData, 0, hashData.length);
|
||
|
var cipher = new AES256Cipher(key);
|
||
|
return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
|
||
|
},
|
||
|
getUserKey: function PDF17_getUserKey(password, userKeySalt, userEncryption) {
|
||
|
var hashData = new Uint8Array(password.length + 8);
|
||
|
hashData.set(password, 0);
|
||
|
hashData.set(userKeySalt, password.length);
|
||
|
var key = calculateSHA256(hashData, 0, hashData.length);
|
||
|
var cipher = new AES256Cipher(key);
|
||
|
return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
|
||
|
}
|
||
|
};
|
||
|
return PDF17;
|
||
|
}();
|
||
|
var PDF20 = function PDF20Closure() {
|
||
|
function concatArrays(array1, array2) {
|
||
|
var t = new Uint8Array(array1.length + array2.length);
|
||
|
t.set(array1, 0);
|
||
|
t.set(array2, array1.length);
|
||
|
return t;
|
||
|
}
|
||
|
function calculatePDF20Hash(password, input, userBytes) {
|
||
|
var k = calculateSHA256(input, 0, input.length).subarray(0, 32);
|
||
|
var e = [0];
|
||
|
var i = 0;
|
||
|
while (i < 64 || e[e.length - 1] > i - 32) {
|
||
|
var arrayLength = password.length + k.length + userBytes.length;
|
||
|
var k1 = new Uint8Array(arrayLength * 64);
|
||
|
var array = concatArrays(password, k);
|
||
|
array = concatArrays(array, userBytes);
|
||
|
for (var j = 0, pos = 0; j < 64; j++, pos += arrayLength) {
|
||
|
k1.set(array, pos);
|
||
|
}
|
||
|
var cipher = new AES128Cipher(k.subarray(0, 16));
|
||
|
e = cipher.encrypt(k1, k.subarray(16, 32));
|
||
|
var remainder = 0;
|
||
|
for (var z = 0; z < 16; z++) {
|
||
|
remainder *= 256 % 3;
|
||
|
remainder %= 3;
|
||
|
remainder += (e[z] >>> 0) % 3;
|
||
|
remainder %= 3;
|
||
|
}
|
||
|
if (remainder === 0) {
|
||
|
k = calculateSHA256(e, 0, e.length);
|
||
|
} else if (remainder === 1) {
|
||
|
k = calculateSHA384(e, 0, e.length);
|
||
|
} else if (remainder === 2) {
|
||
|
k = calculateSHA512(e, 0, e.length);
|
||
|
}
|
||
|
i++;
|
||
|
}
|
||
|
return k.subarray(0, 32);
|
||
|
}
|
||
|
function PDF20() {
|
||
|
}
|
||
|
function compareByteArrays(array1, array2) {
|
||
|
if (array1.length !== array2.length) {
|
||
|
return false;
|
||
|
}
|
||
|
for (var i = 0; i < array1.length; i++) {
|
||
|
if (array1[i] !== array2[i]) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
PDF20.prototype = {
|
||
|
hash: function PDF20_hash(password, concatBytes, userBytes) {
|
||
|
return calculatePDF20Hash(password, concatBytes, userBytes);
|
||
|
},
|
||
|
checkOwnerPassword: function PDF20_checkOwnerPassword(password, ownerValidationSalt, userBytes, ownerPassword) {
|
||
|
var hashData = new Uint8Array(password.length + 56);
|
||
|
hashData.set(password, 0);
|
||
|
hashData.set(ownerValidationSalt, password.length);
|
||
|
hashData.set(userBytes, password.length + ownerValidationSalt.length);
|
||
|
var result = calculatePDF20Hash(password, hashData, userBytes);
|
||
|
return compareByteArrays(result, ownerPassword);
|
||
|
},
|
||
|
checkUserPassword: function PDF20_checkUserPassword(password, userValidationSalt, userPassword) {
|
||
|
var hashData = new Uint8Array(password.length + 8);
|
||
|
hashData.set(password, 0);
|
||
|
hashData.set(userValidationSalt, password.length);
|
||
|
var result = calculatePDF20Hash(password, hashData, []);
|
||
|
return compareByteArrays(result, userPassword);
|
||
|
},
|
||
|
getOwnerKey: function PDF20_getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
|
||
|
var hashData = new Uint8Array(password.length + 56);
|
||
|
hashData.set(password, 0);
|
||
|
hashData.set(ownerKeySalt, password.length);
|
||
|
hashData.set(userBytes, password.length + ownerKeySalt.length);
|
||
|
var key = calculatePDF20Hash(password, hashData, userBytes);
|
||
|
var cipher = new AES256Cipher(key);
|
||
|
return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
|
||
|
},
|
||
|
getUserKey: function PDF20_getUserKey(password, userKeySalt, userEncryption) {
|
||
|
var hashData = new Uint8Array(password.length + 8);
|
||
|
hashData.set(password, 0);
|
||
|
hashData.set(userKeySalt, password.length);
|
||
|
var key = calculatePDF20Hash(password, hashData, []);
|
||
|
var cipher = new AES256Cipher(key);
|
||
|
return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
|
||
|
}
|
||
|
};
|
||
|
return PDF20;
|
||
|
}();
|
||
|
var CipherTransform = function CipherTransformClosure() {
|
||
|
function CipherTransform(stringCipherConstructor, streamCipherConstructor) {
|
||
|
this.StringCipherConstructor = stringCipherConstructor;
|
||
|
this.StreamCipherConstructor = streamCipherConstructor;
|
||
|
}
|
||
|
CipherTransform.prototype = {
|
||
|
createStream: function CipherTransform_createStream(stream, length) {
|
||
|
var cipher = new this.StreamCipherConstructor();
|
||
|
return new DecryptStream(stream, length, function cipherTransformDecryptStream(data, finalize) {
|
||
|
return cipher.decryptBlock(data, finalize);
|
||
|
});
|
||
|
},
|
||
|
decryptString: function CipherTransform_decryptString(s) {
|
||
|
var cipher = new this.StringCipherConstructor();
|
||
|
var data = stringToBytes(s);
|
||
|
data = cipher.decryptBlock(data, true);
|
||
|
return bytesToString(data);
|
||
|
}
|
||
|
};
|
||
|
return CipherTransform;
|
||
|
}();
|
||
|
var CipherTransformFactory = function CipherTransformFactoryClosure() {
|
||
|
var defaultPasswordBytes = new Uint8Array([
|
||
|
0x28,
|
||
|
0xBF,
|
||
|
0x4E,
|
||
|
0x5E,
|
||
|
0x4E,
|
||
|
0x75,
|
||
|
0x8A,
|
||
|
0x41,
|
||
|
0x64,
|
||
|
0x00,
|
||
|
0x4E,
|
||
|
0x56,
|
||
|
0xFF,
|
||
|
0xFA,
|
||
|
0x01,
|
||
|
0x08,
|
||
|
0x2E,
|
||
|
0x2E,
|
||
|
0x00,
|
||
|
0xB6,
|
||
|
0xD0,
|
||
|
0x68,
|
||
|
0x3E,
|
||
|
0x80,
|
||
|
0x2F,
|
||
|
0x0C,
|
||
|
0xA9,
|
||
|
0xFE,
|
||
|
0x64,
|
||
|
0x53,
|
||
|
0x69,
|
||
|
0x7A
|
||
|
]);
|
||
|
function createEncryptionKey20(revision, password, ownerPassword, ownerValidationSalt, ownerKeySalt, uBytes, userPassword, userValidationSalt, userKeySalt, ownerEncryption, userEncryption, perms) {
|
||
|
if (password) {
|
||
|
var passwordLength = Math.min(127, password.length);
|
||
|
password = password.subarray(0, passwordLength);
|
||
|
} else {
|
||
|
password = [];
|
||
|
}
|
||
|
var pdfAlgorithm;
|
||
|
if (revision === 6) {
|
||
|
pdfAlgorithm = new PDF20();
|
||
|
} else {
|
||
|
pdfAlgorithm = new PDF17();
|
||
|
}
|
||
|
if (pdfAlgorithm.checkUserPassword(password, userValidationSalt, userPassword)) {
|
||
|
return pdfAlgorithm.getUserKey(password, userKeySalt, userEncryption);
|
||
|
} else if (password.length && pdfAlgorithm.checkOwnerPassword(password, ownerValidationSalt, uBytes, ownerPassword)) {
|
||
|
return pdfAlgorithm.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption);
|
||
|
}
|
||
|
return null;
|
||
|
}
|
||
|
function prepareKeyData(fileId, password, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata) {
|
||
|
var hashDataSize = 40 + ownerPassword.length + fileId.length;
|
||
|
var hashData = new Uint8Array(hashDataSize), i = 0, j, n;
|
||
|
if (password) {
|
||
|
n = Math.min(32, password.length);
|
||
|
for (; i < n; ++i) {
|
||
|
hashData[i] = password[i];
|
||
|
}
|
||
|
}
|
||
|
j = 0;
|
||
|
while (i < 32) {
|
||
|
hashData[i++] = defaultPasswordBytes[j++];
|
||
|
}
|
||
|
for (j = 0, n = ownerPassword.length; j < n; ++j) {
|
||
|
hashData[i++] = ownerPassword[j];
|
||
|
}
|
||
|
hashData[i++] = flags & 0xFF;
|
||
|
hashData[i++] = flags >> 8 & 0xFF;
|
||
|
hashData[i++] = flags >> 16 & 0xFF;
|
||
|
hashData[i++] = flags >>> 24 & 0xFF;
|
||
|
for (j = 0, n = fileId.length; j < n; ++j) {
|
||
|
hashData[i++] = fileId[j];
|
||
|
}
|
||
|
if (revision >= 4 && !encryptMetadata) {
|
||
|
hashData[i++] = 0xFF;
|
||
|
hashData[i++] = 0xFF;
|
||
|
hashData[i++] = 0xFF;
|
||
|
hashData[i++] = 0xFF;
|
||
|
}
|
||
|
var hash = calculateMD5(hashData, 0, i);
|
||
|
var keyLengthInBytes = keyLength >> 3;
|
||
|
if (revision >= 3) {
|
||
|
for (j = 0; j < 50; ++j) {
|
||
|
hash = calculateMD5(hash, 0, keyLengthInBytes);
|
||
|
}
|
||
|
}
|
||
|
var encryptionKey = hash.subarray(0, keyLengthInBytes);
|
||
|
var cipher, checkData;
|
||
|
if (revision >= 3) {
|
||
|
for (i = 0; i < 32; ++i) {
|
||
|
hashData[i] = defaultPasswordBytes[i];
|
||
|
}
|
||
|
for (j = 0, n = fileId.length; j < n; ++j) {
|
||
|
hashData[i++] = fileId[j];
|
||
|
}
|
||
|
cipher = new ARCFourCipher(encryptionKey);
|
||
|
checkData = cipher.encryptBlock(calculateMD5(hashData, 0, i));
|
||
|
n = encryptionKey.length;
|
||
|
var derivedKey = new Uint8Array(n), k;
|
||
|
for (j = 1; j <= 19; ++j) {
|
||
|
for (k = 0; k < n; ++k) {
|
||
|
derivedKey[k] = encryptionKey[k] ^ j;
|
||
|
}
|
||
|
cipher = new ARCFourCipher(derivedKey);
|
||
|
checkData = cipher.encryptBlock(checkData);
|
||
|
}
|
||
|
for (j = 0, n = checkData.length; j < n; ++j) {
|
||
|
if (userPassword[j] !== checkData[j]) {
|
||
|
return null;
|
||
|
}
|
||
|
}
|
||
|
} else {
|
||
|
cipher = new ARCFourCipher(encryptionKey);
|
||
|
checkData = cipher.encryptBlock(defaultPasswordBytes);
|
||
|
for (j = 0, n = checkData.length; j < n; ++j) {
|
||
|
if (userPassword[j] !== checkData[j]) {
|
||
|
return null;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return encryptionKey;
|
||
|
}
|
||
|
function decodeUserPassword(password, ownerPassword, revision, keyLength) {
|
||
|
var hashData = new Uint8Array(32), i = 0, j, n;
|
||
|
n = Math.min(32, password.length);
|
||
|
for (; i < n; ++i) {
|
||
|
hashData[i] = password[i];
|
||
|
}
|
||
|
j = 0;
|
||
|
while (i < 32) {
|
||
|
hashData[i++] = defaultPasswordBytes[j++];
|
||
|
}
|
||
|
var hash = calculateMD5(hashData, 0, i);
|
||
|
var keyLengthInBytes = keyLength >> 3;
|
||
|
if (revision >= 3) {
|
||
|
for (j = 0; j < 50; ++j) {
|
||
|
hash = calculateMD5(hash, 0, hash.length);
|
||
|
}
|
||
|
}
|
||
|
var cipher, userPassword;
|
||
|
if (revision >= 3) {
|
||
|
userPassword = ownerPassword;
|
||
|
var derivedKey = new Uint8Array(keyLengthInBytes), k;
|
||
|
for (j = 19; j >= 0; j--) {
|
||
|
for (k = 0; k < keyLengthInBytes; ++k) {
|
||
|
derivedKey[k] = hash[k] ^ j;
|
||
|
}
|
||
|
cipher = new ARCFourCipher(derivedKey);
|
||
|
userPassword = cipher.encryptBlock(userPassword);
|
||
|
}
|
||
|
} else {
|
||
|
cipher = new ARCFourCipher(hash.subarray(0, keyLengthInBytes));
|
||
|
userPassword = cipher.encryptBlock(ownerPassword);
|
||
|
}
|
||
|
return userPassword;
|
||
|
}
|
||
|
var identityName = Name.get('Identity');
|
||
|
function CipherTransformFactory(dict, fileId, password) {
|
||
|
var filter = dict.get('Filter');
|
||
|
if (!isName(filter, 'Standard')) {
|
||
|
error('unknown encryption method');
|
||
|
}
|
||
|
this.dict = dict;
|
||
|
var algorithm = dict.get('V');
|
||
|
if (!isInt(algorithm) || algorithm !== 1 && algorithm !== 2 && algorithm !== 4 && algorithm !== 5) {
|
||
|
error('unsupported encryption algorithm');
|
||
|
}
|
||
|
this.algorithm = algorithm;
|
||
|
var keyLength = dict.get('Length');
|
||
|
if (!keyLength) {
|
||
|
if (algorithm <= 3) {
|
||
|
keyLength = 40;
|
||
|
} else {
|
||
|
var cfDict = dict.get('CF');
|
||
|
var streamCryptoName = dict.get('StmF');
|
||
|
if (isDict(cfDict) && isName(streamCryptoName)) {
|
||
|
cfDict.suppressEncryption = true;
|
||
|
var handlerDict = cfDict.get(streamCryptoName.name);
|
||
|
keyLength = handlerDict && handlerDict.get('Length') || 128;
|
||
|
if (keyLength < 40) {
|
||
|
keyLength <<= 3;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (!isInt(keyLength) || keyLength < 40 || keyLength % 8 !== 0) {
|
||
|
error('invalid key length');
|
||
|
}
|
||
|
var ownerPassword = stringToBytes(dict.get('O')).subarray(0, 32);
|
||
|
var userPassword = stringToBytes(dict.get('U')).subarray(0, 32);
|
||
|
var flags = dict.get('P');
|
||
|
var revision = dict.get('R');
|
||
|
var encryptMetadata = (algorithm === 4 || algorithm === 5) && dict.get('EncryptMetadata') !== false;
|
||
|
this.encryptMetadata = encryptMetadata;
|
||
|
var fileIdBytes = stringToBytes(fileId);
|
||
|
var passwordBytes;
|
||
|
if (password) {
|
||
|
if (revision === 6) {
|
||
|
try {
|
||
|
password = utf8StringToString(password);
|
||
|
} catch (ex) {
|
||
|
warn('CipherTransformFactory: ' + 'Unable to convert UTF8 encoded password.');
|
||
|
}
|
||
|
}
|
||
|
passwordBytes = stringToBytes(password);
|
||
|
}
|
||
|
var encryptionKey;
|
||
|
if (algorithm !== 5) {
|
||
|
encryptionKey = prepareKeyData(fileIdBytes, passwordBytes, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata);
|
||
|
} else {
|
||
|
var ownerValidationSalt = stringToBytes(dict.get('O')).subarray(32, 40);
|
||
|
var ownerKeySalt = stringToBytes(dict.get('O')).subarray(40, 48);
|
||
|
var uBytes = stringToBytes(dict.get('U')).subarray(0, 48);
|
||
|
var userValidationSalt = stringToBytes(dict.get('U')).subarray(32, 40);
|
||
|
var userKeySalt = stringToBytes(dict.get('U')).subarray(40, 48);
|
||
|
var ownerEncryption = stringToBytes(dict.get('OE'));
|
||
|
var userEncryption = stringToBytes(dict.get('UE'));
|
||
|
var perms = stringToBytes(dict.get('Perms'));
|
||
|
encryptionKey = createEncryptionKey20(revision, passwordBytes, ownerPassword, ownerValidationSalt, ownerKeySalt, uBytes, userPassword, userValidationSalt, userKeySalt, ownerEncryption, userEncryption, perms);
|
||
|
}
|
||
|
if (!encryptionKey && !password) {
|
||
|
throw new PasswordException('No password given', PasswordResponses.NEED_PASSWORD);
|
||
|
} else if (!encryptionKey && password) {
|
||
|
var decodedPassword = decodeUserPassword(passwordBytes, ownerPassword, revision, keyLength);
|
||
|
encryptionKey = prepareKeyData(fileIdBytes, decodedPassword, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata);
|
||
|
}
|
||
|
if (!encryptionKey) {
|
||
|
throw new PasswordException('Incorrect Password', PasswordResponses.INCORRECT_PASSWORD);
|
||
|
}
|
||
|
this.encryptionKey = encryptionKey;
|
||
|
if (algorithm >= 4) {
|
||
|
var cf = dict.get('CF');
|
||
|
if (isDict(cf)) {
|
||
|
cf.suppressEncryption = true;
|
||
|
}
|
||
|
this.cf = cf;
|
||
|
this.stmf = dict.get('StmF') || identityName;
|
||
|
this.strf = dict.get('StrF') || identityName;
|
||
|
this.eff = dict.get('EFF') || this.stmf;
|
||
|
}
|
||
|
}
|
||
|
function buildObjectKey(num, gen, encryptionKey, isAes) {
|
||
|
var key = new Uint8Array(encryptionKey.length + 9), i, n;
|
||
|
for (i = 0, n = encryptionKey.length; i < n; ++i) {
|
||
|
key[i] = encryptionKey[i];
|
||
|
}
|
||
|
key[i++] = num & 0xFF;
|
||
|
key[i++] = num >> 8 & 0xFF;
|
||
|
key[i++] = num >> 16 & 0xFF;
|
||
|
key[i++] = gen & 0xFF;
|
||
|
key[i++] = gen >> 8 & 0xFF;
|
||
|
if (isAes) {
|
||
|
key[i++] = 0x73;
|
||
|
key[i++] = 0x41;
|
||
|
key[i++] = 0x6C;
|
||
|
key[i++] = 0x54;
|
||
|
}
|
||
|
var hash = calculateMD5(key, 0, i);
|
||
|
return hash.subarray(0, Math.min(encryptionKey.length + 5, 16));
|
||
|
}
|
||
|
function buildCipherConstructor(cf, name, num, gen, key) {
|
||
|
assert(isName(name), 'Invalid crypt filter name.');
|
||
|
var cryptFilter = cf.get(name.name);
|
||
|
var cfm;
|
||
|
if (cryptFilter !== null && cryptFilter !== undefined) {
|
||
|
cfm = cryptFilter.get('CFM');
|
||
|
}
|
||
|
if (!cfm || cfm.name === 'None') {
|
||
|
return function cipherTransformFactoryBuildCipherConstructorNone() {
|
||
|
return new NullCipher();
|
||
|
};
|
||
|
}
|
||
|
if (cfm.name === 'V2') {
|
||
|
return function cipherTransformFactoryBuildCipherConstructorV2() {
|
||
|
return new ARCFourCipher(buildObjectKey(num, gen, key, false));
|
||
|
};
|
||
|
}
|
||
|
if (cfm.name === 'AESV2') {
|
||
|
return function cipherTransformFactoryBuildCipherConstructorAESV2() {
|
||
|
return new AES128Cipher(buildObjectKey(num, gen, key, true));
|
||
|
};
|
||
|
}
|
||
|
if (cfm.name === 'AESV3') {
|
||
|
return function cipherTransformFactoryBuildCipherConstructorAESV3() {
|
||
|
return new AES256Cipher(key);
|
||
|
};
|
||
|
}
|
||
|
error('Unknown crypto method');
|
||
|
}
|
||
|
CipherTransformFactory.prototype = {
|
||
|
createCipherTransform: function CipherTransformFactory_createCipherTransform(num, gen) {
|
||
|
if (this.algorithm === 4 || this.algorithm === 5) {
|
||
|
return new CipherTransform(buildCipherConstructor(this.cf, this.stmf, num, gen, this.encryptionKey), buildCipherConstructor(this.cf, this.strf, num, gen, this.encryptionKey));
|
||
|
}
|
||
|
var key = buildObjectKey(num, gen, this.encryptionKey, false);
|
||
|
var cipherConstructor = function buildCipherCipherConstructor() {
|
||
|
return new ARCFourCipher(key);
|
||
|
};
|
||
|
return new CipherTransform(cipherConstructor, cipherConstructor);
|
||
|
}
|
||
|
};
|
||
|
return CipherTransformFactory;
|
||
|
}();
|
||
|
exports.AES128Cipher = AES128Cipher;
|
||
|
exports.AES256Cipher = AES256Cipher;
|
||
|
exports.ARCFourCipher = ARCFourCipher;
|
||
|
exports.CipherTransformFactory = CipherTransformFactory;
|
||
|
exports.PDF17 = PDF17;
|
||
|
exports.PDF20 = PDF20;
|
||
|
exports.calculateMD5 = calculateMD5;
|
||
|
exports.calculateSHA256 = calculateSHA256;
|
||
|
exports.calculateSHA384 = calculateSHA384;
|
||
|
exports.calculateSHA512 = calculateSHA512;
|