terraconstructs 0.0.8

package/lib/aws/encryption/key.js

@@ -0,0 +1,586 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Key = exports.KeyUsage = exports.KeySpec = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/2.170.0/packages/aws-cdk-lib/aws-kms/lib/key.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const alias_1 = require("./alias");
+const iam = require("../iam");
+const perms = require("./private/perms");
+class KeyBase extends aws_construct_1.AwsConstructBase {
+    get keyOutputs() {
+        return {
+            keyArn: this.keyArn,
+            keyId: this.keyId,
+        };
+    }
+    get outputs() {
+        return this.keyOutputs;
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        /**
+         * 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 = [];
+        this.node.addValidation({
+            validate: () => this.policy?.validateForResourcePolicy() ?? [],
+        });
+    }
+    /**
+     * 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 = aws_stack_1.AwsStack.ofAwsConstruct(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 };
+    }
+    /**
+     * 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]);
+    }
+    /**
+     * Grant permissions to generating MACs to the given principal
+     */
+    grantGenerateMac(grantee) {
+        return this.grant(grantee, ...perms.GENERATE_HMAC_ACTIONS);
+    }
+    /**
+     * Grant permissions to verifying MACs to the given principal
+     */
+    grantVerifyMac(grantee) {
+        return this.grant(grantee, ...perms.VERIFY_HMAC_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;
+        // this logic should only apply to newly created
+        // (= not imported) resources
+        if (!iam.principalIsOwnedResource(grantPrincipal)) {
+            return undefined;
+        }
+        const keyStack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        const granteeStack = aws_stack_1.AwsStack.ofAwsConstruct(grantPrincipal);
+        if (keyStack === granteeStack) {
+            return undefined;
+        }
+        // TODO: Find test case without cross stack reference cyclic dependencies...
+        return granteeStack.dependencies.includes(keyStack)
+            ? granteeStack.account
+            : undefined;
+    }
+    isGranteeFromAnotherRegion(grantee) {
+        if (!iam.principalIsOwnedResource(grantee.grantPrincipal)) {
+            return false;
+        }
+        const keyStack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        const identityStack = aws_stack_1.AwsStack.ofAwsConstruct(grantee.grantPrincipal);
+        // if two compared stacks have the same region, this should return 'false' since it's from the
+        // same region; if two stacks have different region, then compare env.region
+        return (keyStack.region !== identityStack.region &&
+            this.env.region !== identityStack.region);
+    }
+    isGranteeFromAnotherAccount(grantee) {
+        if (!iam.principalIsOwnedResource(grantee.grantPrincipal)) {
+            return false;
+        }
+        const keyStack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        const identityStack = aws_stack_1.AwsStack.ofAwsConstruct(grantee.grantPrincipal);
+        // if two compared stacks have the same account, this should return 'false' since it's from the
+        // same account; if two stacks have different account, then compare env.account
+        return (keyStack.account !== identityStack.account &&
+            this.env.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";
+    /**
+     * Hash-Based Message Authentication Code as defined in RFC 2104 using the message digest function SHA224.
+     *
+     * Valid usage: GENERATE_VERIFY_MAC
+     */
+    KeySpec["HMAC_224"] = "HMAC_224";
+    /**
+     * Hash-Based Message Authentication Code as defined in RFC 2104 using the message digest function SHA256.
+     *
+     * Valid usage: GENERATE_VERIFY_MAC
+     */
+    KeySpec["HMAC_256"] = "HMAC_256";
+    /**
+     * Hash-Based Message Authentication Code as defined in RFC 2104 using the message digest function SHA384.
+     *
+     * Valid usage: GENERATE_VERIFY_MAC
+     */
+    KeySpec["HMAC_384"] = "HMAC_384";
+    /**
+     * Hash-Based Message Authentication Code as defined in RFC 2104 using the message digest function SHA512.
+     *
+     * Valid usage: GENERATE_VERIFY_MAC
+     */
+    KeySpec["HMAC_512"] = "HMAC_512";
+    /**
+     * Elliptic curve key spec available only in China Regions.
+     *
+     * Valid usage: ENCRYPT_DECRYPT and SIGN_VERIFY
+     */
+    KeySpec["SM2"] = "SM2";
+})(KeySpec || (exports.KeySpec = 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";
+    /**
+     * Generating and verifying MACs
+     */
+    KeyUsage["GENERATE_VERIFY_MAC"] = "GENERATE_VERIFY_MAC";
+    /**
+     * Deriving shared secrets
+     */
+    KeyUsage["KEY_AGREEMENT"] = "KEY_AGREEMENT";
+})(KeyUsage || (exports.KeyUsage = KeyUsage = {}));
+/**
+ * Defines a KMS key.
+ *
+ * @resource aws_kms_key
+ */
+class Key extends KeyBase {
+    /**
+     * 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, props = {}) {
+                super(scope, id, props);
+                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 = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(keyArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+        if (!keyResourceName) {
+            throw new Error(`KMS key ARN must be in the format 'arn:<partition>:kms:<region>:<account>:key/<keyId>', got: '${keyArn}'`);
+        }
+        return new Import(keyResourceName, {
+            environmentFromArn: keyArn,
+        });
+    }
+    /**
+     * Create a mutable `IKey` based on a low-level `KmsKey`.
+     * This method is different than `fromKeyArn()` because the `IKey`
+     * returned from this method is mutable;
+     * meaning, calling any mutating methods on it,
+     * like `IKey.addToResourcePolicy()`,
+     * will actually be reflected in the resulting template,
+     * as opposed to the object returned from `fromKeyArn()`,
+     * on which calling those methods would have no effect.
+     */
+    static fromTfKey(tfKey) {
+        // use a "weird" id that has a higher chance of being unique
+        const id = "@FromTfKey";
+        // if fromTfKey() was already called on this tfKey,
+        // return the same L2
+        // (as different L2s would conflict, because of the mutation of the keyPolicy property of the L1 below)
+        const existing = tfKey.node.tryFindChild(id);
+        if (existing) {
+            return existing;
+        }
+        let keyPolicy;
+        if (cdktf_1.Token.isUnresolved(tfKey.policyInput)) {
+            // find first PolicyDocument in the scope who's json token points to the key policy
+            keyPolicy = aws_stack_1.AwsStack.of(tfKey)
+                .node.findAll()
+                .filter((c) => c instanceof iam.PolicyDocument && c.json === tfKey.policyInput)[0];
+            if (!keyPolicy) {
+                throw new Error("Could not resolve the passed aws_kms_key policy attribute to a PolicyDocument resource json attribute. " +
+                    "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");
+            }
+        }
+        else {
+            try {
+                const policyInputObj = JSON.parse(tfKey.policyInput ?? "");
+                // create new PolicyDocument from the json string
+                keyPolicy = iam.PolicyDocument.fromJson(tfKey, "Policy", policyInputObj);
+            }
+            catch {
+                // If 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. " +
+                    "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");
+            }
+        }
+        // re-ensure key policy points to the nested L2 PolicyDocument
+        tfKey.policy = keyPolicy.json;
+        return new (class extends KeyBase {
+            constructor() {
+                super(...arguments);
+                this.keyArn = tfKey.arn;
+                this.keyId = tfKey.id;
+                this.policy = keyPolicy;
+                this.trustAccountIdentities = false;
+            }
+        })(tfKey, 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 CDKTF
+     * 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 CLI is executed.
+     * You can therefore not use any values that will only be available at
+     * Terraform execution time (i.e., Tokens).
+     */
+    static fromLookup(scope, id, options) {
+        class Import extends KeyBase {
+            constructor(keyId) {
+                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.dataSource = new provider_aws_1.dataAwsKmsKey.DataAwsKmsKey(this, "Resource", {
+                    keyId,
+                });
+                this.keyId = keyId;
+                this.keyArn = this.dataSource.arn;
+            }
+        }
+        if (cdktf_1.Token.isUnresolved(options.aliasName)) {
+            throw new Error("All arguments to Key.fromLookup() must be concrete (no Tokens)");
+        }
+        return new Import(options.aliasName);
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        const denyLists = {
+            [KeyUsage.ENCRYPT_DECRYPT]: [
+                KeySpec.ECC_NIST_P256,
+                KeySpec.ECC_NIST_P384,
+                KeySpec.ECC_NIST_P521,
+                KeySpec.ECC_SECG_P256K1,
+                KeySpec.HMAC_224,
+                KeySpec.HMAC_256,
+                KeySpec.HMAC_384,
+                KeySpec.HMAC_512,
+            ],
+            [KeyUsage.SIGN_VERIFY]: [
+                KeySpec.SYMMETRIC_DEFAULT,
+                KeySpec.HMAC_224,
+                KeySpec.HMAC_256,
+                KeySpec.HMAC_384,
+                KeySpec.HMAC_512,
+            ],
+            [KeyUsage.GENERATE_VERIFY_MAC]: [
+                KeySpec.RSA_2048,
+                KeySpec.RSA_3072,
+                KeySpec.RSA_4096,
+                KeySpec.ECC_NIST_P256,
+                KeySpec.ECC_NIST_P384,
+                KeySpec.ECC_NIST_P521,
+                KeySpec.ECC_SECG_P256K1,
+                KeySpec.SYMMETRIC_DEFAULT,
+                KeySpec.SM2,
+            ],
+            [KeyUsage.KEY_AGREEMENT]: [
+                KeySpec.SYMMETRIC_DEFAULT,
+                KeySpec.RSA_2048,
+                KeySpec.RSA_3072,
+                KeySpec.RSA_4096,
+                KeySpec.ECC_SECG_P256K1,
+                KeySpec.HMAC_224,
+                KeySpec.HMAC_256,
+                KeySpec.HMAC_384,
+                KeySpec.HMAC_512,
+            ],
+        };
+        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.startsWith("HMAC") && props.enableKeyRotation) {
+            throw new Error("key rotation cannot be enabled on HMAC keys");
+        }
+        if (keySpec !== KeySpec.SYMMETRIC_DEFAULT && props.enableKeyRotation) {
+            throw new Error("key rotation cannot be enabled on asymmetric keys");
+        }
+        this.enableKeyRotation = props.enableKeyRotation;
+        if (props.rotationPeriod) {
+            if (props.enableKeyRotation === false) {
+                throw new Error("'rotationPeriod' cannot be specified when 'enableKeyRotation' is disabled");
+            }
+            if (props.rotationPeriod.toDays() < 90 ||
+                props.rotationPeriod.toDays() > 2560) {
+                throw new Error(`'rotationPeriod' value must between 90 and 2650 days. Received: ${props.rotationPeriod.toDays()}`);
+            }
+            // If rotationPeriod is specified, enableKeyRotation is set to true by default
+            if (props.enableKeyRotation === undefined) {
+                this.enableKeyRotation = true;
+            }
+        }
+        this.policy = props.policy ?? new iam.PolicyDocument(this, "Policy");
+        this.trustAccountIdentities = props.trustAccountIdentities ?? true;
+        if (this.trustAccountIdentities) {
+            // Set the default key policy if one hasn't been provided by the user.
+            if (!props.policy) {
+                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}`);
+            }
+        }
+        this.resource = new provider_aws_1.kmsKey.KmsKey(this, "Resource", {
+            description: props.description,
+            enableKeyRotation: this.enableKeyRotation,
+            rotationPeriodInDays: props.rotationPeriod?.toDays(),
+            isEnabled: props.enabled,
+            customerMasterKeySpec: props.keySpec,
+            keyUsage: props.keyUsage,
+            policy: this.policy.json,
+            multiRegion: props.multiRegion,
+            deletionWindowInDays: pendingWindowInDays,
+        });
+        this.keyArn = this.resource.arn;
+        this.keyId = this.resource.id;
+        (props.admins ?? []).forEach((p) => this.grantAdmin(p));
+        if (props.alias !== undefined) {
+            this.addAlias(props.alias);
+        }
+    }
+    /**
+     * 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.
+     *
+     * @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: "terraconstructs.aws.encryption.Key", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key.js","sourceRoot":"","sources":["../../../src/aws/encryption/key.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/2.170.0/packages/aws-cdk-lib/aws-kms/lib/key.ts\n\nimport { kmsKey, dataAwsKmsKey } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { Alias } from \"./alias\";\nimport { KeyLookupOptions } from \"./key-lookup\";\nimport * as iam from \"../iam\";\nimport * as perms from \"./private/perms\";\nimport { Duration } from \"../../duration\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface KeyOutputs {\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/**\n * A KMS Key, either managed by this CDK app, or imported.\n */\nexport interface IKey extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly keyOutputs: KeyOutputs;\n\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(\n    statement: iam.PolicyStatement,\n    allowNoOp?: boolean,\n  ): 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  /**\n   * Grant permissions to generating MACs to the given principal\n   */\n  grantGenerateMac(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant permissions to verifying MACs to the given principal\n   */\n  grantVerifyMac(grantee: iam.IGrantable): iam.Grant;\n}\n\nabstract class KeyBase extends AwsConstructBase 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   * 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  public get keyOutputs(): KeyOutputs {\n    return {\n      keyArn: this.keyArn,\n      keyId: this.keyId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.keyOutputs;\n  }\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  constructor(scope: Construct, id: string, props: AwsConstructProps = {}) {\n    super(scope, id, props);\n\n    this.node.addValidation({\n      validate: () => this.policy?.validateForResourcePolicy() ?? [],\n    });\n  }\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(\n    statement: iam.PolicyStatement,\n    allowNoOp = true,\n  ): iam.AddToResourcePolicyResult {\n    const stack = AwsStack.ofAwsConstruct(this);\n\n    if (!this.policy) {\n      if (allowNoOp) {\n        return { statementAdded: false };\n      }\n      throw new Error(\n        `Unable to add statement to IAM resource policy for KMS key: ${JSON.stringify(stack.resolve(this.keyArn))}`,\n      );\n    }\n\n    this.policy.addStatements(statement);\n    return { statementAdded: true, policyDependable: this.policy };\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 =\n      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(\n      grantee,\n      ...[...perms.DECRYPT_ACTIONS, ...perms.ENCRYPT_ACTIONS],\n    );\n  }\n\n  /**\n   * Grant permissions to generating MACs to the given principal\n   */\n  public grantGenerateMac(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, ...perms.GENERATE_HMAC_ACTIONS);\n  }\n\n  /**\n   * Grant permissions to verifying MACs to the given principal\n   */\n  public grantVerifyMac(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, ...perms.VERIFY_HMAC_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(\n    grantee: iam.IGrantable,\n  ): string | undefined {\n    const grantPrincipal = grantee.grantPrincipal;\n    // this logic should only apply to newly created\n    // (= not imported) resources\n    if (!iam.principalIsOwnedResource(grantPrincipal)) {\n      return undefined;\n    }\n    const keyStack = AwsStack.ofAwsConstruct(this);\n    const granteeStack = AwsStack.ofAwsConstruct(grantPrincipal);\n    if (keyStack === granteeStack) {\n      return undefined;\n    }\n\n    // TODO: Find test case without cross stack reference cyclic dependencies...\n    return granteeStack.dependencies.includes(keyStack)\n      ? granteeStack.account\n      : undefined;\n  }\n\n  private isGranteeFromAnotherRegion(grantee: iam.IGrantable): boolean {\n    if (!iam.principalIsOwnedResource(grantee.grantPrincipal)) {\n      return false;\n    }\n    const keyStack = AwsStack.ofAwsConstruct(this);\n    const identityStack = AwsStack.ofAwsConstruct(grantee.grantPrincipal);\n\n    // if two compared stacks have the same region, this should return 'false' since it's from the\n    // same region; if two stacks have different region, then compare env.region\n    return (\n      keyStack.region !== identityStack.region &&\n      this.env.region !== identityStack.region\n    );\n  }\n\n  private isGranteeFromAnotherAccount(grantee: iam.IGrantable): boolean {\n    if (!iam.principalIsOwnedResource(grantee.grantPrincipal)) {\n      return false;\n    }\n    const keyStack = AwsStack.ofAwsConstruct(this);\n    const identityStack = AwsStack.ofAwsConstruct(grantee.grantPrincipal);\n\n    // if two compared stacks have the same account, this should return 'false' since it's from the\n    // same account; if two stacks have different account, then compare env.account\n    return (\n      keyStack.account !== identityStack.account &&\n      this.env.account !== identityStack.account\n    );\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   * Hash-Based Message Authentication Code as defined in RFC 2104 using the message digest function SHA224.\n   *\n   * Valid usage: GENERATE_VERIFY_MAC\n   */\n  HMAC_224 = \"HMAC_224\",\n\n  /**\n   * Hash-Based Message Authentication Code as defined in RFC 2104 using the message digest function SHA256.\n   *\n   * Valid usage: GENERATE_VERIFY_MAC\n   */\n  HMAC_256 = \"HMAC_256\",\n\n  /**\n   * Hash-Based Message Authentication Code as defined in RFC 2104 using the message digest function SHA384.\n   *\n   * Valid usage: GENERATE_VERIFY_MAC\n   */\n  HMAC_384 = \"HMAC_384\",\n\n  /**\n   * Hash-Based Message Authentication Code as defined in RFC 2104 using the message digest function SHA512.\n   *\n   * Valid usage: GENERATE_VERIFY_MAC\n   */\n  HMAC_512 = \"HMAC_512\",\n\n  /**\n   * Elliptic curve key spec available only in China Regions.\n   *\n   * Valid usage: ENCRYPT_DECRYPT and SIGN_VERIFY\n   */\n  SM2 = \"SM2\",\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   * Generating and verifying MACs\n   */\n  GENERATE_VERIFY_MAC = \"GENERATE_VERIFY_MAC\",\n\n  /**\n   * Deriving shared secrets\n   */\n  KEY_AGREEMENT = \"KEY_AGREEMENT\",\n}\n\n/**\n * Construction properties for a KMS Key object\n */\nexport interface KeyProps extends AwsConstructProps {\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   * The period between each automatic rotation.\n   *\n   * @default - set by CFN to 365 days.\n   */\n  readonly rotationPeriod?: Duration;\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   * Creates a multi-Region primary key that you can replicate in other AWS Regions.\n   *\n   * You can't change the `multiRegion` value after the KMS key is created.\n   *\n   * IMPORTANT: If you change the value of the `multiRegion` property on an existing KMS key, the update request fails,\n   * regardless of the value of the UpdateReplacePolicy attribute.\n   * This prevents you from accidentally deleting a KMS key by changing an immutable property value.\n   *\n   * @default false\n   * @see https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html\n   */\n  readonly multiRegion?: boolean;\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 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   * @default - true\n   * @see https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default-allow-root-enable-iam\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, props: AwsConstructProps = {}) {\n        super(scope, id, props);\n\n        this.keyId = keyId;\n      }\n    }\n\n    const keyResourceName = AwsStack.ofAwsConstruct(scope).splitArn(\n      keyArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    ).resourceName;\n    if (!keyResourceName) {\n      throw new Error(\n        `KMS key ARN must be in the format 'arn:<partition>:kms:<region>:<account>:key/<keyId>', got: '${keyArn}'`,\n      );\n    }\n\n    return new Import(keyResourceName, {\n      environmentFromArn: keyArn,\n    });\n  }\n\n  /**\n   * Create a mutable `IKey` based on a low-level `KmsKey`.\n   * This method is different than `fromKeyArn()` because the `IKey`\n   * returned from this method is mutable;\n   * meaning, calling any mutating methods on it,\n   * like `IKey.addToResourcePolicy()`,\n   * will actually be reflected in the resulting template,\n   * as opposed to the object returned from `fromKeyArn()`,\n   * on which calling those methods would have no effect.\n   */\n  public static fromTfKey(tfKey: kmsKey.KmsKey): IKey {\n    // use a \"weird\" id that has a higher chance of being unique\n    const id = \"@FromTfKey\";\n\n    // if fromTfKey() was already called on this tfKey,\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 = tfKey.node.tryFindChild(id);\n    if (existing) {\n      return <IKey>existing;\n    }\n\n    let keyPolicy: iam.PolicyDocument;\n    if (Token.isUnresolved(tfKey.policyInput)) {\n      // find first PolicyDocument in the scope who's json token points to the key policy\n      keyPolicy = AwsStack.of(tfKey)\n        .node.findAll()\n        .filter(\n          (c) =>\n            c instanceof iam.PolicyDocument && c.json === tfKey.policyInput,\n        )[0] as iam.PolicyDocument;\n      if (!keyPolicy) {\n        throw new Error(\n          \"Could not resolve the passed aws_kms_key policy attribute to a PolicyDocument resource json attribute. \" +\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    } else {\n      try {\n        const policyInputObj = JSON.parse(tfKey.policyInput ?? \"\");\n        // create new PolicyDocument from the json string\n        keyPolicy = iam.PolicyDocument.fromJson(\n          tfKey,\n          \"Policy\",\n          policyInputObj,\n        );\n      } catch {\n        // If 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(\n          \"Could not parse the PolicyDocument of the passed aws_kms_key resource. \" +\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    }\n\n    // re-ensure key policy points to the nested L2 PolicyDocument\n    tfKey.policy = keyPolicy.json;\n\n    return new (class extends KeyBase {\n      public readonly keyArn = tfKey.arn;\n      public readonly keyId = tfKey.id;\n      protected readonly policy = keyPolicy;\n      protected readonly trustAccountIdentities = false;\n    })(tfKey, 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 CDKTF\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 CLI is executed.\n   * You can therefore not use any values that will only be available at\n   * Terraform execution time (i.e., Tokens).\n   */\n  public static fromLookup(\n    scope: Construct,\n    id: string,\n    options: KeyLookupOptions,\n  ): IKey {\n    class Import extends KeyBase {\n      public readonly keyArn: string;\n      public readonly keyId: string;\n      public readonly dataSource: dataAwsKmsKey.DataAwsKmsKey;\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        this.dataSource = new dataAwsKmsKey.DataAwsKmsKey(this, \"Resource\", {\n          keyId,\n        });\n        this.keyId = keyId;\n        this.keyArn = this.dataSource.arn;\n      }\n    }\n    if (Token.isUnresolved(options.aliasName)) {\n      throw new Error(\n        \"All arguments to Key.fromLookup() must be concrete (no Tokens)\",\n      );\n    }\n\n    return new Import(options.aliasName);\n  }\n\n  public readonly keyArn: string;\n  public readonly keyId: string;\n  public readonly resource: kmsKey.KmsKey;\n\n  protected readonly policy?: iam.PolicyDocument;\n  protected readonly trustAccountIdentities: boolean;\n  private readonly enableKeyRotation?: boolean;\n\n  constructor(scope: Construct, id: string, props: KeyProps = {}) {\n    super(scope, id, props);\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        KeySpec.HMAC_224,\n        KeySpec.HMAC_256,\n        KeySpec.HMAC_384,\n        KeySpec.HMAC_512,\n      ],\n      [KeyUsage.SIGN_VERIFY]: [\n        KeySpec.SYMMETRIC_DEFAULT,\n        KeySpec.HMAC_224,\n        KeySpec.HMAC_256,\n        KeySpec.HMAC_384,\n        KeySpec.HMAC_512,\n      ],\n      [KeyUsage.GENERATE_VERIFY_MAC]: [\n        KeySpec.RSA_2048,\n        KeySpec.RSA_3072,\n        KeySpec.RSA_4096,\n        KeySpec.ECC_NIST_P256,\n        KeySpec.ECC_NIST_P384,\n        KeySpec.ECC_NIST_P521,\n        KeySpec.ECC_SECG_P256K1,\n        KeySpec.SYMMETRIC_DEFAULT,\n        KeySpec.SM2,\n      ],\n      [KeyUsage.KEY_AGREEMENT]: [\n        KeySpec.SYMMETRIC_DEFAULT,\n        KeySpec.RSA_2048,\n        KeySpec.RSA_3072,\n        KeySpec.RSA_4096,\n        KeySpec.ECC_SECG_P256K1,\n        KeySpec.HMAC_224,\n        KeySpec.HMAC_256,\n        KeySpec.HMAC_384,\n        KeySpec.HMAC_512,\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(\n        `key spec '${keySpec}' is not valid with usage '${keyUsage}'`,\n      );\n    }\n\n    if (keySpec.startsWith(\"HMAC\") && props.enableKeyRotation) {\n      throw new Error(\"key rotation cannot be enabled on HMAC keys\");\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    this.enableKeyRotation = props.enableKeyRotation;\n\n    if (props.rotationPeriod) {\n      if (props.enableKeyRotation === false) {\n        throw new Error(\n          \"'rotationPeriod' cannot be specified when 'enableKeyRotation' is disabled\",\n        );\n      }\n      if (\n        props.rotationPeriod.toDays() < 90 ||\n        props.rotationPeriod.toDays() > 2560\n      ) {\n        throw new Error(\n          `'rotationPeriod' value must between 90 and 2650 days. Received: ${props.rotationPeriod.toDays()}`,\n        );\n      }\n      // If rotationPeriod is specified, enableKeyRotation is set to true by default\n      if (props.enableKeyRotation === undefined) {\n        this.enableKeyRotation = true;\n      }\n    }\n\n    this.policy = props.policy ?? new iam.PolicyDocument(this, \"Policy\");\n    this.trustAccountIdentities = props.trustAccountIdentities ?? true;\n    if (this.trustAccountIdentities) {\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.addLegacyAdminPolicy();\n    }\n\n    let pendingWindowInDays;\n    if (props.pendingWindow) {\n      pendingWindowInDays = props.pendingWindow.toDays();\n      if (pendingWindowInDays < 7 || pendingWindowInDays > 30) {\n        throw new Error(\n          `'pendingWindow' value must between 7 and 30 days. Received: ${pendingWindowInDays}`,\n        );\n      }\n    }\n\n    this.resource = new kmsKey.KmsKey(this, \"Resource\", {\n      description: props.description,\n      enableKeyRotation: this.enableKeyRotation,\n      rotationPeriodInDays: props.rotationPeriod?.toDays(),\n      isEnabled: props.enabled,\n      customerMasterKeySpec: props.keySpec,\n      keyUsage: props.keyUsage,\n      policy: this.policy.json,\n      multiRegion: props.multiRegion,\n      deletionWindowInDays: pendingWindowInDays,\n    });\n\n    this.keyArn = this.resource.arn;\n    this.keyId = this.resource.id;\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(\n      new iam.PolicyStatement({\n        resources: [\"*\"],\n        actions: [\"kms:*\"],\n        principals: [new iam.AccountRootPrincipal()],\n      }),\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.\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(\n      new iam.PolicyStatement({\n        resources: [\"*\"],\n        actions,\n        principals: [new iam.AccountRootPrincipal()],\n      }),\n    );\n  }\n}\n"]}