@aws-cdk/aws-kms/lib/key.js

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Key = exports.KeyUsage = exports.KeySpec = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const iam = require("@aws-cdk/aws-iam");
const cxschema = require("@aws-cdk/cloud-assembly-schema");
const core_1 = require("@aws-cdk/core");
const cxapi = require("@aws-cdk/cx-api");
const constructs_1 = require("constructs");
const alias_1 = require("./alias");
const kms_generated_1 = require("./kms.generated");
const perms = require("./private/perms");
class KeyBase extends core_1.Resource {
    constructor() {
        super(...arguments);
        /**
         * Collection of aliases added to the key
         *
         * Tracked to determine whether or not the aliasName should be added to the end of its ID
         */
        this.aliases = [];
    }
    /**
     * Defines a new alias for the key.
     */
    addAlias(aliasName) {
        const aliasId = this.aliases.length > 0 ? `Alias${aliasName}` : 'Alias';
        const alias = new alias_1.Alias(this, aliasId, { aliasName, targetKey: this });
        this.aliases.push(alias);
        return alias;
    }
    /**
     * Adds a statement to the KMS key resource policy.
     * @param statement The policy statement to add
     * @param allowNoOp If this is set to `false` and there is no policy
     * defined (i.e. external key), the operation will fail. Otherwise, it will
     * no-op.
     */
    addToResourcePolicy(statement, allowNoOp = true) {
        const stack = core_1.Stack.of(this);
        if (!this.policy) {
            if (allowNoOp) {
                return { statementAdded: false };
            }
            throw new Error(`Unable to add statement to IAM resource policy for KMS key: ${JSON.stringify(stack.resolve(this.keyArn))}`);
        }
        this.policy.addStatements(statement);
        return { statementAdded: true, policyDependable: this.policy };
    }
    validate() {
        const errors = super.validate();
        errors.push(...this.policy?.validateForResourcePolicy() || []);
        return errors;
    }
    /**
     * Grant the indicated permissions on this key to the given principal
     *
     * This modifies both the principal's policy as well as the resource policy,
     * since the default CloudFormation setup for KMS keys is that the policy
     * must not be empty and so default grants won't work.
     */
    grant(grantee, ...actions) {
        // KMS verifies whether the principals included in its key policy actually exist.
        // This is a problem if the stack the grantee is part of depends on the key stack
        // (as it won't exist before the key policy is attempted to be created).
        // In that case, make the account the resource policy principal
        const granteeStackDependsOnKeyStack = this.granteeStackDependsOnKeyStack(grantee);
        const principal = granteeStackDependsOnKeyStack
            ? new iam.AccountPrincipal(granteeStackDependsOnKeyStack)
            : grantee.grantPrincipal;
        const crossAccountAccess = this.isGranteeFromAnotherAccount(grantee);
        const crossRegionAccess = this.isGranteeFromAnotherRegion(grantee);
        const crossEnvironment = crossAccountAccess || crossRegionAccess;
        const grantOptions = {
            grantee,
            actions,
            resource: this,
            resourceArns: [this.keyArn],
            resourceSelfArns: crossEnvironment ? undefined : ['*'],
        };
        if (this.trustAccountIdentities && !crossEnvironment) {
            return iam.Grant.addToPrincipalOrResource(grantOptions);
        }
        else {
            return iam.Grant.addToPrincipalAndResource({
                ...grantOptions,
                // if the key is used in a cross-environment matter,
                // we can't access the Key ARN (they don't have physical names),
                // so fall back to using '*'. ToDo we need to make this better... somehow
                resourceArns: crossEnvironment ? ['*'] : [this.keyArn],
                resourcePolicyPrincipal: principal,
            });
        }
    }
    /**
     * Grant decryption permissions using this key to the given principal
     */
    grantDecrypt(grantee) {
        return this.grant(grantee, ...perms.DECRYPT_ACTIONS);
    }
    /**
     * Grant encryption permissions using this key to the given principal
     */
    grantEncrypt(grantee) {
        return this.grant(grantee, ...perms.ENCRYPT_ACTIONS);
    }
    /**
     * Grant encryption and decryption permissions using this key to the given principal
     */
    grantEncryptDecrypt(grantee) {
        return this.grant(grantee, ...[...perms.DECRYPT_ACTIONS, ...perms.ENCRYPT_ACTIONS]);
    }
    /**
     * Checks whether the grantee belongs to a stack that will be deployed
     * after the stack containing this key.
     *
     * @param grantee the grantee to give permissions to
     * @returns the account ID of the grantee stack if its stack does depend on this stack,
     *   undefined otherwise
     */
    granteeStackDependsOnKeyStack(grantee) {
        const grantPrincipal = grantee.grantPrincipal;
        if (!isConstruct(grantPrincipal)) {
            return undefined;
        }
        // this logic should only apply to newly created
        // (= not imported) resources
        if (!this.principalIsANewlyCreatedResource(grantPrincipal)) {
            return undefined;
        }
        // return undefined;
        const keyStack = core_1.Stack.of(this);
        const granteeStack = core_1.Stack.of(grantPrincipal);
        if (keyStack === granteeStack) {
            return undefined;
        }
        return granteeStack.dependencies.includes(keyStack)
            ? granteeStack.account
            : undefined;
    }
    principalIsANewlyCreatedResource(principal) {
        // yes, this sucks
        // this is just a temporary stopgap to stem the bleeding while we work on a proper fix
        return principal instanceof iam.Role ||
            principal instanceof iam.User ||
            principal instanceof iam.Group;
    }
    isGranteeFromAnotherRegion(grantee) {
        if (!isConstruct(grantee)) {
            return false;
        }
        const bucketStack = core_1.Stack.of(this);
        const identityStack = core_1.Stack.of(grantee);
        return bucketStack.region !== identityStack.region;
    }
    isGranteeFromAnotherAccount(grantee) {
        if (!isConstruct(grantee)) {
            return false;
        }
        const bucketStack = core_1.Stack.of(this);
        const identityStack = core_1.Stack.of(grantee);
        return bucketStack.account !== identityStack.account;
    }
}
/**
 * The key spec, represents the cryptographic configuration of keys.
 */
var KeySpec;
(function (KeySpec) {
    /**
     * The default key spec.
     *
     * Valid usage: ENCRYPT_DECRYPT
     */
    KeySpec["SYMMETRIC_DEFAULT"] = "SYMMETRIC_DEFAULT";
    /**
     * RSA with 2048 bits of key.
     *
     * Valid usage: ENCRYPT_DECRYPT and SIGN_VERIFY
     */
    KeySpec["RSA_2048"] = "RSA_2048";
    /**
     * RSA with 3072 bits of key.
     *
     * Valid usage: ENCRYPT_DECRYPT and SIGN_VERIFY
     */
    KeySpec["RSA_3072"] = "RSA_3072";
    /**
     * RSA with 4096 bits of key.
     *
     * Valid usage: ENCRYPT_DECRYPT and SIGN_VERIFY
     */
    KeySpec["RSA_4096"] = "RSA_4096";
    /**
     * NIST FIPS 186-4, Section 6.4, ECDSA signature using the curve specified by the key and
     * SHA-256 for the message digest.
     *
     * Valid usage: SIGN_VERIFY
     */
    KeySpec["ECC_NIST_P256"] = "ECC_NIST_P256";
    /**
     * NIST FIPS 186-4, Section 6.4, ECDSA signature using the curve specified by the key and
     * SHA-384 for the message digest.
     *
     * Valid usage: SIGN_VERIFY
     */
    KeySpec["ECC_NIST_P384"] = "ECC_NIST_P384";
    /**
     * NIST FIPS 186-4, Section 6.4, ECDSA signature using the curve specified by the key and
     * SHA-512 for the message digest.
     *
     * Valid usage: SIGN_VERIFY
     */
    KeySpec["ECC_NIST_P521"] = "ECC_NIST_P521";
    /**
     * Standards for Efficient Cryptography 2, Section 2.4.1, ECDSA signature on the Koblitz curve.
     *
     * Valid usage: SIGN_VERIFY
     */
    KeySpec["ECC_SECG_P256K1"] = "ECC_SECG_P256K1";
})(KeySpec = exports.KeySpec || (exports.KeySpec = {}));
/**
 * The key usage, represents the cryptographic operations of keys.
 */
var KeyUsage;
(function (KeyUsage) {
    /**
     * Encryption and decryption.
     */
    KeyUsage["ENCRYPT_DECRYPT"] = "ENCRYPT_DECRYPT";
    /**
     * Signing and verification
     */
    KeyUsage["SIGN_VERIFY"] = "SIGN_VERIFY";
})(KeyUsage = exports.KeyUsage || (exports.KeyUsage = {}));
/**
 * Defines a KMS key.
 *
 * @resource AWS::KMS::Key
 */
class Key extends KeyBase {
    constructor(scope, id, props = {}) {
        super(scope, id);
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_kms_KeyProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, Key);
            }
            throw error;
        }
        const denyLists = {
            [KeyUsage.ENCRYPT_DECRYPT]: [
                KeySpec.ECC_NIST_P256,
                KeySpec.ECC_NIST_P384,
                KeySpec.ECC_NIST_P521,
                KeySpec.ECC_SECG_P256K1,
            ],
            [KeyUsage.SIGN_VERIFY]: [
                KeySpec.SYMMETRIC_DEFAULT,
            ],
        };
        const keySpec = props.keySpec ?? KeySpec.SYMMETRIC_DEFAULT;
        const keyUsage = props.keyUsage ?? KeyUsage.ENCRYPT_DECRYPT;
        if (denyLists[keyUsage].includes(keySpec)) {
            throw new Error(`key spec '${keySpec}' is not valid with usage '${keyUsage}'`);
        }
        if (keySpec !== KeySpec.SYMMETRIC_DEFAULT && props.enableKeyRotation) {
            throw new Error('key rotation cannot be enabled on asymmetric keys');
        }
        const defaultKeyPoliciesFeatureEnabled = core_1.FeatureFlags.of(this).isEnabled(cxapi.KMS_DEFAULT_KEY_POLICIES);
        this.policy = props.policy ?? new iam.PolicyDocument();
        if (defaultKeyPoliciesFeatureEnabled) {
            if (props.trustAccountIdentities === false) {
                throw new Error('`trustAccountIdentities` cannot be false if the @aws-cdk/aws-kms:defaultKeyPolicies feature flag is set');
            }
            this.trustAccountIdentities = true;
            // Set the default key policy if one hasn't been provided by the user.
            if (!props.policy) {
                this.addDefaultAdminPolicy();
            }
        }
        else {
            this.trustAccountIdentities = props.trustAccountIdentities ?? false;
            if (this.trustAccountIdentities) {
                this.addDefaultAdminPolicy();
            }
            else {
                this.addLegacyAdminPolicy();
            }
        }
        let pendingWindowInDays;
        if (props.pendingWindow) {
            pendingWindowInDays = props.pendingWindow.toDays();
            if (pendingWindowInDays < 7 || pendingWindowInDays > 30) {
                throw new Error(`'pendingWindow' value must between 7 and 30 days. Received: ${pendingWindowInDays}`);
            }
        }
        const resource = new kms_generated_1.CfnKey(this, 'Resource', {
            description: props.description,
            enableKeyRotation: props.enableKeyRotation,
            enabled: props.enabled,
            keySpec: props.keySpec,
            keyUsage: props.keyUsage,
            keyPolicy: this.policy,
            pendingWindowInDays: pendingWindowInDays,
        });
        this.keyArn = resource.attrArn;
        this.keyId = resource.ref;
        resource.applyRemovalPolicy(props.removalPolicy);
        (props.admins ?? []).forEach((p) => this.grantAdmin(p));
        if (props.alias !== undefined) {
            this.addAlias(props.alias);
        }
    }
    /**
     * Import an externally defined KMS Key using its ARN.
     *
     * @param scope  the construct that will "own" the imported key.
     * @param id     the id of the imported key in the construct tree.
     * @param keyArn the ARN of an existing KMS key.
     */
    static fromKeyArn(scope, id, keyArn) {
        class Import extends KeyBase {
            constructor(keyId) {
                super(scope, id);
                this.keyArn = keyArn;
                this.policy = undefined;
                // defaulting true: if we are importing the key the key policy is
                // undefined and impossible to change here; this means updating identity
                // policies is really the only option
                this.trustAccountIdentities = true;
                this.keyId = keyId;
            }
        }
        const keyResourceName = core_1.Stack.of(scope).splitArn(keyArn, core_1.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
        if (!keyResourceName) {
            throw new Error(`KMS key ARN must be in the format 'arn:aws:kms:<region>:<account>:key/<keyId>', got: '${keyArn}'`);
        }
        return new Import(keyResourceName);
    }
    /**
     * Create a mutable {@link IKey} based on a low-level {@link CfnKey}.
     * This is most useful when combined with the cloudformation-include module.
     * This method is different than {@link fromKeyArn()} because the {@link IKey}
     * returned from this method is mutable;
     * meaning, calling any mutating methods on it,
     * like {@link IKey.addToResourcePolicy()},
     * will actually be reflected in the resulting template,
     * as opposed to the object returned from {@link fromKeyArn()},
     * on which calling those methods would have no effect.
     */
    static fromCfnKey(cfnKey) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_kms_CfnKey(cfnKey);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.fromCfnKey);
            }
            throw error;
        }
        // use a "weird" id that has a higher chance of being unique
        const id = '@FromCfnKey';
        // if fromCfnKey() was already called on this cfnKey,
        // return the same L2
        // (as different L2s would conflict, because of the mutation of the keyPolicy property of the L1 below)
        const existing = cfnKey.node.tryFindChild(id);
        if (existing) {
            return existing;
        }
        let keyPolicy;
        try {
            keyPolicy = iam.PolicyDocument.fromJson(cfnKey.keyPolicy);
        }
        catch (e) {
            // If the KeyPolicy contains any CloudFormation functions,
            // PolicyDocument.fromJson() throws an exception.
            // In that case, because we would have to effectively make the returned IKey immutable,
            // throw an exception suggesting to use the other importing methods instead.
            // We might make this parsing logic smarter later,
            // but let's start by erroring out.
            throw new Error('Could not parse the PolicyDocument of the passed AWS::KMS::Key resource because it contains CloudFormation functions. ' +
                'This makes it impossible to create a mutable IKey from that Policy. ' +
                'You have to use fromKeyArn instead, passing it the ARN attribute property of the low-level CfnKey');
        }
        // change the key policy of the L1, so that all changes done in the L2 are reflected in the resulting template
        cfnKey.keyPolicy = core_1.Lazy.any({ produce: () => keyPolicy.toJSON() });
        return new class extends KeyBase {
            constructor() {
                super(...arguments);
                this.keyArn = cfnKey.attrArn;
                this.keyId = cfnKey.ref;
                this.policy = keyPolicy;
                this.trustAccountIdentities = false;
            }
        }(cfnKey, id);
    }
    /**
     * Import an existing Key by querying the AWS environment this stack is deployed to.
     *
     * This function only needs to be used to use Keys not defined in your CDK
     * application. If you are looking to share a Key between stacks, you can
     * pass the `Key` object between stacks and use it as normal. In addition,
     * it's not necessary to use this method if an interface accepts an `IKey`.
     * In this case, `Alias.fromAliasName()` can be used which returns an alias
     * that extends `IKey`.
     *
     * Calling this method will lead to a lookup when the CDK CLI is executed.
     * You can therefore not use any values that will only be available at
     * CloudFormation execution time (i.e., Tokens).
     *
     * The Key information will be cached in `cdk.context.json` and the same Key
     * will be used on future runs. To refresh the lookup, you will have to
     * evict the value from the cache using the `cdk context` command. See
     * https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.
     */
    static fromLookup(scope, id, options) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_kms_KeyLookupOptions(options);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.fromLookup);
            }
            throw error;
        }
        class Import extends KeyBase {
            constructor(keyId, keyArn) {
                super(scope, id);
                this.policy = undefined;
                // defaulting true: if we are importing the key the key policy is
                // undefined and impossible to change here; this means updating identity
                // policies is really the only option
                this.trustAccountIdentities = true;
                this.keyId = keyId;
                this.keyArn = keyArn;
            }
        }
        if (core_1.Token.isUnresolved(options.aliasName)) {
            throw new Error('All arguments to Key.fromLookup() must be concrete (no Tokens)');
        }
        const attributes = core_1.ContextProvider.getValue(scope, {
            provider: cxschema.ContextProvider.KEY_PROVIDER,
            props: {
                aliasName: options.aliasName,
            },
            dummyValue: {
                keyId: '1234abcd-12ab-34cd-56ef-1234567890ab',
            },
        }).value;
        return new Import(attributes.keyId, core_1.Arn.format({ resource: 'key', service: 'kms', resourceName: attributes.keyId }, core_1.Stack.of(scope)));
    }
    /**
     * Grant admins permissions using this key to the given principal
     *
     * Key administrators have permissions to manage the key (e.g., change permissions, revoke), but do not have permissions
     * to use the key in cryptographic operations (e.g., encrypt, decrypt).
     */
    grantAdmin(grantee) {
        return this.grant(grantee, ...perms.ADMIN_ACTIONS);
    }
    /**
     * Adds the default key policy to the key. This policy gives the AWS account (root user) full access to the CMK,
     * which reduces the risk of the CMK becoming unmanageable and enables IAM policies to allow access to the CMK.
     * This is the same policy that is default when creating a Key via the KMS API or Console.
     * @see https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default
     */
    addDefaultAdminPolicy() {
        this.addToResourcePolicy(new iam.PolicyStatement({
            resources: ['*'],
            actions: ['kms:*'],
            principals: [new iam.AccountRootPrincipal()],
        }));
    }
    /**
     * Grants the account admin privileges -- not full account access -- plus the GenerateDataKey action.
     * The GenerateDataKey action was added for interop with S3 in https://github.com/aws/aws-cdk/issues/3458.
     *
     * This policy is discouraged and deprecated by the `@aws-cdk/aws-kms:defaultKeyPolicies` feature flag.
     *
     * @link https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default
     * @deprecated
     */
    addLegacyAdminPolicy() {
        // This is equivalent to `[...perms.ADMIN_ACTIONS, 'kms:GenerateDataKey']`,
        // but keeping this explicit ordering for backwards-compatibility (changing the ordering causes resource updates)
        const actions = [
            'kms:Create*',
            'kms:Describe*',
            'kms:Enable*',
            'kms:List*',
            'kms:Put*',
            'kms:Update*',
            'kms:Revoke*',
            'kms:Disable*',
            'kms:Get*',
            'kms:Delete*',
            'kms:ScheduleKeyDeletion',
            'kms:CancelKeyDeletion',
            'kms:GenerateDataKey',
            'kms:TagResource',
            'kms:UntagResource',
        ];
        this.addToResourcePolicy(new iam.PolicyStatement({
            resources: ['*'],
            actions,
            principals: [new iam.AccountRootPrincipal()],
        }));
    }
}
exports.Key = Key;
_a = JSII_RTTI_SYMBOL_1;
Key[_a] = { fqn: "@aws-cdk/aws-kms.Key", version: "1.191.0" };
/**
 * Whether the given object is a Construct
 *
 * Normally we'd do `x instanceof Construct`, but that is not robust against
 * multiple copies of the `constructs` library on disk. This can happen
 * when upgrading and downgrading between v2 and v1, and in the use of CDK
 * Pipelines is going to an error that says "Can't use Pipeline/Pipeline/Role in
 * a cross-environment fashion", which is very confusing.
 */
function isConstruct(x) {
    const sym = Symbol.for('constructs.Construct.node');
    return (typeof x === 'object' && x &&
        (x instanceof constructs_1.Construct // happy fast case
            || !!x.node // constructs v10
            || !!x[sym])); // constructs v3
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key.js","sourceRoot":"","sources":["key.ts"],"names":[],"mappings":"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","sourcesContent":["import * as iam from '@aws-cdk/aws-iam';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport { FeatureFlags, IResource, Lazy, RemovalPolicy, Resource, Stack, Duration, Token, ContextProvider, Arn, ArnFormat } from '@aws-cdk/core';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport { IConstruct, Construct } from 'constructs';\nimport { Alias } from './alias';\nimport { KeyLookupOptions } from './key-lookup';\nimport { CfnKey } from './kms.generated';\nimport * as perms from './private/perms';\n\n/**\n * A KMS Key, either managed by this CDK app, or imported.\n */\nexport interface IKey extends IResource {\n  /**\n   * The ARN of the key.\n   *\n   * @attribute\n   */\n  readonly keyArn: string;\n\n  /**\n   * The ID of the key\n   * (the part that looks something like: 1234abcd-12ab-34cd-56ef-1234567890ab).\n   *\n   * @attribute\n   */\n  readonly keyId: string;\n\n  /**\n   * Defines a new alias for the key.\n   */\n  addAlias(alias: string): Alias;\n\n  /**\n   * Adds a statement to the KMS key resource policy.\n   * @param statement The policy statement to add\n   * @param allowNoOp If this is set to `false` and there is no policy\n   * defined (i.e. external key), the operation will fail. Otherwise, it will\n   * no-op.\n   */\n  addToResourcePolicy(statement: iam.PolicyStatement, allowNoOp?: boolean): iam.AddToResourcePolicyResult;\n\n  /**\n   * Grant the indicated permissions on this key to the given principal\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Grant decryption permissions using this key to the given principal\n   */\n  grantDecrypt(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant encryption permissions using this key to the given principal\n   */\n  grantEncrypt(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant encryption and decryption permissions using this key to the given principal\n   */\n  grantEncryptDecrypt(grantee: iam.IGrantable): iam.Grant;\n}\n\nabstract class KeyBase extends Resource implements IKey {\n  /**\n   * The ARN of the key.\n   */\n  public abstract readonly keyArn: string;\n\n  public abstract readonly keyId: string;\n\n  /**\n   * Optional policy document that represents the resource policy of this key.\n   *\n   * If specified, addToResourcePolicy can be used to edit this policy.\n   * Otherwise this method will no-op.\n   */\n  protected abstract readonly policy?: iam.PolicyDocument;\n\n  /**\n   * Optional property to control trusting account identities.\n   *\n   * If specified, grants will default identity policies instead of to both\n   * resource and identity policies. This matches the default behavior when creating\n   * KMS keys via the API or console.\n   */\n  protected abstract readonly trustAccountIdentities: boolean;\n\n  /**\n   * Collection of aliases added to the key\n   *\n   * Tracked to determine whether or not the aliasName should be added to the end of its ID\n   */\n  private readonly aliases: Alias[] = [];\n\n  /**\n   * Defines a new alias for the key.\n   */\n  public addAlias(aliasName: string): Alias {\n    const aliasId = this.aliases.length > 0 ? `Alias${aliasName}` : 'Alias';\n\n    const alias = new Alias(this, aliasId, { aliasName, targetKey: this });\n    this.aliases.push(alias);\n\n    return alias;\n  }\n\n  /**\n   * Adds a statement to the KMS key resource policy.\n   * @param statement The policy statement to add\n   * @param allowNoOp If this is set to `false` and there is no policy\n   * defined (i.e. external key), the operation will fail. Otherwise, it will\n   * no-op.\n   */\n  public addToResourcePolicy(statement: iam.PolicyStatement, allowNoOp = true): iam.AddToResourcePolicyResult {\n    const stack = Stack.of(this);\n\n    if (!this.policy) {\n      if (allowNoOp) { return { statementAdded: false }; }\n      throw new Error(`Unable to add statement to IAM resource policy for KMS key: ${JSON.stringify(stack.resolve(this.keyArn))}`);\n    }\n\n    this.policy.addStatements(statement);\n    return { statementAdded: true, policyDependable: this.policy };\n  }\n\n  protected validate(): string[] {\n    const errors = super.validate();\n    errors.push(...this.policy?.validateForResourcePolicy() || []);\n    return errors;\n  }\n\n  /**\n   * Grant the indicated permissions on this key to the given principal\n   *\n   * This modifies both the principal's policy as well as the resource policy,\n   * since the default CloudFormation setup for KMS keys is that the policy\n   * must not be empty and so default grants won't work.\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    // KMS verifies whether the principals included in its key policy actually exist.\n    // This is a problem if the stack the grantee is part of depends on the key stack\n    // (as it won't exist before the key policy is attempted to be created).\n    // In that case, make the account the resource policy principal\n    const granteeStackDependsOnKeyStack = this.granteeStackDependsOnKeyStack(grantee);\n    const principal = granteeStackDependsOnKeyStack\n      ? new iam.AccountPrincipal(granteeStackDependsOnKeyStack)\n      : grantee.grantPrincipal;\n\n    const crossAccountAccess = this.isGranteeFromAnotherAccount(grantee);\n    const crossRegionAccess = this.isGranteeFromAnotherRegion(grantee);\n    const crossEnvironment = crossAccountAccess || crossRegionAccess;\n    const grantOptions: iam.GrantWithResourceOptions = {\n      grantee,\n      actions,\n      resource: this,\n      resourceArns: [this.keyArn],\n      resourceSelfArns: crossEnvironment ? undefined : ['*'],\n    };\n    if (this.trustAccountIdentities && !crossEnvironment) {\n      return iam.Grant.addToPrincipalOrResource(grantOptions);\n    } else {\n      return iam.Grant.addToPrincipalAndResource({\n        ...grantOptions,\n        // if the key is used in a cross-environment matter,\n        // we can't access the Key ARN (they don't have physical names),\n        // so fall back to using '*'. ToDo we need to make this better... somehow\n        resourceArns: crossEnvironment ? ['*'] : [this.keyArn],\n        resourcePolicyPrincipal: principal,\n      });\n    }\n  }\n\n  /**\n   * Grant decryption permissions using this key to the given principal\n   */\n  public grantDecrypt(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, ...perms.DECRYPT_ACTIONS);\n  }\n\n  /**\n   * Grant encryption permissions using this key to the given principal\n   */\n  public grantEncrypt(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, ...perms.ENCRYPT_ACTIONS);\n  }\n\n  /**\n   * Grant encryption and decryption permissions using this key to the given principal\n   */\n  public grantEncryptDecrypt(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, ...[...perms.DECRYPT_ACTIONS, ...perms.ENCRYPT_ACTIONS]);\n  }\n\n  /**\n   * Checks whether the grantee belongs to a stack that will be deployed\n   * after the stack containing this key.\n   *\n   * @param grantee the grantee to give permissions to\n   * @returns the account ID of the grantee stack if its stack does depend on this stack,\n   *   undefined otherwise\n   */\n  private granteeStackDependsOnKeyStack(grantee: iam.IGrantable): string | undefined {\n    const grantPrincipal = grantee.grantPrincipal;\n    if (!isConstruct(grantPrincipal)) {\n      return undefined;\n    }\n    // this logic should only apply to newly created\n    // (= not imported) resources\n    if (!this.principalIsANewlyCreatedResource(grantPrincipal)) {\n      return undefined;\n    }\n    // return undefined;\n    const keyStack = Stack.of(this);\n    const granteeStack = Stack.of(grantPrincipal);\n    if (keyStack === granteeStack) {\n      return undefined;\n    }\n    return granteeStack.dependencies.includes(keyStack)\n      ? granteeStack.account\n      : undefined;\n  }\n\n  private principalIsANewlyCreatedResource(principal: IConstruct): boolean {\n    // yes, this sucks\n    // this is just a temporary stopgap to stem the bleeding while we work on a proper fix\n    return principal instanceof iam.Role ||\n      principal instanceof iam.User ||\n      principal instanceof iam.Group;\n  }\n\n  private isGranteeFromAnotherRegion(grantee: iam.IGrantable): boolean {\n    if (!isConstruct(grantee)) {\n      return false;\n    }\n    const bucketStack = Stack.of(this);\n    const identityStack = Stack.of(grantee);\n    return bucketStack.region !== identityStack.region;\n  }\n\n  private isGranteeFromAnotherAccount(grantee: iam.IGrantable): boolean {\n    if (!isConstruct(grantee)) {\n      return false;\n    }\n    const bucketStack = Stack.of(this);\n    const identityStack = Stack.of(grantee);\n    return bucketStack.account !== identityStack.account;\n  }\n}\n\n/**\n * The key spec, represents the cryptographic configuration of keys.\n */\nexport enum KeySpec {\n  /**\n   * The default key spec.\n   *\n   * Valid usage: ENCRYPT_DECRYPT\n   */\n  SYMMETRIC_DEFAULT = 'SYMMETRIC_DEFAULT',\n\n  /**\n   * RSA with 2048 bits of key.\n   *\n   * Valid usage: ENCRYPT_DECRYPT and SIGN_VERIFY\n   */\n  RSA_2048 = 'RSA_2048',\n\n  /**\n   * RSA with 3072 bits of key.\n   *\n   * Valid usage: ENCRYPT_DECRYPT and SIGN_VERIFY\n   */\n  RSA_3072 = 'RSA_3072',\n\n  /**\n   * RSA with 4096 bits of key.\n   *\n   * Valid usage: ENCRYPT_DECRYPT and SIGN_VERIFY\n   */\n  RSA_4096 = 'RSA_4096',\n\n  /**\n   * NIST FIPS 186-4, Section 6.4, ECDSA signature using the curve specified by the key and\n   * SHA-256 for the message digest.\n   *\n   * Valid usage: SIGN_VERIFY\n   */\n  ECC_NIST_P256 = 'ECC_NIST_P256',\n\n  /**\n   * NIST FIPS 186-4, Section 6.4, ECDSA signature using the curve specified by the key and\n   * SHA-384 for the message digest.\n   *\n   * Valid usage: SIGN_VERIFY\n   */\n  ECC_NIST_P384 = 'ECC_NIST_P384',\n\n  /**\n   * NIST FIPS 186-4, Section 6.4, ECDSA signature using the curve specified by the key and\n   * SHA-512 for the message digest.\n   *\n   * Valid usage: SIGN_VERIFY\n   */\n  ECC_NIST_P521 = 'ECC_NIST_P521',\n\n  /**\n   * Standards for Efficient Cryptography 2, Section 2.4.1, ECDSA signature on the Koblitz curve.\n   *\n   * Valid usage: SIGN_VERIFY\n   */\n  ECC_SECG_P256K1 = 'ECC_SECG_P256K1',\n}\n\n/**\n * The key usage, represents the cryptographic operations of keys.\n */\nexport enum KeyUsage {\n  /**\n   * Encryption and decryption.\n   */\n  ENCRYPT_DECRYPT = 'ENCRYPT_DECRYPT',\n\n  /**\n   * Signing and verification\n   */\n  SIGN_VERIFY = 'SIGN_VERIFY',\n}\n\n/**\n * Construction properties for a KMS Key object\n */\nexport interface KeyProps {\n  /**\n   * A description of the key. Use a description that helps your users decide\n   * whether the key is appropriate for a particular task.\n   *\n   * @default - No description.\n   */\n  readonly description?: string;\n\n  /**\n   * Initial alias to add to the key\n   *\n   * More aliases can be added later by calling `addAlias`.\n   *\n   * @default - No alias is added for the key.\n   */\n  readonly alias?: string;\n\n  /**\n   * Indicates whether AWS KMS rotates the key.\n   *\n   * @default false\n   */\n  readonly enableKeyRotation?: boolean;\n\n  /**\n   * Indicates whether the key is available for use.\n   *\n   * @default - Key is enabled.\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * The cryptographic configuration of the key. The valid value depends on usage of the key.\n   *\n   * IMPORTANT: If you change this property of an existing key, the existing key is scheduled for deletion\n   * and a new key is created with the specified value.\n   *\n   * @default KeySpec.SYMMETRIC_DEFAULT\n   */\n  readonly keySpec?: KeySpec;\n\n  /**\n   * The cryptographic operations for which the key can be used.\n   *\n   * IMPORTANT: If you change this property of an existing key, the existing key is scheduled for deletion\n   * and a new key is created with the specified value.\n   *\n   * @default KeyUsage.ENCRYPT_DECRYPT\n   */\n  readonly keyUsage?: KeyUsage;\n\n  /**\n   * Custom policy document to attach to the KMS key.\n   *\n   * NOTE - If the `@aws-cdk/aws-kms:defaultKeyPolicies` feature flag is set (the default for new projects),\n   * this policy will *override* the default key policy and become the only key policy for the key. If the\n   * feature flag is not set, this policy will be appended to the default key policy.\n   *\n   * @default - A policy document with permissions for the account root to\n   * administer the key will be created.\n   */\n  readonly policy?: iam.PolicyDocument;\n\n  /**\n   * A list of principals to add as key administrators to the key policy.\n   *\n   * Key administrators have permissions to manage the key (e.g., change permissions, revoke), but do not have permissions\n   * to use the key in cryptographic operations (e.g., encrypt, decrypt).\n   *\n   * These principals will be added to the default key policy (if none specified), or to the specified policy (if provided).\n   *\n   * @default []\n   */\n  readonly admins?: iam.IPrincipal[];\n\n  /**\n   * Whether the encryption key should be retained when it is removed from the Stack. This is useful when one wants to\n   * retain access to data that was encrypted with a key that is being retired.\n   *\n   * @default RemovalPolicy.Retain\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * Whether the key usage can be granted by IAM policies\n   *\n   * Setting this to true adds a default statement which delegates key\n   * access control completely to the identity's IAM policy (similar\n   * to how it works for other AWS resources). This matches the default behavior\n   * when creating KMS keys via the API or console.\n   *\n   * If the `@aws-cdk/aws-kms:defaultKeyPolicies` feature flag is set (the default for new projects),\n   * this flag will always be treated as 'true' and does not need to be explicitly set.\n   *\n   * @default - false, unless the `@aws-cdk/aws-kms:defaultKeyPolicies` feature flag is set.\n   * @see https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default-allow-root-enable-iam\n   * @deprecated redundant with the `@aws-cdk/aws-kms:defaultKeyPolicies` feature flag\n   */\n  readonly trustAccountIdentities?: boolean;\n\n  /**\n   * Specifies the number of days in the waiting period before\n   * AWS KMS deletes a CMK that has been removed from a CloudFormation stack.\n   *\n   * When you remove a customer master key (CMK) from a CloudFormation stack, AWS KMS schedules the CMK for deletion\n   * and starts the mandatory waiting period. The PendingWindowInDays property determines the length of waiting period.\n   * During the waiting period, the key state of CMK is Pending Deletion, which prevents the CMK from being used in\n   * cryptographic operations. When the waiting period expires, AWS KMS permanently deletes the CMK.\n   *\n   * Enter a value between 7 and 30 days.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kms-key.html#cfn-kms-key-pendingwindowindays\n   * @default - 30 days\n   */\n  readonly pendingWindow?: Duration;\n}\n\n/**\n * Defines a KMS key.\n *\n * @resource AWS::KMS::Key\n */\nexport class Key extends KeyBase {\n  /**\n   * Import an externally defined KMS Key using its ARN.\n   *\n   * @param scope  the construct that will \"own\" the imported key.\n   * @param id     the id of the imported key in the construct tree.\n   * @param keyArn the ARN of an existing KMS key.\n   */\n  public static fromKeyArn(scope: Construct, id: string, keyArn: string): IKey {\n    class Import extends KeyBase {\n      public readonly keyArn = keyArn;\n      public readonly keyId: string;\n      protected readonly policy?: iam.PolicyDocument | undefined = undefined;\n      // defaulting true: if we are importing the key the key policy is\n      // undefined and impossible to change here; this means updating identity\n      // policies is really the only option\n      protected readonly trustAccountIdentities: boolean = true;\n\n      constructor(keyId: string) {\n        super(scope, id);\n\n        this.keyId = keyId;\n      }\n    }\n\n    const keyResourceName = Stack.of(scope).splitArn(keyArn, ArnFormat.SLASH_RESOURCE_NAME).resourceName;\n    if (!keyResourceName) {\n      throw new Error(`KMS key ARN must be in the format 'arn:aws:kms:<region>:<account>:key/<keyId>', got: '${keyArn}'`);\n    }\n\n    return new Import(keyResourceName);\n  }\n\n  /**\n   * Create a mutable {@link IKey} based on a low-level {@link CfnKey}.\n   * This is most useful when combined with the cloudformation-include module.\n   * This method is different than {@link fromKeyArn()} because the {@link IKey}\n   * returned from this method is mutable;\n   * meaning, calling any mutating methods on it,\n   * like {@link IKey.addToResourcePolicy()},\n   * will actually be reflected in the resulting template,\n   * as opposed to the object returned from {@link fromKeyArn()},\n   * on which calling those methods would have no effect.\n   */\n  public static fromCfnKey(cfnKey: CfnKey): IKey {\n    // use a \"weird\" id that has a higher chance of being unique\n    const id = '@FromCfnKey';\n\n    // if fromCfnKey() was already called on this cfnKey,\n    // return the same L2\n    // (as different L2s would conflict, because of the mutation of the keyPolicy property of the L1 below)\n    const existing = cfnKey.node.tryFindChild(id);\n    if (existing) {\n      return <IKey>existing;\n    }\n\n    let keyPolicy: iam.PolicyDocument;\n    try {\n      keyPolicy = iam.PolicyDocument.fromJson(cfnKey.keyPolicy);\n    } catch (e) {\n      // If the KeyPolicy contains any CloudFormation functions,\n      // PolicyDocument.fromJson() throws an exception.\n      // In that case, because we would have to effectively make the returned IKey immutable,\n      // throw an exception suggesting to use the other importing methods instead.\n      // We might make this parsing logic smarter later,\n      // but let's start by erroring out.\n      throw new Error('Could not parse the PolicyDocument of the passed AWS::KMS::Key resource because it contains CloudFormation functions. ' +\n        'This makes it impossible to create a mutable IKey from that Policy. ' +\n        'You have to use fromKeyArn instead, passing it the ARN attribute property of the low-level CfnKey');\n    }\n\n    // change the key policy of the L1, so that all changes done in the L2 are reflected in the resulting template\n    cfnKey.keyPolicy = Lazy.any({ produce: () => keyPolicy.toJSON() });\n\n    return new class extends KeyBase {\n      public readonly keyArn = cfnKey.attrArn;\n      public readonly keyId = cfnKey.ref;\n      protected readonly policy = keyPolicy;\n      protected readonly trustAccountIdentities = false;\n    }(cfnKey, id);\n  }\n\n  /**\n   * Import an existing Key by querying the AWS environment this stack is deployed to.\n   *\n   * This function only needs to be used to use Keys not defined in your CDK\n   * application. If you are looking to share a Key between stacks, you can\n   * pass the `Key` object between stacks and use it as normal. In addition,\n   * it's not necessary to use this method if an interface accepts an `IKey`.\n   * In this case, `Alias.fromAliasName()` can be used which returns an alias\n   * that extends `IKey`.\n   *\n   * Calling this method will lead to a lookup when the CDK CLI is executed.\n   * You can therefore not use any values that will only be available at\n   * CloudFormation execution time (i.e., Tokens).\n   *\n   * The Key information will be cached in `cdk.context.json` and the same Key\n   * will be used on future runs. To refresh the lookup, you will have to\n   * evict the value from the cache using the `cdk context` command. See\n   * https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.\n   */\n  public static fromLookup(scope: Construct, id: string, options: KeyLookupOptions): IKey {\n    class Import extends KeyBase {\n      public readonly keyArn: string;\n      public readonly keyId: string;\n      protected readonly policy?: iam.PolicyDocument | undefined = undefined;\n      // defaulting true: if we are importing the key the key policy is\n      // undefined and impossible to change here; this means updating identity\n      // policies is really the only option\n      protected readonly trustAccountIdentities: boolean = true;\n\n      constructor(keyId: string, keyArn: string) {\n        super(scope, id);\n\n        this.keyId = keyId;\n        this.keyArn = keyArn;\n      }\n    }\n    if (Token.isUnresolved(options.aliasName)) {\n      throw new Error('All arguments to Key.fromLookup() must be concrete (no Tokens)');\n    }\n\n    const attributes: cxapi.KeyContextResponse = ContextProvider.getValue(scope, {\n      provider: cxschema.ContextProvider.KEY_PROVIDER,\n      props: {\n        aliasName: options.aliasName,\n      } as cxschema.KeyContextQuery,\n      dummyValue: {\n        keyId: '1234abcd-12ab-34cd-56ef-1234567890ab',\n      },\n    }).value;\n\n    return new Import(attributes.keyId,\n      Arn.format({ resource: 'key', service: 'kms', resourceName: attributes.keyId }, Stack.of(scope)));\n  }\n\n  public readonly keyArn: string;\n  public readonly keyId: string;\n  protected readonly policy?: iam.PolicyDocument;\n  protected readonly trustAccountIdentities: boolean;\n\n  constructor(scope: Construct, id: string, props: KeyProps = {}) {\n    super(scope, id);\n\n    const denyLists = {\n      [KeyUsage.ENCRYPT_DECRYPT]: [\n        KeySpec.ECC_NIST_P256,\n        KeySpec.ECC_NIST_P384,\n        KeySpec.ECC_NIST_P521,\n        KeySpec.ECC_SECG_P256K1,\n      ],\n      [KeyUsage.SIGN_VERIFY]: [\n        KeySpec.SYMMETRIC_DEFAULT,\n      ],\n    };\n    const keySpec = props.keySpec ?? KeySpec.SYMMETRIC_DEFAULT;\n    const keyUsage = props.keyUsage ?? KeyUsage.ENCRYPT_DECRYPT;\n    if (denyLists[keyUsage].includes(keySpec)) {\n      throw new Error(`key spec '${keySpec}' is not valid with usage '${keyUsage}'`);\n    }\n\n    if (keySpec !== KeySpec.SYMMETRIC_DEFAULT && props.enableKeyRotation) {\n      throw new Error('key rotation cannot be enabled on asymmetric keys');\n    }\n\n    const defaultKeyPoliciesFeatureEnabled = FeatureFlags.of(this).isEnabled(cxapi.KMS_DEFAULT_KEY_POLICIES);\n\n    this.policy = props.policy ?? new iam.PolicyDocument();\n    if (defaultKeyPoliciesFeatureEnabled) {\n      if (props.trustAccountIdentities === false) {\n        throw new Error('`trustAccountIdentities` cannot be false if the @aws-cdk/aws-kms:defaultKeyPolicies feature flag is set');\n      }\n\n      this.trustAccountIdentities = true;\n      // Set the default key policy if one hasn't been provided by the user.\n      if (!props.policy) {\n        this.addDefaultAdminPolicy();\n      }\n    } else {\n      this.trustAccountIdentities = props.trustAccountIdentities ?? false;\n      if (this.trustAccountIdentities) {\n        this.addDefaultAdminPolicy();\n      } else {\n        this.addLegacyAdminPolicy();\n      }\n    }\n\n    let pendingWindowInDays;\n    if (props.pendingWindow) {\n      pendingWindowInDays = props.pendingWindow.toDays();\n      if (pendingWindowInDays < 7 || pendingWindowInDays > 30) {\n        throw new Error(`'pendingWindow' value must between 7 and 30 days. Received: ${pendingWindowInDays}`);\n      }\n    }\n\n    const resource = new CfnKey(this, 'Resource', {\n      description: props.description,\n      enableKeyRotation: props.enableKeyRotation,\n      enabled: props.enabled,\n      keySpec: props.keySpec,\n      keyUsage: props.keyUsage,\n      keyPolicy: this.policy,\n      pendingWindowInDays: pendingWindowInDays,\n    });\n\n    this.keyArn = resource.attrArn;\n    this.keyId = resource.ref;\n    resource.applyRemovalPolicy(props.removalPolicy);\n\n    (props.admins ?? []).forEach((p) => this.grantAdmin(p));\n\n    if (props.alias !== undefined) {\n      this.addAlias(props.alias);\n    }\n  }\n\n  /**\n   * Grant admins permissions using this key to the given principal\n   *\n   * Key administrators have permissions to manage the key (e.g., change permissions, revoke), but do not have permissions\n   * to use the key in cryptographic operations (e.g., encrypt, decrypt).\n   */\n  public grantAdmin(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, ...perms.ADMIN_ACTIONS);\n  }\n\n  /**\n   * Adds the default key policy to the key. This policy gives the AWS account (root user) full access to the CMK,\n   * which reduces the risk of the CMK becoming unmanageable and enables IAM policies to allow access to the CMK.\n   * This is the same policy that is default when creating a Key via the KMS API or Console.\n   * @see https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default\n   */\n  private addDefaultAdminPolicy() {\n    this.addToResourcePolicy(new iam.PolicyStatement({\n      resources: ['*'],\n      actions: ['kms:*'],\n      principals: [new iam.AccountRootPrincipal()],\n    }));\n  }\n\n  /**\n   * Grants the account admin privileges -- not full account access -- plus the GenerateDataKey action.\n   * The GenerateDataKey action was added for interop with S3 in https://github.com/aws/aws-cdk/issues/3458.\n   *\n   * This policy is discouraged and deprecated by the `@aws-cdk/aws-kms:defaultKeyPolicies` feature flag.\n   *\n   * @link https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default\n   * @deprecated\n   */\n  private addLegacyAdminPolicy() {\n    // This is equivalent to `[...perms.ADMIN_ACTIONS, 'kms:GenerateDataKey']`,\n    // but keeping this explicit ordering for backwards-compatibility (changing the ordering causes resource updates)\n    const actions = [\n      'kms:Create*',\n      'kms:Describe*',\n      'kms:Enable*',\n      'kms:List*',\n      'kms:Put*',\n      'kms:Update*',\n      'kms:Revoke*',\n      'kms:Disable*',\n      'kms:Get*',\n      'kms:Delete*',\n      'kms:ScheduleKeyDeletion',\n      'kms:CancelKeyDeletion',\n      'kms:GenerateDataKey',\n      'kms:TagResource',\n      'kms:UntagResource',\n    ];\n\n    this.addToResourcePolicy(new iam.PolicyStatement({\n      resources: ['*'],\n      actions,\n      principals: [new iam.AccountRootPrincipal()],\n    }));\n  }\n}\n\n/**\n * Whether the given object is a Construct\n *\n * Normally we'd do `x instanceof Construct`, but that is not robust against\n * multiple copies of the `constructs` library on disk. This can happen\n * when upgrading and downgrading between v2 and v1, and in the use of CDK\n * Pipelines is going to an error that says \"Can't use Pipeline/Pipeline/Role in\n * a cross-environment fashion\", which is very confusing.\n */\nfunction isConstruct(x: any): x is Construct {\n  const sym = Symbol.for('constructs.Construct.node');\n  return (typeof x === 'object' && x &&\n    (x instanceof Construct // happy fast case\n    || !!(x as any).node // constructs v10\n    || !!(x as any)[sym])); // constructs v3\n}"]}