raindancers-cloudfront 0.0.0

package/lib/cloudfront/cloudfront-functions/function-composer.js

@@ -0,0 +1,132 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionComposer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const securedCloudFront_1 = require("../patterns/securedCloudFront");
+/**
+ * Generates a combined CloudFront Function from modular check functions
+ * based on requested extensions
+ */
+class FunctionComposer {
+    constructor() {
+        this.modulesDir = path.join(__dirname, 'modules');
+    }
+    /**
+     * Generate combined function code based on requested extensions
+     */
+    compose(extensions, config, composerConfig) {
+        const parts = [];
+        // Always include shared utilities
+        parts.push(this.loadModule('shared-utils.js'));
+        // Include required check modules
+        const checks = [];
+        if (extensions.includes(securedCloudFront_1.Extension.REWRITE_TO_INDEX_HTML)) {
+            parts.push(this.loadModule('url-rewrite.js'));
+            checks.push('rewrite');
+        }
+        if (extensions.includes(securedCloudFront_1.Extension.REQUIRE_TLS_13)) {
+            parts.push(this.loadModule('tls-check.js'));
+            checks.push('tls');
+        }
+        if (extensions.includes(securedCloudFront_1.Extension.REQUIRE_AUTH)) {
+            const isCognito = composerConfig?.cognitoDomain !== undefined;
+            let authModule = this.loadModule(isCognito ? 'cognito-auth-check.js' : 'auth-check.js');
+            if (composerConfig) {
+                if (composerConfig.cognitoDomain) {
+                    authModule = authModule.replace(/COGNITO_DOMAIN_PLACEHOLDER/g, composerConfig.cognitoDomain);
+                }
+                if (composerConfig.tenantId) {
+                    authModule = authModule.replace(/TENANT_ID_PLACEHOLDER/g, composerConfig.tenantId);
+                }
+                if (composerConfig.clientId) {
+                    authModule = authModule.replace(/CLIENT_ID_PLACEHOLDER/g, composerConfig.clientId);
+                }
+                if (composerConfig.redirectUri) {
+                    authModule = authModule.replace(/REDIRECT_URI_PLACEHOLDER/g, composerConfig.redirectUri);
+                }
+            }
+            parts.push(authModule);
+            checks.push('auth');
+        }
+        // Generate handler function
+        parts.push(this.generateHandler(checks, config));
+        const code = parts.join('\n\n');
+        const sizeKB = Buffer.byteLength(code, 'utf-8') / 1024;
+        if (sizeKB > 10) {
+            throw new Error(`CloudFront Function exceeds 10KB limit: ${sizeKB.toFixed(2)}KB (extensions: ${extensions.join(', ')})`);
+        }
+        return code;
+    }
+    loadModule(filename) {
+        const filePath = path.join(this.modulesDir, filename);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return content
+            .replace(/\/\*[\s\S]*?\*\//g, '') // block comments
+            .replace(/^\s*\/\/.*$/gm, '') // line comments (whole-line only)
+            .replace(/^\s*\n/gm, '') // blank lines
+            .replace(/function handler\(event\) \{[\s\S]*?\n\}/g, '')
+            .replace(/async function handler\(event\) \{[\s\S]*?\n\}/g, '');
+    }
+    generateHandler(checks, config) {
+        const hasAuth = checks.includes('auth');
+        const lines = [
+            '// Generated handler function',
+            hasAuth ? 'async function handler(event) {' : 'function handler(event) {',
+            '  var decodedPayload = null;',
+            '',
+        ];
+        // Add TLS check
+        if (checks.includes('tls')) {
+            lines.push('  // TLS 1.3 enforcement', '  var tlsResult = checkTLS(event);', '  if (tlsResult) return tlsResult;', '');
+        }
+        // Add auth check (with optional role checking built-in)
+        if (hasAuth) {
+            const requiredRoles = config?.requiredRoles ? config.requiredRoles : [];
+            const matchMode = config?.roleMatchMode || securedCloudFront_1.RoleMatchMode.OR;
+            const rolesJson = JSON.stringify(requiredRoles);
+            lines.push('  // Authentication check', `  var requiredRoles = ${rolesJson};`, `  var matchMode = '${matchMode}';`, '  var authResult = await checkAuth(event, decodedPayload, requiredRoles, matchMode);', '  if (!authResult.pass) return authResult.response;', '  decodedPayload = authResult.payload;', '', '  // Inject Azure AD JWT for AssumeRoleWithWebIdentity (Azure only)', '  if (typeof injectAzureToken === \'function\') {', '    event.request = injectAzureToken(event.request, event.request.cookies);', '  }', '');
+        }
+        // Add URL rewrite after auth so originalPath is saved correctly
+        if (checks.includes('rewrite')) {
+            lines.push('  rewriteToIndex(event);', '');
+        }
+        lines.push('  // All checks passed', '  return event.request;', '}');
+        return lines.join('\n');
+    }
+}
+exports.FunctionComposer = FunctionComposer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-composer.js","sourceRoot":"","sources":["../../../src/cloudfront/cloudfront-functions/function-composer.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Extension, ExtensionConfig, RoleMatchMode } from '../patterns/securedCloudFront';\n\nexport interface ComposerConfig {\n  readonly tenantId?: string;\n  readonly cognitoDomain?: string;\n  readonly clientId?: string;\n  readonly redirectUri?: string;\n}\n\n/**\n * Generates a combined CloudFront Function from modular check functions\n * based on requested extensions\n */\nexport class FunctionComposer {\n  private readonly modulesDir: string;\n\n  constructor() {\n    this.modulesDir = path.join(__dirname, 'modules');\n  }\n\n  /**\n   * Generate combined function code based on requested extensions\n   */\n  public compose(extensions: Extension[], config?: ExtensionConfig, composerConfig?: ComposerConfig): string {\n    const parts: string[] = [];\n\n    // Always include shared utilities\n    parts.push(this.loadModule('shared-utils.js'));\n\n    // Include required check modules\n    const checks: string[] = [];\n\n    if (extensions.includes(Extension.REWRITE_TO_INDEX_HTML)) {\n      parts.push(this.loadModule('url-rewrite.js'));\n      checks.push('rewrite');\n    }\n\n    if (extensions.includes(Extension.REQUIRE_TLS_13)) {\n      parts.push(this.loadModule('tls-check.js'));\n      checks.push('tls');\n    }\n\n    if (extensions.includes(Extension.REQUIRE_AUTH)) {\n      const isCognito = composerConfig?.cognitoDomain !== undefined;\n      let authModule = this.loadModule(isCognito ? 'cognito-auth-check.js' : 'auth-check.js');\n      if (composerConfig) {\n        if (composerConfig.cognitoDomain) {\n          authModule = authModule.replace(/COGNITO_DOMAIN_PLACEHOLDER/g, composerConfig.cognitoDomain);\n        }\n        if (composerConfig.tenantId) {\n          authModule = authModule.replace(/TENANT_ID_PLACEHOLDER/g, composerConfig.tenantId);\n        }\n        if (composerConfig.clientId) {\n          authModule = authModule.replace(/CLIENT_ID_PLACEHOLDER/g, composerConfig.clientId);\n        }\n        if (composerConfig.redirectUri) {\n          authModule = authModule.replace(/REDIRECT_URI_PLACEHOLDER/g, composerConfig.redirectUri);\n        }\n      }\n      parts.push(authModule);\n      checks.push('auth');\n    }\n\n    // Generate handler function\n    parts.push(this.generateHandler(checks, config));\n\n    const code = parts.join('\\n\\n');\n    const sizeKB = Buffer.byteLength(code, 'utf-8') / 1024;\n\n    if (sizeKB > 10) {\n      throw new Error(`CloudFront Function exceeds 10KB limit: ${sizeKB.toFixed(2)}KB (extensions: ${extensions.join(', ')})`);\n    }\n\n    return code;\n  }\n\n  private loadModule(filename: string): string {\n    const filePath = path.join(this.modulesDir, filename);\n    const content = fs.readFileSync(filePath, 'utf-8');\n\n    return content\n      .replace(/\\/\\*[\\s\\S]*?\\*\\//g, '') // block comments\n      .replace(/^\\s*\\/\\/.*$/gm, '') // line comments (whole-line only)\n      .replace(/^\\s*\\n/gm, '') // blank lines\n      .replace(/function handler\\(event\\) \\{[\\s\\S]*?\\n\\}/g, '')\n      .replace(/async function handler\\(event\\) \\{[\\s\\S]*?\\n\\}/g, '');\n  }\n\n  private generateHandler(checks: string[], config?: ExtensionConfig): string {\n    const hasAuth = checks.includes('auth');\n    const lines: string[] = [\n      '// Generated handler function',\n      hasAuth ? 'async function handler(event) {' : 'function handler(event) {',\n      '  var decodedPayload = null;',\n      '',\n    ];\n\n    // Add TLS check\n    if (checks.includes('tls')) {\n      lines.push(\n        '  // TLS 1.3 enforcement',\n        '  var tlsResult = checkTLS(event);',\n        '  if (tlsResult) return tlsResult;',\n        '',\n      );\n    }\n\n    // Add auth check (with optional role checking built-in)\n    if (hasAuth) {\n      const requiredRoles = config?.requiredRoles ? config.requiredRoles : [];\n      const matchMode = config?.roleMatchMode || RoleMatchMode.OR;\n      const rolesJson = JSON.stringify(requiredRoles);\n\n      lines.push(\n        '  // Authentication check',\n        `  var requiredRoles = ${rolesJson};`,\n        `  var matchMode = '${matchMode}';`,\n        '  var authResult = await checkAuth(event, decodedPayload, requiredRoles, matchMode);',\n        '  if (!authResult.pass) return authResult.response;',\n        '  decodedPayload = authResult.payload;',\n        '',\n        '  // Inject Azure AD JWT for AssumeRoleWithWebIdentity (Azure only)',\n        '  if (typeof injectAzureToken === \\'function\\') {',\n        '    event.request = injectAzureToken(event.request, event.request.cookies);',\n        '  }',\n        '',\n      );\n    }\n\n    // Add URL rewrite after auth so originalPath is saved correctly\n    if (checks.includes('rewrite')) {\n      lines.push(\n        '  rewriteToIndex(event);',\n        '',\n      );\n    }\n\n    lines.push(\n      '  // All checks passed',\n      '  return event.request;',\n      '}',\n    );\n\n    return lines.join('\\n');\n  }\n}\n"]}

package/lib/cloudfront/cloudfrontCertificate.d.ts

@@ -0,0 +1,40 @@
+import { aws_route53 as route53, aws_certificatemanager as acm } from 'aws-cdk-lib';
+import * as constructs from 'constructs';
+/**
+ * Properties for CloudFrontCertificate construct.
+ */
+export interface CloudFrontCertificateProps {
+    /** Domain name for the certificate (e.g., 'example.com' or '*.example.com') */
+    readonly domainName: string;
+    /** Route53 hosted zone for DNS validation */
+    readonly hostedZone: route53.IHostedZone;
+    /** Optional subject alternative names */
+    readonly subjectAlternativeNames?: string[];
+}
+/**
+ * Creates an ACM certificate in us-east-1 for use with CloudFront.
+ *
+ * CloudFront requires certificates to be in us-east-1 region.
+ * This construct uses a custom resource to create the certificate
+ * in us-east-1 regardless of the stack's region.
+ *
+ * @example
+ * ```typescript
+ * const cert = new CloudFrontCertificate(this, 'Certificate', {
+ *   domainName: 'example.com',
+ *   hostedZone: zone,
+ *   subjectAlternativeNames: ['*.example.com'],
+ * });
+ *
+ * new cloudfront.Distribution(this, 'Distribution', {
+ *   certificate: cert.certificate,
+ *   domainNames: ['example.com'],
+ *   // ...
+ * });
+ * ```
+ */
+export declare class CloudFrontCertificate extends constructs.Construct {
+    /** The ACM certificate in us-east-1 */
+    readonly certificate: acm.ICertificate;
+    constructor(scope: constructs.Construct, id: string, props: CloudFrontCertificateProps);
+}

package/lib/cloudfront/cloudfrontCertificate.js

@@ -0,0 +1,116 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudFrontCertificate = void 0;
+const path = __importStar(require("path"));
+const core = __importStar(require("aws-cdk-lib"));
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs = __importStar(require("constructs"));
+/**
+ * Creates an ACM certificate in us-east-1 for use with CloudFront.
+ *
+ * CloudFront requires certificates to be in us-east-1 region.
+ * This construct uses a custom resource to create the certificate
+ * in us-east-1 regardless of the stack's region.
+ *
+ * @example
+ * ```typescript
+ * const cert = new CloudFrontCertificate(this, 'Certificate', {
+ *   domainName: 'example.com',
+ *   hostedZone: zone,
+ *   subjectAlternativeNames: ['*.example.com'],
+ * });
+ *
+ * new cloudfront.Distribution(this, 'Distribution', {
+ *   certificate: cert.certificate,
+ *   domainNames: ['example.com'],
+ *   // ...
+ * });
+ * ```
+ */
+class CloudFrontCertificate extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const certLogGroup = new aws_cdk_lib_1.aws_logs.LogGroup(this, 'CertificateFunctionLogGroup', {
+            retention: aws_cdk_lib_1.aws_logs.RetentionDays.ONE_WEEK,
+        });
+        const certFunction = new aws_cdk_lib_1.aws_lambda.SingletonFunction(this, 'CertificateFunction', {
+            uuid: 'cloudfront-certificate-us-east-1',
+            runtime: aws_cdk_lib_1.aws_lambda.Runtime.PYTHON_3_12,
+            handler: 'index.handler',
+            code: aws_cdk_lib_1.aws_lambda.Code.fromAsset(path.join(__dirname, 'lambda', 'certificate')),
+            timeout: core.Duration.minutes(15),
+            logGroup: certLogGroup,
+        });
+        certFunction.addToRolePolicy(new aws_cdk_lib_1.aws_iam.PolicyStatement({
+            actions: [
+                'acm:RequestCertificate',
+                'acm:DescribeCertificate',
+                'acm:DeleteCertificate',
+                'acm:AddTagsToCertificate',
+            ],
+            resources: ['*'],
+        }));
+        certFunction.addToRolePolicy(new aws_cdk_lib_1.aws_iam.PolicyStatement({
+            actions: [
+                'route53:GetChange',
+                'route53:ListHostedZones',
+            ],
+            resources: ['*'],
+        }));
+        certFunction.addToRolePolicy(new aws_cdk_lib_1.aws_iam.PolicyStatement({
+            actions: [
+                'route53:ChangeResourceRecordSets',
+            ],
+            resources: [props.hostedZone.hostedZoneArn],
+        }));
+        const provider = new aws_cdk_lib_1.custom_resources.Provider(this, 'CertificateProvider', {
+            onEventHandler: certFunction,
+        });
+        const resource = new core.CustomResource(this, 'CertificateResource', {
+            resourceType: 'Custom::CloudFrontCertificateInUsEast1',
+            serviceToken: provider.serviceToken,
+            properties: {
+                DomainName: props.domainName,
+                SubjectAlternativeNames: props.subjectAlternativeNames || [],
+                HostedZoneId: props.hostedZone.hostedZoneId,
+                Region: 'us-east-1',
+            },
+        });
+        this.certificate = aws_cdk_lib_1.aws_certificatemanager.Certificate.fromCertificateArn(this, 'Certificate', resource.getAttString('CertificateArn'));
+    }
+}
+exports.CloudFrontCertificate = CloudFrontCertificate;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cloudfront/cloudfrontWebAcl.d.ts

@@ -0,0 +1,72 @@
+import { aws_wafv2 as wafv2 } from 'aws-cdk-lib';
+import * as constructs from 'constructs';
+import { Country } from './countries';
+export { Country, CountryCode } from './countries';
+export type CountryName = keyof typeof Country;
+/**
+ * Path-specific rate limit configuration.
+ */
+export interface PathRateLimit {
+    /** URI path pattern (e.g., '/oauth2/callback', '/api/auth/*') */
+    readonly path: string;
+    /** Rate limit for this path (requests per 5 minutes) */
+    readonly rateLimit: number;
+    /** Optional name for the rule (auto-generated if not provided) */
+    readonly name?: string;
+}
+/**
+ * Properties for CloudFrontWebAcl construct.
+ */
+export interface CloudFrontWebAclProps {
+    /** Name for the Web ACL */
+    readonly name?: string;
+    /** Whether to enable AWS managed rules (default: true) */
+    readonly enableManagedRules?: boolean;
+    /** Custom rules to add to the Web ACL */
+    readonly rules?: wafv2.CfnWebACL.RuleProperty[];
+    /** Rate limit for requests per 5 minutes (default: 2000) */
+    readonly rateLimit?: number;
+    /** Path-specific rate limits (overrides default rateLimit for matching paths) */
+    readonly pathRateLimits?: PathRateLimit[];
+    /** Allow requests only from these countries (all others blocked) */
+    readonly allowedCountries?: CountryName[];
+    /** Block requests from these countries (all others allowed) */
+    readonly blockedCountries?: CountryName[];
+}
+/**
+ * Creates a WAF WebACL in us-east-1 for use with CloudFront.
+ *
+ * CloudFront requires WAF WebACLs to be in us-east-1 with CLOUDFRONT scope.
+ * This construct uses a custom resource to create the WebACL in us-east-1
+ * regardless of the stack's region.
+ *
+ * Provides sensible defaults with AWS managed rules for common threats.
+ *
+ * @example
+ * ```typescript
+ * const webAcl = new CloudFrontWebAcl(this, 'WebAcl', {
+ *   name: 'MyCloudFrontWebAcl',
+ *   rateLimit: 10000, // Default for all paths
+ *   pathRateLimits: [
+ *     { path: '/oauth2/callback', rateLimit: 100 },
+ *     { path: '/oauth2/authorize', rateLimit: 100 },
+ *     { path: '/api/auth', rateLimit: 500 },
+ *   ],
+ *   allowedCountries: ['UnitedStates', 'Canada', 'UnitedKingdom'],
+ * });
+ *
+ * new cloudfront.Distribution(this, 'Distribution', {
+ *   webAclId: webAcl.webAclArn,
+ *   // ...
+ * });
+ * ```
+ */
+export declare class CloudFrontWebAcl extends constructs.Construct {
+    /** The WebACL ARN */
+    readonly webAclArn: string;
+    /** The WebACL ID */
+    readonly webAclId: string;
+    private readonly webAcl;
+    constructor(scope: constructs.Construct, id: string, props?: CloudFrontWebAclProps);
+    private buildRules;
+}