diff --git a/Tagging-Governance/README.md b/Tagging-Governance/README.md new file mode 100644 index 0000000..0ffe977 --- /dev/null +++ b/Tagging-Governance/README.md @@ -0,0 +1,96 @@ +# Tagging Governance using AWS Organizations +A solution for implementing enterprise-grade resource tagging governance using AWS Organizations Service Control Policies (SCPs). + +## Overview +This project demonstrates how to implement preventative tagging controls for AWS resources using Service Control Policies. It leverages De Morgan's Laws to create complex logical conditions within SCP constraints, ensuring consistent resource tagging across multiple AWS accounts. + +## Features +Enforce required tags at resource creation time +Scale across multiple AWS accounts +Support for complex tag validation patterns +Integration with AWS Backup based on compliance tags +Support for hybrid and edge deployment patterns +Architecture +The solution implements tagging governance through: + +## Service Control Policies (SCPs) for tag enforcement +AWS Organizations for policy management +AWS Lambda for testing and validation +AWS Backup for automated backup policies + +## Important Notes on SCP Implementation + +### ⚠️ Testing and Deployment Strategy + +The service control policies in this repository are provided as examples only. Before implementing any SCPs: + +1. **Thoroughly test** all policies before attachment +2. Test in an isolated environment that mirrors your production setup +3. Use a gradual deployment approach: + - Start with specific, limited-scope OUs + - Gradually expand to broader OUs + - Monitor and verify impact at each stage + +### Understanding SCP Behavior + +- SCPs provide coarse-grained guardrails but **do not grant permissions** +- Administrators must still manage identity-based and resource-based policies +- Effective permissions are the **logical intersection** of: + - Service Control Policy/Resource Control Policy + - Identity Policy or Resource Policy + +### Organizational Design Recommendations + +- Organize accounts by function, compliance requirements, or control sets +- Avoid mirroring organizational reporting structure +- Consider compliance and security requirements when designing OU structure + +### Additional Resources + +- [Understanding SCP Effects on Permissions](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scp.html) +- [Multi-account Strategy Design Principles](https://docs.aws.amazon.com/prescriptive-guidance/latest/security-reference-architecture/organizations.html) +- [AWS Organizations and SCP Evolution Case Studies](https://aws.amazon.com/organizations/getting-started/) + +This implementation guide assumes familiarity with AWS Organizations and SCP concepts. For additional guidance, please consult the AWS documentation. + +### Prerequisites +AWS Organizations enabled +Administrator access to AWS Management Account +AWS CDK v2.x installed +Node.js 18.x or later +AWS CLI v2 configured +### Installation +Clone the repository: +git clone https://github.com/aws-samples/aws-enterprise-tagging-governance +cd Tagging-Governance +Install dependencies: +npm install +Deploy the stack: +cdk deploy +Testing +The project includes comprehensive test scenarios for validating tag enforcement: + +### Compliant resource creation +Non-compliant scenarios +Special pattern testing +Comprehensive boundary testing +Execute tests using the provided Lambda function: + +aws lambda invoke --function-name TaggingTestFunction --payload file://tests/compliant-scenario.json response.json +Test Scenarios +| Scenario Type | Test Case | Expected Result | +|--------------|-----------|-----------------| +| Compliant | Full Compliance | Resource creation successful | +| Non-Compliant | Missing Tags | Resource creation denied | +| Non-Compliant | Invalid Values | Resource creation denied | +| Special Pattern | Invalid Prefix | Resource creation denied | +| Comprehensive | Multiple Violations | Resource creation denied | + +## License +See LICENSE for more information. + +## Contributing +See CONTRIBUTING for more information. + +## Support +Please submit bug reports and feature requests through our GitHub issues page. \ No newline at end of file diff --git a/Tagging-Governance/cdk.json b/Tagging-Governance/cdk.json new file mode 100644 index 0000000..fe18114 --- /dev/null +++ b/Tagging-Governance/cdk.json @@ -0,0 +1,82 @@ +{ + "app": "npx ts-node --prefer-ts-exts bin/security_blog_sample_code.ts", + "watch": { + "include": [ + "**" + ], + "exclude": [ + "README.md", + "cdk*.json", + "**/*.d.ts", + "**/*.js", + "tsconfig.json", + "package*.json", + "yarn.lock", + "node_modules", + "test" + ] + }, + "context": { + "@aws-cdk/aws-lambda:recognizeLayerVersion": true, + "@aws-cdk/core:checkSecretUsage": true, + "@aws-cdk/core:target-partitions": [ + "aws", + "aws-cn" + ], + "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true, + "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true, + "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": true, + "@aws-cdk/aws-iam:minimizePolicies": true, + "@aws-cdk/core:validateSnapshotRemovalPolicy": true, + "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": true, + "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true, + "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": true, + "@aws-cdk/aws-apigateway:disableCloudWatchRole": true, + "@aws-cdk/core:enablePartitionLiterals": true, + "@aws-cdk/aws-events:eventsTargetQueueSameAccount": true, + "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": true, + "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": true, + "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": true, + "@aws-cdk/aws-route53-patters:useCertificate": true, + "@aws-cdk/customresources:installLatestAwsSdkDefault": false, + "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": true, + "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": true, + "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": true, + "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": true, + "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": true, + "@aws-cdk/aws-redshift:columnId": true, + "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": true, + "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": true, + "@aws-cdk/aws-apigateway:requestValidatorUniqueId": true, + "@aws-cdk/aws-kms:aliasNameRef": true, + "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": true, + "@aws-cdk/core:includePrefixInUniqueNameGeneration": true, + "@aws-cdk/aws-efs:denyAnonymousAccess": true, + "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": true, + "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": true, + "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": true, + "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": true, + "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": true, + "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": true, + "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": true, + "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": true, + "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": true, + "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": true, + "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": true, + "@aws-cdk/aws-eks:nodegroupNameAttribute": true, + "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": true, + "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": true, + "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": false, + "@aws-cdk/aws-s3:keepNotificationInImportedBucket": false, + "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions": true, + "@aws-cdk/aws-dynamodb:resourcePolicyPerReplica": true, + "@aws-cdk/aws-ec2:ec2SumTImeoutEnabled": true, + "@aws-cdk/aws-appsync:appSyncGraphQLAPIScopeLambdaPermission": true, + "@aws-cdk/aws-rds:setCorrectValueForDatabaseInstanceReadReplicaInstanceResourceId": true, + "@aws-cdk/core:cfnIncludeRejectComplexResourceUpdateCreatePolicyIntrinsics": true, + "@aws-cdk/aws-lambda-nodejs:sdkV3ExcludeSmithyPackages": true, + "@aws-cdk/aws-stepfunctions-tasks:fixRunEcsTaskPolicy": true, + "@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault": true, + "@aws-cdk/aws-route53-targets:userPoolDomainNameMethodWithoutCustomResource": true + } +} diff --git a/Tagging-Governance/jest.config.js b/Tagging-Governance/jest.config.js new file mode 100644 index 0000000..08263b8 --- /dev/null +++ b/Tagging-Governance/jest.config.js @@ -0,0 +1,8 @@ +module.exports = { + testEnvironment: 'node', + roots: ['/test'], + testMatch: ['**/*.test.ts'], + transform: { + '^.+\\.tsx?$': 'ts-jest' + } +}; diff --git a/Tagging-Governance/lib/security_blog_sample_code-stack.d.ts b/Tagging-Governance/lib/security_blog_sample_code-stack.d.ts new file mode 100644 index 0000000..dc071f5 --- /dev/null +++ b/Tagging-Governance/lib/security_blog_sample_code-stack.d.ts @@ -0,0 +1,5 @@ +import * as cdk from 'aws-cdk-lib'; +import { Construct } from 'constructs'; +export declare class SecurityBlogSampleCodeStack extends cdk.Stack { + constructor(scope: Construct, id: string, props?: cdk.StackProps); +} diff --git a/Tagging-Governance/lib/security_blog_sample_code-stack.js b/Tagging-Governance/lib/security_blog_sample_code-stack.js new file mode 100644 index 0000000..a2e985a --- /dev/null +++ b/Tagging-Governance/lib/security_blog_sample_code-stack.js @@ -0,0 +1,426 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SecurityBlogSampleCodeStack = void 0; +const cdk = require("aws-cdk-lib"); +const ec2 = require("aws-cdk-lib/aws-ec2"); +const iam = require("aws-cdk-lib/aws-iam"); +const lambda = require("aws-cdk-lib/aws-lambda"); +const backup = require("aws-cdk-lib/aws-backup"); +const organizations = require("aws-cdk-lib/aws-organizations"); +// Updated Organizations check Lambda code +const organizationsCheckCode = ` +const { OrganizationsClient, DescribeOrganizationCommand } = require('@aws-sdk/client-organizations'); + +exports.handler = async function(event, context) { + console.log('Event:', JSON.stringify(event, null, 2)); + + const client = new OrganizationsClient(); + + try { + switch (event.RequestType) { + case 'Create': + case 'Update': + try { + const command = new DescribeOrganizationCommand({}); + const response = await client.send(command); + console.log('Organizations API Response:', JSON.stringify(response, null, 2)); + + return { + Status: 'SUCCESS', + PhysicalResourceId: event.LogicalResourceId, + Data: { + OrganizationsEnabled: true, + OrganizationId: response.Organization.Id + } + }; + } catch (error) { + console.log('Error checking organizations:', error); + if (error.name === 'AWSOrganizationsNotInUseException') { + return { + Status: 'SUCCESS', + PhysicalResourceId: event.LogicalResourceId, + Data: { + OrganizationsEnabled: false + } + }; + } + throw error; + } + + case 'Delete': + return { + Status: 'SUCCESS', + PhysicalResourceId: event.LogicalResourceId, + Data: { + OrganizationsEnabled: false + } + }; + + default: + throw new Error('Invalid request type: ' + event.RequestType); + } + } catch (error) { + console.error('Error:', error); + return { + Status: 'FAILED', + PhysicalResourceId: event.LogicalResourceId, + Reason: error.message, + Data: { + OrganizationsEnabled: false + } + }; + } +}; +`; +// Tagging test Lambda code remains the same +const taggingTestCode = ` +const { EC2Client, RunInstancesCommand } = require('@aws-sdk/client-ec2'); + +/** + * Lambda handler for testing EC2 instance creation with various tagging scenarios + * Implements De Morgan's Laws for logical test cases: + * 1. NOT (A AND B) = (NOT A) OR (NOT B) + * 2. NOT (A OR B) = (NOT A) AND (NOT B) + */ +exports.handler = async function(event) { + const ec2Client = new EC2Client(); + const testScenario = event.testScenario; + const testVariation = event.testVariation || 'default'; + + console.log(\`Executing test scenario: \${testScenario}, variation: \${testVariation}\`); + + try { + switch(testScenario) { + case 'compliant': + return await createCompliantInstance(ec2Client); + case 'non-compliant': + return await createNonCompliantInstance(ec2Client, testVariation); + case 'special-pattern': + return await createSpecialPatternInstance(ec2Client, testVariation); + case 'comprehensive': + return await createComprehensiveTestInstance(ec2Client, testVariation); + default: + throw new Error('Invalid test scenario'); + } + } catch (error) { + console.error('Error:', error); + throw error; + } +}; + +/** + * Creates a fully compliant instance - baseline for comparison + * All conditions must be true: (A AND B AND C AND D) + */ +async function createCompliantInstance(ec2Client) { + const params = { + ImageId: 'ami-002b9d4784a46775f', + InstanceType: 't3.micro', + MinCount: 1, + MaxCount: 1, + TagSpecifications: [{ + ResourceType: 'instance', + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'infra-prod' } + ] + }] + }; + const command = new RunInstancesCommand(params); + return await ec2Client.send(command); +} + +/** + * Tests non-compliant scenarios based on De Morgan's Law: + * NOT(all tags present AND all values valid) = + * (missing tags OR invalid values) + */ +async function createNonCompliantInstance(ec2Client, variation) { + const testCases = { + 'missing-tags': { + Tags: [ + // Missing DeploymentType - tests NOT A + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' } + // Missing BusinessUnit - tests NOT D + ] + }, + 'invalid-values': { + Tags: [ + { Key: 'DeploymentType', Value: 'invalid' }, // Tests NOT valid(A) + { Key: 'BackupCompliance', Value: 'not-critical' }, // Tests NOT valid(B) + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'infra-prod' } + ] + }, + 'mixed-violations': { + Tags: [ + { Key: 'DeploymentType', Value: 'invalid' }, + // Missing BackupCompliance + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'invalid-pattern' } + ] + } + }; + + const params = { + ImageId: 'ami-002b9d4784a46775f', + InstanceType: 't3.micro', + MinCount: 1, + MaxCount: 1, + TagSpecifications: [{ + ResourceType: 'instance', + Tags: testCases[variation].Tags + }] + }; + + const command = new RunInstancesCommand(params); + return await ec2Client.send(command); +} + +/** + * Tests special pattern matching scenarios + * Based on De Morgan's Law for pattern matching: + * NOT(matches pattern) = matches NOT(pattern) + */ +async function createSpecialPatternInstance(ec2Client, variation) { + const testCases = { + 'invalid-prefix': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'not-infra-prod' } + ] + }, + 'missing-suffix': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'infra' } + ] + }, + 'case-sensitivity': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'INFRA-PROD' } + ] + } + }; + + const params = { + ImageId: 'ami-002b9d4784a46775f', + InstanceType: 't3.micro', + MinCount: 1, + MaxCount: 1, + TagSpecifications: [{ + ResourceType: 'instance', + Tags: testCases[variation].Tags + }] + }; + + const command = new RunInstancesCommand(params); + return await ec2Client.send(command); +} + +/** + * Comprehensive test combining multiple conditions + * Tests complex combinations of De Morgan's Laws: + * NOT(A AND B AND C) = NOT(A) OR NOT(B) OR NOT(C) + */ +async function createComprehensiveTestInstance(ec2Client, variation) { + const testCases = { + 'multiple-violations': { + Tags: [ + { Key: 'DeploymentType', Value: 'invalid' }, + { Key: 'BackupCompliance', Value: 'not-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'invalid-pattern' } + ] + }, + 'boundary-conditions': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: '' }, // Empty value + { Key: 'BusinessUnit', Value: 'infra-' } // Minimum pattern + ] + }, + 'special-characters': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'infra-prod#123' } // Special characters + ] + } + }; + + const params = { + ImageId: 'ami-002b9d4784a46775f', + InstanceType: 't3.micro', + MinCount: 1, + MaxCount: 1, + TagSpecifications: [{ + ResourceType: 'instance', + Tags: testCases[variation].Tags + }] + }; + + const command = new RunInstancesCommand(params); + return await ec2Client.send(command); +} +`; +class SecurityBlogSampleCodeStack extends cdk.Stack { + constructor(scope, id, props) { + super(scope, id, props); + // Define required tags and allowed values + const REQUIRED_TAGS = { + DeploymentType: ['edge', 'core', 'hybrid'], + BackupCompliance: ['mission-critical', 'business-critical'], + OutpostIdentifier: '*', + BusinessUnit: 'infra-*' + }; + // Create VPC for EC2 instance + const vpc = new ec2.Vpc(this, 'TaggingTestVPC', { + maxAzs: 2, + natGateways: 1 + }); + // Create AWS Backup configuration + const backupVault = new backup.BackupVault(this, 'EC2BackupVault', { + backupVaultName: 'ec2-backup-vault', + removalPolicy: cdk.RemovalPolicy.DESTROY + }); + // Create Mission Critical Backup Plan + const missionCriticalPlan = new backup.BackupPlan(this, 'MissionCriticalBackupPlan', { + backupVault, + backupPlanRules: [ + new backup.BackupPlanRule({ + completionWindow: cdk.Duration.hours(2), + startWindow: cdk.Duration.hours(1), + scheduleExpression: cdk.aws_events.Schedule.cron({ + day: '*', + hour: '3', + minute: '0' + }), + deleteAfter: cdk.Duration.days(180), + moveToColdStorageAfter: cdk.Duration.days(90), + enableContinuousBackup: false + }) + ] + }); + // Create Business Critical Backup Plan + const businessCriticalPlan = new backup.BackupPlan(this, 'BusinessCriticalBackupPlan', { + backupVault, + backupPlanRules: [ + new backup.BackupPlanRule({ + completionWindow: cdk.Duration.hours(3), + startWindow: cdk.Duration.hours(1), + scheduleExpression: cdk.aws_events.Schedule.cron({ + day: '*', + hour: '12', + minute: '0' + }), + deleteAfter: cdk.Duration.days(97), + moveToColdStorageAfter: cdk.Duration.days(7) + }) + ] + }); + // Add selection for Mission Critical resources + new backup.BackupSelection(this, 'MissionCriticalSelection', { + backupPlan: missionCriticalPlan, + resources: [ + backup.BackupResource.fromTag('BackupCompliance', 'mission-critical') + ] + }); + // Add selection for Business Critical resources + new backup.BackupSelection(this, 'BusinessCriticalSelection', { + backupPlan: businessCriticalPlan, + resources: [ + backup.BackupResource.fromTag('BackupCompliance', 'business-critical') + ] + }); + // Create SCP policies using De Morgan's Laws + const tagEnforcementSCP = new organizations.CfnPolicy(this, 'TagEnforcementSCP', { + content: { + Version: '2012-10-17', + Statement: [ + { + Sid: 'EnforceRequiredTags', + Effect: 'Deny', + Action: ['ec2:RunInstances'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'Null': { + 'aws:RequestTag/OutpostIdentifier': 'true', + } + } + }, + { + Sid: 'EnforceDeploymentTypeValues', + Effect: 'Deny', + Action: ['ec2:RunInstances'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'StringNotEquals': { + 'aws:RequestTag/DeploymentType': ['edge', 'core', 'hybrid'] + } + } + }, + { + Sid: 'EnforceBackupComplianceValues', + Effect: 'Deny', + Action: ['ec2:RunInstances'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'StringNotEquals': { + 'aws:RequestTag/BackupCompliance': ['mission-critical', 'business-critical'] + } + } + }, + { + Sid: 'EnforceBusinessUnitPattern', + Effect: 'Deny', + Action: ['ec2:RunInstances'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'StringNotLike': { + 'aws:RequestTag/BusinessUnit': 'infra-*' + } + } + } + ] + }, + name: 'TagEnforcementPolicy', + type: 'SERVICE_CONTROL_POLICY', + targetIds: ['ou-8033-hltnny6u'] // update with your OU + }); + // Create Lambda function for testing EC2 creation scenarios + const testFunction = new lambda.Function(this, 'TaggingTestFunction', { + runtime: lambda.Runtime.NODEJS_22_X, + handler: 'index.handler', + code: lambda.Code.fromInline(taggingTestCode), + vpc, + timeout: cdk.Duration.minutes(5), + environment: { + REQUIRED_TAGS: JSON.stringify(REQUIRED_TAGS) + } + }); + testFunction.addToRolePolicy(new iam.PolicyStatement({ + actions: ['ec2:RunInstances', 'ec2:CreateTags'], + resources: ['*'] + })); + // Outputs + new cdk.CfnOutput(this, 'LambdaFunctionName', { + value: testFunction.functionName, + description: 'Name of the Lambda function for testing' + }); + } +} +exports.SecurityBlogSampleCodeStack = SecurityBlogSampleCodeStack; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security_blog_sample_code-stack.js","sourceRoot":"","sources":["security_blog_sample_code-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as backup from 'aws-cdk-lib/aws-backup';\nimport * as organizations from 'aws-cdk-lib/aws-organizations';\nimport * as cr from 'aws-cdk-lib/custom-resources';\nimport { Construct } from 'constructs';\nimport { Tags } from 'aws-cdk-lib';\n\n// Updated Organizations check Lambda code\nconst organizationsCheckCode = `\nconst { OrganizationsClient, DescribeOrganizationCommand } = require('@aws-sdk/client-organizations');\n\nexports.handler = async function(event, context) {\n  console.log('Event:', JSON.stringify(event, null, 2));\n  \n  const client = new OrganizationsClient();\n  \n  try {\n    switch (event.RequestType) {\n      case 'Create':\n      case 'Update':\n        try {\n          const command = new DescribeOrganizationCommand({});\n          const response = await client.send(command);\n          console.log('Organizations API Response:', JSON.stringify(response, null, 2));\n          \n          return {\n            Status: 'SUCCESS',\n            PhysicalResourceId: event.LogicalResourceId,\n            Data: {\n              OrganizationsEnabled: true,\n              OrganizationId: response.Organization.Id\n            }\n          };\n        } catch (error) {\n          console.log('Error checking organizations:', error);\n          if (error.name === 'AWSOrganizationsNotInUseException') {\n            return {\n              Status: 'SUCCESS',\n              PhysicalResourceId: event.LogicalResourceId,\n              Data: {\n                OrganizationsEnabled: false\n              }\n            };\n          }\n          throw error;\n        }\n        \n      case 'Delete':\n        return {\n          Status: 'SUCCESS',\n          PhysicalResourceId: event.LogicalResourceId,\n          Data: {\n            OrganizationsEnabled: false\n          }\n        };\n        \n      default:\n        throw new Error('Invalid request type: ' + event.RequestType);\n    }\n  } catch (error) {\n    console.error('Error:', error);\n    return {\n      Status: 'FAILED',\n      PhysicalResourceId: event.LogicalResourceId,\n      Reason: error.message,\n      Data: {\n        OrganizationsEnabled: false\n      }\n    };\n  }\n};\n`;\n\n// Tagging test Lambda code remains the same\nconst taggingTestCode = `\nconst { EC2Client, RunInstancesCommand } = require('@aws-sdk/client-ec2');\n\n/**\n * Lambda handler for testing EC2 instance creation with various tagging scenarios\n * Implements De Morgan's Laws for logical test cases:\n * 1. NOT (A AND B) = (NOT A) OR (NOT B)\n * 2. NOT (A OR B) = (NOT A) AND (NOT B)\n */\nexports.handler = async function(event) {\n  const ec2Client = new EC2Client();\n  const testScenario = event.testScenario;\n  const testVariation = event.testVariation || 'default';\n\n  console.log(\\`Executing test scenario: \\${testScenario}, variation: \\${testVariation}\\`);\n\n  try {\n    switch(testScenario) {\n      case 'compliant':\n        return await createCompliantInstance(ec2Client);\n      case 'non-compliant':\n        return await createNonCompliantInstance(ec2Client, testVariation);\n      case 'special-pattern':\n        return await createSpecialPatternInstance(ec2Client, testVariation);\n      case 'comprehensive':\n        return await createComprehensiveTestInstance(ec2Client, testVariation);\n      default:\n        throw new Error('Invalid test scenario');\n    }\n  } catch (error) {\n    console.error('Error:', error);\n    throw error;\n  }\n};\n\n/**\n * Creates a fully compliant instance - baseline for comparison\n * All conditions must be true: (A AND B AND C AND D)\n */\nasync function createCompliantInstance(ec2Client) {\n  const params = {\n    ImageId: 'ami-002b9d4784a46775f',\n    InstanceType: 't3.micro',\n    MinCount: 1,\n    MaxCount: 1,\n    TagSpecifications: [{\n      ResourceType: 'instance',\n      Tags: [\n        { Key: 'DeploymentType', Value: 'edge' },\n        { Key: 'BackupCompliance', Value: 'mission-critical' },\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' },\n        { Key: 'BusinessUnit', Value: 'infra-prod' }\n      ]\n    }]\n  };\n  const command = new RunInstancesCommand(params);\n  return await ec2Client.send(command);\n}\n\n/**\n * Tests non-compliant scenarios based on De Morgan's Law:\n * NOT(all tags present AND all values valid) = \n * (missing tags OR invalid values)\n */\nasync function createNonCompliantInstance(ec2Client, variation) {\n  const testCases = {\n    'missing-tags': {\n      Tags: [\n        // Missing DeploymentType - tests NOT A\n        { Key: 'BackupCompliance', Value: 'mission-critical' },\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }\n        // Missing BusinessUnit - tests NOT D\n      ]\n    },\n    'invalid-values': {\n      Tags: [\n        { Key: 'DeploymentType', Value: 'invalid' }, // Tests NOT valid(A)\n        { Key: 'BackupCompliance', Value: 'not-critical' }, // Tests NOT valid(B)\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' },\n        { Key: 'BusinessUnit', Value: 'infra-prod' }\n      ]\n    },\n    'mixed-violations': {\n      Tags: [\n        { Key: 'DeploymentType', Value: 'invalid' },\n        // Missing BackupCompliance\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' },\n        { Key: 'BusinessUnit', Value: 'invalid-pattern' }\n      ]\n    }\n  };\n\n  const params = {\n    ImageId: 'ami-002b9d4784a46775f',\n    InstanceType: 't3.micro',\n    MinCount: 1,\n    MaxCount: 1,\n    TagSpecifications: [{\n      ResourceType: 'instance',\n      Tags: testCases[variation].Tags\n    }]\n  };\n\n  const command = new RunInstancesCommand(params);\n  return await ec2Client.send(command);\n}\n\n/**\n * Tests special pattern matching scenarios\n * Based on De Morgan's Law for pattern matching:\n * NOT(matches pattern) = matches NOT(pattern)\n */\nasync function createSpecialPatternInstance(ec2Client, variation) {\n  const testCases = {\n    'invalid-prefix': {\n      Tags: [\n        { Key: 'DeploymentType', Value: 'edge' },\n        { Key: 'BackupCompliance', Value: 'mission-critical' },\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' },\n        { Key: 'BusinessUnit', Value: 'not-infra-prod' }\n      ]\n    },\n    'missing-suffix': {\n      Tags: [\n        { Key: 'DeploymentType', Value: 'edge' },\n        { Key: 'BackupCompliance', Value: 'mission-critical' },\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' },\n        { Key: 'BusinessUnit', Value: 'infra' }\n      ]\n    },\n    'case-sensitivity': {\n      Tags: [\n        { Key: 'DeploymentType', Value: 'edge' },\n        { Key: 'BackupCompliance', Value: 'mission-critical' },\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' },\n        { Key: 'BusinessUnit', Value: 'INFRA-PROD' }\n      ]\n    }\n  };\n\n  const params = {\n    ImageId: 'ami-002b9d4784a46775f',\n    InstanceType: 't3.micro',\n    MinCount: 1,\n    MaxCount: 1,\n    TagSpecifications: [{\n      ResourceType: 'instance',\n      Tags: testCases[variation].Tags\n    }]\n  };\n\n  const command = new RunInstancesCommand(params);\n  return await ec2Client.send(command);\n}\n\n/**\n * Comprehensive test combining multiple conditions\n * Tests complex combinations of De Morgan's Laws:\n * NOT(A AND B AND C) = NOT(A) OR NOT(B) OR NOT(C)\n */\nasync function createComprehensiveTestInstance(ec2Client, variation) {\n  const testCases = {\n    'multiple-violations': {\n      Tags: [\n        { Key: 'DeploymentType', Value: 'invalid' },\n        { Key: 'BackupCompliance', Value: 'not-critical' },\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' },\n        { Key: 'BusinessUnit', Value: 'invalid-pattern' }\n      ]\n    },\n    'boundary-conditions': {\n      Tags: [\n        { Key: 'DeploymentType', Value: 'edge' },\n        { Key: 'BackupCompliance', Value: 'mission-critical' },\n        { Key: 'OutpostIdentifier', Value: '' }, // Empty value\n        { Key: 'BusinessUnit', Value: 'infra-' } // Minimum pattern\n      ]\n    },\n    'special-characters': {\n      Tags: [\n        { Key: 'DeploymentType', Value: 'edge' },\n        { Key: 'BackupCompliance', Value: 'mission-critical' },\n        { Key: 'OutpostIdentifier', Value: 'outpost-east-1' },\n        { Key: 'BusinessUnit', Value: 'infra-prod#123' } // Special characters\n      ]\n    }\n  };\n\n  const params = {\n    ImageId: 'ami-002b9d4784a46775f',\n    InstanceType: 't3.micro',\n    MinCount: 1,\n    MaxCount: 1,\n    TagSpecifications: [{\n      ResourceType: 'instance',\n      Tags: testCases[variation].Tags\n    }]\n  };\n\n  const command = new RunInstancesCommand(params);\n  return await ec2Client.send(command);\n}\n`;\n\nexport class SecurityBlogSampleCodeStack extends cdk.Stack {\n  constructor(scope: Construct, id: string, props?: cdk.StackProps) {\n    super(scope, id, props);\n\n    // Define required tags and allowed values\n    const REQUIRED_TAGS = {\n      DeploymentType: ['edge', 'core', 'hybrid'],\n      BackupCompliance: ['mission-critical', 'business-critical'],\n      OutpostIdentifier: '*',\n      BusinessUnit: 'infra-*'\n    };\n\n    // Create VPC for EC2 instance\n    const vpc = new ec2.Vpc(this, 'TaggingTestVPC', {\n      maxAzs: 2,\n      natGateways: 1\n    });\n\n    // Create AWS Backup configuration\n    const backupVault = new backup.BackupVault(this, 'EC2BackupVault', {\n      backupVaultName: 'ec2-backup-vault',\n      removalPolicy: cdk.RemovalPolicy.DESTROY\n    });\n\n    // Create Mission Critical Backup Plan\n    const missionCriticalPlan = new backup.BackupPlan(this, 'MissionCriticalBackupPlan', {\n      backupVault,\n      backupPlanRules: [\n        new backup.BackupPlanRule({\n          completionWindow: cdk.Duration.hours(2),\n          startWindow: cdk.Duration.hours(1),\n          scheduleExpression: cdk.aws_events.Schedule.cron({\n            day: '*',\n            hour: '3',\n            minute: '0'\n          }),\n          deleteAfter: cdk.Duration.days(180),\n          moveToColdStorageAfter: cdk.Duration.days(90),\n          enableContinuousBackup: false\n        })\n      ]\n    });\n\n    // Create Business Critical Backup Plan\n    const businessCriticalPlan = new backup.BackupPlan(this, 'BusinessCriticalBackupPlan', {\n      backupVault,\n      backupPlanRules: [\n        new backup.BackupPlanRule({\n          completionWindow: cdk.Duration.hours(3),\n          startWindow: cdk.Duration.hours(1),\n          scheduleExpression: cdk.aws_events.Schedule.cron({\n            day: '*',\n            hour: '12',\n            minute: '0'\n          }),\n          deleteAfter: cdk.Duration.days(97),\n          moveToColdStorageAfter: cdk.Duration.days(7)\n        })\n      ]\n    });\n\n    // Add selection for Mission Critical resources\n    new backup.BackupSelection(this, 'MissionCriticalSelection', {\n      backupPlan: missionCriticalPlan,\n      resources: [\n        backup.BackupResource.fromTag('BackupCompliance', 'mission-critical')\n      ]\n    });\n\n    // Add selection for Business Critical resources\n    new backup.BackupSelection(this, 'BusinessCriticalSelection', {\n      backupPlan: businessCriticalPlan,\n      resources: [\n        backup.BackupResource.fromTag('BackupCompliance', 'business-critical')\n      ]\n    });\n\n      // Create SCP policies using De Morgan's Laws\n    const tagEnforcementSCP = new organizations.CfnPolicy(this, 'TagEnforcementSCP', {\n        content: {\n          Version: '2012-10-17',\n          Statement: [\n            {\n              Sid: 'EnforceRequiredTags',\n              Effect: 'Deny',\n              Action: ['ec2:RunInstances'],\n              Resource: ['arn:aws:ec2:*:*:instance/*'],\n              Condition: {\n                'Null': {\n                  'aws:RequestTag/OutpostIdentifier': 'true',\n                }\n              }\n            },\n            {\n              Sid: 'EnforceDeploymentTypeValues',\n              Effect: 'Deny',\n              Action: ['ec2:RunInstances'],\n              Resource: ['arn:aws:ec2:*:*:instance/*'],\n              Condition: {\n                'StringNotEquals': {\n                  'aws:RequestTag/DeploymentType': ['edge', 'core', 'hybrid']\n                }\n              }\n            },\n            {\n              Sid: 'EnforceBackupComplianceValues',\n              Effect: 'Deny',\n              Action: ['ec2:RunInstances'],\n              Resource: ['arn:aws:ec2:*:*:instance/*'],\n              Condition: {\n                'StringNotEquals': {\n                  'aws:RequestTag/BackupCompliance': ['mission-critical', 'business-critical']\n                }\n              }\n            },\n            {\n              Sid: 'EnforceBusinessUnitPattern',\n              Effect: 'Deny',\n              Action: ['ec2:RunInstances'],\n              Resource: ['arn:aws:ec2:*:*:instance/*'],\n              Condition: {\n                'StringNotLike': {\n                  'aws:RequestTag/BusinessUnit': 'infra-*'\n                }\n              }\n            }\n          ]\n        },\n        name: 'TagEnforcementPolicy',\n        type: 'SERVICE_CONTROL_POLICY',\n        targetIds: ['ou-8033-hltnny6u'] // update with your OU\n      });\n\n    // Create Lambda function for testing EC2 creation scenarios\n    const testFunction = new lambda.Function(this, 'TaggingTestFunction', {\n      runtime: lambda.Runtime.NODEJS_22_X,\n      handler: 'index.handler',\n      code: lambda.Code.fromInline(taggingTestCode),\n      vpc,\n      timeout: cdk.Duration.minutes(5),\n      environment: {\n        REQUIRED_TAGS: JSON.stringify(REQUIRED_TAGS)\n      }\n    });\n\n    testFunction.addToRolePolicy(new iam.PolicyStatement({\n      actions: ['ec2:RunInstances', 'ec2:CreateTags'],\n      resources: ['*']\n    }));\n\n    // Outputs\n    new cdk.CfnOutput(this, 'LambdaFunctionName', {\n      value: testFunction.functionName,\n      description: 'Name of the Lambda function for testing'\n    });\n\n  }\n}"]} \ No newline at end of file diff --git a/Tagging-Governance/lib/security_blog_sample_code-stack.ts b/Tagging-Governance/lib/security_blog_sample_code-stack.ts new file mode 100644 index 0000000..79f7adb --- /dev/null +++ b/Tagging-Governance/lib/security_blog_sample_code-stack.ts @@ -0,0 +1,480 @@ +import * as cdk from 'aws-cdk-lib'; +import * as ec2 from 'aws-cdk-lib/aws-ec2'; +import * as iam from 'aws-cdk-lib/aws-iam'; +import * as lambda from 'aws-cdk-lib/aws-lambda'; +import * as backup from 'aws-cdk-lib/aws-backup'; +import * as organizations from 'aws-cdk-lib/aws-organizations'; +import * as cr from 'aws-cdk-lib/custom-resources'; +import { Construct } from 'constructs'; +import { Tags } from 'aws-cdk-lib'; + +// Updated Organizations check Lambda code +const organizationsCheckCode = ` +const { OrganizationsClient, DescribeOrganizationCommand } = require('@aws-sdk/client-organizations'); + +exports.handler = async function(event, context) { + console.log('Event:', JSON.stringify(event, null, 2)); + + const client = new OrganizationsClient(); + + try { + switch (event.RequestType) { + case 'Create': + case 'Update': + try { + const command = new DescribeOrganizationCommand({}); + const response = await client.send(command); + console.log('Organizations API Response:', JSON.stringify(response, null, 2)); + + return { + Status: 'SUCCESS', + PhysicalResourceId: event.LogicalResourceId, + Data: { + OrganizationsEnabled: true, + OrganizationId: response.Organization.Id + } + }; + } catch (error) { + console.log('Error checking organizations:', error); + if (error.name === 'AWSOrganizationsNotInUseException') { + return { + Status: 'SUCCESS', + PhysicalResourceId: event.LogicalResourceId, + Data: { + OrganizationsEnabled: false + } + }; + } + throw error; + } + + case 'Delete': + return { + Status: 'SUCCESS', + PhysicalResourceId: event.LogicalResourceId, + Data: { + OrganizationsEnabled: false + } + }; + + default: + throw new Error('Invalid request type: ' + event.RequestType); + } + } catch (error) { + console.error('Error:', error); + return { + Status: 'FAILED', + PhysicalResourceId: event.LogicalResourceId, + Reason: error.message, + Data: { + OrganizationsEnabled: false + } + }; + } +}; +`; + +// Tagging test Lambda code remains the same +const taggingTestCode = ` +const { EC2Client, RunInstancesCommand } = require('@aws-sdk/client-ec2'); + +/** + * Lambda handler for testing EC2 instance creation with various tagging scenarios + * Implements De Morgan's Laws for logical test cases: + * 1. NOT (A AND B) = (NOT A) OR (NOT B) + * 2. NOT (A OR B) = (NOT A) AND (NOT B) + */ +exports.handler = async function(event) { + const ec2Client = new EC2Client(); + const testScenario = event.testScenario; + const testVariation = event.testVariation || 'default'; + + console.log(\`Executing test scenario: \${testScenario}, variation: \${testVariation}\`); + + try { + switch(testScenario) { + case 'compliant': + return await createCompliantInstance(ec2Client); + case 'non-compliant': + return await createNonCompliantInstance(ec2Client, testVariation); + case 'special-pattern': + return await createSpecialPatternInstance(ec2Client, testVariation); + case 'comprehensive': + return await createComprehensiveTestInstance(ec2Client, testVariation); + default: + throw new Error('Invalid test scenario'); + } + } catch (error) { + console.error('Error:', error); + throw error; + } +}; + +/** + * Creates a fully compliant instance - baseline for comparison + * All conditions must be true: (A AND B AND C AND D) + */ +async function createCompliantInstance(ec2Client) { + const params = { + ImageId: 'ami-002b9d4784a46775f', + InstanceType: 't3.micro', + MinCount: 1, + MaxCount: 1, + TagSpecifications: [{ + ResourceType: 'instance', + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'infra-prod' } + ] + }] + }; + const command = new RunInstancesCommand(params); + return await ec2Client.send(command); +} + +/** + * Tests non-compliant scenarios based on De Morgan's Law: + * NOT(all tags present AND all values valid) = + * (missing tags OR invalid values) + */ +async function createNonCompliantInstance(ec2Client, variation) { + const testCases = { + 'missing-tags': { + Tags: [ + // Missing DeploymentType - tests NOT A + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' } + // Missing BusinessUnit - tests NOT D + ] + }, + 'invalid-values': { + Tags: [ + { Key: 'DeploymentType', Value: 'invalid' }, // Tests NOT valid(A) + { Key: 'BackupCompliance', Value: 'not-critical' }, // Tests NOT valid(B) + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'infra-prod' } + ] + }, + 'mixed-violations': { + Tags: [ + { Key: 'DeploymentType', Value: 'invalid' }, + // Missing BackupCompliance + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'invalid-pattern' } + ] + } + }; + + const params = { + ImageId: 'ami-002b9d4784a46775f', + InstanceType: 't3.micro', + MinCount: 1, + MaxCount: 1, + TagSpecifications: [{ + ResourceType: 'instance', + Tags: testCases[variation].Tags + }] + }; + + const command = new RunInstancesCommand(params); + return await ec2Client.send(command); +} + +/** + * Tests special pattern matching scenarios + * Based on De Morgan's Law for pattern matching: + * NOT(matches pattern) = matches NOT(pattern) + */ +async function createSpecialPatternInstance(ec2Client, variation) { + const testCases = { + 'invalid-prefix': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'not-infra-prod' } + ] + }, + 'missing-suffix': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'infra' } + ] + }, + 'case-sensitivity': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'INFRA-PROD' } + ] + } + }; + + const params = { + ImageId: 'ami-002b9d4784a46775f', + InstanceType: 't3.micro', + MinCount: 1, + MaxCount: 1, + TagSpecifications: [{ + ResourceType: 'instance', + Tags: testCases[variation].Tags + }] + }; + + const command = new RunInstancesCommand(params); + return await ec2Client.send(command); +} + +/** + * Comprehensive test combining multiple conditions + * Tests complex combinations of De Morgan's Laws: + * NOT(A AND B AND C) = NOT(A) OR NOT(B) OR NOT(C) + */ +async function createComprehensiveTestInstance(ec2Client, variation) { + const testCases = { + 'multiple-violations': { + Tags: [ + { Key: 'DeploymentType', Value: 'invalid' }, + { Key: 'BackupCompliance', Value: 'not-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'invalid-pattern' } + ] + }, + 'boundary-conditions': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: '' }, // Empty value + { Key: 'BusinessUnit', Value: 'infra-' } // Minimum pattern + ] + }, + 'special-characters': { + Tags: [ + { Key: 'DeploymentType', Value: 'edge' }, + { Key: 'BackupCompliance', Value: 'mission-critical' }, + { Key: 'OutpostIdentifier', Value: 'outpost-east-1' }, + { Key: 'BusinessUnit', Value: 'infra-prod#123' } // Special characters + ] + } + }; + + const params = { + ImageId: 'ami-002b9d4784a46775f', + InstanceType: 't3.micro', + MinCount: 1, + MaxCount: 1, + TagSpecifications: [{ + ResourceType: 'instance', + Tags: testCases[variation].Tags + }] + }; + + const command = new RunInstancesCommand(params); + return await ec2Client.send(command); +} +`; + +export class SecurityBlogSampleCodeStack extends cdk.Stack { + constructor(scope: Construct, id: string, props?: cdk.StackProps) { + super(scope, id, props); + + // Define required tags and allowed values + const REQUIRED_TAGS = { + DeploymentType: ['edge', 'core', 'hybrid'], + BackupCompliance: ['mission-critical', 'business-critical'], + OutpostIdentifier: '*', + BusinessUnit: 'infra-*' + }; + + // Create VPC for EC2 instance + const vpc = new ec2.Vpc(this, 'TaggingTestVPC', { + maxAzs: 2, + natGateways: 1 + }); + + // Create AWS Backup configuration + const backupVault = new backup.BackupVault(this, 'EC2BackupVault', { + backupVaultName: 'ec2-backup-vault', + removalPolicy: cdk.RemovalPolicy.DESTROY + }); + + // Create Mission Critical Backup Plan + const missionCriticalPlan = new backup.BackupPlan(this, 'MissionCriticalBackupPlan', { + backupVault, + backupPlanRules: [ + new backup.BackupPlanRule({ + completionWindow: cdk.Duration.hours(2), + startWindow: cdk.Duration.hours(1), + scheduleExpression: cdk.aws_events.Schedule.cron({ + day: '*', + hour: '3', + minute: '0' + }), + deleteAfter: cdk.Duration.days(180), + moveToColdStorageAfter: cdk.Duration.days(90), + enableContinuousBackup: false + }) + ] + }); + + // Create Business Critical Backup Plan + const businessCriticalPlan = new backup.BackupPlan(this, 'BusinessCriticalBackupPlan', { + backupVault, + backupPlanRules: [ + new backup.BackupPlanRule({ + completionWindow: cdk.Duration.hours(3), + startWindow: cdk.Duration.hours(1), + scheduleExpression: cdk.aws_events.Schedule.cron({ + day: '*', + hour: '12', + minute: '0' + }), + deleteAfter: cdk.Duration.days(97), + moveToColdStorageAfter: cdk.Duration.days(7) + }) + ] + }); + + // Add selection for Mission Critical resources + new backup.BackupSelection(this, 'MissionCriticalSelection', { + backupPlan: missionCriticalPlan, + resources: [ + backup.BackupResource.fromTag('BackupCompliance', 'mission-critical') + ] + }); + + // Add selection for Business Critical resources + new backup.BackupSelection(this, 'BusinessCriticalSelection', { + backupPlan: businessCriticalPlan, + resources: [ + backup.BackupResource.fromTag('BackupCompliance', 'business-critical') + ] + }); + + // Create privileged IAM role for tag management exception + const privilegedRole = new iam.Role(this, 'PrivilegedRole', { + roleName: 'PrivilegedRole', + assumedBy: new iam.CompositePrincipal( + new iam.ServicePrincipal('lambda.amazonaws.com') + ), + description: 'A privileged role with the ability to delete Tags' + }); + + // Create SCP policies using De Morgan's Laws + const tagEnforcementSCP = new organizations.CfnPolicy(this, 'TagEnforcementSCP', { + content: { + Version: '2012-10-17', + Statement: [ + { + Sid: 'EnforceRequiredTags', + Effect: 'Deny', + Action: ['ec2:RunInstances'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'Null': { + 'aws:RequestTag/OutpostIdentifier': 'true', + } + } + }, + { + Sid: 'EnforceDeploymentTypeValues', + Effect: 'Deny', + Action: ['ec2:RunInstances'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'StringNotEquals': { + 'aws:RequestTag/DeploymentType': ['edge', 'core', 'hybrid'] + } + } + }, + { + Sid: 'EnforceBackupComplianceValues', + Effect: 'Deny', + Action: ['ec2:RunInstances'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'StringNotEquals': { + 'aws:RequestTag/BackupCompliance': ['mission-critical', 'business-critical'] + } + } + }, + { + Sid: 'EnforceBusinessUnitPattern', + Effect: 'Deny', + Action: ['ec2:RunInstances'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'StringNotLike': { + 'aws:RequestTag/BusinessUnit': 'infra-*' + } + } + }, + { + Sid: 'DenyTagChangesOutsideOfRunInstances', + Effect: 'Deny', + Action: ['ec2:CreateTags'], + Resource: ['arn:aws:ec2:*:*:instance/*'], + Condition: { + 'StringNotEquals': { + 'ec2:CreateAction': 'RunInstances' + } + } + }, + { + Sid: 'DenyTagDeletion', + Effect: 'Deny', + Action: ['ec2:DeleteTags'], + Resource: ['arn:aws:ec2:*:*:*/*'], + Condition: { + 'ArnNotLike': { + 'aws:PrincipalARN': 'arn:aws:iam::${Account}:role/' + privilegedRole.roleArn + } + } + } + ] + }, + name: 'TagEnforcementPolicy', + type: 'SERVICE_CONTROL_POLICY', + targetIds: ['ou-8033-hltnny6u'] // update with your OU + }); + + // Create Lambda function for testing EC2 creation scenarios + const testFunction = new lambda.Function(this, 'TaggingTestFunction', { + runtime: lambda.Runtime.NODEJS_22_X, + handler: 'index.handler', + code: lambda.Code.fromInline(taggingTestCode), + vpc, + timeout: cdk.Duration.minutes(5), + environment: { + REQUIRED_TAGS: JSON.stringify(REQUIRED_TAGS) + } + }); + + testFunction.addToRolePolicy(new iam.PolicyStatement({ + actions: ['ec2:RunInstances'], + resources: ['*'] + })); + + testFunction.addToRolePolicy(new iam.PolicyStatement({ + actions: ['ec2:CreateTags'], + resources: ['arn:aws:ec2:*:*:instance/*'], + condition: { + 'StringEquals': { + 'ec2:CreateAction': 'RunInstances' + } + } + })); + + // Outputs + new cdk.CfnOutput(this, 'LambdaFunctionName', { + value: testFunction.functionName, + description: 'Name of the Lambda function for testing' + }); + + } +} \ No newline at end of file diff --git a/Tagging-Governance/package.json b/Tagging-Governance/package.json new file mode 100644 index 0000000..1486bea --- /dev/null +++ b/Tagging-Governance/package.json @@ -0,0 +1,26 @@ +{ + "name": "security_blog_sample_code", + "version": "0.1.0", + "bin": { + "security_blog_sample_code": "bin/security_blog_sample_code.js" + }, + "scripts": { + "build": "tsc", + "watch": "tsc -w", + "test": "jest", + "cdk": "cdk" + }, + "devDependencies": { + "@types/jest": "^29.5.14", + "@types/node": "22.7.9", + "jest": "^29.7.0", + "ts-jest": "^29.2.5", + "aws-cdk": "2.174.1", + "ts-node": "^10.9.2", + "typescript": "~5.6.3" + }, + "dependencies": { + "aws-cdk-lib": "2.174.1", + "constructs": "^10.0.0" + } +} diff --git a/Tagging-Governance/test/security_blog_sample_code.test.d.ts b/Tagging-Governance/test/security_blog_sample_code.test.d.ts new file mode 100644 index 0000000..e69de29 diff --git a/Tagging-Governance/test/security_blog_sample_code.test.js b/Tagging-Governance/test/security_blog_sample_code.test.js new file mode 100644 index 0000000..698f11b --- /dev/null +++ b/Tagging-Governance/test/security_blog_sample_code.test.js @@ -0,0 +1,17 @@ +"use strict"; +// import * as cdk from 'aws-cdk-lib'; +// import { Template } from 'aws-cdk-lib/assertions'; +// import * as SecurityBlogSampleCode from '../lib/security_blog_sample_code-stack'; +// example test. To run these tests, uncomment this file along with the +// example resource in lib/security_blog_sample_code-stack.ts +test('SQS Queue Created', () => { + // const app = new cdk.App(); + // // WHEN + // const stack = new SecurityBlogSampleCode.SecurityBlogSampleCodeStack(app, 'MyTestStack'); + // // THEN + // const template = Template.fromStack(stack); + // template.hasResourceProperties('AWS::SQS::Queue', { + // VisibilityTimeout: 300 + // }); +}); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjdXJpdHlfYmxvZ19zYW1wbGVfY29kZS50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic2VjdXJpdHlfYmxvZ19zYW1wbGVfY29kZS50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxzQ0FBc0M7QUFDdEMscURBQXFEO0FBQ3JELG9GQUFvRjtBQUVwRix1RUFBdUU7QUFDdkUsNkRBQTZEO0FBQzdELElBQUksQ0FBQyxtQkFBbUIsRUFBRSxHQUFHLEVBQUU7SUFDL0IsK0JBQStCO0lBQy9CLGNBQWM7SUFDZCw4RkFBOEY7SUFDOUYsY0FBYztJQUNkLGdEQUFnRDtJQUVoRCx3REFBd0Q7SUFDeEQsNkJBQTZCO0lBQzdCLFFBQVE7QUFDUixDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIGltcG9ydCAqIGFzIGNkayBmcm9tICdhd3MtY2RrLWxpYic7XG4vLyBpbXBvcnQgeyBUZW1wbGF0ZSB9IGZyb20gJ2F3cy1jZGstbGliL2Fzc2VydGlvbnMnO1xuLy8gaW1wb3J0ICogYXMgU2VjdXJpdHlCbG9nU2FtcGxlQ29kZSBmcm9tICcuLi9saWIvc2VjdXJpdHlfYmxvZ19zYW1wbGVfY29kZS1zdGFjayc7XG5cbi8vIGV4YW1wbGUgdGVzdC4gVG8gcnVuIHRoZXNlIHRlc3RzLCB1bmNvbW1lbnQgdGhpcyBmaWxlIGFsb25nIHdpdGggdGhlXG4vLyBleGFtcGxlIHJlc291cmNlIGluIGxpYi9zZWN1cml0eV9ibG9nX3NhbXBsZV9jb2RlLXN0YWNrLnRzXG50ZXN0KCdTUVMgUXVldWUgQ3JlYXRlZCcsICgpID0+IHtcbi8vICAgY29uc3QgYXBwID0gbmV3IGNkay5BcHAoKTtcbi8vICAgICAvLyBXSEVOXG4vLyAgIGNvbnN0IHN0YWNrID0gbmV3IFNlY3VyaXR5QmxvZ1NhbXBsZUNvZGUuU2VjdXJpdHlCbG9nU2FtcGxlQ29kZVN0YWNrKGFwcCwgJ015VGVzdFN0YWNrJyk7XG4vLyAgICAgLy8gVEhFTlxuLy8gICBjb25zdCB0ZW1wbGF0ZSA9IFRlbXBsYXRlLmZyb21TdGFjayhzdGFjayk7XG5cbi8vICAgdGVtcGxhdGUuaGFzUmVzb3VyY2VQcm9wZXJ0aWVzKCdBV1M6OlNRUzo6UXVldWUnLCB7XG4vLyAgICAgVmlzaWJpbGl0eVRpbWVvdXQ6IDMwMFxuLy8gICB9KTtcbn0pO1xuIl19 \ No newline at end of file diff --git a/Tagging-Governance/test/security_blog_sample_code.test.ts b/Tagging-Governance/test/security_blog_sample_code.test.ts new file mode 100644 index 0000000..6bac8bb --- /dev/null +++ b/Tagging-Governance/test/security_blog_sample_code.test.ts @@ -0,0 +1,17 @@ +// import * as cdk from 'aws-cdk-lib'; +// import { Template } from 'aws-cdk-lib/assertions'; +// import * as SecurityBlogSampleCode from '../lib/security_blog_sample_code-stack'; + +// example test. To run these tests, uncomment this file along with the +// example resource in lib/security_blog_sample_code-stack.ts +test('SQS Queue Created', () => { +// const app = new cdk.App(); +// // WHEN +// const stack = new SecurityBlogSampleCode.SecurityBlogSampleCodeStack(app, 'MyTestStack'); +// // THEN +// const template = Template.fromStack(stack); + +// template.hasResourceProperties('AWS::SQS::Queue', { +// VisibilityTimeout: 300 +// }); +}); diff --git a/Tagging-Governance/tsconfig.json b/Tagging-Governance/tsconfig.json new file mode 100644 index 0000000..aaa7dc5 --- /dev/null +++ b/Tagging-Governance/tsconfig.json @@ -0,0 +1,31 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "commonjs", + "lib": [ + "es2020", + "dom" + ], + "declaration": true, + "strict": true, + "noImplicitAny": true, + "strictNullChecks": true, + "noImplicitThis": true, + "alwaysStrict": true, + "noUnusedLocals": false, + "noUnusedParameters": false, + "noImplicitReturns": true, + "noFallthroughCasesInSwitch": false, + "inlineSourceMap": true, + "inlineSources": true, + "experimentalDecorators": true, + "strictPropertyInitialization": false, + "typeRoots": [ + "./node_modules/@types" + ] + }, + "exclude": [ + "node_modules", + "cdk.out" + ] +}