p6-cdk-s3-protector 0.0.1

package/lib/p6cdks3protector.p6CDKS3Protector.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = handler;
+exports.main = main;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const client_s3_1 = require("@aws-sdk/client-s3");
+const client_s3_control_1 = require("@aws-sdk/client-s3-control");
+const client_sts_1 = require("@aws-sdk/client-sts");
+const winston_1 = __importDefault(require("winston"));
+// Configure the logger
+const logger = winston_1.default.createLogger({
+    level: 'info',
+    format: winston_1.default.format.json(),
+    defaultMeta: { service: 'user-service' },
+    transports: [
+        new winston_1.default.transports.Console(),
+    ],
+});
+const s3Client = new client_s3_1.S3({});
+const s3ControlClient = new client_s3_control_1.S3ControlClient({});
+const stsClient = new client_sts_1.STSClient({});
+function p6ShortCircuitShould(event) {
+    if (event.detail.requestParameters['x-amz-acl']) {
+        logger.info('ACL is currently %s', event.detail.requestParameters['x-amz-acl'][0]);
+        if (event.detail.requestParameters['x-amz-acl'][0] === 'private') {
+            logger.info('ACL is already private.  Ending.');
+            return true;
+        }
+    }
+    return false;
+}
+function p6LoopPrevent(event) {
+    if (event.detail.errorCode || event.detail.errorMessage) {
+        logger.info('Previous API call resulted in an error. Ending');
+        return true;
+    }
+    return false;
+}
+async function p6S3BucketAclGet(event) {
+    try {
+        const bucketName = event.detail.requestParameters.bucketName;
+        logger.info('Describing the current ACL: s3://%s', bucketName);
+        const bucketAcl = await s3Client.getBucketAcl({ Bucket: bucketName });
+        logger.info(JSON.stringify(bucketAcl));
+        return bucketAcl;
+    }
+    catch (err) {
+        logger.error('Error was: {%s} Manual followup recommended', err);
+        return false;
+    }
+}
+function p6LogDeliveryPreserve(bucketAcl) {
+    let uriList = '';
+    const preserveLogDelivery = [];
+    for (const grant of bucketAcl.Grants || []) {
+        if (grant.Grantee?.URI) {
+            logger.info('Found Grant: %s', JSON.stringify(grant));
+            uriList += grant.Grantee.URI;
+            if (grant.Grantee.URI.includes('LogDelivery')) {
+                preserveLogDelivery.push(grant);
+            }
+        }
+    }
+    return [uriList, preserveLogDelivery];
+}
+function p6S3BucketAclViolation(uriList) {
+    if (uriList.includes('AllUsers') || uriList.includes('AuthenticatedUsers')) {
+        logger.info('Violation found.  Grant ACL greater than Private');
+        return true;
+    }
+    logger.info('ACL is correctly already private');
+    return false;
+}
+async function p6S3BucketAclCorrect(bucketAcl, preserveLogDelivery) {
+    logger.info('Attempting Automatic Resolution');
+    try {
+        if (preserveLogDelivery) {
+            logger.info('ACL resetting ACL to LogDelivery');
+            logger.info('Preserve was: %s', JSON.stringify(preserveLogDelivery));
+            const aclString = {
+                Grants: preserveLogDelivery,
+                Owner: bucketAcl.Owner,
+            };
+            const response = await s3Client.putBucketAcl({
+                Bucket: bucketAcl?.Owner?.ID,
+                AccessControlPolicy: aclString,
+            });
+            logger.info(JSON.stringify(response));
+            if (response.$metadata.httpStatusCode === 200) {
+                logger.info('Reverted to only contain LogDelivery');
+            }
+            else {
+                logger.error('PutBucketACL failed. Manual followup');
+            }
+        }
+        else {
+            logger.info('ACL resetting ACL to Private');
+            const response = await s3Client.putBucketAcl({
+                Bucket: bucketAcl?.Owner?.ID,
+                ACL: 'private',
+            });
+            logger.info(JSON.stringify(response));
+            if (response.$metadata.httpStatusCode === 200) {
+                logger.info('Bucket ACL has been changed to Private');
+            }
+            else {
+                logger.error('PutBucketACL failed. Manual followup');
+            }
+        }
+    }
+    catch (err) {
+        logger.info('Unable to resolve violation automatically');
+        logger.info('Error was: %s', err);
+    }
+}
+async function p6S3PublicBucketAcl(event) {
+    if (p6ShortCircuitShould(event)) {
+        return true;
+    }
+    if (p6LoopPrevent(event)) {
+        return true;
+    }
+    const bucketAcl = await p6S3BucketAclGet(event);
+    if (!bucketAcl) {
+        return false;
+    }
+    const [uriList, preserveLogDelivery] = p6LogDeliveryPreserve(bucketAcl);
+    if (p6S3BucketAclViolation(uriList)) {
+        await p6S3BucketAclCorrect(bucketAcl, preserveLogDelivery);
+        return true;
+    }
+    return false;
+}
+async function awsIsPrivate(bucket, key) {
+    logger.info('Describing the ACL: s3://%s/%s', bucket, key);
+    const acl = await s3Client.getObjectAcl({ Bucket: bucket, Key: key });
+    if (acl.Grants.length > 1) {
+        logger.info('Greater than one Grant');
+        return false;
+    }
+    const ownerId = acl.Owner?.ID;
+    const granteeId = acl.Grants[0].Grantee?.ID;
+    if (ownerId !== granteeId) {
+        logger.info('owner:[%s], grantee[%s] do not match', ownerId, granteeId);
+        return false;
+    }
+    return true;
+}
+async function awsMakePrivate(bucket, key) {
+    logger.info('Making s3://%s/%s private', bucket, key);
+    await s3Client.putObjectAcl({ Bucket: bucket, Key: key, ACL: 'private' });
+}
+async function p6S3PublicBucketObjectAcl(event) {
+    const key = event.detail.requestParameters.key;
+    const bucket = event.detail.requestParameters.bucketName;
+    if (!(await awsIsPrivate(bucket, key))) {
+        await awsMakePrivate(bucket, key);
+    }
+}
+async function p6S3PublicBucketAccessBlock(event) {
+    const pbc = event.detail.requestParameters.PublicAccessBlockConfiguration;
+    logger.info(JSON.stringify(pbc));
+    if (!pbc.RestrictPublicBuckets || !pbc.BlockPublicPolicy || !pbc.BlockPublicAcls || !pbc.IgnorePublicAcls) {
+        const bucket = event.detail.requestParameters.bucketName;
+        logger.info('s3://%s now not private, fixing...', bucket);
+        const response = await s3Client.putPublicAccessBlock({
+            Bucket: bucket,
+            PublicAccessBlockConfiguration: {
+                BlockPublicAcls: true,
+                IgnorePublicAcls: true,
+                BlockPublicPolicy: true,
+                RestrictPublicBuckets: true,
+            },
+        });
+        logger.info(JSON.stringify(response));
+    }
+}
+async function p6S3PublicAccessBlock(event) {
+    const pbc = event.detail.requestParameters.PublicAccessBlockConfiguration;
+    logger.info(JSON.stringify(pbc));
+    if (!pbc.RestrictPublicBuckets || !pbc.BlockPublicPolicy || !pbc.BlockPublicAcls || !pbc.IgnorePublicAcls) {
+        const command = new client_sts_1.GetCallerIdentityCommand({});
+        const account = await stsClient.send(command);
+        logger.info('%s', account);
+        const response = await s3ControlClient.send(new client_s3_control_1.PutPublicAccessBlockCommand({
+            PublicAccessBlockConfiguration: {
+                BlockPublicAcls: true,
+                IgnorePublicAcls: true,
+                BlockPublicPolicy: true,
+                RestrictPublicBuckets: true,
+            },
+            AccountId: account.Account,
+        }));
+        logger.info(JSON.stringify(response));
+    }
+}
+async function p6S3PublicFusebox(event) {
+    if (!event.detail || !event.detail.eventName) {
+        return false;
+    }
+    const events = [
+        'PutBucketAcl',
+        'PutObjectAcl',
+        'PutBucketPublicAccessBlock',
+        'PutAccountPublicAccessBlock',
+    ];
+    const eventName = event.detail.eventName;
+    if (events.includes(eventName)) {
+        logger.info('======================================================================================');
+        logger.info('eventName: %s', eventName);
+    }
+    if (eventName === 'PutBucketAcl') {
+        await p6S3PublicBucketAcl(event);
+    }
+    else if (eventName === 'PutObjectAcl') {
+        await p6S3PublicBucketObjectAcl(event);
+    }
+    else if (eventName === 'PutBucketPublicAccessBlock') {
+        await p6S3PublicBucketAccessBlock(event);
+    }
+    else if (eventName === 'PutAccountPublicAccessBlock') {
+        await p6S3PublicAccessBlock(event);
+    }
+    return true;
+}
+async function handler(event, _context) {
+    await p6S3PublicFusebox(event);
+    return true;
+}
+async function main() {
+    logger.debug('Reading fixtures/putBucketAcl.json');
+    const data = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.resolve('fixtures/putBucketAcl.json'), 'utf8'));
+    logger.debug('handler()');
+    await handler(data);
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"p6cdks3protector.p6CDKS3Protector.js","sourceRoot":"","sources":["../src/p6cdks3protector.p6CDKS3Protector.ts"],"names":[],"mappings":"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","sourcesContent":["import type { GetBucketAclOutput, Grant } from '@aws-sdk/client-s3'\nimport type { Context } from 'aws-lambda'\nimport type { Logger } from 'winston'\nimport fs from 'node:fs'\nimport path from 'node:path'\nimport { S3 } from '@aws-sdk/client-s3'\nimport { PutPublicAccessBlockCommand, S3ControlClient } from '@aws-sdk/client-s3-control'\nimport { GetCallerIdentityCommand, STSClient } from '@aws-sdk/client-sts'\nimport winston from 'winston'\n\n// Configure the logger\nconst logger: Logger = winston.createLogger({\n  level: 'info',\n  format: winston.format.json(),\n  defaultMeta: { service: 'user-service' },\n  transports: [\n    new winston.transports.Console(),\n  ],\n})\n\nconst s3Client = new S3({})\nconst s3ControlClient = new S3ControlClient({})\nconst stsClient = new STSClient({})\n\ninterface S3Event {\n  detail: {\n    requestParameters: {\n      [key: string]: any\n    }\n    eventName: string\n    errorCode?: string\n    errorMessage?: string\n  }\n}\n\nfunction p6ShortCircuitShould(event: S3Event): boolean {\n  if (event.detail.requestParameters['x-amz-acl']) {\n    logger.info('ACL is currently %s', event.detail.requestParameters['x-amz-acl'][0])\n    if (event.detail.requestParameters['x-amz-acl'][0] === 'private') {\n      logger.info('ACL is already private.  Ending.')\n      return true\n    }\n  }\n  return false\n}\n\nfunction p6LoopPrevent(event: S3Event): boolean {\n  if (event.detail.errorCode || event.detail.errorMessage) {\n    logger.info('Previous API call resulted in an error. Ending')\n    return true\n  }\n  return false\n}\n\nasync function p6S3BucketAclGet(event: S3Event): Promise<GetBucketAclOutput | false> {\n  try {\n    const bucketName = event.detail.requestParameters.bucketName\n    logger.info('Describing the current ACL: s3://%s', bucketName)\n    const bucketAcl = await s3Client.getBucketAcl({ Bucket: bucketName })\n    logger.info(JSON.stringify(bucketAcl))\n    return bucketAcl\n  }\n  catch (err) {\n    logger.error('Error was: {%s} Manual followup recommended', err)\n    return false\n  }\n}\n\nfunction p6LogDeliveryPreserve(bucketAcl: GetBucketAclOutput): [string, Grant[]] {\n  let uriList = ''\n  const preserveLogDelivery: Grant[] = []\n\n  for (const grant of bucketAcl.Grants || []) {\n    if (grant.Grantee?.URI) {\n      logger.info('Found Grant: %s', JSON.stringify(grant))\n      uriList += grant.Grantee.URI\n      if (grant.Grantee.URI.includes('LogDelivery')) {\n        preserveLogDelivery.push(grant)\n      }\n    }\n  }\n\n  return [uriList, preserveLogDelivery]\n}\n\nfunction p6S3BucketAclViolation(uriList: string): boolean {\n  if (uriList.includes('AllUsers') || uriList.includes('AuthenticatedUsers')) {\n    logger.info('Violation found.  Grant ACL greater than Private')\n    return true\n  }\n  logger.info('ACL is correctly already private')\n  return false\n}\n\nasync function p6S3BucketAclCorrect(bucketAcl: GetBucketAclOutput, preserveLogDelivery: Array<Grant> | false): Promise<void> {\n  logger.info('Attempting Automatic Resolution')\n  try {\n    if (preserveLogDelivery) {\n      logger.info('ACL resetting ACL to LogDelivery')\n      logger.info('Preserve was: %s', JSON.stringify(preserveLogDelivery))\n\n      const aclString = {\n        Grants: preserveLogDelivery,\n        Owner: bucketAcl.Owner,\n      }\n\n      const response = await s3Client.putBucketAcl({\n        Bucket: bucketAcl?.Owner?.ID,\n        AccessControlPolicy: aclString,\n      })\n\n      logger.info(JSON.stringify(response))\n      if (response.$metadata.httpStatusCode === 200) {\n        logger.info('Reverted to only contain LogDelivery')\n      }\n      else {\n        logger.error('PutBucketACL failed. Manual followup')\n      }\n    }\n    else {\n      logger.info('ACL resetting ACL to Private')\n      const response = await s3Client.putBucketAcl({\n        Bucket: bucketAcl?.Owner?.ID,\n        ACL: 'private',\n      })\n\n      logger.info(JSON.stringify(response))\n      if (response.$metadata.httpStatusCode === 200) {\n        logger.info('Bucket ACL has been changed to Private')\n      }\n      else {\n        logger.error('PutBucketACL failed. Manual followup')\n      }\n    }\n  }\n  catch (err) {\n    logger.info('Unable to resolve violation automatically')\n    logger.info('Error was: %s', err)\n  }\n}\n\nasync function p6S3PublicBucketAcl(event: S3Event): Promise<boolean> {\n  if (p6ShortCircuitShould(event)) {\n    return true\n  }\n\n  if (p6LoopPrevent(event)) {\n    return true\n  }\n\n  const bucketAcl = await p6S3BucketAclGet(event)\n  if (!bucketAcl) {\n    return false\n  }\n\n  const [uriList, preserveLogDelivery] = p6LogDeliveryPreserve(bucketAcl)\n\n  if (p6S3BucketAclViolation(uriList)) {\n    await p6S3BucketAclCorrect(bucketAcl, preserveLogDelivery)\n    return true\n  }\n\n  return false\n}\n\nasync function awsIsPrivate(bucket: string, key: string): Promise<boolean> {\n  logger.info('Describing the ACL: s3://%s/%s', bucket, key)\n  const acl = await s3Client.getObjectAcl({ Bucket: bucket, Key: key })\n\n  if (acl.Grants!.length > 1) {\n    logger.info('Greater than one Grant')\n    return false\n  }\n\n  const ownerId = acl.Owner?.ID\n  const granteeId = acl.Grants![0].Grantee?.ID\n  if (ownerId !== granteeId) {\n    logger.info('owner:[%s], grantee[%s] do not match', ownerId, granteeId)\n    return false\n  }\n\n  return true\n}\n\nasync function awsMakePrivate(bucket: string, key: string): Promise<void> {\n  logger.info('Making s3://%s/%s private', bucket, key)\n  await s3Client.putObjectAcl({ Bucket: bucket, Key: key, ACL: 'private' })\n}\n\nasync function p6S3PublicBucketObjectAcl(event: S3Event): Promise<void> {\n  const key = event.detail.requestParameters.key\n  const bucket = event.detail.requestParameters.bucketName\n\n  if (!(await awsIsPrivate(bucket, key))) {\n    await awsMakePrivate(bucket, key)\n  }\n}\n\nasync function p6S3PublicBucketAccessBlock(event: S3Event): Promise<void> {\n  const pbc = event.detail.requestParameters.PublicAccessBlockConfiguration\n  logger.info(JSON.stringify(pbc))\n\n  if (!pbc.RestrictPublicBuckets || !pbc.BlockPublicPolicy || !pbc.BlockPublicAcls || !pbc.IgnorePublicAcls) {\n    const bucket = event.detail.requestParameters.bucketName\n    logger.info('s3://%s now not private, fixing...', bucket)\n\n    const response = await s3Client.putPublicAccessBlock({\n      Bucket: bucket,\n      PublicAccessBlockConfiguration: {\n        BlockPublicAcls: true,\n        IgnorePublicAcls: true,\n        BlockPublicPolicy: true,\n        RestrictPublicBuckets: true,\n      },\n    })\n\n    logger.info(JSON.stringify(response))\n  }\n}\n\nasync function p6S3PublicAccessBlock(event: S3Event): Promise<void> {\n  const pbc = event.detail.requestParameters.PublicAccessBlockConfiguration\n  logger.info(JSON.stringify(pbc))\n\n  if (!pbc.RestrictPublicBuckets || !pbc.BlockPublicPolicy || !pbc.BlockPublicAcls || !pbc.IgnorePublicAcls) {\n    const command = new GetCallerIdentityCommand({})\n    const account = await stsClient.send(command)\n    logger.info('%s', account)\n\n    const response = await s3ControlClient.send(new PutPublicAccessBlockCommand({\n      PublicAccessBlockConfiguration: {\n        BlockPublicAcls: true,\n        IgnorePublicAcls: true,\n        BlockPublicPolicy: true,\n        RestrictPublicBuckets: true,\n      },\n      AccountId: account.Account,\n    }))\n\n    logger.info(JSON.stringify(response))\n  }\n}\n\nasync function p6S3PublicFusebox(event: S3Event): Promise<boolean> {\n  if (!event.detail || !event.detail.eventName) {\n    return false\n  }\n\n  const events = [\n    'PutBucketAcl',\n    'PutObjectAcl',\n    'PutBucketPublicAccessBlock',\n    'PutAccountPublicAccessBlock',\n  ]\n\n  const eventName = event.detail.eventName\n  if (events.includes(eventName)) {\n    logger.info('======================================================================================')\n    logger.info('eventName: %s', eventName)\n  }\n\n  if (eventName === 'PutBucketAcl') {\n    await p6S3PublicBucketAcl(event)\n  }\n  else if (eventName === 'PutObjectAcl') {\n    await p6S3PublicBucketObjectAcl(event)\n  }\n  else if (eventName === 'PutBucketPublicAccessBlock') {\n    await p6S3PublicBucketAccessBlock(event)\n  }\n  else if (eventName === 'PutAccountPublicAccessBlock') {\n    await p6S3PublicAccessBlock(event)\n  }\n\n  return true\n}\n\nexport async function handler(event: S3Event, _context?: Context): Promise<boolean> {\n  await p6S3PublicFusebox(event)\n  return true\n}\n\nexport async function main(): Promise<void> {\n  logger.debug('Reading fixtures/putBucketAcl.json')\n  const data = JSON.parse(fs.readFileSync(path.resolve('fixtures/putBucketAcl.json'), 'utf8'))\n\n  logger.debug('handler()')\n  await handler(data)\n}\n\nif (require.main === module) {\n  main()\n}\n"]}

package/package.json

@@ -0,0 +1,141 @@
+{
+  "name": "p6-cdk-s3-protector",
+  "description": "AWS CDK: S3 a real-time protector",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/p6m7g8/p6-cdk-s3-protector.git"
+  },
+  "scripts": {
+    "act:build": "act --container-architecture linux/amd64 --container-daemon-socket - --container-options \"--memory 4g\" -j build",
+    "act:release": "act --container-architecture linux/amd64 --container-daemon-socket - --container-options \"--memory 4g\" -j release",
+    "build": "pnpm run ci:local && pnpm run jsii:pacmak:parallel",
+    "ci:both": "pnpm run compile && pnpm run lint && pnpm run jsii:docgen && pnpm run test",
+    "ci:gha": "pnpm run ci:both",
+    "ci:local": "pnpm run ci:both && pnpm run diagram:update",
+    "clean": "rm -rf dist/ lib/ cdk.out/ coverage/ .jsii",
+    "compile": "pnpm run tsc:compile && pnpm run jsii:compile",
+    "diagram:run": "pnpm run diagram:update && pnpm run diagram:serve",
+    "diagram:update": "pnpm run synth && pnpm run diagram:png && pnpm run diagram:cytoscape",
+    "diagram:cytoscape": "pnpm cdk-dia --target-path assets --rendering cytoscape-html -- ts-node bin/visualize.ts",
+    "diagram:png": "pnpm cdk-dia --target-path assets/diagram.png -- ts-node bin/visualize.ts",
+    "diagram:serve": "pnpm http-server assets -o",
+    "jsii:compile": "pnpm jsii compile --verbose -c tsconfig.dev.json",
+    "jsii:docgen": "pnpm jsii-docgen -v -o API.md",
+    "jsii:pacmak:dotnet": "pnpm jsii-pacmak --verbose --targets dotnet",
+    "jsii:pacmak:go": "pnpm jsii-pacmak --verbose --targets go",
+    "jsii:pacmak:java": "pnpm jsii-pacmak --verbose --targets java",
+    "jsii:pacmak:js": "pnpm jsii-pacmak --verbose --targets js",
+    "jsii:pacmak:parallel": "pnpm jsii-pacmak --verbose --parallel --targets dotnet,go,java,js,python",
+    "jsii:pacmak:py": "pnpm jsii-pacmak --verbose --targets python",
+    "lint:fix": "pnpm eslint . --fix",
+    "lint": "pnpm eslint .",
+    "nuke": "pnpm run clean && rm -rf node_modules/",
+    "publish": "pnpm run build && pnpm run publish:npm && pnpm run publish:pypi && pnpm run publish:maven && pnpm run publish:nuget && pnpm run publish:golang",
+    "publish:nuget": "pnpm publib-nuget",
+    "publish:golang": "pnpm publib-golang",
+    "publish:maven": "pnpm publib-maven",
+    "publish:npm": "pnpm publib-npm",
+    "publish:pypi": "pnpm publib-pypi",
+    "reset": "pnpm run nuke && rm -f pnpm-lock.yaml",
+    "synth": "pnpm cdk synth",
+    "test": "node --max-old-space-size=4096 --trace-deprecation ./node_modules/jest/bin/jest.js  --config jest.config.js --coverage --updateSnapshot",
+    "test:watch": "node --max-old-space-size=4096 --trace-deprecation ./node_modules/jest/bin/jest.js  --config jest.config.js --watch --coverage --updateSnapshot",
+    "tsc:compile": "pnpm tsc -p tsconfig.dev.json"
+  },
+  "author": {
+    "name": "Philip M. Gollucci",
+    "email": "pgollucci@p6m7g8.com",
+    "organization": true
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^3.8.0",
+    "@swc-node/register": "^1.10.9",
+    "@types/aws-lambda": "^8.10.145",
+    "@types/jest": "^29.5.14",
+    "@types/node": "22.8.2",
+    "@typescript-eslint/eslint-plugin": "^8.12.0",
+    "@typescript-eslint/parser": "^8.12.0",
+    "aws-cdk": "^2.164.1",
+    "aws-cdk-lib": "2.164.1",
+    "cdk-dia": "^0.11.0",
+    "constructs": "10.4.2",
+    "esbuild": "^0.24.0",
+    "eslint": "^9.13.0",
+    "eslint-plugin-import": "^2.31.0",
+    "http-server": "^14.1.1",
+    "jest": "^29.7.0",
+    "jsii": "^5.5.4",
+    "jsii-diff": "^1.104.0",
+    "jsii-docgen": "^10.5.5",
+    "jsii-pacmak": "^1.104.0",
+    "publib": "^0.2.906",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "~5.6.3"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "2.164.1",
+    "constructs": "^10.4.2"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.679.0",
+    "@aws-sdk/client-s3-control": "^3.679.0",
+    "@aws-sdk/client-sts": "^3.679.0",
+    "@types/aws-lambda": "^8.10.145",
+    "aws-cdk-lib": "2.164.1",
+    "aws-sdk": "^2.1691.0",
+    "cdk-iam-floyd": "^0.658.0",
+    "constructs": "^10.4.2",
+    "source-map-support": "^0.5.21",
+    "winston": "^3.15.0"
+  },
+  "bundledDependencies": [
+    "@aws-sdk/client-s3",
+    "@aws-sdk/client-s3-control",
+    "@aws-sdk/client-sts",
+    "@types/aws-lambda",
+    "aws-sdk",
+    "cdk-iam-floyd",
+    "source-map-support",
+    "winston"
+  ],
+  "keywords": [
+    "aws",
+    "cdk",
+    "s3",
+    "compliance",
+    "security"
+  ],
+  "main": "lib/index.js",
+  "types": "src/index.d.ts",
+  "license": "Apache-2.0",
+  "version": "0.0.1",
+  "jsii": {
+    "outdir": "dist",
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    },
+    "targets": {
+      "java": {
+        "package": "com.github.p6m7g8.p6cds3protector",
+        "maven": {
+          "groupId": "com.github.p6m7g8",
+          "artifactId": "p6-cdk-s3-protector"
+        }
+      },
+      "python": {
+        "distName": "p6-cdk-s3-protector",
+        "module": "p6_cdk_s3_protector"
+      },
+      "dotnet": {
+        "namespace": "P6m7g8.P6CDKS3Protector",
+        "packageId": "P6m7g8.P6CDKS3Protector"
+      },
+      "go": {
+        "moduleName": "github.com/p6m7g8/p6-cdk-s3-protector"
+      }
+    }
+  },
+  "packageManager": "pnpm@9.12.2+sha512.22721b3a11f81661ae1ec68ce1a7b879425a1ca5b991c975b074ac220b187ce56c708fe5db69f4c962c989452eee76c82877f4ee80f474cebd61ee13461b6228"
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './p6cdks3protector'