@hanzo/s3 0.6.4 → 8.0.7

package/dist/esm/signing.mjs

@@ -0,0 +1,258 @@
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 Hanzo AI, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as crypto from "crypto";
+import * as errors from "./errors.mjs";
+import { PRESIGN_EXPIRY_DAYS_MAX } from "./helpers.mjs";
+import { getScope, isNumber, isObject, isString, makeDateLong, makeDateShort, uriEscape } from "./internal/helper.mjs";
+const signV4Algorithm = 'AWS4-HMAC-SHA256';
+
+// getCanonicalRequest generate a canonical request of style.
+//
+// canonicalRequest =
+//  <HTTPMethod>\n
+//  <CanonicalURI>\n
+//  <CanonicalQueryString>\n
+//  <CanonicalHeaders>\n
+//  <SignedHeaders>\n
+//  <HashedPayload>
+//
+function getCanonicalRequest(method, path, headers, signedHeaders, hashedPayload) {
+  if (!isString(method)) {
+    throw new TypeError('method should be of type "string"');
+  }
+  if (!isString(path)) {
+    throw new TypeError('path should be of type "string"');
+  }
+  if (!isObject(headers)) {
+    throw new TypeError('headers should be of type "object"');
+  }
+  if (!Array.isArray(signedHeaders)) {
+    throw new TypeError('signedHeaders should be of type "array"');
+  }
+  if (!isString(hashedPayload)) {
+    throw new TypeError('hashedPayload should be of type "string"');
+  }
+  const headersArray = signedHeaders.reduce((acc, i) => {
+    // Trim spaces from the value (required by V4 spec)
+    const val = `${headers[i]}`.replace(/ +/g, ' ');
+    acc.push(`${i.toLowerCase()}:${val}`);
+    return acc;
+  }, []);
+  const requestResource = path.split('?')[0];
+  let requestQuery = path.split('?')[1];
+  if (!requestQuery) {
+    requestQuery = '';
+  }
+  if (requestQuery) {
+    requestQuery = requestQuery.split('&').sort().map(element => !element.includes('=') ? element + '=' : element).join('&');
+  }
+  return [method.toUpperCase(), requestResource, requestQuery, headersArray.join('\n') + '\n', signedHeaders.join(';').toLowerCase(), hashedPayload].join('\n');
+}
+
+// generate a credential string
+function getCredential(accessKey, region, requestDate, serviceName = 's3') {
+  if (!isString(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!isObject(requestDate)) {
+    throw new TypeError('requestDate should be of type "object"');
+  }
+  return `${accessKey}/${getScope(region, requestDate, serviceName)}`;
+}
+
+// Returns signed headers array - alphabetically sorted
+function getSignedHeaders(headers) {
+  if (!isObject(headers)) {
+    throw new TypeError('request should be of type "object"');
+  }
+  // Excerpts from @lsegal - https://github.com/aws/aws-sdk-js/issues/659#issuecomment-120477258
+  //
+  //  User-Agent:
+  //
+  //      This is ignored from signing because signing this causes problems with generating pre-signed URLs
+  //      (that are executed by other agents) or when customers pass requests through proxies, which may
+  //      modify the user-agent.
+  //
+  //  Content-Length:
+  //
+  //      This is ignored from signing because generating a pre-signed URL should not provide a content-length
+  //      constraint, specifically when vending a S3 pre-signed PUT URL. The corollary to this is that when
+  //      sending regular requests (non-pre-signed), the signature contains a checksum of the body, which
+  //      implicitly validates the payload length (since changing the number of bytes would change the checksum)
+  //      and therefore this header is not valuable in the signature.
+  //
+  //  Content-Type:
+  //
+  //      Signing this header causes quite a number of problems in browser environments, where browsers
+  //      like to modify and normalize the content-type header in different ways. There is more information
+  //      on this in https://github.com/aws/aws-sdk-js/issues/244. Avoiding this field simplifies logic
+  //      and reduces the possibility of future bugs
+  //
+  //  Authorization:
+  //
+  //      Is skipped for obvious reasons
+
+  const ignoredHeaders = ['authorization', 'content-length', 'content-type', 'user-agent'];
+  return Object.keys(headers).filter(header => !ignoredHeaders.includes(header)).sort();
+}
+
+// returns the key used for calculating signature
+function getSigningKey(date, region, secretKey, serviceName = 's3') {
+  if (!isObject(date)) {
+    throw new TypeError('date should be of type "object"');
+  }
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!isString(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  const dateLine = makeDateShort(date);
+  const hmac1 = crypto.createHmac('sha256', 'AWS4' + secretKey).update(dateLine).digest(),
+    hmac2 = crypto.createHmac('sha256', hmac1).update(region).digest(),
+    hmac3 = crypto.createHmac('sha256', hmac2).update(serviceName).digest();
+  return crypto.createHmac('sha256', hmac3).update('aws4_request').digest();
+}
+
+// returns the string that needs to be signed
+function getStringToSign(canonicalRequest, requestDate, region, serviceName = 's3') {
+  if (!isString(canonicalRequest)) {
+    throw new TypeError('canonicalRequest should be of type "string"');
+  }
+  if (!isObject(requestDate)) {
+    throw new TypeError('requestDate should be of type "object"');
+  }
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  const hash = crypto.createHash('sha256').update(canonicalRequest).digest('hex');
+  const scope = getScope(region, requestDate, serviceName);
+  const stringToSign = [signV4Algorithm, makeDateLong(requestDate), scope, hash];
+  return stringToSign.join('\n');
+}
+
+// calculate the signature of the POST policy
+export function postPresignSignatureV4(region, date, secretKey, policyBase64) {
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!isObject(date)) {
+    throw new TypeError('date should be of type "object"');
+  }
+  if (!isString(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!isString(policyBase64)) {
+    throw new TypeError('policyBase64 should be of type "string"');
+  }
+  const signingKey = getSigningKey(date, region, secretKey);
+  return crypto.createHmac('sha256', signingKey).update(policyBase64).digest('hex').toLowerCase();
+}
+
+// Returns the authorization header
+export function signV4(request, accessKey, secretKey, region, requestDate, sha256sum, serviceName = 's3') {
+  if (!isObject(request)) {
+    throw new TypeError('request should be of type "object"');
+  }
+  if (!isString(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!isString(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!accessKey) {
+    throw new errors.AccessKeyRequiredError('accessKey is required for signing');
+  }
+  if (!secretKey) {
+    throw new errors.SecretKeyRequiredError('secretKey is required for signing');
+  }
+  const signedHeaders = getSignedHeaders(request.headers);
+  const canonicalRequest = getCanonicalRequest(request.method, request.path, request.headers, signedHeaders, sha256sum);
+  const serviceIdentifier = serviceName || 's3';
+  const stringToSign = getStringToSign(canonicalRequest, requestDate, region, serviceIdentifier);
+  const signingKey = getSigningKey(requestDate, region, secretKey, serviceIdentifier);
+  const credential = getCredential(accessKey, region, requestDate, serviceIdentifier);
+  const signature = crypto.createHmac('sha256', signingKey).update(stringToSign).digest('hex').toLowerCase();
+  return `${signV4Algorithm} Credential=${credential}, SignedHeaders=${signedHeaders.join(';').toLowerCase()}, Signature=${signature}`;
+}
+export function signV4ByServiceName(request, accessKey, secretKey, region, requestDate, contentSha256, serviceName = 's3') {
+  return signV4(request, accessKey, secretKey, region, requestDate, contentSha256, serviceName);
+}
+
+// returns a presigned URL string
+export function presignSignatureV4(request, accessKey, secretKey, sessionToken, region, requestDate, expires) {
+  if (!isObject(request)) {
+    throw new TypeError('request should be of type "object"');
+  }
+  if (!isString(accessKey)) {
+    throw new TypeError('accessKey should be of type "string"');
+  }
+  if (!isString(secretKey)) {
+    throw new TypeError('secretKey should be of type "string"');
+  }
+  if (!isString(region)) {
+    throw new TypeError('region should be of type "string"');
+  }
+  if (!accessKey) {
+    throw new errors.AccessKeyRequiredError('accessKey is required for presigning');
+  }
+  if (!secretKey) {
+    throw new errors.SecretKeyRequiredError('secretKey is required for presigning');
+  }
+  if (expires && !isNumber(expires)) {
+    throw new TypeError('expires should be of type "number"');
+  }
+  if (expires && expires < 1) {
+    throw new errors.ExpiresParamError('expires param cannot be less than 1 seconds');
+  }
+  if (expires && expires > PRESIGN_EXPIRY_DAYS_MAX) {
+    throw new errors.ExpiresParamError('expires param cannot be greater than 7 days');
+  }
+  const iso8601Date = makeDateLong(requestDate);
+  const signedHeaders = getSignedHeaders(request.headers);
+  const credential = getCredential(accessKey, region, requestDate);
+  const hashedPayload = 'UNSIGNED-PAYLOAD';
+  const requestQuery = [];
+  requestQuery.push(`X-Amz-Algorithm=${signV4Algorithm}`);
+  requestQuery.push(`X-Amz-Credential=${uriEscape(credential)}`);
+  requestQuery.push(`X-Amz-Date=${iso8601Date}`);
+  requestQuery.push(`X-Amz-Expires=${expires}`);
+  requestQuery.push(`X-Amz-SignedHeaders=${uriEscape(signedHeaders.join(';').toLowerCase())}`);
+  if (sessionToken) {
+    requestQuery.push(`X-Amz-Security-Token=${uriEscape(sessionToken)}`);
+  }
+  const resource = request.path.split('?')[0];
+  let query = request.path.split('?')[1];
+  if (query) {
+    query = query + '&' + requestQuery.join('&');
+  } else {
+    query = requestQuery.join('&');
+  }
+  const path = resource + '?' + query;
+  const canonicalRequest = getCanonicalRequest(request.method, path, request.headers, signedHeaders, hashedPayload);
+  const stringToSign = getStringToSign(canonicalRequest, requestDate, region);
+  const signingKey = getSigningKey(requestDate, region, secretKey);
+  const signature = crypto.createHmac('sha256', signingKey).update(stringToSign).digest('hex').toLowerCase();
+  return request.protocol + '//' + request.headers.host + path + `&X-Amz-Signature=${signature}`;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["crypto","errors","PRESIGN_EXPIRY_DAYS_MAX","getScope","isNumber","isObject","isString","makeDateLong","makeDateShort","uriEscape","signV4Algorithm","getCanonicalRequest","method","path","headers","signedHeaders","hashedPayload","TypeError","Array","isArray","headersArray","reduce","acc","i","val","replace","push","toLowerCase","requestResource","split","requestQuery","sort","map","element","includes","join","toUpperCase","getCredential","accessKey","region","requestDate","serviceName","getSignedHeaders","ignoredHeaders","Object","keys","filter","header","getSigningKey","date","secretKey","dateLine","hmac1","createHmac","update","digest","hmac2","hmac3","getStringToSign","canonicalRequest","hash","createHash","scope","stringToSign","postPresignSignatureV4","policyBase64","signingKey","signV4","request","sha256sum","AccessKeyRequiredError","SecretKeyRequiredError","serviceIdentifier","credential","signature","signV4ByServiceName","contentSha256","presignSignatureV4","sessionToken","expires","ExpiresParamError","iso8601Date","resource","query","protocol","host"],"sources":["signing.ts"],"sourcesContent":["/*\n * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 Hanzo AI, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as crypto from 'node:crypto'\n\nimport * as errors from './errors.ts'\nimport { PRESIGN_EXPIRY_DAYS_MAX } from './helpers.ts'\nimport { getScope, isNumber, isObject, isString, makeDateLong, makeDateShort, uriEscape } from './internal/helper.ts'\nimport type { ICanonicalRequest, IRequest, RequestHeaders } from './internal/type.ts'\n\nconst signV4Algorithm = 'AWS4-HMAC-SHA256'\n\n// getCanonicalRequest generate a canonical request of style.\n//\n// canonicalRequest =\n//  <HTTPMethod>\\n\n//  <CanonicalURI>\\n\n//  <CanonicalQueryString>\\n\n//  <CanonicalHeaders>\\n\n//  <SignedHeaders>\\n\n//  <HashedPayload>\n//\nfunction getCanonicalRequest(\n  method: string,\n  path: string,\n  headers: RequestHeaders,\n  signedHeaders: string[],\n  hashedPayload: string,\n): ICanonicalRequest {\n  if (!isString(method)) {\n    throw new TypeError('method should be of type \"string\"')\n  }\n  if (!isString(path)) {\n    throw new TypeError('path should be of type \"string\"')\n  }\n  if (!isObject(headers)) {\n    throw new TypeError('headers should be of type \"object\"')\n  }\n  if (!Array.isArray(signedHeaders)) {\n    throw new TypeError('signedHeaders should be of type \"array\"')\n  }\n  if (!isString(hashedPayload)) {\n    throw new TypeError('hashedPayload should be of type \"string\"')\n  }\n\n  const headersArray = signedHeaders.reduce((acc, i) => {\n    // Trim spaces from the value (required by V4 spec)\n    const val = `${headers[i]}`.replace(/ +/g, ' ')\n    acc.push(`${i.toLowerCase()}:${val}`)\n    return acc\n  }, [] as string[])\n\n  const requestResource = path.split('?')[0]\n  let requestQuery = path.split('?')[1]\n  if (!requestQuery) {\n    requestQuery = ''\n  }\n\n  if (requestQuery) {\n    requestQuery = requestQuery\n      .split('&')\n      .sort()\n      .map((element) => (!element.includes('=') ? element + '=' : element))\n      .join('&')\n  }\n\n  return [\n    method.toUpperCase(),\n    requestResource,\n    requestQuery,\n    headersArray.join('\\n') + '\\n',\n    signedHeaders.join(';').toLowerCase(),\n    hashedPayload,\n  ].join('\\n')\n}\n\n// generate a credential string\nfunction getCredential(accessKey: string, region: string, requestDate?: Date, serviceName = 's3') {\n  if (!isString(accessKey)) {\n    throw new TypeError('accessKey should be of type \"string\"')\n  }\n  if (!isString(region)) {\n    throw new TypeError('region should be of type \"string\"')\n  }\n  if (!isObject(requestDate)) {\n    throw new TypeError('requestDate should be of type \"object\"')\n  }\n  return `${accessKey}/${getScope(region, requestDate, serviceName)}`\n}\n\n// Returns signed headers array - alphabetically sorted\nfunction getSignedHeaders(headers: RequestHeaders): string[] {\n  if (!isObject(headers)) {\n    throw new TypeError('request should be of type \"object\"')\n  }\n  // Excerpts from @lsegal - https://github.com/aws/aws-sdk-js/issues/659#issuecomment-120477258\n  //\n  //  User-Agent:\n  //\n  //      This is ignored from signing because signing this causes problems with generating pre-signed URLs\n  //      (that are executed by other agents) or when customers pass requests through proxies, which may\n  //      modify the user-agent.\n  //\n  //  Content-Length:\n  //\n  //      This is ignored from signing because generating a pre-signed URL should not provide a content-length\n  //      constraint, specifically when vending a S3 pre-signed PUT URL. The corollary to this is that when\n  //      sending regular requests (non-pre-signed), the signature contains a checksum of the body, which\n  //      implicitly validates the payload length (since changing the number of bytes would change the checksum)\n  //      and therefore this header is not valuable in the signature.\n  //\n  //  Content-Type:\n  //\n  //      Signing this header causes quite a number of problems in browser environments, where browsers\n  //      like to modify and normalize the content-type header in different ways. There is more information\n  //      on this in https://github.com/aws/aws-sdk-js/issues/244. Avoiding this field simplifies logic\n  //      and reduces the possibility of future bugs\n  //\n  //  Authorization:\n  //\n  //      Is skipped for obvious reasons\n\n  const ignoredHeaders = ['authorization', 'content-length', 'content-type', 'user-agent']\n  return Object.keys(headers)\n    .filter((header) => !ignoredHeaders.includes(header))\n    .sort()\n}\n\n// returns the key used for calculating signature\nfunction getSigningKey(date: Date, region: string, secretKey: string, serviceName = 's3') {\n  if (!isObject(date)) {\n    throw new TypeError('date should be of type \"object\"')\n  }\n  if (!isString(region)) {\n    throw new TypeError('region should be of type \"string\"')\n  }\n  if (!isString(secretKey)) {\n    throw new TypeError('secretKey should be of type \"string\"')\n  }\n  const dateLine = makeDateShort(date)\n  const hmac1 = crypto\n      .createHmac('sha256', 'AWS4' + secretKey)\n      .update(dateLine)\n      .digest(),\n    hmac2 = crypto.createHmac('sha256', hmac1).update(region).digest(),\n    hmac3 = crypto.createHmac('sha256', hmac2).update(serviceName).digest()\n  return crypto.createHmac('sha256', hmac3).update('aws4_request').digest()\n}\n\n// returns the string that needs to be signed\nfunction getStringToSign(canonicalRequest: ICanonicalRequest, requestDate: Date, region: string, serviceName = 's3') {\n  if (!isString(canonicalRequest)) {\n    throw new TypeError('canonicalRequest should be of type \"string\"')\n  }\n  if (!isObject(requestDate)) {\n    throw new TypeError('requestDate should be of type \"object\"')\n  }\n  if (!isString(region)) {\n    throw new TypeError('region should be of type \"string\"')\n  }\n  const hash = crypto.createHash('sha256').update(canonicalRequest).digest('hex')\n  const scope = getScope(region, requestDate, serviceName)\n  const stringToSign = [signV4Algorithm, makeDateLong(requestDate), scope, hash]\n\n  return stringToSign.join('\\n')\n}\n\n// calculate the signature of the POST policy\nexport function postPresignSignatureV4(region: string, date: Date, secretKey: string, policyBase64: string): string {\n  if (!isString(region)) {\n    throw new TypeError('region should be of type \"string\"')\n  }\n  if (!isObject(date)) {\n    throw new TypeError('date should be of type \"object\"')\n  }\n  if (!isString(secretKey)) {\n    throw new TypeError('secretKey should be of type \"string\"')\n  }\n  if (!isString(policyBase64)) {\n    throw new TypeError('policyBase64 should be of type \"string\"')\n  }\n  const signingKey = getSigningKey(date, region, secretKey)\n  return crypto.createHmac('sha256', signingKey).update(policyBase64).digest('hex').toLowerCase()\n}\n\n// Returns the authorization header\nexport function signV4(\n  request: IRequest,\n  accessKey: string,\n  secretKey: string,\n  region: string,\n  requestDate: Date,\n  sha256sum: string,\n  serviceName = 's3',\n) {\n  if (!isObject(request)) {\n    throw new TypeError('request should be of type \"object\"')\n  }\n  if (!isString(accessKey)) {\n    throw new TypeError('accessKey should be of type \"string\"')\n  }\n  if (!isString(secretKey)) {\n    throw new TypeError('secretKey should be of type \"string\"')\n  }\n  if (!isString(region)) {\n    throw new TypeError('region should be of type \"string\"')\n  }\n\n  if (!accessKey) {\n    throw new errors.AccessKeyRequiredError('accessKey is required for signing')\n  }\n  if (!secretKey) {\n    throw new errors.SecretKeyRequiredError('secretKey is required for signing')\n  }\n\n  const signedHeaders = getSignedHeaders(request.headers)\n  const canonicalRequest = getCanonicalRequest(request.method, request.path, request.headers, signedHeaders, sha256sum)\n  const serviceIdentifier = serviceName || 's3'\n  const stringToSign = getStringToSign(canonicalRequest, requestDate, region, serviceIdentifier)\n  const signingKey = getSigningKey(requestDate, region, secretKey, serviceIdentifier)\n  const credential = getCredential(accessKey, region, requestDate, serviceIdentifier)\n  const signature = crypto.createHmac('sha256', signingKey).update(stringToSign).digest('hex').toLowerCase()\n\n  return `${signV4Algorithm} Credential=${credential}, SignedHeaders=${signedHeaders\n    .join(';')\n    .toLowerCase()}, Signature=${signature}`\n}\n\nexport function signV4ByServiceName(\n  request: IRequest,\n  accessKey: string,\n  secretKey: string,\n  region: string,\n  requestDate: Date,\n  contentSha256: string,\n  serviceName = 's3',\n): string {\n  return signV4(request, accessKey, secretKey, region, requestDate, contentSha256, serviceName)\n}\n\n// returns a presigned URL string\nexport function presignSignatureV4(\n  request: IRequest,\n  accessKey: string,\n  secretKey: string,\n  sessionToken: string | undefined,\n  region: string,\n  requestDate: Date,\n  expires: number | undefined,\n) {\n  if (!isObject(request)) {\n    throw new TypeError('request should be of type \"object\"')\n  }\n  if (!isString(accessKey)) {\n    throw new TypeError('accessKey should be of type \"string\"')\n  }\n  if (!isString(secretKey)) {\n    throw new TypeError('secretKey should be of type \"string\"')\n  }\n  if (!isString(region)) {\n    throw new TypeError('region should be of type \"string\"')\n  }\n\n  if (!accessKey) {\n    throw new errors.AccessKeyRequiredError('accessKey is required for presigning')\n  }\n  if (!secretKey) {\n    throw new errors.SecretKeyRequiredError('secretKey is required for presigning')\n  }\n\n  if (expires && !isNumber(expires)) {\n    throw new TypeError('expires should be of type \"number\"')\n  }\n  if (expires && expires < 1) {\n    throw new errors.ExpiresParamError('expires param cannot be less than 1 seconds')\n  }\n  if (expires && expires > PRESIGN_EXPIRY_DAYS_MAX) {\n    throw new errors.ExpiresParamError('expires param cannot be greater than 7 days')\n  }\n\n  const iso8601Date = makeDateLong(requestDate)\n  const signedHeaders = getSignedHeaders(request.headers)\n  const credential = getCredential(accessKey, region, requestDate)\n  const hashedPayload = 'UNSIGNED-PAYLOAD'\n\n  const requestQuery: string[] = []\n  requestQuery.push(`X-Amz-Algorithm=${signV4Algorithm}`)\n  requestQuery.push(`X-Amz-Credential=${uriEscape(credential)}`)\n  requestQuery.push(`X-Amz-Date=${iso8601Date}`)\n  requestQuery.push(`X-Amz-Expires=${expires}`)\n  requestQuery.push(`X-Amz-SignedHeaders=${uriEscape(signedHeaders.join(';').toLowerCase())}`)\n  if (sessionToken) {\n    requestQuery.push(`X-Amz-Security-Token=${uriEscape(sessionToken)}`)\n  }\n\n  const resource = request.path.split('?')[0]\n  let query = request.path.split('?')[1]\n  if (query) {\n    query = query + '&' + requestQuery.join('&')\n  } else {\n    query = requestQuery.join('&')\n  }\n\n  const path = resource + '?' + query\n\n  const canonicalRequest = getCanonicalRequest(request.method, path, request.headers, signedHeaders, hashedPayload)\n\n  const stringToSign = getStringToSign(canonicalRequest, requestDate, region)\n  const signingKey = getSigningKey(requestDate, region, secretKey)\n  const signature = crypto.createHmac('sha256', signingKey).update(stringToSign).digest('hex').toLowerCase()\n  return request.protocol + '//' + request.headers.host + path + `&X-Amz-Signature=${signature}`\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,OAAO,KAAKA,MAAM;AAElB,OAAO,KAAKC,MAAM,MAAM,cAAa;AACrC,SAASC,uBAAuB,QAAQ,eAAc;AACtD,SAASC,QAAQ,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,YAAY,EAAEC,aAAa,EAAEC,SAAS,QAAQ,uBAAsB;AAGrH,MAAMC,eAAe,GAAG,kBAAkB;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,mBAAmBA,CAC1BC,MAAc,EACdC,IAAY,EACZC,OAAuB,EACvBC,aAAuB,EACvBC,aAAqB,EACF;EACnB,IAAI,CAACV,QAAQ,CAACM,MAAM,CAAC,EAAE;IACrB,MAAM,IAAIK,SAAS,CAAC,mCAAmC,CAAC;EAC1D;EACA,IAAI,CAACX,QAAQ,CAACO,IAAI,CAAC,EAAE;IACnB,MAAM,IAAII,SAAS,CAAC,iCAAiC,CAAC;EACxD;EACA,IAAI,CAACZ,QAAQ,CAACS,OAAO,CAAC,EAAE;IACtB,MAAM,IAAIG,SAAS,CAAC,oCAAoC,CAAC;EAC3D;EACA,IAAI,CAACC,KAAK,CAACC,OAAO,CAACJ,aAAa,CAAC,EAAE;IACjC,MAAM,IAAIE,SAAS,CAAC,yCAAyC,CAAC;EAChE;EACA,IAAI,CAACX,QAAQ,CAACU,aAAa,CAAC,EAAE;IAC5B,MAAM,IAAIC,SAAS,CAAC,0CAA0C,CAAC;EACjE;EAEA,MAAMG,YAAY,GAAGL,aAAa,CAACM,MAAM,CAAC,CAACC,GAAG,EAAEC,CAAC,KAAK;IACpD;IACA,MAAMC,GAAG,GAAI,GAAEV,OAAO,CAACS,CAAC,CAAE,EAAC,CAACE,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;IAC/CH,GAAG,CAACI,IAAI,CAAE,GAAEH,CAAC,CAACI,WAAW,CAAC,CAAE,IAAGH,GAAI,EAAC,CAAC;IACrC,OAAOF,GAAG;EACZ,CAAC,EAAE,EAAc,CAAC;EAElB,MAAMM,eAAe,GAAGf,IAAI,CAACgB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;EAC1C,IAAIC,YAAY,GAAGjB,IAAI,CAACgB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;EACrC,IAAI,CAACC,YAAY,EAAE;IACjBA,YAAY,GAAG,EAAE;EACnB;EAEA,IAAIA,YAAY,EAAE;IAChBA,YAAY,GAAGA,YAAY,CACxBD,KAAK,CAAC,GAAG,CAAC,CACVE,IAAI,CAAC,CAAC,CACNC,GAAG,CAAEC,OAAO,IAAM,CAACA,OAAO,CAACC,QAAQ,CAAC,GAAG,CAAC,GAAGD,OAAO,GAAG,GAAG,GAAGA,OAAQ,CAAC,CACpEE,IAAI,CAAC,GAAG,CAAC;EACd;EAEA,OAAO,CACLvB,MAAM,CAACwB,WAAW,CAAC,CAAC,EACpBR,eAAe,EACfE,YAAY,EACZV,YAAY,CAACe,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,EAC9BpB,aAAa,CAACoB,IAAI,CAAC,GAAG,CAAC,CAACR,WAAW,CAAC,CAAC,EACrCX,aAAa,CACd,CAACmB,IAAI,CAAC,IAAI,CAAC;AACd;;AAEA;AACA,SAASE,aAAaA,CAACC,SAAiB,EAAEC,MAAc,EAAEC,WAAkB,EAAEC,WAAW,GAAG,IAAI,EAAE;EAChG,IAAI,CAACnC,QAAQ,CAACgC,SAAS,CAAC,EAAE;IACxB,MAAM,IAAIrB,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EACA,IAAI,CAACX,QAAQ,CAACiC,MAAM,CAAC,EAAE;IACrB,MAAM,IAAItB,SAAS,CAAC,mCAAmC,CAAC;EAC1D;EACA,IAAI,CAACZ,QAAQ,CAACmC,WAAW,CAAC,EAAE;IAC1B,MAAM,IAAIvB,SAAS,CAAC,wCAAwC,CAAC;EAC/D;EACA,OAAQ,GAAEqB,SAAU,IAAGnC,QAAQ,CAACoC,MAAM,EAAEC,WAAW,EAAEC,WAAW,CAAE,EAAC;AACrE;;AAEA;AACA,SAASC,gBAAgBA,CAAC5B,OAAuB,EAAY;EAC3D,IAAI,CAACT,QAAQ,CAACS,OAAO,CAAC,EAAE;IACtB,MAAM,IAAIG,SAAS,CAAC,oCAAoC,CAAC;EAC3D;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA,MAAM0B,cAAc,GAAG,CAAC,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,YAAY,CAAC;EACxF,OAAOC,MAAM,CAACC,IAAI,CAAC/B,OAAO,CAAC,CACxBgC,MAAM,CAAEC,MAAM,IAAK,CAACJ,cAAc,CAACT,QAAQ,CAACa,MAAM,CAAC,CAAC,CACpDhB,IAAI,CAAC,CAAC;AACX;;AAEA;AACA,SAASiB,aAAaA,CAACC,IAAU,EAAEV,MAAc,EAAEW,SAAiB,EAAET,WAAW,GAAG,IAAI,EAAE;EACxF,IAAI,CAACpC,QAAQ,CAAC4C,IAAI,CAAC,EAAE;IACnB,MAAM,IAAIhC,SAAS,CAAC,iCAAiC,CAAC;EACxD;EACA,IAAI,CAACX,QAAQ,CAACiC,MAAM,CAAC,EAAE;IACrB,MAAM,IAAItB,SAAS,CAAC,mCAAmC,CAAC;EAC1D;EACA,IAAI,CAACX,QAAQ,CAAC4C,SAAS,CAAC,EAAE;IACxB,MAAM,IAAIjC,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EACA,MAAMkC,QAAQ,GAAG3C,aAAa,CAACyC,IAAI,CAAC;EACpC,MAAMG,KAAK,GAAGpD,MAAM,CACfqD,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAGH,SAAS,CAAC,CACxCI,MAAM,CAACH,QAAQ,CAAC,CAChBI,MAAM,CAAC,CAAC;IACXC,KAAK,GAAGxD,MAAM,CAACqD,UAAU,CAAC,QAAQ,EAAED,KAAK,CAAC,CAACE,MAAM,CAACf,MAAM,CAAC,CAACgB,MAAM,CAAC,CAAC;IAClEE,KAAK,GAAGzD,MAAM,CAACqD,UAAU,CAAC,QAAQ,EAAEG,KAAK,CAAC,CAACF,MAAM,CAACb,WAAW,CAAC,CAACc,MAAM,CAAC,CAAC;EACzE,OAAOvD,MAAM,CAACqD,UAAU,CAAC,QAAQ,EAAEI,KAAK,CAAC,CAACH,MAAM,CAAC,cAAc,CAAC,CAACC,MAAM,CAAC,CAAC;AAC3E;;AAEA;AACA,SAASG,eAAeA,CAACC,gBAAmC,EAAEnB,WAAiB,EAAED,MAAc,EAAEE,WAAW,GAAG,IAAI,EAAE;EACnH,IAAI,CAACnC,QAAQ,CAACqD,gBAAgB,CAAC,EAAE;IAC/B,MAAM,IAAI1C,SAAS,CAAC,6CAA6C,CAAC;EACpE;EACA,IAAI,CAACZ,QAAQ,CAACmC,WAAW,CAAC,EAAE;IAC1B,MAAM,IAAIvB,SAAS,CAAC,wCAAwC,CAAC;EAC/D;EACA,IAAI,CAACX,QAAQ,CAACiC,MAAM,CAAC,EAAE;IACrB,MAAM,IAAItB,SAAS,CAAC,mCAAmC,CAAC;EAC1D;EACA,MAAM2C,IAAI,GAAG5D,MAAM,CAAC6D,UAAU,CAAC,QAAQ,CAAC,CAACP,MAAM,CAACK,gBAAgB,CAAC,CAACJ,MAAM,CAAC,KAAK,CAAC;EAC/E,MAAMO,KAAK,GAAG3D,QAAQ,CAACoC,MAAM,EAAEC,WAAW,EAAEC,WAAW,CAAC;EACxD,MAAMsB,YAAY,GAAG,CAACrD,eAAe,EAAEH,YAAY,CAACiC,WAAW,CAAC,EAAEsB,KAAK,EAAEF,IAAI,CAAC;EAE9E,OAAOG,YAAY,CAAC5B,IAAI,CAAC,IAAI,CAAC;AAChC;;AAEA;AACA,OAAO,SAAS6B,sBAAsBA,CAACzB,MAAc,EAAEU,IAAU,EAAEC,SAAiB,EAAEe,YAAoB,EAAU;EAClH,IAAI,CAAC3D,QAAQ,CAACiC,MAAM,CAAC,EAAE;IACrB,MAAM,IAAItB,SAAS,CAAC,mCAAmC,CAAC;EAC1D;EACA,IAAI,CAACZ,QAAQ,CAAC4C,IAAI,CAAC,EAAE;IACnB,MAAM,IAAIhC,SAAS,CAAC,iCAAiC,CAAC;EACxD;EACA,IAAI,CAACX,QAAQ,CAAC4C,SAAS,CAAC,EAAE;IACxB,MAAM,IAAIjC,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EACA,IAAI,CAACX,QAAQ,CAAC2D,YAAY,CAAC,EAAE;IAC3B,MAAM,IAAIhD,SAAS,CAAC,yCAAyC,CAAC;EAChE;EACA,MAAMiD,UAAU,GAAGlB,aAAa,CAACC,IAAI,EAAEV,MAAM,EAAEW,SAAS,CAAC;EACzD,OAAOlD,MAAM,CAACqD,UAAU,CAAC,QAAQ,EAAEa,UAAU,CAAC,CAACZ,MAAM,CAACW,YAAY,CAAC,CAACV,MAAM,CAAC,KAAK,CAAC,CAAC5B,WAAW,CAAC,CAAC;AACjG;;AAEA;AACA,OAAO,SAASwC,MAAMA,CACpBC,OAAiB,EACjB9B,SAAiB,EACjBY,SAAiB,EACjBX,MAAc,EACdC,WAAiB,EACjB6B,SAAiB,EACjB5B,WAAW,GAAG,IAAI,EAClB;EACA,IAAI,CAACpC,QAAQ,CAAC+D,OAAO,CAAC,EAAE;IACtB,MAAM,IAAInD,SAAS,CAAC,oCAAoC,CAAC;EAC3D;EACA,IAAI,CAACX,QAAQ,CAACgC,SAAS,CAAC,EAAE;IACxB,MAAM,IAAIrB,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EACA,IAAI,CAACX,QAAQ,CAAC4C,SAAS,CAAC,EAAE;IACxB,MAAM,IAAIjC,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EACA,IAAI,CAACX,QAAQ,CAACiC,MAAM,CAAC,EAAE;IACrB,MAAM,IAAItB,SAAS,CAAC,mCAAmC,CAAC;EAC1D;EAEA,IAAI,CAACqB,SAAS,EAAE;IACd,MAAM,IAAIrC,MAAM,CAACqE,sBAAsB,CAAC,mCAAmC,CAAC;EAC9E;EACA,IAAI,CAACpB,SAAS,EAAE;IACd,MAAM,IAAIjD,MAAM,CAACsE,sBAAsB,CAAC,mCAAmC,CAAC;EAC9E;EAEA,MAAMxD,aAAa,GAAG2B,gBAAgB,CAAC0B,OAAO,CAACtD,OAAO,CAAC;EACvD,MAAM6C,gBAAgB,GAAGhD,mBAAmB,CAACyD,OAAO,CAACxD,MAAM,EAAEwD,OAAO,CAACvD,IAAI,EAAEuD,OAAO,CAACtD,OAAO,EAAEC,aAAa,EAAEsD,SAAS,CAAC;EACrH,MAAMG,iBAAiB,GAAG/B,WAAW,IAAI,IAAI;EAC7C,MAAMsB,YAAY,GAAGL,eAAe,CAACC,gBAAgB,EAAEnB,WAAW,EAAED,MAAM,EAAEiC,iBAAiB,CAAC;EAC9F,MAAMN,UAAU,GAAGlB,aAAa,CAACR,WAAW,EAAED,MAAM,EAAEW,SAAS,EAAEsB,iBAAiB,CAAC;EACnF,MAAMC,UAAU,GAAGpC,aAAa,CAACC,SAAS,EAAEC,MAAM,EAAEC,WAAW,EAAEgC,iBAAiB,CAAC;EACnF,MAAME,SAAS,GAAG1E,MAAM,CAACqD,UAAU,CAAC,QAAQ,EAAEa,UAAU,CAAC,CAACZ,MAAM,CAACS,YAAY,CAAC,CAACR,MAAM,CAAC,KAAK,CAAC,CAAC5B,WAAW,CAAC,CAAC;EAE1G,OAAQ,GAAEjB,eAAgB,eAAc+D,UAAW,mBAAkB1D,aAAa,CAC/EoB,IAAI,CAAC,GAAG,CAAC,CACTR,WAAW,CAAC,CAAE,eAAc+C,SAAU,EAAC;AAC5C;AAEA,OAAO,SAASC,mBAAmBA,CACjCP,OAAiB,EACjB9B,SAAiB,EACjBY,SAAiB,EACjBX,MAAc,EACdC,WAAiB,EACjBoC,aAAqB,EACrBnC,WAAW,GAAG,IAAI,EACV;EACR,OAAO0B,MAAM,CAACC,OAAO,EAAE9B,SAAS,EAAEY,SAAS,EAAEX,MAAM,EAAEC,WAAW,EAAEoC,aAAa,EAAEnC,WAAW,CAAC;AAC/F;;AAEA;AACA,OAAO,SAASoC,kBAAkBA,CAChCT,OAAiB,EACjB9B,SAAiB,EACjBY,SAAiB,EACjB4B,YAAgC,EAChCvC,MAAc,EACdC,WAAiB,EACjBuC,OAA2B,EAC3B;EACA,IAAI,CAAC1E,QAAQ,CAAC+D,OAAO,CAAC,EAAE;IACtB,MAAM,IAAInD,SAAS,CAAC,oCAAoC,CAAC;EAC3D;EACA,IAAI,CAACX,QAAQ,CAACgC,SAAS,CAAC,EAAE;IACxB,MAAM,IAAIrB,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EACA,IAAI,CAACX,QAAQ,CAAC4C,SAAS,CAAC,EAAE;IACxB,MAAM,IAAIjC,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EACA,IAAI,CAACX,QAAQ,CAACiC,MAAM,CAAC,EAAE;IACrB,MAAM,IAAItB,SAAS,CAAC,mCAAmC,CAAC;EAC1D;EAEA,IAAI,CAACqB,SAAS,EAAE;IACd,MAAM,IAAIrC,MAAM,CAACqE,sBAAsB,CAAC,sCAAsC,CAAC;EACjF;EACA,IAAI,CAACpB,SAAS,EAAE;IACd,MAAM,IAAIjD,MAAM,CAACsE,sBAAsB,CAAC,sCAAsC,CAAC;EACjF;EAEA,IAAIQ,OAAO,IAAI,CAAC3E,QAAQ,CAAC2E,OAAO,CAAC,EAAE;IACjC,MAAM,IAAI9D,SAAS,CAAC,oCAAoC,CAAC;EAC3D;EACA,IAAI8D,OAAO,IAAIA,OAAO,GAAG,CAAC,EAAE;IAC1B,MAAM,IAAI9E,MAAM,CAAC+E,iBAAiB,CAAC,6CAA6C,CAAC;EACnF;EACA,IAAID,OAAO,IAAIA,OAAO,GAAG7E,uBAAuB,EAAE;IAChD,MAAM,IAAID,MAAM,CAAC+E,iBAAiB,CAAC,6CAA6C,CAAC;EACnF;EAEA,MAAMC,WAAW,GAAG1E,YAAY,CAACiC,WAAW,CAAC;EAC7C,MAAMzB,aAAa,GAAG2B,gBAAgB,CAAC0B,OAAO,CAACtD,OAAO,CAAC;EACvD,MAAM2D,UAAU,GAAGpC,aAAa,CAACC,SAAS,EAAEC,MAAM,EAAEC,WAAW,CAAC;EAChE,MAAMxB,aAAa,GAAG,kBAAkB;EAExC,MAAMc,YAAsB,GAAG,EAAE;EACjCA,YAAY,CAACJ,IAAI,CAAE,mBAAkBhB,eAAgB,EAAC,CAAC;EACvDoB,YAAY,CAACJ,IAAI,CAAE,oBAAmBjB,SAAS,CAACgE,UAAU,CAAE,EAAC,CAAC;EAC9D3C,YAAY,CAACJ,IAAI,CAAE,cAAauD,WAAY,EAAC,CAAC;EAC9CnD,YAAY,CAACJ,IAAI,CAAE,iBAAgBqD,OAAQ,EAAC,CAAC;EAC7CjD,YAAY,CAACJ,IAAI,CAAE,uBAAsBjB,SAAS,CAACM,aAAa,CAACoB,IAAI,CAAC,GAAG,CAAC,CAACR,WAAW,CAAC,CAAC,CAAE,EAAC,CAAC;EAC5F,IAAImD,YAAY,EAAE;IAChBhD,YAAY,CAACJ,IAAI,CAAE,wBAAuBjB,SAAS,CAACqE,YAAY,CAAE,EAAC,CAAC;EACtE;EAEA,MAAMI,QAAQ,GAAGd,OAAO,CAACvD,IAAI,CAACgB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;EAC3C,IAAIsD,KAAK,GAAGf,OAAO,CAACvD,IAAI,CAACgB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;EACtC,IAAIsD,KAAK,EAAE;IACTA,KAAK,GAAGA,KAAK,GAAG,GAAG,GAAGrD,YAAY,CAACK,IAAI,CAAC,GAAG,CAAC;EAC9C,CAAC,MAAM;IACLgD,KAAK,GAAGrD,YAAY,CAACK,IAAI,CAAC,GAAG,CAAC;EAChC;EAEA,MAAMtB,IAAI,GAAGqE,QAAQ,GAAG,GAAG,GAAGC,KAAK;EAEnC,MAAMxB,gBAAgB,GAAGhD,mBAAmB,CAACyD,OAAO,CAACxD,MAAM,EAAEC,IAAI,EAAEuD,OAAO,CAACtD,OAAO,EAAEC,aAAa,EAAEC,aAAa,CAAC;EAEjH,MAAM+C,YAAY,GAAGL,eAAe,CAACC,gBAAgB,EAAEnB,WAAW,EAAED,MAAM,CAAC;EAC3E,MAAM2B,UAAU,GAAGlB,aAAa,CAACR,WAAW,EAAED,MAAM,EAAEW,SAAS,CAAC;EAChE,MAAMwB,SAAS,GAAG1E,MAAM,CAACqD,UAAU,CAAC,QAAQ,EAAEa,UAAU,CAAC,CAACZ,MAAM,CAACS,YAAY,CAAC,CAACR,MAAM,CAAC,KAAK,CAAC,CAAC5B,WAAW,CAAC,CAAC;EAC1G,OAAOyC,OAAO,CAACgB,QAAQ,GAAG,IAAI,GAAGhB,OAAO,CAACtD,OAAO,CAACuE,IAAI,GAAGxE,IAAI,GAAI,oBAAmB6D,SAAU,EAAC;AAChG"}

package/dist/main/AssumeRoleProvider.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import * as http from 'node:http';
+import { CredentialProvider } from "./CredentialProvider.js";
+import { Credentials } from "./Credentials.js";
+/**
+ * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html
+ */
+type CredentialResponse = {
+  ErrorResponse?: {
+    Error?: {
+      Code?: string;
+      Message?: string;
+    };
+  };
+  AssumeRoleResponse: {
+    AssumeRoleResult: {
+      Credentials: {
+        AccessKeyId: string;
+        SecretAccessKey: string;
+        SessionToken: string;
+        Expiration: string;
+      };
+    };
+  };
+};
+export interface AssumeRoleProviderOptions {
+  stsEndpoint: string;
+  accessKey: string;
+  secretKey: string;
+  durationSeconds?: number;
+  sessionToken?: string;
+  policy?: string;
+  region?: string;
+  roleArn?: string;
+  roleSessionName?: string;
+  externalId?: string;
+  token?: string;
+  webIdentityToken?: string;
+  action?: string;
+  transportAgent?: http.Agent;
+}
+export declare class AssumeRoleProvider extends CredentialProvider {
+  private readonly stsEndpoint;
+  private readonly accessKey;
+  private readonly secretKey;
+  private readonly durationSeconds;
+  private readonly policy?;
+  private readonly region;
+  private readonly roleArn?;
+  private readonly roleSessionName?;
+  private readonly externalId?;
+  private readonly token?;
+  private readonly webIdentityToken?;
+  private readonly action;
+  private _credentials;
+  private readonly expirySeconds;
+  private accessExpiresAt;
+  private readonly transportAgent?;
+  private readonly transport;
+  constructor({
+    stsEndpoint,
+    accessKey,
+    secretKey,
+    durationSeconds,
+    sessionToken,
+    policy,
+    region,
+    roleArn,
+    roleSessionName,
+    externalId,
+    token,
+    webIdentityToken,
+    action,
+    transportAgent
+  }: AssumeRoleProviderOptions);
+  getRequestConfig(): {
+    requestOptions: http.RequestOptions;
+    requestData: string;
+  };
+  performRequest(): Promise<CredentialResponse>;
+  parseCredentials(respObj: CredentialResponse): Credentials;
+  refreshCredentials(): Promise<Credentials>;
+  getCredentials(): Promise<Credentials>;
+  isAboutToExpire(): boolean;
+}
+export default AssumeRoleProvider;

package/dist/main/AssumeRoleProvider.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var http = _interopRequireWildcard(require("http"), true);
+var https = _interopRequireWildcard(require("https"), true);
+var _url = require("url");
+var _CredentialProvider = require("./CredentialProvider.js");
+var _Credentials = require("./Credentials.js");
+var _helper = require("./internal/helper.js");
+var _request = require("./internal/request.js");
+var _response = require("./internal/response.js");
+var _signing = require("./signing.js");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html
+ */
+
+const defaultExpirySeconds = 900;
+class AssumeRoleProvider extends _CredentialProvider.CredentialProvider {
+  accessExpiresAt = '';
+  constructor({
+    stsEndpoint,
+    accessKey,
+    secretKey,
+    durationSeconds = defaultExpirySeconds,
+    sessionToken,
+    policy,
+    region = '',
+    roleArn,
+    roleSessionName,
+    externalId,
+    token,
+    webIdentityToken,
+    action = 'AssumeRole',
+    transportAgent = undefined
+  }) {
+    super({
+      accessKey,
+      secretKey,
+      sessionToken
+    });
+    this.stsEndpoint = new _url.URL(stsEndpoint);
+    this.accessKey = accessKey;
+    this.secretKey = secretKey;
+    this.policy = policy;
+    this.region = region;
+    this.roleArn = roleArn;
+    this.roleSessionName = roleSessionName;
+    this.externalId = externalId;
+    this.token = token;
+    this.webIdentityToken = webIdentityToken;
+    this.action = action;
+    this.durationSeconds = parseInt(durationSeconds);
+    let expirySeconds = this.durationSeconds;
+    if (this.durationSeconds < defaultExpirySeconds) {
+      expirySeconds = defaultExpirySeconds;
+    }
+    this.expirySeconds = expirySeconds; // for calculating refresh of credentials.
+
+    // By default, nodejs uses a global agent if the 'agent' property
+    // is set to undefined. Otherwise, it's okay to assume the users
+    // know what they're doing if they specify a custom transport agent.
+    this.transportAgent = transportAgent;
+    const isHttp = this.stsEndpoint.protocol === 'http:';
+    this.transport = isHttp ? http : https;
+
+    /**
+     * Internal Tracking variables
+     */
+    this._credentials = null;
+  }
+  getRequestConfig() {
+    const hostValue = this.stsEndpoint.hostname;
+    const portValue = this.stsEndpoint.port;
+    const qryParams = new _url.URLSearchParams({
+      Action: this.action,
+      Version: '2011-06-15'
+    });
+    qryParams.set('DurationSeconds', this.expirySeconds.toString());
+    if (this.policy) {
+      qryParams.set('Policy', this.policy);
+    }
+    if (this.roleArn) {
+      qryParams.set('RoleArn', this.roleArn);
+    }
+    if (this.roleSessionName != null) {
+      qryParams.set('RoleSessionName', this.roleSessionName);
+    }
+    if (this.token != null) {
+      qryParams.set('Token', this.token);
+    }
+    if (this.webIdentityToken) {
+      qryParams.set('WebIdentityToken', this.webIdentityToken);
+    }
+    if (this.externalId) {
+      qryParams.set('ExternalId', this.externalId);
+    }
+    const urlParams = qryParams.toString();
+    const contentSha256 = (0, _helper.toSha256)(urlParams);
+    const date = new Date();
+    const requestOptions = {
+      hostname: hostValue,
+      port: portValue,
+      path: '/',
+      protocol: this.stsEndpoint.protocol,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'content-length': urlParams.length.toString(),
+        host: hostValue,
+        'x-amz-date': (0, _helper.makeDateLong)(date),
+        'x-amz-content-sha256': contentSha256
+      },
+      agent: this.transportAgent
+    };
+    requestOptions.headers.authorization = (0, _signing.signV4ByServiceName)(requestOptions, this.accessKey, this.secretKey, this.region, date, contentSha256, 'sts');
+    return {
+      requestOptions,
+      requestData: urlParams
+    };
+  }
+  async performRequest() {
+    const {
+      requestOptions,
+      requestData
+    } = this.getRequestConfig();
+    const res = await (0, _request.request)(this.transport, requestOptions, requestData);
+    const body = await (0, _response.readAsString)(res);
+    return (0, _helper.parseXml)(body);
+  }
+  parseCredentials(respObj) {
+    if (respObj.ErrorResponse) {
+      var _respObj$ErrorRespons, _respObj$ErrorRespons2, _respObj$ErrorRespons3, _respObj$ErrorRespons4;
+      throw new Error(`Unable to obtain credentials: ${(_respObj$ErrorRespons = respObj.ErrorResponse) === null || _respObj$ErrorRespons === void 0 ? void 0 : (_respObj$ErrorRespons2 = _respObj$ErrorRespons.Error) === null || _respObj$ErrorRespons2 === void 0 ? void 0 : _respObj$ErrorRespons2.Code} ${(_respObj$ErrorRespons3 = respObj.ErrorResponse) === null || _respObj$ErrorRespons3 === void 0 ? void 0 : (_respObj$ErrorRespons4 = _respObj$ErrorRespons3.Error) === null || _respObj$ErrorRespons4 === void 0 ? void 0 : _respObj$ErrorRespons4.Message}`, {
+        cause: respObj
+      });
+    }
+    const {
+      AssumeRoleResponse: {
+        AssumeRoleResult: {
+          Credentials: {
+            AccessKeyId: accessKey,
+            SecretAccessKey: secretKey,
+            SessionToken: sessionToken,
+            Expiration: expiresAt
+          }
+        }
+      }
+    } = respObj;
+    this.accessExpiresAt = expiresAt;
+    return new _Credentials.Credentials({
+      accessKey,
+      secretKey,
+      sessionToken
+    });
+  }
+  async refreshCredentials() {
+    try {
+      const assumeRoleCredentials = await this.performRequest();
+      this._credentials = this.parseCredentials(assumeRoleCredentials);
+    } catch (err) {
+      throw new Error(`Failed to get Credentials: ${err}`, {
+        cause: err
+      });
+    }
+    return this._credentials;
+  }
+  async getCredentials() {
+    if (this._credentials && !this.isAboutToExpire()) {
+      return this._credentials;
+    }
+    this._credentials = await this.refreshCredentials();
+    return this._credentials;
+  }
+  isAboutToExpire() {
+    const expiresAt = new Date(this.accessExpiresAt);
+    const provisionalExpiry = new Date(Date.now() + 1000 * 10); // check before 10 seconds.
+    return provisionalExpiry > expiresAt;
+  }
+}
+
+// deprecated default export, please use named exports.
+// keep for backward compatibility.
+// eslint-disable-next-line import/no-default-export
+exports.AssumeRoleProvider = AssumeRoleProvider;
+var _default = AssumeRoleProvider;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["http","_interopRequireWildcard","require","https","_url","_CredentialProvider","_Credentials","_helper","_request","_response","_signing","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","defaultExpirySeconds","AssumeRoleProvider","CredentialProvider","accessExpiresAt","constructor","stsEndpoint","accessKey","secretKey","durationSeconds","sessionToken","policy","region","roleArn","roleSessionName","externalId","token","webIdentityToken","action","transportAgent","undefined","URL","parseInt","expirySeconds","isHttp","protocol","transport","_credentials","getRequestConfig","hostValue","hostname","portValue","port","qryParams","URLSearchParams","Action","Version","toString","urlParams","contentSha256","toSha256","date","Date","requestOptions","path","method","headers","length","host","makeDateLong","agent","authorization","signV4ByServiceName","requestData","performRequest","res","request","body","readAsString","parseXml","parseCredentials","respObj","ErrorResponse","_respObj$ErrorRespons","_respObj$ErrorRespons2","_respObj$ErrorRespons3","_respObj$ErrorRespons4","Error","Code","Message","cause","AssumeRoleResponse","AssumeRoleResult","Credentials","AccessKeyId","SecretAccessKey","SessionToken","Expiration","expiresAt","refreshCredentials","assumeRoleCredentials","err","getCredentials","isAboutToExpire","provisionalExpiry","now","exports","_default"],"sources":["AssumeRoleProvider.ts"],"sourcesContent":["import * as http from 'node:http'\nimport * as https from 'node:https'\nimport { URL, URLSearchParams } from 'node:url'\n\nimport { CredentialProvider } from './CredentialProvider.ts'\nimport { Credentials } from './Credentials.ts'\nimport { makeDateLong, parseXml, toSha256 } from './internal/helper.ts'\nimport { request } from './internal/request.ts'\nimport { readAsString } from './internal/response.ts'\nimport type { Transport } from './internal/type.ts'\nimport { signV4ByServiceName } from './signing.ts'\n\n/**\n * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html\n */\ntype CredentialResponse = {\n  ErrorResponse?: {\n    Error?: {\n      Code?: string\n      Message?: string\n    }\n  }\n\n  AssumeRoleResponse: {\n    AssumeRoleResult: {\n      Credentials: {\n        AccessKeyId: string\n        SecretAccessKey: string\n        SessionToken: string\n        Expiration: string\n      }\n    }\n  }\n}\n\nexport interface AssumeRoleProviderOptions {\n  stsEndpoint: string\n  accessKey: string\n  secretKey: string\n  durationSeconds?: number\n  sessionToken?: string\n  policy?: string\n  region?: string\n  roleArn?: string\n  roleSessionName?: string\n  externalId?: string\n  token?: string\n  webIdentityToken?: string\n  action?: string\n  transportAgent?: http.Agent\n}\n\nconst defaultExpirySeconds = 900\n\nexport class AssumeRoleProvider extends CredentialProvider {\n  private readonly stsEndpoint: URL\n  private readonly accessKey: string\n  private readonly secretKey: string\n  private readonly durationSeconds: number\n  private readonly policy?: string\n  private readonly region: string\n  private readonly roleArn?: string\n  private readonly roleSessionName?: string\n  private readonly externalId?: string\n  private readonly token?: string\n  private readonly webIdentityToken?: string\n  private readonly action: string\n\n  private _credentials: Credentials | null\n  private readonly expirySeconds: number\n  private accessExpiresAt = ''\n  private readonly transportAgent?: http.Agent\n\n  private readonly transport: Transport\n\n  constructor({\n    stsEndpoint,\n    accessKey,\n    secretKey,\n    durationSeconds = defaultExpirySeconds,\n    sessionToken,\n    policy,\n    region = '',\n    roleArn,\n    roleSessionName,\n    externalId,\n    token,\n    webIdentityToken,\n    action = 'AssumeRole',\n    transportAgent = undefined,\n  }: AssumeRoleProviderOptions) {\n    super({ accessKey, secretKey, sessionToken })\n\n    this.stsEndpoint = new URL(stsEndpoint)\n    this.accessKey = accessKey\n    this.secretKey = secretKey\n    this.policy = policy\n    this.region = region\n    this.roleArn = roleArn\n    this.roleSessionName = roleSessionName\n    this.externalId = externalId\n    this.token = token\n    this.webIdentityToken = webIdentityToken\n    this.action = action\n\n    this.durationSeconds = parseInt(durationSeconds as unknown as string)\n\n    let expirySeconds = this.durationSeconds\n    if (this.durationSeconds < defaultExpirySeconds) {\n      expirySeconds = defaultExpirySeconds\n    }\n    this.expirySeconds = expirySeconds // for calculating refresh of credentials.\n\n    // By default, nodejs uses a global agent if the 'agent' property\n    // is set to undefined. Otherwise, it's okay to assume the users\n    // know what they're doing if they specify a custom transport agent.\n    this.transportAgent = transportAgent\n    const isHttp: boolean = this.stsEndpoint.protocol === 'http:'\n    this.transport = isHttp ? http : https\n\n    /**\n     * Internal Tracking variables\n     */\n    this._credentials = null\n  }\n\n  getRequestConfig(): {\n    requestOptions: http.RequestOptions\n    requestData: string\n  } {\n    const hostValue = this.stsEndpoint.hostname\n    const portValue = this.stsEndpoint.port\n    const qryParams = new URLSearchParams({ Action: this.action, Version: '2011-06-15' })\n\n    qryParams.set('DurationSeconds', this.expirySeconds.toString())\n\n    if (this.policy) {\n      qryParams.set('Policy', this.policy)\n    }\n    if (this.roleArn) {\n      qryParams.set('RoleArn', this.roleArn)\n    }\n\n    if (this.roleSessionName != null) {\n      qryParams.set('RoleSessionName', this.roleSessionName)\n    }\n    if (this.token != null) {\n      qryParams.set('Token', this.token)\n    }\n\n    if (this.webIdentityToken) {\n      qryParams.set('WebIdentityToken', this.webIdentityToken)\n    }\n\n    if (this.externalId) {\n      qryParams.set('ExternalId', this.externalId)\n    }\n\n    const urlParams = qryParams.toString()\n    const contentSha256 = toSha256(urlParams)\n\n    const date = new Date()\n\n    const requestOptions = {\n      hostname: hostValue,\n      port: portValue,\n      path: '/',\n      protocol: this.stsEndpoint.protocol,\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n        'content-length': urlParams.length.toString(),\n        host: hostValue,\n        'x-amz-date': makeDateLong(date),\n        'x-amz-content-sha256': contentSha256,\n      } as Record<string, string>,\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    requestOptions.headers.authorization = signV4ByServiceName(\n      requestOptions,\n      this.accessKey,\n      this.secretKey,\n      this.region,\n      date,\n      contentSha256,\n      'sts',\n    )\n\n    return {\n      requestOptions,\n      requestData: urlParams,\n    }\n  }\n\n  async performRequest(): Promise<CredentialResponse> {\n    const { requestOptions, requestData } = this.getRequestConfig()\n\n    const res = await request(this.transport, requestOptions, requestData)\n\n    const body = await readAsString(res)\n\n    return parseXml(body)\n  }\n\n  parseCredentials(respObj: CredentialResponse): Credentials {\n    if (respObj.ErrorResponse) {\n      throw new Error(\n        `Unable to obtain credentials: ${respObj.ErrorResponse?.Error?.Code} ${respObj.ErrorResponse?.Error?.Message}`,\n        { cause: respObj },\n      )\n    }\n\n    const {\n      AssumeRoleResponse: {\n        AssumeRoleResult: {\n          Credentials: {\n            AccessKeyId: accessKey,\n            SecretAccessKey: secretKey,\n            SessionToken: sessionToken,\n            Expiration: expiresAt,\n          },\n        },\n      },\n    } = respObj\n\n    this.accessExpiresAt = expiresAt\n\n    return new Credentials({ accessKey, secretKey, sessionToken })\n  }\n\n  async refreshCredentials(): Promise<Credentials> {\n    try {\n      const assumeRoleCredentials = await this.performRequest()\n      this._credentials = this.parseCredentials(assumeRoleCredentials)\n    } catch (err) {\n      throw new Error(`Failed to get Credentials: ${err}`, { cause: err })\n    }\n\n    return this._credentials\n  }\n\n  async getCredentials(): Promise<Credentials> {\n    if (this._credentials && !this.isAboutToExpire()) {\n      return this._credentials\n    }\n\n    this._credentials = await this.refreshCredentials()\n    return this._credentials\n  }\n\n  isAboutToExpire() {\n    const expiresAt = new Date(this.accessExpiresAt)\n    const provisionalExpiry = new Date(Date.now() + 1000 * 10) // check before 10 seconds.\n    return provisionalExpiry > expiresAt\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default AssumeRoleProvider\n"],"mappings":"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"}

package/dist/main/CredentialProvider.d.ts

@@ -0,0 +1,22 @@
+import { Credentials } from "./Credentials.js";
+export declare class CredentialProvider {
+  private credentials;
+  constructor({
+    accessKey,
+    secretKey,
+    sessionToken
+  }: {
+    accessKey: string;
+    secretKey: string;
+    sessionToken?: string;
+  });
+  getCredentials(): Promise<Credentials>;
+  setCredentials(credentials: Credentials): void;
+  setAccessKey(accessKey: string): void;
+  getAccessKey(): string;
+  setSecretKey(secretKey: string): void;
+  getSecretKey(): string;
+  setSessionToken(sessionToken: string): void;
+  getSessionToken(): string | undefined;
+}
+export default CredentialProvider;