@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,4 +1,4 @@
|
|
|
1
|
-
const {
|
|
1
|
+
const { toUint8Array, concatBytes, fromBase64 } = require("@smithy/core/serde");
|
|
2
2
|
|
|
3
3
|
async function blobReader$1(blob, onChunk, chunkSize = 1024 * 1024) {
|
|
4
4
|
const size = blob.size;
|
|
@@ -18,175 +18,373 @@ const blobHasher = async function blobHasher(hashCtor, blob) {
|
|
|
18
18
|
return hash.digest();
|
|
19
19
|
};
|
|
20
20
|
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
21
|
+
class Md5Js {
|
|
22
|
+
digestLength = 16;
|
|
23
|
+
state = Uint32Array.from(INIT$1);
|
|
24
|
+
writeBuffer = new DataView(new ArrayBuffer(64));
|
|
25
|
+
bufferLength = 0;
|
|
26
|
+
bytesHashed = 0;
|
|
27
|
+
update(sourceData) {
|
|
28
|
+
const data = toUint8Array(sourceData);
|
|
29
|
+
let pos = 0;
|
|
30
|
+
let len = data.byteLength;
|
|
31
|
+
this.bytesHashed += len;
|
|
32
|
+
while (len > 0) {
|
|
33
|
+
this.writeBuffer.setUint8(this.bufferLength++, data[pos++]);
|
|
34
|
+
--len;
|
|
35
|
+
if (this.bufferLength === 64) {
|
|
36
|
+
compress(this.state, this.writeBuffer);
|
|
37
|
+
this.bufferLength = 0;
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
}
|
|
41
|
+
async digest() {
|
|
42
|
+
const state = Uint32Array.from(this.state);
|
|
43
|
+
const buf = new DataView(this.writeBuffer.buffer.slice(0));
|
|
44
|
+
let bufLen = this.bufferLength;
|
|
45
|
+
const bits = this.bytesHashed * 8;
|
|
46
|
+
buf.setUint8(bufLen++, 0x80);
|
|
47
|
+
if (this.bufferLength % 64 >= 56) {
|
|
48
|
+
for (let i = bufLen; i < 64; ++i) {
|
|
49
|
+
buf.setUint8(i, 0);
|
|
50
|
+
}
|
|
51
|
+
compress(state, buf);
|
|
52
|
+
bufLen = 0;
|
|
53
|
+
}
|
|
54
|
+
for (let i = bufLen; i < 56; ++i) {
|
|
55
|
+
buf.setUint8(i, 0);
|
|
56
|
+
}
|
|
57
|
+
buf.setUint32(56, bits >>> 0, true);
|
|
58
|
+
buf.setUint32(60, Math.floor(bits / 2 ** 32), true);
|
|
59
|
+
compress(state, buf);
|
|
60
|
+
const out = new Uint8Array(16);
|
|
61
|
+
const view = new DataView(out.buffer);
|
|
62
|
+
for (let i = 0; i < 4; ++i) {
|
|
63
|
+
view.setUint32(i * 4, state[i], true);
|
|
64
|
+
}
|
|
65
|
+
return out;
|
|
66
|
+
}
|
|
67
|
+
reset() {
|
|
68
|
+
this.state.set(INIT$1);
|
|
69
|
+
this.writeBuffer = new DataView(new ArrayBuffer(64));
|
|
70
|
+
this.bufferLength = 0;
|
|
71
|
+
this.bytesHashed = 0;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
const INIT$1 = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];
|
|
75
|
+
const M = 0xffffffff;
|
|
76
|
+
const S = Uint8Array.of(7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21);
|
|
77
|
+
const T = Array.from({ length: 64 }, (_, i) => (Math.abs(Math.sin(i + 1)) * 2 ** 32) >>> 0);
|
|
78
|
+
function compress(state, block) {
|
|
79
|
+
let a = state[0], b = state[1], c = state[2], d = state[3];
|
|
80
|
+
for (let i = 0; i < 64; ++i) {
|
|
81
|
+
let f, g;
|
|
82
|
+
if (i < 16) {
|
|
83
|
+
f = (b & c) | (~b & d);
|
|
84
|
+
g = i;
|
|
85
|
+
}
|
|
86
|
+
else if (i < 32) {
|
|
87
|
+
f = (d & b) | (c & ~d);
|
|
88
|
+
g = (5 * i + 1) % 16;
|
|
89
|
+
}
|
|
90
|
+
else if (i < 48) {
|
|
91
|
+
f = b ^ c ^ d;
|
|
92
|
+
g = (3 * i + 5) % 16;
|
|
93
|
+
}
|
|
94
|
+
else {
|
|
95
|
+
f = c ^ (b | ~d);
|
|
96
|
+
g = (7 * i) % 16;
|
|
97
|
+
}
|
|
98
|
+
const x = block.getUint32(g * 4, true);
|
|
99
|
+
const tmp = d;
|
|
100
|
+
d = c;
|
|
101
|
+
c = b;
|
|
102
|
+
const s = S[(i >> 4) * 4 + (i & 3)];
|
|
103
|
+
const sum = (((a + f) & M) + ((x + T[i]) & M)) & M;
|
|
104
|
+
b = (b + (((sum << s) | (sum >>> (32 - s))) >>> 0)) & M;
|
|
105
|
+
a = tmp;
|
|
106
|
+
}
|
|
107
|
+
state[0] = (state[0] + a) & M;
|
|
108
|
+
state[1] = (state[1] + b) & M;
|
|
109
|
+
state[2] = (state[2] + c) & M;
|
|
110
|
+
state[3] = (state[3] + d) & M;
|
|
111
|
+
}
|
|
24
112
|
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
finished;
|
|
31
|
-
constructor() {
|
|
32
|
-
this.reset();
|
|
113
|
+
const CRC32_TABLE = new Uint32Array(256);
|
|
114
|
+
for (let i = 0; i < 256; ++i) {
|
|
115
|
+
let c = i;
|
|
116
|
+
for (let j = 0; j < 8; ++j) {
|
|
117
|
+
c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
|
|
33
118
|
}
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
119
|
+
CRC32_TABLE[i] = c >>> 0;
|
|
120
|
+
}
|
|
121
|
+
const ONES = 0xffff_ffff;
|
|
122
|
+
class Crc32Js {
|
|
123
|
+
digestLength = 4;
|
|
124
|
+
checksum = ONES;
|
|
125
|
+
update(data) {
|
|
126
|
+
for (let i = 0; i < data.length; ++i) {
|
|
127
|
+
this.checksum = (this.checksum >>> 8) ^ CRC32_TABLE[(this.checksum ^ data[i]) & 0xff];
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
async digest() {
|
|
131
|
+
const value = (this.checksum ^ ONES) >>> 0;
|
|
132
|
+
const out = new Uint8Array(4);
|
|
133
|
+
new DataView(out.buffer).setUint32(0, value, false);
|
|
134
|
+
return out;
|
|
135
|
+
}
|
|
136
|
+
reset() {
|
|
137
|
+
this.checksum = ONES;
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
const BLOCK = 64;
|
|
142
|
+
const DIGEST_LENGTH = 32;
|
|
143
|
+
const MAX_HASHABLE_LENGTH = 2 ** 53 - 1;
|
|
144
|
+
class Sha256Js {
|
|
145
|
+
digestLength = DIGEST_LENGTH;
|
|
146
|
+
state = Int32Array.from(INIT);
|
|
147
|
+
w;
|
|
148
|
+
buffer = new Uint8Array(64);
|
|
149
|
+
bufferLength = 0;
|
|
150
|
+
bytesHashed = 0;
|
|
151
|
+
finished = false;
|
|
152
|
+
inner;
|
|
153
|
+
outer;
|
|
154
|
+
constructor(secret) {
|
|
155
|
+
if (secret) {
|
|
156
|
+
const key = Sha256Js.normalizeKey(secret);
|
|
157
|
+
this.inner = new Sha256Js();
|
|
158
|
+
this.outer = new Sha256Js();
|
|
159
|
+
const { inner, outer } = this;
|
|
160
|
+
const pad = new Uint8Array(BLOCK * 2);
|
|
161
|
+
for (let i = 0; i < BLOCK; ++i) {
|
|
162
|
+
pad[i] = 0x36 ^ key[i];
|
|
163
|
+
pad[i + BLOCK] = 0x5c ^ key[i];
|
|
164
|
+
}
|
|
165
|
+
inner.update(pad.subarray(0, BLOCK));
|
|
166
|
+
outer.update(pad.subarray(BLOCK));
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
update(data) {
|
|
170
|
+
if (this.finished) {
|
|
171
|
+
throw new Error("Attempted to update an already finished HMAC.");
|
|
37
172
|
}
|
|
38
|
-
|
|
39
|
-
|
|
173
|
+
if (this.inner) {
|
|
174
|
+
this.inner.update(data);
|
|
175
|
+
return;
|
|
40
176
|
}
|
|
41
|
-
const
|
|
177
|
+
const chunk = toUint8Array(data);
|
|
42
178
|
let position = 0;
|
|
43
|
-
let { byteLength } =
|
|
179
|
+
let { byteLength } = chunk;
|
|
44
180
|
this.bytesHashed += byteLength;
|
|
181
|
+
if (this.bytesHashed * 8 > MAX_HASHABLE_LENGTH) {
|
|
182
|
+
throw new Error("Cannot hash more than 2^53 - 1 bits");
|
|
183
|
+
}
|
|
45
184
|
while (byteLength > 0) {
|
|
46
|
-
this.buffer
|
|
185
|
+
this.buffer[this.bufferLength++] = chunk[position++];
|
|
47
186
|
byteLength--;
|
|
48
|
-
if (this.bufferLength ===
|
|
187
|
+
if (this.bufferLength === BLOCK) {
|
|
49
188
|
this.hashBuffer();
|
|
50
189
|
this.bufferLength = 0;
|
|
51
190
|
}
|
|
52
191
|
}
|
|
53
192
|
}
|
|
54
193
|
async digest() {
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
if (undecoratedLength % BLOCK_SIZE >= BLOCK_SIZE - 8) {
|
|
60
|
-
for (let i = this.bufferLength; i < BLOCK_SIZE; i++) {
|
|
61
|
-
buffer.setUint8(i, 0);
|
|
62
|
-
}
|
|
63
|
-
this.hashBuffer();
|
|
64
|
-
this.bufferLength = 0;
|
|
65
|
-
}
|
|
66
|
-
for (let i = this.bufferLength; i < BLOCK_SIZE - 8; i++) {
|
|
67
|
-
buffer.setUint8(i, 0);
|
|
194
|
+
const { inner, outer } = this;
|
|
195
|
+
if (inner && outer) {
|
|
196
|
+
if (this.finished) {
|
|
197
|
+
throw new Error("Attempted to digest an already finished HMAC.");
|
|
68
198
|
}
|
|
69
|
-
buffer.setUint32(BLOCK_SIZE - 8, bitsHashed >>> 0, true);
|
|
70
|
-
buffer.setUint32(BLOCK_SIZE - 4, Math.floor(bitsHashed / 0x100000000), true);
|
|
71
|
-
this.hashBuffer();
|
|
72
199
|
this.finished = true;
|
|
200
|
+
const innerDigest = inner.digestSync();
|
|
201
|
+
outer.update(innerDigest);
|
|
202
|
+
return outer.digestSync();
|
|
73
203
|
}
|
|
74
|
-
|
|
75
|
-
for (let i = 0; i < 4; i++) {
|
|
76
|
-
out.setUint32(i * 4, this.state[i], true);
|
|
77
|
-
}
|
|
78
|
-
return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
|
|
79
|
-
}
|
|
80
|
-
hashBuffer() {
|
|
81
|
-
const { buffer, state } = this;
|
|
82
|
-
let a = state[0], b = state[1], c = state[2], d = state[3];
|
|
83
|
-
a = ff(a, b, c, d, buffer.getUint32(0, true), 7, 0xd76aa478);
|
|
84
|
-
d = ff(d, a, b, c, buffer.getUint32(4, true), 12, 0xe8c7b756);
|
|
85
|
-
c = ff(c, d, a, b, buffer.getUint32(8, true), 17, 0x242070db);
|
|
86
|
-
b = ff(b, c, d, a, buffer.getUint32(12, true), 22, 0xc1bdceee);
|
|
87
|
-
a = ff(a, b, c, d, buffer.getUint32(16, true), 7, 0xf57c0faf);
|
|
88
|
-
d = ff(d, a, b, c, buffer.getUint32(20, true), 12, 0x4787c62a);
|
|
89
|
-
c = ff(c, d, a, b, buffer.getUint32(24, true), 17, 0xa8304613);
|
|
90
|
-
b = ff(b, c, d, a, buffer.getUint32(28, true), 22, 0xfd469501);
|
|
91
|
-
a = ff(a, b, c, d, buffer.getUint32(32, true), 7, 0x698098d8);
|
|
92
|
-
d = ff(d, a, b, c, buffer.getUint32(36, true), 12, 0x8b44f7af);
|
|
93
|
-
c = ff(c, d, a, b, buffer.getUint32(40, true), 17, 0xffff5bb1);
|
|
94
|
-
b = ff(b, c, d, a, buffer.getUint32(44, true), 22, 0x895cd7be);
|
|
95
|
-
a = ff(a, b, c, d, buffer.getUint32(48, true), 7, 0x6b901122);
|
|
96
|
-
d = ff(d, a, b, c, buffer.getUint32(52, true), 12, 0xfd987193);
|
|
97
|
-
c = ff(c, d, a, b, buffer.getUint32(56, true), 17, 0xa679438e);
|
|
98
|
-
b = ff(b, c, d, a, buffer.getUint32(60, true), 22, 0x49b40821);
|
|
99
|
-
a = gg(a, b, c, d, buffer.getUint32(4, true), 5, 0xf61e2562);
|
|
100
|
-
d = gg(d, a, b, c, buffer.getUint32(24, true), 9, 0xc040b340);
|
|
101
|
-
c = gg(c, d, a, b, buffer.getUint32(44, true), 14, 0x265e5a51);
|
|
102
|
-
b = gg(b, c, d, a, buffer.getUint32(0, true), 20, 0xe9b6c7aa);
|
|
103
|
-
a = gg(a, b, c, d, buffer.getUint32(20, true), 5, 0xd62f105d);
|
|
104
|
-
d = gg(d, a, b, c, buffer.getUint32(40, true), 9, 0x02441453);
|
|
105
|
-
c = gg(c, d, a, b, buffer.getUint32(60, true), 14, 0xd8a1e681);
|
|
106
|
-
b = gg(b, c, d, a, buffer.getUint32(16, true), 20, 0xe7d3fbc8);
|
|
107
|
-
a = gg(a, b, c, d, buffer.getUint32(36, true), 5, 0x21e1cde6);
|
|
108
|
-
d = gg(d, a, b, c, buffer.getUint32(56, true), 9, 0xc33707d6);
|
|
109
|
-
c = gg(c, d, a, b, buffer.getUint32(12, true), 14, 0xf4d50d87);
|
|
110
|
-
b = gg(b, c, d, a, buffer.getUint32(32, true), 20, 0x455a14ed);
|
|
111
|
-
a = gg(a, b, c, d, buffer.getUint32(52, true), 5, 0xa9e3e905);
|
|
112
|
-
d = gg(d, a, b, c, buffer.getUint32(8, true), 9, 0xfcefa3f8);
|
|
113
|
-
c = gg(c, d, a, b, buffer.getUint32(28, true), 14, 0x676f02d9);
|
|
114
|
-
b = gg(b, c, d, a, buffer.getUint32(48, true), 20, 0x8d2a4c8a);
|
|
115
|
-
a = hh(a, b, c, d, buffer.getUint32(20, true), 4, 0xfffa3942);
|
|
116
|
-
d = hh(d, a, b, c, buffer.getUint32(32, true), 11, 0x8771f681);
|
|
117
|
-
c = hh(c, d, a, b, buffer.getUint32(44, true), 16, 0x6d9d6122);
|
|
118
|
-
b = hh(b, c, d, a, buffer.getUint32(56, true), 23, 0xfde5380c);
|
|
119
|
-
a = hh(a, b, c, d, buffer.getUint32(4, true), 4, 0xa4beea44);
|
|
120
|
-
d = hh(d, a, b, c, buffer.getUint32(16, true), 11, 0x4bdecfa9);
|
|
121
|
-
c = hh(c, d, a, b, buffer.getUint32(28, true), 16, 0xf6bb4b60);
|
|
122
|
-
b = hh(b, c, d, a, buffer.getUint32(40, true), 23, 0xbebfbc70);
|
|
123
|
-
a = hh(a, b, c, d, buffer.getUint32(52, true), 4, 0x289b7ec6);
|
|
124
|
-
d = hh(d, a, b, c, buffer.getUint32(0, true), 11, 0xeaa127fa);
|
|
125
|
-
c = hh(c, d, a, b, buffer.getUint32(12, true), 16, 0xd4ef3085);
|
|
126
|
-
b = hh(b, c, d, a, buffer.getUint32(24, true), 23, 0x04881d05);
|
|
127
|
-
a = hh(a, b, c, d, buffer.getUint32(36, true), 4, 0xd9d4d039);
|
|
128
|
-
d = hh(d, a, b, c, buffer.getUint32(48, true), 11, 0xe6db99e5);
|
|
129
|
-
c = hh(c, d, a, b, buffer.getUint32(60, true), 16, 0x1fa27cf8);
|
|
130
|
-
b = hh(b, c, d, a, buffer.getUint32(8, true), 23, 0xc4ac5665);
|
|
131
|
-
a = ii(a, b, c, d, buffer.getUint32(0, true), 6, 0xf4292244);
|
|
132
|
-
d = ii(d, a, b, c, buffer.getUint32(28, true), 10, 0x432aff97);
|
|
133
|
-
c = ii(c, d, a, b, buffer.getUint32(56, true), 15, 0xab9423a7);
|
|
134
|
-
b = ii(b, c, d, a, buffer.getUint32(20, true), 21, 0xfc93a039);
|
|
135
|
-
a = ii(a, b, c, d, buffer.getUint32(48, true), 6, 0x655b59c3);
|
|
136
|
-
d = ii(d, a, b, c, buffer.getUint32(12, true), 10, 0x8f0ccc92);
|
|
137
|
-
c = ii(c, d, a, b, buffer.getUint32(40, true), 15, 0xffeff47d);
|
|
138
|
-
b = ii(b, c, d, a, buffer.getUint32(4, true), 21, 0x85845dd1);
|
|
139
|
-
a = ii(a, b, c, d, buffer.getUint32(32, true), 6, 0x6fa87e4f);
|
|
140
|
-
d = ii(d, a, b, c, buffer.getUint32(60, true), 10, 0xfe2ce6e0);
|
|
141
|
-
c = ii(c, d, a, b, buffer.getUint32(24, true), 15, 0xa3014314);
|
|
142
|
-
b = ii(b, c, d, a, buffer.getUint32(52, true), 21, 0x4e0811a1);
|
|
143
|
-
a = ii(a, b, c, d, buffer.getUint32(16, true), 6, 0xf7537e82);
|
|
144
|
-
d = ii(d, a, b, c, buffer.getUint32(44, true), 10, 0xbd3af235);
|
|
145
|
-
c = ii(c, d, a, b, buffer.getUint32(8, true), 15, 0x2ad7d2bb);
|
|
146
|
-
b = ii(b, c, d, a, buffer.getUint32(36, true), 21, 0xeb86d391);
|
|
147
|
-
state[0] = (a + state[0]) & 0xffffffff;
|
|
148
|
-
state[1] = (b + state[1]) & 0xffffffff;
|
|
149
|
-
state[2] = (c + state[2]) & 0xffffffff;
|
|
150
|
-
state[3] = (d + state[3]) & 0xffffffff;
|
|
204
|
+
return this.digestSync();
|
|
151
205
|
}
|
|
152
206
|
reset() {
|
|
153
|
-
this.state =
|
|
154
|
-
this.buffer = new
|
|
207
|
+
this.state = Int32Array.from(INIT);
|
|
208
|
+
this.buffer = new Uint8Array(64);
|
|
155
209
|
this.bufferLength = 0;
|
|
156
210
|
this.bytesHashed = 0;
|
|
157
|
-
this.finished = false;
|
|
158
211
|
}
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
}
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
}
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
}
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
212
|
+
digestSync() {
|
|
213
|
+
const state = this.state.slice();
|
|
214
|
+
const buffer = this.buffer.slice();
|
|
215
|
+
let bufferLength = this.bufferLength;
|
|
216
|
+
const bitsHashed = this.bytesHashed * 8;
|
|
217
|
+
const bufferView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
218
|
+
bufferView.setUint8(bufferLength++, 0x80);
|
|
219
|
+
if ((bufferLength - 1) % BLOCK >= BLOCK - 8) {
|
|
220
|
+
for (let i = bufferLength; i < BLOCK; ++i) {
|
|
221
|
+
bufferView.setUint8(i, 0);
|
|
222
|
+
}
|
|
223
|
+
this.hashBufferWith(state, buffer);
|
|
224
|
+
bufferLength = 0;
|
|
225
|
+
}
|
|
226
|
+
for (let i = bufferLength; i < BLOCK - 8; ++i) {
|
|
227
|
+
bufferView.setUint8(i, 0);
|
|
228
|
+
}
|
|
229
|
+
bufferView.setUint32(BLOCK - 8, Math.floor(bitsHashed / 0x100000000), false);
|
|
230
|
+
bufferView.setUint32(BLOCK - 4, bitsHashed, false);
|
|
231
|
+
this.hashBufferWith(state, buffer);
|
|
232
|
+
const out = new Uint8Array(DIGEST_LENGTH);
|
|
233
|
+
for (let i = 0; i < 8; ++i) {
|
|
234
|
+
out[i * 4] = (state[i] >>> 24) & 0xff;
|
|
235
|
+
out[i * 4 + 1] = (state[i] >>> 16) & 0xff;
|
|
236
|
+
out[i * 4 + 2] = (state[i] >>> 8) & 0xff;
|
|
237
|
+
out[i * 4 + 3] = (state[i] >>> 0) & 0xff;
|
|
238
|
+
}
|
|
239
|
+
return out;
|
|
240
|
+
}
|
|
241
|
+
static normalizeKey(secret) {
|
|
242
|
+
const key = toUint8Array(secret);
|
|
243
|
+
if (key.byteLength > BLOCK) {
|
|
244
|
+
const h = new Sha256Js();
|
|
245
|
+
h.update(key);
|
|
246
|
+
const out = h.digestSync();
|
|
247
|
+
const padded = new Uint8Array(BLOCK);
|
|
248
|
+
padded.set(out);
|
|
249
|
+
return padded;
|
|
250
|
+
}
|
|
251
|
+
if (key.byteLength < BLOCK) {
|
|
252
|
+
const padded = new Uint8Array(BLOCK);
|
|
253
|
+
padded.set(key);
|
|
254
|
+
return padded;
|
|
255
|
+
}
|
|
256
|
+
return key;
|
|
257
|
+
}
|
|
258
|
+
hashBuffer() {
|
|
259
|
+
this.hashBufferWith(this.state, this.buffer);
|
|
260
|
+
}
|
|
261
|
+
hashBufferWith(state, buffer) {
|
|
262
|
+
const w = (this.w ??= new Int32Array(64));
|
|
263
|
+
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];
|
|
264
|
+
for (let i = 0; i < BLOCK; ++i) {
|
|
265
|
+
if (i < 16) {
|
|
266
|
+
w[i] =
|
|
267
|
+
((buffer[i * 4] & 0xff) << 24) |
|
|
268
|
+
((buffer[i * 4 + 1] & 0xff) << 16) |
|
|
269
|
+
((buffer[i * 4 + 2] & 0xff) << 8) |
|
|
270
|
+
(buffer[i * 4 + 3] & 0xff);
|
|
271
|
+
}
|
|
272
|
+
else {
|
|
273
|
+
let u = w[i - 2];
|
|
274
|
+
const t1 = ((u >>> 17) | (u << 15)) ^ ((u >>> 19) | (u << 13)) ^ (u >>> 10);
|
|
275
|
+
u = w[i - 15];
|
|
276
|
+
const t2 = ((u >>> 7) | (u << 25)) ^ ((u >>> 18) | (u << 14)) ^ (u >>> 3);
|
|
277
|
+
w[i] = ((t1 + w[i - 7]) | 0) + ((t2 + w[i - 16]) | 0);
|
|
278
|
+
}
|
|
279
|
+
const t1 = ((((((s4 >>> 6) | (s4 << 26)) ^ ((s4 >>> 11) | (s4 << 21)) ^ ((s4 >>> 25) | (s4 << 7))) +
|
|
280
|
+
((s4 & s5) ^ (~s4 & s6))) |
|
|
281
|
+
0) +
|
|
282
|
+
((s7 + ((K[i] + w[i]) | 0)) | 0)) |
|
|
283
|
+
0;
|
|
284
|
+
const t2 = ((((s0 >>> 2) | (s0 << 30)) ^ ((s0 >>> 13) | (s0 << 19)) ^ ((s0 >>> 22) | (s0 << 10))) +
|
|
285
|
+
((s0 & s1) ^ (s0 & s2) ^ (s1 & s2))) |
|
|
286
|
+
0;
|
|
287
|
+
s7 = s6;
|
|
288
|
+
s6 = s5;
|
|
289
|
+
s5 = s4;
|
|
290
|
+
s4 = (s3 + t1) | 0;
|
|
291
|
+
s3 = s2;
|
|
292
|
+
s2 = s1;
|
|
293
|
+
s1 = s0;
|
|
294
|
+
s0 = (t1 + t2) | 0;
|
|
295
|
+
}
|
|
296
|
+
state[0] += s0;
|
|
297
|
+
state[1] += s1;
|
|
298
|
+
state[2] += s2;
|
|
299
|
+
state[3] += s3;
|
|
300
|
+
state[4] += s4;
|
|
301
|
+
state[5] += s5;
|
|
302
|
+
state[6] += s6;
|
|
303
|
+
state[7] += s7;
|
|
179
304
|
}
|
|
180
|
-
return data.byteLength === 0;
|
|
181
305
|
}
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
306
|
+
const INIT = new Int32Array([
|
|
307
|
+
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
|
|
308
|
+
]);
|
|
309
|
+
const K = new Int32Array([
|
|
310
|
+
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
|
311
|
+
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
|
312
|
+
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
|
313
|
+
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
|
|
314
|
+
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
|
315
|
+
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
|
316
|
+
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
|
317
|
+
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
|
|
318
|
+
]);
|
|
319
|
+
|
|
320
|
+
const { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
|
|
321
|
+
const subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function"
|
|
322
|
+
? globalThis.crypto.subtle
|
|
323
|
+
: undefined;
|
|
324
|
+
const MAX_PENDING_BYTES = 8 * 1024 * 1024;
|
|
325
|
+
class Sha256WebCrypto {
|
|
326
|
+
digestLength = 32;
|
|
327
|
+
secret;
|
|
328
|
+
pending = [];
|
|
329
|
+
pendingBytes = 0;
|
|
330
|
+
fallback;
|
|
331
|
+
finished = false;
|
|
332
|
+
constructor(secret) {
|
|
333
|
+
if (secret) {
|
|
334
|
+
this.secret = toUint8Array(secret);
|
|
335
|
+
}
|
|
336
|
+
}
|
|
337
|
+
update(data) {
|
|
338
|
+
if (this.finished) {
|
|
339
|
+
throw new Error("Attempted to update an already finished HMAC.");
|
|
340
|
+
}
|
|
341
|
+
if (this.fallback) {
|
|
342
|
+
this.fallback.update(data);
|
|
343
|
+
return;
|
|
344
|
+
}
|
|
345
|
+
this.pending.push(data.slice());
|
|
346
|
+
this.pendingBytes += data.byteLength;
|
|
347
|
+
if (this.pendingBytes >= MAX_PENDING_BYTES) {
|
|
348
|
+
this.switchToFallback();
|
|
349
|
+
}
|
|
185
350
|
}
|
|
186
|
-
|
|
187
|
-
|
|
351
|
+
async digest() {
|
|
352
|
+
if (this.fallback) {
|
|
353
|
+
return this.fallback.digest();
|
|
354
|
+
}
|
|
355
|
+
if (this.secret && this.finished) {
|
|
356
|
+
throw new Error("Attempted to digest an already finished HMAC.");
|
|
357
|
+
}
|
|
358
|
+
const data = concatBytes(this.pending);
|
|
359
|
+
if (subtle) {
|
|
360
|
+
if (this.secret) {
|
|
361
|
+
this.finished = true;
|
|
362
|
+
const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
|
|
363
|
+
const sig = await subtle.sign("HMAC", key, data);
|
|
364
|
+
return new Uint8Array(sig);
|
|
365
|
+
}
|
|
366
|
+
const hash = await subtle.digest("SHA-256", data);
|
|
367
|
+
return new Uint8Array(hash);
|
|
368
|
+
}
|
|
369
|
+
const sha256 = new Sha256Js(this.secret);
|
|
370
|
+
sha256.update(data);
|
|
371
|
+
return sha256.digest();
|
|
372
|
+
}
|
|
373
|
+
reset() {
|
|
374
|
+
this.pending = [];
|
|
375
|
+
this.pendingBytes = 0;
|
|
376
|
+
this.fallback = undefined;
|
|
377
|
+
this.finished = false;
|
|
378
|
+
}
|
|
379
|
+
switchToFallback() {
|
|
380
|
+
const sha256Js = new Sha256Js(this.secret);
|
|
381
|
+
for (const chunk of this.pending) {
|
|
382
|
+
sha256Js.update(chunk);
|
|
383
|
+
}
|
|
384
|
+
this.fallback = sha256Js;
|
|
385
|
+
this.pending = [];
|
|
386
|
+
this.pendingBytes = 0;
|
|
188
387
|
}
|
|
189
|
-
return new Uint8Array(data);
|
|
190
388
|
}
|
|
191
389
|
|
|
192
390
|
function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
|
|
@@ -219,8 +417,20 @@ function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
|
|
|
219
417
|
const no = Symbol.for("node-only");
|
|
220
418
|
const fileStreamHasher = no;
|
|
221
419
|
const readableStreamHasher = no;
|
|
420
|
+
const Md5Node = no;
|
|
421
|
+
const Crc32Node = no;
|
|
422
|
+
const Sha256Node = no;
|
|
222
423
|
|
|
223
|
-
exports.
|
|
424
|
+
exports.Crc32 = Crc32Js;
|
|
425
|
+
exports.Crc32Js = Crc32Js;
|
|
426
|
+
exports.Crc32Node = Crc32Node;
|
|
427
|
+
exports.Md5 = Md5Js;
|
|
428
|
+
exports.Md5Js = Md5Js;
|
|
429
|
+
exports.Md5Node = Md5Node;
|
|
430
|
+
exports.Sha256 = Sha256WebCrypto;
|
|
431
|
+
exports.Sha256Js = Sha256Js;
|
|
432
|
+
exports.Sha256Node = Sha256Node;
|
|
433
|
+
exports.Sha256WebCrypto = Sha256WebCrypto;
|
|
224
434
|
exports.blobHasher = blobHasher;
|
|
225
435
|
exports.blobReader = blobReader;
|
|
226
436
|
exports.fileStreamHasher = fileStreamHasher;
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
const { Uint8ArrayBlobAdapter, sdkStreamMixin, splitEvery, splitHeader, fromBase64, _parseEpochTimestamp, _parseRfc7231DateTime, _parseRfc3339DateTimeWithOffset, LazyJsonString, NumericValue, toUtf8, fromUtf8, generateIdempotencyToken, toBase64, dateToUtcString, quoteHeader } = require("@smithy/core/serde");
|
|
2
2
|
const { TypeRegistry, NormalizedSchema, translateTraits } = require("@smithy/core/schema");
|
|
3
|
-
const { HttpRequest, HttpResponse } = require("@smithy/core/transport");
|
|
4
|
-
const {
|
|
3
|
+
const { HttpRequest, HttpResponse, isValidHostname } = require("@smithy/core/transport");
|
|
4
|
+
const { parseQueryString, parseUrl } = require("@smithy/core/transport");
|
|
5
5
|
exports.HttpRequest = HttpRequest;
|
|
6
6
|
exports.HttpResponse = HttpResponse;
|
|
7
7
|
exports.isValidHostname = isValidHostname;
|
|
@@ -116,6 +116,9 @@ class HttpProtocol extends SerdeContext {
|
|
|
116
116
|
hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
|
|
117
117
|
}
|
|
118
118
|
request.hostname = hostPrefix + request.hostname;
|
|
119
|
+
if (!isValidHostname(request.hostname)) {
|
|
120
|
+
throw new Error(`[${request.hostname}] is not a valid hostname.`);
|
|
121
|
+
}
|
|
119
122
|
}
|
|
120
123
|
}
|
|
121
124
|
}
|
|
@@ -863,6 +863,9 @@ const calculateBodyLength = (body) => {
|
|
|
863
863
|
};
|
|
864
864
|
|
|
865
865
|
const toUint8Array = (data) => {
|
|
866
|
+
if (data instanceof Uint8Array) {
|
|
867
|
+
return data;
|
|
868
|
+
}
|
|
866
869
|
if (typeof data === "string") {
|
|
867
870
|
return fromUtf8(data);
|
|
868
871
|
}
|
|
@@ -872,6 +875,22 @@ const toUint8Array = (data) => {
|
|
|
872
875
|
return new Uint8Array(data);
|
|
873
876
|
};
|
|
874
877
|
|
|
878
|
+
function concatBytes(arrays, length) {
|
|
879
|
+
if (length === undefined) {
|
|
880
|
+
length = 0;
|
|
881
|
+
for (const bytes of arrays) {
|
|
882
|
+
length += bytes.byteLength;
|
|
883
|
+
}
|
|
884
|
+
}
|
|
885
|
+
const result = new Uint8Array(length);
|
|
886
|
+
let offset = 0;
|
|
887
|
+
for (const buf of arrays) {
|
|
888
|
+
result.set(buf, offset);
|
|
889
|
+
offset += buf.byteLength;
|
|
890
|
+
}
|
|
891
|
+
return result;
|
|
892
|
+
}
|
|
893
|
+
|
|
875
894
|
const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
|
|
876
895
|
Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
|
|
877
896
|
|
|
@@ -1201,56 +1220,29 @@ async function headStream(stream, bytes) {
|
|
|
1201
1220
|
}
|
|
1202
1221
|
|
|
1203
1222
|
const streamCollector = async (stream) => {
|
|
1204
|
-
if ((
|
|
1205
|
-
if (Blob.prototype.arrayBuffer !== undefined) {
|
|
1206
|
-
return new Uint8Array(await stream.arrayBuffer());
|
|
1207
|
-
}
|
|
1223
|
+
if (isBlob(stream)) {
|
|
1208
1224
|
return collectBlob(stream);
|
|
1209
1225
|
}
|
|
1210
|
-
return
|
|
1226
|
+
return collectReadableStream(stream);
|
|
1211
1227
|
};
|
|
1212
1228
|
async function collectBlob(blob) {
|
|
1213
|
-
|
|
1214
|
-
const arrayBuffer = fromBase64(base64);
|
|
1215
|
-
return new Uint8Array(arrayBuffer);
|
|
1229
|
+
return blob.arrayBuffer().then((ab) => new Uint8Array(ab));
|
|
1216
1230
|
}
|
|
1217
|
-
async function
|
|
1231
|
+
async function collectReadableStream(stream) {
|
|
1218
1232
|
const chunks = [];
|
|
1219
1233
|
const reader = stream.getReader();
|
|
1220
|
-
let isDone = false;
|
|
1221
1234
|
let length = 0;
|
|
1222
|
-
while (
|
|
1235
|
+
while (true) {
|
|
1223
1236
|
const { done, value } = await reader.read();
|
|
1224
1237
|
if (value) {
|
|
1225
1238
|
chunks.push(value);
|
|
1226
1239
|
length += value.length;
|
|
1227
1240
|
}
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1231
|
-
let offset = 0;
|
|
1232
|
-
for (const chunk of chunks) {
|
|
1233
|
-
collected.set(chunk, offset);
|
|
1234
|
-
offset += chunk.length;
|
|
1241
|
+
if (done) {
|
|
1242
|
+
break;
|
|
1243
|
+
}
|
|
1235
1244
|
}
|
|
1236
|
-
return
|
|
1237
|
-
}
|
|
1238
|
-
function readToBase64(blob) {
|
|
1239
|
-
return new Promise((resolve, reject) => {
|
|
1240
|
-
const reader = new FileReader();
|
|
1241
|
-
reader.onloadend = () => {
|
|
1242
|
-
if (reader.readyState !== 2) {
|
|
1243
|
-
return reject(new Error("Reader aborted too early"));
|
|
1244
|
-
}
|
|
1245
|
-
const result = (reader.result ?? "");
|
|
1246
|
-
const commaIndex = result.indexOf(",");
|
|
1247
|
-
const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
|
|
1248
|
-
resolve(result.substring(dataOffset));
|
|
1249
|
-
};
|
|
1250
|
-
reader.onabort = () => reject(new Error("Read aborted"));
|
|
1251
|
-
reader.onerror = () => reject(reader.error);
|
|
1252
|
-
reader.readAsDataURL(blob);
|
|
1253
|
-
});
|
|
1245
|
+
return concatBytes(chunks, length);
|
|
1254
1246
|
}
|
|
1255
1247
|
|
|
1256
1248
|
const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
|
|
@@ -1340,6 +1332,7 @@ exports._parseEpochTimestamp = _parseEpochTimestamp;
|
|
|
1340
1332
|
exports._parseRfc3339DateTimeWithOffset = _parseRfc3339DateTimeWithOffset;
|
|
1341
1333
|
exports._parseRfc7231DateTime = _parseRfc7231DateTime;
|
|
1342
1334
|
exports.calculateBodyLength = calculateBodyLength;
|
|
1335
|
+
exports.concatBytes = concatBytes;
|
|
1343
1336
|
exports.copyDocumentWithTransform = copyDocumentWithTransform;
|
|
1344
1337
|
exports.createBufferedReadable = createBufferedReadable;
|
|
1345
1338
|
exports.createChecksumStream = createChecksumStream;
|
|
@@ -1388,6 +1381,7 @@ exports.serializerMiddlewareOption = serializerMiddlewareOption;
|
|
|
1388
1381
|
exports.splitEvery = splitEvery;
|
|
1389
1382
|
exports.splitHeader = splitHeader;
|
|
1390
1383
|
exports.splitStream = splitStream;
|
|
1384
|
+
exports.streamCollector = streamCollector;
|
|
1391
1385
|
exports.strictParseByte = strictParseByte;
|
|
1392
1386
|
exports.strictParseDouble = strictParseDouble;
|
|
1393
1387
|
exports.strictParseFloat = strictParseFloat;
|