@aws-sdk/middleware-signing 3.901.0 → 3.910.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist-cjs/index.js +204 -250
  2. package/package.json +7 -7
package/dist-cjs/index.js CHANGED
@@ -1,267 +1,221 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
10
- };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
18
- };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
1
+ 'use strict';
20
2
 
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- awsAuthMiddleware: () => awsAuthMiddleware,
25
- awsAuthMiddlewareOptions: () => awsAuthMiddlewareOptions,
26
- getAwsAuthPlugin: () => getAwsAuthPlugin,
27
- getSigV4AuthPlugin: () => getSigV4AuthPlugin,
28
- resolveAwsAuthConfig: () => resolveAwsAuthConfig,
29
- resolveSigV4AuthConfig: () => resolveSigV4AuthConfig
30
- });
31
- module.exports = __toCommonJS(index_exports);
3
+ var propertyProvider = require('@smithy/property-provider');
4
+ var signatureV4 = require('@smithy/signature-v4');
5
+ var utilMiddleware = require('@smithy/util-middleware');
6
+ var protocolHttp = require('@smithy/protocol-http');
32
7
 
33
- // src/awsAuthConfiguration.ts
34
- var import_property_provider = require("@smithy/property-provider");
35
- var import_signature_v4 = require("@smithy/signature-v4");
36
- var import_util_middleware = require("@smithy/util-middleware");
37
- var CREDENTIAL_EXPIRE_WINDOW = 3e5;
38
- var resolveAwsAuthConfig = /* @__PURE__ */ __name((input) => {
39
- const normalizedCreds = createConfigBoundCredentialProvider(input);
40
- const { signingEscapePath = true, systemClockOffset = input.systemClockOffset || 0, sha256 } = input;
41
- let signer;
42
- if (input.signer) {
43
- signer = (0, import_util_middleware.normalizeProvider)(input.signer);
44
- } else if (input.regionInfoProvider) {
45
- signer = /* @__PURE__ */ __name(() => (0, import_util_middleware.normalizeProvider)(input.region)().then(
46
- async (region) => [
47
- await input.regionInfoProvider(region, {
48
- useFipsEndpoint: await input.useFipsEndpoint(),
49
- useDualstackEndpoint: await input.useDualstackEndpoint()
50
- }) || {},
51
- region
52
- ]
53
- ).then(([regionInfo, region]) => {
54
- const { signingRegion, signingService } = regionInfo;
55
- input.signingRegion = input.signingRegion || signingRegion || region;
56
- input.signingName = input.signingName || signingService || input.serviceId;
57
- const params = {
58
- ...input,
59
- credentials: normalizedCreds,
60
- region: input.signingRegion,
61
- service: input.signingName,
62
- sha256,
63
- uriEscapePath: signingEscapePath
64
- };
65
- const SignerCtor = input.signerConstructor || import_signature_v4.SignatureV4;
66
- return new SignerCtor(params);
67
- }), "signer");
68
- } else {
69
- signer = /* @__PURE__ */ __name(async (authScheme) => {
70
- authScheme = Object.assign(
71
- {},
72
- {
73
- name: "sigv4",
74
- signingName: input.signingName || input.defaultSigningName,
75
- signingRegion: await (0, import_util_middleware.normalizeProvider)(input.region)(),
76
- properties: {}
77
- },
78
- authScheme
79
- );
80
- const isSigv4a = authScheme?.name === "sigv4a";
81
- const signingRegion = authScheme.signingRegion;
82
- const signingService = authScheme.signingName;
83
- let regionForSigner;
84
- if (isSigv4a) {
85
- regionForSigner = input.signingRegion || signingRegion;
86
- } else {
87
- input.signingRegion = input.signingRegion || signingRegion;
88
- regionForSigner = input.signingRegion;
89
- }
90
- input.signingName = input.signingName || signingService || input.serviceId;
91
- const params = {
92
- ...input,
8
+ const CREDENTIAL_EXPIRE_WINDOW = 300000;
9
+ const resolveAwsAuthConfig = (input) => {
10
+ const normalizedCreds = createConfigBoundCredentialProvider(input);
11
+ const { signingEscapePath = true, systemClockOffset = input.systemClockOffset || 0, sha256 } = input;
12
+ let signer;
13
+ if (input.signer) {
14
+ signer = utilMiddleware.normalizeProvider(input.signer);
15
+ }
16
+ else if (input.regionInfoProvider) {
17
+ signer = () => utilMiddleware.normalizeProvider(input.region)()
18
+ .then(async (region) => [
19
+ (await input.regionInfoProvider(region, {
20
+ useFipsEndpoint: await input.useFipsEndpoint(),
21
+ useDualstackEndpoint: await input.useDualstackEndpoint(),
22
+ })) || {},
23
+ region,
24
+ ])
25
+ .then(([regionInfo, region]) => {
26
+ const { signingRegion, signingService } = regionInfo;
27
+ input.signingRegion = input.signingRegion || signingRegion || region;
28
+ input.signingName = input.signingName || signingService || input.serviceId;
29
+ const params = {
30
+ ...input,
31
+ credentials: normalizedCreds,
32
+ region: input.signingRegion,
33
+ service: input.signingName,
34
+ sha256,
35
+ uriEscapePath: signingEscapePath,
36
+ };
37
+ const SignerCtor = input.signerConstructor || signatureV4.SignatureV4;
38
+ return new SignerCtor(params);
39
+ });
40
+ }
41
+ else {
42
+ signer = async (authScheme) => {
43
+ authScheme = Object.assign({}, {
44
+ name: "sigv4",
45
+ signingName: input.signingName || input.defaultSigningName,
46
+ signingRegion: await utilMiddleware.normalizeProvider(input.region)(),
47
+ properties: {},
48
+ }, authScheme);
49
+ const isSigv4a = authScheme?.name === "sigv4a";
50
+ const signingRegion = authScheme.signingRegion;
51
+ const signingService = authScheme.signingName;
52
+ let regionForSigner;
53
+ if (isSigv4a) {
54
+ regionForSigner = input.signingRegion || signingRegion;
55
+ }
56
+ else {
57
+ input.signingRegion = input.signingRegion || signingRegion;
58
+ regionForSigner = input.signingRegion;
59
+ }
60
+ input.signingName = input.signingName || signingService || input.serviceId;
61
+ const params = {
62
+ ...input,
63
+ credentials: normalizedCreds,
64
+ region: regionForSigner,
65
+ service: input.signingName,
66
+ sha256,
67
+ uriEscapePath: signingEscapePath,
68
+ };
69
+ const SignerCtor = input.signerConstructor || signatureV4.SignatureV4;
70
+ return new SignerCtor(params);
71
+ };
72
+ }
73
+ return Object.assign(input, {
74
+ systemClockOffset,
75
+ signingEscapePath,
93
76
  credentials: normalizedCreds,
94
- region: regionForSigner,
95
- service: input.signingName,
96
- sha256,
97
- uriEscapePath: signingEscapePath
98
- };
99
- const SignerCtor = input.signerConstructor || import_signature_v4.SignatureV4;
100
- return new SignerCtor(params);
101
- }, "signer");
102
- }
103
- return Object.assign(input, {
104
- systemClockOffset,
105
- signingEscapePath,
106
- credentials: normalizedCreds,
107
- signer
108
- });
109
- }, "resolveAwsAuthConfig");
110
- var resolveSigV4AuthConfig = /* @__PURE__ */ __name((input) => {
111
- const normalizedCreds = createConfigBoundCredentialProvider(input);
112
- const { signingEscapePath = true, systemClockOffset = input.systemClockOffset || 0, sha256 } = input;
113
- let signer;
114
- if (input.signer) {
115
- signer = (0, import_util_middleware.normalizeProvider)(input.signer);
116
- } else {
117
- signer = (0, import_util_middleware.normalizeProvider)(
118
- new import_signature_v4.SignatureV4({
77
+ signer,
78
+ });
79
+ };
80
+ const resolveSigV4AuthConfig = (input) => {
81
+ const normalizedCreds = createConfigBoundCredentialProvider(input);
82
+ const { signingEscapePath = true, systemClockOffset = input.systemClockOffset || 0, sha256 } = input;
83
+ let signer;
84
+ if (input.signer) {
85
+ signer = utilMiddleware.normalizeProvider(input.signer);
86
+ }
87
+ else {
88
+ signer = utilMiddleware.normalizeProvider(new signatureV4.SignatureV4({
89
+ credentials: normalizedCreds,
90
+ region: input.region,
91
+ service: input.signingName,
92
+ sha256,
93
+ uriEscapePath: signingEscapePath,
94
+ }));
95
+ }
96
+ return Object.assign(input, {
97
+ systemClockOffset,
98
+ signingEscapePath,
119
99
  credentials: normalizedCreds,
120
- region: input.region,
121
- service: input.signingName,
122
- sha256,
123
- uriEscapePath: signingEscapePath
124
- })
125
- );
126
- }
127
- return Object.assign(input, {
128
- systemClockOffset,
129
- signingEscapePath,
130
- credentials: normalizedCreds,
131
- signer
132
- });
133
- }, "resolveSigV4AuthConfig");
134
- var normalizeCredentialProvider = /* @__PURE__ */ __name((credentials) => {
135
- if (typeof credentials === "function") {
136
- return (0, import_property_provider.memoize)(
137
- credentials,
138
- (credentials2) => credentials2.expiration !== void 0 && credentials2.expiration.getTime() - Date.now() < CREDENTIAL_EXPIRE_WINDOW,
139
- (credentials2) => credentials2.expiration !== void 0
140
- );
141
- }
142
- return (0, import_util_middleware.normalizeProvider)(credentials);
143
- }, "normalizeCredentialProvider");
144
- var createConfigBoundCredentialProvider = /* @__PURE__ */ __name((input) => {
145
- const normalizedCredentialsProvider = input.credentials ? normalizeCredentialProvider(input.credentials) : input.credentialDefaultProvider(
146
- Object.assign({}, input, {
147
- parentClientConfig: input
148
- })
149
- );
150
- const normalizedCreds = /* @__PURE__ */ __name(async () => normalizedCredentialsProvider({
151
- callerClientConfig: {
152
- region: (0, import_util_middleware.normalizeProvider)(input.region),
153
- profile: input.profile
100
+ signer,
101
+ });
102
+ };
103
+ const normalizeCredentialProvider = (credentials) => {
104
+ if (typeof credentials === "function") {
105
+ return propertyProvider.memoize(credentials, (credentials) => credentials.expiration !== undefined &&
106
+ credentials.expiration.getTime() - Date.now() < CREDENTIAL_EXPIRE_WINDOW, (credentials) => credentials.expiration !== undefined);
154
107
  }
155
- }), "normalizedCreds");
156
- return normalizedCreds;
157
- }, "createConfigBoundCredentialProvider");
158
-
159
- // src/awsAuthMiddleware.ts
160
- var import_protocol_http = require("@smithy/protocol-http");
108
+ return utilMiddleware.normalizeProvider(credentials);
109
+ };
110
+ const createConfigBoundCredentialProvider = (input) => {
111
+ const normalizedCredentialsProvider = input.credentials
112
+ ? normalizeCredentialProvider(input.credentials)
113
+ : input.credentialDefaultProvider(Object.assign({}, input, {
114
+ parentClientConfig: input,
115
+ }));
116
+ const normalizedCreds = async () => normalizedCredentialsProvider({
117
+ callerClientConfig: {
118
+ region: utilMiddleware.normalizeProvider(input.region),
119
+ profile: input.profile,
120
+ },
121
+ });
122
+ return normalizedCreds;
123
+ };
161
124
 
162
- // src/utils/getSkewCorrectedDate.ts
163
- var getSkewCorrectedDate = /* @__PURE__ */ __name((systemClockOffset) => new Date(Date.now() + systemClockOffset), "getSkewCorrectedDate");
125
+ const getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
164
126
 
165
- // src/utils/isClockSkewed.ts
166
- var isClockSkewed = /* @__PURE__ */ __name((clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 3e5, "isClockSkewed");
127
+ const isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000;
167
128
 
168
- // src/utils/getUpdatedSystemClockOffset.ts
169
- var getUpdatedSystemClockOffset = /* @__PURE__ */ __name((clockTime, currentSystemClockOffset) => {
170
- const clockTimeInMs = Date.parse(clockTime);
171
- if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
172
- return clockTimeInMs - Date.now();
173
- }
174
- return currentSystemClockOffset;
175
- }, "getUpdatedSystemClockOffset");
129
+ const getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
130
+ const clockTimeInMs = Date.parse(clockTime);
131
+ if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
132
+ return clockTimeInMs - Date.now();
133
+ }
134
+ return currentSystemClockOffset;
135
+ };
176
136
 
177
- // src/awsAuthMiddleware.ts
178
- var awsAuthMiddleware = /* @__PURE__ */ __name((options) => (next, context) => async function(args) {
179
- if (!import_protocol_http.HttpRequest.isInstance(args.request)) return next(args);
180
- let authScheme;
181
- let signer;
182
- const firstAuthScheme = context.endpointV2?.properties?.authSchemes?.[0];
183
- const secondAuthScheme = context.endpointV2?.properties?.authSchemes?.[1];
184
- const firstAuthSchemeIsSigv4a = firstAuthScheme?.name === "sigv4a";
185
- if (firstAuthSchemeIsSigv4a && secondAuthScheme) {
186
- signer = await options.signer(authScheme = firstAuthScheme);
187
- const uncheckedSigner = signer;
188
- const sigv4aAvailable = (() => {
189
- if (typeof uncheckedSigner?.getSigv4aSigner === "function") {
190
- if (uncheckedSigner?.signerOptions?.runtime !== "node") {
191
- return false;
137
+ const awsAuthMiddleware = (options) => (next, context) => async function (args) {
138
+ if (!protocolHttp.HttpRequest.isInstance(args.request))
139
+ return next(args);
140
+ let authScheme;
141
+ let signer;
142
+ const firstAuthScheme = context.endpointV2?.properties?.authSchemes?.[0];
143
+ const secondAuthScheme = context.endpointV2?.properties?.authSchemes?.[1];
144
+ const firstAuthSchemeIsSigv4a = firstAuthScheme?.name === "sigv4a";
145
+ if (firstAuthSchemeIsSigv4a && secondAuthScheme) {
146
+ signer = await options.signer((authScheme = firstAuthScheme));
147
+ const uncheckedSigner = signer;
148
+ const sigv4aAvailable = (() => {
149
+ if (typeof uncheckedSigner?.getSigv4aSigner === "function") {
150
+ if (uncheckedSigner?.signerOptions?.runtime !== "node") {
151
+ return false;
152
+ }
153
+ try {
154
+ uncheckedSigner.getSigv4aSigner();
155
+ return true;
156
+ }
157
+ catch (e) { }
158
+ }
159
+ return false;
160
+ })();
161
+ if (!sigv4aAvailable) {
162
+ signer = await options.signer((authScheme = secondAuthScheme));
192
163
  }
193
- try {
194
- uncheckedSigner.getSigv4aSigner();
195
- return true;
196
- } catch (e) {
164
+ }
165
+ else {
166
+ signer = await options.signer((authScheme = firstAuthScheme));
167
+ }
168
+ let signedRequest;
169
+ const multiRegionOverride = authScheme?.name === "sigv4a" ? authScheme?.signingRegionSet?.join(",") : undefined;
170
+ const signingOptions = {
171
+ signingDate: getSkewCorrectedDate(options.systemClockOffset),
172
+ signingRegion: multiRegionOverride || context["signing_region"],
173
+ signingService: context["signing_service"],
174
+ };
175
+ if (context.s3ExpressIdentity) {
176
+ const sigV4MultiRegion = signer;
177
+ signedRequest = await sigV4MultiRegion.signWithCredentials(args.request, context.s3ExpressIdentity, signingOptions);
178
+ if (signedRequest.headers["X-Amz-Security-Token"] || signedRequest.headers["x-amz-security-token"]) {
179
+ throw new Error("X-Amz-Security-Token must not be set for s3-express requests.");
197
180
  }
198
- }
199
- return false;
200
- })();
201
- if (!sigv4aAvailable) {
202
- signer = await options.signer(authScheme = secondAuthScheme);
203
181
  }
204
- } else {
205
- signer = await options.signer(authScheme = firstAuthScheme);
206
- }
207
- let signedRequest;
208
- const multiRegionOverride = authScheme?.name === "sigv4a" ? authScheme?.signingRegionSet?.join(",") : void 0;
209
- const signingOptions = {
210
- signingDate: getSkewCorrectedDate(options.systemClockOffset),
211
- signingRegion: multiRegionOverride || context["signing_region"],
212
- signingService: context["signing_service"]
213
- };
214
- if (context.s3ExpressIdentity) {
215
- const sigV4MultiRegion = signer;
216
- signedRequest = await sigV4MultiRegion.signWithCredentials(
217
- args.request,
218
- context.s3ExpressIdentity,
219
- signingOptions
220
- );
221
- if (signedRequest.headers["X-Amz-Security-Token"] || signedRequest.headers["x-amz-security-token"]) {
222
- throw new Error("X-Amz-Security-Token must not be set for s3-express requests.");
182
+ else {
183
+ signedRequest = await signer.sign(args.request, signingOptions);
223
184
  }
224
- } else {
225
- signedRequest = await signer.sign(args.request, signingOptions);
226
- }
227
- const output = await next({
228
- ...args,
229
- request: signedRequest
230
- }).catch((error) => {
231
- const serverTime = error.ServerTime ?? getDateHeader(error.$response);
232
- if (serverTime) {
233
- options.systemClockOffset = getUpdatedSystemClockOffset(serverTime, options.systemClockOffset);
185
+ const output = await next({
186
+ ...args,
187
+ request: signedRequest,
188
+ }).catch((error) => {
189
+ const serverTime = error.ServerTime ?? getDateHeader(error.$response);
190
+ if (serverTime) {
191
+ options.systemClockOffset = getUpdatedSystemClockOffset(serverTime, options.systemClockOffset);
192
+ }
193
+ throw error;
194
+ });
195
+ const dateHeader = getDateHeader(output.response);
196
+ if (dateHeader) {
197
+ options.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, options.systemClockOffset);
234
198
  }
235
- throw error;
236
- });
237
- const dateHeader = getDateHeader(output.response);
238
- if (dateHeader) {
239
- options.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, options.systemClockOffset);
240
- }
241
- return output;
242
- }, "awsAuthMiddleware");
243
- var getDateHeader = /* @__PURE__ */ __name((response) => import_protocol_http.HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : void 0, "getDateHeader");
244
- var awsAuthMiddlewareOptions = {
245
- name: "awsAuthMiddleware",
246
- tags: ["SIGNATURE", "AWSAUTH"],
247
- relation: "after",
248
- toMiddleware: "retryMiddleware",
249
- override: true
199
+ return output;
250
200
  };
251
- var getAwsAuthPlugin = /* @__PURE__ */ __name((options) => ({
252
- applyToStack: /* @__PURE__ */ __name((clientStack) => {
253
- clientStack.addRelativeTo(awsAuthMiddleware(options), awsAuthMiddlewareOptions);
254
- }, "applyToStack")
255
- }), "getAwsAuthPlugin");
256
- var getSigV4AuthPlugin = getAwsAuthPlugin;
257
- // Annotate the CommonJS export names for ESM import in node:
258
-
259
- 0 && (module.exports = {
260
- resolveAwsAuthConfig,
261
- resolveSigV4AuthConfig,
262
- awsAuthMiddleware,
263
- awsAuthMiddlewareOptions,
264
- getAwsAuthPlugin,
265
- getSigV4AuthPlugin
201
+ const getDateHeader = (response) => protocolHttp.HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined;
202
+ const awsAuthMiddlewareOptions = {
203
+ name: "awsAuthMiddleware",
204
+ tags: ["SIGNATURE", "AWSAUTH"],
205
+ relation: "after",
206
+ toMiddleware: "retryMiddleware",
207
+ override: true,
208
+ };
209
+ const getAwsAuthPlugin = (options) => ({
210
+ applyToStack: (clientStack) => {
211
+ clientStack.addRelativeTo(awsAuthMiddleware(options), awsAuthMiddlewareOptions);
212
+ },
266
213
  });
214
+ const getSigV4AuthPlugin = getAwsAuthPlugin;
267
215
 
216
+ exports.awsAuthMiddleware = awsAuthMiddleware;
217
+ exports.awsAuthMiddlewareOptions = awsAuthMiddlewareOptions;
218
+ exports.getAwsAuthPlugin = getAwsAuthPlugin;
219
+ exports.getSigV4AuthPlugin = getSigV4AuthPlugin;
220
+ exports.resolveAwsAuthConfig = resolveAwsAuthConfig;
221
+ exports.resolveSigV4AuthConfig = resolveSigV4AuthConfig;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@aws-sdk/middleware-signing",
3
- "version": "3.901.0",
3
+ "version": "3.910.0",
4
4
  "scripts": {
5
5
  "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
6
6
  "build:cjs": "node ../../scripts/compilation/inline middleware-signing",
@@ -25,12 +25,12 @@
25
25
  },
26
26
  "license": "Apache-2.0",
27
27
  "dependencies": {
28
- "@aws-sdk/types": "3.901.0",
29
- "@smithy/property-provider": "^4.2.0",
30
- "@smithy/protocol-http": "^5.3.0",
31
- "@smithy/signature-v4": "^5.3.0",
32
- "@smithy/types": "^4.6.0",
33
- "@smithy/util-middleware": "^4.2.0",
28
+ "@aws-sdk/types": "3.910.0",
29
+ "@smithy/property-provider": "^4.2.2",
30
+ "@smithy/protocol-http": "^5.3.2",
31
+ "@smithy/signature-v4": "^5.3.2",
32
+ "@smithy/types": "^4.7.1",
33
+ "@smithy/util-middleware": "^4.2.2",
34
34
  "tslib": "^2.6.2"
35
35
  },
36
36
  "engines": {