truemark-cdk-lib 1.29.0 → 1.31.0

package/dist/aws-securitylake/lib/standard-security-lake.d.ts

@@ -1,5 +1,5 @@
 import { CfnServiceLinkedRole, Role } from 'aws-cdk-lib/aws-iam';
-import { CfnAwsLogSource, CfnDataLake } from 'aws-cdk-lib/aws-securitylake';
+import { CfnAwsLogSource, CfnDataLake, CfnSubscriber, CfnSubscriberNotification } from 'aws-cdk-lib/aws-securitylake';
 import type { Construct } from 'constructs';
 import { ExtendedConstruct, type ExtendedConstructProps } from '../../aws-cdk/index';
 /**
@@ -116,6 +116,102 @@ export interface SecurityLakeReplicationProps {
      */
     readonly destinationKmsKeyArns?: string[];
 }
+/**
+ * The AWS log sources a subscriber should receive. Each entry maps to the
+ * same `sourceName`/`sourceVersion` pair used when enabling the source.
+ */
+export interface SecurityLakeSubscriberSourceProps {
+    /**
+     * The source name, e.g. `CLOUD_TRAIL_MGMT`.
+     */
+    readonly sourceName: AwsLogSourceName | string;
+    /**
+     * The source version.
+     *
+     * @default - '2.0'
+     */
+    readonly sourceVersion?: string;
+}
+/**
+ * Properties for a Security Lake subscriber with S3-notification access.
+ * Only the `S3` access type (asynchronous SQS notification of new objects)
+ * is modelled; Lake Formation subscribers can be created directly against
+ * the underlying `CfnSubscriber` L1.
+ *
+ * @see https://docs.aws.amazon.com/security-lake/latest/userguide/subscriber-management.html
+ */
+export interface SecurityLakeSubscriberProps {
+    /**
+     * The friendly name of the subscriber.
+     */
+    readonly subscriberName: string;
+    /**
+     * The AWS account id of the principal that will consume data (typically
+     * the SIEM / downstream account id).
+     */
+    readonly principal: string;
+    /**
+     * External id the subscriber must present when assuming the
+     * Security-Lake-managed role. Treat as a shared secret.
+     */
+    readonly externalId: string;
+    /**
+     * Log sources this subscriber receives. Each entry must correspond to a
+     * source that is enabled on the data lake.
+     */
+    readonly sources: SecurityLakeSubscriberSourceProps[];
+    /**
+     * Optional human-readable description.
+     *
+     * @default - no description
+     */
+    readonly description?: string;
+    /**
+     * Optional HTTPS endpoint for subscriber notifications. If omitted,
+     * Security Lake creates an SQS queue in the data-lake account and
+     * notifies the subscriber via SQS messages (recommended default — the
+     * SIEM polls the queue).
+     *
+     * When set, {@link httpsNotificationTargetRoleArn} is required.
+     *
+     * @default - SQS notification
+     */
+    readonly httpsNotificationEndpoint?: string;
+    /**
+     * IAM role ARN EventBridge assumes to invoke the HTTPS endpoint when
+     * {@link httpsNotificationEndpoint} is set. The role must trust
+     * `events.amazonaws.com` and have `events:InvokeApiDestination`
+     * permissions. The AWS console provisions this helper role
+     * automatically when a subscriber is created through the UI, but the
+     * CloudFormation / API path does **not** — so a fresh account must
+     * create and pass this role explicitly, or Security Lake will reject
+     * the subscriber-notification create call.
+     *
+     * Ignored when {@link httpsNotificationEndpoint} is omitted.
+     *
+     * @default - none; required when `httpsNotificationEndpoint` is set
+     */
+    readonly httpsNotificationTargetRoleArn?: string;
+    /**
+     * When set and the subscriber uses the default SQS notification path,
+     * the construct patches the Security-Lake-managed Main-Queue's
+     * `VisibilityTimeout` attribute to this value (seconds) via an
+     * `AwsCustomResource`. Needed because Security Lake auto-provisions
+     * the queue with a 300s visibility timeout, which is **less than** the
+     * default aes-siem es-loader Lambda timeout of 600s, causing the
+     * event-source-mapping create to be rejected with
+     * `"The event source mapping's function timeout must be smaller than
+     * or equal to the queue's visibility timeout"`.
+     *
+     * Set to a value `>=` your subscriber Lambda's timeout. 3600 is a
+     * safe default for aes-siem.
+     *
+     * Ignored when {@link httpsNotificationEndpoint} is set.
+     *
+     * @default - no patch; the queue keeps the Security-Lake-provisioned 300s
+     */
+    readonly sqsVisibilityTimeoutSeconds?: number;
+}
 /**
  * Properties for StandardSecurityLake.
  */
@@ -185,6 +281,14 @@ export interface StandardSecurityLakeProps extends ExtendedConstructProps {
      * @default false
      */
     readonly createLakeFormationServiceLinkedRole?: boolean;
+    /**
+     * Subscribers that should receive S3 notifications of new Security Lake
+     * objects. Each entry creates an `AWS::SecurityLake::Subscriber` (access
+     * type `S3`) plus an `AWS::SecurityLake::SubscriberNotification`.
+     *
+     * @default - no subscribers are created
+     */
+    readonly subscribers?: SecurityLakeSubscriberProps[];
 }
 /**
  * Standard Amazon Security Lake. Wraps the Security Lake L1 constructs to
@@ -219,5 +323,15 @@ export declare class StandardSecurityLake extends ExtendedConstruct {
      * they were declared.
      */
     readonly logSources: CfnAwsLogSource[];
+    /**
+     * The `CfnSubscriber` resources created by this construct, in the order
+     * they were declared.
+     */
+    readonly subscribers: CfnSubscriber[];
+    /**
+     * The `CfnSubscriberNotification` resources created by this construct,
+     * one per subscriber, in the order they were declared.
+     */
+    readonly subscriberNotifications: CfnSubscriberNotification[];
     constructor(scope: Construct, id: string, props?: StandardSecurityLakeProps);
 }

package/dist/aws-securitylake/lib/standard-security-lake.js

@@ -4,6 +4,7 @@ exports.StandardSecurityLake = exports.AwsLogSourceName = void 0;
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_iam_1 = require("aws-cdk-lib/aws-iam");
 const aws_securitylake_1 = require("aws-cdk-lib/aws-securitylake");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
 const index_1 = require("../../aws-cdk/index");
 /**
  * The AWS-native log sources that Amazon Security Lake can ingest.
@@ -31,13 +32,23 @@ var AwsLogSourceName;
  */
 class StandardSecurityLake extends index_1.ExtendedConstruct {
     constructor(scope, id, props) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         super(scope, id, props);
         /**
          * The `CfnAwsLogSource` resources created by this construct, in the order
          * they were declared.
          */
         this.logSources = [];
+        /**
+         * The `CfnSubscriber` resources created by this construct, in the order
+         * they were declared.
+         */
+        this.subscribers = [];
+        /**
+         * The `CfnSubscriberNotification` resources created by this construct,
+         * one per subscriber, in the order they were declared.
+         */
+        this.subscriberNotifications = [];
         // Optional Lake Formation service-linked role. Security Lake requires
         // this SLR to exist in the account before a data lake can be created.
         if (props === null || props === void 0 ? void 0 : props.createLakeFormationServiceLinkedRole) {
@@ -260,7 +271,123 @@ class StandardSecurityLake extends index_1.ExtendedConstruct {
             previous = logSource;
             this.logSources.push(logSource);
         }
+        // Subscribers. Each entry becomes a `CfnSubscriber` with `accessTypes:
+        // ['S3']` plus a sibling `CfnSubscriberNotification`. The notification
+        // defaults to SQS (Security Lake creates the queue in this account);
+        // callers can switch to HTTPS by passing `httpsNotificationEndpoint`.
+        for (const sub of (_e = props === null || props === void 0 ? void 0 : props.subscribers) !== null && _e !== void 0 ? _e : []) {
+            const subscriber = new aws_securitylake_1.CfnSubscriber(this, `Subscriber${sub.subscriberName}`, {
+                accessTypes: ['S3'],
+                dataLakeArn: this.dataLake.attrArn,
+                subscriberName: sub.subscriberName,
+                subscriberDescription: sub.description,
+                subscriberIdentity: {
+                    externalId: sub.externalId,
+                    principal: sub.principal,
+                },
+                sources: sub.sources.map((s) => {
+                    var _a;
+                    return ({
+                        awsLogSource: {
+                            sourceName: s.sourceName,
+                            sourceVersion: (_a = s.sourceVersion) !== null && _a !== void 0 ? _a : '2.0',
+                        },
+                    });
+                }),
+            });
+            subscriber.addDependency(this.dataLake);
+            // Subscriber creation requires the AwsLogSource to exist for every
+            // source it references; chain through the last log source we created
+            // so CFN waits for ingestion to be enabled.
+            for (const ls of this.logSources) {
+                subscriber.addDependency(ls);
+            }
+            this.subscribers.push(subscriber);
+            if (sub.httpsNotificationEndpoint &&
+                !sub.httpsNotificationTargetRoleArn) {
+                throw new Error(`StandardSecurityLake: subscriber "${sub.subscriberName}" sets ` +
+                    '`httpsNotificationEndpoint` but no ' +
+                    '`httpsNotificationTargetRoleArn`. The CloudFormation/API path ' +
+                    'does not auto-provision the EventBridge invocation role (only ' +
+                    'the AWS console does). Create a role trusted by ' +
+                    '`events.amazonaws.com` with `events:InvokeApiDestination` on ' +
+                    'the target endpoint and pass its ARN as ' +
+                    '`httpsNotificationTargetRoleArn`.');
+            }
+            const notification = new aws_securitylake_1.CfnSubscriberNotification(this, `SubscriberNotification${sub.subscriberName}`, {
+                subscriberArn: subscriber.attrSubscriberArn,
+                notificationConfiguration: sub.httpsNotificationEndpoint
+                    ? {
+                        httpsNotificationConfiguration: {
+                            endpoint: sub.httpsNotificationEndpoint,
+                            targetRoleArn: sub.httpsNotificationTargetRoleArn,
+                        },
+                    }
+                    : {
+                        sqsNotificationConfiguration: {},
+                    },
+            });
+            notification.addDependency(subscriber);
+            this.subscriberNotifications.push(notification);
+            // Patch the Security-Lake-managed SQS Main-Queue's visibility
+            // timeout. Needed because Security Lake auto-provisions the queue
+            // with 300s, less than the aes-siem es-loader Lambda timeout (600s
+            // default), causing event-source-mapping creation to fail with
+            // "The event source mapping's function timeout must be smaller
+            // than or equal to the queue's visibility timeout."
+            if (!sub.httpsNotificationEndpoint &&
+                sub.sqsVisibilityTimeoutSeconds !== undefined) {
+                const timeout = sub.sqsVisibilityTimeoutSeconds;
+                const stack = aws_cdk_lib_1.Stack.of(this);
+                // The notification resource returns the queue ARN via
+                // `SubscriberEndpoint`. Convert to a queue URL for the SQS SDK.
+                // ARN: arn:<partition>:sqs:<region>:<account>:<name>
+                // URL: https://sqs.<region>.<url-suffix>/<account>/<name>
+                //
+                // The URL suffix is partition-aware (`amazonaws.com`,
+                // `amazonaws.com.cn`, `c2s.ic.gov`, etc.); hard-coding
+                // `amazonaws.com` breaks `aws-cn` and GovCloud. Use the stack's
+                // `urlSuffix` token so CloudFormation substitutes the right
+                // value at deploy time.
+                const queueName = aws_cdk_lib_1.Fn.select(5, aws_cdk_lib_1.Fn.split(':', notification.attrSubscriberEndpoint));
+                const queueUrl = `https://sqs.${stack.region}.${stack.urlSuffix}/${stack.account}/${queueName}`;
+                const patch = new custom_resources_1.AwsCustomResource(this, `SubscriberQueueVisibilityPatch${sub.subscriberName}`, {
+                    onCreate: {
+                        service: 'SQS',
+                        action: 'setQueueAttributes',
+                        parameters: {
+                            QueueUrl: queueUrl,
+                            Attributes: { VisibilityTimeout: timeout.toString() },
+                        },
+                        physicalResourceId: custom_resources_1.PhysicalResourceId.of(`${sub.subscriberName}-visibility-${timeout}`),
+                    },
+                    onUpdate: {
+                        service: 'SQS',
+                        action: 'setQueueAttributes',
+                        parameters: {
+                            QueueUrl: queueUrl,
+                            Attributes: { VisibilityTimeout: timeout.toString() },
+                        },
+                        physicalResourceId: custom_resources_1.PhysicalResourceId.of(`${sub.subscriberName}-visibility-${timeout}`),
+                    },
+                    policy: custom_resources_1.AwsCustomResourcePolicy.fromStatements([
+                        new aws_iam_1.PolicyStatement({
+                            actions: ['sqs:SetQueueAttributes'],
+                            // Scope to the exact queue ARN exposed by the
+                            // SubscriberNotification resource
+                            // (`attrSubscriberEndpoint`), which is already an SQS
+                            // ARN. Using the token means CloudFormation substitutes
+                            // the real queue ARN at deploy-time, so the custom-
+                            // resource role cannot be abused to modify unrelated
+                            // queues in the account.
+                            resources: [notification.attrSubscriberEndpoint],
+                        }),
+                    ]),
+                });
+                patch.node.addDependency(notification);
+            }
+        }
     }
 }
 exports.StandardSecurityLake = StandardSecurityLake;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard-security-lake.js","sourceRoot":"","sources":["../../../src/aws-securitylake/lib/standard-security-lake.ts"],"names":[],"mappings":"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","sourcesContent":["import {RemovalPolicy, Stack} from 'aws-cdk-lib';\nimport {\n  CfnServiceLinkedRole,\n  ManagedPolicy,\n  PolicyDocument,\n  PolicyStatement,\n  Role,\n  ServicePrincipal,\n} from 'aws-cdk-lib/aws-iam';\nimport {CfnAwsLogSource, CfnDataLake} from 'aws-cdk-lib/aws-securitylake';\nimport type {Construct} from 'constructs';\nimport {\n  ExtendedConstruct,\n  type ExtendedConstructProps,\n} from '../../aws-cdk/index';\n\n/**\n * The AWS-native log sources that Amazon Security Lake can ingest.\n *\n * @see https://docs.aws.amazon.com/security-lake/latest/userguide/internal-sources.html\n */\nexport enum AwsLogSourceName {\n  CLOUD_TRAIL_MGMT = 'CLOUD_TRAIL_MGMT',\n  LAMBDA_EXECUTION = 'LAMBDA_EXECUTION',\n  ROUTE53 = 'ROUTE53',\n  S3_DATA = 'S3_DATA',\n  SH_FINDINGS = 'SH_FINDINGS',\n  VPC_FLOW = 'VPC_FLOW',\n  EKS_AUDIT = 'EKS_AUDIT',\n  WAF = 'WAF',\n}\n\n/**\n * Properties for an individual AWS log source to enable on the data lake.\n */\nexport interface AwsLogSourceProps {\n  /**\n   * The name of the AWS log source to enable.\n   */\n  readonly sourceName: AwsLogSourceName | string;\n\n  /**\n   * The version of the AWS log source to enable.\n   *\n   * @default - '2.0'\n   */\n  readonly sourceVersion?: string;\n\n  /**\n   * The AWS accounts whose data should be collected for this source. If not\n   * provided, the data lake owner account is used.\n   *\n   * @default - [Stack.of(this).account]\n   */\n  readonly accounts?: string[];\n}\n\n/**\n * Lifecycle transition for Security Lake data.\n */\nexport interface SecurityLakeTransitionProps {\n  /**\n   * The number of days before data transitions to the given storage class.\n   */\n  readonly days: number;\n\n  /**\n   * The target S3 storage class. Supported values include `STANDARD_IA`,\n   * `ONEZONE_IA`, `INTELLIGENT_TIERING`, `GLACIER_IR`, `GLACIER` and\n   * `DEEP_ARCHIVE`.\n   */\n  readonly storageClass: string;\n}\n\n/**\n * Lifecycle configuration options for Security Lake managed S3 storage.\n */\nexport interface SecurityLakeLifecycleProps {\n  /**\n   * The number of days before Security Lake data is expired/deleted.\n   *\n   * @default - data is retained indefinitely\n   */\n  readonly expirationDays?: number;\n\n  /**\n   * Transitions applied to Security Lake data.\n   *\n   * @default - no transitions\n   */\n  readonly transitions?: SecurityLakeTransitionProps[];\n}\n\n/**\n * Replication configuration for Security Lake data.\n */\nexport interface SecurityLakeReplicationProps {\n  /**\n   * One or more rollup Regions to replicate data to.\n   */\n  readonly regions: string[];\n\n  /**\n   * The ARN of the IAM role Security Lake uses to replicate objects. If not\n   * provided, a role will be created automatically.\n   *\n   * @default - a new role is created\n   */\n  readonly roleArn?: string;\n\n  /**\n   * The ARN of the customer-managed KMS key encrypting the source\n   * (originating-Region) Security Lake bucket. Required when the enclosing\n   * `StandardSecurityLake` is configured with a customer-managed `kmsKeyId`\n   * and this construct creates the replication role (i.e. when `roleArn`\n   * is not provided); S3 needs `kms:Decrypt` on this key to read objects\n   * before replicating them. Not required when the source bucket uses\n   * S3-managed or AWS-managed encryption.\n   *\n   * This is independent of `destinationKmsKeyArns`: Security Lake rollup\n   * Regions may use their own encryption settings, so a CMK source can\n   * replicate to an SSE-S3 rollup and vice versa.\n   *\n   * @default - no KMS decrypt statement is added\n   */\n  readonly sourceKmsKeyArn?: string;\n\n  /**\n   * The ARNs of the customer-managed KMS keys encrypting the destination\n   * (rollup-Region) Security Lake buckets. Supply when any rollup Region's\n   * bucket uses a customer-managed KMS key so the replication role can\n   * `kms:Encrypt` / `kms:GenerateDataKey` against them. Not required when\n   * every rollup bucket uses S3-managed or AWS-managed encryption.\n   *\n   * This is independent of `sourceKmsKeyArn` and the source lake's\n   * `kmsKeyId`.\n   *\n   * @default - no KMS encrypt statement is added\n   */\n  readonly destinationKmsKeyArns?: string[];\n}\n\n/**\n * Properties for StandardSecurityLake.\n */\nexport interface StandardSecurityLakeProps extends ExtendedConstructProps {\n  /**\n   * The KMS key id to use to encrypt data stored by Security Lake. Use the\n   * literal string `S3_MANAGED_KEY` to use S3 managed keys (SSE-S3). Omit to\n   * let Security Lake use its default managed key.\n   *\n   * @default - Security Lake managed encryption\n   */\n  readonly kmsKeyId?: string;\n\n  /**\n   * The ARN of the role used by Security Lake to manage the AWS Glue\n   * metastore. If omitted, a role is created with the\n   * `AmazonSecurityLakeMetastoreManager` AWS managed policy attached.\n   *\n   * @default - a role is created\n   */\n  readonly metaStoreManagerRoleArn?: string;\n\n  /**\n   * The ARN of the customer-managed KMS key used to encrypt Security Lake\n   * data. Required when `kmsKeyId` is set to a customer-managed key and this\n   * construct creates the metastore manager role (i.e. when\n   * `metaStoreManagerRoleArn` is not provided). The metastore manager\n   * Lambda must decrypt and (re)encrypt Security Lake metadata; the AWS\n   * managed policy `AmazonSecurityLakeMetastoreManager` does not include\n   * KMS permissions, so without this grant the stack deploys but partition\n   * updates and subscriber queries silently fail. Not required when\n   * `kmsKeyId` is unset or set to `S3_MANAGED_KEY`.\n   *\n   * @default - no KMS statement is added (sufficient when the data lake\n   * uses Security Lake defaults or SSE-S3)\n   */\n  readonly metaStoreManagerKmsKeyArn?: string;\n\n  /**\n   * Lifecycle configuration for the Security Lake managed S3 storage.\n   *\n   * @default - Security Lake defaults\n   */\n  readonly lifecycle?: SecurityLakeLifecycleProps;\n\n  /**\n   * Replication configuration for the Security Lake managed S3 storage.\n   *\n   * @default - no replication\n   */\n  readonly replication?: SecurityLakeReplicationProps;\n\n  /**\n   * The AWS native log sources to enable on the data lake. Sources are\n   * created sequentially using `DependsOn` as required by Security Lake.\n   *\n   * @default - no log sources are enabled\n   */\n  readonly logSources?: AwsLogSourceProps[];\n\n  /**\n   * Whether to create the `AWSServiceRoleForLakeFormationDataAccess`\n   * service-linked role. Security Lake requires this role to exist in the\n   * account before a data lake can be created; however the role is a\n   * singleton per account and is frequently auto-created on first use of\n   * Lake Formation. Enable this only when you know the role does not yet\n   * exist in the account, otherwise stack creation will fail with\n   * `has been taken in this account`.\n   *\n   * The data lake will `DependsOn` this role when it is created so ordering\n   * is handled automatically.\n   *\n   * @default false\n   */\n  readonly createLakeFormationServiceLinkedRole?: boolean;\n}\n\n/**\n * Standard Amazon Security Lake. Wraps the Security Lake L1 constructs to\n * stand up a data lake with an optional set of AWS native log sources\n * enabled, a metastore manager role, lifecycle policy and replication.\n *\n * Where this construct does not meet your needs, use the underlying\n * `CfnDataLake` and `CfnAwsLogSource` constructs directly.\n */\nexport class StandardSecurityLake extends ExtendedConstruct {\n  /**\n   * The underlying `CfnDataLake` resource.\n   */\n  readonly dataLake: CfnDataLake;\n\n  /**\n   * The IAM role used by Security Lake to manage the Glue metastore. When\n   * `metaStoreManagerRoleArn` is provided this will be `undefined`.\n   */\n  readonly metaStoreManagerRole?: Role;\n\n  /**\n   * The IAM role used by Security Lake to replicate objects. Only created\n   * when replication is enabled and no `roleArn` was supplied.\n   */\n  readonly replicationRole?: Role;\n\n  /**\n   * The Lake Formation `AWSServiceRoleForLakeFormationDataAccess`\n   * service-linked role, when it was provisioned by this construct.\n   */\n  readonly lakeFormationServiceLinkedRole?: CfnServiceLinkedRole;\n\n  /**\n   * The `CfnAwsLogSource` resources created by this construct, in the order\n   * they were declared.\n   */\n  readonly logSources: CfnAwsLogSource[] = [];\n\n  constructor(scope: Construct, id: string, props?: StandardSecurityLakeProps) {\n    super(scope, id, props);\n\n    // Optional Lake Formation service-linked role. Security Lake requires\n    // this SLR to exist in the account before a data lake can be created.\n    if (props?.createLakeFormationServiceLinkedRole) {\n      this.lakeFormationServiceLinkedRole = new CfnServiceLinkedRole(\n        this,\n        'LakeFormationServiceLinkedRole',\n        {\n          awsServiceName: 'lakeformation.amazonaws.com',\n          description:\n            'Service-linked role used by AWS Lake Formation to access registered S3 locations. Required by Amazon Security Lake.',\n        },\n      );\n      // The Lake Formation SLR is an account singleton that is frequently\n      // shared with other stacks and consoles. Retain it on\n      // stack-delete/opt-out so toggling this flag off (or removing this\n      // construct) does not strip Lake Formation access account-wide.\n      this.lakeFormationServiceLinkedRole.applyRemovalPolicy(\n        RemovalPolicy.RETAIN,\n      );\n    }\n\n    // Metastore manager role.\n    let metaStoreManagerRoleArn = props?.metaStoreManagerRoleArn;\n    const usesCustomerManagedKey =\n      props?.kmsKeyId !== undefined && props.kmsKeyId !== 'S3_MANAGED_KEY';\n    if (!metaStoreManagerRoleArn) {\n      // When the data lake is encrypted with a customer-managed KMS key,\n      // the metastore manager Lambda must be able to Decrypt / Encrypt /\n      // GenerateDataKey against that key. The AWS managed policy\n      // `AmazonSecurityLakeMetastoreManager` does NOT include KMS actions,\n      // so without this grant CFN deployment succeeds but partition\n      // updates and subscriber queries fail at runtime. The key ARN is\n      // not derivable at synth time, so require the caller to supply it\n      // explicitly via `metaStoreManagerKmsKeyArn` or pre-provision their\n      // own metastore manager role via `metaStoreManagerRoleArn`.\n      if (usesCustomerManagedKey && !props?.metaStoreManagerKmsKeyArn) {\n        throw new Error(\n          'StandardSecurityLake: a customer-managed `kmsKeyId` requires ' +\n            '`metaStoreManagerKmsKeyArn` so the generated metastore manager ' +\n            'role can be granted the necessary KMS permissions. ' +\n            'Alternatively, pre-provision the metastore manager role ' +\n            'yourself and pass its ARN via `metaStoreManagerRoleArn`.',\n        );\n      }\n      const metaStoreInlinePolicies: {[name: string]: PolicyDocument} = {};\n      if (usesCustomerManagedKey && props?.metaStoreManagerKmsKeyArn) {\n        metaStoreInlinePolicies.AmazonSecurityLakeMetastoreManagerKmsPolicy =\n          new PolicyDocument({\n            statements: [\n              new PolicyStatement({\n                sid: 'AllowMetaStoreManagerKmsAccess',\n                actions: [\n                  'kms:Decrypt',\n                  'kms:Encrypt',\n                  'kms:GenerateDataKey',\n                  'kms:DescribeKey',\n                ],\n                resources: [props.metaStoreManagerKmsKeyArn],\n              }),\n            ],\n          });\n      }\n      this.metaStoreManagerRole = new Role(this, 'MetaStoreManagerRole', {\n        // The partition-updater Lambda functions created by Security Lake are\n        // hard-coded to assume a role named\n        // `AmazonSecurityLakeMetaStoreManagerV2` under the `/service-role/`\n        // path and do not honor an arbitrary role ARN. Without a matching\n        // role name, CFN deployment and `CreateDataLake` succeed but the\n        // partition updater silently fails and subscribers cannot query\n        // replicated objects. The role name is account-global; for\n        // multi-Region deploys in the same account pass\n        // `metaStoreManagerRoleArn` for all but one Region.\n        path: '/service-role/',\n        roleName: 'AmazonSecurityLakeMetaStoreManagerV2',\n        assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n        description:\n          'Role used by Amazon Security Lake metastore manager Lambda to manage the AWS Glue metastore.',\n        managedPolicies: [\n          ManagedPolicy.fromAwsManagedPolicyName(\n            'service-role/AmazonSecurityLakeMetastoreManager',\n          ),\n        ],\n        inlinePolicies: metaStoreInlinePolicies,\n      });\n      metaStoreManagerRoleArn = this.metaStoreManagerRole.roleArn;\n    }\n\n    // Encryption configuration.\n    const encryptionConfiguration:\n      | CfnDataLake.EncryptionConfigurationProperty\n      | undefined =\n      props?.kmsKeyId !== undefined ? {kmsKeyId: props.kmsKeyId} : undefined;\n\n    // Lifecycle configuration.\n    let lifecycleConfiguration:\n      | CfnDataLake.LifecycleConfigurationProperty\n      | undefined;\n    if (props?.lifecycle) {\n      lifecycleConfiguration = {\n        expiration:\n          props.lifecycle.expirationDays !== undefined\n            ? {days: props.lifecycle.expirationDays}\n            : undefined,\n        transitions: props.lifecycle.transitions?.map((t) => ({\n          days: t.days,\n          storageClass: t.storageClass,\n        })),\n      };\n    }\n\n    // Replication configuration.\n    let replicationConfiguration:\n      | CfnDataLake.ReplicationConfigurationProperty\n      | undefined;\n    if (props?.replication) {\n      let replicationRoleArn = props.replication.roleArn;\n      if (!replicationRoleArn) {\n        const account = Stack.of(this).account;\n        const sourceRegion = Stack.of(this).region;\n        const destinationRegions = props.replication.regions;\n\n        // Source and destination encryption are independent in Security\n        // Lake: a CMK source can replicate to an SSE-S3 rollup and vice\n        // versa. Grant `kms:Decrypt` on the source key only when the\n        // source lake uses a CMK, and grant `kms:Encrypt` /\n        // `kms:GenerateDataKey` on the destination keys only when any\n        // rollup bucket uses a CMK. The key ARNs are not derivable at\n        // synth time, so require the caller to supply them explicitly on\n        // the encrypted side (or pre-provision their own replication role\n        // via `replication.roleArn`).\n        if (usesCustomerManagedKey && !props.replication.sourceKmsKeyArn) {\n          throw new Error(\n            'StandardSecurityLake: a customer-managed `kmsKeyId` with ' +\n              'replication requires `replication.sourceKmsKeyArn` so the ' +\n              'generated replication role can `kms:Decrypt` source objects. ' +\n              'If any rollup Region bucket is also encrypted with a ' +\n              'customer-managed key, pass its ARN via ' +\n              '`replication.destinationKmsKeyArns`. Alternatively, ' +\n              'pre-provision the replication role yourself and pass its ARN ' +\n              'via `replication.roleArn`.',\n          );\n        }\n\n        const kmsStatements: PolicyStatement[] = [];\n        if (usesCustomerManagedKey && props.replication.sourceKmsKeyArn) {\n          kmsStatements.push(\n            new PolicyStatement({\n              sid: 'AllowDecryptSourceKmsKey',\n              actions: ['kms:Decrypt'],\n              resources: [props.replication.sourceKmsKeyArn],\n            }),\n          );\n        }\n        if (\n          props.replication.destinationKmsKeyArns &&\n          props.replication.destinationKmsKeyArns.length > 0\n        ) {\n          kmsStatements.push(\n            new PolicyStatement({\n              sid: 'AllowEncryptDestinationKmsKeys',\n              actions: ['kms:Encrypt', 'kms:GenerateDataKey'],\n              resources: props.replication.destinationKmsKeyArns,\n            }),\n          );\n        }\n\n        this.replicationRole = new Role(this, 'ReplicationRole', {\n          // Security Lake requires the replication role to live under the\n          // service-role/ path and start with `SecurityLake`. IAM role names\n          // are account-global, so include the source Region in the suffix to\n          // avoid collisions when the construct is deployed to multiple\n          // Regions in the same account.\n          path: '/service-role/',\n          roleName: `SecurityLakeS3ReplicationRole-${sourceRegion}`,\n          // Amazon S3 performs the cross-Region replication, so it (not the\n          // Security Lake service) must be allowed to assume this role.\n          assumedBy: new ServicePrincipal('s3.amazonaws.com'),\n          description:\n            'Role used by Amazon S3 to replicate Amazon Security Lake objects across Regions.',\n          // No AWS managed policy exists for this role; attach the inline\n          // policy documented by Security Lake.\n          // https://docs.aws.amazon.com/security-lake/latest/userguide/add-rollup-region.html\n          inlinePolicies: {\n            AmazonSecurityLakeS3ReplicationRolePolicy: new PolicyDocument({\n              statements: [\n                new PolicyStatement({\n                  sid: 'AllowReadS3ReplicationSetting',\n                  actions: [\n                    's3:ListBucket',\n                    's3:GetReplicationConfiguration',\n                    's3:GetObjectVersionForReplication',\n                    's3:GetObjectVersion',\n                    's3:GetObjectVersionAcl',\n                    's3:GetObjectVersionTagging',\n                    's3:GetObjectRetention',\n                    's3:GetObjectLegalHold',\n                  ],\n                  resources: [\n                    `arn:${Stack.of(this).partition}:s3:::aws-security-data-lake-${sourceRegion}*`,\n                    `arn:${Stack.of(this).partition}:s3:::aws-security-data-lake-${sourceRegion}*/*`,\n                  ],\n                  conditions: {\n                    StringEquals: {'s3:ResourceAccount': [account]},\n                  },\n                }),\n                new PolicyStatement({\n                  sid: 'AllowS3Replication',\n                  actions: [\n                    's3:ReplicateObject',\n                    's3:ReplicateDelete',\n                    's3:ReplicateTags',\n                    's3:GetObjectVersionTagging',\n                  ],\n                  resources: destinationRegions.flatMap((r) => [\n                    `arn:${Stack.of(this).partition}:s3:::aws-security-data-lake-${r}*/*`,\n                  ]),\n                  conditions: {\n                    StringEquals: {'s3:ResourceAccount': [account]},\n                  },\n                }),\n                ...kmsStatements,\n              ],\n            }),\n          },\n        });\n        replicationRoleArn = this.replicationRole.roleArn;\n      }\n      replicationConfiguration = {\n        regions: props.replication.regions,\n        roleArn: replicationRoleArn,\n      };\n    }\n\n    this.dataLake = new CfnDataLake(this, 'DataLake', {\n      metaStoreManagerRoleArn,\n      encryptionConfiguration,\n      lifecycleConfiguration,\n      replicationConfiguration,\n    });\n    if (this.lakeFormationServiceLinkedRole) {\n      this.dataLake.addDependency(this.lakeFormationServiceLinkedRole);\n    }\n\n    // Create AWS log sources sequentially using DependsOn, as required by\n    // Security Lake when more than one source is created in the same\n    // template.\n    let previous: CfnAwsLogSource | undefined;\n    for (const source of props?.logSources ?? []) {\n      const logSource = new CfnAwsLogSource(\n        this,\n        `LogSource${source.sourceName}`,\n        {\n          dataLakeArn: this.dataLake.attrArn,\n          sourceName: source.sourceName,\n          sourceVersion: source.sourceVersion ?? '2.0',\n          accounts: source.accounts ?? [Stack.of(this).account],\n        },\n      );\n      logSource.addDependency(this.dataLake);\n      if (previous) {\n        logSource.addDependency(previous);\n      }\n      previous = logSource;\n      this.logSources.push(logSource);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard-security-lake.js","sourceRoot":"","sources":["../../../src/aws-securitylake/lib/standard-security-lake.ts"],"names":[],"mappings":"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","sourcesContent":["import {Fn, RemovalPolicy, Stack} from 'aws-cdk-lib';\nimport {\n  CfnServiceLinkedRole,\n  ManagedPolicy,\n  PolicyDocument,\n  PolicyStatement,\n  Role,\n  ServicePrincipal,\n} from 'aws-cdk-lib/aws-iam';\nimport {\n  CfnAwsLogSource,\n  CfnDataLake,\n  CfnSubscriber,\n  CfnSubscriberNotification,\n} from 'aws-cdk-lib/aws-securitylake';\nimport {\n  AwsCustomResource,\n  AwsCustomResourcePolicy,\n  PhysicalResourceId,\n} from 'aws-cdk-lib/custom-resources';\nimport type {Construct} from 'constructs';\nimport {\n  ExtendedConstruct,\n  type ExtendedConstructProps,\n} from '../../aws-cdk/index';\n\n/**\n * The AWS-native log sources that Amazon Security Lake can ingest.\n *\n * @see https://docs.aws.amazon.com/security-lake/latest/userguide/internal-sources.html\n */\nexport enum AwsLogSourceName {\n  CLOUD_TRAIL_MGMT = 'CLOUD_TRAIL_MGMT',\n  LAMBDA_EXECUTION = 'LAMBDA_EXECUTION',\n  ROUTE53 = 'ROUTE53',\n  S3_DATA = 'S3_DATA',\n  SH_FINDINGS = 'SH_FINDINGS',\n  VPC_FLOW = 'VPC_FLOW',\n  EKS_AUDIT = 'EKS_AUDIT',\n  WAF = 'WAF',\n}\n\n/**\n * Properties for an individual AWS log source to enable on the data lake.\n */\nexport interface AwsLogSourceProps {\n  /**\n   * The name of the AWS log source to enable.\n   */\n  readonly sourceName: AwsLogSourceName | string;\n\n  /**\n   * The version of the AWS log source to enable.\n   *\n   * @default - '2.0'\n   */\n  readonly sourceVersion?: string;\n\n  /**\n   * The AWS accounts whose data should be collected for this source. If not\n   * provided, the data lake owner account is used.\n   *\n   * @default - [Stack.of(this).account]\n   */\n  readonly accounts?: string[];\n}\n\n/**\n * Lifecycle transition for Security Lake data.\n */\nexport interface SecurityLakeTransitionProps {\n  /**\n   * The number of days before data transitions to the given storage class.\n   */\n  readonly days: number;\n\n  /**\n   * The target S3 storage class. Supported values include `STANDARD_IA`,\n   * `ONEZONE_IA`, `INTELLIGENT_TIERING`, `GLACIER_IR`, `GLACIER` and\n   * `DEEP_ARCHIVE`.\n   */\n  readonly storageClass: string;\n}\n\n/**\n * Lifecycle configuration options for Security Lake managed S3 storage.\n */\nexport interface SecurityLakeLifecycleProps {\n  /**\n   * The number of days before Security Lake data is expired/deleted.\n   *\n   * @default - data is retained indefinitely\n   */\n  readonly expirationDays?: number;\n\n  /**\n   * Transitions applied to Security Lake data.\n   *\n   * @default - no transitions\n   */\n  readonly transitions?: SecurityLakeTransitionProps[];\n}\n\n/**\n * Replication configuration for Security Lake data.\n */\nexport interface SecurityLakeReplicationProps {\n  /**\n   * One or more rollup Regions to replicate data to.\n   */\n  readonly regions: string[];\n\n  /**\n   * The ARN of the IAM role Security Lake uses to replicate objects. If not\n   * provided, a role will be created automatically.\n   *\n   * @default - a new role is created\n   */\n  readonly roleArn?: string;\n\n  /**\n   * The ARN of the customer-managed KMS key encrypting the source\n   * (originating-Region) Security Lake bucket. Required when the enclosing\n   * `StandardSecurityLake` is configured with a customer-managed `kmsKeyId`\n   * and this construct creates the replication role (i.e. when `roleArn`\n   * is not provided); S3 needs `kms:Decrypt` on this key to read objects\n   * before replicating them. Not required when the source bucket uses\n   * S3-managed or AWS-managed encryption.\n   *\n   * This is independent of `destinationKmsKeyArns`: Security Lake rollup\n   * Regions may use their own encryption settings, so a CMK source can\n   * replicate to an SSE-S3 rollup and vice versa.\n   *\n   * @default - no KMS decrypt statement is added\n   */\n  readonly sourceKmsKeyArn?: string;\n\n  /**\n   * The ARNs of the customer-managed KMS keys encrypting the destination\n   * (rollup-Region) Security Lake buckets. Supply when any rollup Region's\n   * bucket uses a customer-managed KMS key so the replication role can\n   * `kms:Encrypt` / `kms:GenerateDataKey` against them. Not required when\n   * every rollup bucket uses S3-managed or AWS-managed encryption.\n   *\n   * This is independent of `sourceKmsKeyArn` and the source lake's\n   * `kmsKeyId`.\n   *\n   * @default - no KMS encrypt statement is added\n   */\n  readonly destinationKmsKeyArns?: string[];\n}\n\n/**\n * The AWS log sources a subscriber should receive. Each entry maps to the\n * same `sourceName`/`sourceVersion` pair used when enabling the source.\n */\nexport interface SecurityLakeSubscriberSourceProps {\n  /**\n   * The source name, e.g. `CLOUD_TRAIL_MGMT`.\n   */\n  readonly sourceName: AwsLogSourceName | string;\n\n  /**\n   * The source version.\n   *\n   * @default - '2.0'\n   */\n  readonly sourceVersion?: string;\n}\n\n/**\n * Properties for a Security Lake subscriber with S3-notification access.\n * Only the `S3` access type (asynchronous SQS notification of new objects)\n * is modelled; Lake Formation subscribers can be created directly against\n * the underlying `CfnSubscriber` L1.\n *\n * @see https://docs.aws.amazon.com/security-lake/latest/userguide/subscriber-management.html\n */\nexport interface SecurityLakeSubscriberProps {\n  /**\n   * The friendly name of the subscriber.\n   */\n  readonly subscriberName: string;\n\n  /**\n   * The AWS account id of the principal that will consume data (typically\n   * the SIEM / downstream account id).\n   */\n  readonly principal: string;\n\n  /**\n   * External id the subscriber must present when assuming the\n   * Security-Lake-managed role. Treat as a shared secret.\n   */\n  readonly externalId: string;\n\n  /**\n   * Log sources this subscriber receives. Each entry must correspond to a\n   * source that is enabled on the data lake.\n   */\n  readonly sources: SecurityLakeSubscriberSourceProps[];\n\n  /**\n   * Optional human-readable description.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n\n  /**\n   * Optional HTTPS endpoint for subscriber notifications. If omitted,\n   * Security Lake creates an SQS queue in the data-lake account and\n   * notifies the subscriber via SQS messages (recommended default — the\n   * SIEM polls the queue).\n   *\n   * When set, {@link httpsNotificationTargetRoleArn} is required.\n   *\n   * @default - SQS notification\n   */\n  readonly httpsNotificationEndpoint?: string;\n\n  /**\n   * IAM role ARN EventBridge assumes to invoke the HTTPS endpoint when\n   * {@link httpsNotificationEndpoint} is set. The role must trust\n   * `events.amazonaws.com` and have `events:InvokeApiDestination`\n   * permissions. The AWS console provisions this helper role\n   * automatically when a subscriber is created through the UI, but the\n   * CloudFormation / API path does **not** — so a fresh account must\n   * create and pass this role explicitly, or Security Lake will reject\n   * the subscriber-notification create call.\n   *\n   * Ignored when {@link httpsNotificationEndpoint} is omitted.\n   *\n   * @default - none; required when `httpsNotificationEndpoint` is set\n   */\n  readonly httpsNotificationTargetRoleArn?: string;\n\n  /**\n   * When set and the subscriber uses the default SQS notification path,\n   * the construct patches the Security-Lake-managed Main-Queue's\n   * `VisibilityTimeout` attribute to this value (seconds) via an\n   * `AwsCustomResource`. Needed because Security Lake auto-provisions\n   * the queue with a 300s visibility timeout, which is **less than** the\n   * default aes-siem es-loader Lambda timeout of 600s, causing the\n   * event-source-mapping create to be rejected with\n   * `\"The event source mapping's function timeout must be smaller than\n   * or equal to the queue's visibility timeout\"`.\n   *\n   * Set to a value `>=` your subscriber Lambda's timeout. 3600 is a\n   * safe default for aes-siem.\n   *\n   * Ignored when {@link httpsNotificationEndpoint} is set.\n   *\n   * @default - no patch; the queue keeps the Security-Lake-provisioned 300s\n   */\n  readonly sqsVisibilityTimeoutSeconds?: number;\n}\n\n/**\n * Properties for StandardSecurityLake.\n */\nexport interface StandardSecurityLakeProps extends ExtendedConstructProps {\n  /**\n   * The KMS key id to use to encrypt data stored by Security Lake. Use the\n   * literal string `S3_MANAGED_KEY` to use S3 managed keys (SSE-S3). Omit to\n   * let Security Lake use its default managed key.\n   *\n   * @default - Security Lake managed encryption\n   */\n  readonly kmsKeyId?: string;\n\n  /**\n   * The ARN of the role used by Security Lake to manage the AWS Glue\n   * metastore. If omitted, a role is created with the\n   * `AmazonSecurityLakeMetastoreManager` AWS managed policy attached.\n   *\n   * @default - a role is created\n   */\n  readonly metaStoreManagerRoleArn?: string;\n\n  /**\n   * The ARN of the customer-managed KMS key used to encrypt Security Lake\n   * data. Required when `kmsKeyId` is set to a customer-managed key and this\n   * construct creates the metastore manager role (i.e. when\n   * `metaStoreManagerRoleArn` is not provided). The metastore manager\n   * Lambda must decrypt and (re)encrypt Security Lake metadata; the AWS\n   * managed policy `AmazonSecurityLakeMetastoreManager` does not include\n   * KMS permissions, so without this grant the stack deploys but partition\n   * updates and subscriber queries silently fail. Not required when\n   * `kmsKeyId` is unset or set to `S3_MANAGED_KEY`.\n   *\n   * @default - no KMS statement is added (sufficient when the data lake\n   * uses Security Lake defaults or SSE-S3)\n   */\n  readonly metaStoreManagerKmsKeyArn?: string;\n\n  /**\n   * Lifecycle configuration for the Security Lake managed S3 storage.\n   *\n   * @default - Security Lake defaults\n   */\n  readonly lifecycle?: SecurityLakeLifecycleProps;\n\n  /**\n   * Replication configuration for the Security Lake managed S3 storage.\n   *\n   * @default - no replication\n   */\n  readonly replication?: SecurityLakeReplicationProps;\n\n  /**\n   * The AWS native log sources to enable on the data lake. Sources are\n   * created sequentially using `DependsOn` as required by Security Lake.\n   *\n   * @default - no log sources are enabled\n   */\n  readonly logSources?: AwsLogSourceProps[];\n\n  /**\n   * Whether to create the `AWSServiceRoleForLakeFormationDataAccess`\n   * service-linked role. Security Lake requires this role to exist in the\n   * account before a data lake can be created; however the role is a\n   * singleton per account and is frequently auto-created on first use of\n   * Lake Formation. Enable this only when you know the role does not yet\n   * exist in the account, otherwise stack creation will fail with\n   * `has been taken in this account`.\n   *\n   * The data lake will `DependsOn` this role when it is created so ordering\n   * is handled automatically.\n   *\n   * @default false\n   */\n  readonly createLakeFormationServiceLinkedRole?: boolean;\n\n  /**\n   * Subscribers that should receive S3 notifications of new Security Lake\n   * objects. Each entry creates an `AWS::SecurityLake::Subscriber` (access\n   * type `S3`) plus an `AWS::SecurityLake::SubscriberNotification`.\n   *\n   * @default - no subscribers are created\n   */\n  readonly subscribers?: SecurityLakeSubscriberProps[];\n}\n\n/**\n * Standard Amazon Security Lake. Wraps the Security Lake L1 constructs to\n * stand up a data lake with an optional set of AWS native log sources\n * enabled, a metastore manager role, lifecycle policy and replication.\n *\n * Where this construct does not meet your needs, use the underlying\n * `CfnDataLake` and `CfnAwsLogSource` constructs directly.\n */\nexport class StandardSecurityLake extends ExtendedConstruct {\n  /**\n   * The underlying `CfnDataLake` resource.\n   */\n  readonly dataLake: CfnDataLake;\n\n  /**\n   * The IAM role used by Security Lake to manage the Glue metastore. When\n   * `metaStoreManagerRoleArn` is provided this will be `undefined`.\n   */\n  readonly metaStoreManagerRole?: Role;\n\n  /**\n   * The IAM role used by Security Lake to replicate objects. Only created\n   * when replication is enabled and no `roleArn` was supplied.\n   */\n  readonly replicationRole?: Role;\n\n  /**\n   * The Lake Formation `AWSServiceRoleForLakeFormationDataAccess`\n   * service-linked role, when it was provisioned by this construct.\n   */\n  readonly lakeFormationServiceLinkedRole?: CfnServiceLinkedRole;\n\n  /**\n   * The `CfnAwsLogSource` resources created by this construct, in the order\n   * they were declared.\n   */\n  readonly logSources: CfnAwsLogSource[] = [];\n\n  /**\n   * The `CfnSubscriber` resources created by this construct, in the order\n   * they were declared.\n   */\n  readonly subscribers: CfnSubscriber[] = [];\n\n  /**\n   * The `CfnSubscriberNotification` resources created by this construct,\n   * one per subscriber, in the order they were declared.\n   */\n  readonly subscriberNotifications: CfnSubscriberNotification[] = [];\n\n  constructor(scope: Construct, id: string, props?: StandardSecurityLakeProps) {\n    super(scope, id, props);\n\n    // Optional Lake Formation service-linked role. Security Lake requires\n    // this SLR to exist in the account before a data lake can be created.\n    if (props?.createLakeFormationServiceLinkedRole) {\n      this.lakeFormationServiceLinkedRole = new CfnServiceLinkedRole(\n        this,\n        'LakeFormationServiceLinkedRole',\n        {\n          awsServiceName: 'lakeformation.amazonaws.com',\n          description:\n            'Service-linked role used by AWS Lake Formation to access registered S3 locations. Required by Amazon Security Lake.',\n        },\n      );\n      // The Lake Formation SLR is an account singleton that is frequently\n      // shared with other stacks and consoles. Retain it on\n      // stack-delete/opt-out so toggling this flag off (or removing this\n      // construct) does not strip Lake Formation access account-wide.\n      this.lakeFormationServiceLinkedRole.applyRemovalPolicy(\n        RemovalPolicy.RETAIN,\n      );\n    }\n\n    // Metastore manager role.\n    let metaStoreManagerRoleArn = props?.metaStoreManagerRoleArn;\n    const usesCustomerManagedKey =\n      props?.kmsKeyId !== undefined && props.kmsKeyId !== 'S3_MANAGED_KEY';\n    if (!metaStoreManagerRoleArn) {\n      // When the data lake is encrypted with a customer-managed KMS key,\n      // the metastore manager Lambda must be able to Decrypt / Encrypt /\n      // GenerateDataKey against that key. The AWS managed policy\n      // `AmazonSecurityLakeMetastoreManager` does NOT include KMS actions,\n      // so without this grant CFN deployment succeeds but partition\n      // updates and subscriber queries fail at runtime. The key ARN is\n      // not derivable at synth time, so require the caller to supply it\n      // explicitly via `metaStoreManagerKmsKeyArn` or pre-provision their\n      // own metastore manager role via `metaStoreManagerRoleArn`.\n      if (usesCustomerManagedKey && !props?.metaStoreManagerKmsKeyArn) {\n        throw new Error(\n          'StandardSecurityLake: a customer-managed `kmsKeyId` requires ' +\n            '`metaStoreManagerKmsKeyArn` so the generated metastore manager ' +\n            'role can be granted the necessary KMS permissions. ' +\n            'Alternatively, pre-provision the metastore manager role ' +\n            'yourself and pass its ARN via `metaStoreManagerRoleArn`.',\n        );\n      }\n      const metaStoreInlinePolicies: {[name: string]: PolicyDocument} = {};\n      if (usesCustomerManagedKey && props?.metaStoreManagerKmsKeyArn) {\n        metaStoreInlinePolicies.AmazonSecurityLakeMetastoreManagerKmsPolicy =\n          new PolicyDocument({\n            statements: [\n              new PolicyStatement({\n                sid: 'AllowMetaStoreManagerKmsAccess',\n                actions: [\n                  'kms:Decrypt',\n                  'kms:Encrypt',\n                  'kms:GenerateDataKey',\n                  'kms:DescribeKey',\n                ],\n                resources: [props.metaStoreManagerKmsKeyArn],\n              }),\n            ],\n          });\n      }\n      this.metaStoreManagerRole = new Role(this, 'MetaStoreManagerRole', {\n        // The partition-updater Lambda functions created by Security Lake are\n        // hard-coded to assume a role named\n        // `AmazonSecurityLakeMetaStoreManagerV2` under the `/service-role/`\n        // path and do not honor an arbitrary role ARN. Without a matching\n        // role name, CFN deployment and `CreateDataLake` succeed but the\n        // partition updater silently fails and subscribers cannot query\n        // replicated objects. The role name is account-global; for\n        // multi-Region deploys in the same account pass\n        // `metaStoreManagerRoleArn` for all but one Region.\n        path: '/service-role/',\n        roleName: 'AmazonSecurityLakeMetaStoreManagerV2',\n        assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n        description:\n          'Role used by Amazon Security Lake metastore manager Lambda to manage the AWS Glue metastore.',\n        managedPolicies: [\n          ManagedPolicy.fromAwsManagedPolicyName(\n            'service-role/AmazonSecurityLakeMetastoreManager',\n          ),\n        ],\n        inlinePolicies: metaStoreInlinePolicies,\n      });\n      metaStoreManagerRoleArn = this.metaStoreManagerRole.roleArn;\n    }\n\n    // Encryption configuration.\n    const encryptionConfiguration:\n      | CfnDataLake.EncryptionConfigurationProperty\n      | undefined =\n      props?.kmsKeyId !== undefined ? {kmsKeyId: props.kmsKeyId} : undefined;\n\n    // Lifecycle configuration.\n    let lifecycleConfiguration:\n      | CfnDataLake.LifecycleConfigurationProperty\n      | undefined;\n    if (props?.lifecycle) {\n      lifecycleConfiguration = {\n        expiration:\n          props.lifecycle.expirationDays !== undefined\n            ? {days: props.lifecycle.expirationDays}\n            : undefined,\n        transitions: props.lifecycle.transitions?.map((t) => ({\n          days: t.days,\n          storageClass: t.storageClass,\n        })),\n      };\n    }\n\n    // Replication configuration.\n    let replicationConfiguration:\n      | CfnDataLake.ReplicationConfigurationProperty\n      | undefined;\n    if (props?.replication) {\n      let replicationRoleArn = props.replication.roleArn;\n      if (!replicationRoleArn) {\n        const account = Stack.of(this).account;\n        const sourceRegion = Stack.of(this).region;\n        const destinationRegions = props.replication.regions;\n\n        // Source and destination encryption are independent in Security\n        // Lake: a CMK source can replicate to an SSE-S3 rollup and vice\n        // versa. Grant `kms:Decrypt` on the source key only when the\n        // source lake uses a CMK, and grant `kms:Encrypt` /\n        // `kms:GenerateDataKey` on the destination keys only when any\n        // rollup bucket uses a CMK. The key ARNs are not derivable at\n        // synth time, so require the caller to supply them explicitly on\n        // the encrypted side (or pre-provision their own replication role\n        // via `replication.roleArn`).\n        if (usesCustomerManagedKey && !props.replication.sourceKmsKeyArn) {\n          throw new Error(\n            'StandardSecurityLake: a customer-managed `kmsKeyId` with ' +\n              'replication requires `replication.sourceKmsKeyArn` so the ' +\n              'generated replication role can `kms:Decrypt` source objects. ' +\n              'If any rollup Region bucket is also encrypted with a ' +\n              'customer-managed key, pass its ARN via ' +\n              '`replication.destinationKmsKeyArns`. Alternatively, ' +\n              'pre-provision the replication role yourself and pass its ARN ' +\n              'via `replication.roleArn`.',\n          );\n        }\n\n        const kmsStatements: PolicyStatement[] = [];\n        if (usesCustomerManagedKey && props.replication.sourceKmsKeyArn) {\n          kmsStatements.push(\n            new PolicyStatement({\n              sid: 'AllowDecryptSourceKmsKey',\n              actions: ['kms:Decrypt'],\n              resources: [props.replication.sourceKmsKeyArn],\n            }),\n          );\n        }\n        if (\n          props.replication.destinationKmsKeyArns &&\n          props.replication.destinationKmsKeyArns.length > 0\n        ) {\n          kmsStatements.push(\n            new PolicyStatement({\n              sid: 'AllowEncryptDestinationKmsKeys',\n              actions: ['kms:Encrypt', 'kms:GenerateDataKey'],\n              resources: props.replication.destinationKmsKeyArns,\n            }),\n          );\n        }\n\n        this.replicationRole = new Role(this, 'ReplicationRole', {\n          // Security Lake requires the replication role to live under the\n          // service-role/ path and start with `SecurityLake`. IAM role names\n          // are account-global, so include the source Region in the suffix to\n          // avoid collisions when the construct is deployed to multiple\n          // Regions in the same account.\n          path: '/service-role/',\n          roleName: `SecurityLakeS3ReplicationRole-${sourceRegion}`,\n          // Amazon S3 performs the cross-Region replication, so it (not the\n          // Security Lake service) must be allowed to assume this role.\n          assumedBy: new ServicePrincipal('s3.amazonaws.com'),\n          description:\n            'Role used by Amazon S3 to replicate Amazon Security Lake objects across Regions.',\n          // No AWS managed policy exists for this role; attach the inline\n          // policy documented by Security Lake.\n          // https://docs.aws.amazon.com/security-lake/latest/userguide/add-rollup-region.html\n          inlinePolicies: {\n            AmazonSecurityLakeS3ReplicationRolePolicy: new PolicyDocument({\n              statements: [\n                new PolicyStatement({\n                  sid: 'AllowReadS3ReplicationSetting',\n                  actions: [\n                    's3:ListBucket',\n                    's3:GetReplicationConfiguration',\n                    's3:GetObjectVersionForReplication',\n                    's3:GetObjectVersion',\n                    's3:GetObjectVersionAcl',\n                    's3:GetObjectVersionTagging',\n                    's3:GetObjectRetention',\n                    's3:GetObjectLegalHold',\n                  ],\n                  resources: [\n                    `arn:${Stack.of(this).partition}:s3:::aws-security-data-lake-${sourceRegion}*`,\n                    `arn:${Stack.of(this).partition}:s3:::aws-security-data-lake-${sourceRegion}*/*`,\n                  ],\n                  conditions: {\n                    StringEquals: {'s3:ResourceAccount': [account]},\n                  },\n                }),\n                new PolicyStatement({\n                  sid: 'AllowS3Replication',\n                  actions: [\n                    's3:ReplicateObject',\n                    's3:ReplicateDelete',\n                    's3:ReplicateTags',\n                    's3:GetObjectVersionTagging',\n                  ],\n                  resources: destinationRegions.flatMap((r) => [\n                    `arn:${Stack.of(this).partition}:s3:::aws-security-data-lake-${r}*/*`,\n                  ]),\n                  conditions: {\n                    StringEquals: {'s3:ResourceAccount': [account]},\n                  },\n                }),\n                ...kmsStatements,\n              ],\n            }),\n          },\n        });\n        replicationRoleArn = this.replicationRole.roleArn;\n      }\n      replicationConfiguration = {\n        regions: props.replication.regions,\n        roleArn: replicationRoleArn,\n      };\n    }\n\n    this.dataLake = new CfnDataLake(this, 'DataLake', {\n      metaStoreManagerRoleArn,\n      encryptionConfiguration,\n      lifecycleConfiguration,\n      replicationConfiguration,\n    });\n    if (this.lakeFormationServiceLinkedRole) {\n      this.dataLake.addDependency(this.lakeFormationServiceLinkedRole);\n    }\n\n    // Create AWS log sources sequentially using DependsOn, as required by\n    // Security Lake when more than one source is created in the same\n    // template.\n    let previous: CfnAwsLogSource | undefined;\n    for (const source of props?.logSources ?? []) {\n      const logSource = new CfnAwsLogSource(\n        this,\n        `LogSource${source.sourceName}`,\n        {\n          dataLakeArn: this.dataLake.attrArn,\n          sourceName: source.sourceName,\n          sourceVersion: source.sourceVersion ?? '2.0',\n          accounts: source.accounts ?? [Stack.of(this).account],\n        },\n      );\n      logSource.addDependency(this.dataLake);\n      if (previous) {\n        logSource.addDependency(previous);\n      }\n      previous = logSource;\n      this.logSources.push(logSource);\n    }\n\n    // Subscribers. Each entry becomes a `CfnSubscriber` with `accessTypes:\n    // ['S3']` plus a sibling `CfnSubscriberNotification`. The notification\n    // defaults to SQS (Security Lake creates the queue in this account);\n    // callers can switch to HTTPS by passing `httpsNotificationEndpoint`.\n    for (const sub of props?.subscribers ?? []) {\n      const subscriber = new CfnSubscriber(\n        this,\n        `Subscriber${sub.subscriberName}`,\n        {\n          accessTypes: ['S3'],\n          dataLakeArn: this.dataLake.attrArn,\n          subscriberName: sub.subscriberName,\n          subscriberDescription: sub.description,\n          subscriberIdentity: {\n            externalId: sub.externalId,\n            principal: sub.principal,\n          },\n          sources: sub.sources.map((s) => ({\n            awsLogSource: {\n              sourceName: s.sourceName,\n              sourceVersion: s.sourceVersion ?? '2.0',\n            },\n          })),\n        },\n      );\n      subscriber.addDependency(this.dataLake);\n      // Subscriber creation requires the AwsLogSource to exist for every\n      // source it references; chain through the last log source we created\n      // so CFN waits for ingestion to be enabled.\n      for (const ls of this.logSources) {\n        subscriber.addDependency(ls);\n      }\n      this.subscribers.push(subscriber);\n\n      if (\n        sub.httpsNotificationEndpoint &&\n        !sub.httpsNotificationTargetRoleArn\n      ) {\n        throw new Error(\n          `StandardSecurityLake: subscriber \"${sub.subscriberName}\" sets ` +\n            '`httpsNotificationEndpoint` but no ' +\n            '`httpsNotificationTargetRoleArn`. The CloudFormation/API path ' +\n            'does not auto-provision the EventBridge invocation role (only ' +\n            'the AWS console does). Create a role trusted by ' +\n            '`events.amazonaws.com` with `events:InvokeApiDestination` on ' +\n            'the target endpoint and pass its ARN as ' +\n            '`httpsNotificationTargetRoleArn`.',\n        );\n      }\n\n      const notification = new CfnSubscriberNotification(\n        this,\n        `SubscriberNotification${sub.subscriberName}`,\n        {\n          subscriberArn: subscriber.attrSubscriberArn,\n          notificationConfiguration: sub.httpsNotificationEndpoint\n            ? {\n                httpsNotificationConfiguration: {\n                  endpoint: sub.httpsNotificationEndpoint,\n                  targetRoleArn: sub.httpsNotificationTargetRoleArn as string,\n                },\n              }\n            : {\n                sqsNotificationConfiguration: {},\n              },\n        },\n      );\n      notification.addDependency(subscriber);\n      this.subscriberNotifications.push(notification);\n\n      // Patch the Security-Lake-managed SQS Main-Queue's visibility\n      // timeout. Needed because Security Lake auto-provisions the queue\n      // with 300s, less than the aes-siem es-loader Lambda timeout (600s\n      // default), causing event-source-mapping creation to fail with\n      // \"The event source mapping's function timeout must be smaller\n      // than or equal to the queue's visibility timeout.\"\n      if (\n        !sub.httpsNotificationEndpoint &&\n        sub.sqsVisibilityTimeoutSeconds !== undefined\n      ) {\n        const timeout = sub.sqsVisibilityTimeoutSeconds;\n        const stack = Stack.of(this);\n        // The notification resource returns the queue ARN via\n        // `SubscriberEndpoint`. Convert to a queue URL for the SQS SDK.\n        // ARN: arn:<partition>:sqs:<region>:<account>:<name>\n        // URL: https://sqs.<region>.<url-suffix>/<account>/<name>\n        //\n        // The URL suffix is partition-aware (`amazonaws.com`,\n        // `amazonaws.com.cn`, `c2s.ic.gov`, etc.); hard-coding\n        // `amazonaws.com` breaks `aws-cn` and GovCloud. Use the stack's\n        // `urlSuffix` token so CloudFormation substitutes the right\n        // value at deploy time.\n        const queueName = Fn.select(\n          5,\n          Fn.split(':', notification.attrSubscriberEndpoint),\n        );\n        const queueUrl = `https://sqs.${stack.region}.${stack.urlSuffix}/${stack.account}/${queueName}`;\n        const patch = new AwsCustomResource(\n          this,\n          `SubscriberQueueVisibilityPatch${sub.subscriberName}`,\n          {\n            onCreate: {\n              service: 'SQS',\n              action: 'setQueueAttributes',\n              parameters: {\n                QueueUrl: queueUrl,\n                Attributes: {VisibilityTimeout: timeout.toString()},\n              },\n              physicalResourceId: PhysicalResourceId.of(\n                `${sub.subscriberName}-visibility-${timeout}`,\n              ),\n            },\n            onUpdate: {\n              service: 'SQS',\n              action: 'setQueueAttributes',\n              parameters: {\n                QueueUrl: queueUrl,\n                Attributes: {VisibilityTimeout: timeout.toString()},\n              },\n              physicalResourceId: PhysicalResourceId.of(\n                `${sub.subscriberName}-visibility-${timeout}`,\n              ),\n            },\n            policy: AwsCustomResourcePolicy.fromStatements([\n              new PolicyStatement({\n                actions: ['sqs:SetQueueAttributes'],\n                // Scope to the exact queue ARN exposed by the\n                // SubscriberNotification resource\n                // (`attrSubscriberEndpoint`), which is already an SQS\n                // ARN. Using the token means CloudFormation substitutes\n                // the real queue ARN at deploy-time, so the custom-\n                // resource role cannot be abused to modify unrelated\n                // queues in the account.\n                resources: [notification.attrSubscriberEndpoint],\n              }),\n            ]),\n          },\n        );\n        patch.node.addDependency(notification);\n      }\n    }\n  }\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "truemark-cdk-lib",
   "description": "AWS CDK constructs created by TrueMark",
-  "version": "1.29.0",
+  "version": "1.31.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "typesVersions": {
@@ -103,7 +103,7 @@
   ],
   "devDependencies": {
     "@aws-sdk/client-dynamodb": "^3.996.2",
-    "@aws-sdk/client-elastic-load-balancing-v2": "^3.996.2",
+    "@aws-sdk/client-elastic-load-balancing-v2": "3.1050.0",
     "@aws-sdk/util-dynamodb": "^3.996.2",
     "@biomejs/biome": "2.4.5",
     "@opensearch-project/opensearch": "^2.13.0",