aws-cdk
Version:
CDK Toolkit, the command line tool for CDK apps
417 lines • 57.8 kB
JavaScript
"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.defaultCliUserAgent = exports.SdkProvider = void 0;
const os = require("os");
const path = require("path");
const cxapi = require("@aws-cdk/cx-api");
const AWS = require("aws-sdk");
const fs = require("fs-extra");
const _env_1 = require("./_env");
const awscli_compatible_1 = require("./awscli-compatible");
const cached_1 = require("./cached");
const credential_plugins_1 = require("./credential-plugins");
const sdk_1 = require("./sdk");
const directories_1 = require("../../util/directories");
const tracing_1 = require("../../util/tracing");
// Some configuration that can only be achieved by setting
// environment variables.
process.env.AWS_STS_REGIONAL_ENDPOINTS = 'regional';
process.env.AWS_NODEJS_CONNECTION_REUSE_ENABLED = '1';
const CACHED_ACCOUNT = Symbol('cached_account');
const CACHED_DEFAULT_CREDENTIALS = Symbol('cached_default_credentials');
/**
* 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 = exports.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 = {}) {
const sdkOptions = parseHttpOptions(options.httpOptions ?? {});
const chain = await awscli_compatible_1.AwsCliCompatible.credentialChain({
profile: options.profile,
ec2instance: options.ec2creds,
containerCreds: options.containerCreds,
httpOptions: sdkOptions.httpOptions,
});
const region = await awscli_compatible_1.AwsCliCompatible.region({
profile: options.profile,
ec2instance: options.ec2creds,
});
return new SdkProvider_1(chain, region, sdkOptions);
}
constructor(defaultChain,
/**
* Default region
*/
defaultRegion, sdkOptions = {}) {
this.defaultChain = defaultChain;
this.defaultRegion = defaultRegion;
this.sdkOptions = sdkOptions;
this.plugins = new credential_plugins_1.CredentialPlugins();
}
/**
* 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 Error(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 Error(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 = new sdk_1.SDK(baseCreds.credentials, env.region, this.sdkOptions);
await sdk.validateCredentials();
return { sdk, didAssumeRole: false };
}
// We will proceed to AssumeRole using whatever we've been given.
const sdk = await this.withAssumedRole(baseCreds, options.assumeRoleArn, options.assumeRoleExternalId, env.region);
// Exercise the AssumeRoleCredentialsProvider we've gotten at least once so
// we can determine whether the AssumeRole call succeeds or not.
try {
await sdk.forceCredentialRetrieval();
return { sdk, didAssumeRole: true };
}
catch (e) {
if ((0, sdk_1.isUnrecoverableAwsError)(e)) {
throw e;
}
// 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') {
(0, _env_1.debug)(e.message);
const logger = quiet ? _env_1.debug : _env_1.warning;
logger(`${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`);
return { sdk: new sdk_1.SDK(baseCreds.credentials, env.region, this.sdkOptions), didAssumeRole: false };
}
throw e;
}
}
/**
* 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 new sdk_1.SDK(baseCreds.credentials, env.region, this.sdkOptions).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 !== cxapi.UNKNOWN_REGION ? env.region : this.defaultRegion;
const account = env.account !== cxapi.UNKNOWN_ACCOUNT ? env.account : (await this.defaultAccount())?.accountId;
if (!account) {
throw new Error('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: cxapi.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.
*/
defaultAccount() {
return (0, cached_1.cached)(this, CACHED_ACCOUNT, async () => {
try {
const creds = await this.defaultCredentials();
const accessKeyId = creds.accessKeyId;
if (!accessKeyId) {
throw new Error('Unable to resolve AWS credentials (setup with "aws configure")');
}
return await new sdk_1.SDK(creds, this.defaultRegion, this.sdkOptions).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.code === 'ExpiredToken') {
(0, _env_1.warning)('There are expired AWS credentials in your environment. The CDK app will synth without current account information.');
return undefined;
}
(0, _env_1.debug)(`Unable to determine the default AWS account (${e.code}): ${e.message}`);
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.defaultCredentials() };
}
// 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.defaultCredentials(),
unusedPlugins: this.plugins.availablePluginNames,
};
}
// Apparently we didn't find any at all
return {
source: 'none',
unusedPlugins: this.plugins.availablePluginNames,
};
}
/**
* Resolve the default chain to the first set of credentials that is available
*/
defaultCredentials() {
return (0, cached_1.cached)(this, CACHED_DEFAULT_CREDENTIALS, () => {
(0, _env_1.debug)('Resolving default credentials');
return this.defaultChain.resolvePromise();
});
}
/**
* 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(masterCredentials, roleArn, externalId, region) {
(0, _env_1.debug)(`Assuming role '${roleArn}'.`);
region = region ?? this.defaultRegion;
const creds = new AWS.ChainableTemporaryCredentials({
params: {
RoleArn: roleArn,
...externalId ? { ExternalId: externalId } : {},
RoleSessionName: `aws-cdk-${safeUsername()}`,
},
stsConfig: {
region,
...this.sdkOptions,
},
masterCredentials: masterCredentials.credentials,
});
return new sdk_1.SDK(creds, region, this.sdkOptions, {
assumeRoleCredentialsSourceDescription: fmtObtainedCredentials(masterCredentials),
});
}
};
exports.SdkProvider = SdkProvider = SdkProvider_1 = __decorate([
tracing_1.traceMethods
], SdkProvider);
const DEFAULT_CONNECTION_TIMEOUT = 10000;
const DEFAULT_TIMEOUT = 300000;
/**
* Get HTTP options for the SDK
*
* Read from user input or environment variables.
*
* Returns a complete `ConfigurationOptions` object because that's where
* `customUserAgent` lives, but `httpOptions` is the most important attribute.
*/
function parseHttpOptions(options) {
const config = {};
config.httpOptions = {};
config.httpOptions.connectTimeout = DEFAULT_CONNECTION_TIMEOUT;
config.httpOptions.timeout = DEFAULT_TIMEOUT;
let userAgent = options.userAgent;
if (userAgent == null) {
userAgent = defaultCliUserAgent();
}
config.customUserAgent = userAgent;
const caBundlePath = options.caBundlePath || caBundlePathFromEnvironment();
if (caBundlePath) {
(0, _env_1.debug)('Using CA bundle path: %s', caBundlePath);
config.httpOptions.ca = readIfPossible(caBundlePath);
}
if (options.proxyAddress) {
(0, _env_1.debug)('Proxy server from command-line arguments: %s', options.proxyAddress);
}
// Configure the proxy agent. By default, this will use HTTPS?_PROXY and
// NO_PROXY environment variables to determine which proxy to use for each
// request.
//
// eslint-disable-next-line @typescript-eslint/no-require-imports
const { ProxyAgent } = require('proxy-agent');
config.httpOptions.agent = new ProxyAgent(options.proxyAddress);
return config;
}
/**
* Find the package.json from the main toolkit.
*
* If we can't read it for some reason, try to do something reasonable anyway.
* Fall back to argv[1], or a standard string if that is undefined for some reason.
*/
function defaultCliUserAgent() {
const root = (0, directories_1.rootDir)(false);
const pkg = JSON.parse((root ? readIfPossible(path.join(root, 'package.json')) : undefined) ?? '{}');
const name = pkg.name ?? path.basename(process.argv[1] ?? 'cdk-cli');
const version = pkg.version ?? '<unknown>';
return `${name}/${version}`;
}
exports.defaultCliUserAgent = defaultCliUserAgent;
/**
* Find and return a CA certificate bundle path to be passed into the SDK.
*/
function caBundlePathFromEnvironment() {
if (process.env.aws_ca_bundle) {
return process.env.aws_ca_bundle;
}
if (process.env.AWS_CA_BUNDLE) {
return process.env.AWS_CA_BUNDLE;
}
return undefined;
}
/**
* Read a file if it exists, or return undefined
*
* Not async because it is used in the constructor
*/
function readIfPossible(filename) {
try {
if (!fs.pathExistsSync(filename)) {
return undefined;
}
return fs.readFileSync(filename, { encoding: 'utf-8' });
}
catch (e) {
(0, _env_1.debug)(e);
return undefined;
}
}
/**
* 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('');
}
}
//# 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 * as path from 'path';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as AWS from 'aws-sdk';\nimport type { ConfigurationOptions } from 'aws-sdk/lib/config-base';\nimport * as fs from 'fs-extra';\nimport { debug, warning } from './_env';\nimport { AwsCliCompatible } from './awscli-compatible';\nimport { cached } from './cached';\nimport { CredentialPlugins } from './credential-plugins';\nimport { Mode } from './credentials';\nimport { ISDK, SDK, isUnrecoverableAwsError } from './sdk';\nimport { rootDir } from '../../util/directories';\nimport { traceMethods } from '../../util/tracing';\n\n// Some configuration that can only be achieved by setting\n// environment variables.\nprocess.env.AWS_STS_REGIONAL_ENDPOINTS = 'regional';\nprocess.env.AWS_NODEJS_CONNECTION_REUSE_ENABLED = '1';\n\n/**\n * Options for the default SDK provider\n */\nexport interface SdkProviderOptions {\n  /**\n   * Profile to read from ~/.aws\n   *\n   * @default - No profile\n   */\n  readonly profile?: string;\n\n  /**\n   * Whether we should check for EC2 credentials\n   *\n   * @default - Autodetect\n   */\n  readonly ec2creds?: boolean;\n\n  /**\n   * Whether we should check for container credentials\n   *\n   * @default - Autodetect\n   */\n  readonly containerCreds?: boolean;\n\n  /**\n   * HTTP options for SDK\n   */\n  readonly httpOptions?: SdkHttpOptions;\n}\n\n/**\n * Options for individual SDKs\n */\nexport interface SdkHttpOptions {\n  /**\n   * Proxy address to use\n   *\n   * @default No proxy\n   */\n  readonly proxyAddress?: string;\n\n  /**\n   * A path to a certificate bundle that contains a cert to be trusted.\n   *\n   * @default No certificate bundle\n   */\n  readonly caBundlePath?: string;\n\n  /**\n   * The custom user agent to use.\n   *\n   * @default - <package-name>/<package-version>\n   */\n  readonly userAgent?: string;\n}\n\nconst CACHED_ACCOUNT = Symbol('cached_account');\nconst CACHED_DEFAULT_CREDENTIALS = Symbol('cached_default_credentials');\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: ISDK;\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@traceMethods\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    const sdkOptions = parseHttpOptions(options.httpOptions ?? {});\n\n    const chain = await AwsCliCompatible.credentialChain({\n      profile: options.profile,\n      ec2instance: options.ec2creds,\n      containerCreds: options.containerCreds,\n      httpOptions: sdkOptions.httpOptions,\n    });\n    const region = await AwsCliCompatible.region({\n      profile: options.profile,\n      ec2instance: options.ec2creds,\n    });\n\n    return new SdkProvider(chain, region, sdkOptions);\n  }\n\n  private readonly plugins = new CredentialPlugins();\n\n  public constructor(\n    private readonly defaultChain: AWS.CredentialProviderChain,\n    /**\n     * Default region\n     */\n    public readonly defaultRegion: string,\n    private readonly sdkOptions: ConfigurationOptions = {}) {\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: cxapi.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') { throw new Error(fmtObtainCredentialsError(env.account, baseCreds)); }\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') { throw new Error(fmtObtainCredentialsError(env.account, baseCreds)); }\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 = new SDK(baseCreds.credentials, env.region, this.sdkOptions);\n      await sdk.validateCredentials();\n      return { sdk, didAssumeRole: false };\n    }\n\n    // We will proceed to AssumeRole using whatever we've been given.\n    const sdk = await this.withAssumedRole(baseCreds, options.assumeRoleArn, options.assumeRoleExternalId, env.region);\n\n    // Exercise the AssumeRoleCredentialsProvider we've gotten at least once so\n    // we can determine whether the AssumeRole call succeeds or not.\n    try {\n      await sdk.forceCredentialRetrieval();\n      return { sdk, didAssumeRole: true };\n    } catch (e: any) {\n      if (isUnrecoverableAwsError(e)) {\n        throw e;\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        debug(e.message);\n        const logger = quiet ? debug : warning;\n        logger(`${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`);\n        return { sdk: new SDK(baseCreds.credentials, env.region, this.sdkOptions), didAssumeRole: false };\n      }\n\n      throw e;\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: cxapi.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') { return undefined; }\n    return (await new SDK(baseCreds.credentials, env.region, this.sdkOptions).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: cxapi.Environment): Promise<cxapi.Environment> {\n    const region = env.region !== cxapi.UNKNOWN_REGION ? env.region : this.defaultRegion;\n    const account = env.account !== cxapi.UNKNOWN_ACCOUNT ? env.account : (await this.defaultAccount())?.accountId;\n\n    if (!account) {\n      throw new Error('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    return {\n      region,\n      account,\n      name: cxapi.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 defaultAccount(): Promise<Account | undefined> {\n    return cached(this, CACHED_ACCOUNT, async () => {\n      try {\n        const creds = await this.defaultCredentials();\n\n        const accessKeyId = creds.accessKeyId;\n        if (!accessKeyId) {\n          throw new Error('Unable to resolve AWS credentials (setup with \"aws configure\")');\n        }\n\n        return await new SDK(creds, this.defaultRegion, this.sdkOptions).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.code === 'ExpiredToken') {\n          warning('There are expired AWS credentials in your environment. The CDK app will synth without current account information.');\n          return undefined;\n        }\n\n        debug(`Unable to determine the default AWS account (${e.code}): ${e.message}`);\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 { source: 'correctDefault', credentials: await this.defaultCredentials() };\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.defaultCredentials(),\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   * Resolve the default chain to the first set of credentials that is available\n   */\n  private defaultCredentials(): Promise<AWS.Credentials> {\n    return cached(this, CACHED_DEFAULT_CREDENTIALS, () => {\n      debug('Resolving default credentials');\n      return this.defaultChain.resolvePromise();\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    masterCredentials: Exclude<ObtainBaseCredentialsResult, { source: 'none' }>,\n    roleArn: string,\n    externalId: string | undefined,\n    region: string | undefined) {\n    debug(`Assuming role '${roleArn}'.`);\n\n    region = region ?? this.defaultRegion;\n\n    const creds = new AWS.ChainableTemporaryCredentials({\n      params: {\n        RoleArn: roleArn,\n        ...externalId ? { ExternalId: externalId } : {},\n        RoleSessionName: `aws-cdk-${safeUsername()}`,\n      },\n      stsConfig: {\n        region,\n        ...this.sdkOptions,\n      },\n      masterCredentials: masterCredentials.credentials,\n    });\n\n    return new SDK(creds, region, this.sdkOptions, {\n      assumeRoleCredentialsSourceDescription: fmtObtainedCredentials(masterCredentials),\n    });\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 {\