first commit
This commit is contained in:
327
node_modules/jssha/src/sha512.ts
generated
vendored
Normal file
327
node_modules/jssha/src/sha512.ts
generated
vendored
Normal file
@@ -0,0 +1,327 @@
|
||||
import { jsSHABase, TWO_PWR_32, H_trunc, H_full, K_sha2, sha_variant_error, parseInputOption } from "./common";
|
||||
import {
|
||||
packedValue,
|
||||
FixedLengthOptionsEncodingType,
|
||||
FixedLengthOptionsNoEncodingType,
|
||||
FormatNoTextType,
|
||||
} from "./custom_types";
|
||||
import { getStrConverter } from "./converters";
|
||||
import {
|
||||
ch_64,
|
||||
gamma0_64,
|
||||
gamma1_64,
|
||||
Int_64,
|
||||
maj_64,
|
||||
safeAdd_64_2,
|
||||
safeAdd_64_4,
|
||||
safeAdd_64_5,
|
||||
sigma0_64,
|
||||
sigma1_64,
|
||||
} from "./primitives_64";
|
||||
|
||||
type VariantType = "SHA-384" | "SHA-512";
|
||||
|
||||
const K_sha512 = [
|
||||
new Int_64(K_sha2[0], 0xd728ae22),
|
||||
new Int_64(K_sha2[1], 0x23ef65cd),
|
||||
new Int_64(K_sha2[2], 0xec4d3b2f),
|
||||
new Int_64(K_sha2[3], 0x8189dbbc),
|
||||
new Int_64(K_sha2[4], 0xf348b538),
|
||||
new Int_64(K_sha2[5], 0xb605d019),
|
||||
new Int_64(K_sha2[6], 0xaf194f9b),
|
||||
new Int_64(K_sha2[7], 0xda6d8118),
|
||||
new Int_64(K_sha2[8], 0xa3030242),
|
||||
new Int_64(K_sha2[9], 0x45706fbe),
|
||||
new Int_64(K_sha2[10], 0x4ee4b28c),
|
||||
new Int_64(K_sha2[11], 0xd5ffb4e2),
|
||||
new Int_64(K_sha2[12], 0xf27b896f),
|
||||
new Int_64(K_sha2[13], 0x3b1696b1),
|
||||
new Int_64(K_sha2[14], 0x25c71235),
|
||||
new Int_64(K_sha2[15], 0xcf692694),
|
||||
new Int_64(K_sha2[16], 0x9ef14ad2),
|
||||
new Int_64(K_sha2[17], 0x384f25e3),
|
||||
new Int_64(K_sha2[18], 0x8b8cd5b5),
|
||||
new Int_64(K_sha2[19], 0x77ac9c65),
|
||||
new Int_64(K_sha2[20], 0x592b0275),
|
||||
new Int_64(K_sha2[21], 0x6ea6e483),
|
||||
new Int_64(K_sha2[22], 0xbd41fbd4),
|
||||
new Int_64(K_sha2[23], 0x831153b5),
|
||||
new Int_64(K_sha2[24], 0xee66dfab),
|
||||
new Int_64(K_sha2[25], 0x2db43210),
|
||||
new Int_64(K_sha2[26], 0x98fb213f),
|
||||
new Int_64(K_sha2[27], 0xbeef0ee4),
|
||||
new Int_64(K_sha2[28], 0x3da88fc2),
|
||||
new Int_64(K_sha2[29], 0x930aa725),
|
||||
new Int_64(K_sha2[30], 0xe003826f),
|
||||
new Int_64(K_sha2[31], 0x0a0e6e70),
|
||||
new Int_64(K_sha2[32], 0x46d22ffc),
|
||||
new Int_64(K_sha2[33], 0x5c26c926),
|
||||
new Int_64(K_sha2[34], 0x5ac42aed),
|
||||
new Int_64(K_sha2[35], 0x9d95b3df),
|
||||
new Int_64(K_sha2[36], 0x8baf63de),
|
||||
new Int_64(K_sha2[37], 0x3c77b2a8),
|
||||
new Int_64(K_sha2[38], 0x47edaee6),
|
||||
new Int_64(K_sha2[39], 0x1482353b),
|
||||
new Int_64(K_sha2[40], 0x4cf10364),
|
||||
new Int_64(K_sha2[41], 0xbc423001),
|
||||
new Int_64(K_sha2[42], 0xd0f89791),
|
||||
new Int_64(K_sha2[43], 0x0654be30),
|
||||
new Int_64(K_sha2[44], 0xd6ef5218),
|
||||
new Int_64(K_sha2[45], 0x5565a910),
|
||||
new Int_64(K_sha2[46], 0x5771202a),
|
||||
new Int_64(K_sha2[47], 0x32bbd1b8),
|
||||
new Int_64(K_sha2[48], 0xb8d2d0c8),
|
||||
new Int_64(K_sha2[49], 0x5141ab53),
|
||||
new Int_64(K_sha2[50], 0xdf8eeb99),
|
||||
new Int_64(K_sha2[51], 0xe19b48a8),
|
||||
new Int_64(K_sha2[52], 0xc5c95a63),
|
||||
new Int_64(K_sha2[53], 0xe3418acb),
|
||||
new Int_64(K_sha2[54], 0x7763e373),
|
||||
new Int_64(K_sha2[55], 0xd6b2b8a3),
|
||||
new Int_64(K_sha2[56], 0x5defb2fc),
|
||||
new Int_64(K_sha2[57], 0x43172f60),
|
||||
new Int_64(K_sha2[58], 0xa1f0ab72),
|
||||
new Int_64(K_sha2[59], 0x1a6439ec),
|
||||
new Int_64(K_sha2[60], 0x23631e28),
|
||||
new Int_64(K_sha2[61], 0xde82bde9),
|
||||
new Int_64(K_sha2[62], 0xb2c67915),
|
||||
new Int_64(K_sha2[63], 0xe372532b),
|
||||
new Int_64(0xca273ece, 0xea26619c),
|
||||
new Int_64(0xd186b8c7, 0x21c0c207),
|
||||
new Int_64(0xeada7dd6, 0xcde0eb1e),
|
||||
new Int_64(0xf57d4f7f, 0xee6ed178),
|
||||
new Int_64(0x06f067aa, 0x72176fba),
|
||||
new Int_64(0x0a637dc5, 0xa2c898a6),
|
||||
new Int_64(0x113f9804, 0xbef90dae),
|
||||
new Int_64(0x1b710b35, 0x131c471b),
|
||||
new Int_64(0x28db77f5, 0x23047d84),
|
||||
new Int_64(0x32caab7b, 0x40c72493),
|
||||
new Int_64(0x3c9ebe0a, 0x15c9bebc),
|
||||
new Int_64(0x431d67c4, 0x9c100d4c),
|
||||
new Int_64(0x4cc5d4be, 0xcb3e42b6),
|
||||
new Int_64(0x597f299c, 0xfc657e2a),
|
||||
new Int_64(0x5fcb6fab, 0x3ad6faec),
|
||||
new Int_64(0x6c44198c, 0x4a475817),
|
||||
];
|
||||
|
||||
/**
|
||||
* Gets the state values for the specified SHA variant.
|
||||
*
|
||||
* @param variant: The SHA-512 family variant.
|
||||
* @returns The initial state values.
|
||||
*/
|
||||
function getNewState512(variant: VariantType): Int_64[] {
|
||||
if ("SHA-384" === variant) {
|
||||
return [
|
||||
new Int_64(0xcbbb9d5d, H_trunc[0]),
|
||||
new Int_64(0x0629a292a, H_trunc[1]),
|
||||
new Int_64(0x9159015a, H_trunc[2]),
|
||||
new Int_64(0x0152fecd8, H_trunc[3]),
|
||||
new Int_64(0x67332667, H_trunc[4]),
|
||||
new Int_64(0x98eb44a87, H_trunc[5]),
|
||||
new Int_64(0xdb0c2e0d, H_trunc[6]),
|
||||
new Int_64(0x047b5481d, H_trunc[7]),
|
||||
];
|
||||
} else {
|
||||
/* SHA-512 */
|
||||
return [
|
||||
new Int_64(H_full[0], 0xf3bcc908),
|
||||
new Int_64(H_full[1], 0x84caa73b),
|
||||
new Int_64(H_full[2], 0xfe94f82b),
|
||||
new Int_64(H_full[3], 0x5f1d36f1),
|
||||
new Int_64(H_full[4], 0xade682d1),
|
||||
new Int_64(H_full[5], 0x2b3e6c1f),
|
||||
new Int_64(H_full[6], 0xfb41bd6b),
|
||||
new Int_64(H_full[7], 0x137e2179),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a round of SHA-512 hashing over a block. This clobbers `H`.
|
||||
*
|
||||
* @param block The binary array representation of the block to hash.
|
||||
* @param H The intermediate H values from a previous round.
|
||||
* @returns The resulting H values.
|
||||
*/
|
||||
function roundSHA512(block: number[], H: Int_64[]): Int_64[] {
|
||||
let a, b, c, d, e, f, g, h, T1, T2, t, offset;
|
||||
|
||||
const W: Int_64[] = [];
|
||||
|
||||
a = H[0];
|
||||
b = H[1];
|
||||
c = H[2];
|
||||
d = H[3];
|
||||
e = H[4];
|
||||
f = H[5];
|
||||
g = H[6];
|
||||
h = H[7];
|
||||
|
||||
for (t = 0; t < 80; t += 1) {
|
||||
if (t < 16) {
|
||||
offset = t * 2;
|
||||
W[t] = new Int_64(block[offset], block[offset + 1]);
|
||||
} else {
|
||||
W[t] = safeAdd_64_4(gamma1_64(W[t - 2]), W[t - 7], gamma0_64(W[t - 15]), W[t - 16]);
|
||||
}
|
||||
T1 = safeAdd_64_5(h, sigma1_64(e), ch_64(e, f, g), K_sha512[t], W[t]);
|
||||
T2 = safeAdd_64_2(sigma0_64(a), maj_64(a, b, c));
|
||||
h = g;
|
||||
g = f;
|
||||
f = e;
|
||||
e = safeAdd_64_2(d, T1);
|
||||
d = c;
|
||||
c = b;
|
||||
b = a;
|
||||
a = safeAdd_64_2(T1, T2);
|
||||
}
|
||||
|
||||
H[0] = safeAdd_64_2(a, H[0]);
|
||||
H[1] = safeAdd_64_2(b, H[1]);
|
||||
H[2] = safeAdd_64_2(c, H[2]);
|
||||
H[3] = safeAdd_64_2(d, H[3]);
|
||||
H[4] = safeAdd_64_2(e, H[4]);
|
||||
H[5] = safeAdd_64_2(f, H[5]);
|
||||
H[6] = safeAdd_64_2(g, H[6]);
|
||||
H[7] = safeAdd_64_2(h, H[7]);
|
||||
|
||||
return H;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finalizes the SHA-512 hash. This clobbers `remainder` and `H`.
|
||||
*
|
||||
* @param remainder Any leftover unprocessed packed ints that still need to be processed.
|
||||
* @param remainderBinLen The number of bits in `remainder`.
|
||||
* @param processedBinLen The number of bits already processed.
|
||||
* @param H The intermediate H values from a previous round.
|
||||
* @param variant The desired SHA-512 variant.
|
||||
* @returns The array of integers representing the SHA-512 hash of message.
|
||||
*/
|
||||
function finalizeSHA512(
|
||||
remainder: number[],
|
||||
remainderBinLen: number,
|
||||
processedBinLen: number,
|
||||
H: Int_64[],
|
||||
variant: VariantType
|
||||
): number[] {
|
||||
let i, retVal;
|
||||
|
||||
/* The 129 addition is a hack but it works. The correct number is
|
||||
actually 136 (128 + 8) but the below math fails if
|
||||
remainderBinLen + 136 % 1024 = 0. Since remainderBinLen % 8 = 0,
|
||||
"shorting" the addition is OK. */
|
||||
const offset = (((remainderBinLen + 129) >>> 10) << 5) + 31,
|
||||
binaryStringInc = 32,
|
||||
totalLen = remainderBinLen + processedBinLen;
|
||||
|
||||
while (remainder.length <= offset) {
|
||||
remainder.push(0);
|
||||
}
|
||||
/* Append '1' at the end of the binary string */
|
||||
remainder[remainderBinLen >>> 5] |= 0x80 << (24 - (remainderBinLen % 32));
|
||||
/* Append length of binary string in the position such that the new
|
||||
* length is correct. JavaScript numbers are limited to 2^53 so it's
|
||||
* "safe" to treat the totalLen as a 64-bit integer. */
|
||||
|
||||
remainder[offset] = totalLen & 0xffffffff;
|
||||
/* Bitwise operators treat the operand as a 32-bit number so need to
|
||||
* use hacky division and round to get access to upper 32-ish bits */
|
||||
remainder[offset - 1] = (totalLen / TWO_PWR_32) | 0;
|
||||
|
||||
/* This will always be at least 1 full chunk */
|
||||
for (i = 0; i < remainder.length; i += binaryStringInc) {
|
||||
H = roundSHA512(remainder.slice(i, i + binaryStringInc), H);
|
||||
}
|
||||
|
||||
if ("SHA-384" === variant) {
|
||||
H = (H as unknown) as Int_64[];
|
||||
retVal = [
|
||||
H[0].highOrder,
|
||||
H[0].lowOrder,
|
||||
H[1].highOrder,
|
||||
H[1].lowOrder,
|
||||
H[2].highOrder,
|
||||
H[2].lowOrder,
|
||||
H[3].highOrder,
|
||||
H[3].lowOrder,
|
||||
H[4].highOrder,
|
||||
H[4].lowOrder,
|
||||
H[5].highOrder,
|
||||
H[5].lowOrder,
|
||||
];
|
||||
} else {
|
||||
/* SHA-512 */
|
||||
retVal = [
|
||||
H[0].highOrder,
|
||||
H[0].lowOrder,
|
||||
H[1].highOrder,
|
||||
H[1].lowOrder,
|
||||
H[2].highOrder,
|
||||
H[2].lowOrder,
|
||||
H[3].highOrder,
|
||||
H[3].lowOrder,
|
||||
H[4].highOrder,
|
||||
H[4].lowOrder,
|
||||
H[5].highOrder,
|
||||
H[5].lowOrder,
|
||||
H[6].highOrder,
|
||||
H[6].lowOrder,
|
||||
H[7].highOrder,
|
||||
H[7].lowOrder,
|
||||
];
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
|
||||
export default class jsSHA extends jsSHABase<Int_64[], VariantType> {
|
||||
intermediateState: Int_64[];
|
||||
variantBlockSize: number;
|
||||
bigEndianMod: -1 | 1;
|
||||
outputBinLen: number;
|
||||
isVariableLen: boolean;
|
||||
HMACSupported: boolean;
|
||||
|
||||
/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
|
||||
converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
|
||||
roundFunc: (block: number[], H: Int_64[]) => Int_64[];
|
||||
finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: Int_64[]) => number[];
|
||||
stateCloneFunc: (state: Int_64[]) => Int_64[];
|
||||
newStateFunc: (variant: VariantType) => Int_64[];
|
||||
getMAC: () => number[];
|
||||
|
||||
constructor(variant: VariantType, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
|
||||
constructor(variant: VariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
constructor(variant: any, inputFormat: any, options?: any) {
|
||||
if (!("SHA-384" === variant || "SHA-512" === variant)) {
|
||||
throw new Error(sha_variant_error);
|
||||
}
|
||||
super(variant, inputFormat, options);
|
||||
const resolvedOptions = options || {};
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/unbound-method
|
||||
this.getMAC = this._getHMAC;
|
||||
this.HMACSupported = true;
|
||||
this.bigEndianMod = -1;
|
||||
this.converterFunc = getStrConverter(this.inputFormat, this.utfType, this.bigEndianMod);
|
||||
this.roundFunc = roundSHA512;
|
||||
this.stateCloneFunc = function (state): Int_64[] {
|
||||
return state.slice();
|
||||
};
|
||||
this.newStateFunc = getNewState512;
|
||||
this.finalizeFunc = function (remainder, remainderBinLen, processedBinLen, H): number[] {
|
||||
return finalizeSHA512(remainder, remainderBinLen, processedBinLen, H, variant);
|
||||
};
|
||||
|
||||
this.intermediateState = getNewState512(variant);
|
||||
this.variantBlockSize = 1024;
|
||||
this.outputBinLen = "SHA-384" === variant ? 384 : 512;
|
||||
this.isVariableLen = false;
|
||||
|
||||
if (resolvedOptions["hmacKey"]) {
|
||||
this._setHMACKey(parseInputOption("hmacKey", resolvedOptions["hmacKey"], this.bigEndianMod));
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user