@sureshgururajan/aws-console-private-access-validator 1.0.3 → 1.0.5

package/src/validator.js

@@ -0,0 +1,236 @@
+export class ConsolePrivateAccessValidator {
+    template;
+    region;
+    checks = [];
+    constructor(template, region = 'us-east-1') {
+        this.template = template;
+        this.region = region;
+    }
+    validate() {
+        this.checks = [];
+        this.checkVpcEndpoints();
+        this.checkEndpointPolicies();
+        this.checkRoute53HostedZones();
+        this.checkSecurityGroups();
+        this.checkEc2Instance();
+        this.checkNatGateway();
+        this.checkNetworkConfiguration();
+        const failCount = this.checks.filter(c => c.status === 'fail').length;
+        const valid = failCount === 0;
+        return {
+            valid,
+            checks: this.checks,
+            summary: this.generateSummary(valid, failCount),
+        };
+    }
+    getServiceName(serviceName) {
+        if (typeof serviceName === 'string') {
+            return serviceName;
+        }
+        if (serviceName?.['Fn::Join']) {
+            const parts = serviceName['Fn::Join'][1];
+            if (Array.isArray(parts)) {
+                // Handle Ref to AWS::Region by replacing with actual region
+                return parts
+                    .map((part) => {
+                    if (typeof part === 'string') {
+                        return part;
+                    }
+                    if (part?.Ref === 'AWS::Region') {
+                        return this.region;
+                    }
+                    return '';
+                })
+                    .join('');
+            }
+        }
+        return null;
+    }
+    checkVpcEndpoints() {
+        const requiredEndpoints = [
+            { name: 'console', service: `com.amazonaws.${this.region}.console` },
+            { name: 'signin', service: `com.amazonaws.${this.region}.signin` },
+            { name: 'ssm', service: `com.amazonaws.${this.region}.ssm` },
+            { name: 'ec2messages', service: `com.amazonaws.${this.region}.ec2messages` },
+            { name: 'ssmmessages', service: `com.amazonaws.${this.region}.ssmmessages` },
+        ];
+        const resources = this.template.Resources || {};
+        const interfaceEndpoints = Object.values(resources).filter((r) => r.Type === 'AWS::EC2::VPCEndpoint' && r.Properties?.VpcEndpointType === 'Interface');
+        for (const endpoint of requiredEndpoints) {
+            const found = interfaceEndpoints.some((e) => {
+                const serviceName = this.getServiceName(e.Properties?.ServiceName);
+                return serviceName && serviceName.includes(endpoint.service);
+            });
+            this.checks.push({
+                name: `VPC Endpoint: ${endpoint.name}`,
+                status: found ? 'pass' : 'fail',
+                message: found
+                    ? `Interface VPC endpoint for ${endpoint.name} found`
+                    : `Missing interface VPC endpoint for ${endpoint.name}`,
+            });
+        }
+        // Check for S3 Gateway endpoint
+        const s3Gateway = Object.values(resources).some((r) => {
+            const serviceName = this.getServiceName(r.Properties?.ServiceName);
+            return (r.Type === 'AWS::EC2::VPCEndpoint' &&
+                r.Properties?.VpcEndpointType === 'Gateway' &&
+                serviceName &&
+                serviceName.includes('s3'));
+        });
+        this.checks.push({
+            name: 'VPC Endpoint: S3 Gateway',
+            status: s3Gateway ? 'pass' : 'fail',
+            message: s3Gateway ? 'S3 Gateway VPC endpoint found' : 'Missing S3 Gateway VPC endpoint',
+        });
+    }
+    checkEndpointPolicies() {
+        const resources = this.template.Resources || {};
+        const consoleEndpoint = Object.entries(resources).find(([_, r]) => {
+            const serviceName = this.getServiceName(r.Properties?.ServiceName);
+            return (r.Type === 'AWS::EC2::VPCEndpoint' &&
+                serviceName &&
+                serviceName.includes('console'));
+        });
+        const signinEndpoint = Object.entries(resources).find(([_, r]) => {
+            const serviceName = this.getServiceName(r.Properties?.ServiceName);
+            return (r.Type === 'AWS::EC2::VPCEndpoint' &&
+                serviceName &&
+                serviceName.includes('signin'));
+        });
+        for (const [name, endpoint] of [
+            ['Console', consoleEndpoint],
+            ['Signin', signinEndpoint],
+        ]) {
+            if (!endpoint)
+                continue;
+            const [_, resource] = endpoint;
+            const hasPolicy = resource.Properties?.PolicyDocument;
+            this.checks.push({
+                name: `Endpoint Policy: ${name}`,
+                status: hasPolicy ? 'pass' : 'fail',
+                message: hasPolicy
+                    ? `${name} endpoint has a policy attached`
+                    : `${name} endpoint is missing a policy`,
+                details: hasPolicy
+                    ? this.validatePolicyContent(resource.Properties.PolicyDocument)
+                    : undefined,
+            });
+        }
+    }
+    validatePolicyContent(policy) {
+        if (!policy.Statement || policy.Statement.length === 0) {
+            return 'Policy has no statements';
+        }
+        const statement = policy.Statement[0];
+        const hasAccountCondition = statement.Condition?.StringEquals?.['aws:PrincipalAccount'];
+        if (hasAccountCondition) {
+            return 'Policy restricts access to specific account(s)';
+        }
+        return 'Policy does not restrict access by account';
+    }
+    checkRoute53HostedZones() {
+        const resources = this.template.Resources || {};
+        const hostedZones = Object.values(resources).filter((r) => r.Type === 'AWS::Route53::HostedZone');
+        const requiredZones = ['console.aws.amazon.com', 'signin.aws.amazon.com'];
+        for (const zone of requiredZones) {
+            const found = hostedZones.some((hz) => {
+                const zoneName = hz.Properties?.Name;
+                // Route53 zone names may have a trailing dot
+                return zoneName === zone || zoneName === `${zone}.`;
+            });
+            this.checks.push({
+                name: `Route53 Hosted Zone: ${zone}`,
+                status: found ? 'pass' : 'fail',
+                message: found
+                    ? `Private hosted zone for ${zone} found`
+                    : `Missing private hosted zone for ${zone}`,
+            });
+        }
+        // Check for Route53 records
+        const recordSets = Object.values(resources).filter((r) => r.Type === 'AWS::Route53::RecordSet');
+        this.checks.push({
+            name: 'Route53 Records',
+            status: recordSets.length > 0 ? 'pass' : 'warning',
+            message: recordSets.length > 0
+                ? `Found ${recordSets.length} Route53 records`
+                : 'No Route53 records found',
+        });
+    }
+    checkSecurityGroups() {
+        const resources = this.template.Resources || {};
+        const securityGroups = Object.values(resources).filter((r) => r.Type === 'AWS::EC2::SecurityGroup');
+        const hasHttpsIngress = securityGroups.some((sg) => {
+            const ingress = sg.Properties?.SecurityGroupIngress || [];
+            return ingress.some((rule) => (rule.FromPort === 443 || rule.IpProtocol === 'tcp') &&
+                (rule.ToPort === 443 || rule.IpProtocol === 'tcp'));
+        });
+        this.checks.push({
+            name: 'Security Group: HTTPS Access',
+            status: hasHttpsIngress ? 'pass' : 'warning',
+            message: hasHttpsIngress
+                ? 'Security group allows HTTPS (port 443) traffic'
+                : 'No security group rule found for HTTPS (port 443)',
+        });
+    }
+    checkEc2Instance() {
+        const resources = this.template.Resources || {};
+        const instance = Object.values(resources).find((r) => r.Type === 'AWS::EC2::Instance');
+        this.checks.push({
+            name: 'EC2 Instance',
+            status: instance ? 'pass' : 'warning',
+            message: instance ? 'EC2 instance found' : 'No EC2 instance found (optional)',
+        });
+        if (instance) {
+            const hasIamRole = instance.Properties?.IamInstanceProfile;
+            this.checks.push({
+                name: 'EC2 IAM Role',
+                status: hasIamRole ? 'pass' : 'warning',
+                message: hasIamRole
+                    ? 'EC2 instance has IAM instance profile'
+                    : 'EC2 instance missing IAM instance profile',
+            });
+        }
+    }
+    checkNatGateway() {
+        const resources = this.template.Resources || {};
+        const natGateway = Object.values(resources).find((r) => r.Type === 'AWS::EC2::NatGateway');
+        this.checks.push({
+            name: 'NAT Gateway',
+            status: natGateway ? 'pass' : 'warning',
+            message: natGateway
+                ? 'NAT Gateway found for private subnet egress'
+                : 'No NAT Gateway found (required for private subnet internet access)',
+        });
+    }
+    checkNetworkConfiguration() {
+        const resources = this.template.Resources || {};
+        // Check for private subnets
+        const privateSubnets = Object.values(resources).filter((r) => r.Type === 'AWS::EC2::Subnet' &&
+            !r.Properties?.MapPublicIpOnLaunch);
+        this.checks.push({
+            name: 'Private Subnets',
+            status: privateSubnets.length > 0 ? 'pass' : 'fail',
+            message: privateSubnets.length > 0
+                ? `Found ${privateSubnets.length} private subnet(s)`
+                : 'No private subnets found',
+        });
+        // Check for route tables
+        const routeTables = Object.values(resources).filter((r) => r.Type === 'AWS::EC2::RouteTable');
+        this.checks.push({
+            name: 'Route Tables',
+            status: routeTables.length > 0 ? 'pass' : 'warning',
+            message: routeTables.length > 0
+                ? `Found ${routeTables.length} route table(s)`
+                : 'No route tables found',
+        });
+    }
+    generateSummary(valid, failCount) {
+        const passCount = this.checks.filter(c => c.status === 'pass').length;
+        const warningCount = this.checks.filter(c => c.status === 'warning').length;
+        if (valid) {
+            return `✓ Validation passed. All required checks passed (${passCount} passed, ${warningCount} warnings).`;
+        }
+        return `✗ Validation failed. ${failCount} check(s) failed, ${passCount} passed, ${warningCount} warnings.`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validator.js","sourceRoot":"","sources":["validator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ValidationCheck, ValidationResult, CloudFormationTemplate } from './types';\n\nexport class ConsolePrivateAccessValidator {\n  private template: CloudFormationTemplate;\n  private region: string;\n  private checks: ValidationCheck[] = [];\n\n  constructor(template: CloudFormationTemplate, region: string = 'us-east-1') {\n    this.template = template;\n    this.region = region;\n  }\n\n  validate(): ValidationResult {\n    this.checks = [];\n\n    this.checkVpcEndpoints();\n    this.checkEndpointPolicies();\n    this.checkRoute53HostedZones();\n    this.checkSecurityGroups();\n    this.checkEc2Instance();\n    this.checkNatGateway();\n    this.checkNetworkConfiguration();\n\n    const failCount = this.checks.filter(c => c.status === 'fail').length;\n    const valid = failCount === 0;\n\n    return {\n      valid,\n      checks: this.checks,\n      summary: this.generateSummary(valid, failCount),\n    };\n  }\n\n  private getServiceName(serviceName: any): string | null {\n    if (typeof serviceName === 'string') {\n      return serviceName;\n    }\n    if (serviceName?.['Fn::Join']) {\n      const parts = serviceName['Fn::Join'][1];\n      if (Array.isArray(parts)) {\n        // Handle Ref to AWS::Region by replacing with actual region\n        return parts\n          .map((part: any) => {\n            if (typeof part === 'string') {\n              return part;\n            }\n            if (part?.Ref === 'AWS::Region') {\n              return this.region;\n            }\n            return '';\n          })\n          .join('');\n      }\n    }\n    return null;\n  }\n\n  private checkVpcEndpoints(): void {\n    const requiredEndpoints = [\n      { name: 'console', service: `com.amazonaws.${this.region}.console` },\n      { name: 'signin', service: `com.amazonaws.${this.region}.signin` },\n      { name: 'ssm', service: `com.amazonaws.${this.region}.ssm` },\n      { name: 'ec2messages', service: `com.amazonaws.${this.region}.ec2messages` },\n      { name: 'ssmmessages', service: `com.amazonaws.${this.region}.ssmmessages` },\n    ];\n\n    const resources = this.template.Resources || {};\n    const interfaceEndpoints = Object.values(resources).filter(\n      (r: any) => r.Type === 'AWS::EC2::VPCEndpoint' && r.Properties?.VpcEndpointType === 'Interface'\n    );\n\n    for (const endpoint of requiredEndpoints) {\n      const found = interfaceEndpoints.some((e: any) => {\n        const serviceName = this.getServiceName(e.Properties?.ServiceName);\n        return serviceName && serviceName.includes(endpoint.service);\n      });\n\n      this.checks.push({\n        name: `VPC Endpoint: ${endpoint.name}`,\n        status: found ? 'pass' : 'fail',\n        message: found\n          ? `Interface VPC endpoint for ${endpoint.name} found`\n          : `Missing interface VPC endpoint for ${endpoint.name}`,\n      });\n    }\n\n    // Check for S3 Gateway endpoint\n    const s3Gateway = Object.values(resources).some(\n      (r: any) => {\n        const serviceName = this.getServiceName(r.Properties?.ServiceName);\n        return (\n          r.Type === 'AWS::EC2::VPCEndpoint' &&\n          r.Properties?.VpcEndpointType === 'Gateway' &&\n          serviceName &&\n          serviceName.includes('s3')\n        );\n      }\n    );\n\n    this.checks.push({\n      name: 'VPC Endpoint: S3 Gateway',\n      status: s3Gateway ? 'pass' : 'fail',\n      message: s3Gateway ? 'S3 Gateway VPC endpoint found' : 'Missing S3 Gateway VPC endpoint',\n    });\n  }\n\n  private checkEndpointPolicies(): void {\n    const resources = this.template.Resources || {};\n    const consoleEndpoint = Object.entries(resources).find(\n      ([_, r]: [string, any]) => {\n        const serviceName = this.getServiceName(r.Properties?.ServiceName);\n        return (\n          r.Type === 'AWS::EC2::VPCEndpoint' &&\n          serviceName &&\n          serviceName.includes('console')\n        );\n      }\n    );\n\n    const signinEndpoint = Object.entries(resources).find(\n      ([_, r]: [string, any]) => {\n        const serviceName = this.getServiceName(r.Properties?.ServiceName);\n        return (\n          r.Type === 'AWS::EC2::VPCEndpoint' &&\n          serviceName &&\n          serviceName.includes('signin')\n        );\n      }\n    );\n\n    for (const [name, endpoint] of [\n      ['Console', consoleEndpoint],\n      ['Signin', signinEndpoint],\n    ]) {\n      if (!endpoint) continue;\n\n      const [_, resource] = endpoint as [string, any];\n      const hasPolicy = resource.Properties?.PolicyDocument;\n\n      this.checks.push({\n        name: `Endpoint Policy: ${name}`,\n        status: hasPolicy ? 'pass' : 'fail',\n        message: hasPolicy\n          ? `${name} endpoint has a policy attached`\n          : `${name} endpoint is missing a policy`,\n        details: hasPolicy\n          ? this.validatePolicyContent(resource.Properties.PolicyDocument)\n          : undefined,\n      });\n    }\n  }\n\n  private validatePolicyContent(policy: any): string {\n    if (!policy.Statement || policy.Statement.length === 0) {\n      return 'Policy has no statements';\n    }\n\n    const statement = policy.Statement[0];\n    const hasAccountCondition = statement.Condition?.StringEquals?.['aws:PrincipalAccount'];\n\n    if (hasAccountCondition) {\n      return 'Policy restricts access to specific account(s)';\n    }\n\n    return 'Policy does not restrict access by account';\n  }\n\n  private checkRoute53HostedZones(): void {\n    const resources = this.template.Resources || {};\n    const hostedZones = Object.values(resources).filter(\n      (r: any) => r.Type === 'AWS::Route53::HostedZone'\n    );\n\n    const requiredZones = ['console.aws.amazon.com', 'signin.aws.amazon.com'];\n\n    for (const zone of requiredZones) {\n      const found = hostedZones.some((hz: any) => {\n        const zoneName = hz.Properties?.Name;\n        // Route53 zone names may have a trailing dot\n        return zoneName === zone || zoneName === `${zone}.`;\n      });\n\n      this.checks.push({\n        name: `Route53 Hosted Zone: ${zone}`,\n        status: found ? 'pass' : 'fail',\n        message: found\n          ? `Private hosted zone for ${zone} found`\n          : `Missing private hosted zone for ${zone}`,\n      });\n    }\n\n    // Check for Route53 records\n    const recordSets = Object.values(resources).filter(\n      (r: any) => r.Type === 'AWS::Route53::RecordSet'\n    );\n\n    this.checks.push({\n      name: 'Route53 Records',\n      status: recordSets.length > 0 ? 'pass' : 'warning',\n      message:\n        recordSets.length > 0\n          ? `Found ${recordSets.length} Route53 records`\n          : 'No Route53 records found',\n    });\n  }\n\n  private checkSecurityGroups(): void {\n    const resources = this.template.Resources || {};\n    const securityGroups = Object.values(resources).filter(\n      (r: any) => r.Type === 'AWS::EC2::SecurityGroup'\n    );\n\n    const hasHttpsIngress = securityGroups.some((sg: any) => {\n      const ingress = sg.Properties?.SecurityGroupIngress || [];\n      return ingress.some(\n        (rule: any) =>\n          (rule.FromPort === 443 || rule.IpProtocol === 'tcp') &&\n          (rule.ToPort === 443 || rule.IpProtocol === 'tcp')\n      );\n    });\n\n    this.checks.push({\n      name: 'Security Group: HTTPS Access',\n      status: hasHttpsIngress ? 'pass' : 'warning',\n      message: hasHttpsIngress\n        ? 'Security group allows HTTPS (port 443) traffic'\n        : 'No security group rule found for HTTPS (port 443)',\n    });\n  }\n\n  private checkEc2Instance(): void {\n    const resources = this.template.Resources || {};\n    const instance = Object.values(resources).find((r: any) => r.Type === 'AWS::EC2::Instance');\n\n    this.checks.push({\n      name: 'EC2 Instance',\n      status: instance ? 'pass' : 'warning',\n      message: instance ? 'EC2 instance found' : 'No EC2 instance found (optional)',\n    });\n\n    if (instance) {\n      const hasIamRole = (instance as any).Properties?.IamInstanceProfile;\n      this.checks.push({\n        name: 'EC2 IAM Role',\n        status: hasIamRole ? 'pass' : 'warning',\n        message: hasIamRole\n          ? 'EC2 instance has IAM instance profile'\n          : 'EC2 instance missing IAM instance profile',\n      });\n    }\n  }\n\n  private checkNatGateway(): void {\n    const resources = this.template.Resources || {};\n    const natGateway = Object.values(resources).find((r: any) => r.Type === 'AWS::EC2::NatGateway');\n\n    this.checks.push({\n      name: 'NAT Gateway',\n      status: natGateway ? 'pass' : 'warning',\n      message: natGateway\n        ? 'NAT Gateway found for private subnet egress'\n        : 'No NAT Gateway found (required for private subnet internet access)',\n    });\n  }\n\n  private checkNetworkConfiguration(): void {\n    const resources = this.template.Resources || {};\n\n    // Check for private subnets\n    const privateSubnets = Object.values(resources).filter(\n      (r: any) =>\n        r.Type === 'AWS::EC2::Subnet' &&\n        !r.Properties?.MapPublicIpOnLaunch\n    );\n\n    this.checks.push({\n      name: 'Private Subnets',\n      status: privateSubnets.length > 0 ? 'pass' : 'fail',\n      message:\n        privateSubnets.length > 0\n          ? `Found ${privateSubnets.length} private subnet(s)`\n          : 'No private subnets found',\n    });\n\n    // Check for route tables\n    const routeTables = Object.values(resources).filter(\n      (r: any) => r.Type === 'AWS::EC2::RouteTable'\n    );\n\n    this.checks.push({\n      name: 'Route Tables',\n      status: routeTables.length > 0 ? 'pass' : 'warning',\n      message:\n        routeTables.length > 0\n          ? `Found ${routeTables.length} route table(s)`\n          : 'No route tables found',\n    });\n  }\n\n  private generateSummary(valid: boolean, failCount: number): string {\n    const passCount = this.checks.filter(c => c.status === 'pass').length;\n    const warningCount = this.checks.filter(c => c.status === 'warning').length;\n\n    if (valid) {\n      return `✓ Validation passed. All required checks passed (${passCount} passed, ${warningCount} warnings).`;\n    }\n\n    return `✗ Validation failed. ${failCount} check(s) failed, ${passCount} passed, ${warningCount} warnings.`;\n  }\n}\n"]}