ecr-scan-verifier 0.0.0

package/lib/ecr-scan-verifier.js

@@ -0,0 +1,126 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcrScanVerifier = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path_1 = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const constructs_1 = require("constructs");
+const types_1 = require("./types");
+/**
+ * A Construct that verifies container image scan findings with ECR image scanning.
+ * It uses a Lambda function as a Custom Resource provider to call ECR scan APIs
+ * and evaluate scan findings.
+ */
+class EcrScanVerifier extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.defaultLogGroup = props.defaultLogGroup;
+        const lambdaPurpose = 'Custom::EcrScanVerifierCustomResourceLambda';
+        const customResourceLambda = new aws_lambda_1.SingletonFunction(this, 'CustomResourceLambda', {
+            uuid: 'c56cee6b-6775-541b-d179-c1535d88a0c8',
+            lambdaPurpose,
+            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+            handler: 'index.handler',
+            code: aws_lambda_1.Code.fromAsset((0, path_1.join)(__dirname, '../assets/lambda/dist'), {
+                // exclude node_modules
+                // because the native binary of the installed esbuild changes depending on the cpu architecture
+                // and the hash value of the image asset changes depending on the execution environment.
+                exclude: ['node_modules'],
+            }),
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            timeout: aws_cdk_lib_1.Duration.seconds(900),
+            retryAttempts: 0,
+            logGroup: this.defaultLogGroup,
+        });
+        const imageTag = props.imageTag ?? 'latest';
+        const scanConfigOutput = props.scanConfig.bind();
+        // Validate: SBOM output requires Enhanced scanning
+        if (props.sbomOutput && scanConfigOutput.scanType === 'BASIC') {
+            throw new Error('SBOM output is only available with Enhanced scanning (ScanConfig.enhanced()). Basic scanning does not support SBOM generation.');
+        }
+        const outputOptions = props.scanLogsOutput?.bind(customResourceLambda);
+        // SBOM output (independent from scan logs)
+        const sbomConfig = props.sbomOutput?.bind(customResourceLambda);
+        // ECR scan permissions
+        customResourceLambda.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ['ecr:DescribeImageScanFindings', 'ecr:DescribeImages'],
+            resources: [props.repository.repositoryArn],
+        }));
+        if (scanConfigOutput.scanType === 'ENHANCED') {
+            customResourceLambda.addToRolePolicy(new aws_iam_1.PolicyStatement({
+                actions: ['inspector2:ListCoverage', 'inspector2:ListFindings'],
+                resources: ['*'],
+            }));
+        }
+        if (scanConfigOutput.startScan) {
+            customResourceLambda.addToRolePolicy(new aws_iam_1.PolicyStatement({
+                actions: ['ecr:StartImageScan'],
+                resources: [props.repository.repositoryArn],
+            }));
+        }
+        // SBOM export permissions (Inspector CreateSbomExport)
+        if (sbomConfig) {
+            customResourceLambda.addToRolePolicy(new aws_iam_1.PolicyStatement({
+                actions: ['inspector2:CreateSbomExport', 'inspector2:GetSbomExport'],
+                resources: ['*'],
+            }));
+        }
+        if (props.vulnsNotificationTopic) {
+            props.vulnsNotificationTopic.grantPublish(customResourceLambda);
+        }
+        const suppressErrorOnRollback = props.suppressErrorOnRollback ?? true;
+        if (suppressErrorOnRollback) {
+            customResourceLambda.addToRolePolicy(new aws_iam_1.PolicyStatement({
+                actions: ['cloudformation:DescribeStacks'],
+                resources: [aws_cdk_lib_1.Stack.of(this).stackId],
+            }));
+        }
+        // Check for defaultLogGroup consistency across multiple instances in the same stack
+        aws_cdk_lib_1.Aspects.of(aws_cdk_lib_1.Stack.of(this)).add({
+            visit: (node) => {
+                if (node instanceof EcrScanVerifier &&
+                    node._defaultLogGroup?.node.path !== this.defaultLogGroup?.node.path) {
+                    aws_cdk_lib_1.Annotations.of(this).addWarningV2('@ecr-scan-verifier:duplicateLambdaDefaultLogGroup', "You have to set the same log group for 'defaultLogGroup' for each EcrScanVerifier construct in the same stack.");
+                }
+            },
+        });
+        const verifierProvider = new custom_resources_1.Provider(this, 'Provider', {
+            onEventHandler: customResourceLambda,
+        });
+        const verifierProperties = {
+            addr: this.node.addr,
+            repositoryName: props.repository.repositoryName,
+            imageTag,
+            scanType: scanConfigOutput.scanType,
+            startScan: String(scanConfigOutput.startScan),
+            severity: props.severity ?? [types_1.Severity.CRITICAL],
+            failOnVulnerability: String(props.failOnVulnerability ?? true),
+            ignoreFindings: props.ignoreFindings ?? [],
+            output: outputOptions,
+            sbom: sbomConfig,
+            suppressErrorOnRollback: String(suppressErrorOnRollback),
+            vulnsTopicArn: props.vulnsNotificationTopic?.topicArn,
+            defaultLogGroupName: this.defaultLogGroup?.logGroupName ?? `/aws/lambda/${customResourceLambda.functionName}`,
+        };
+        new aws_cdk_lib_1.CustomResource(this, 'Resource', {
+            resourceType: 'Custom::EcrScanVerifier',
+            properties: verifierProperties,
+            serviceToken: verifierProvider.serviceToken,
+        });
+        props.blockConstructs?.forEach((construct) => {
+            construct.node.addDependency(this);
+        });
+    }
+    /** @internal */
+    get _defaultLogGroup() {
+        return this.defaultLogGroup;
+    }
+}
+exports.EcrScanVerifier = EcrScanVerifier;
+_a = JSII_RTTI_SYMBOL_1;
+EcrScanVerifier[_a] = { fqn: "ecr-scan-verifier.EcrScanVerifier", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecr-scan-verifier.js","sourceRoot":"","sources":["../src/ecr-scan-verifier.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from 'path';\nimport { Annotations, Aspects, CustomResource, Duration, Stack } from 'aws-cdk-lib';\nimport { IRepository } from 'aws-cdk-lib/aws-ecr';\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Architecture, Code, Runtime, SingletonFunction } from 'aws-cdk-lib/aws-lambda';\nimport { ILogGroup } from 'aws-cdk-lib/aws-logs';\nimport { ITopic } from 'aws-cdk-lib/aws-sns';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport { Construct, IConstruct } from 'constructs';\nimport { ScannerCustomResourceProps } from './custom-resource-props';\nimport { SbomOutput } from './sbom-output';\nimport { ScanConfig } from './scan-config';\nimport { ScanLogsOutput } from './scan-logs-output';\nimport { Severity } from './types';\n\n/**\n * Properties for EcrScanVerifier Construct.\n */\nexport interface EcrScanVerifierProps {\n  /**\n   * ECR Repository to scan.\n   */\n  readonly repository: IRepository;\n\n  /**\n   * Image tag or digest to scan.\n   *\n   * You can specify a tag (e.g., 'v1.0', 'latest') or a digest (e.g., 'sha256:abc123...').\n   * If the value starts with 'sha256:', it is treated as a digest.\n   *\n   * @default 'latest'\n   */\n  readonly imageTag?: string;\n\n  /**\n   * Scan configuration: basic (ECR native) or enhanced (Amazon Inspector).\n   *\n   * Use `ScanConfig.basic()` for ECR native basic scanning,\n   * or `ScanConfig.enhanced()` for Amazon Inspector enhanced scanning.\n   */\n  readonly scanConfig: ScanConfig;\n\n  /**\n   * Severity threshold for vulnerability detection.\n   *\n   * If vulnerabilities at or above any of the specified severity levels are found,\n   * the scan will be considered as having found vulnerabilities.\n   *\n   * @default [Severity.CRITICAL]\n   */\n  readonly severity?: Severity[];\n\n  /**\n   * Whether to fail the CloudFormation deployment if vulnerabilities are detected\n   * above the severity threshold.\n   *\n   * @default true\n   */\n  readonly failOnVulnerability?: boolean;\n\n  /**\n   * Finding IDs to ignore during vulnerability evaluation.\n   *\n   * For basic scanning: CVE IDs (e.g., 'CVE-2023-37920')\n   * For enhanced scanning: finding ARNs or CVE IDs\n   *\n   * @default - no findings ignored\n   */\n  readonly ignoreFindings?: string[];\n\n  /**\n   * Configuration for scan logs output.\n   *\n   * @default - scan logs output to default log group created by Scanner Lambda.\n   */\n  readonly scanLogsOutput?: ScanLogsOutput;\n\n  /**\n   * SBOM (Software Bill of Materials) output configuration.\n   *\n   * SBOM export uses Amazon Inspector's CreateSbomExport API to generate SBOM\n   * and uploads it to S3.\n   *\n   * **Note**: SBOM export is only available with Enhanced scanning (Amazon Inspector).\n   * Using with Basic scanning will throw an error.\n   *\n   * @default - no SBOM output\n   */\n  readonly sbomOutput?: SbomOutput;\n\n  /**\n   * The Scanner Lambda function's default log group.\n   *\n   * If you use EcrScanVerifier construct multiple times in the same stack,\n   * you must specify the same log group for each construct.\n   *\n   * @default - Scanner Lambda creates the default log group.\n   */\n  readonly defaultLogGroup?: ILogGroup;\n\n  /**\n   * Suppress errors during rollback scanner Lambda execution.\n   *\n   * @default true\n   */\n  readonly suppressErrorOnRollback?: boolean;\n\n  /**\n   * SNS topic for vulnerability notification.\n   *\n   * Supports AWS Chatbot message format.\n   *\n   * @default - no notification\n   */\n  readonly vulnsNotificationTopic?: ITopic;\n\n  /**\n   * Constructs to block if vulnerabilities are detected.\n   *\n   * @default - no constructs to block\n   */\n  readonly blockConstructs?: IConstruct[];\n}\n\n/**\n * A Construct that verifies container image scan findings with ECR image scanning.\n * It uses a Lambda function as a Custom Resource provider to call ECR scan APIs\n * and evaluate scan findings.\n */\nexport class EcrScanVerifier extends Construct {\n  private readonly defaultLogGroup?: ILogGroup;\n\n  constructor(scope: Construct, id: string, props: EcrScanVerifierProps) {\n    super(scope, id);\n\n    this.defaultLogGroup = props.defaultLogGroup;\n    const lambdaPurpose = 'Custom::EcrScanVerifierCustomResourceLambda';\n\n    const customResourceLambda = new SingletonFunction(this, 'CustomResourceLambda', {\n      uuid: 'c56cee6b-6775-541b-d179-c1535d88a0c8',\n      lambdaPurpose,\n      runtime: Runtime.NODEJS_22_X,\n      handler: 'index.handler',\n      code: Code.fromAsset(join(__dirname, '../assets/lambda/dist'), {\n        // exclude node_modules\n        // because the native binary of the installed esbuild changes depending on the cpu architecture\n        // and the hash value of the image asset changes depending on the execution environment.\n        exclude: ['node_modules'],\n      }),\n      architecture: Architecture.ARM_64,\n      timeout: Duration.seconds(900),\n      retryAttempts: 0,\n      logGroup: this.defaultLogGroup,\n    });\n\n    const imageTag = props.imageTag ?? 'latest';\n\n    const scanConfigOutput = props.scanConfig.bind();\n    // Validate: SBOM output requires Enhanced scanning\n    if (props.sbomOutput && scanConfigOutput.scanType === 'BASIC') {\n      throw new Error(\n        'SBOM output is only available with Enhanced scanning (ScanConfig.enhanced()). Basic scanning does not support SBOM generation.',\n      );\n    }\n\n    const outputOptions = props.scanLogsOutput?.bind(customResourceLambda);\n\n    // SBOM output (independent from scan logs)\n    const sbomConfig = props.sbomOutput?.bind(customResourceLambda);\n\n    // ECR scan permissions\n    customResourceLambda.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['ecr:DescribeImageScanFindings', 'ecr:DescribeImages'],\n        resources: [props.repository.repositoryArn],\n      }),\n    );\n\n    if (scanConfigOutput.scanType === 'ENHANCED') {\n      customResourceLambda.addToRolePolicy(\n        new PolicyStatement({\n          actions: ['inspector2:ListCoverage', 'inspector2:ListFindings'],\n          resources: ['*'],\n        }),\n      );\n    }\n\n    if (scanConfigOutput.startScan) {\n      customResourceLambda.addToRolePolicy(\n        new PolicyStatement({\n          actions: ['ecr:StartImageScan'],\n          resources: [props.repository.repositoryArn],\n        }),\n      );\n    }\n\n    // SBOM export permissions (Inspector CreateSbomExport)\n    if (sbomConfig) {\n      customResourceLambda.addToRolePolicy(\n        new PolicyStatement({\n          actions: ['inspector2:CreateSbomExport', 'inspector2:GetSbomExport'],\n          resources: ['*'],\n        }),\n      );\n    }\n\n    if (props.vulnsNotificationTopic) {\n      props.vulnsNotificationTopic.grantPublish(customResourceLambda);\n    }\n\n    const suppressErrorOnRollback = props.suppressErrorOnRollback ?? true;\n    if (suppressErrorOnRollback) {\n      customResourceLambda.addToRolePolicy(\n        new PolicyStatement({\n          actions: ['cloudformation:DescribeStacks'],\n          resources: [Stack.of(this).stackId],\n        }),\n      );\n    }\n\n    // Check for defaultLogGroup consistency across multiple instances in the same stack\n    Aspects.of(Stack.of(this)).add({\n      visit: (node) => {\n        if (\n          node instanceof EcrScanVerifier &&\n          node._defaultLogGroup?.node.path !== this.defaultLogGroup?.node.path\n        ) {\n          Annotations.of(this).addWarningV2(\n            '@ecr-scan-verifier:duplicateLambdaDefaultLogGroup',\n            \"You have to set the same log group for 'defaultLogGroup' for each EcrScanVerifier construct in the same stack.\",\n          );\n        }\n      },\n    });\n\n    const verifierProvider = new Provider(this, 'Provider', {\n      onEventHandler: customResourceLambda,\n    });\n\n    const verifierProperties: ScannerCustomResourceProps = {\n      addr: this.node.addr,\n      repositoryName: props.repository.repositoryName,\n      imageTag,\n      scanType: scanConfigOutput.scanType,\n      startScan: String(scanConfigOutput.startScan),\n      severity: props.severity ?? [Severity.CRITICAL],\n      failOnVulnerability: String(props.failOnVulnerability ?? true),\n      ignoreFindings: props.ignoreFindings ?? [],\n      output: outputOptions,\n      sbom: sbomConfig,\n      suppressErrorOnRollback: String(suppressErrorOnRollback),\n      vulnsTopicArn: props.vulnsNotificationTopic?.topicArn,\n      defaultLogGroupName:\n        this.defaultLogGroup?.logGroupName ?? `/aws/lambda/${customResourceLambda.functionName}`,\n    };\n\n    new CustomResource(this, 'Resource', {\n      resourceType: 'Custom::EcrScanVerifier',\n      properties: verifierProperties,\n      serviceToken: verifierProvider.serviceToken,\n    });\n\n    props.blockConstructs?.forEach((construct) => {\n      construct.node.addDependency(this);\n    });\n  }\n\n  /** @internal */\n  get _defaultLogGroup(): ILogGroup | undefined {\n    return this.defaultLogGroup;\n  }\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ecr-scan-verifier';
+export * from './scan-config';
+export * from './scan-logs-output';
+export * from './sbom-output';
+export * from './types';

package/lib/index.js

@@ -0,0 +1,22 @@
+"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("./ecr-scan-verifier"), exports);
+__exportStar(require("./scan-config"), exports);
+__exportStar(require("./scan-logs-output"), exports);
+__exportStar(require("./sbom-output"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHNEQUFvQztBQUNwQyxnREFBOEI7QUFDOUIscURBQW1DO0FBQ25DLGdEQUE4QjtBQUM5QiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Vjci1zY2FuLXZlcmlmaWVyJztcbmV4cG9ydCAqIGZyb20gJy4vc2Nhbi1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9zY2FuLWxvZ3Mtb3V0cHV0JztcbmV4cG9ydCAqIGZyb20gJy4vc2JvbS1vdXRwdXQnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/lib/sbom-output.d.ts

@@ -0,0 +1,75 @@
+import { IGrantable } from 'aws-cdk-lib/aws-iam';
+import { IKey } from 'aws-cdk-lib/aws-kms';
+import { IBucket } from 'aws-cdk-lib/aws-s3';
+import { SbomFormat } from './types';
+/**
+ * Output of SbomOutput.bind().
+ */
+export interface SbomOutputConfig {
+    /**
+     * The SBOM format.
+     */
+    readonly format: SbomFormat;
+    /**
+     * The S3 bucket name for SBOM output.
+     */
+    readonly bucketName: string;
+    /**
+     * Optional prefix for S3 objects.
+     */
+    readonly prefix?: string;
+    /**
+     * The KMS key ARN for encrypting SBOM output in S3.
+     */
+    readonly kmsKeyArn: string;
+}
+/**
+ * Properties for SBOM output.
+ */
+export interface SbomOutputProps {
+    /**
+     * The S3 bucket to output SBOM.
+     *
+     * The bucket is used as the destination for Amazon Inspector's
+     * CreateSbomExport API and for storing the final SBOM file.
+     */
+    readonly bucket: IBucket;
+    /**
+     * Optional prefix for S3 objects.
+     *
+     * @default - no prefix
+     */
+    readonly prefix?: string;
+    /**
+     * The KMS key used to encrypt the SBOM report in S3.
+     *
+     * Amazon Inspector's CreateSbomExport API requires a customer managed
+     * symmetric encryption KMS key. AWS managed keys are not supported.
+     *
+     * The construct automatically adds the required key policy for
+     * the `inspector2.amazonaws.com` service principal.
+     */
+    readonly encryptionKey: IKey;
+}
+/**
+ * Configuration for SBOM (Software Bill of Materials) output.
+ *
+ * SBOM export is only available with Enhanced scanning (Amazon Inspector).
+ * Uses the Inspector CreateSbomExport API to generate SBOM and uploads it to S3.
+ *
+ * **Note**: Using with Basic scanning will throw an error.
+ */
+export declare abstract class SbomOutput {
+    /**
+     * Output SBOM in CycloneDX 1.4 JSON format.
+     */
+    static cycloneDx14(props: SbomOutputProps): SbomOutput;
+    /**
+     * Output SBOM in SPDX 2.3 JSON format.
+     */
+    static spdx23(props: SbomOutputProps): SbomOutput;
+    /**
+     * Returns the SBOM output configuration.
+     */
+    abstract bind(grantee: IGrantable): SbomOutputConfig;
+}

package/lib/sbom-output.js

@@ -0,0 +1,78 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SbomOutput = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const types_1 = require("./types");
+/**
+ * Configuration for SBOM (Software Bill of Materials) output.
+ *
+ * SBOM export is only available with Enhanced scanning (Amazon Inspector).
+ * Uses the Inspector CreateSbomExport API to generate SBOM and uploads it to S3.
+ *
+ * **Note**: Using with Basic scanning will throw an error.
+ */
+class SbomOutput {
+    /**
+     * Output SBOM in CycloneDX 1.4 JSON format.
+     */
+    static cycloneDx14(props) {
+        return new SbomOutputImpl(props, types_1.SbomFormat.CYCLONEDX_1_4);
+    }
+    /**
+     * Output SBOM in SPDX 2.3 JSON format.
+     */
+    static spdx23(props) {
+        return new SbomOutputImpl(props, types_1.SbomFormat.SPDX_2_3);
+    }
+}
+exports.SbomOutput = SbomOutput;
+_a = JSII_RTTI_SYMBOL_1;
+SbomOutput[_a] = { fqn: "ecr-scan-verifier.SbomOutput", version: "0.0.0" };
+class SbomOutputImpl extends SbomOutput {
+    constructor(props, format) {
+        super();
+        this.bucket = props.bucket;
+        this.prefix = props.prefix;
+        this.encryptionKey = props.encryptionKey;
+        this.format = format;
+    }
+    bind(grantee) {
+        this.bucket.grantReadWrite(grantee);
+        const account = aws_cdk_lib_1.Stack.of(this.bucket).account;
+        // Inspector2 CreateSbomExport writes SBOM directly to the S3 bucket.
+        // The service needs a bucket policy to allow PutObject.
+        this.bucket.addToResourcePolicy(new aws_iam_1.PolicyStatement({
+            actions: ['s3:PutObject', 's3:AbortMultipartUpload'],
+            principals: [new aws_iam_1.ServicePrincipal('inspector2.amazonaws.com')],
+            resources: [this.bucket.arnForObjects('*')],
+            conditions: {
+                StringEquals: {
+                    'aws:SourceAccount': account,
+                },
+            },
+        }));
+        // Inspector2 needs kms:Decrypt and kms:GenerateDataKey* to encrypt the SBOM report.
+        this.encryptionKey.addToResourcePolicy(new aws_iam_1.PolicyStatement({
+            actions: ['kms:Decrypt', 'kms:GenerateDataKey*'],
+            principals: [new aws_iam_1.ServicePrincipal('inspector2.amazonaws.com')],
+            resources: ['*'],
+            conditions: {
+                StringEquals: {
+                    'aws:SourceAccount': account,
+                },
+            },
+        }));
+        // Lambda needs to decrypt the SBOM to download it from S3.
+        this.encryptionKey.grantDecrypt(grantee);
+        return {
+            format: this.format,
+            bucketName: this.bucket.bucketName,
+            prefix: this.prefix,
+            kmsKeyArn: this.encryptionKey.keyArn,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/scan-config.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Options for basic ECR image scanning.
+ */
+export interface BasicScanConfigOptions {
+    /**
+     * Whether to start an image scan via StartImageScan API.
+     *
+     * If false, the construct will poll for existing scan results
+     * (useful when scan-on-push is configured).
+     *
+     * **Note**: If `startScan` is false and no scan has been performed
+     * (e.g., scan-on-push is not configured), the deployment will fail
+     * after polling times out.
+     *
+     * **Note**: If scan-on-push is configured and `startScan` is true,
+     * the `StartImageScan` API may return a `LimitExceededException`
+     * because a scan has already been performed. The construct handles
+     * this gracefully by falling back to polling for the existing results.
+     *
+     * **Note**: If Enhanced scanning (Amazon Inspector) is enabled on your account,
+     * the `StartImageScan` API is disabled. In that case, you must use
+     * `ScanConfig.enhanced()` instead. Using `ScanConfig.basic()` with an
+     * Enhanced scanning account will result in a deployment error.
+     *
+     * @default true
+     */
+    readonly startScan?: boolean;
+}
+/**
+ * Options for enhanced ECR image scanning (Amazon Inspector).
+ */
+export interface EnhancedScanConfigOptions {
+}
+/**
+ * Output of ScanConfig.bind().
+ */
+export interface ScanConfigBindOutput {
+    /**
+     * The scan type ('BASIC' or 'ENHANCED').
+     */
+    readonly scanType: string;
+    /**
+     * Whether to start an image scan via StartImageScan API.
+     */
+    readonly startScan: boolean;
+}
+/**
+ * Configuration for ECR image scan type.
+ *
+ * Use `ScanConfig.basic()` for ECR native basic scanning,
+ * or `ScanConfig.enhanced()` for Amazon Inspector enhanced scanning.
+ */
+export declare abstract class ScanConfig {
+    /**
+     * Basic scanning using Amazon ECR native scanning.
+     *
+     * Basic scanning scans for known CVEs in the OS packages of your container image.
+     */
+    static basic(options?: BasicScanConfigOptions): ScanConfig;
+    /**
+     * Enhanced scanning using Amazon Inspector.
+     *
+     * Enhanced scanning provides more detailed findings including
+     * programming language package vulnerabilities.
+     * Ensure Amazon Inspector is enabled for your registry.
+     */
+    static enhanced(options?: EnhancedScanConfigOptions): ScanConfig;
+    /**
+     * Returns the scan configuration.
+     */
+    abstract bind(): ScanConfigBindOutput;
+}

package/lib/scan-config.js

@@ -0,0 +1,58 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanConfig = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Configuration for ECR image scan type.
+ *
+ * Use `ScanConfig.basic()` for ECR native basic scanning,
+ * or `ScanConfig.enhanced()` for Amazon Inspector enhanced scanning.
+ */
+class ScanConfig {
+    /**
+     * Basic scanning using Amazon ECR native scanning.
+     *
+     * Basic scanning scans for known CVEs in the OS packages of your container image.
+     */
+    static basic(options) {
+        return new BasicScanConfig(options);
+    }
+    /**
+     * Enhanced scanning using Amazon Inspector.
+     *
+     * Enhanced scanning provides more detailed findings including
+     * programming language package vulnerabilities.
+     * Ensure Amazon Inspector is enabled for your registry.
+     */
+    static enhanced(options) {
+        return new EnhancedScanConfig(options);
+    }
+}
+exports.ScanConfig = ScanConfig;
+_a = JSII_RTTI_SYMBOL_1;
+ScanConfig[_a] = { fqn: "ecr-scan-verifier.ScanConfig", version: "0.0.0" };
+class BasicScanConfig extends ScanConfig {
+    constructor(options) {
+        super();
+        this.startScan = options?.startScan ?? true;
+    }
+    bind() {
+        return {
+            scanType: 'BASIC',
+            startScan: this.startScan,
+        };
+    }
+}
+class EnhancedScanConfig extends ScanConfig {
+    constructor(_options) {
+        super();
+    }
+    bind() {
+        return {
+            scanType: 'ENHANCED',
+            startScan: false,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/scan-logs-output.d.ts

@@ -0,0 +1,93 @@
+import { IGrantable } from 'aws-cdk-lib/aws-iam';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { IBucket } from 'aws-cdk-lib/aws-s3';
+/**
+ * Enum for ScanLogsOutputType
+ */
+export declare enum ScanLogsOutputType {
+    /**
+     * Output scan logs to CloudWatch Logs.
+     */
+    CLOUDWATCH_LOGS = "cloudWatchLogs",
+    /**
+     * Output scan logs to S3 bucket.
+     */
+    S3 = "s3"
+}
+/**
+ * Output configurations for scan logs.
+ */
+export interface ScanLogsOutputOptions {
+    /**
+     * The type of scan logs output.
+     */
+    readonly type: ScanLogsOutputType;
+}
+/**
+ * Output configuration for scan logs to CloudWatch Logs.
+ */
+export interface CloudWatchLogsOutputOptions extends ScanLogsOutputOptions {
+    /**
+     * The name of the CloudWatch Logs log group.
+     */
+    readonly logGroupName: string;
+}
+/**
+ * Configuration for scan logs output to CloudWatch Logs log group.
+ */
+export interface CloudWatchLogsOutputProps {
+    /**
+     * The log group to output scan logs.
+     */
+    readonly logGroup: ILogGroup;
+}
+/**
+ * Output configuration for scan logs to S3 bucket.
+ */
+export interface S3OutputOptions extends ScanLogsOutputOptions {
+    /**
+     * The name of the S3 bucket.
+     */
+    readonly bucketName: string;
+    /**
+     * Optional prefix for S3 objects.
+     */
+    readonly prefix?: string;
+}
+/**
+ * Configuration for scan logs output to S3 bucket.
+ */
+export interface S3OutputProps {
+    /**
+     * The S3 bucket to output scan logs.
+     */
+    readonly bucket: IBucket;
+    /**
+     * Optional prefix for S3 objects.
+     */
+    readonly prefix?: string;
+}
+/**
+ * Represents the output of the scan logs.
+ */
+export declare abstract class ScanLogsOutput {
+    /**
+     * Scan logs output to CloudWatch Logs log group.
+     *
+     * **Note on Large Scan Results**: CloudWatch Logs has a limit of 1 MB per log event.
+     * If scan results exceed this limit, they will be automatically
+     * split into multiple log events. Each chunk will be prefixed with `[part X/Y]` to
+     * indicate the sequence, ensuring no data loss while staying within CloudWatch Logs quotas.
+     * **For large scan results, we recommend using S3 output instead** to avoid fragmentation
+     * and make it easier to view complete results.
+     */
+    static cloudWatchLogs(options: CloudWatchLogsOutputProps): ScanLogsOutput;
+    /**
+     * Scan logs output to S3 bucket.
+     */
+    static s3(options: S3OutputProps): ScanLogsOutput;
+    /**
+     * Returns the output configuration for scan logs.
+     */
+    abstract bind(grantee: IGrantable): ScanLogsOutputOptions;
+}