@prism-d1/cli 1.0.27 → 1.0.28

package/dist/assets/infra/lib/lambda/exfiltration-detector.ts

@@ -0,0 +1,100 @@
+import {
+  EventBridgeClient,
+  PutEventsCommand,
+} from '@aws-sdk/client-eventbridge';
+
+const eventBridgeClient = new EventBridgeClient({});
+const EVENT_BUS_NAME = process.env.EVENT_BUS_NAME!;
+const ALERT_THRESHOLD_READS = parseInt(process.env.ALERT_THRESHOLD_READS ?? '100', 10);
+
+interface CloudTrailDynamoDBEvent {
+  detail: {
+    eventSource: string;
+    eventName: string;
+    eventTime: string;
+    userIdentity: {
+      type: string;
+      arn: string;
+      principalId: string;
+      accountId: string;
+    };
+    requestParameters?: {
+      tableName?: string;
+    };
+    responseElements?: unknown;
+    readOnly?: boolean;
+  };
+}
+
+// Simple in-memory rate tracking (reset on cold start)
+const readCounts = new Map<string, { count: number; firstSeen: string }>();
+
+/**
+ * Monitors CloudTrail DynamoDB read events for anomalous patterns.
+ * Emits prism.d1.security events when thresholds are exceeded.
+ */
+export async function handler(event: CloudTrailDynamoDBEvent): Promise<void> {
+  const detail = event.detail;
+
+  // Only process read operations on PRISM tables
+  const tableName = detail.requestParameters?.tableName ?? '';
+  if (!tableName.startsWith('prism-')) {
+    return;
+  }
+
+  const principal = detail.userIdentity?.arn ?? 'unknown';
+  const key = `${principal}:${tableName}`;
+
+  // Track read count per principal per table
+  const existing = readCounts.get(key);
+  if (existing) {
+    existing.count += 1;
+  } else {
+    readCounts.set(key, { count: 1, firstSeen: detail.eventTime });
+  }
+
+  const current = readCounts.get(key)!;
+
+  // Check if threshold exceeded
+  if (current.count >= ALERT_THRESHOLD_READS) {
+    console.warn(
+      `Exfiltration alert: ${principal} made ${current.count} reads on ${tableName} since ${current.firstSeen}`,
+    );
+
+    const securityEvent = {
+      team_id: 'security',
+      repo: 'platform',
+      timestamp: detail.eventTime,
+      prism_level: 1,
+      metric: {
+        name: 'ExfiltrationAlertCount',
+        value: current.count,
+        unit: 'count',
+      },
+      security: {
+        alert_type: 'high_read_volume',
+        table_name: tableName,
+        principal_arn: principal,
+        read_count: current.count,
+        window_start: current.firstSeen,
+        window_end: detail.eventTime,
+      },
+    };
+
+    await eventBridgeClient.send(
+      new PutEventsCommand({
+        Entries: [
+          {
+            Source: 'prism.d1.velocity',
+            DetailType: 'prism.d1.security',
+            EventBusName: EVENT_BUS_NAME,
+            Detail: JSON.stringify(securityEvent),
+          },
+        ],
+      }),
+    );
+
+    // Reset counter after alert
+    readCounts.delete(key);
+  }
+}

package/dist/assets/infra/lib/lambda/layers/guardrail-enforcer/nodejs/guardrail-enforcer.js

@@ -0,0 +1,53 @@
+/**
+ * PRISM D1 Guardrail Enforcer — Lambda layer for Bedrock Guardrail enforcement.
+ *
+ * Usage:
+ *   const { enforceGuardrail } = require('guardrail-enforcer');
+ *   const result = await enforceGuardrail(inputText);
+ *   if (result.blocked) { ... }
+ */
+
+const { BedrockRuntimeClient, ApplyGuardrailCommand } = require('@aws-sdk/client-bedrock-runtime');
+
+const client = new BedrockRuntimeClient({});
+const GUARDRAIL_ID = process.env.GUARDRAIL_ID;
+const GUARDRAIL_VERSION = process.env.GUARDRAIL_VERSION || 'DRAFT';
+
+/**
+ * Apply the PRISM guardrail to input or output text.
+ * @param {string} text - The text to check
+ * @param {'INPUT'|'OUTPUT'} source - Whether this is input or output
+ * @returns {Promise<{blocked: boolean, action: string, outputs: any[]}>}
+ */
+async function enforceGuardrail(text, source = 'INPUT') {
+  if (!GUARDRAIL_ID) {
+    console.warn('GUARDRAIL_ID not set, skipping enforcement');
+    return { blocked: false, action: 'NONE', outputs: [] };
+  }
+
+  try {
+    const response = await client.send(
+      new ApplyGuardrailCommand({
+        guardrailIdentifier: GUARDRAIL_ID,
+        guardrailVersion: GUARDRAIL_VERSION,
+        source,
+        content: [{ text: { text } }],
+      }),
+    );
+
+    const action = response.action || 'NONE';
+    const blocked = action === 'GUARDRAIL_INTERVENED';
+
+    return {
+      blocked,
+      action,
+      outputs: response.outputs || [],
+      assessments: response.assessments || [],
+    };
+  } catch (err) {
+    console.error('Guardrail enforcement failed:', err);
+    return { blocked: false, action: 'ERROR', outputs: [], error: err.message };
+  }
+}
+
+module.exports = { enforceGuardrail };