@alliander-opensource/aws-jwt-sts 0.2.6

package/dist/index.js

@@ -0,0 +1,451 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Alliander NV
+//
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsJwtSts = exports.wafUsage = void 0;
+/* eslint-disable no-unused-vars */
+const cdk = require("aws-cdk-lib");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const sfn = require("aws-cdk-lib/aws-stepfunctions");
+const tasks = require("aws-cdk-lib/aws-stepfunctions-tasks");
+const iam = require("aws-cdk-lib/aws-iam");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const s3 = require("aws-cdk-lib/aws-s3");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const cloudfront = require("aws-cdk-lib/aws-cloudfront");
+const cloudfrontOrigins = require("aws-cdk-lib/aws-cloudfront-origins");
+const events = require("aws-cdk-lib/aws-events");
+const targets = require("aws-cdk-lib/aws-events-targets");
+const acm = require("aws-cdk-lib/aws-certificatemanager");
+const route53 = require("aws-cdk-lib/aws-route53");
+const route53targets = require("aws-cdk-lib/aws-route53-targets");
+const apigateway = require("aws-cdk-lib/aws-apigateway");
+const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
+const wafv2 = require("aws-cdk-lib/aws-wafv2");
+const sns = require("aws-cdk-lib/aws-sns");
+const logs = require("aws-cdk-lib/aws-logs");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
+const lambdaNodejs = require("aws-cdk-lib/aws-lambda-nodejs");
+const constructs_1 = require("constructs");
+var wafUsage;
+(function (wafUsage) {
+    wafUsage[wafUsage["ConstructProvided"] = 0] = "ConstructProvided";
+    wafUsage[wafUsage["ProvideWebAclArn"] = 1] = "ProvideWebAclArn";
+})(wafUsage = exports.wafUsage || (exports.wafUsage = {}));
+/* eslint-disable no-new */
+class AwsJwtSts extends constructs_1.Construct {
+    constructor(app, id, props) {
+        super(app, id);
+        /** ---------------------- Custom domain thingies ----------------------- */
+        let distributionDomainNames = [];
+        let oidcCertificate;
+        let tokenCertificate;
+        let hostedZone;
+        const oidcSubdomain = props.oidcSubdomain ? props.oidcSubdomain : 'oidc';
+        const tokenSubdomain = props.tokenSubdomain ? props.tokenSubdomain : 'token';
+        const architecture = props.architecture ? props.architecture : lambda.Architecture.X86_64;
+        let oidcDomainName = '';
+        let tokenDomainName = '';
+        const useCustomDomain = props.hostedZoneId && props.hostedZoneName;
+        if (useCustomDomain) {
+            oidcDomainName = oidcSubdomain + '.' + props.hostedZoneName;
+            tokenDomainName = tokenSubdomain + '.' + props.hostedZoneName;
+            distributionDomainNames = [oidcDomainName];
+            hostedZone = route53.HostedZone.fromHostedZoneAttributes(this, 'hostedZone', {
+                zoneName: props.hostedZoneName,
+                hostedZoneId: props.hostedZoneId
+            });
+            oidcCertificate = new acm.DnsValidatedCertificate(this, 'CrossRegionCertificate', {
+                domainName: oidcDomainName,
+                hostedZone,
+                region: 'us-east-1'
+            });
+            tokenCertificate = new acm.Certificate(this, 'tokenCertificate', {
+                domainName: tokenDomainName,
+                validation: acm.CertificateValidation.fromDns(hostedZone)
+            });
+        }
+        /** ---------------------- S3 Definition ----------------------- */
+        // Create bucket where oidc information can be stored
+        const oidcbucket = new s3.Bucket(this, 'oidcbucket', {
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+            autoDeleteObjects: true,
+            encryption: aws_s3_1.BucketEncryption.S3_MANAGED,
+            versioned: true,
+            blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL
+        });
+        /** ------------------- Cloudfront Definition ------------------- */
+        const cloudfrontOAI = new cloudfront.OriginAccessIdentity(this, 'cloudfront-OAI', {
+            comment: 'OAI for oidc'
+        });
+        const distribution = new cloudfront.Distribution(this, 'oidcDistribution', {
+            domainNames: distributionDomainNames,
+            comment: 'Discovery endpoint for OIDC',
+            certificate: oidcCertificate,
+            defaultBehavior: {
+                origin: new cloudfrontOrigins.S3Origin(oidcbucket, { originAccessIdentity: cloudfrontOAI }),
+                compress: true,
+                allowedMethods: cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+                viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS
+            }
+        });
+        /** ------------------ Lambda Handlers Definition ------------------ */
+        const issuer = useCustomDomain ? 'https://' + oidcDomainName : 'https://' + distribution.distributionDomainName;
+        const rotateKeysRole = new iam.Role(this, 'rotateKeysRole', {
+            assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')]
+        });
+        const rotateKeys = new lambdaNodejs.NodejsFunction(this, 'keyrotate', {
+            timeout: cdk.Duration.seconds(5),
+            runtime: lambda.Runtime.NODEJS_18_X,
+            role: rotateKeysRole,
+            architecture,
+            environment: {
+                S3_BUCKET: oidcbucket.bucketName,
+                ISSUER: issuer
+            }
+        });
+        const signRole = new iam.Role(this, 'signRole', {
+            assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')]
+        });
+        const sign = new lambdaNodejs.NodejsFunction(this, 'sign', {
+            timeout: cdk.Duration.seconds(5),
+            runtime: lambda.Runtime.NODEJS_18_X,
+            role: signRole,
+            architecture,
+            environment: {
+                ISSUER: issuer,
+                DEFAULT_AUDIENCE: props.defaultAudience
+            }
+        });
+        /** ------------------------ SNS Topic ------------------------- */
+        this.failedRotationTopic = new sns.Topic(this, 'sts');
+        const snsFail = new tasks.SnsPublish(this, 'snsFailed', {
+            topic: this.failedRotationTopic,
+            subject: 'STS KeyRotate step function execution failed',
+            message: sfn.TaskInput.fromJsonPathAt('$')
+        });
+        /** ------------------ Step functions Definition ------------------ */
+        const deletePreviousStep = new tasks.LambdaInvoke(this, 'delete Previous', {
+            lambdaFunction: rotateKeys,
+            payload: sfn.TaskInput.fromObject({
+                step: 'deletePrevious'
+            }),
+            outputPath: '$.Payload'
+        });
+        const movePreviousStep = new tasks.LambdaInvoke(this, 'move Previous', {
+            lambdaFunction: rotateKeys,
+            payload: sfn.TaskInput.fromObject({
+                step: 'movePrevious'
+            }),
+            outputPath: '$.Payload'
+        });
+        const moveCurrentStep = new tasks.LambdaInvoke(this, 'move Current', {
+            lambdaFunction: rotateKeys,
+            payload: sfn.TaskInput.fromObject({
+                step: 'moveCurrent'
+            }),
+            outputPath: '$.Payload'
+        });
+        const createPendingStep = new tasks.LambdaInvoke(this, 'create Pending', {
+            lambdaFunction: rotateKeys,
+            payload: sfn.TaskInput.fromObject({
+                step: 'createPending'
+            }),
+            outputPath: '$.Payload'
+        });
+        const generateArtifactsStep = new tasks.LambdaInvoke(this, 'generate artifacts', {
+            lambdaFunction: rotateKeys,
+            payload: sfn.TaskInput.fromObject({
+                step: 'generateArtifacts'
+            }),
+            outputPath: '$.Payload'
+        });
+        const jobFailed = new sfn.Fail(this, 'Failed', {
+            cause: 'AWS Batch Job Failed',
+            error: 'DescribeJob returned FAILED'
+        });
+        const jobSuccess = new sfn.Succeed(this, 'Success!');
+        deletePreviousStep.addCatch(snsFail);
+        movePreviousStep.addCatch(snsFail);
+        moveCurrentStep.addCatch(snsFail);
+        createPendingStep.addCatch(snsFail);
+        generateArtifactsStep.addCatch(snsFail);
+        // Create chain
+        const definition = deletePreviousStep
+            .next(movePreviousStep)
+            .next(moveCurrentStep)
+            .next(createPendingStep)
+            .next(generateArtifactsStep)
+            .next(jobSuccess);
+        snsFail.next(jobFailed);
+        // Create state machine
+        const rotateKeysMachine = new sfn.StateMachine(this, 'RotateKeys', {
+            definition,
+            timeout: cdk.Duration.minutes(5)
+        });
+        rotateKeys.grantInvoke(rotateKeysMachine.role);
+        oidcbucket.grantReadWrite(rotateKeys);
+        const statementSign = new iam.PolicyStatement();
+        statementSign.addActions('kms:*');
+        statementSign.addResources('*');
+        const signPolicy = new iam.ManagedPolicy(this, 'SignPolicy', {
+            statements: [statementSign]
+        });
+        signRole.addManagedPolicy(signPolicy);
+        const statementRotateKeys = new iam.PolicyStatement();
+        statementRotateKeys.addActions('kms:*');
+        statementRotateKeys.addResources('*');
+        const rotateKeysPolicy = new iam.ManagedPolicy(this, 'RotateKeysPolicy', {
+            statements: [statementRotateKeys]
+        });
+        rotateKeysRole.addManagedPolicy(rotateKeysPolicy);
+        /** ------------------ Events Rule Definition ------------------ */
+        // Run every 3 months at 8 PM UTC
+        const scheduledRotateRule = new events.Rule(this, 'scheduledRotateRule', {
+            schedule: events.Schedule.expression('cron(0 20 1 */3 ? *)')
+        });
+        scheduledRotateRule.addTarget(new targets.SfnStateMachine(rotateKeysMachine));
+        // Create state machine and trigger to populate initial keys
+        if (!props.disableKeyRotateOnCreate) {
+            const rotateOnce = new tasks.StepFunctionsStartExecution(this, 'rotateOnce', {
+                stateMachine: rotateKeysMachine,
+                integrationPattern: sfn.IntegrationPattern.RUN_JOB
+            });
+            const rotateTwice = new tasks.StepFunctionsStartExecution(this, 'rotateTwice', {
+                stateMachine: rotateKeysMachine,
+                integrationPattern: sfn.IntegrationPattern.RUN_JOB
+            });
+            const populateKeys = new sfn.StateMachine(this, 'populateKeys', {
+                definition: rotateOnce.next(rotateTwice),
+                timeout: cdk.Duration.minutes(10)
+            });
+            const initialRunRule = new events.Rule(this, 'initialRunRule', {
+                eventPattern: {
+                    source: ['aws.cloudformation'],
+                    resources: [cdk.Stack.of(this).stackId],
+                    detailType: ['CloudFormation Stack Status Change'],
+                    detail: {
+                        'status-details': {
+                            status: ['CREATE_COMPLETE']
+                        }
+                    }
+                }
+            });
+            initialRunRule.addTarget(new targets.SfnStateMachine(populateKeys));
+        }
+        /** ---------------------- API Gateway ----------------------- */
+        // only set policy when orgId is set
+        let apiPolicy;
+        if (props.orgId) {
+            apiPolicy = new iam.PolicyDocument({
+                statements: [
+                    new iam.PolicyStatement({
+                        actions: ['execute-api:Invoke'],
+                        resources: ['*'],
+                        principals: [
+                            new aws_iam_1.OrganizationPrincipal(props.orgId)
+                        ]
+                    })
+                ]
+            });
+        }
+        const logGroup = new logs.LogGroup(this, 'APIGatewayAccessLogs', {
+            retention: 7
+        });
+        // Create API
+        const api = new apigateway.LambdaRestApi(this, 'jwk-sts-api', {
+            description: 'STS Token API Gateway',
+            handler: sign,
+            defaultMethodOptions: {
+                authorizationType: apigateway.AuthorizationType.IAM
+            },
+            endpointConfiguration: {
+                types: [apigateway.EndpointType.REGIONAL]
+            },
+            policy: apiPolicy,
+            deployOptions: {
+                loggingLevel: aws_apigateway_1.MethodLoggingLevel.INFO,
+                accessLogDestination: new apigateway.LogGroupLogDestination(logGroup)
+            }
+        });
+        /** ------------------- Route53 Definition for custom domain ------------------- */
+        if (useCustomDomain && hostedZone) {
+            api.addDomainName('apiCustomDomainName', {
+                domainName: tokenDomainName,
+                certificate: tokenCertificate
+            });
+            // Add A record for cloudfront distribution
+            new route53.ARecord(this, 'oidcRecord', {
+                recordName: oidcDomainName,
+                zone: hostedZone,
+                target: route53.RecordTarget.fromAlias(new route53targets.CloudFrontTarget(distribution))
+            });
+            new route53.ARecord(this, 'tokenRecord', {
+                recordName: tokenDomainName,
+                zone: hostedZone,
+                target: route53.RecordTarget.fromAlias(new route53targets.ApiGateway(api))
+            });
+            new cdk.CfnOutput(this, 'tokenEndpoint', {
+                value: 'https://' + tokenDomainName + '/token',
+                description: 'Url of the token endpoint',
+                exportName: 'tokenEndpoint'
+            });
+        }
+        else {
+            new cdk.CfnOutput(this, 'tokenEndpoint', {
+                value: api.url + 'token',
+                description: 'Url of the token endpoint',
+                exportName: 'tokenEndpoint'
+            });
+        }
+        new cdk.CfnOutput(this, 'issuer', {
+            value: issuer,
+            description: 'Url of the issuer',
+            exportName: 'issuer'
+        });
+        /** ---------------------- WAF ----------------------- */
+        if (props.apiGwWaf === wafUsage.ConstructProvided) {
+            // API gateway WAF ACL and rules
+            const APIGatewayWebACL = new wafv2.CfnWebACL(this, 'APIGatewayWebACL', {
+                description: 'This is WebACL for Auth APi Gateway',
+                scope: 'REGIONAL',
+                defaultAction: { allow: {} },
+                visibilityConfig: {
+                    metricName: 'APIWebACL',
+                    cloudWatchMetricsEnabled: true,
+                    sampledRequestsEnabled: true
+                },
+                rules: [
+                    {
+                        name: 'AWS-AWSManagedRulesCommonRuleSet',
+                        priority: 0,
+                        statement: {
+                            managedRuleGroupStatement: {
+                                vendorName: 'AWS',
+                                name: 'AWSManagedRulesCommonRuleSet'
+                            }
+                        },
+                        overrideAction: {
+                            none: {}
+                        },
+                        visibilityConfig: {
+                            sampledRequestsEnabled: true,
+                            cloudWatchMetricsEnabled: true,
+                            metricName: 'AWS-AWSManagedRulesCommonRuleSet'
+                        }
+                    },
+                    {
+                        name: 'AWS-AWSManagedRulesAmazonIpReputationList',
+                        priority: 1,
+                        statement: {
+                            managedRuleGroupStatement: {
+                                vendorName: 'AWS',
+                                name: 'AWSManagedRulesAmazonIpReputationList'
+                            }
+                        },
+                        overrideAction: {
+                            none: {}
+                        },
+                        visibilityConfig: {
+                            sampledRequestsEnabled: true,
+                            cloudWatchMetricsEnabled: true,
+                            metricName: 'AWS-AWSManagedRulesAmazonIpReputationList'
+                        }
+                    },
+                    {
+                        name: 'api-gw-AuthAPIGeoLocation',
+                        priority: 3,
+                        action: { block: {} },
+                        visibilityConfig: {
+                            metricName: 'AuthAPIGeoLocation',
+                            cloudWatchMetricsEnabled: true,
+                            sampledRequestsEnabled: false
+                        },
+                        statement: {
+                            geoMatchStatement: {
+                                countryCodes: ['BY', 'CN', 'IR', 'RU', 'SY', 'KP']
+                            }
+                        }
+                    },
+                    {
+                        name: 'api-gw-rateLimitRule',
+                        priority: 4,
+                        action: { block: {} },
+                        visibilityConfig: {
+                            metricName: 'rateLimitRule',
+                            cloudWatchMetricsEnabled: true,
+                            sampledRequestsEnabled: false
+                        },
+                        statement: {
+                            rateBasedStatement: {
+                                aggregateKeyType: 'IP',
+                                limit: 100
+                            }
+                        }
+                    }
+                ]
+            });
+            // Web ACL Association
+            new wafv2.CfnWebACLAssociation(this, 'APIGatewayWebACLAssociation', {
+                webAclArn: APIGatewayWebACL.attrArn,
+                resourceArn: api.deploymentStage.stageArn
+            });
+        }
+        else if (props.apiGwWaf === wafUsage.ProvideWebAclArn && props.apiGwWafWebAclArn) {
+            // Web ACL Association
+            new wafv2.CfnWebACLAssociation(this, 'APIGatewayWebACLAssociation', {
+                webAclArn: props.apiGwWafWebAclArn,
+                resourceArn: api.deploymentStage.stageArn
+            });
+        }
+        /** ---------------------- Cloudwatch ----------------------- */
+        new cloudwatch.Alarm(this, 'StepFunctionError', {
+            alarmName: props.alarmNameKeyRotationStepFunctionFailed ?? 'sts-key_rotate_sfn-alarm',
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: 1,
+            evaluationPeriods: 1,
+            metric: rotateKeysMachine.metricFailed(),
+            alarmDescription: 'Key Rotation Failed',
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING
+        });
+        new cloudwatch.Alarm(this, 'ApiGateway5XXAlarm', {
+            alarmName: props.alarmNameApiGateway5xx ?? 'sts-5xx_api_gw-alarm',
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: 1,
+            evaluationPeriods: 1,
+            metric: api.metricServerError(),
+            alarmDescription: '5xx STS API gateway failures',
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING
+        });
+        const signErrors = sign.metricErrors({
+            period: cdk.Duration.minutes(1)
+        });
+        const rotateErrors = rotateKeys.metricErrors({
+            period: cdk.Duration.minutes(1)
+        });
+        new cloudwatch.Alarm(this, 'LambdaSignError', {
+            alarmName: props.alarmNameSignLambdaFailed ?? 'sts-sign_errors_lambda-alarm',
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: 1,
+            evaluationPeriods: 1,
+            metric: signErrors,
+            alarmDescription: 'Sign Lambda Failed',
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING
+        });
+        new cloudwatch.Alarm(this, 'LambdaRotateError', {
+            alarmName: props.alarmNameKeyRotationLambdaFailed ?? 'sts-key_rotate_errors_lambda-alarm',
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: 1,
+            evaluationPeriods: 1,
+            metric: rotateErrors,
+            alarmDescription: 'Key Rotation Lambda Failed',
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING
+        });
+    }
+}
+exports.AwsJwtSts = AwsJwtSts;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-FileCopyrightText: 2023 Alliander NV\n//\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable no-unused-vars */\nimport * as cdk from 'aws-cdk-lib'\nimport * as lambda from 'aws-cdk-lib/aws-lambda'\nimport * as sfn from 'aws-cdk-lib/aws-stepfunctions'\nimport * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks'\nimport * as iam from 'aws-cdk-lib/aws-iam'\nimport { OrganizationPrincipal, PolicyDocument } from 'aws-cdk-lib/aws-iam'\nimport * as s3 from 'aws-cdk-lib/aws-s3'\nimport { BucketEncryption } from 'aws-cdk-lib/aws-s3'\nimport * as cloudfront from 'aws-cdk-lib/aws-cloudfront'\nimport * as cloudfrontOrigins from 'aws-cdk-lib/aws-cloudfront-origins'\nimport * as events from 'aws-cdk-lib/aws-events'\nimport * as targets from 'aws-cdk-lib/aws-events-targets'\nimport * as acm from 'aws-cdk-lib/aws-certificatemanager'\nimport * as route53 from 'aws-cdk-lib/aws-route53'\nimport * as route53targets from 'aws-cdk-lib/aws-route53-targets'\nimport * as apigateway from 'aws-cdk-lib/aws-apigateway'\nimport { MethodLoggingLevel } from 'aws-cdk-lib/aws-apigateway'\nimport * as wafv2 from 'aws-cdk-lib/aws-wafv2'\nimport * as sns from 'aws-cdk-lib/aws-sns'\nimport * as logs from 'aws-cdk-lib/aws-logs'\nimport * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch'\nimport { TreatMissingData } from 'aws-cdk-lib/aws-cloudwatch'\nimport * as lambdaNodejs from 'aws-cdk-lib/aws-lambda-nodejs'\nimport { Construct } from 'constructs'\nimport { ICertificate } from 'aws-cdk-lib/aws-certificatemanager'\nimport { IHostedZone } from 'aws-cdk-lib/aws-route53'\n\nexport enum wafUsage {\n  ConstructProvided,\n  ProvideWebAclArn\n}\n\nexport interface AwsJwtStsProps {\n  /**\n   * defaultAudience which is used in de JWT's\n   */\n  readonly defaultAudience: string;\n\n  /**\n   * HostedZoneId of the domain used for hosting the sts function\n   */\n  readonly hostedZoneId?: string;\n\n  /**\n   * Name of the hostedZone.\n   */\n  readonly hostedZoneName?: string;\n\n  /**\n  * Optional subdomain name of oidc discovery, default: oidc.\n  */\n  readonly oidcSubdomain?: string;\n\n  /**\n  * Optional subdomain name of the token api (on api gw), default: token.\n  */\n  readonly tokenSubdomain?: string;\n\n  /**\n   * If waf needs to be added to the API GW\n   *\n   * None: no waf is used\n   * ConstructProvided: the construct will deploy a wafAcl with opinionated rules\n   * ProvideWebAclArn: provide your own arn\n   */\n  readonly apiGwWaf?: wafUsage;\n\n  /**\n   * Arn of the waf webAcl rule to be associated with the API GW\n   *\n   */\n  readonly apiGwWafWebAclArn?: string;\n\n  /**\n   * The ID of the AWS Organization 0-xxxx\n   *\n   */\n  readonly orgId?: string;\n\n  /**\n   * CPU Architecture\n   */\n  readonly architecture?: lambda.Architecture\n\n  /**\n   * Optional boolean to specify if key rotation should be triggered on creation of the stack, default: false\n   */\n  readonly disableKeyRotateOnCreate?: boolean\n\n  /**\n   * Optional custom name for the CloudWatch Alarm monitoring Step Function failures, default: sts-key_rotate_sfn-alarm\n   */\n  readonly alarmNameKeyRotationStepFunctionFailed?: string\n\n  /**\n   * Optional custom name for the CloudWatch Alarm monitoring 5xx errors on the API Gateway, default: sts-5xx_api_gw-alarm\n   */\n  readonly alarmNameApiGateway5xx?: string\n\n  /**\n   * Optional custom name for the CloudWatch Alarm monitoring Sign Lambda failures, default: sts-sign_errors_lambda-alarm\n   */\n  readonly alarmNameSignLambdaFailed?: string\n\n  /**\n   * Optional custom name for the CloudWatch Alarm monitoring Key Rotation Lambda failures, default: sts-key_rotate_errors_lambda-alarm\n   */\n  readonly alarmNameKeyRotationLambdaFailed?: string\n}\n\n/* eslint-disable no-new */\nexport class AwsJwtSts extends Construct {\n  /**\n   * SNS topic used to publish errors from the Step Function rotation flow\n   */\n  public readonly failedRotationTopic: sns.Topic\n\n  constructor (app: Construct, id: string, props: AwsJwtStsProps) {\n    super(app, id)\n\n    /** ---------------------- Custom domain thingies ----------------------- */\n\n    let distributionDomainNames: string[] = []\n    let oidcCertificate: ICertificate | undefined\n    let tokenCertificate: ICertificate | undefined\n    let hostedZone: IHostedZone | undefined\n    const oidcSubdomain = props.oidcSubdomain ? props.oidcSubdomain : 'oidc'\n    const tokenSubdomain = props.tokenSubdomain ? props.tokenSubdomain : 'token'\n    const architecture = props.architecture ? props.architecture : lambda.Architecture.X86_64\n    let oidcDomainName = ''\n    let tokenDomainName = ''\n\n    const useCustomDomain = props.hostedZoneId && props.hostedZoneName\n\n    if (useCustomDomain) {\n      oidcDomainName = oidcSubdomain + '.' + props.hostedZoneName\n      tokenDomainName = tokenSubdomain + '.' + props.hostedZoneName\n\n      distributionDomainNames = [oidcDomainName]\n\n      hostedZone = route53.HostedZone.fromHostedZoneAttributes(\n        this,\n        'hostedZone',\n        {\n          zoneName: props.hostedZoneName!,\n          hostedZoneId: props.hostedZoneId!\n        }\n      )\n\n      oidcCertificate = new acm.DnsValidatedCertificate(this, 'CrossRegionCertificate', {\n        domainName: oidcDomainName,\n        hostedZone,\n        region: 'us-east-1'\n      })\n\n      tokenCertificate = new acm.Certificate(this, 'tokenCertificate', {\n        domainName: tokenDomainName,\n        validation: acm.CertificateValidation.fromDns(hostedZone)\n      })\n    }\n\n    /** ---------------------- S3 Definition ----------------------- */\n\n    // Create bucket where oidc information can be stored\n    const oidcbucket = new s3.Bucket(this, 'oidcbucket', {\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n      encryption: BucketEncryption.S3_MANAGED,\n      versioned: true,\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL\n    })\n\n    /** ------------------- Cloudfront Definition ------------------- */\n\n    const cloudfrontOAI = new cloudfront.OriginAccessIdentity(this, 'cloudfront-OAI', {\n      comment: 'OAI for oidc'\n    })\n\n    const distribution = new cloudfront.Distribution(this, 'oidcDistribution', {\n      domainNames: distributionDomainNames,\n      comment: 'Discovery endpoint for OIDC',\n      certificate: oidcCertificate,\n      defaultBehavior: {\n        origin: new cloudfrontOrigins.S3Origin(oidcbucket, { originAccessIdentity: cloudfrontOAI }),\n        compress: true,\n        allowedMethods: cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS\n      }\n    })\n\n    /** ------------------ Lambda Handlers Definition ------------------ */\n\n    const issuer = useCustomDomain ? 'https://' + oidcDomainName : 'https://' + distribution.distributionDomainName\n\n    const rotateKeysRole = new iam.Role(this, 'rotateKeysRole', {\n      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')]\n    })\n    const rotateKeys = new lambdaNodejs.NodejsFunction(this, 'keyrotate', {\n      timeout: cdk.Duration.seconds(5),\n      runtime: lambda.Runtime.NODEJS_18_X,\n      role: rotateKeysRole,\n      architecture,\n      environment: {\n        S3_BUCKET: oidcbucket.bucketName,\n        ISSUER: issuer\n      }\n    })\n\n    const signRole = new iam.Role(this, 'signRole', {\n      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')]\n    })\n    const sign = new lambdaNodejs.NodejsFunction(this, 'sign', {\n      timeout: cdk.Duration.seconds(5),\n      runtime: lambda.Runtime.NODEJS_18_X,\n      role: signRole,\n      architecture,\n      environment: {\n        ISSUER: issuer,\n        DEFAULT_AUDIENCE: props.defaultAudience\n      }\n    })\n\n    /** ------------------------ SNS Topic ------------------------- */\n\n    this.failedRotationTopic = new sns.Topic(this, 'sts')\n    const snsFail = new tasks.SnsPublish(this, 'snsFailed', {\n      topic: this.failedRotationTopic,\n      subject: 'STS KeyRotate step function execution failed',\n      message: sfn.TaskInput.fromJsonPathAt('$')\n    })\n\n    /** ------------------ Step functions Definition ------------------ */\n\n    const deletePreviousStep = new tasks.LambdaInvoke(this, 'delete Previous', {\n      lambdaFunction: rotateKeys,\n      payload: sfn.TaskInput.fromObject({\n        step: 'deletePrevious'\n      }),\n      outputPath: '$.Payload'\n    })\n\n    const movePreviousStep = new tasks.LambdaInvoke(this, 'move Previous', {\n      lambdaFunction: rotateKeys,\n      payload: sfn.TaskInput.fromObject({\n        step: 'movePrevious'\n      }),\n      outputPath: '$.Payload'\n    })\n\n    const moveCurrentStep = new tasks.LambdaInvoke(this, 'move Current', {\n      lambdaFunction: rotateKeys,\n      payload: sfn.TaskInput.fromObject({\n        step: 'moveCurrent'\n      }),\n      outputPath: '$.Payload'\n    })\n\n    const createPendingStep = new tasks.LambdaInvoke(this, 'create Pending', {\n      lambdaFunction: rotateKeys,\n      payload: sfn.TaskInput.fromObject({\n        step: 'createPending'\n      }),\n      outputPath: '$.Payload'\n    })\n\n    const generateArtifactsStep = new tasks.LambdaInvoke(this, 'generate artifacts', {\n      lambdaFunction: rotateKeys,\n      payload: sfn.TaskInput.fromObject({\n        step: 'generateArtifacts'\n      }),\n      outputPath: '$.Payload'\n    })\n\n    const jobFailed = new sfn.Fail(this, 'Failed', {\n      cause: 'AWS Batch Job Failed',\n      error: 'DescribeJob returned FAILED'\n    })\n\n    const jobSuccess = new sfn.Succeed(this, 'Success!')\n\n    deletePreviousStep.addCatch(snsFail)\n    movePreviousStep.addCatch(snsFail)\n    moveCurrentStep.addCatch(snsFail)\n    createPendingStep.addCatch(snsFail)\n    generateArtifactsStep.addCatch(snsFail)\n\n    // Create chain\n    const definition = deletePreviousStep\n      .next(movePreviousStep)\n      .next(moveCurrentStep)\n      .next(createPendingStep)\n      .next(generateArtifactsStep)\n      .next(jobSuccess)\n\n    snsFail.next(jobFailed)\n\n    // Create state machine\n    const rotateKeysMachine = new sfn.StateMachine(this, 'RotateKeys', {\n      definition,\n      timeout: cdk.Duration.minutes(5)\n    })\n\n    rotateKeys.grantInvoke(rotateKeysMachine.role)\n    oidcbucket.grantReadWrite(rotateKeys)\n\n    const statementSign = new iam.PolicyStatement()\n    statementSign.addActions('kms:*')\n    statementSign.addResources('*')\n    const signPolicy = new iam.ManagedPolicy(this, 'SignPolicy', {\n      statements: [statementSign]\n    })\n    signRole.addManagedPolicy(signPolicy)\n\n    const statementRotateKeys = new iam.PolicyStatement()\n    statementRotateKeys.addActions('kms:*')\n    statementRotateKeys.addResources('*')\n    const rotateKeysPolicy = new iam.ManagedPolicy(this, 'RotateKeysPolicy', {\n      statements: [statementRotateKeys]\n    })\n    rotateKeysRole.addManagedPolicy(rotateKeysPolicy)\n\n    /** ------------------ Events Rule Definition ------------------ */\n\n    // Run every 3 months at 8 PM UTC\n    const scheduledRotateRule = new events.Rule(this, 'scheduledRotateRule', {\n      schedule: events.Schedule.expression('cron(0 20 1 */3 ? *)')\n    })\n    scheduledRotateRule.addTarget(new targets.SfnStateMachine(rotateKeysMachine))\n\n    // Create state machine and trigger to populate initial keys\n    if (!props.disableKeyRotateOnCreate) {\n      const rotateOnce = new tasks.StepFunctionsStartExecution(this, 'rotateOnce', {\n        stateMachine: rotateKeysMachine,\n        integrationPattern: sfn.IntegrationPattern.RUN_JOB\n      })\n\n      const rotateTwice = new tasks.StepFunctionsStartExecution(this, 'rotateTwice', {\n        stateMachine: rotateKeysMachine,\n        integrationPattern: sfn.IntegrationPattern.RUN_JOB\n      })\n\n      const populateKeys = new sfn.StateMachine(this, 'populateKeys', {\n        definition: rotateOnce.next(rotateTwice),\n        timeout: cdk.Duration.minutes(10)\n      })\n\n      const initialRunRule = new events.Rule(this, 'initialRunRule', {\n        eventPattern: {\n          source: ['aws.cloudformation'],\n          resources: [cdk.Stack.of(this).stackId],\n          detailType: ['CloudFormation Stack Status Change'],\n          detail: {\n            'status-details': {\n              status: ['CREATE_COMPLETE']\n            }\n          }\n        }\n      })\n\n      initialRunRule.addTarget(new targets.SfnStateMachine(populateKeys))\n    }\n\n    /** ---------------------- API Gateway ----------------------- */\n\n    // only set policy when orgId is set\n    let apiPolicy: PolicyDocument | undefined\n    if (props.orgId) {\n      apiPolicy = new iam.PolicyDocument({\n        statements: [\n          new iam.PolicyStatement({\n            actions: ['execute-api:Invoke'],\n            resources: ['*'],\n            principals: [\n              new OrganizationPrincipal(props.orgId)\n            ]\n          })\n        ]\n      })\n    }\n\n    const logGroup = new logs.LogGroup(this, 'APIGatewayAccessLogs', {\n      retention: 7\n    })\n\n    // Create API\n    const api = new apigateway.LambdaRestApi(this, 'jwk-sts-api', {\n      description: 'STS Token API Gateway',\n      handler: sign,\n      defaultMethodOptions: {\n        authorizationType: apigateway.AuthorizationType.IAM\n      },\n      endpointConfiguration: {\n        types: [apigateway.EndpointType.REGIONAL]\n      },\n      policy: apiPolicy,\n      deployOptions: {\n        loggingLevel: MethodLoggingLevel.INFO,\n        accessLogDestination: new apigateway.LogGroupLogDestination(logGroup)\n      }\n    })\n\n    /** ------------------- Route53 Definition for custom domain ------------------- */\n\n    if (useCustomDomain && hostedZone) {\n      api.addDomainName('apiCustomDomainName', {\n        domainName: tokenDomainName,\n        certificate: tokenCertificate!\n      })\n\n      // Add A record for cloudfront distribution\n\n      new route53.ARecord(this, 'oidcRecord', {\n        recordName: oidcDomainName,\n        zone: hostedZone,\n        target: route53.RecordTarget.fromAlias(new route53targets.CloudFrontTarget(distribution))\n      })\n\n      new route53.ARecord(this, 'tokenRecord', {\n        recordName: tokenDomainName,\n        zone: hostedZone,\n        target: route53.RecordTarget.fromAlias(new route53targets.ApiGateway(api))\n      })\n\n      new cdk.CfnOutput(this, 'tokenEndpoint', {\n        value: 'https://' + tokenDomainName + '/token',\n        description: 'Url of the token endpoint',\n        exportName: 'tokenEndpoint'\n      })\n    } else {\n      new cdk.CfnOutput(this, 'tokenEndpoint', {\n        value: api.url + 'token',\n        description: 'Url of the token endpoint',\n        exportName: 'tokenEndpoint'\n      })\n    }\n\n    new cdk.CfnOutput(this, 'issuer', {\n      value: issuer,\n      description: 'Url of the issuer',\n      exportName: 'issuer'\n    })\n\n    /** ---------------------- WAF ----------------------- */\n\n    if (props.apiGwWaf === wafUsage.ConstructProvided) {\n      // API gateway WAF ACL and rules\n      const APIGatewayWebACL = new wafv2.CfnWebACL(this, 'APIGatewayWebACL', {\n        description: 'This is WebACL for Auth APi Gateway',\n        scope: 'REGIONAL',\n        defaultAction: { allow: {} },\n        visibilityConfig: {\n          metricName: 'APIWebACL',\n          cloudWatchMetricsEnabled: true,\n          sampledRequestsEnabled: true\n        },\n        rules: [\n          {\n            name: 'AWS-AWSManagedRulesCommonRuleSet',\n            priority: 0,\n            statement: {\n              managedRuleGroupStatement: {\n                vendorName: 'AWS',\n                name: 'AWSManagedRulesCommonRuleSet'\n              }\n            },\n            overrideAction: {\n              none: {}\n            },\n            visibilityConfig: {\n              sampledRequestsEnabled: true,\n              cloudWatchMetricsEnabled: true,\n              metricName: 'AWS-AWSManagedRulesCommonRuleSet'\n            }\n          },\n          {\n            name: 'AWS-AWSManagedRulesAmazonIpReputationList',\n            priority: 1,\n            statement: {\n              managedRuleGroupStatement: {\n                vendorName: 'AWS',\n                name: 'AWSManagedRulesAmazonIpReputationList'\n              }\n            },\n            overrideAction: {\n              none: {}\n            },\n            visibilityConfig: {\n              sampledRequestsEnabled: true,\n              cloudWatchMetricsEnabled: true,\n              metricName: 'AWS-AWSManagedRulesAmazonIpReputationList'\n            }\n          },\n          {\n            name: 'api-gw-AuthAPIGeoLocation',\n            priority: 3,\n            action: { block: {} },\n            visibilityConfig: {\n              metricName: 'AuthAPIGeoLocation',\n              cloudWatchMetricsEnabled: true,\n              sampledRequestsEnabled: false\n            },\n            statement: {\n              geoMatchStatement: {\n                countryCodes: ['BY', 'CN', 'IR', 'RU', 'SY', 'KP']\n              }\n            }\n          },\n          {\n            name: 'api-gw-rateLimitRule',\n            priority: 4,\n            action: { block: {} },\n            visibilityConfig: {\n              metricName: 'rateLimitRule',\n              cloudWatchMetricsEnabled: true,\n              sampledRequestsEnabled: false\n            },\n            statement: {\n              rateBasedStatement: {\n                aggregateKeyType: 'IP',\n                limit: 100\n              }\n            }\n          }\n        ]\n      })\n\n      // Web ACL Association\n      new wafv2.CfnWebACLAssociation(this, 'APIGatewayWebACLAssociation', {\n        webAclArn: APIGatewayWebACL.attrArn,\n        resourceArn: api.deploymentStage.stageArn\n      })\n    } else if (props.apiGwWaf === wafUsage.ProvideWebAclArn && props.apiGwWafWebAclArn) {\n      // Web ACL Association\n      new wafv2.CfnWebACLAssociation(this, 'APIGatewayWebACLAssociation', {\n        webAclArn: props.apiGwWafWebAclArn,\n        resourceArn: api.deploymentStage.stageArn\n      })\n    }\n\n    /** ---------------------- Cloudwatch ----------------------- */\n\n    new cloudwatch.Alarm(this, 'StepFunctionError', {\n      alarmName: props.alarmNameKeyRotationStepFunctionFailed ?? 'sts-key_rotate_sfn-alarm',\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      threshold: 1,\n      evaluationPeriods: 1,\n      metric: rotateKeysMachine.metricFailed(),\n      alarmDescription: 'Key Rotation Failed',\n      treatMissingData: TreatMissingData.NOT_BREACHING\n    })\n\n    new cloudwatch.Alarm(this, 'ApiGateway5XXAlarm', {\n      alarmName: props.alarmNameApiGateway5xx ?? 'sts-5xx_api_gw-alarm',\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      threshold: 1,\n      evaluationPeriods: 1,\n      metric: api.metricServerError(),\n      alarmDescription: '5xx STS API gateway failures',\n      treatMissingData: TreatMissingData.NOT_BREACHING\n    })\n\n    const signErrors = sign.metricErrors({\n      period: cdk.Duration.minutes(1)\n    })\n\n    const rotateErrors = rotateKeys.metricErrors({\n      period: cdk.Duration.minutes(1)\n    })\n\n    new cloudwatch.Alarm(this, 'LambdaSignError', {\n      alarmName: props.alarmNameSignLambdaFailed ?? 'sts-sign_errors_lambda-alarm',\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      threshold: 1,\n      evaluationPeriods: 1,\n      metric: signErrors,\n      alarmDescription: 'Sign Lambda Failed',\n      treatMissingData: TreatMissingData.NOT_BREACHING\n    })\n\n    new cloudwatch.Alarm(this, 'LambdaRotateError', {\n      alarmName: props.alarmNameKeyRotationLambdaFailed ?? 'sts-key_rotate_errors_lambda-alarm',\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      threshold: 1,\n      evaluationPeriods: 1,\n      metric: rotateErrors,\n      alarmDescription: 'Key Rotation Lambda Failed',\n      treatMissingData: TreatMissingData.NOT_BREACHING\n    })\n  }\n}\n"]}

package/dist/index.keyrotate.d.ts

@@ -0,0 +1 @@
+export declare const handler: (event: any) => Promise<any>;