@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.
Files changed (50) hide show
  1. package/dist-cjs/submodules/checksum/index.browser.js +355 -145
  2. package/dist-cjs/submodules/checksum/index.js +456 -142
  3. package/dist-cjs/submodules/checksum/index.native.js +355 -145
  4. package/dist-cjs/submodules/protocols/index.js +5 -2
  5. package/dist-cjs/submodules/serde/index.browser.js +30 -36
  6. package/dist-cjs/submodules/serde/index.js +54 -110
  7. package/dist-cjs/submodules/serde/index.native.js +30 -36
  8. package/dist-es/submodules/checksum/crc32/Crc32Js.js +27 -0
  9. package/dist-es/submodules/checksum/crc32/Crc32Node.js +21 -0
  10. package/dist-es/submodules/checksum/index.browser.js +7 -1
  11. package/dist-es/submodules/checksum/index.js +7 -1
  12. package/dist-es/submodules/checksum/index.native.js +7 -1
  13. package/dist-es/submodules/checksum/md5/Md5Js.js +92 -0
  14. package/dist-es/submodules/checksum/md5/Md5Node.js +29 -0
  15. package/dist-es/submodules/checksum/sha256/Sha256Js.js +179 -0
  16. package/dist-es/submodules/checksum/sha256/Sha256Node.js +59 -0
  17. package/dist-es/submodules/checksum/sha256/Sha256WebCrypto.js +71 -0
  18. package/dist-es/submodules/protocols/HttpProtocol.js +4 -1
  19. package/dist-es/submodules/serde/concatBytes.js +15 -0
  20. package/dist-es/submodules/serde/index.browser.js +2 -0
  21. package/dist-es/submodules/serde/index.js +2 -0
  22. package/dist-es/submodules/serde/index.native.js +2 -0
  23. package/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.js +4 -0
  24. package/dist-es/submodules/serde/util-stream/headStream.js +2 -1
  25. package/dist-es/submodules/serde/util-stream/stream-collector.browser.js +12 -38
  26. package/dist-es/submodules/serde/util-stream/stream-collector.js +18 -33
  27. package/dist-es/submodules/serde/util-utf8/toUint8Array.browser.js +3 -0
  28. package/dist-es/submodules/serde/util-utf8/toUint8Array.js +3 -0
  29. package/dist-types/submodules/checksum/crc32/Crc32Js.d.ts +13 -0
  30. package/dist-types/submodules/checksum/crc32/Crc32Node.d.ts +13 -0
  31. package/dist-types/submodules/checksum/index.browser.d.ts +7 -1
  32. package/dist-types/submodules/checksum/index.d.ts +7 -1
  33. package/dist-types/submodules/checksum/index.native.d.ts +7 -1
  34. package/dist-types/submodules/checksum/md5/Md5Js.d.ts +19 -0
  35. package/dist-types/submodules/checksum/md5/Md5Node.d.ts +17 -0
  36. package/dist-types/submodules/checksum/sha256/Sha256Js.d.ts +28 -0
  37. package/dist-types/submodules/checksum/sha256/Sha256Node.d.ts +13 -0
  38. package/dist-types/submodules/checksum/sha256/Sha256WebCrypto.d.ts +22 -0
  39. package/dist-types/submodules/serde/concatBytes.d.ts +6 -0
  40. package/dist-types/submodules/serde/index.browser.d.ts +2 -0
  41. package/dist-types/submodules/serde/index.d.ts +2 -0
  42. package/dist-types/submodules/serde/index.native.d.ts +2 -0
  43. package/dist-types/submodules/serde/util-stream/checksum/ChecksumStream.d.ts +9 -0
  44. package/dist-types/submodules/serde/util-stream/stream-collector.browser.d.ts +8 -2
  45. package/dist-types/submodules/serde/util-stream/stream-collector.d.ts +4 -1
  46. package/package.json +4 -3
  47. package/dist-es/submodules/checksum/md5-js/constants.js +0 -3
  48. package/dist-es/submodules/checksum/md5-js/md5.js +0 -168
  49. package/dist-types/submodules/checksum/md5-js/constants.d.ts +0 -12
  50. 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, fromUtf8 } = require("@smithy/core/serde");
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
- const BLOCK_SIZE = 64;
83
- const DIGEST_LENGTH = 16;
84
- const INIT = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];
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
- class Md5 {
87
- state;
88
- buffer;
89
- bufferLength;
90
- bytesHashed;
91
- finished;
92
- constructor() {
93
- this.reset();
176
+ const hasNativeCrypto$1 = (() => {
177
+ try {
178
+ createHash("md5");
179
+ return true;
94
180
  }
95
- update(sourceData) {
96
- if (isEmptyData(sourceData)) {
97
- return;
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
- else if (this.finished) {
100
- throw new Error("Attempted to update an already finished hash.");
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
- const data = convertToBuffer(sourceData);
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 } = data;
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.setUint8(this.bufferLength++, data[position++]);
295
+ this.buffer[this.bufferLength++] = chunk[position++];
108
296
  byteLength--;
109
- if (this.bufferLength === BLOCK_SIZE) {
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
- if (!this.finished) {
117
- const { buffer, bufferLength: undecoratedLength, bytesHashed } = this;
118
- const bitsHashed = bytesHashed * 8;
119
- buffer.setUint8(this.bufferLength++, 0b10000000);
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
- const out = new DataView(new ArrayBuffer(DIGEST_LENGTH));
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 = Uint32Array.from(INIT);
215
- this.buffer = new DataView(new ArrayBuffer(BLOCK_SIZE));
317
+ this.state = Int32Array.from(INIT);
318
+ this.buffer = new Uint8Array(64);
216
319
  this.bufferLength = 0;
217
320
  this.bytesHashed = 0;
218
- this.finished = false;
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
- function cmn(q, a, b, x, s, t) {
222
- a = (((a + q) & 0xffffffff) + ((x + t) & 0xffffffff)) & 0xffffffff;
223
- return (((a << s) | (a >>> (32 - s))) + b) & 0xffffffff;
224
- }
225
- function ff(a, b, c, d, x, s, t) {
226
- return cmn((b & c) | (~b & d), a, b, x, s, t);
227
- }
228
- function gg(a, b, c, d, x, s, t) {
229
- return cmn((b & d) | (c & ~d), a, b, x, s, t);
230
- }
231
- function hh(a, b, c, d, x, s, t) {
232
- return cmn(b ^ c ^ d, a, b, x, s, t);
233
- }
234
- function ii(a, b, c, d, x, s, t) {
235
- return cmn(c ^ (b | ~d), a, b, x, s, t);
236
- }
237
- function isEmptyData(data) {
238
- if (typeof data === "string") {
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
- return data.byteLength === 0;
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 convertToBuffer(data) {
478
+ function toBuffer(data) {
244
479
  if (typeof data === "string") {
245
- return fromUtf8(data);
480
+ return data;
246
481
  }
247
482
  if (ArrayBuffer.isView(data)) {
248
- return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
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.Md5 = Md5;
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;