Postmortem: GPT-5 Generated Insecure Code in 20% of PRs – Our Mitigation Strategy

import os
import re
import requests
from typing import List, Dict, Optional
from dataclasses import dataclass

# Dataclass to store PR vulnerability scan results
@dataclass
class PRScanResult:
    pr_number: int
    repo_name: str
    is_gpt5_generated: bool
    has_critical_vuln: bool
    hardcoded_secrets: List[str]
    missing_input_validation: List[str]
    scan_error: Optional[str] = None

class GPT5PRAuditor:
    """Audits GitHub PRs for GPT-5 generated code and security vulnerabilities."""

    def __init__(self, github_token: str, org_name: str):
        self.github_token = github_token
        self.org_name = org_name
        self.headers = {
            "Authorization": f"token {github_token}",
            "Accept": "application/vnd.github.v3+json"
        }
        # Regex to detect GPT-5 generated code blocks (our team's standard marker)
        self.gpt5_marker_pattern = re.compile(r'#\s*GPT-5-GENERATED\s+v\d+\.\d+\.\d+')
        # Common hardcoded secret patterns (AWS, Stripe, DB creds)
        self.secret_patterns = [
            re.compile(r'AKIA[0-9A-Z]{16}'),  # AWS Access Key
            re.compile(r'sk_live_[0-9a-zA-Z]{24}'),  # Stripe Live Key
            re.compile(r'postgres://[^:]+:[^@]+@[^/]+/[^?]+')  # DB Connection String
        ]
        # Input validation anti-patterns (missing checks for user input)
        self.input_validation_patterns = [
            re.compile(r'request\.args\.get\([^)]+\)(?!.*validate)'),  # Flask missing validation
            re.compile(r'req\.body\.([^)]+)(?!.*joi\.validate)')  # Express missing Joi validation
        ]

    def fetch_org_prs(self, state: str = "merged", per_page: int = 100) -> List[Dict]:
        """Fetch all merged PRs for the organization."""
        prs = []
        page = 1
        while True:
            try:
                resp = requests.get(
                    f"https://api.github.com/orgs/{self.org_name}/pulls",
                    headers=self.headers,
                    params={"state": state, "per_page": per_page, "page": page}
                )
                resp.raise_for_status()
                batch = resp.json()
                if not batch:
                    break
                prs.extend(batch)
                page += 1
            except requests.exceptions.RequestException as e:
                print(f"Failed to fetch PRs page {page}: {e}")
                break
        return prs

    def check_gpt5_generated(self, pr_files: List[Dict]) -> bool:
        """Check if any file in the PR contains GPT-5 generated code markers."""
        for file in pr_files:
            if file["filename"].endswith((".py", ".ts", ".js", ".go")):
                # Fetch file content (truncated to 10k lines for performance)
                try:
                    content_resp = requests.get(file["raw_url"], headers=self.headers)
                    content_resp.raise_for_status()
                    content = content_resp.text
                    if self.gpt5_marker_pattern.search(content):
                        return True
                except requests.exceptions.RequestException:
                    continue
        return False

    def scan_pr_for_vulns(self, pr: Dict) -> PRScanResult:
        """Full vulnerability scan for a single PR."""
        pr_number = pr["number"]
        repo_name = pr["base"]["repo"]["full_name"]
        result = PRScanResult(
            pr_number=pr_number,
            repo_name=repo_name,
            is_gpt5_generated=False,
            has_critical_vuln=False,
            hardcoded_secrets=[],
            missing_input_validation=[]
        )

        try:
            # Fetch PR files
            files_resp = requests.get(pr["url"] + "/files", headers=self.headers)
            files_resp.raise_for_status()
            pr_files = files_resp.json()

            # Check if GPT-5 generated
            result.is_gpt5_generated = self.check_gpt5_generated(pr_files)
            if not result.is_gpt5_generated:
                return result  # Skip non-GPT-5 PRs

            # Scan all files for secrets and missing validation
            for file in pr_files:
                if not file["filename"].endswith((".py", ".ts", ".js", ".go")):
                    continue
                try:
                    content_resp = requests.get(file["raw_url"], headers=self.headers)
                    content_resp.raise_for_status()
                    content = content_resp.text

                    # Check for hardcoded secrets
                    for pattern in self.secret_patterns:
                        matches = pattern.findall(content)
                        if matches:
                            result.hardcoded_secrets.extend(matches)
                            result.has_critical_vuln = True

                    # Check for missing input validation
                    for pattern in self.input_validation_patterns:
                        matches = pattern.findall(content)
                        if matches:
                            result.missing_input_validation.append(f"{file['filename']}: {matches}")
                            result.has_critical_vuln = True
                except requests.exceptions.RequestException as e:
                    result.scan_error = f"Failed to scan {file['filename']}: {e}"
        except requests.exceptions.RequestException as e:
            result.scan_error = f"Failed to fetch PR {pr_number} details: {e}"

        return result

if __name__ == "__main__":
    # Load config from env vars
    github_token = os.getenv("GITHUB_AUDIT_TOKEN")
    org_name = os.getenv("GITHUB_ORG_NAME", "our-prod-org")
    if not github_token:
        raise ValueError("GITHUB_AUDIT_TOKEN environment variable is required")

    auditor = GPT5PRAuditor(github_token, org_name)
    print(f"Fetching merged PRs for org {org_name}...")
    merged_prs = auditor.fetch_org_prs()
    print(f"Found {len(merged_prs)} merged PRs. Scanning for GPT-5 code...")

    gpt5_prs = []
    for pr in merged_prs:
        scan_result = auditor.scan_pr_for_vulns(pr)
        if scan_result.is_gpt5_generated:
            gpt5_prs.append(scan_result)

    print(f"Scanned {len(gpt5_prs)} GPT-5 generated PRs.")
    vulnerable_prs = [r for r in gpt5_prs if r.has_critical_vuln]
    print(f"Vulnerable GPT-5 PRs: {len(vulnerable_prs)} ({len(vulnerable_prs)/len(gpt5_prs)*100:.1f}%)")

name: AI Code Security Gate
on:
  pull_request:
    types: [opened, synchronize, reopened]
  workflow_dispatch:

env:
  GPT5_MARKER_PATTERN: '# GPT-5-GENERATED v'
  SECRET_SCAN_TOOL: https://github.com/trufflesecurity/trufflehog
  INPUT_VALIDATION_SCHEMA: .github/input-validation-rules.json

jobs:
  detect-ai-code:
    runs-on: ubuntu-latest
    outputs:
      is-gpt5: ${{ steps.check-marker.outputs.is-gpt5 }}
    steps:
      - name: Checkout PR code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Fetch full history to diff against base

      - name: Check for GPT-5 generated code markers
        id: check-marker
        run: |
          # Search all changed files for GPT-5 markers
          CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD)
          IS_GPT5=false
          for file in $CHANGED_FILES; do
            if [[ "$file" =~ \.(py|ts|js|go)$ ]]; then
              if grep -qE "$GPT5_MARKER_PATTERN" "$file"; then
                IS_GPT5=true
                echo "Detected GPT-5 generated code in $file"
                break
              fi
            fi
          done
          echo "is-gpt5=$IS_GPT5" >> $GITHUB_OUTPUT
        continue-on-error: false  # Fail if grep errors out

      - name: Log detection result
        run: |
          if [[ "${{ steps.check-marker.outputs.is-gpt5 }}" == "true" ]]; then
            echo "::notice::GPT-5 generated code detected. Enforcing strict security gates."
          else
            echo "::notice::No GPT-5 code detected. Using standard security gates."
          fi

  scan-secrets:
    runs-on: ubuntu-latest
    needs: detect-ai-code
    if: needs.detect-ai-code.outputs.is-gpt5 == 'true'
    steps:
      - name: Checkout PR code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install TruffleHog
        run: |
          curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin
          trufflehog --version

      - name: Run secret scan on changed files
        id: secret-scan
        run: |
          CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD)
          SCAN_OUTPUT=$(trufflehog git file://. --since-commit origin/${{ github.base_ref }} --only-verified --fail)
          if [ $? -eq 0 ]; then
            echo "secret-found=false" >> $GITHUB_OUTPUT
          else
            echo "secret-found=true" >> $GITHUB_OUTPUT
            echo "::error::Hardcoded secrets detected in GPT-5 generated code. Blocking PR."
            echo "$SCAN_OUTPUT"
          fi
        continue-on-error: true  # We handle failure manually

      - name: Block PR if secrets found
        if: steps.secret-scan.outputs.secret-found == 'true'
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.pulls.createReview({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.issue.number,
              event: "REQUEST_CHANGES",
              body: "## 🚨 Security Gate Failed: Hardcoded Secrets Detected\nTruffleHog (https://github.com/trufflesecurity/trufflehog) found verified secrets in GPT-5 generated code. Remove all hardcoded credentials and use environment variables or secret managers."
            })
            core.setFailed("Hardcoded secrets detected in AI-generated code")

  validate-inputs:
    runs-on: ubuntu-latest
    needs: detect-ai-code
    if: needs.detect-ai-code.outputs.is-gpt5 == 'true'
    steps:
      - name: Checkout PR code
        uses: actions/checkout@v4

      - name: Setup Node.js for validation tool
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Install input validation tool
        run: npm install -g @our-org/ai-input-validator@1.2.3

      - name: Run input validation scan
        id: input-scan
        run: |
          CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD)
          VALIDATION_OUTPUT=$(ai-input-validator scan --files "$CHANGED_FILES" --schema $INPUT_VALIDATION_SCHEMA --json)
          if [ $? -eq 0 ]; then
            echo "validation-failed=false" >> $GITHUB_OUTPUT
          else
            echo "validation-failed=true" >> $GITHUB_OUTPUT
            echo "::error::Missing input validation in GPT-5 generated code. Blocking PR."
            echo "$VALIDATION_OUTPUT"
          fi
        continue-on-error: true

      - name: Block PR if validation fails
        if: steps.input-scan.outputs.validation-failed == 'true'
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.pulls.createReview({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.issue.number,
              event: "REQUEST_CHANGES",
              body: "## 🚨 Security Gate Failed: Missing Input Validation\nOur AI input validator (https://github.com/our-org/ai-input-validator) detected unvalidated user input in GPT-5 generated code. Add input validation per the schema defined in $INPUT_VALIDATION_SCHEMA."
            })
            core.setFailed("Missing input validation in AI-generated code")

  standard-gates:
    runs-on: ubuntu-latest
    needs: detect-ai-code
    if: needs.detect-ai-code.outputs.is-gpt5 != 'true'
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Run standard lint and tests
        run: |
          echo "Running standard security gates for non-AI code"
          # Add standard steps here

import { z } from "https://github.com/colinhacks/zod"; // Zod v3.23.4
import { readFileSync } from "fs";
import { resolve } from "path";

// Schema for validating GPT-5 generated code metadata
const GPT5CodeMetadataSchema = z.object({
  generator: z.literal("GPT-5"),
  version: z.string().regex(/^\d+\.\d+\.\d+$/),
  promptHash: z.string().length(64), // SHA-256 hash of the prompt used
  timestamp: z.number().int().positive(),
  author: z.string().email()
});

// Schema for validating user input in API endpoints (to check AI-generated code)
const UserInputSchema = z.object({
  email: z.string().email().max(254),
  userId: z.string().uuid(),
  requestBody: z.record(z.unknown()).optional()
});

// Interface for AI-generated code scan result
interface AICodeScanResult {
  filePath: string;
  isValid: boolean;
  errors: string[];
  metadata: GPT5CodeMetadataSchema | null;
  hasInputValidation: boolean;
}

class AIInputValidator {
  private validationRules: Record;
  private gpt5Marker: RegExp;

  constructor() {
    // Load validation rules from config file
    try {
      const rulesPath = resolve(process.cwd(), ".github/input-validation-rules.json");
      const rules = JSON.parse(readFileSync(rulesPath, "utf-8"));
      this.validationRules = rules;
    } catch (err) {
      throw new Error(`Failed to load validation rules: ${err instanceof Error ? err.message : String(err)}`);
    }

    // Marker to detect GPT-5 generated code
    this.gpt5Marker = /#\s*GPT-5-GENERATED\s+v\d+\.\d+\.\d+/;
  }

  /**
   * Scans a single file for GPT-5 generated code and validates input handling.
   * @param filePath - Absolute path to the file to scan
   * @returns AICodeScanResult with validation details
   */
  async scanFile(filePath: string): Promise {
    const result: AICodeScanResult = {
      filePath,
      isValid: true,
      errors: [],
      metadata: null,
      hasInputValidation: false
    };

    try {
      // Read file content
      const content = readFileSync(filePath, "utf-8");
      const lines = content.split("\n");

      // Check for GPT-5 marker and extract metadata
      const markerLine = lines.find(line => this.gpt5Marker.test(line));
      if (!markerLine) {
        result.isValid = false;
        result.errors.push("No GPT-5 generated code marker found");
        return result;
      }

      // Extract metadata from marker (simplified parsing for example)
      const metadataMatch = markerLine.match(/#\s*GPT-5-GENERATED\s+v(\d+\.\d+\.\d+)\s+hash:([a-f0-9]{64})\s+author:([^\s]+)/);
      if (!metadataMatch) {
        result.isValid = false;
        result.errors.push("Invalid GPT-5 metadata format");
        return result;
      }

      // Validate metadata against schema
      try {
        result.metadata = GPT5CodeMetadataSchema.parse({
          generator: "GPT-5",
          version: metadataMatch[1],
          promptHash: metadataMatch[2],
          timestamp: Date.now(), // Simplified for example
          author: metadataMatch[3]
        });
      } catch (err) {
        result.isValid = false;
        result.errors.push(`Invalid GPT-5 metadata: ${err instanceof Error ? err.message : String(err)}`);
        return result;
      }

      // Check for input validation patterns (simplified check for Zod usage)
      const hasZodValidation = lines.some(line => line.includes("z.object") || line.includes("z.string()"));
      const hasInputCheck = lines.some(line => line.includes("UserInputSchema.parse") || line.includes("validateInput"));

      if (!hasZodValidation || !hasInputCheck) {
        result.isValid = false;
        result.errors.push("Missing input validation: Use Zod schemas to validate all user input per https://github.com/colinhacks/zod");
        result.hasInputValidation = false;
      } else {
        result.hasInputValidation = true;
      }

      // Check for error handling (try-catch blocks)
      const hasErrorHandling = lines.some(line => line.includes("try {") && lines.some(l => l.includes("catch")));
      if (!hasErrorHandling) {
        result.isValid = false;
        result.errors.push("Missing error handling: All AI-generated code must include try-catch blocks for async operations");
      }

    } catch (err) {
      result.isValid = false;
      result.errors.push(`Failed to scan file: ${err instanceof Error ? err.message : String(err)}`);
    }

    return result;
  }

  /**
   * Scans all files in a list and returns aggregated results.
   * @param filePaths - List of file paths to scan
   * @returns Array of AICodeScanResult
   */
  async scanFiles(filePaths: string[]): Promise {
    const results: AICodeScanResult[] = [];
    for (const filePath of filePaths) {
      // Skip non-code files
      if (!filePath.endswith(".ts") && !filePath.endswith(".js") && !filePath.endswith(".py")) {
        continue;
      }
      const result = await this.scanFile(filePath);
      results.push(result);
    }
    return results;
  }
}

// Example usage
async function main() {
  try {
    const validator = new AIInputValidator();
    const filesToScan = process.argv.slice(2);
    if (filesToScan.length === 0) {
      throw new Error("No files provided to scan. Usage: ts-node validator.ts   ...");
    }
    const results = await validator.scanFiles(filesToScan);
    const invalidFiles = results.filter(r => !r.isValid);
    if (invalidFiles.length > 0) {
      console.error(`::error::${invalidFiles.length} invalid AI-generated files found:`);
      invalidFiles.forEach(r => {
        console.error(`- ${r.filePath}: ${r.errors.join(", ")}`);
      });
      process.exit(1);
    } else {
      console.log("::notice::All AI-generated files passed validation.");
      process.exit(0);
    }
  } catch (err) {
    console.error(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
    process.exit(1);
  }
}

if (import.meta.url === `file://${process.argv[1]}`) {
  main();
}

# GPT-5-GENERATED v2.1.4 hash:a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2 author:dev@our-org.com

trufflehog git file://. --since-commit origin/main --only-verified --fail

const LoginInputSchema = z.object({
  email: z.string().email().max(254),
  password: z.string().min(12).max(128),
  mfaToken: z.string().length(6).optional()
});
const input = LoginInputSchema.parse(req.body); // Throws if invalid