@smithy/core 3.26.0 → 3.27.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist-cjs/submodules/checksum/index.browser.js +355 -145
- package/dist-cjs/submodules/checksum/index.js +456 -142
- package/dist-cjs/submodules/checksum/index.native.js +355 -145
- package/dist-cjs/submodules/protocols/index.js +5 -2
- package/dist-cjs/submodules/serde/index.browser.js +30 -36
- package/dist-cjs/submodules/serde/index.js +54 -110
- package/dist-cjs/submodules/serde/index.native.js +30 -36
- package/dist-es/submodules/checksum/crc32/Crc32Js.js +27 -0
- package/dist-es/submodules/checksum/crc32/Crc32Node.js +21 -0
- package/dist-es/submodules/checksum/index.browser.js +7 -1
- package/dist-es/submodules/checksum/index.js +7 -1
- package/dist-es/submodules/checksum/index.native.js +7 -1
- package/dist-es/submodules/checksum/md5/Md5Js.js +92 -0
- package/dist-es/submodules/checksum/md5/Md5Node.js +29 -0
- package/dist-es/submodules/checksum/sha256/Sha256Js.js +179 -0
- package/dist-es/submodules/checksum/sha256/Sha256Node.js +59 -0
- package/dist-es/submodules/checksum/sha256/Sha256WebCrypto.js +71 -0
- package/dist-es/submodules/protocols/HttpProtocol.js +4 -1
- package/dist-es/submodules/serde/concatBytes.js +15 -0
- package/dist-es/submodules/serde/index.browser.js +2 -0
- package/dist-es/submodules/serde/index.js +2 -0
- package/dist-es/submodules/serde/index.native.js +2 -0
- package/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.js +4 -0
- package/dist-es/submodules/serde/util-stream/headStream.js +2 -1
- package/dist-es/submodules/serde/util-stream/stream-collector.browser.js +12 -38
- package/dist-es/submodules/serde/util-stream/stream-collector.js +18 -33
- package/dist-es/submodules/serde/util-utf8/toUint8Array.browser.js +3 -0
- package/dist-es/submodules/serde/util-utf8/toUint8Array.js +3 -0
- package/dist-types/submodules/checksum/crc32/Crc32Js.d.ts +13 -0
- package/dist-types/submodules/checksum/crc32/Crc32Node.d.ts +13 -0
- package/dist-types/submodules/checksum/index.browser.d.ts +7 -1
- package/dist-types/submodules/checksum/index.d.ts +7 -1
- package/dist-types/submodules/checksum/index.native.d.ts +7 -1
- package/dist-types/submodules/checksum/md5/Md5Js.d.ts +19 -0
- package/dist-types/submodules/checksum/md5/Md5Node.d.ts +17 -0
- package/dist-types/submodules/checksum/sha256/Sha256Js.d.ts +28 -0
- package/dist-types/submodules/checksum/sha256/Sha256Node.d.ts +13 -0
- package/dist-types/submodules/checksum/sha256/Sha256WebCrypto.d.ts +22 -0
- package/dist-types/submodules/serde/concatBytes.d.ts +6 -0
- package/dist-types/submodules/serde/index.browser.d.ts +2 -0
- package/dist-types/submodules/serde/index.d.ts +2 -0
- package/dist-types/submodules/serde/index.native.d.ts +2 -0
- package/dist-types/submodules/serde/util-stream/checksum/ChecksumStream.d.ts +9 -0
- package/dist-types/submodules/serde/util-stream/stream-collector.browser.d.ts +8 -2
- package/dist-types/submodules/serde/util-stream/stream-collector.d.ts +4 -1
- package/package.json +4 -3
- package/dist-es/submodules/checksum/md5-js/constants.js +0 -3
- package/dist-es/submodules/checksum/md5-js/md5.js +0 -168
- package/dist-types/submodules/checksum/md5-js/constants.d.ts +0 -12
- package/dist-types/submodules/checksum/md5-js/md5.d.ts +0 -16
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
const { createReadStream } = require("node:fs");
|
|
2
2
|
const { Writable } = require("node:stream");
|
|
3
|
-
const { toUint8Array,
|
|
3
|
+
const { toUint8Array, concatBytes } = require("@smithy/core/serde");
|
|
4
|
+
const { createHash, createHmac } = require("node:crypto");
|
|
5
|
+
const zlib = require("node:zlib");
|
|
4
6
|
|
|
5
7
|
async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
|
|
6
8
|
const size = blob.size;
|
|
@@ -79,178 +81,490 @@ const readableStreamHasher = (hashCtor, readableStream) => {
|
|
|
79
81
|
});
|
|
80
82
|
};
|
|
81
83
|
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
84
|
+
class Md5Js {
|
|
85
|
+
digestLength = 16;
|
|
86
|
+
state = Uint32Array.from(INIT$1);
|
|
87
|
+
writeBuffer = new DataView(new ArrayBuffer(64));
|
|
88
|
+
bufferLength = 0;
|
|
89
|
+
bytesHashed = 0;
|
|
90
|
+
update(sourceData) {
|
|
91
|
+
const data = toUint8Array(sourceData);
|
|
92
|
+
let pos = 0;
|
|
93
|
+
let len = data.byteLength;
|
|
94
|
+
this.bytesHashed += len;
|
|
95
|
+
while (len > 0) {
|
|
96
|
+
this.writeBuffer.setUint8(this.bufferLength++, data[pos++]);
|
|
97
|
+
--len;
|
|
98
|
+
if (this.bufferLength === 64) {
|
|
99
|
+
compress(this.state, this.writeBuffer);
|
|
100
|
+
this.bufferLength = 0;
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
async digest() {
|
|
105
|
+
const state = Uint32Array.from(this.state);
|
|
106
|
+
const buf = new DataView(this.writeBuffer.buffer.slice(0));
|
|
107
|
+
let bufLen = this.bufferLength;
|
|
108
|
+
const bits = this.bytesHashed * 8;
|
|
109
|
+
buf.setUint8(bufLen++, 0x80);
|
|
110
|
+
if (this.bufferLength % 64 >= 56) {
|
|
111
|
+
for (let i = bufLen; i < 64; ++i) {
|
|
112
|
+
buf.setUint8(i, 0);
|
|
113
|
+
}
|
|
114
|
+
compress(state, buf);
|
|
115
|
+
bufLen = 0;
|
|
116
|
+
}
|
|
117
|
+
for (let i = bufLen; i < 56; ++i) {
|
|
118
|
+
buf.setUint8(i, 0);
|
|
119
|
+
}
|
|
120
|
+
buf.setUint32(56, bits >>> 0, true);
|
|
121
|
+
buf.setUint32(60, Math.floor(bits / 2 ** 32), true);
|
|
122
|
+
compress(state, buf);
|
|
123
|
+
const out = new Uint8Array(16);
|
|
124
|
+
const view = new DataView(out.buffer);
|
|
125
|
+
for (let i = 0; i < 4; ++i) {
|
|
126
|
+
view.setUint32(i * 4, state[i], true);
|
|
127
|
+
}
|
|
128
|
+
return out;
|
|
129
|
+
}
|
|
130
|
+
reset() {
|
|
131
|
+
this.state.set(INIT$1);
|
|
132
|
+
this.writeBuffer = new DataView(new ArrayBuffer(64));
|
|
133
|
+
this.bufferLength = 0;
|
|
134
|
+
this.bytesHashed = 0;
|
|
135
|
+
}
|
|
136
|
+
}
|
|
137
|
+
const INIT$1 = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];
|
|
138
|
+
const M = 0xffffffff;
|
|
139
|
+
const S = Uint8Array.of(7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21);
|
|
140
|
+
const T = Array.from({ length: 64 }, (_, i) => (Math.abs(Math.sin(i + 1)) * 2 ** 32) >>> 0);
|
|
141
|
+
function compress(state, block) {
|
|
142
|
+
let a = state[0], b = state[1], c = state[2], d = state[3];
|
|
143
|
+
for (let i = 0; i < 64; ++i) {
|
|
144
|
+
let f, g;
|
|
145
|
+
if (i < 16) {
|
|
146
|
+
f = (b & c) | (~b & d);
|
|
147
|
+
g = i;
|
|
148
|
+
}
|
|
149
|
+
else if (i < 32) {
|
|
150
|
+
f = (d & b) | (c & ~d);
|
|
151
|
+
g = (5 * i + 1) % 16;
|
|
152
|
+
}
|
|
153
|
+
else if (i < 48) {
|
|
154
|
+
f = b ^ c ^ d;
|
|
155
|
+
g = (3 * i + 5) % 16;
|
|
156
|
+
}
|
|
157
|
+
else {
|
|
158
|
+
f = c ^ (b | ~d);
|
|
159
|
+
g = (7 * i) % 16;
|
|
160
|
+
}
|
|
161
|
+
const x = block.getUint32(g * 4, true);
|
|
162
|
+
const tmp = d;
|
|
163
|
+
d = c;
|
|
164
|
+
c = b;
|
|
165
|
+
const s = S[(i >> 4) * 4 + (i & 3)];
|
|
166
|
+
const sum = (((a + f) & M) + ((x + T[i]) & M)) & M;
|
|
167
|
+
b = (b + (((sum << s) | (sum >>> (32 - s))) >>> 0)) & M;
|
|
168
|
+
a = tmp;
|
|
169
|
+
}
|
|
170
|
+
state[0] = (state[0] + a) & M;
|
|
171
|
+
state[1] = (state[1] + b) & M;
|
|
172
|
+
state[2] = (state[2] + c) & M;
|
|
173
|
+
state[3] = (state[3] + d) & M;
|
|
174
|
+
}
|
|
85
175
|
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
bytesHashed;
|
|
91
|
-
finished;
|
|
92
|
-
constructor() {
|
|
93
|
-
this.reset();
|
|
176
|
+
const hasNativeCrypto$1 = (() => {
|
|
177
|
+
try {
|
|
178
|
+
createHash("md5");
|
|
179
|
+
return true;
|
|
94
180
|
}
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
181
|
+
catch {
|
|
182
|
+
return false;
|
|
183
|
+
}
|
|
184
|
+
})();
|
|
185
|
+
const Md5Node = hasNativeCrypto$1 ? buildNativeClass$2() : Md5Js;
|
|
186
|
+
function buildNativeClass$2() {
|
|
187
|
+
return class Md5Node {
|
|
188
|
+
digestLength = 16;
|
|
189
|
+
hash = createHash("md5");
|
|
190
|
+
update(data) {
|
|
191
|
+
this.hash.update(toUint8Array(data));
|
|
192
|
+
}
|
|
193
|
+
async digest() {
|
|
194
|
+
const buf = this.hash.copy().digest();
|
|
195
|
+
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
|
|
196
|
+
}
|
|
197
|
+
reset() {
|
|
198
|
+
this.hash = createHash("md5");
|
|
98
199
|
}
|
|
99
|
-
|
|
100
|
-
|
|
200
|
+
};
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
const CRC32_TABLE = new Uint32Array(256);
|
|
204
|
+
for (let i = 0; i < 256; ++i) {
|
|
205
|
+
let c = i;
|
|
206
|
+
for (let j = 0; j < 8; ++j) {
|
|
207
|
+
c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
|
|
208
|
+
}
|
|
209
|
+
CRC32_TABLE[i] = c >>> 0;
|
|
210
|
+
}
|
|
211
|
+
const ONES = 0xffff_ffff;
|
|
212
|
+
class Crc32Js {
|
|
213
|
+
digestLength = 4;
|
|
214
|
+
checksum = ONES;
|
|
215
|
+
update(data) {
|
|
216
|
+
for (let i = 0; i < data.length; ++i) {
|
|
217
|
+
this.checksum = (this.checksum >>> 8) ^ CRC32_TABLE[(this.checksum ^ data[i]) & 0xff];
|
|
218
|
+
}
|
|
219
|
+
}
|
|
220
|
+
async digest() {
|
|
221
|
+
const value = (this.checksum ^ ONES) >>> 0;
|
|
222
|
+
const out = new Uint8Array(4);
|
|
223
|
+
new DataView(out.buffer).setUint32(0, value, false);
|
|
224
|
+
return out;
|
|
225
|
+
}
|
|
226
|
+
reset() {
|
|
227
|
+
this.checksum = ONES;
|
|
228
|
+
}
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
const zlibCrc32 = typeof zlib.crc32 === "function" ? zlib.crc32 : undefined;
|
|
232
|
+
const Crc32Node = zlibCrc32 ? buildNativeClass$1(zlibCrc32) : Crc32Js;
|
|
233
|
+
function buildNativeClass$1(nativeCrc32) {
|
|
234
|
+
return class Crc32Node {
|
|
235
|
+
digestLength = 4;
|
|
236
|
+
value = 0;
|
|
237
|
+
update(data) {
|
|
238
|
+
this.value = nativeCrc32(data, this.value);
|
|
239
|
+
}
|
|
240
|
+
async digest() {
|
|
241
|
+
const out = new Uint8Array(4);
|
|
242
|
+
new DataView(out.buffer).setUint32(0, this.value >>> 0, false);
|
|
243
|
+
return out;
|
|
244
|
+
}
|
|
245
|
+
reset() {
|
|
246
|
+
this.value = 0;
|
|
101
247
|
}
|
|
102
|
-
|
|
248
|
+
};
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
const BLOCK = 64;
|
|
252
|
+
const DIGEST_LENGTH = 32;
|
|
253
|
+
const MAX_HASHABLE_LENGTH = 2 ** 53 - 1;
|
|
254
|
+
class Sha256Js {
|
|
255
|
+
digestLength = DIGEST_LENGTH;
|
|
256
|
+
state = Int32Array.from(INIT);
|
|
257
|
+
w;
|
|
258
|
+
buffer = new Uint8Array(64);
|
|
259
|
+
bufferLength = 0;
|
|
260
|
+
bytesHashed = 0;
|
|
261
|
+
finished = false;
|
|
262
|
+
inner;
|
|
263
|
+
outer;
|
|
264
|
+
constructor(secret) {
|
|
265
|
+
if (secret) {
|
|
266
|
+
const key = Sha256Js.normalizeKey(secret);
|
|
267
|
+
this.inner = new Sha256Js();
|
|
268
|
+
this.outer = new Sha256Js();
|
|
269
|
+
const { inner, outer } = this;
|
|
270
|
+
const pad = new Uint8Array(BLOCK * 2);
|
|
271
|
+
for (let i = 0; i < BLOCK; ++i) {
|
|
272
|
+
pad[i] = 0x36 ^ key[i];
|
|
273
|
+
pad[i + BLOCK] = 0x5c ^ key[i];
|
|
274
|
+
}
|
|
275
|
+
inner.update(pad.subarray(0, BLOCK));
|
|
276
|
+
outer.update(pad.subarray(BLOCK));
|
|
277
|
+
}
|
|
278
|
+
}
|
|
279
|
+
update(data) {
|
|
280
|
+
if (this.finished) {
|
|
281
|
+
throw new Error("Attempted to update an already finished HMAC.");
|
|
282
|
+
}
|
|
283
|
+
if (this.inner) {
|
|
284
|
+
this.inner.update(data);
|
|
285
|
+
return;
|
|
286
|
+
}
|
|
287
|
+
const chunk = toUint8Array(data);
|
|
103
288
|
let position = 0;
|
|
104
|
-
let { byteLength } =
|
|
289
|
+
let { byteLength } = chunk;
|
|
105
290
|
this.bytesHashed += byteLength;
|
|
291
|
+
if (this.bytesHashed * 8 > MAX_HASHABLE_LENGTH) {
|
|
292
|
+
throw new Error("Cannot hash more than 2^53 - 1 bits");
|
|
293
|
+
}
|
|
106
294
|
while (byteLength > 0) {
|
|
107
|
-
this.buffer
|
|
295
|
+
this.buffer[this.bufferLength++] = chunk[position++];
|
|
108
296
|
byteLength--;
|
|
109
|
-
if (this.bufferLength ===
|
|
297
|
+
if (this.bufferLength === BLOCK) {
|
|
110
298
|
this.hashBuffer();
|
|
111
299
|
this.bufferLength = 0;
|
|
112
300
|
}
|
|
113
301
|
}
|
|
114
302
|
}
|
|
115
303
|
async digest() {
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
if (undecoratedLength % BLOCK_SIZE >= BLOCK_SIZE - 8) {
|
|
121
|
-
for (let i = this.bufferLength; i < BLOCK_SIZE; i++) {
|
|
122
|
-
buffer.setUint8(i, 0);
|
|
123
|
-
}
|
|
124
|
-
this.hashBuffer();
|
|
125
|
-
this.bufferLength = 0;
|
|
126
|
-
}
|
|
127
|
-
for (let i = this.bufferLength; i < BLOCK_SIZE - 8; i++) {
|
|
128
|
-
buffer.setUint8(i, 0);
|
|
304
|
+
const { inner, outer } = this;
|
|
305
|
+
if (inner && outer) {
|
|
306
|
+
if (this.finished) {
|
|
307
|
+
throw new Error("Attempted to digest an already finished HMAC.");
|
|
129
308
|
}
|
|
130
|
-
buffer.setUint32(BLOCK_SIZE - 8, bitsHashed >>> 0, true);
|
|
131
|
-
buffer.setUint32(BLOCK_SIZE - 4, Math.floor(bitsHashed / 0x100000000), true);
|
|
132
|
-
this.hashBuffer();
|
|
133
309
|
this.finished = true;
|
|
310
|
+
const innerDigest = inner.digestSync();
|
|
311
|
+
outer.update(innerDigest);
|
|
312
|
+
return outer.digestSync();
|
|
134
313
|
}
|
|
135
|
-
|
|
136
|
-
for (let i = 0; i < 4; i++) {
|
|
137
|
-
out.setUint32(i * 4, this.state[i], true);
|
|
138
|
-
}
|
|
139
|
-
return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
|
|
140
|
-
}
|
|
141
|
-
hashBuffer() {
|
|
142
|
-
const { buffer, state } = this;
|
|
143
|
-
let a = state[0], b = state[1], c = state[2], d = state[3];
|
|
144
|
-
a = ff(a, b, c, d, buffer.getUint32(0, true), 7, 0xd76aa478);
|
|
145
|
-
d = ff(d, a, b, c, buffer.getUint32(4, true), 12, 0xe8c7b756);
|
|
146
|
-
c = ff(c, d, a, b, buffer.getUint32(8, true), 17, 0x242070db);
|
|
147
|
-
b = ff(b, c, d, a, buffer.getUint32(12, true), 22, 0xc1bdceee);
|
|
148
|
-
a = ff(a, b, c, d, buffer.getUint32(16, true), 7, 0xf57c0faf);
|
|
149
|
-
d = ff(d, a, b, c, buffer.getUint32(20, true), 12, 0x4787c62a);
|
|
150
|
-
c = ff(c, d, a, b, buffer.getUint32(24, true), 17, 0xa8304613);
|
|
151
|
-
b = ff(b, c, d, a, buffer.getUint32(28, true), 22, 0xfd469501);
|
|
152
|
-
a = ff(a, b, c, d, buffer.getUint32(32, true), 7, 0x698098d8);
|
|
153
|
-
d = ff(d, a, b, c, buffer.getUint32(36, true), 12, 0x8b44f7af);
|
|
154
|
-
c = ff(c, d, a, b, buffer.getUint32(40, true), 17, 0xffff5bb1);
|
|
155
|
-
b = ff(b, c, d, a, buffer.getUint32(44, true), 22, 0x895cd7be);
|
|
156
|
-
a = ff(a, b, c, d, buffer.getUint32(48, true), 7, 0x6b901122);
|
|
157
|
-
d = ff(d, a, b, c, buffer.getUint32(52, true), 12, 0xfd987193);
|
|
158
|
-
c = ff(c, d, a, b, buffer.getUint32(56, true), 17, 0xa679438e);
|
|
159
|
-
b = ff(b, c, d, a, buffer.getUint32(60, true), 22, 0x49b40821);
|
|
160
|
-
a = gg(a, b, c, d, buffer.getUint32(4, true), 5, 0xf61e2562);
|
|
161
|
-
d = gg(d, a, b, c, buffer.getUint32(24, true), 9, 0xc040b340);
|
|
162
|
-
c = gg(c, d, a, b, buffer.getUint32(44, true), 14, 0x265e5a51);
|
|
163
|
-
b = gg(b, c, d, a, buffer.getUint32(0, true), 20, 0xe9b6c7aa);
|
|
164
|
-
a = gg(a, b, c, d, buffer.getUint32(20, true), 5, 0xd62f105d);
|
|
165
|
-
d = gg(d, a, b, c, buffer.getUint32(40, true), 9, 0x02441453);
|
|
166
|
-
c = gg(c, d, a, b, buffer.getUint32(60, true), 14, 0xd8a1e681);
|
|
167
|
-
b = gg(b, c, d, a, buffer.getUint32(16, true), 20, 0xe7d3fbc8);
|
|
168
|
-
a = gg(a, b, c, d, buffer.getUint32(36, true), 5, 0x21e1cde6);
|
|
169
|
-
d = gg(d, a, b, c, buffer.getUint32(56, true), 9, 0xc33707d6);
|
|
170
|
-
c = gg(c, d, a, b, buffer.getUint32(12, true), 14, 0xf4d50d87);
|
|
171
|
-
b = gg(b, c, d, a, buffer.getUint32(32, true), 20, 0x455a14ed);
|
|
172
|
-
a = gg(a, b, c, d, buffer.getUint32(52, true), 5, 0xa9e3e905);
|
|
173
|
-
d = gg(d, a, b, c, buffer.getUint32(8, true), 9, 0xfcefa3f8);
|
|
174
|
-
c = gg(c, d, a, b, buffer.getUint32(28, true), 14, 0x676f02d9);
|
|
175
|
-
b = gg(b, c, d, a, buffer.getUint32(48, true), 20, 0x8d2a4c8a);
|
|
176
|
-
a = hh(a, b, c, d, buffer.getUint32(20, true), 4, 0xfffa3942);
|
|
177
|
-
d = hh(d, a, b, c, buffer.getUint32(32, true), 11, 0x8771f681);
|
|
178
|
-
c = hh(c, d, a, b, buffer.getUint32(44, true), 16, 0x6d9d6122);
|
|
179
|
-
b = hh(b, c, d, a, buffer.getUint32(56, true), 23, 0xfde5380c);
|
|
180
|
-
a = hh(a, b, c, d, buffer.getUint32(4, true), 4, 0xa4beea44);
|
|
181
|
-
d = hh(d, a, b, c, buffer.getUint32(16, true), 11, 0x4bdecfa9);
|
|
182
|
-
c = hh(c, d, a, b, buffer.getUint32(28, true), 16, 0xf6bb4b60);
|
|
183
|
-
b = hh(b, c, d, a, buffer.getUint32(40, true), 23, 0xbebfbc70);
|
|
184
|
-
a = hh(a, b, c, d, buffer.getUint32(52, true), 4, 0x289b7ec6);
|
|
185
|
-
d = hh(d, a, b, c, buffer.getUint32(0, true), 11, 0xeaa127fa);
|
|
186
|
-
c = hh(c, d, a, b, buffer.getUint32(12, true), 16, 0xd4ef3085);
|
|
187
|
-
b = hh(b, c, d, a, buffer.getUint32(24, true), 23, 0x04881d05);
|
|
188
|
-
a = hh(a, b, c, d, buffer.getUint32(36, true), 4, 0xd9d4d039);
|
|
189
|
-
d = hh(d, a, b, c, buffer.getUint32(48, true), 11, 0xe6db99e5);
|
|
190
|
-
c = hh(c, d, a, b, buffer.getUint32(60, true), 16, 0x1fa27cf8);
|
|
191
|
-
b = hh(b, c, d, a, buffer.getUint32(8, true), 23, 0xc4ac5665);
|
|
192
|
-
a = ii(a, b, c, d, buffer.getUint32(0, true), 6, 0xf4292244);
|
|
193
|
-
d = ii(d, a, b, c, buffer.getUint32(28, true), 10, 0x432aff97);
|
|
194
|
-
c = ii(c, d, a, b, buffer.getUint32(56, true), 15, 0xab9423a7);
|
|
195
|
-
b = ii(b, c, d, a, buffer.getUint32(20, true), 21, 0xfc93a039);
|
|
196
|
-
a = ii(a, b, c, d, buffer.getUint32(48, true), 6, 0x655b59c3);
|
|
197
|
-
d = ii(d, a, b, c, buffer.getUint32(12, true), 10, 0x8f0ccc92);
|
|
198
|
-
c = ii(c, d, a, b, buffer.getUint32(40, true), 15, 0xffeff47d);
|
|
199
|
-
b = ii(b, c, d, a, buffer.getUint32(4, true), 21, 0x85845dd1);
|
|
200
|
-
a = ii(a, b, c, d, buffer.getUint32(32, true), 6, 0x6fa87e4f);
|
|
201
|
-
d = ii(d, a, b, c, buffer.getUint32(60, true), 10, 0xfe2ce6e0);
|
|
202
|
-
c = ii(c, d, a, b, buffer.getUint32(24, true), 15, 0xa3014314);
|
|
203
|
-
b = ii(b, c, d, a, buffer.getUint32(52, true), 21, 0x4e0811a1);
|
|
204
|
-
a = ii(a, b, c, d, buffer.getUint32(16, true), 6, 0xf7537e82);
|
|
205
|
-
d = ii(d, a, b, c, buffer.getUint32(44, true), 10, 0xbd3af235);
|
|
206
|
-
c = ii(c, d, a, b, buffer.getUint32(8, true), 15, 0x2ad7d2bb);
|
|
207
|
-
b = ii(b, c, d, a, buffer.getUint32(36, true), 21, 0xeb86d391);
|
|
208
|
-
state[0] = (a + state[0]) & 0xffffffff;
|
|
209
|
-
state[1] = (b + state[1]) & 0xffffffff;
|
|
210
|
-
state[2] = (c + state[2]) & 0xffffffff;
|
|
211
|
-
state[3] = (d + state[3]) & 0xffffffff;
|
|
314
|
+
return this.digestSync();
|
|
212
315
|
}
|
|
213
316
|
reset() {
|
|
214
|
-
this.state =
|
|
215
|
-
this.buffer = new
|
|
317
|
+
this.state = Int32Array.from(INIT);
|
|
318
|
+
this.buffer = new Uint8Array(64);
|
|
216
319
|
this.bufferLength = 0;
|
|
217
320
|
this.bytesHashed = 0;
|
|
218
|
-
|
|
321
|
+
}
|
|
322
|
+
digestSync() {
|
|
323
|
+
const state = this.state.slice();
|
|
324
|
+
const buffer = this.buffer.slice();
|
|
325
|
+
let bufferLength = this.bufferLength;
|
|
326
|
+
const bitsHashed = this.bytesHashed * 8;
|
|
327
|
+
const bufferView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
328
|
+
bufferView.setUint8(bufferLength++, 0x80);
|
|
329
|
+
if ((bufferLength - 1) % BLOCK >= BLOCK - 8) {
|
|
330
|
+
for (let i = bufferLength; i < BLOCK; ++i) {
|
|
331
|
+
bufferView.setUint8(i, 0);
|
|
332
|
+
}
|
|
333
|
+
this.hashBufferWith(state, buffer);
|
|
334
|
+
bufferLength = 0;
|
|
335
|
+
}
|
|
336
|
+
for (let i = bufferLength; i < BLOCK - 8; ++i) {
|
|
337
|
+
bufferView.setUint8(i, 0);
|
|
338
|
+
}
|
|
339
|
+
bufferView.setUint32(BLOCK - 8, Math.floor(bitsHashed / 0x100000000), false);
|
|
340
|
+
bufferView.setUint32(BLOCK - 4, bitsHashed, false);
|
|
341
|
+
this.hashBufferWith(state, buffer);
|
|
342
|
+
const out = new Uint8Array(DIGEST_LENGTH);
|
|
343
|
+
for (let i = 0; i < 8; ++i) {
|
|
344
|
+
out[i * 4] = (state[i] >>> 24) & 0xff;
|
|
345
|
+
out[i * 4 + 1] = (state[i] >>> 16) & 0xff;
|
|
346
|
+
out[i * 4 + 2] = (state[i] >>> 8) & 0xff;
|
|
347
|
+
out[i * 4 + 3] = (state[i] >>> 0) & 0xff;
|
|
348
|
+
}
|
|
349
|
+
return out;
|
|
350
|
+
}
|
|
351
|
+
static normalizeKey(secret) {
|
|
352
|
+
const key = toUint8Array(secret);
|
|
353
|
+
if (key.byteLength > BLOCK) {
|
|
354
|
+
const h = new Sha256Js();
|
|
355
|
+
h.update(key);
|
|
356
|
+
const out = h.digestSync();
|
|
357
|
+
const padded = new Uint8Array(BLOCK);
|
|
358
|
+
padded.set(out);
|
|
359
|
+
return padded;
|
|
360
|
+
}
|
|
361
|
+
if (key.byteLength < BLOCK) {
|
|
362
|
+
const padded = new Uint8Array(BLOCK);
|
|
363
|
+
padded.set(key);
|
|
364
|
+
return padded;
|
|
365
|
+
}
|
|
366
|
+
return key;
|
|
367
|
+
}
|
|
368
|
+
hashBuffer() {
|
|
369
|
+
this.hashBufferWith(this.state, this.buffer);
|
|
370
|
+
}
|
|
371
|
+
hashBufferWith(state, buffer) {
|
|
372
|
+
const w = (this.w ??= new Int32Array(64));
|
|
373
|
+
let s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3], s4 = state[4], s5 = state[5], s6 = state[6], s7 = state[7];
|
|
374
|
+
for (let i = 0; i < BLOCK; ++i) {
|
|
375
|
+
if (i < 16) {
|
|
376
|
+
w[i] =
|
|
377
|
+
((buffer[i * 4] & 0xff) << 24) |
|
|
378
|
+
((buffer[i * 4 + 1] & 0xff) << 16) |
|
|
379
|
+
((buffer[i * 4 + 2] & 0xff) << 8) |
|
|
380
|
+
(buffer[i * 4 + 3] & 0xff);
|
|
381
|
+
}
|
|
382
|
+
else {
|
|
383
|
+
let u = w[i - 2];
|
|
384
|
+
const t1 = ((u >>> 17) | (u << 15)) ^ ((u >>> 19) | (u << 13)) ^ (u >>> 10);
|
|
385
|
+
u = w[i - 15];
|
|
386
|
+
const t2 = ((u >>> 7) | (u << 25)) ^ ((u >>> 18) | (u << 14)) ^ (u >>> 3);
|
|
387
|
+
w[i] = ((t1 + w[i - 7]) | 0) + ((t2 + w[i - 16]) | 0);
|
|
388
|
+
}
|
|
389
|
+
const t1 = ((((((s4 >>> 6) | (s4 << 26)) ^ ((s4 >>> 11) | (s4 << 21)) ^ ((s4 >>> 25) | (s4 << 7))) +
|
|
390
|
+
((s4 & s5) ^ (~s4 & s6))) |
|
|
391
|
+
0) +
|
|
392
|
+
((s7 + ((K[i] + w[i]) | 0)) | 0)) |
|
|
393
|
+
0;
|
|
394
|
+
const t2 = ((((s0 >>> 2) | (s0 << 30)) ^ ((s0 >>> 13) | (s0 << 19)) ^ ((s0 >>> 22) | (s0 << 10))) +
|
|
395
|
+
((s0 & s1) ^ (s0 & s2) ^ (s1 & s2))) |
|
|
396
|
+
0;
|
|
397
|
+
s7 = s6;
|
|
398
|
+
s6 = s5;
|
|
399
|
+
s5 = s4;
|
|
400
|
+
s4 = (s3 + t1) | 0;
|
|
401
|
+
s3 = s2;
|
|
402
|
+
s2 = s1;
|
|
403
|
+
s1 = s0;
|
|
404
|
+
s0 = (t1 + t2) | 0;
|
|
405
|
+
}
|
|
406
|
+
state[0] += s0;
|
|
407
|
+
state[1] += s1;
|
|
408
|
+
state[2] += s2;
|
|
409
|
+
state[3] += s3;
|
|
410
|
+
state[4] += s4;
|
|
411
|
+
state[5] += s5;
|
|
412
|
+
state[6] += s6;
|
|
413
|
+
state[7] += s7;
|
|
219
414
|
}
|
|
220
415
|
}
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
return data.length === 0;
|
|
416
|
+
const INIT = new Int32Array([
|
|
417
|
+
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
|
|
418
|
+
]);
|
|
419
|
+
const K = new Int32Array([
|
|
420
|
+
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
|
421
|
+
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
|
422
|
+
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
|
423
|
+
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
|
|
424
|
+
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
|
425
|
+
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
|
426
|
+
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
|
427
|
+
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
|
|
428
|
+
]);
|
|
429
|
+
|
|
430
|
+
const hasNativeCrypto = (() => {
|
|
431
|
+
try {
|
|
432
|
+
createHash("sha256");
|
|
433
|
+
return true;
|
|
240
434
|
}
|
|
241
|
-
|
|
435
|
+
catch {
|
|
436
|
+
return false;
|
|
437
|
+
}
|
|
438
|
+
})();
|
|
439
|
+
const Sha256Node = hasNativeCrypto ? buildNativeClass() : Sha256Js;
|
|
440
|
+
function buildNativeClass() {
|
|
441
|
+
return class Sha256Node {
|
|
442
|
+
digestLength = 32;
|
|
443
|
+
secret;
|
|
444
|
+
hash;
|
|
445
|
+
isHmac;
|
|
446
|
+
finished = false;
|
|
447
|
+
constructor(secret) {
|
|
448
|
+
this.secret = secret;
|
|
449
|
+
this.isHmac = !!secret;
|
|
450
|
+
this.hash = this.createHash();
|
|
451
|
+
}
|
|
452
|
+
update(data) {
|
|
453
|
+
if (this.finished) {
|
|
454
|
+
throw new Error("Attempted to update an already finished hash.");
|
|
455
|
+
}
|
|
456
|
+
this.hash.update(data);
|
|
457
|
+
}
|
|
458
|
+
async digest() {
|
|
459
|
+
let buf;
|
|
460
|
+
if (this.isHmac) {
|
|
461
|
+
this.finished = true;
|
|
462
|
+
buf = this.hash.digest();
|
|
463
|
+
}
|
|
464
|
+
else {
|
|
465
|
+
buf = this.hash.copy().digest();
|
|
466
|
+
}
|
|
467
|
+
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
|
|
468
|
+
}
|
|
469
|
+
reset() {
|
|
470
|
+
this.hash = this.createHash();
|
|
471
|
+
this.finished = false;
|
|
472
|
+
}
|
|
473
|
+
createHash() {
|
|
474
|
+
return this.secret ? createHmac("sha256", toBuffer(this.secret)) : createHash("sha256");
|
|
475
|
+
}
|
|
476
|
+
};
|
|
242
477
|
}
|
|
243
|
-
function
|
|
478
|
+
function toBuffer(data) {
|
|
244
479
|
if (typeof data === "string") {
|
|
245
|
-
return
|
|
480
|
+
return data;
|
|
246
481
|
}
|
|
247
482
|
if (ArrayBuffer.isView(data)) {
|
|
248
|
-
return
|
|
483
|
+
return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
|
|
484
|
+
}
|
|
485
|
+
return Buffer.from(data);
|
|
486
|
+
}
|
|
487
|
+
|
|
488
|
+
const { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
|
|
489
|
+
const subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function"
|
|
490
|
+
? globalThis.crypto.subtle
|
|
491
|
+
: undefined;
|
|
492
|
+
const MAX_PENDING_BYTES = 8 * 1024 * 1024;
|
|
493
|
+
class Sha256WebCrypto {
|
|
494
|
+
digestLength = 32;
|
|
495
|
+
secret;
|
|
496
|
+
pending = [];
|
|
497
|
+
pendingBytes = 0;
|
|
498
|
+
fallback;
|
|
499
|
+
finished = false;
|
|
500
|
+
constructor(secret) {
|
|
501
|
+
if (secret) {
|
|
502
|
+
this.secret = toUint8Array(secret);
|
|
503
|
+
}
|
|
504
|
+
}
|
|
505
|
+
update(data) {
|
|
506
|
+
if (this.finished) {
|
|
507
|
+
throw new Error("Attempted to update an already finished HMAC.");
|
|
508
|
+
}
|
|
509
|
+
if (this.fallback) {
|
|
510
|
+
this.fallback.update(data);
|
|
511
|
+
return;
|
|
512
|
+
}
|
|
513
|
+
this.pending.push(data.slice());
|
|
514
|
+
this.pendingBytes += data.byteLength;
|
|
515
|
+
if (this.pendingBytes >= MAX_PENDING_BYTES) {
|
|
516
|
+
this.switchToFallback();
|
|
517
|
+
}
|
|
518
|
+
}
|
|
519
|
+
async digest() {
|
|
520
|
+
if (this.fallback) {
|
|
521
|
+
return this.fallback.digest();
|
|
522
|
+
}
|
|
523
|
+
if (this.secret && this.finished) {
|
|
524
|
+
throw new Error("Attempted to digest an already finished HMAC.");
|
|
525
|
+
}
|
|
526
|
+
const data = concatBytes(this.pending);
|
|
527
|
+
if (subtle) {
|
|
528
|
+
if (this.secret) {
|
|
529
|
+
this.finished = true;
|
|
530
|
+
const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
|
|
531
|
+
const sig = await subtle.sign("HMAC", key, data);
|
|
532
|
+
return new Uint8Array(sig);
|
|
533
|
+
}
|
|
534
|
+
const hash = await subtle.digest("SHA-256", data);
|
|
535
|
+
return new Uint8Array(hash);
|
|
536
|
+
}
|
|
537
|
+
const sha256 = new Sha256Js(this.secret);
|
|
538
|
+
sha256.update(data);
|
|
539
|
+
return sha256.digest();
|
|
540
|
+
}
|
|
541
|
+
reset() {
|
|
542
|
+
this.pending = [];
|
|
543
|
+
this.pendingBytes = 0;
|
|
544
|
+
this.fallback = undefined;
|
|
545
|
+
this.finished = false;
|
|
546
|
+
}
|
|
547
|
+
switchToFallback() {
|
|
548
|
+
const sha256Js = new Sha256Js(this.secret);
|
|
549
|
+
for (const chunk of this.pending) {
|
|
550
|
+
sha256Js.update(chunk);
|
|
551
|
+
}
|
|
552
|
+
this.fallback = sha256Js;
|
|
553
|
+
this.pending = [];
|
|
554
|
+
this.pendingBytes = 0;
|
|
249
555
|
}
|
|
250
|
-
return new Uint8Array(data);
|
|
251
556
|
}
|
|
252
557
|
|
|
253
|
-
exports.
|
|
558
|
+
exports.Crc32 = Crc32Node;
|
|
559
|
+
exports.Crc32Js = Crc32Js;
|
|
560
|
+
exports.Crc32Node = Crc32Node;
|
|
561
|
+
exports.Md5 = Md5Node;
|
|
562
|
+
exports.Md5Js = Md5Js;
|
|
563
|
+
exports.Md5Node = Md5Node;
|
|
564
|
+
exports.Sha256 = Sha256Node;
|
|
565
|
+
exports.Sha256Js = Sha256Js;
|
|
566
|
+
exports.Sha256Node = Sha256Node;
|
|
567
|
+
exports.Sha256WebCrypto = Sha256WebCrypto;
|
|
254
568
|
exports.blobHasher = blobHasher;
|
|
255
569
|
exports.blobReader = blobReader;
|
|
256
570
|
exports.fileStreamHasher = fileStreamHasher;
|