fix: 修复配额说明重复和undefined问题
- 在editStorageForm中初始化oss_storage_quota_value和oss_quota_unit - 删除重复的旧配额说明块，保留新的当前配额设置显示 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
556
backend/node_modules/@smithy/signature-v4/dist-cjs/index.js
generated
vendored
Normal file
556
backend/node_modules/@smithy/signature-v4/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,556 @@
|
||||
'use strict';
|
||||
|
||||
var utilHexEncoding = require('@smithy/util-hex-encoding');
|
||||
var utilUtf8 = require('@smithy/util-utf8');
|
||||
var isArrayBuffer = require('@smithy/is-array-buffer');
|
||||
var protocolHttp = require('@smithy/protocol-http');
|
||||
var utilMiddleware = require('@smithy/util-middleware');
|
||||
var utilUriEscape = require('@smithy/util-uri-escape');
|
||||
|
||||
const ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm";
|
||||
const CREDENTIAL_QUERY_PARAM = "X-Amz-Credential";
|
||||
const AMZ_DATE_QUERY_PARAM = "X-Amz-Date";
|
||||
const SIGNED_HEADERS_QUERY_PARAM = "X-Amz-SignedHeaders";
|
||||
const EXPIRES_QUERY_PARAM = "X-Amz-Expires";
|
||||
const SIGNATURE_QUERY_PARAM = "X-Amz-Signature";
|
||||
const TOKEN_QUERY_PARAM = "X-Amz-Security-Token";
|
||||
const REGION_SET_PARAM = "X-Amz-Region-Set";
|
||||
const AUTH_HEADER = "authorization";
|
||||
const AMZ_DATE_HEADER = AMZ_DATE_QUERY_PARAM.toLowerCase();
|
||||
const DATE_HEADER = "date";
|
||||
const GENERATED_HEADERS = [AUTH_HEADER, AMZ_DATE_HEADER, DATE_HEADER];
|
||||
const SIGNATURE_HEADER = SIGNATURE_QUERY_PARAM.toLowerCase();
|
||||
const SHA256_HEADER = "x-amz-content-sha256";
|
||||
const TOKEN_HEADER = TOKEN_QUERY_PARAM.toLowerCase();
|
||||
const HOST_HEADER = "host";
|
||||
const ALWAYS_UNSIGNABLE_HEADERS = {
|
||||
authorization: true,
|
||||
"cache-control": true,
|
||||
connection: true,
|
||||
expect: true,
|
||||
from: true,
|
||||
"keep-alive": true,
|
||||
"max-forwards": true,
|
||||
pragma: true,
|
||||
referer: true,
|
||||
te: true,
|
||||
trailer: true,
|
||||
"transfer-encoding": true,
|
||||
upgrade: true,
|
||||
"user-agent": true,
|
||||
"x-amzn-trace-id": true,
|
||||
};
|
||||
const PROXY_HEADER_PATTERN = /^proxy-/;
|
||||
const SEC_HEADER_PATTERN = /^sec-/;
|
||||
const UNSIGNABLE_PATTERNS = [/^proxy-/i, /^sec-/i];
|
||||
const ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256";
|
||||
const ALGORITHM_IDENTIFIER_V4A = "AWS4-ECDSA-P256-SHA256";
|
||||
const EVENT_ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256-PAYLOAD";
|
||||
const UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
|
||||
const MAX_CACHE_SIZE = 50;
|
||||
const KEY_TYPE_IDENTIFIER = "aws4_request";
|
||||
const MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7;
|
||||
|
||||
const signingKeyCache = {};
|
||||
const cacheQueue = [];
|
||||
const createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`;
|
||||
const getSigningKey = async (sha256Constructor, credentials, shortDate, region, service) => {
|
||||
const credsHash = await hmac(sha256Constructor, credentials.secretAccessKey, credentials.accessKeyId);
|
||||
const cacheKey = `${shortDate}:${region}:${service}:${utilHexEncoding.toHex(credsHash)}:${credentials.sessionToken}`;
|
||||
if (cacheKey in signingKeyCache) {
|
||||
return signingKeyCache[cacheKey];
|
||||
}
|
||||
cacheQueue.push(cacheKey);
|
||||
while (cacheQueue.length > MAX_CACHE_SIZE) {
|
||||
delete signingKeyCache[cacheQueue.shift()];
|
||||
}
|
||||
let key = `AWS4${credentials.secretAccessKey}`;
|
||||
for (const signable of [shortDate, region, service, KEY_TYPE_IDENTIFIER]) {
|
||||
key = await hmac(sha256Constructor, key, signable);
|
||||
}
|
||||
return (signingKeyCache[cacheKey] = key);
|
||||
};
|
||||
const clearCredentialCache = () => {
|
||||
cacheQueue.length = 0;
|
||||
Object.keys(signingKeyCache).forEach((cacheKey) => {
|
||||
delete signingKeyCache[cacheKey];
|
||||
});
|
||||
};
|
||||
const hmac = (ctor, secret, data) => {
|
||||
const hash = new ctor(secret);
|
||||
hash.update(utilUtf8.toUint8Array(data));
|
||||
return hash.digest();
|
||||
};
|
||||
|
||||
const getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
|
||||
const canonical = {};
|
||||
for (const headerName of Object.keys(headers).sort()) {
|
||||
if (headers[headerName] == undefined) {
|
||||
continue;
|
||||
}
|
||||
const canonicalHeaderName = headerName.toLowerCase();
|
||||
if (canonicalHeaderName in ALWAYS_UNSIGNABLE_HEADERS ||
|
||||
unsignableHeaders?.has(canonicalHeaderName) ||
|
||||
PROXY_HEADER_PATTERN.test(canonicalHeaderName) ||
|
||||
SEC_HEADER_PATTERN.test(canonicalHeaderName)) {
|
||||
if (!signableHeaders || (signableHeaders && !signableHeaders.has(canonicalHeaderName))) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " ");
|
||||
}
|
||||
return canonical;
|
||||
};
|
||||
|
||||
const getPayloadHash = async ({ headers, body }, hashConstructor) => {
|
||||
for (const headerName of Object.keys(headers)) {
|
||||
if (headerName.toLowerCase() === SHA256_HEADER) {
|
||||
return headers[headerName];
|
||||
}
|
||||
}
|
||||
if (body == undefined) {
|
||||
return "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
|
||||
}
|
||||
else if (typeof body === "string" || ArrayBuffer.isView(body) || isArrayBuffer.isArrayBuffer(body)) {
|
||||
const hashCtor = new hashConstructor();
|
||||
hashCtor.update(utilUtf8.toUint8Array(body));
|
||||
return utilHexEncoding.toHex(await hashCtor.digest());
|
||||
}
|
||||
return UNSIGNED_PAYLOAD;
|
||||
};
|
||||
|
||||
class HeaderFormatter {
|
||||
format(headers) {
|
||||
const chunks = [];
|
||||
for (const headerName of Object.keys(headers)) {
|
||||
const bytes = utilUtf8.fromUtf8(headerName);
|
||||
chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
|
||||
}
|
||||
const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
|
||||
let position = 0;
|
||||
for (const chunk of chunks) {
|
||||
out.set(chunk, position);
|
||||
position += chunk.byteLength;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
formatHeaderValue(header) {
|
||||
switch (header.type) {
|
||||
case "boolean":
|
||||
return Uint8Array.from([header.value ? 0 : 1]);
|
||||
case "byte":
|
||||
return Uint8Array.from([2, header.value]);
|
||||
case "short":
|
||||
const shortView = new DataView(new ArrayBuffer(3));
|
||||
shortView.setUint8(0, 3);
|
||||
shortView.setInt16(1, header.value, false);
|
||||
return new Uint8Array(shortView.buffer);
|
||||
case "integer":
|
||||
const intView = new DataView(new ArrayBuffer(5));
|
||||
intView.setUint8(0, 4);
|
||||
intView.setInt32(1, header.value, false);
|
||||
return new Uint8Array(intView.buffer);
|
||||
case "long":
|
||||
const longBytes = new Uint8Array(9);
|
||||
longBytes[0] = 5;
|
||||
longBytes.set(header.value.bytes, 1);
|
||||
return longBytes;
|
||||
case "binary":
|
||||
const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
|
||||
binView.setUint8(0, 6);
|
||||
binView.setUint16(1, header.value.byteLength, false);
|
||||
const binBytes = new Uint8Array(binView.buffer);
|
||||
binBytes.set(header.value, 3);
|
||||
return binBytes;
|
||||
case "string":
|
||||
const utf8Bytes = utilUtf8.fromUtf8(header.value);
|
||||
const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
|
||||
strView.setUint8(0, 7);
|
||||
strView.setUint16(1, utf8Bytes.byteLength, false);
|
||||
const strBytes = new Uint8Array(strView.buffer);
|
||||
strBytes.set(utf8Bytes, 3);
|
||||
return strBytes;
|
||||
case "timestamp":
|
||||
const tsBytes = new Uint8Array(9);
|
||||
tsBytes[0] = 8;
|
||||
tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
|
||||
return tsBytes;
|
||||
case "uuid":
|
||||
if (!UUID_PATTERN.test(header.value)) {
|
||||
throw new Error(`Invalid UUID received: ${header.value}`);
|
||||
}
|
||||
const uuidBytes = new Uint8Array(17);
|
||||
uuidBytes[0] = 9;
|
||||
uuidBytes.set(utilHexEncoding.fromHex(header.value.replace(/\-/g, "")), 1);
|
||||
return uuidBytes;
|
||||
}
|
||||
}
|
||||
}
|
||||
const UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
|
||||
class Int64 {
|
||||
bytes;
|
||||
constructor(bytes) {
|
||||
this.bytes = bytes;
|
||||
if (bytes.byteLength !== 8) {
|
||||
throw new Error("Int64 buffers must be exactly 8 bytes");
|
||||
}
|
||||
}
|
||||
static fromNumber(number) {
|
||||
if (number > 9_223_372_036_854_775_807 || number < -9223372036854776e3) {
|
||||
throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
|
||||
}
|
||||
const bytes = new Uint8Array(8);
|
||||
for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) {
|
||||
bytes[i] = remaining;
|
||||
}
|
||||
if (number < 0) {
|
||||
negate(bytes);
|
||||
}
|
||||
return new Int64(bytes);
|
||||
}
|
||||
valueOf() {
|
||||
const bytes = this.bytes.slice(0);
|
||||
const negative = bytes[0] & 0b10000000;
|
||||
if (negative) {
|
||||
negate(bytes);
|
||||
}
|
||||
return parseInt(utilHexEncoding.toHex(bytes), 16) * (negative ? -1 : 1);
|
||||
}
|
||||
toString() {
|
||||
return String(this.valueOf());
|
||||
}
|
||||
}
|
||||
function negate(bytes) {
|
||||
for (let i = 0; i < 8; i++) {
|
||||
bytes[i] ^= 0xff;
|
||||
}
|
||||
for (let i = 7; i > -1; i--) {
|
||||
bytes[i]++;
|
||||
if (bytes[i] !== 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
const hasHeader = (soughtHeader, headers) => {
|
||||
soughtHeader = soughtHeader.toLowerCase();
|
||||
for (const headerName of Object.keys(headers)) {
|
||||
if (soughtHeader === headerName.toLowerCase()) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
const moveHeadersToQuery = (request, options = {}) => {
|
||||
const { headers, query = {} } = protocolHttp.HttpRequest.clone(request);
|
||||
for (const name of Object.keys(headers)) {
|
||||
const lname = name.toLowerCase();
|
||||
if ((lname.slice(0, 6) === "x-amz-" && !options.unhoistableHeaders?.has(lname)) ||
|
||||
options.hoistableHeaders?.has(lname)) {
|
||||
query[name] = headers[name];
|
||||
delete headers[name];
|
||||
}
|
||||
}
|
||||
return {
|
||||
...request,
|
||||
headers,
|
||||
query,
|
||||
};
|
||||
};
|
||||
|
||||
const prepareRequest = (request) => {
|
||||
request = protocolHttp.HttpRequest.clone(request);
|
||||
for (const headerName of Object.keys(request.headers)) {
|
||||
if (GENERATED_HEADERS.indexOf(headerName.toLowerCase()) > -1) {
|
||||
delete request.headers[headerName];
|
||||
}
|
||||
}
|
||||
return request;
|
||||
};
|
||||
|
||||
const getCanonicalQuery = ({ query = {} }) => {
|
||||
const keys = [];
|
||||
const serialized = {};
|
||||
for (const key of Object.keys(query)) {
|
||||
if (key.toLowerCase() === SIGNATURE_HEADER) {
|
||||
continue;
|
||||
}
|
||||
const encodedKey = utilUriEscape.escapeUri(key);
|
||||
keys.push(encodedKey);
|
||||
const value = query[key];
|
||||
if (typeof value === "string") {
|
||||
serialized[encodedKey] = `${encodedKey}=${utilUriEscape.escapeUri(value)}`;
|
||||
}
|
||||
else if (Array.isArray(value)) {
|
||||
serialized[encodedKey] = value
|
||||
.slice(0)
|
||||
.reduce((encoded, value) => encoded.concat([`${encodedKey}=${utilUriEscape.escapeUri(value)}`]), [])
|
||||
.sort()
|
||||
.join("&");
|
||||
}
|
||||
}
|
||||
return keys
|
||||
.sort()
|
||||
.map((key) => serialized[key])
|
||||
.filter((serialized) => serialized)
|
||||
.join("&");
|
||||
};
|
||||
|
||||
const iso8601 = (time) => toDate(time)
|
||||
.toISOString()
|
||||
.replace(/\.\d{3}Z$/, "Z");
|
||||
const toDate = (time) => {
|
||||
if (typeof time === "number") {
|
||||
return new Date(time * 1000);
|
||||
}
|
||||
if (typeof time === "string") {
|
||||
if (Number(time)) {
|
||||
return new Date(Number(time) * 1000);
|
||||
}
|
||||
return new Date(time);
|
||||
}
|
||||
return time;
|
||||
};
|
||||
|
||||
class SignatureV4Base {
|
||||
service;
|
||||
regionProvider;
|
||||
credentialProvider;
|
||||
sha256;
|
||||
uriEscapePath;
|
||||
applyChecksum;
|
||||
constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true, }) {
|
||||
this.service = service;
|
||||
this.sha256 = sha256;
|
||||
this.uriEscapePath = uriEscapePath;
|
||||
this.applyChecksum = typeof applyChecksum === "boolean" ? applyChecksum : true;
|
||||
this.regionProvider = utilMiddleware.normalizeProvider(region);
|
||||
this.credentialProvider = utilMiddleware.normalizeProvider(credentials);
|
||||
}
|
||||
createCanonicalRequest(request, canonicalHeaders, payloadHash) {
|
||||
const sortedHeaders = Object.keys(canonicalHeaders).sort();
|
||||
return `${request.method}
|
||||
${this.getCanonicalPath(request)}
|
||||
${getCanonicalQuery(request)}
|
||||
${sortedHeaders.map((name) => `${name}:${canonicalHeaders[name]}`).join("\n")}
|
||||
|
||||
${sortedHeaders.join(";")}
|
||||
${payloadHash}`;
|
||||
}
|
||||
async createStringToSign(longDate, credentialScope, canonicalRequest, algorithmIdentifier) {
|
||||
const hash = new this.sha256();
|
||||
hash.update(utilUtf8.toUint8Array(canonicalRequest));
|
||||
const hashedRequest = await hash.digest();
|
||||
return `${algorithmIdentifier}
|
||||
${longDate}
|
||||
${credentialScope}
|
||||
${utilHexEncoding.toHex(hashedRequest)}`;
|
||||
}
|
||||
getCanonicalPath({ path }) {
|
||||
if (this.uriEscapePath) {
|
||||
const normalizedPathSegments = [];
|
||||
for (const pathSegment of path.split("/")) {
|
||||
if (pathSegment?.length === 0)
|
||||
continue;
|
||||
if (pathSegment === ".")
|
||||
continue;
|
||||
if (pathSegment === "..") {
|
||||
normalizedPathSegments.pop();
|
||||
}
|
||||
else {
|
||||
normalizedPathSegments.push(pathSegment);
|
||||
}
|
||||
}
|
||||
const normalizedPath = `${path?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path?.endsWith("/") ? "/" : ""}`;
|
||||
const doubleEncoded = utilUriEscape.escapeUri(normalizedPath);
|
||||
return doubleEncoded.replace(/%2F/g, "/");
|
||||
}
|
||||
return path;
|
||||
}
|
||||
validateResolvedCredentials(credentials) {
|
||||
if (typeof credentials !== "object" ||
|
||||
typeof credentials.accessKeyId !== "string" ||
|
||||
typeof credentials.secretAccessKey !== "string") {
|
||||
throw new Error("Resolved credential object is not valid");
|
||||
}
|
||||
}
|
||||
formatDate(now) {
|
||||
const longDate = iso8601(now).replace(/[\-:]/g, "");
|
||||
return {
|
||||
longDate,
|
||||
shortDate: longDate.slice(0, 8),
|
||||
};
|
||||
}
|
||||
getCanonicalHeaderList(headers) {
|
||||
return Object.keys(headers).sort().join(";");
|
||||
}
|
||||
}
|
||||
|
||||
class SignatureV4 extends SignatureV4Base {
|
||||
headerFormatter = new HeaderFormatter();
|
||||
constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true, }) {
|
||||
super({
|
||||
applyChecksum,
|
||||
credentials,
|
||||
region,
|
||||
service,
|
||||
sha256,
|
||||
uriEscapePath,
|
||||
});
|
||||
}
|
||||
async presign(originalRequest, options = {}) {
|
||||
const { signingDate = new Date(), expiresIn = 3600, unsignableHeaders, unhoistableHeaders, signableHeaders, hoistableHeaders, signingRegion, signingService, } = options;
|
||||
const credentials = await this.credentialProvider();
|
||||
this.validateResolvedCredentials(credentials);
|
||||
const region = signingRegion ?? (await this.regionProvider());
|
||||
const { longDate, shortDate } = this.formatDate(signingDate);
|
||||
if (expiresIn > MAX_PRESIGNED_TTL) {
|
||||
return Promise.reject("Signature version 4 presigned URLs" + " must have an expiration date less than one week in" + " the future");
|
||||
}
|
||||
const scope = createScope(shortDate, region, signingService ?? this.service);
|
||||
const request = moveHeadersToQuery(prepareRequest(originalRequest), { unhoistableHeaders, hoistableHeaders });
|
||||
if (credentials.sessionToken) {
|
||||
request.query[TOKEN_QUERY_PARAM] = credentials.sessionToken;
|
||||
}
|
||||
request.query[ALGORITHM_QUERY_PARAM] = ALGORITHM_IDENTIFIER;
|
||||
request.query[CREDENTIAL_QUERY_PARAM] = `${credentials.accessKeyId}/${scope}`;
|
||||
request.query[AMZ_DATE_QUERY_PARAM] = longDate;
|
||||
request.query[EXPIRES_QUERY_PARAM] = expiresIn.toString(10);
|
||||
const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
|
||||
request.query[SIGNED_HEADERS_QUERY_PARAM] = this.getCanonicalHeaderList(canonicalHeaders);
|
||||
request.query[SIGNATURE_QUERY_PARAM] = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, await getPayloadHash(originalRequest, this.sha256)));
|
||||
return request;
|
||||
}
|
||||
async sign(toSign, options) {
|
||||
if (typeof toSign === "string") {
|
||||
return this.signString(toSign, options);
|
||||
}
|
||||
else if (toSign.headers && toSign.payload) {
|
||||
return this.signEvent(toSign, options);
|
||||
}
|
||||
else if (toSign.message) {
|
||||
return this.signMessage(toSign, options);
|
||||
}
|
||||
else {
|
||||
return this.signRequest(toSign, options);
|
||||
}
|
||||
}
|
||||
async signEvent({ headers, payload }, { signingDate = new Date(), priorSignature, signingRegion, signingService }) {
|
||||
const region = signingRegion ?? (await this.regionProvider());
|
||||
const { shortDate, longDate } = this.formatDate(signingDate);
|
||||
const scope = createScope(shortDate, region, signingService ?? this.service);
|
||||
const hashedPayload = await getPayloadHash({ headers: {}, body: payload }, this.sha256);
|
||||
const hash = new this.sha256();
|
||||
hash.update(headers);
|
||||
const hashedHeaders = utilHexEncoding.toHex(await hash.digest());
|
||||
const stringToSign = [
|
||||
EVENT_ALGORITHM_IDENTIFIER,
|
||||
longDate,
|
||||
scope,
|
||||
priorSignature,
|
||||
hashedHeaders,
|
||||
hashedPayload,
|
||||
].join("\n");
|
||||
return this.signString(stringToSign, { signingDate, signingRegion: region, signingService });
|
||||
}
|
||||
async signMessage(signableMessage, { signingDate = new Date(), signingRegion, signingService }) {
|
||||
const promise = this.signEvent({
|
||||
headers: this.headerFormatter.format(signableMessage.message.headers),
|
||||
payload: signableMessage.message.body,
|
||||
}, {
|
||||
signingDate,
|
||||
signingRegion,
|
||||
signingService,
|
||||
priorSignature: signableMessage.priorSignature,
|
||||
});
|
||||
return promise.then((signature) => {
|
||||
return { message: signableMessage.message, signature };
|
||||
});
|
||||
}
|
||||
async signString(stringToSign, { signingDate = new Date(), signingRegion, signingService } = {}) {
|
||||
const credentials = await this.credentialProvider();
|
||||
this.validateResolvedCredentials(credentials);
|
||||
const region = signingRegion ?? (await this.regionProvider());
|
||||
const { shortDate } = this.formatDate(signingDate);
|
||||
const hash = new this.sha256(await this.getSigningKey(credentials, region, shortDate, signingService));
|
||||
hash.update(utilUtf8.toUint8Array(stringToSign));
|
||||
return utilHexEncoding.toHex(await hash.digest());
|
||||
}
|
||||
async signRequest(requestToSign, { signingDate = new Date(), signableHeaders, unsignableHeaders, signingRegion, signingService, } = {}) {
|
||||
const credentials = await this.credentialProvider();
|
||||
this.validateResolvedCredentials(credentials);
|
||||
const region = signingRegion ?? (await this.regionProvider());
|
||||
const request = prepareRequest(requestToSign);
|
||||
const { longDate, shortDate } = this.formatDate(signingDate);
|
||||
const scope = createScope(shortDate, region, signingService ?? this.service);
|
||||
request.headers[AMZ_DATE_HEADER] = longDate;
|
||||
if (credentials.sessionToken) {
|
||||
request.headers[TOKEN_HEADER] = credentials.sessionToken;
|
||||
}
|
||||
const payloadHash = await getPayloadHash(request, this.sha256);
|
||||
if (!hasHeader(SHA256_HEADER, request.headers) && this.applyChecksum) {
|
||||
request.headers[SHA256_HEADER] = payloadHash;
|
||||
}
|
||||
const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
|
||||
const signature = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, payloadHash));
|
||||
request.headers[AUTH_HEADER] =
|
||||
`${ALGORITHM_IDENTIFIER} ` +
|
||||
`Credential=${credentials.accessKeyId}/${scope}, ` +
|
||||
`SignedHeaders=${this.getCanonicalHeaderList(canonicalHeaders)}, ` +
|
||||
`Signature=${signature}`;
|
||||
return request;
|
||||
}
|
||||
async getSignature(longDate, credentialScope, keyPromise, canonicalRequest) {
|
||||
const stringToSign = await this.createStringToSign(longDate, credentialScope, canonicalRequest, ALGORITHM_IDENTIFIER);
|
||||
const hash = new this.sha256(await keyPromise);
|
||||
hash.update(utilUtf8.toUint8Array(stringToSign));
|
||||
return utilHexEncoding.toHex(await hash.digest());
|
||||
}
|
||||
getSigningKey(credentials, region, shortDate, service) {
|
||||
return getSigningKey(this.sha256, credentials, shortDate, region, service || this.service);
|
||||
}
|
||||
}
|
||||
|
||||
const signatureV4aContainer = {
|
||||
SignatureV4a: null,
|
||||
};
|
||||
|
||||
exports.ALGORITHM_IDENTIFIER = ALGORITHM_IDENTIFIER;
|
||||
exports.ALGORITHM_IDENTIFIER_V4A = ALGORITHM_IDENTIFIER_V4A;
|
||||
exports.ALGORITHM_QUERY_PARAM = ALGORITHM_QUERY_PARAM;
|
||||
exports.ALWAYS_UNSIGNABLE_HEADERS = ALWAYS_UNSIGNABLE_HEADERS;
|
||||
exports.AMZ_DATE_HEADER = AMZ_DATE_HEADER;
|
||||
exports.AMZ_DATE_QUERY_PARAM = AMZ_DATE_QUERY_PARAM;
|
||||
exports.AUTH_HEADER = AUTH_HEADER;
|
||||
exports.CREDENTIAL_QUERY_PARAM = CREDENTIAL_QUERY_PARAM;
|
||||
exports.DATE_HEADER = DATE_HEADER;
|
||||
exports.EVENT_ALGORITHM_IDENTIFIER = EVENT_ALGORITHM_IDENTIFIER;
|
||||
exports.EXPIRES_QUERY_PARAM = EXPIRES_QUERY_PARAM;
|
||||
exports.GENERATED_HEADERS = GENERATED_HEADERS;
|
||||
exports.HOST_HEADER = HOST_HEADER;
|
||||
exports.KEY_TYPE_IDENTIFIER = KEY_TYPE_IDENTIFIER;
|
||||
exports.MAX_CACHE_SIZE = MAX_CACHE_SIZE;
|
||||
exports.MAX_PRESIGNED_TTL = MAX_PRESIGNED_TTL;
|
||||
exports.PROXY_HEADER_PATTERN = PROXY_HEADER_PATTERN;
|
||||
exports.REGION_SET_PARAM = REGION_SET_PARAM;
|
||||
exports.SEC_HEADER_PATTERN = SEC_HEADER_PATTERN;
|
||||
exports.SHA256_HEADER = SHA256_HEADER;
|
||||
exports.SIGNATURE_HEADER = SIGNATURE_HEADER;
|
||||
exports.SIGNATURE_QUERY_PARAM = SIGNATURE_QUERY_PARAM;
|
||||
exports.SIGNED_HEADERS_QUERY_PARAM = SIGNED_HEADERS_QUERY_PARAM;
|
||||
exports.SignatureV4 = SignatureV4;
|
||||
exports.SignatureV4Base = SignatureV4Base;
|
||||
exports.TOKEN_HEADER = TOKEN_HEADER;
|
||||
exports.TOKEN_QUERY_PARAM = TOKEN_QUERY_PARAM;
|
||||
exports.UNSIGNABLE_PATTERNS = UNSIGNABLE_PATTERNS;
|
||||
exports.UNSIGNED_PAYLOAD = UNSIGNED_PAYLOAD;
|
||||
exports.clearCredentialCache = clearCredentialCache;
|
||||
exports.createScope = createScope;
|
||||
exports.getCanonicalHeaders = getCanonicalHeaders;
|
||||
exports.getCanonicalQuery = getCanonicalQuery;
|
||||
exports.getPayloadHash = getPayloadHash;
|
||||
exports.getSigningKey = getSigningKey;
|
||||
exports.hasHeader = hasHeader;
|
||||
exports.moveHeadersToQuery = moveHeadersToQuery;
|
||||
exports.prepareRequest = prepareRequest;
|
||||
exports.signatureV4aContainer = signatureV4aContainer;
|
||||
Reference in New Issue
Block a user