@liflig/cdk 1.49.0 → 1.51.1

package/lib/cdk-deploy/start-deploy-handler.js

@@ -69,4 +69,4 @@ const startDeployHandler = async (event, context) => {
     };
 };
 exports.startDeployHandler = startDeployHandler;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/kinesis/index.d.ts

@@ -0,0 +1 @@
+export { KinesisToDatadogStream, KinesisToDatadogStreamProps, } from "./kinesis-to-datadog-stream";

package/lib/kinesis/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KinesisToDatadogStream = void 0;
+var kinesis_to_datadog_stream_1 = require("./kinesis-to-datadog-stream");
+Object.defineProperty(exports, "KinesisToDatadogStream", { enumerable: true, get: function () { return kinesis_to_datadog_stream_1.KinesisToDatadogStream; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMva2luZXNpcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5RUFHb0M7QUFGbEMsbUlBQUEsc0JBQXNCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBLaW5lc2lzVG9EYXRhZG9nU3RyZWFtLFxuICBLaW5lc2lzVG9EYXRhZG9nU3RyZWFtUHJvcHMsXG59IGZyb20gXCIuL2tpbmVzaXMtdG8tZGF0YWRvZy1zdHJlYW1cIlxuIl19

package/lib/kinesis/kinesis-to-datadog-stream.d.ts

@@ -0,0 +1,27 @@
+import * as logs from "@aws-cdk/aws-logs";
+import * as cdk from "@aws-cdk/core";
+export interface KinesisToDatadogStreamProps {
+    /**
+     *
+     * The name of the SecretsManager secret where your Datadog API key is saved.
+     *
+     * The secret must be a JSON object on the format { "value": "SECRET" }
+     *
+     */
+    datadogApiKeySecretName: string;
+    /**
+     *
+     * The CloudWatch log groups from you are streaming to Datadog
+     *
+     */
+    logGroups: logs.LogGroup[];
+}
+/**
+ *
+ * Forwards logs from log-groups in CloudWatch to a Datadog account.
+ * The logs are delivered through a Firehose delivery stream, which is being subscribed to the log-groups in CloudWatch.
+ *
+ */
+export declare class KinesisToDatadogStream extends cdk.Construct {
+    constructor(scope: cdk.Construct, id: string, props: KinesisToDatadogStreamProps);
+}

package/lib/kinesis/kinesis-to-datadog-stream.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KinesisToDatadogStream = void 0;
+const iam = require("@aws-cdk/aws-iam");
+const firehose = require("@aws-cdk/aws-kinesisfirehose");
+const logs = require("@aws-cdk/aws-logs");
+const s3 = require("@aws-cdk/aws-s3");
+const aws_s3_1 = require("@aws-cdk/aws-s3");
+const secretsmanager = require("@aws-cdk/aws-secretsmanager");
+const cdk = require("@aws-cdk/core");
+/**
+ *
+ * Forwards logs from log-groups in CloudWatch to a Datadog account.
+ * The logs are delivered through a Firehose delivery stream, which is being subscribed to the log-groups in CloudWatch.
+ *
+ */
+class KinesisToDatadogStream extends cdk.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const deliveryStreamLogGroup = new logs.LogGroup(this, "DeliveryStreamLogGroup");
+        const deliveryStreamLogStream = new logs.LogStream(this, "DeliveryStreamLogStream", {
+            logGroup: deliveryStreamLogGroup,
+        });
+        const failedDataBucket = new s3.Bucket(this, "FailedDataBucket", {
+            blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
+        });
+        const cloudWatchLogsRole = new iam.Role(this, "CloudWatchLogsRole", {
+            assumedBy: new iam.ServicePrincipal(`logs.${cdk.Stack.of(this).region}.amazonaws.com`),
+        });
+        const firehoseLogsRole = new iam.Role(this, "FirehoseLogsRole", {
+            assumedBy: new iam.ServicePrincipal("firehose.amazonaws.com"),
+        });
+        const datadogDeliveryStream = new firehose.CfnDeliveryStream(this, "DeliveryStream", {
+            deliveryStreamType: "DirectPut",
+            httpEndpointDestinationConfiguration: {
+                roleArn: firehoseLogsRole.roleArn,
+                endpointConfiguration: {
+                    url: "https://aws-kinesis-http-intake.logs.datadoghq.eu/v1/input",
+                    accessKey: secretsmanager.Secret.fromSecretNameV2(scope, "DatadogApiKey", props.datadogApiKeySecretName)
+                        .secretValueFromJson("value")
+                        .toString(),
+                    name: "datadog-logs-endpoint",
+                },
+                requestConfiguration: {
+                    contentEncoding: "GZIP",
+                },
+                cloudWatchLoggingOptions: {
+                    enabled: true,
+                    logGroupName: deliveryStreamLogGroup.logGroupName,
+                    logStreamName: deliveryStreamLogStream.logStreamName,
+                },
+                bufferingHints: {
+                    intervalInSeconds: 60,
+                    sizeInMBs: 4,
+                },
+                retryOptions: {
+                    durationInSeconds: 60,
+                },
+                s3BackupMode: "FailedDataOnly",
+                s3Configuration: {
+                    bucketArn: failedDataBucket.bucketArn,
+                    compressionFormat: "UNCOMPRESSED",
+                    roleArn: firehoseLogsRole.roleArn,
+                },
+            },
+        });
+        new iam.Policy(this, "CloudWatchLogsPolicy", {
+            document: new iam.PolicyDocument({
+                statements: [
+                    new iam.PolicyStatement({
+                        actions: ["firehose:PutRecord", "firehose:PutRecordBatch"],
+                        resources: [datadogDeliveryStream.attrArn],
+                    }),
+                ],
+            }),
+            roles: [cloudWatchLogsRole],
+        });
+        new iam.Policy(this, "FirehoseLogsPolicy", {
+            document: new iam.PolicyDocument({
+                statements: [
+                    new iam.PolicyStatement({
+                        actions: [
+                            "s3:AbortMultipartUpload",
+                            "s3:GetBucketLocation",
+                            "s3:GetObject",
+                            "s3:ListBucket",
+                            "s3:ListBucketMultipartUploads",
+                            "s3:PutObject",
+                        ],
+                        resources: [
+                            failedDataBucket.bucketArn,
+                            `${failedDataBucket.bucketArn}/*`,
+                        ],
+                    }),
+                    new iam.PolicyStatement({
+                        actions: ["logs:PutLogEvents"],
+                        resources: [
+                            `arn:aws:logs:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:log-group:${deliveryStreamLogGroup.logGroupName}:log-stream:${deliveryStreamLogStream.logStreamName}`,
+                        ],
+                    }),
+                    new iam.PolicyStatement({
+                        actions: [
+                            "kinesis:DescribeStream",
+                            "kinesis:GetShardIterator",
+                            "kinesis:GetRecords",
+                        ],
+                        resources: [datadogDeliveryStream.attrArn],
+                    }),
+                ],
+            }),
+            roles: [firehoseLogsRole],
+        });
+        props.logGroups.forEach((logGroup, index) => {
+            new logs.CfnSubscriptionFilter(this, `SubscriptionFilter${index}`, {
+                logGroupName: logGroup.logGroupName,
+                destinationArn: datadogDeliveryStream.attrArn,
+                filterPattern: logs.FilterPattern.allEvents().logPatternString,
+                roleArn: cloudWatchLogsRole.roleArn,
+            });
+        });
+    }
+}
+exports.KinesisToDatadogStream = KinesisToDatadogStream;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kinesis-to-datadog-stream.js","sourceRoot":"","sources":["../../src/kinesis/kinesis-to-datadog-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import * as iam from \"@aws-cdk/aws-iam\"\nimport * as firehose from \"@aws-cdk/aws-kinesisfirehose\"\nimport * as logs from \"@aws-cdk/aws-logs\"\nimport * as s3 from \"@aws-cdk/aws-s3\"\nimport { BlockPublicAccess } from \"@aws-cdk/aws-s3\"\nimport * as secretsmanager from \"@aws-cdk/aws-secretsmanager\"\nimport * as cdk from \"@aws-cdk/core\"\n\nexport interface KinesisToDatadogStreamProps {\n  /**\n   *\n   * The name of the SecretsManager secret where your Datadog API key is saved.\n   *\n   * The secret must be a JSON object on the format { \"value\": \"SECRET\" }\n   *\n   */\n  datadogApiKeySecretName: string\n  /**\n   *\n   * The CloudWatch log groups from you are streaming to Datadog\n   *\n   */\n  logGroups: logs.LogGroup[]\n}\n\n/**\n *\n * Forwards logs from log-groups in CloudWatch to a Datadog account.\n * The logs are delivered through a Firehose delivery stream, which is being subscribed to the log-groups in CloudWatch.\n *\n */\nexport class KinesisToDatadogStream extends cdk.Construct {\n  constructor(\n    scope: cdk.Construct,\n    id: string,\n    props: KinesisToDatadogStreamProps,\n  ) {\n    super(scope, id)\n\n    const deliveryStreamLogGroup = new logs.LogGroup(\n      this,\n      \"DeliveryStreamLogGroup\",\n    )\n\n    const deliveryStreamLogStream = new logs.LogStream(\n      this,\n      \"DeliveryStreamLogStream\",\n      {\n        logGroup: deliveryStreamLogGroup,\n      },\n    )\n\n    const failedDataBucket = new s3.Bucket(this, \"FailedDataBucket\", {\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n    })\n\n    const cloudWatchLogsRole = new iam.Role(this, \"CloudWatchLogsRole\", {\n      assumedBy: new iam.ServicePrincipal(\n        `logs.${cdk.Stack.of(this).region}.amazonaws.com`,\n      ),\n    })\n\n    const firehoseLogsRole = new iam.Role(this, \"FirehoseLogsRole\", {\n      assumedBy: new iam.ServicePrincipal(\"firehose.amazonaws.com\"),\n    })\n\n    const datadogDeliveryStream = new firehose.CfnDeliveryStream(\n      this,\n      \"DeliveryStream\",\n      {\n        deliveryStreamType: \"DirectPut\",\n        httpEndpointDestinationConfiguration: {\n          roleArn: firehoseLogsRole.roleArn,\n          endpointConfiguration: {\n            url: \"https://aws-kinesis-http-intake.logs.datadoghq.eu/v1/input\",\n            accessKey: secretsmanager.Secret.fromSecretNameV2(\n              scope,\n              \"DatadogApiKey\",\n              props.datadogApiKeySecretName,\n            )\n              .secretValueFromJson(\"value\")\n              .toString(),\n            name: \"datadog-logs-endpoint\",\n          },\n          requestConfiguration: {\n            contentEncoding: \"GZIP\",\n          },\n          cloudWatchLoggingOptions: {\n            enabled: true,\n            logGroupName: deliveryStreamLogGroup.logGroupName,\n            logStreamName: deliveryStreamLogStream.logStreamName,\n          },\n          bufferingHints: {\n            intervalInSeconds: 60,\n            sizeInMBs: 4,\n          },\n          retryOptions: {\n            durationInSeconds: 60,\n          },\n          s3BackupMode: \"FailedDataOnly\",\n          s3Configuration: {\n            bucketArn: failedDataBucket.bucketArn,\n            compressionFormat: \"UNCOMPRESSED\",\n            roleArn: firehoseLogsRole.roleArn,\n          },\n        },\n      },\n    )\n\n    new iam.Policy(this, \"CloudWatchLogsPolicy\", {\n      document: new iam.PolicyDocument({\n        statements: [\n          new iam.PolicyStatement({\n            actions: [\"firehose:PutRecord\", \"firehose:PutRecordBatch\"],\n            resources: [datadogDeliveryStream.attrArn],\n          }),\n        ],\n      }),\n      roles: [cloudWatchLogsRole],\n    })\n\n    new iam.Policy(this, \"FirehoseLogsPolicy\", {\n      document: new iam.PolicyDocument({\n        statements: [\n          new iam.PolicyStatement({\n            actions: [\n              \"s3:AbortMultipartUpload\",\n              \"s3:GetBucketLocation\",\n              \"s3:GetObject\",\n              \"s3:ListBucket\",\n              \"s3:ListBucketMultipartUploads\",\n              \"s3:PutObject\",\n            ],\n            resources: [\n              failedDataBucket.bucketArn,\n              `${failedDataBucket.bucketArn}/*`,\n            ],\n          }),\n          new iam.PolicyStatement({\n            actions: [\"logs:PutLogEvents\"],\n            resources: [\n              `arn:aws:logs:${cdk.Stack.of(this).region}:${\n                cdk.Stack.of(this).account\n              }:log-group:${deliveryStreamLogGroup.logGroupName}:log-stream:${\n                deliveryStreamLogStream.logStreamName\n              }`,\n            ],\n          }),\n          new iam.PolicyStatement({\n            actions: [\n              \"kinesis:DescribeStream\",\n              \"kinesis:GetShardIterator\",\n              \"kinesis:GetRecords\",\n            ],\n            resources: [datadogDeliveryStream.attrArn],\n          }),\n        ],\n      }),\n      roles: [firehoseLogsRole],\n    })\n\n    props.logGroups.forEach((logGroup, index) => {\n      new logs.CfnSubscriptionFilter(this, `SubscriptionFilter${index}`, {\n        logGroupName: logGroup.logGroupName,\n        destinationArn: datadogDeliveryStream.attrArn,\n        filterPattern: logs.FilterPattern.allEvents().logPatternString,\n        roleArn: cloudWatchLogsRole.roleArn,\n      })\n    })\n  }\n}\n"]}

package/lib/webapp/security-headers.js

@@ -21,20 +21,20 @@ function trim(value) {
 }
 function generateContentSecurityPolicyHeader(headerOptions) {
     const defaultValues = {
-        baseUri: "self",
-        childSrc: "none",
-        connectSrc: "self",
-        defaultSrc: "self",
-        fontSrc: "self",
-        formAction: "self",
-        frameAncestors: "none",
-        frameSrc: "self",
-        imgSrc: "self",
-        manifestSrc: "self",
-        mediaSrc: "self",
-        objectSrc: "none",
-        scriptSrc: "self",
-        styleSrc: "self",
+        baseUri: "'self'",
+        childSrc: "'none'",
+        connectSrc: "'self'",
+        defaultSrc: "'self'",
+        fontSrc: "'self'",
+        formAction: "'self'",
+        frameAncestors: "'none'",
+        frameSrc: "'self'",
+        imgSrc: "'self'",
+        manifestSrc: "'self'",
+        mediaSrc: "'self'",
+        objectSrc: "'none'",
+        scriptSrc: "'self'",
+        styleSrc: "'self'",
     };
     const options = {
         ...defaultValues,
@@ -42,18 +42,18 @@ function generateContentSecurityPolicyHeader(headerOptions) {
     };
     Object.values(options).forEach((v) => typeof v === "string" && validateCspParam(v));
     let headerValue = "";
-    headerValue += `base-uri '${trim(trim(options.baseUri))}';`;
-    headerValue += `child-src '${trim(options.childSrc)}';`;
-    headerValue += `connect-src '${trim(options.connectSrc)}';`;
-    headerValue += `default-src '${trim(options.defaultSrc)}';`;
-    headerValue += `font-src '${trim(options.fontSrc)}';`;
-    headerValue += `frame-src '${trim(options.frameSrc)}';`;
-    headerValue += `img-src '${trim(options.imgSrc)}';`;
-    headerValue += `manifest-src '${trim(options.manifestSrc)}';`;
-    headerValue += `media-src '${trim(options.mediaSrc)}';`;
-    headerValue += `object-src '${trim(options.objectSrc)}';`;
-    headerValue += `script-src '${trim(options.scriptSrc)}';`;
-    headerValue += `style-src '${trim(options.styleSrc)}';`;
+    headerValue += `base-uri ${trim(options.baseUri)};`;
+    headerValue += `child-src ${trim(options.childSrc)};`;
+    headerValue += `connect-src ${trim(options.connectSrc)};`;
+    headerValue += `default-src ${trim(options.defaultSrc)};`;
+    headerValue += `font-src ${trim(options.fontSrc)};`;
+    headerValue += `frame-src ${trim(options.frameSrc)};`;
+    headerValue += `img-src ${trim(options.imgSrc)};`;
+    headerValue += `manifest-src ${trim(options.manifestSrc)};`;
+    headerValue += `media-src ${trim(options.mediaSrc)};`;
+    headerValue += `object-src ${trim(options.objectSrc)};`;
+    headerValue += `script-src ${trim(options.scriptSrc)};`;
+    headerValue += `style-src ${trim(options.styleSrc)};`;
     return trim(headerValue);
 }
 function generateStrictTransportSecurityHeader(headerOptions) {
@@ -114,10 +114,13 @@ class WebappSecurityHeaders extends cdk.Construct {
       headers['${cspHeaderName}'] = {value: "${contentSecurityPolicy}"};
       return response;
     }`;
-        this.securityHeadersFunction = new cloudfront.Function(this, "Function", {
+        // Hardcoded logical ID due to bug: https://github.com/aws/aws-cdk/issues/15523
+        const functionId = `Function${this.node.addr}`;
+        this.securityHeadersFunction = new cloudfront.Function(this, functionId, {
+            functionName: functionId,
             code: cloudfront.FunctionCode.fromInline(lambdaCode),
         });
     }
 }
 exports.WebappSecurityHeaders = WebappSecurityHeaders;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-headers.js","sourceRoot":"","sources":["../../src/webapp/security-headers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cloudfront from \"@aws-cdk/aws-cloudfront\"\nimport * as cdk from \"@aws-cdk/core\"\n\nexport interface FrameOptionsHeader {\n  value?: \"DENY\" | \"SAMEORIGIN\"\n}\n\nexport interface ReferrerPolicyHeader {\n  value?: string\n}\n\nexport interface StrictTransportSecurityHeader {\n  maxAge?: number\n  includeSubDomains?: boolean\n  preload?: boolean\n}\n\nexport interface ContentSecurityPolicyHeader {\n  reportOnly?: boolean\n  baseUri?: string\n  childSrc?: string\n  defaultSrc?: string\n  fontSrc?: string\n  frameSrc?: string\n  formAction?: string\n  frameAncestors?: string\n  imgSrc?: string\n  manifestSrc?: string\n  mediaSrc?: string\n  objectSrc?: string\n  scriptSrc?: string\n  styleSrc?: string\n  connectSrc?: string\n}\n\nexport interface SecurityHeaders {\n  contentSecurityPolicy?: ContentSecurityPolicyHeader\n  strictTransportSecurity?: StrictTransportSecurityHeader\n  referrerPolicy?: ReferrerPolicyHeader\n  frameOptions?: FrameOptionsHeader\n}\n\nfunction validateCspParam(param: string): string {\n  if (param.indexOf('\"') !== -1) {\n    throw Error('CSP override contains invalid character \"')\n  }\n\n  if (param.indexOf(\";\") !== -1) {\n    throw Error(\"CSP override contains invalid character ;\")\n  }\n\n  if (param.indexOf(\"\\\\\") !== -1) {\n    throw Error(\"CSP override contains invalid character \\\\\")\n  }\n\n  return param\n}\n\n/* Replace all whitespace in a string with a single space */\nfunction trim(value: string): string {\n  return value.replace(/\\s+/g, \" \").trim()\n}\n\nfunction generateContentSecurityPolicyHeader(\n  headerOptions?: ContentSecurityPolicyHeader,\n) {\n  const defaultValues = {\n    baseUri: \"self\",\n    childSrc: \"none\",\n    connectSrc: \"self\",\n    defaultSrc: \"self\",\n    fontSrc: \"self\",\n    formAction: \"self\",\n    frameAncestors: \"none\",\n    frameSrc: \"self\",\n    imgSrc: \"self\",\n    manifestSrc: \"self\",\n    mediaSrc: \"self\",\n    objectSrc: \"none\",\n    scriptSrc: \"self\",\n    styleSrc: \"self\",\n  }\n\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n\n  Object.values(options).forEach(\n    (v) => typeof v === \"string\" && validateCspParam(v),\n  )\n\n  let headerValue = \"\"\n  headerValue += `base-uri '${trim(trim(options.baseUri))}';`\n  headerValue += `child-src '${trim(options.childSrc)}';`\n  headerValue += `connect-src '${trim(options.connectSrc)}';`\n  headerValue += `default-src '${trim(options.defaultSrc)}';`\n  headerValue += `font-src '${trim(options.fontSrc)}';`\n  headerValue += `frame-src '${trim(options.frameSrc)}';`\n  headerValue += `img-src '${trim(options.imgSrc)}';`\n  headerValue += `manifest-src '${trim(options.manifestSrc)}';`\n  headerValue += `media-src '${trim(options.mediaSrc)}';`\n  headerValue += `object-src '${trim(options.objectSrc)}';`\n  headerValue += `script-src '${trim(options.scriptSrc)}';`\n  headerValue += `style-src '${trim(options.styleSrc)}';`\n\n  return trim(headerValue)\n}\n\nfunction generateStrictTransportSecurityHeader(\n  headerOptions?: StrictTransportSecurityHeader,\n) {\n  const defaultValues = {\n    maxAge: 63072000,\n    includeSubDomains: false,\n    preload: false,\n  }\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n  let headerValue = \"\"\n  headerValue += `max-age=${options.maxAge};`\n  headerValue += options.preload ? \"preload;\" : \"\"\n  headerValue += options.includeSubDomains ? \"includeSubDomains;\" : \"\"\n  return trim(headerValue)\n}\n\nfunction generateReferrerPolicyHeader(headerOptions?: ReferrerPolicyHeader) {\n  const defaultValues = {\n    value: \"strict-origin-when-cross-origin\",\n  }\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n  return options.value\n}\n\nfunction generateFrameOptionsHeader(headerOptions?: FrameOptionsHeader) {\n  const defaultValues = {\n    value: \"DENY\",\n  }\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n  return trim(options.value)\n}\n\nexport class WebappSecurityHeaders extends cdk.Construct {\n  public readonly securityHeadersFunction: cloudfront.Function\n\n  constructor(scope: cdk.Construct, id: string, props: SecurityHeaders) {\n    super(scope, id)\n\n    const cspHeaderName = props.contentSecurityPolicy?.reportOnly\n      ? \"content-security-policy-report-only\"\n      : \"content-security-policy\"\n\n    const contentSecurityPolicy = generateContentSecurityPolicyHeader(\n      props.contentSecurityPolicy,\n    )\n    const strictTransportSecurity = generateStrictTransportSecurityHeader(\n      props.strictTransportSecurity,\n    )\n    const referrerPolicy = generateReferrerPolicyHeader(props.referrerPolicy)\n    const frameOptions = generateFrameOptionsHeader(props.frameOptions)\n\n    const lambdaCode = `function handler(event) {\n      var response = event.response;\n      var headers = response.headers;\n      headers['referrer-policy'] = {value: '${referrerPolicy}'};\n      headers['strict-transport-security'] = {value: '${strictTransportSecurity}'};\n      headers['x-content-type-options'] = {value: 'nosniff'};\n      headers['x-frame-options'] = {value: '${frameOptions}'};\n      headers['x-xss-protection'] = {value: '1; mode=block'};\n      headers['${cspHeaderName}'] = {value: \"${contentSecurityPolicy}\"};\n      return response;\n    }`\n\n    this.securityHeadersFunction = new cloudfront.Function(this, \"Function\", {\n      code: cloudfront.FunctionCode.fromInline(lambdaCode),\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-headers.js","sourceRoot":"","sources":["../../src/webapp/security-headers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cloudfront from \"@aws-cdk/aws-cloudfront\"\nimport * as cdk from \"@aws-cdk/core\"\n\nexport interface FrameOptionsHeader {\n  value?: \"DENY\" | \"SAMEORIGIN\"\n}\n\nexport interface ReferrerPolicyHeader {\n  value?: string\n}\n\nexport interface StrictTransportSecurityHeader {\n  maxAge?: number\n  includeSubDomains?: boolean\n  preload?: boolean\n}\n\nexport interface ContentSecurityPolicyHeader {\n  reportOnly?: boolean\n  baseUri?: string\n  childSrc?: string\n  defaultSrc?: string\n  fontSrc?: string\n  frameSrc?: string\n  formAction?: string\n  frameAncestors?: string\n  imgSrc?: string\n  manifestSrc?: string\n  mediaSrc?: string\n  objectSrc?: string\n  scriptSrc?: string\n  styleSrc?: string\n  connectSrc?: string\n}\n\nexport interface SecurityHeaders {\n  contentSecurityPolicy?: ContentSecurityPolicyHeader\n  strictTransportSecurity?: StrictTransportSecurityHeader\n  referrerPolicy?: ReferrerPolicyHeader\n  frameOptions?: FrameOptionsHeader\n}\n\nfunction validateCspParam(param: string): string {\n  if (param.indexOf('\"') !== -1) {\n    throw Error('CSP override contains invalid character \"')\n  }\n\n  if (param.indexOf(\";\") !== -1) {\n    throw Error(\"CSP override contains invalid character ;\")\n  }\n\n  if (param.indexOf(\"\\\\\") !== -1) {\n    throw Error(\"CSP override contains invalid character \\\\\")\n  }\n\n  return param\n}\n\n/* Replace all whitespace in a string with a single space */\nfunction trim(value: string): string {\n  return value.replace(/\\s+/g, \" \").trim()\n}\n\nfunction generateContentSecurityPolicyHeader(\n  headerOptions?: ContentSecurityPolicyHeader,\n) {\n  const defaultValues = {\n    baseUri: \"'self'\",\n    childSrc: \"'none'\",\n    connectSrc: \"'self'\",\n    defaultSrc: \"'self'\",\n    fontSrc: \"'self'\",\n    formAction: \"'self'\",\n    frameAncestors: \"'none'\",\n    frameSrc: \"'self'\",\n    imgSrc: \"'self'\",\n    manifestSrc: \"'self'\",\n    mediaSrc: \"'self'\",\n    objectSrc: \"'none'\",\n    scriptSrc: \"'self'\",\n    styleSrc: \"'self'\",\n  }\n\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n\n  Object.values(options).forEach(\n    (v) => typeof v === \"string\" && validateCspParam(v),\n  )\n\n  let headerValue = \"\"\n  headerValue += `base-uri ${trim(options.baseUri)};`\n  headerValue += `child-src ${trim(options.childSrc)};`\n  headerValue += `connect-src ${trim(options.connectSrc)};`\n  headerValue += `default-src ${trim(options.defaultSrc)};`\n  headerValue += `font-src ${trim(options.fontSrc)};`\n  headerValue += `frame-src ${trim(options.frameSrc)};`\n  headerValue += `img-src ${trim(options.imgSrc)};`\n  headerValue += `manifest-src ${trim(options.manifestSrc)};`\n  headerValue += `media-src ${trim(options.mediaSrc)};`\n  headerValue += `object-src ${trim(options.objectSrc)};`\n  headerValue += `script-src ${trim(options.scriptSrc)};`\n  headerValue += `style-src ${trim(options.styleSrc)};`\n\n  return trim(headerValue)\n}\n\nfunction generateStrictTransportSecurityHeader(\n  headerOptions?: StrictTransportSecurityHeader,\n) {\n  const defaultValues = {\n    maxAge: 63072000,\n    includeSubDomains: false,\n    preload: false,\n  }\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n  let headerValue = \"\"\n  headerValue += `max-age=${options.maxAge};`\n  headerValue += options.preload ? \"preload;\" : \"\"\n  headerValue += options.includeSubDomains ? \"includeSubDomains;\" : \"\"\n  return trim(headerValue)\n}\n\nfunction generateReferrerPolicyHeader(headerOptions?: ReferrerPolicyHeader) {\n  const defaultValues = {\n    value: \"strict-origin-when-cross-origin\",\n  }\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n  return options.value\n}\n\nfunction generateFrameOptionsHeader(headerOptions?: FrameOptionsHeader) {\n  const defaultValues = {\n    value: \"DENY\",\n  }\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n  return trim(options.value)\n}\n\nexport class WebappSecurityHeaders extends cdk.Construct {\n  public readonly securityHeadersFunction: cloudfront.Function\n\n  constructor(scope: cdk.Construct, id: string, props: SecurityHeaders) {\n    super(scope, id)\n\n    const cspHeaderName = props.contentSecurityPolicy?.reportOnly\n      ? \"content-security-policy-report-only\"\n      : \"content-security-policy\"\n\n    const contentSecurityPolicy = generateContentSecurityPolicyHeader(\n      props.contentSecurityPolicy,\n    )\n    const strictTransportSecurity = generateStrictTransportSecurityHeader(\n      props.strictTransportSecurity,\n    )\n    const referrerPolicy = generateReferrerPolicyHeader(props.referrerPolicy)\n    const frameOptions = generateFrameOptionsHeader(props.frameOptions)\n\n    const lambdaCode = `function handler(event) {\n      var response = event.response;\n      var headers = response.headers;\n      headers['referrer-policy'] = {value: '${referrerPolicy}'};\n      headers['strict-transport-security'] = {value: '${strictTransportSecurity}'};\n      headers['x-content-type-options'] = {value: 'nosniff'};\n      headers['x-frame-options'] = {value: '${frameOptions}'};\n      headers['x-xss-protection'] = {value: '1; mode=block'};\n      headers['${cspHeaderName}'] = {value: \"${contentSecurityPolicy}\"};\n      return response;\n    }`\n\n    // Hardcoded logical ID due to bug: https://github.com/aws/aws-cdk/issues/15523\n    const functionId = `Function${this.node.addr}`\n\n    this.securityHeadersFunction = new cloudfront.Function(this, functionId, {\n      functionName: functionId,\n      code: cloudfront.FunctionCode.fromInline(lambdaCode),\n    })\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liflig/cdk",
-  "version": "1.49.0",
+  "version": "1.51.1",
   "description": "Experimental CDK library for Liflig",
   "repository": {
     "type": "git",
@@ -9,7 +9,7 @@
   "scripts": {
     "build": "tsc",
     "watch": "tsc -w",
-    "test": "jest",
+    "test": "jest --runInBand",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "prepare": "npm run build && husky install",
@@ -34,51 +34,50 @@
     "access": "public"
   },
   "devDependencies": {
-    "@aws-cdk/assert": "1.128.0",
-    "@aws-cdk/aws-certificatemanager": "1.128.0",
-    "@aws-cdk/aws-cloudfront": "1.128.0",
-    "@aws-cdk/aws-cloudfront-origins": "1.128.0",
-    "@aws-cdk/aws-cloudwatch": "1.128.0",
-    "@aws-cdk/aws-cloudwatch-actions": "1.128.0",
-    "@aws-cdk/aws-codebuild": "1.128.0",
-    "@aws-cdk/aws-codepipeline": "1.128.0",
-    "@aws-cdk/aws-codepipeline-actions": "1.128.0",
-    "@aws-cdk/aws-ecs": "1.128.0",
-    "@aws-cdk/aws-events-targets": "1.128.0",
-    "@aws-cdk/aws-iam": "1.128.0",
-    "@aws-cdk/aws-lambda": "1.128.0",
-    "@aws-cdk/aws-logs": "1.128.0",
-    "@aws-cdk/aws-rds": "1.128.0",
-    "@aws-cdk/aws-route53": "1.128.0",
-    "@aws-cdk/aws-route53-targets": "1.128.0",
-    "@aws-cdk/aws-s3": "1.128.0",
-    "@aws-cdk/aws-ses": "1.128.0",
-    "@aws-cdk/aws-sns": "1.128.0",
-    "@aws-cdk/aws-stepfunctions": "1.128.0",
-    "@aws-cdk/aws-stepfunctions-tasks": "1.128.0",
-    "@aws-cdk/core": "1.128.0",
-    "@aws-cdk/custom-resources": "1.128.0",
-    "@aws-cdk/pipelines": "1.128.0",
-    "@commitlint/cli": "13.2.1",
-    "@commitlint/config-conventional": "13.2.0",
-    "@types/aws-lambda": "8.10.85",
-    "@types/jest": "27.0.2",
-    "@types/node": "16.11.6",
-    "@typescript-eslint/eslint-plugin": "5.3.0",
-    "@typescript-eslint/parser": "5.3.0",
-    "aws-cdk": "1.128.0",
-    "eslint": "7.32.0",
+    "@aws-cdk/assert": "1.135.0",
+    "@aws-cdk/aws-certificatemanager": "1.135.0",
+    "@aws-cdk/aws-cloudfront": "1.135.0",
+    "@aws-cdk/aws-cloudfront-origins": "1.135.0",
+    "@aws-cdk/aws-cloudwatch": "1.135.0",
+    "@aws-cdk/aws-cloudwatch-actions": "1.135.0",
+    "@aws-cdk/aws-codebuild": "1.135.0",
+    "@aws-cdk/aws-codepipeline": "1.135.0",
+    "@aws-cdk/aws-codepipeline-actions": "1.135.0",
+    "@aws-cdk/aws-ecs": "1.135.0",
+    "@aws-cdk/aws-events-targets": "1.135.0",
+    "@aws-cdk/aws-iam": "1.135.0",
+    "@aws-cdk/aws-lambda": "1.135.0",
+    "@aws-cdk/aws-logs": "1.135.0",
+    "@aws-cdk/aws-rds": "1.135.0",
+    "@aws-cdk/aws-route53": "1.135.0",
+    "@aws-cdk/aws-route53-targets": "1.135.0",
+    "@aws-cdk/aws-s3": "1.135.0",
+    "@aws-cdk/aws-ses": "1.135.0",
+    "@aws-cdk/aws-sns": "1.135.0",
+    "@aws-cdk/aws-stepfunctions": "1.135.0",
+    "@aws-cdk/aws-stepfunctions-tasks": "1.135.0",
+    "@aws-cdk/core": "1.135.0",
+    "@aws-cdk/custom-resources": "1.135.0",
+    "@aws-cdk/pipelines": "1.135.0",
+    "@commitlint/cli": "15.0.0",
+    "@commitlint/config-conventional": "15.0.0",
+    "@types/aws-lambda": "8.10.88",
+    "@types/jest": "27.0.3",
+    "@types/node": "16.11.14",
+    "@typescript-eslint/eslint-plugin": "5.7.0",
+    "@typescript-eslint/parser": "5.7.0",
+    "aws-cdk": "1.135.0",
+    "eslint": "8.5.0",
     "eslint-config-prettier": "8.3.0",
-    "eslint-plugin-deprecation": "1.2.1",
     "eslint-plugin-prettier": "4.0.0",
     "husky": "7.0.4",
-    "jest": "27.3.1",
+    "jest": "27.4.5",
     "jest-cdk-snapshot": "1.4.2",
-    "prettier": "2.4.1",
-    "semantic-release": "18.0.0",
-    "ts-jest": "27.0.7",
+    "prettier": "2.5.1",
+    "semantic-release": "18.0.1",
+    "ts-jest": "27.1.2",
     "ts-node": "10.4.0",
-    "typescript": "4.4.4"
+    "typescript": "4.5.4"
   },
   "dependencies": {
     "@capraconsulting/webapp-deploy-lambda": "^1.2.1",