truemark-cdk-lib 1.28.2 → 1.30.0

package/dist/aws-securitylake/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/index';

package/dist/aws-securitylake/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/index"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXdzLXNlY3VyaXR5bGFrZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvaW5kZXgnO1xuIl19

package/dist/aws-securitylake/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './standard-security-lake';

package/dist/aws-securitylake/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./standard-security-lake"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzLXNlY3VyaXR5bGFrZS9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDJEQUF5QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3RhbmRhcmQtc2VjdXJpdHktbGFrZSc7XG4iXX0=

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

@@ -0,0 +1,337 @@
+import { CfnServiceLinkedRole, Role } from 'aws-cdk-lib/aws-iam';
+import { CfnAwsLogSource, CfnDataLake, CfnSubscriber, CfnSubscriberNotification } from 'aws-cdk-lib/aws-securitylake';
+import type { Construct } from 'constructs';
+import { ExtendedConstruct, type ExtendedConstructProps } from '../../aws-cdk/index';
+/**
+ * The AWS-native log sources that Amazon Security Lake can ingest.
+ *
+ * @see https://docs.aws.amazon.com/security-lake/latest/userguide/internal-sources.html
+ */
+export declare enum AwsLogSourceName {
+    CLOUD_TRAIL_MGMT = "CLOUD_TRAIL_MGMT",
+    LAMBDA_EXECUTION = "LAMBDA_EXECUTION",
+    ROUTE53 = "ROUTE53",
+    S3_DATA = "S3_DATA",
+    SH_FINDINGS = "SH_FINDINGS",
+    VPC_FLOW = "VPC_FLOW",
+    EKS_AUDIT = "EKS_AUDIT",
+    WAF = "WAF"
+}
+/**
+ * Properties for an individual AWS log source to enable on the data lake.
+ */
+export interface AwsLogSourceProps {
+    /**
+     * The name of the AWS log source to enable.
+     */
+    readonly sourceName: AwsLogSourceName | string;
+    /**
+     * The version of the AWS log source to enable.
+     *
+     * @default - '2.0'
+     */
+    readonly sourceVersion?: string;
+    /**
+     * The AWS accounts whose data should be collected for this source. If not
+     * provided, the data lake owner account is used.
+     *
+     * @default - [Stack.of(this).account]
+     */
+    readonly accounts?: string[];
+}
+/**
+ * Lifecycle transition for Security Lake data.
+ */
+export interface SecurityLakeTransitionProps {
+    /**
+     * The number of days before data transitions to the given storage class.
+     */
+    readonly days: number;
+    /**
+     * The target S3 storage class. Supported values include `STANDARD_IA`,
+     * `ONEZONE_IA`, `INTELLIGENT_TIERING`, `GLACIER_IR`, `GLACIER` and
+     * `DEEP_ARCHIVE`.
+     */
+    readonly storageClass: string;
+}
+/**
+ * Lifecycle configuration options for Security Lake managed S3 storage.
+ */
+export interface SecurityLakeLifecycleProps {
+    /**
+     * The number of days before Security Lake data is expired/deleted.
+     *
+     * @default - data is retained indefinitely
+     */
+    readonly expirationDays?: number;
+    /**
+     * Transitions applied to Security Lake data.
+     *
+     * @default - no transitions
+     */
+    readonly transitions?: SecurityLakeTransitionProps[];
+}
+/**
+ * Replication configuration for Security Lake data.
+ */
+export interface SecurityLakeReplicationProps {
+    /**
+     * One or more rollup Regions to replicate data to.
+     */
+    readonly regions: string[];
+    /**
+     * The ARN of the IAM role Security Lake uses to replicate objects. If not
+     * provided, a role will be created automatically.
+     *
+     * @default - a new role is created
+     */
+    readonly roleArn?: string;
+    /**
+     * The ARN of the customer-managed KMS key encrypting the source
+     * (originating-Region) Security Lake bucket. Required when the enclosing
+     * `StandardSecurityLake` is configured with a customer-managed `kmsKeyId`
+     * and this construct creates the replication role (i.e. when `roleArn`
+     * is not provided); S3 needs `kms:Decrypt` on this key to read objects
+     * before replicating them. Not required when the source bucket uses
+     * S3-managed or AWS-managed encryption.
+     *
+     * This is independent of `destinationKmsKeyArns`: Security Lake rollup
+     * Regions may use their own encryption settings, so a CMK source can
+     * replicate to an SSE-S3 rollup and vice versa.
+     *
+     * @default - no KMS decrypt statement is added
+     */
+    readonly sourceKmsKeyArn?: string;
+    /**
+     * The ARNs of the customer-managed KMS keys encrypting the destination
+     * (rollup-Region) Security Lake buckets. Supply when any rollup Region's
+     * bucket uses a customer-managed KMS key so the replication role can
+     * `kms:Encrypt` / `kms:GenerateDataKey` against them. Not required when
+     * every rollup bucket uses S3-managed or AWS-managed encryption.
+     *
+     * This is independent of `sourceKmsKeyArn` and the source lake's
+     * `kmsKeyId`.
+     *
+     * @default - no KMS encrypt statement is added
+     */
+    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.
+ */
+export interface StandardSecurityLakeProps extends ExtendedConstructProps {
+    /**
+     * The KMS key id to use to encrypt data stored by Security Lake. Use the
+     * literal string `S3_MANAGED_KEY` to use S3 managed keys (SSE-S3). Omit to
+     * let Security Lake use its default managed key.
+     *
+     * @default - Security Lake managed encryption
+     */
+    readonly kmsKeyId?: string;
+    /**
+     * The ARN of the role used by Security Lake to manage the AWS Glue
+     * metastore. If omitted, a role is created with the
+     * `AmazonSecurityLakeMetastoreManager` AWS managed policy attached.
+     *
+     * @default - a role is created
+     */
+    readonly metaStoreManagerRoleArn?: string;
+    /**
+     * The ARN of the customer-managed KMS key used to encrypt Security Lake
+     * data. Required when `kmsKeyId` is set to a customer-managed key and this
+     * construct creates the metastore manager role (i.e. when
+     * `metaStoreManagerRoleArn` is not provided). The metastore manager
+     * Lambda must decrypt and (re)encrypt Security Lake metadata; the AWS
+     * managed policy `AmazonSecurityLakeMetastoreManager` does not include
+     * KMS permissions, so without this grant the stack deploys but partition
+     * updates and subscriber queries silently fail. Not required when
+     * `kmsKeyId` is unset or set to `S3_MANAGED_KEY`.
+     *
+     * @default - no KMS statement is added (sufficient when the data lake
+     * uses Security Lake defaults or SSE-S3)
+     */
+    readonly metaStoreManagerKmsKeyArn?: string;
+    /**
+     * Lifecycle configuration for the Security Lake managed S3 storage.
+     *
+     * @default - Security Lake defaults
+     */
+    readonly lifecycle?: SecurityLakeLifecycleProps;
+    /**
+     * Replication configuration for the Security Lake managed S3 storage.
+     *
+     * @default - no replication
+     */
+    readonly replication?: SecurityLakeReplicationProps;
+    /**
+     * The AWS native log sources to enable on the data lake. Sources are
+     * created sequentially using `DependsOn` as required by Security Lake.
+     *
+     * @default - no log sources are enabled
+     */
+    readonly logSources?: AwsLogSourceProps[];
+    /**
+     * Whether to create the `AWSServiceRoleForLakeFormationDataAccess`
+     * service-linked role. Security Lake requires this role to exist in the
+     * account before a data lake can be created; however the role is a
+     * singleton per account and is frequently auto-created on first use of
+     * Lake Formation. Enable this only when you know the role does not yet
+     * exist in the account, otherwise stack creation will fail with
+     * `has been taken in this account`.
+     *
+     * The data lake will `DependsOn` this role when it is created so ordering
+     * is handled automatically.
+     *
+     * @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
+ * stand up a data lake with an optional set of AWS native log sources
+ * enabled, a metastore manager role, lifecycle policy and replication.
+ *
+ * Where this construct does not meet your needs, use the underlying
+ * `CfnDataLake` and `CfnAwsLogSource` constructs directly.
+ */
+export declare class StandardSecurityLake extends ExtendedConstruct {
+    /**
+     * The underlying `CfnDataLake` resource.
+     */
+    readonly dataLake: CfnDataLake;
+    /**
+     * The IAM role used by Security Lake to manage the Glue metastore. When
+     * `metaStoreManagerRoleArn` is provided this will be `undefined`.
+     */
+    readonly metaStoreManagerRole?: Role;
+    /**
+     * The IAM role used by Security Lake to replicate objects. Only created
+     * when replication is enabled and no `roleArn` was supplied.
+     */
+    readonly replicationRole?: Role;
+    /**
+     * The Lake Formation `AWSServiceRoleForLakeFormationDataAccess`
+     * service-linked role, when it was provisioned by this construct.
+     */
+    readonly lakeFormationServiceLinkedRole?: CfnServiceLinkedRole;
+    /**
+     * The `CfnAwsLogSource` resources created by this construct, in the order
+     * 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

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.
+ *
+ * @see https://docs.aws.amazon.com/security-lake/latest/userguide/internal-sources.html
+ */
+var AwsLogSourceName;
+(function (AwsLogSourceName) {
+    AwsLogSourceName["CLOUD_TRAIL_MGMT"] = "CLOUD_TRAIL_MGMT";
+    AwsLogSourceName["LAMBDA_EXECUTION"] = "LAMBDA_EXECUTION";
+    AwsLogSourceName["ROUTE53"] = "ROUTE53";
+    AwsLogSourceName["S3_DATA"] = "S3_DATA";
+    AwsLogSourceName["SH_FINDINGS"] = "SH_FINDINGS";
+    AwsLogSourceName["VPC_FLOW"] = "VPC_FLOW";
+    AwsLogSourceName["EKS_AUDIT"] = "EKS_AUDIT";
+    AwsLogSourceName["WAF"] = "WAF";
+})(AwsLogSourceName || (exports.AwsLogSourceName = AwsLogSourceName = {}));
+/**
+ * Standard Amazon Security Lake. Wraps the Security Lake L1 constructs to
+ * stand up a data lake with an optional set of AWS native log sources
+ * enabled, a metastore manager role, lifecycle policy and replication.
+ *
+ * Where this construct does not meet your needs, use the underlying
+ * `CfnDataLake` and `CfnAwsLogSource` constructs directly.
+ */
+class StandardSecurityLake extends index_1.ExtendedConstruct {
+    constructor(scope, id, props) {
+        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) {
+            this.lakeFormationServiceLinkedRole = new aws_iam_1.CfnServiceLinkedRole(this, 'LakeFormationServiceLinkedRole', {
+                awsServiceName: 'lakeformation.amazonaws.com',
+                description: 'Service-linked role used by AWS Lake Formation to access registered S3 locations. Required by Amazon Security Lake.',
+            });
+            // The Lake Formation SLR is an account singleton that is frequently
+            // shared with other stacks and consoles. Retain it on
+            // stack-delete/opt-out so toggling this flag off (or removing this
+            // construct) does not strip Lake Formation access account-wide.
+            this.lakeFormationServiceLinkedRole.applyRemovalPolicy(aws_cdk_lib_1.RemovalPolicy.RETAIN);
+        }
+        // Metastore manager role.
+        let metaStoreManagerRoleArn = props === null || props === void 0 ? void 0 : props.metaStoreManagerRoleArn;
+        const usesCustomerManagedKey = (props === null || props === void 0 ? void 0 : props.kmsKeyId) !== undefined && props.kmsKeyId !== 'S3_MANAGED_KEY';
+        if (!metaStoreManagerRoleArn) {
+            // When the data lake is encrypted with a customer-managed KMS key,
+            // the metastore manager Lambda must be able to Decrypt / Encrypt /
+            // GenerateDataKey against that key. The AWS managed policy
+            // `AmazonSecurityLakeMetastoreManager` does NOT include KMS actions,
+            // so without this grant CFN deployment succeeds but partition
+            // updates and subscriber queries fail at runtime. The key ARN is
+            // not derivable at synth time, so require the caller to supply it
+            // explicitly via `metaStoreManagerKmsKeyArn` or pre-provision their
+            // own metastore manager role via `metaStoreManagerRoleArn`.
+            if (usesCustomerManagedKey && !(props === null || props === void 0 ? void 0 : props.metaStoreManagerKmsKeyArn)) {
+                throw new Error('StandardSecurityLake: a customer-managed `kmsKeyId` requires ' +
+                    '`metaStoreManagerKmsKeyArn` so the generated metastore manager ' +
+                    'role can be granted the necessary KMS permissions. ' +
+                    'Alternatively, pre-provision the metastore manager role ' +
+                    'yourself and pass its ARN via `metaStoreManagerRoleArn`.');
+            }
+            const metaStoreInlinePolicies = {};
+            if (usesCustomerManagedKey && (props === null || props === void 0 ? void 0 : props.metaStoreManagerKmsKeyArn)) {
+                metaStoreInlinePolicies.AmazonSecurityLakeMetastoreManagerKmsPolicy =
+                    new aws_iam_1.PolicyDocument({
+                        statements: [
+                            new aws_iam_1.PolicyStatement({
+                                sid: 'AllowMetaStoreManagerKmsAccess',
+                                actions: [
+                                    'kms:Decrypt',
+                                    'kms:Encrypt',
+                                    'kms:GenerateDataKey',
+                                    'kms:DescribeKey',
+                                ],
+                                resources: [props.metaStoreManagerKmsKeyArn],
+                            }),
+                        ],
+                    });
+            }
+            this.metaStoreManagerRole = new aws_iam_1.Role(this, 'MetaStoreManagerRole', {
+                // The partition-updater Lambda functions created by Security Lake are
+                // hard-coded to assume a role named
+                // `AmazonSecurityLakeMetaStoreManagerV2` under the `/service-role/`
+                // path and do not honor an arbitrary role ARN. Without a matching
+                // role name, CFN deployment and `CreateDataLake` succeed but the
+                // partition updater silently fails and subscribers cannot query
+                // replicated objects. The role name is account-global; for
+                // multi-Region deploys in the same account pass
+                // `metaStoreManagerRoleArn` for all but one Region.
+                path: '/service-role/',
+                roleName: 'AmazonSecurityLakeMetaStoreManagerV2',
+                assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+                description: 'Role used by Amazon Security Lake metastore manager Lambda to manage the AWS Glue metastore.',
+                managedPolicies: [
+                    aws_iam_1.ManagedPolicy.fromAwsManagedPolicyName('service-role/AmazonSecurityLakeMetastoreManager'),
+                ],
+                inlinePolicies: metaStoreInlinePolicies,
+            });
+            metaStoreManagerRoleArn = this.metaStoreManagerRole.roleArn;
+        }
+        // Encryption configuration.
+        const encryptionConfiguration = (props === null || props === void 0 ? void 0 : props.kmsKeyId) !== undefined ? { kmsKeyId: props.kmsKeyId } : undefined;
+        // Lifecycle configuration.
+        let lifecycleConfiguration;
+        if (props === null || props === void 0 ? void 0 : props.lifecycle) {
+            lifecycleConfiguration = {
+                expiration: props.lifecycle.expirationDays !== undefined
+                    ? { days: props.lifecycle.expirationDays }
+                    : undefined,
+                transitions: (_a = props.lifecycle.transitions) === null || _a === void 0 ? void 0 : _a.map((t) => ({
+                    days: t.days,
+                    storageClass: t.storageClass,
+                })),
+            };
+        }
+        // Replication configuration.
+        let replicationConfiguration;
+        if (props === null || props === void 0 ? void 0 : props.replication) {
+            let replicationRoleArn = props.replication.roleArn;
+            if (!replicationRoleArn) {
+                const account = aws_cdk_lib_1.Stack.of(this).account;
+                const sourceRegion = aws_cdk_lib_1.Stack.of(this).region;
+                const destinationRegions = props.replication.regions;
+                // Source and destination encryption are independent in Security
+                // Lake: a CMK source can replicate to an SSE-S3 rollup and vice
+                // versa. Grant `kms:Decrypt` on the source key only when the
+                // source lake uses a CMK, and grant `kms:Encrypt` /
+                // `kms:GenerateDataKey` on the destination keys only when any
+                // rollup bucket uses a CMK. The key ARNs are not derivable at
+                // synth time, so require the caller to supply them explicitly on
+                // the encrypted side (or pre-provision their own replication role
+                // via `replication.roleArn`).
+                if (usesCustomerManagedKey && !props.replication.sourceKmsKeyArn) {
+                    throw new Error('StandardSecurityLake: a customer-managed `kmsKeyId` with ' +
+                        'replication requires `replication.sourceKmsKeyArn` so the ' +
+                        'generated replication role can `kms:Decrypt` source objects. ' +
+                        'If any rollup Region bucket is also encrypted with a ' +
+                        'customer-managed key, pass its ARN via ' +
+                        '`replication.destinationKmsKeyArns`. Alternatively, ' +
+                        'pre-provision the replication role yourself and pass its ARN ' +
+                        'via `replication.roleArn`.');
+                }
+                const kmsStatements = [];
+                if (usesCustomerManagedKey && props.replication.sourceKmsKeyArn) {
+                    kmsStatements.push(new aws_iam_1.PolicyStatement({
+                        sid: 'AllowDecryptSourceKmsKey',
+                        actions: ['kms:Decrypt'],
+                        resources: [props.replication.sourceKmsKeyArn],
+                    }));
+                }
+                if (props.replication.destinationKmsKeyArns &&
+                    props.replication.destinationKmsKeyArns.length > 0) {
+                    kmsStatements.push(new aws_iam_1.PolicyStatement({
+                        sid: 'AllowEncryptDestinationKmsKeys',
+                        actions: ['kms:Encrypt', 'kms:GenerateDataKey'],
+                        resources: props.replication.destinationKmsKeyArns,
+                    }));
+                }
+                this.replicationRole = new aws_iam_1.Role(this, 'ReplicationRole', {
+                    // Security Lake requires the replication role to live under the
+                    // service-role/ path and start with `SecurityLake`. IAM role names
+                    // are account-global, so include the source Region in the suffix to
+                    // avoid collisions when the construct is deployed to multiple
+                    // Regions in the same account.
+                    path: '/service-role/',
+                    roleName: `SecurityLakeS3ReplicationRole-${sourceRegion}`,
+                    // Amazon S3 performs the cross-Region replication, so it (not the
+                    // Security Lake service) must be allowed to assume this role.
+                    assumedBy: new aws_iam_1.ServicePrincipal('s3.amazonaws.com'),
+                    description: 'Role used by Amazon S3 to replicate Amazon Security Lake objects across Regions.',
+                    // No AWS managed policy exists for this role; attach the inline
+                    // policy documented by Security Lake.
+                    // https://docs.aws.amazon.com/security-lake/latest/userguide/add-rollup-region.html
+                    inlinePolicies: {
+                        AmazonSecurityLakeS3ReplicationRolePolicy: new aws_iam_1.PolicyDocument({
+                            statements: [
+                                new aws_iam_1.PolicyStatement({
+                                    sid: 'AllowReadS3ReplicationSetting',
+                                    actions: [
+                                        's3:ListBucket',
+                                        's3:GetReplicationConfiguration',
+                                        's3:GetObjectVersionForReplication',
+                                        's3:GetObjectVersion',
+                                        's3:GetObjectVersionAcl',
+                                        's3:GetObjectVersionTagging',
+                                        's3:GetObjectRetention',
+                                        's3:GetObjectLegalHold',
+                                    ],
+                                    resources: [
+                                        `arn:${aws_cdk_lib_1.Stack.of(this).partition}:s3:::aws-security-data-lake-${sourceRegion}*`,
+                                        `arn:${aws_cdk_lib_1.Stack.of(this).partition}:s3:::aws-security-data-lake-${sourceRegion}*/*`,
+                                    ],
+                                    conditions: {
+                                        StringEquals: { 's3:ResourceAccount': [account] },
+                                    },
+                                }),
+                                new aws_iam_1.PolicyStatement({
+                                    sid: 'AllowS3Replication',
+                                    actions: [
+                                        's3:ReplicateObject',
+                                        's3:ReplicateDelete',
+                                        's3:ReplicateTags',
+                                        's3:GetObjectVersionTagging',
+                                    ],
+                                    resources: destinationRegions.flatMap((r) => [
+                                        `arn:${aws_cdk_lib_1.Stack.of(this).partition}:s3:::aws-security-data-lake-${r}*/*`,
+                                    ]),
+                                    conditions: {
+                                        StringEquals: { 's3:ResourceAccount': [account] },
+                                    },
+                                }),
+                                ...kmsStatements,
+                            ],
+                        }),
+                    },
+                });
+                replicationRoleArn = this.replicationRole.roleArn;
+            }
+            replicationConfiguration = {
+                regions: props.replication.regions,
+                roleArn: replicationRoleArn,
+            };
+        }
+        this.dataLake = new aws_securitylake_1.CfnDataLake(this, 'DataLake', {
+            metaStoreManagerRoleArn,
+            encryptionConfiguration,
+            lifecycleConfiguration,
+            replicationConfiguration,
+        });
+        if (this.lakeFormationServiceLinkedRole) {
+            this.dataLake.addDependency(this.lakeFormationServiceLinkedRole);
+        }
+        // Create AWS log sources sequentially using DependsOn, as required by
+        // Security Lake when more than one source is created in the same
+        // template.
+        let previous;
+        for (const source of (_b = props === null || props === void 0 ? void 0 : props.logSources) !== null && _b !== void 0 ? _b : []) {
+            const logSource = new aws_securitylake_1.CfnAwsLogSource(this, `LogSource${source.sourceName}`, {
+                dataLakeArn: this.dataLake.attrArn,
+                sourceName: source.sourceName,
+                sourceVersion: (_c = source.sourceVersion) !== null && _c !== void 0 ? _c : '2.0',
+                accounts: (_d = source.accounts) !== null && _d !== void 0 ? _d : [aws_cdk_lib_1.Stack.of(this).account],
+            });
+            logSource.addDependency(this.dataLake);
+            if (previous) {
+                logSource.addDependency(previous);
+            }
+            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 {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/dist/index.d.ts

@@ -17,6 +17,7 @@ export * as aws_patterns_workspaces from './aws-patterns-workspaces/index';
 export * as aws_rds from './aws-rds/index';
 export * as aws_route53 from './aws-route53/index';
 export * as aws_s3 from './aws-s3/index';
+export * as aws_securitylake from './aws-securitylake/index';
 export * as aws_ses from './aws-ses/index';
 export * as aws_sqs from './aws-sqs/index';
 export * as aws_ssm from './aws-ssm/index';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.helpers = exports.aws_workspaces = exports.aws_wafv2 = exports.aws_vpc = exports.aws_ssm_patch = exports.aws_ssm_activation = exports.aws_ssm = exports.aws_sqs = exports.aws_ses = exports.aws_s3 = exports.aws_route53 = exports.aws_rds = exports.aws_patterns_workspaces = exports.wordpress = exports.website = exports.domain_redirect = exports.aws_monitoring = exports.aws_lambda = exports.aws_ecs = exports.aws_dynamodb = exports.aws_directory_service = exports.aws_codepipeline = exports.aws_cloudwatch = exports.aws_cloudfront = exports.aws_centergauge = exports.aws_cdk = exports.aws_bedrock = exports.aws_apigatewayv2 = void 0;
+exports.helpers = exports.aws_workspaces = exports.aws_wafv2 = exports.aws_vpc = exports.aws_ssm_patch = exports.aws_ssm_activation = exports.aws_ssm = exports.aws_sqs = exports.aws_ses = exports.aws_securitylake = exports.aws_s3 = exports.aws_route53 = exports.aws_rds = exports.aws_patterns_workspaces = exports.wordpress = exports.website = exports.domain_redirect = exports.aws_monitoring = exports.aws_lambda = exports.aws_ecs = exports.aws_dynamodb = exports.aws_directory_service = exports.aws_codepipeline = exports.aws_cloudwatch = exports.aws_cloudfront = exports.aws_centergauge = exports.aws_cdk = exports.aws_bedrock = exports.aws_apigatewayv2 = void 0;
 exports.aws_apigatewayv2 = require("./aws-apigatewayv2/index");
 exports.aws_bedrock = require("./aws-bedrock/index");
 exports.aws_cdk = require("./aws-cdk/index");
@@ -20,6 +20,7 @@ exports.aws_patterns_workspaces = require("./aws-patterns-workspaces/index");
 exports.aws_rds = require("./aws-rds/index");
 exports.aws_route53 = require("./aws-route53/index");
 exports.aws_s3 = require("./aws-s3/index");
+exports.aws_securitylake = require("./aws-securitylake/index");
 exports.aws_ses = require("./aws-ses/index");
 exports.aws_sqs = require("./aws-sqs/index");
 exports.aws_ssm = require("./aws-ssm/index");
@@ -29,4 +30,4 @@ exports.aws_vpc = require("./aws-vpc/index");
 exports.aws_wafv2 = require("./aws-wafv2/index");
 exports.aws_workspaces = require("./aws-workspaces/index");
 exports.helpers = require("./helpers/index");
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "truemark-cdk-lib",
   "description": "AWS CDK constructs created by TrueMark",
-  "version": "1.28.2",
+  "version": "1.30.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "typesVersions": {
@@ -57,6 +57,9 @@
       "aws-s3": [
         "./dist/aws-s3/index.d.ts"
       ],
+      "aws-securitylake": [
+        "./dist/aws-securitylake/index.d.ts"
+      ],
       "aws-ses": [
         "./dist/aws-ses/index.d.ts"
       ],
@@ -100,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",
@@ -200,6 +203,10 @@
       "types": "./dist/aws-s3/index.d.ts",
       "default": "./dist/aws-s3/index.js"
     },
+    "./aws-securitylake": {
+      "types": "./dist/aws-securitylake/index.d.ts",
+      "default": "./dist/aws-securitylake/index.js"
+    },
     "./aws-ses": {
       "types": "./dist/aws-ses/index.d.ts",
       "default": "./dist/aws-ses/index.js"