@aws-cdk/toolkit-lib 0.3.1 → 0.3.3

package/lib/api/aws-auth/sdk-provider.js

@@ -0,0 +1,373 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SdkProvider_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkProvider = void 0;
+exports.initContextProviderSdk = initContextProviderSdk;
+const os = require("os");
+const cx_api_1 = require("@aws-cdk/cx-api");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const awscli_compatible_1 = require("./awscli-compatible");
+const cached_1 = require("./cached");
+const credential_plugins_1 = require("./credential-plugins");
+const provider_caching_1 = require("./provider-caching");
+const sdk_1 = require("./sdk");
+const tracing_1 = require("./tracing");
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+const plugin_1 = require("../plugin");
+const toolkit_error_1 = require("../toolkit-error");
+const CACHED_ACCOUNT = Symbol('cached_account');
+/**
+ * Creates instances of the AWS SDK appropriate for a given account/region.
+ *
+ * Behavior is as follows:
+ *
+ * - First, a set of "base" credentials are established
+ *   - If a target environment is given and the default ("current") SDK credentials are for
+ *     that account, return those; otherwise
+ *   - If a target environment is given, scan all credential provider plugins
+ *     for credentials, and return those if found; otherwise
+ *   - Return default ("current") SDK credentials, noting that they might be wrong.
+ *
+ * - Second, a role may optionally need to be assumed. Use the base credentials
+ *   established in the previous process to assume that role.
+ *   - If assuming the role fails and the base credentials are for the correct
+ *     account, return those. This is a fallback for people who are trying to interact
+ *     with a Default Synthesized stack and already have right credentials setup.
+ *
+ *     Typical cases we see in the wild:
+ *     - Credential plugin setup that, although not recommended, works for them
+ *     - Seeded terminal with `ReadOnly` credentials in order to do `cdk diff`--the `ReadOnly`
+ *       role doesn't have `sts:AssumeRole` and will fail for no real good reason.
+ */
+let SdkProvider = SdkProvider_1 = class SdkProvider {
+    /**
+     * Create a new SdkProvider which gets its defaults in a way that behaves like the AWS CLI does
+     *
+     * The AWS SDK for JS behaves slightly differently from the AWS CLI in a number of ways; see the
+     * class `AwsCliCompatible` for the details.
+     */
+    static async withAwsCliCompatibleDefaults(options) {
+        (0, tracing_1.callTrace)(SdkProvider_1.withAwsCliCompatibleDefaults.name, SdkProvider_1.constructor.name, options.logger);
+        const config = await new awscli_compatible_1.AwsCliCompatible(options.ioHelper, options.requestHandler ?? {}, options.logger).baseConfig(options.profile);
+        return new SdkProvider_1(config.credentialProvider, config.defaultRegion, options);
+    }
+    defaultRegion;
+    defaultCredentialProvider;
+    plugins;
+    requestHandler;
+    ioHelper;
+    logger;
+    constructor(defaultCredentialProvider, defaultRegion, services) {
+        this.defaultCredentialProvider = defaultCredentialProvider;
+        this.defaultRegion = defaultRegion ?? 'us-east-1';
+        this.requestHandler = services.requestHandler ?? {};
+        this.ioHelper = services.ioHelper;
+        this.logger = services.logger;
+        this.plugins = new credential_plugins_1.CredentialPlugins(services.pluginHost ?? new plugin_1.PluginHost(), this.ioHelper);
+    }
+    /**
+     * Return an SDK which can do operations in the given environment
+     *
+     * The `environment` parameter is resolved first (see `resolveEnvironment()`).
+     */
+    async forEnvironment(environment, mode, options, quiet = false) {
+        const env = await this.resolveEnvironment(environment);
+        const baseCreds = await this.obtainBaseCredentials(env.account, mode);
+        // At this point, we need at least SOME credentials
+        if (baseCreds.source === 'none') {
+            throw new toolkit_error_1.AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds));
+        }
+        // Simple case is if we don't need to "assumeRole" here. If so, we must now have credentials for the right
+        // account.
+        if (options?.assumeRoleArn === undefined) {
+            if (baseCreds.source === 'incorrectDefault') {
+                throw new toolkit_error_1.AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds));
+            }
+            // Our current credentials must be valid and not expired. Confirm that before we get into doing
+            // actual CloudFormation calls, which might take a long time to hang.
+            const sdk = this._makeSdk(baseCreds.credentials, env.region);
+            await sdk.validateCredentials();
+            return { sdk, didAssumeRole: false };
+        }
+        try {
+            // We will proceed to AssumeRole using whatever we've been given.
+            const sdk = await this.withAssumedRole(baseCreds, options.assumeRoleArn, options.assumeRoleExternalId, options.assumeRoleAdditionalOptions, env.region);
+            return { sdk, didAssumeRole: true };
+        }
+        catch (err) {
+            if (err.name === 'ExpiredToken') {
+                throw err;
+            }
+            // AssumeRole failed. Proceed and warn *if and only if* the baseCredentials were already for the right account
+            // or returned from a plugin. This is to cover some current setups for people using plugins or preferring to
+            // feed the CLI credentials which are sufficient by themselves. Prefer to assume the correct role if we can,
+            // but if we can't then let's just try with available credentials anyway.
+            if (baseCreds.source === 'correctDefault' || baseCreds.source === 'plugin') {
+                await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(err.message));
+                const maker = quiet ? private_1.IO.DEFAULT_SDK_DEBUG : private_1.IO.DEFAULT_SDK_WARN;
+                await this.ioHelper.notify(maker.msg(`${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`));
+                return {
+                    sdk: this._makeSdk(baseCreds.credentials, env.region),
+                    didAssumeRole: false,
+                };
+            }
+            throw err;
+        }
+    }
+    /**
+     * Return the partition that base credentials are for
+     *
+     * Returns `undefined` if there are no base credentials.
+     */
+    async baseCredentialsPartition(environment, mode) {
+        const env = await this.resolveEnvironment(environment);
+        const baseCreds = await this.obtainBaseCredentials(env.account, mode);
+        if (baseCreds.source === 'none') {
+            return undefined;
+        }
+        return (await this._makeSdk(baseCreds.credentials, env.region).currentAccount()).partition;
+    }
+    /**
+     * Resolve the environment for a stack
+     *
+     * Replaces the magic values `UNKNOWN_REGION` and `UNKNOWN_ACCOUNT`
+     * with the defaults for the current SDK configuration (`~/.aws/config` or
+     * otherwise).
+     *
+     * It is an error if `UNKNOWN_ACCOUNT` is used but the user hasn't configured
+     * any SDK credentials.
+     */
+    async resolveEnvironment(env) {
+        const region = env.region !== cx_api_1.UNKNOWN_REGION ? env.region : this.defaultRegion;
+        const account = env.account !== cx_api_1.UNKNOWN_ACCOUNT ? env.account : (await this.defaultAccount())?.accountId;
+        if (!account) {
+            throw new toolkit_error_1.AuthenticationError('Unable to resolve AWS account to use. It must be either configured when you define your CDK Stack, or through the environment');
+        }
+        return {
+            region,
+            account,
+            name: cx_api_1.EnvironmentUtils.format(account, region),
+        };
+    }
+    /**
+     * The account we'd auth into if we used default credentials.
+     *
+     * Default credentials are the set of ambiently configured credentials using
+     * one of the environment variables, or ~/.aws/credentials, or the *one*
+     * profile that was passed into the CLI.
+     *
+     * Might return undefined if there are no default/ambient credentials
+     * available (in which case the user should better hope they have
+     * credential plugins configured).
+     *
+     * Uses a cache to avoid STS calls if we don't need 'em.
+     */
+    async defaultAccount() {
+        return (0, cached_1.cached)(this, CACHED_ACCOUNT, async () => {
+            try {
+                return await this._makeSdk(this.defaultCredentialProvider, this.defaultRegion).currentAccount();
+            }
+            catch (e) {
+                // Treat 'ExpiredToken' specially. This is a common situation that people may find themselves in, and
+                // they are complaining about if we fail 'cdk synth' on them. We loudly complain in order to show that
+                // the current situation is probably undesirable, but we don't fail.
+                if (e.name === 'ExpiredToken') {
+                    await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_WARN.msg('There are expired AWS credentials in your environment. The CDK app will synth without current account information.'));
+                    return undefined;
+                }
+                await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Unable to determine the default AWS account (${e.name}): ${(0, util_1.formatErrorMessage)(e)}`));
+                return undefined;
+            }
+        });
+    }
+    /**
+     * Get credentials for the given account ID in the given mode
+     *
+     * 1. Use the default credentials if the destination account matches the
+     *    current credentials' account.
+     * 2. Otherwise try all credential plugins.
+     * 3. Fail if neither of these yield any credentials.
+     * 4. Return a failure if any of them returned credentials
+     */
+    async obtainBaseCredentials(accountId, mode) {
+        // First try 'current' credentials
+        const defaultAccountId = (await this.defaultAccount())?.accountId;
+        if (defaultAccountId === accountId) {
+            return {
+                source: 'correctDefault',
+                credentials: await this.defaultCredentialProvider,
+            };
+        }
+        // Then try the plugins
+        const pluginCreds = await this.plugins.fetchCredentialsFor(accountId, mode);
+        if (pluginCreds) {
+            return { source: 'plugin', ...pluginCreds };
+        }
+        // Fall back to default credentials with a note that they're not the right ones yet
+        if (defaultAccountId !== undefined) {
+            return {
+                source: 'incorrectDefault',
+                accountId: defaultAccountId,
+                credentials: await this.defaultCredentialProvider,
+                unusedPlugins: this.plugins.availablePluginNames,
+            };
+        }
+        // Apparently we didn't find any at all
+        return {
+            source: 'none',
+            unusedPlugins: this.plugins.availablePluginNames,
+        };
+    }
+    /**
+     * Return an SDK which uses assumed role credentials
+     *
+     * The base credentials used to retrieve the assumed role credentials will be the
+     * same credentials returned by obtainCredentials if an environment and mode is passed,
+     * otherwise it will be the current credentials.
+     */
+    async withAssumedRole(mainCredentials, roleArn, externalId, additionalOptions, region) {
+        await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Assuming role '${roleArn}'.`));
+        region = region ?? this.defaultRegion;
+        const sourceDescription = fmtObtainedCredentials(mainCredentials);
+        try {
+            const credentials = await (0, provider_caching_1.makeCachingProvider)((0, credential_providers_1.fromTemporaryCredentials)({
+                masterCredentials: mainCredentials.credentials,
+                params: {
+                    RoleArn: roleArn,
+                    ExternalId: externalId,
+                    RoleSessionName: `aws-cdk-${safeUsername()}`,
+                    ...additionalOptions,
+                    TransitiveTagKeys: additionalOptions?.Tags ? additionalOptions.Tags.map((t) => t.Key) : undefined,
+                },
+                clientConfig: {
+                    region,
+                    requestHandler: this.requestHandler,
+                    customUserAgent: 'aws-cdk',
+                    logger: this.logger,
+                },
+                logger: this.logger,
+            }));
+            // Call the provider at least once here, to catch an error if it occurs
+            await credentials();
+            return this._makeSdk(credentials, region);
+        }
+        catch (err) {
+            if (err.name === 'ExpiredToken') {
+                throw err;
+            }
+            await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Assuming role failed: ${err.message}`));
+            throw new toolkit_error_1.AuthenticationError([
+                'Could not assume role in target account',
+                ...(sourceDescription ? [`using ${sourceDescription}`] : []),
+                err.message,
+                ". Please make sure that this role exists in the account. If it doesn't exist, (re)-bootstrap the environment " +
+                    "with the right '--trust', using the latest version of the CDK CLI.",
+            ].join(' '));
+        }
+    }
+    /**
+     * Factory function that creates a new SDK instance
+     *
+     * This is a function here, instead of all the places where this is used creating a `new SDK`
+     * instance, so that it is trivial to mock from tests.
+     *
+     * Use like this:
+     *
+     * ```ts
+     * const mockSdk = jest.spyOn(SdkProvider.prototype, '_makeSdk').mockReturnValue(new MockSdk());
+     * // ...
+     * mockSdk.mockRestore();
+     * ```
+     *
+     * @internal
+     */
+    _makeSdk(credProvider, region) {
+        return new sdk_1.SDK(credProvider, region, this.requestHandler, this.ioHelper, this.logger);
+    }
+};
+exports.SdkProvider = SdkProvider;
+exports.SdkProvider = SdkProvider = SdkProvider_1 = __decorate([
+    tracing_1.traceMemberMethods
+], SdkProvider);
+/**
+ * Return the username with characters invalid for a RoleSessionName removed
+ *
+ * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters
+ */
+function safeUsername() {
+    try {
+        return os.userInfo().username.replace(/[^\w+=,.@-]/g, '@');
+    }
+    catch {
+        return 'noname';
+    }
+}
+/**
+ * Isolating the code that translates calculation errors into human error messages
+ *
+ * We cover the following cases:
+ *
+ * - No credentials are available at all
+ * - Default credentials are for the wrong account
+ */
+function fmtObtainCredentialsError(targetAccountId, obtainResult) {
+    const msg = [`Need to perform AWS calls for account ${targetAccountId}`];
+    switch (obtainResult.source) {
+        case 'incorrectDefault':
+            msg.push(`but the current credentials are for ${obtainResult.accountId}`);
+            break;
+        case 'none':
+            msg.push('but no credentials have been configured');
+    }
+    if (obtainResult.unusedPlugins.length > 0) {
+        msg.push(`and none of these plugins found any: ${obtainResult.unusedPlugins.join(', ')}`);
+    }
+    return msg.join(', ');
+}
+/**
+ * Format a message indicating where we got base credentials for the assume role
+ *
+ * We cover the following cases:
+ *
+ * - Default credentials for the right account
+ * - Default credentials for the wrong account
+ * - Credentials returned from a plugin
+ */
+function fmtObtainedCredentials(obtainResult) {
+    switch (obtainResult.source) {
+        case 'correctDefault':
+            return 'current credentials';
+        case 'plugin':
+            return `credentials returned by plugin '${obtainResult.pluginName}'`;
+        case 'incorrectDefault':
+            const msg = [];
+            msg.push(`current credentials (which are for account ${obtainResult.accountId}`);
+            if (obtainResult.unusedPlugins.length > 0) {
+                msg.push(`, and none of the following plugins provided credentials: ${obtainResult.unusedPlugins.join(', ')}`);
+            }
+            msg.push(')');
+            return msg.join('');
+    }
+}
+/**
+ * Instantiate an SDK for context providers. This function ensures that all
+ * lookup assume role options are used when context providers perform lookups.
+ */
+async function initContextProviderSdk(aws, options) {
+    const account = options.account;
+    const region = options.region;
+    const creds = {
+        assumeRoleArn: options.lookupRoleArn,
+        assumeRoleExternalId: options.lookupRoleExternalId,
+        assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,
+    };
+    return (await aws.forEnvironment(cx_api_1.EnvironmentUtils.make(account, region), plugin_1.Mode.ForReading, creds)).sdk;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-provider.js","sourceRoot":"","sources":["sdk-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport type { ContextLookupRoleOptions } from '@aws-cdk/cloud-assembly-schema';\nimport type { Environment } from '@aws-cdk/cx-api';\nimport { EnvironmentUtils, UNKNOWN_ACCOUNT, UNKNOWN_REGION } from '@aws-cdk/cx-api';\nimport type { AssumeRoleCommandInput } from '@aws-sdk/client-sts';\nimport { fromTemporaryCredentials } from '@aws-sdk/credential-providers';\nimport type { NodeHttpHandlerOptions } from '@smithy/node-http-handler';\nimport type { AwsCredentialIdentityProvider, Logger } from '@smithy/types';\nimport { AwsCliCompatible } from './awscli-compatible';\nimport { cached } from './cached';\nimport { CredentialPlugins } from './credential-plugins';\nimport { makeCachingProvider } from './provider-caching';\nimport { SDK } from './sdk';\nimport { callTrace, traceMemberMethods } from './tracing';\nimport { formatErrorMessage } from '../../util';\nimport { IO, type IoHelper } from '../io/private';\nimport { PluginHost, Mode } from '../plugin';\nimport { AuthenticationError } from '../toolkit-error';\n\nexport type AssumeRoleAdditionalOptions = Partial<Omit<AssumeRoleCommandInput, 'ExternalId' | 'RoleArn'>>;\n\n/**\n * Options for the default SDK provider\n */\nexport interface SdkProviderOptions extends SdkProviderServices {\n  /**\n   * Profile to read from ~/.aws\n   *\n   * @default - No profile\n   */\n  readonly profile?: string;\n}\n\nconst CACHED_ACCOUNT = Symbol('cached_account');\n\n/**\n * SDK configuration for a given environment\n * 'forEnvironment' will attempt to assume a role and if it\n * is not successful, then it will either:\n *   1. Check to see if the default credentials (local credentials the CLI was executed with)\n *      are for the given environment. If they are then return those.\n *   2. If the default credentials are not for the given environment then\n *      throw an error\n *\n * 'didAssumeRole' allows callers to whether they are receiving the assume role\n * credentials or the default credentials.\n */\nexport interface SdkForEnvironment {\n  /**\n   * The SDK for the given environment\n   */\n  readonly sdk: SDK;\n\n  /**\n   * Whether or not the assume role was successful.\n   * If the assume role was not successful (false)\n   * then that means that the 'sdk' returned contains\n   * the default credentials (not the assume role credentials)\n   */\n  readonly didAssumeRole: boolean;\n}\n\n/**\n * Creates instances of the AWS SDK appropriate for a given account/region.\n *\n * Behavior is as follows:\n *\n * - First, a set of \"base\" credentials are established\n *   - If a target environment is given and the default (\"current\") SDK credentials are for\n *     that account, return those; otherwise\n *   - If a target environment is given, scan all credential provider plugins\n *     for credentials, and return those if found; otherwise\n *   - Return default (\"current\") SDK credentials, noting that they might be wrong.\n *\n * - Second, a role may optionally need to be assumed. Use the base credentials\n *   established in the previous process to assume that role.\n *   - If assuming the role fails and the base credentials are for the correct\n *     account, return those. This is a fallback for people who are trying to interact\n *     with a Default Synthesized stack and already have right credentials setup.\n *\n *     Typical cases we see in the wild:\n *     - Credential plugin setup that, although not recommended, works for them\n *     - Seeded terminal with `ReadOnly` credentials in order to do `cdk diff`--the `ReadOnly`\n *       role doesn't have `sts:AssumeRole` and will fail for no real good reason.\n */\n@traceMemberMethods\nexport class SdkProvider {\n  /**\n   * Create a new SdkProvider which gets its defaults in a way that behaves like the AWS CLI does\n   *\n   * The AWS SDK for JS behaves slightly differently from the AWS CLI in a number of ways; see the\n   * class `AwsCliCompatible` for the details.\n   */\n  public static async withAwsCliCompatibleDefaults(options: SdkProviderOptions) {\n    callTrace(SdkProvider.withAwsCliCompatibleDefaults.name, SdkProvider.constructor.name, options.logger);\n    const config = await new AwsCliCompatible(options.ioHelper, options.requestHandler ?? {}, options.logger).baseConfig(options.profile);\n    return new SdkProvider(config.credentialProvider, config.defaultRegion, options);\n  }\n\n  public readonly defaultRegion: string;\n  private readonly defaultCredentialProvider: AwsCredentialIdentityProvider;\n  private readonly plugins;\n  private readonly requestHandler: NodeHttpHandlerOptions;\n  private readonly ioHelper: IoHelper;\n  private readonly logger?: Logger;\n\n  public constructor(\n    defaultCredentialProvider: AwsCredentialIdentityProvider,\n    defaultRegion: string | undefined,\n    services: SdkProviderServices,\n  ) {\n    this.defaultCredentialProvider = defaultCredentialProvider;\n    this.defaultRegion = defaultRegion ?? 'us-east-1';\n    this.requestHandler = services.requestHandler ?? {};\n    this.ioHelper = services.ioHelper;\n    this.logger = services.logger;\n    this.plugins = new CredentialPlugins(services.pluginHost ?? new PluginHost(), this.ioHelper);\n  }\n\n  /**\n   * Return an SDK which can do operations in the given environment\n   *\n   * The `environment` parameter is resolved first (see `resolveEnvironment()`).\n   */\n  public async forEnvironment(\n    environment: Environment,\n    mode: Mode,\n    options?: CredentialsOptions,\n    quiet = false,\n  ): Promise<SdkForEnvironment> {\n    const env = await this.resolveEnvironment(environment);\n\n    const baseCreds = await this.obtainBaseCredentials(env.account, mode);\n\n    // At this point, we need at least SOME credentials\n    if (baseCreds.source === 'none') {\n      throw new AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds));\n    }\n\n    // Simple case is if we don't need to \"assumeRole\" here. If so, we must now have credentials for the right\n    // account.\n    if (options?.assumeRoleArn === undefined) {\n      if (baseCreds.source === 'incorrectDefault') {\n        throw new AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds));\n      }\n\n      // Our current credentials must be valid and not expired. Confirm that before we get into doing\n      // actual CloudFormation calls, which might take a long time to hang.\n      const sdk = this._makeSdk(baseCreds.credentials, env.region);\n      await sdk.validateCredentials();\n      return { sdk, didAssumeRole: false };\n    }\n\n    try {\n      // We will proceed to AssumeRole using whatever we've been given.\n      const sdk = await this.withAssumedRole(\n        baseCreds,\n        options.assumeRoleArn,\n        options.assumeRoleExternalId,\n        options.assumeRoleAdditionalOptions,\n        env.region,\n      );\n\n      return { sdk, didAssumeRole: true };\n    } catch (err: any) {\n      if (err.name === 'ExpiredToken') {\n        throw err;\n      }\n\n      // AssumeRole failed. Proceed and warn *if and only if* the baseCredentials were already for the right account\n      // or returned from a plugin. This is to cover some current setups for people using plugins or preferring to\n      // feed the CLI credentials which are sufficient by themselves. Prefer to assume the correct role if we can,\n      // but if we can't then let's just try with available credentials anyway.\n      if (baseCreds.source === 'correctDefault' || baseCreds.source === 'plugin') {\n        await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(err.message));\n\n        const maker = quiet ? IO.DEFAULT_SDK_DEBUG : IO.DEFAULT_SDK_WARN;\n        await this.ioHelper.notify(maker.msg(\n          `${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`,\n        ));\n        return {\n          sdk: this._makeSdk(baseCreds.credentials, env.region),\n          didAssumeRole: false,\n        };\n      }\n\n      throw err;\n    }\n  }\n\n  /**\n   * Return the partition that base credentials are for\n   *\n   * Returns `undefined` if there are no base credentials.\n   */\n  public async baseCredentialsPartition(environment: Environment, mode: Mode): Promise<string | undefined> {\n    const env = await this.resolveEnvironment(environment);\n    const baseCreds = await this.obtainBaseCredentials(env.account, mode);\n    if (baseCreds.source === 'none') {\n      return undefined;\n    }\n    return (await this._makeSdk(baseCreds.credentials, env.region).currentAccount()).partition;\n  }\n\n  /**\n   * Resolve the environment for a stack\n   *\n   * Replaces the magic values `UNKNOWN_REGION` and `UNKNOWN_ACCOUNT`\n   * with the defaults for the current SDK configuration (`~/.aws/config` or\n   * otherwise).\n   *\n   * It is an error if `UNKNOWN_ACCOUNT` is used but the user hasn't configured\n   * any SDK credentials.\n   */\n  public async resolveEnvironment(env: Environment): Promise<Environment> {\n    const region = env.region !== UNKNOWN_REGION ? env.region : this.defaultRegion;\n    const account = env.account !== UNKNOWN_ACCOUNT ? env.account : (await this.defaultAccount())?.accountId;\n\n    if (!account) {\n      throw new AuthenticationError(\n        'Unable to resolve AWS account to use. It must be either configured when you define your CDK Stack, or through the environment',\n      );\n    }\n\n    return {\n      region,\n      account,\n      name: EnvironmentUtils.format(account, region),\n    };\n  }\n\n  /**\n   * The account we'd auth into if we used default credentials.\n   *\n   * Default credentials are the set of ambiently configured credentials using\n   * one of the environment variables, or ~/.aws/credentials, or the *one*\n   * profile that was passed into the CLI.\n   *\n   * Might return undefined if there are no default/ambient credentials\n   * available (in which case the user should better hope they have\n   * credential plugins configured).\n   *\n   * Uses a cache to avoid STS calls if we don't need 'em.\n   */\n  public async defaultAccount(): Promise<Account | undefined> {\n    return cached(this, CACHED_ACCOUNT, async () => {\n      try {\n        return await this._makeSdk(this.defaultCredentialProvider, this.defaultRegion).currentAccount();\n      } catch (e: any) {\n        // Treat 'ExpiredToken' specially. This is a common situation that people may find themselves in, and\n        // they are complaining about if we fail 'cdk synth' on them. We loudly complain in order to show that\n        // the current situation is probably undesirable, but we don't fail.\n        if (e.name === 'ExpiredToken') {\n          await this.ioHelper.notify(IO.DEFAULT_SDK_WARN.msg(\n            'There are expired AWS credentials in your environment. The CDK app will synth without current account information.',\n          ));\n          return undefined;\n        }\n\n        await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(`Unable to determine the default AWS account (${e.name}): ${formatErrorMessage(e)}`));\n        return undefined;\n      }\n    });\n  }\n\n  /**\n   * Get credentials for the given account ID in the given mode\n   *\n   * 1. Use the default credentials if the destination account matches the\n   *    current credentials' account.\n   * 2. Otherwise try all credential plugins.\n   * 3. Fail if neither of these yield any credentials.\n   * 4. Return a failure if any of them returned credentials\n   */\n  private async obtainBaseCredentials(accountId: string, mode: Mode): Promise<ObtainBaseCredentialsResult> {\n    // First try 'current' credentials\n    const defaultAccountId = (await this.defaultAccount())?.accountId;\n    if (defaultAccountId === accountId) {\n      return {\n        source: 'correctDefault',\n        credentials: await this.defaultCredentialProvider,\n      };\n    }\n\n    // Then try the plugins\n    const pluginCreds = await this.plugins.fetchCredentialsFor(accountId, mode);\n    if (pluginCreds) {\n      return { source: 'plugin', ...pluginCreds };\n    }\n\n    // Fall back to default credentials with a note that they're not the right ones yet\n    if (defaultAccountId !== undefined) {\n      return {\n        source: 'incorrectDefault',\n        accountId: defaultAccountId,\n        credentials: await this.defaultCredentialProvider,\n        unusedPlugins: this.plugins.availablePluginNames,\n      };\n    }\n\n    // Apparently we didn't find any at all\n    return {\n      source: 'none',\n      unusedPlugins: this.plugins.availablePluginNames,\n    };\n  }\n\n  /**\n   * Return an SDK which uses assumed role credentials\n   *\n   * The base credentials used to retrieve the assumed role credentials will be the\n   * same credentials returned by obtainCredentials if an environment and mode is passed,\n   * otherwise it will be the current credentials.\n   */\n  private async withAssumedRole(\n    mainCredentials: Exclude<ObtainBaseCredentialsResult, { source: 'none' }>,\n    roleArn: string,\n    externalId?: string,\n    additionalOptions?: AssumeRoleAdditionalOptions,\n    region?: string,\n  ): Promise<SDK> {\n    await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(`Assuming role '${roleArn}'.`));\n\n    region = region ?? this.defaultRegion;\n\n    const sourceDescription = fmtObtainedCredentials(mainCredentials);\n\n    try {\n      const credentials = await makeCachingProvider(fromTemporaryCredentials({\n        masterCredentials: mainCredentials.credentials,\n        params: {\n          RoleArn: roleArn,\n          ExternalId: externalId,\n          RoleSessionName: `aws-cdk-${safeUsername()}`,\n          ...additionalOptions,\n          TransitiveTagKeys: additionalOptions?.Tags ? additionalOptions.Tags.map((t) => t.Key!) : undefined,\n        },\n        clientConfig: {\n          region,\n          requestHandler: this.requestHandler,\n          customUserAgent: 'aws-cdk',\n          logger: this.logger,\n        },\n        logger: this.logger,\n      }));\n\n      // Call the provider at least once here, to catch an error if it occurs\n      await credentials();\n\n      return this._makeSdk(credentials, region);\n    } catch (err: any) {\n      if (err.name === 'ExpiredToken') {\n        throw err;\n      }\n\n      await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(`Assuming role failed: ${err.message}`));\n      throw new AuthenticationError(\n        [\n          'Could not assume role in target account',\n          ...(sourceDescription ? [`using ${sourceDescription}`] : []),\n          err.message,\n          \". Please make sure that this role exists in the account. If it doesn't exist, (re)-bootstrap the environment \" +\n            \"with the right '--trust', using the latest version of the CDK CLI.\",\n        ].join(' '),\n      );\n    }\n  }\n\n  /**\n   * Factory function that creates a new SDK instance\n   *\n   * This is a function here, instead of all the places where this is used creating a `new SDK`\n   * instance, so that it is trivial to mock from tests.\n   *\n   * Use like this:\n   *\n   * ```ts\n   * const mockSdk = jest.spyOn(SdkProvider.prototype, '_makeSdk').mockReturnValue(new MockSdk());\n   * // ...\n   * mockSdk.mockRestore();\n   * ```\n   *\n   * @internal\n   */\n  public _makeSdk(\n    credProvider: AwsCredentialIdentityProvider,\n    region: string,\n  ) {\n    return new SDK(credProvider, region, this.requestHandler, this.ioHelper, this.logger);\n  }\n}\n\n/**\n * An AWS account\n *\n * An AWS account always exists in only one partition. Usually we don't care about\n * the partition, but when we need to form ARNs we do.\n */\nexport interface Account {\n  /**\n   * The account number\n   */\n  readonly accountId: string;\n\n  /**\n   * The partition ('aws' or 'aws-cn' or otherwise)\n   */\n  readonly partition: string;\n}\n\n/**\n * Return the username with characters invalid for a RoleSessionName removed\n *\n * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters\n */\nfunction safeUsername() {\n  try {\n    return os.userInfo().username.replace(/[^\\w+=,.@-]/g, '@');\n  } catch {\n    return 'noname';\n  }\n}\n\n/**\n * Options for obtaining credentials for an environment\n */\nexport interface CredentialsOptions {\n  /**\n   * The ARN of the role that needs to be assumed, if any\n   */\n  readonly assumeRoleArn?: string;\n\n  /**\n   * External ID required to assume the given role.\n   */\n  readonly assumeRoleExternalId?: string;\n\n  /**\n   * Session tags required to assume the given role.\n   */\n  readonly assumeRoleAdditionalOptions?: AssumeRoleAdditionalOptions;\n}\n\n/**\n * Result of obtaining base credentials\n */\ntype ObtainBaseCredentialsResult =\n  | { source: 'correctDefault'; credentials: AwsCredentialIdentityProvider }\n  | { source: 'plugin'; pluginName: string; credentials: AwsCredentialIdentityProvider }\n  | {\n    source: 'incorrectDefault';\n    credentials: AwsCredentialIdentityProvider;\n    accountId: string;\n    unusedPlugins: string[];\n  }\n  | { source: 'none'; unusedPlugins: string[] };\n\n/**\n * Isolating the code that translates calculation errors into human error messages\n *\n * We cover the following cases:\n *\n * - No credentials are available at all\n * - Default credentials are for the wrong account\n */\nfunction fmtObtainCredentialsError(\n  targetAccountId: string,\n  obtainResult: ObtainBaseCredentialsResult & {\n    source: 'none' | 'incorrectDefault';\n  },\n): string {\n  const msg = [`Need to perform AWS calls for account ${targetAccountId}`];\n  switch (obtainResult.source) {\n    case 'incorrectDefault':\n      msg.push(`but the current credentials are for ${obtainResult.accountId}`);\n      break;\n    case 'none':\n      msg.push('but no credentials have been configured');\n  }\n  if (obtainResult.unusedPlugins.length > 0) {\n    msg.push(`and none of these plugins found any: ${obtainResult.unusedPlugins.join(', ')}`);\n  }\n  return msg.join(', ');\n}\n\n/**\n * Format a message indicating where we got base credentials for the assume role\n *\n * We cover the following cases:\n *\n * - Default credentials for the right account\n * - Default credentials for the wrong account\n * - Credentials returned from a plugin\n */\nfunction fmtObtainedCredentials(obtainResult: Exclude<ObtainBaseCredentialsResult, { source: 'none' }>): string {\n  switch (obtainResult.source) {\n    case 'correctDefault':\n      return 'current credentials';\n    case 'plugin':\n      return `credentials returned by plugin '${obtainResult.pluginName}'`;\n    case 'incorrectDefault':\n      const msg = [];\n      msg.push(`current credentials (which are for account ${obtainResult.accountId}`);\n\n      if (obtainResult.unusedPlugins.length > 0) {\n        msg.push(`, and none of the following plugins provided credentials: ${obtainResult.unusedPlugins.join(', ')}`);\n      }\n      msg.push(')');\n\n      return msg.join('');\n  }\n}\n\n/**\n * Instantiate an SDK for context providers. This function ensures that all\n * lookup assume role options are used when context providers perform lookups.\n */\nexport async function initContextProviderSdk(aws: SdkProvider, options: ContextLookupRoleOptions): Promise<SDK> {\n  const account = options.account;\n  const region = options.region;\n\n  const creds: CredentialsOptions = {\n    assumeRoleArn: options.lookupRoleArn,\n    assumeRoleExternalId: options.lookupRoleExternalId,\n    assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,\n  };\n\n  return (await aws.forEnvironment(EnvironmentUtils.make(account, region), Mode.ForReading, creds)).sdk;\n}\n\nexport interface SdkProviderServices {\n  /**\n   * An IO helper for emitting messages\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * The request handler settings\n   */\n  readonly requestHandler?: NodeHttpHandlerOptions;\n\n  /**\n   * A plugin host\n   */\n  readonly pluginHost?: PluginHost;\n\n  /**\n   * An SDK logger\n   */\n  readonly logger?: Logger;\n}\n"]}