Prevent Sensitive Data
From Reaching AI Tools

# DLP Content Classification Regex Patterns
# Deploy in your proxy DLP engine or endpoint DLP agent
# Apply to HTTP POST/PUT bodies destined for AI Tools Blocklist domains

import re

dlp_classifiers = {

    # PII: Social Security Numbers (US)
    "SSN": {
        "pattern": re.compile(r'\b(?!000|666|9\d{2})\d{3}[-\s]?(?!00)\d{2}[-\s]?(?!0000)\d{4}\b'),
        "severity": "critical",
        "action": "block",
        "threshold": 1,
    },

    # PCI: Credit Card Numbers (Luhn-validated)
    "CREDIT_CARD": {
        "pattern": re.compile(r'\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})\b'),
        "severity": "critical",
        "action": "block",
        "threshold": 1,
    },

    # PHI: Medical Record Numbers (common formats)
    "MRN": {
        "pattern": re.compile(r'\b(?:MRN|Medical Record|Patient ID)[:\s#]*[A-Z0-9]{6,12}\b', re.IGNORECASE),
        "severity": "critical",
        "action": "block",
        "threshold": 1,
    },

    # Source Code: API keys, secrets, private keys
    "API_SECRET": {
        "pattern": re.compile(
            r'(?:'
            r'(?:api[_-]?key|api[_-]?secret|access[_-]?token|auth[_-]?token)'
            r'[\s]*[=:]\s*["\x27]?[A-Za-z0-9_\-]{20,}'
            r'|-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----'
            r'|ghp_[A-Za-z0-9]{36}'
            r'|sk-[A-Za-z0-9]{32,}'
            r'|AKIA[0-9A-Z]{16}'
            r')', re.IGNORECASE),
        "severity": "critical",
        "action": "block",
        "threshold": 1,
    },

    # Financial: Account numbers, routing numbers
    "FINANCIAL_ACCOUNT": {
        "pattern": re.compile(
            r'\b(?:'
            r'(?:account|acct|routing)[#:\s]*\d{8,17}'
            r'|IBAN\s?[A-Z]{2}\d{2}[\s]?[\dA-Z]{4}[\s]?(?:[\dA-Z]{4}[\s]?){2,7}[\dA-Z]{1,4}'
            r'|SWIFT\s?[A-Z]{6}[A-Z0-9]{2}(?:[A-Z0-9]{3})?'
            r')\b', re.IGNORECASE),
        "severity": "high",
        "action": "block",
        "threshold": 2,
    },

    # Legal: Privilege markers, NDA references
    "LEGAL_PRIVILEGE": {
        "pattern": re.compile(
            r'(?:'
            r'attorney[- ]client privilege'
            r'|work product doctrine'
            r'|confidential.*(?:settlement|litigation|arbitration)'
            r'|subject to nda'
            r'|do not distribute'
            r'|restricted.*internal use only'
            r')', re.IGNORECASE),
        "severity": "high",
        "action": "alert_and_block",
        "threshold": 1,
    },

    # Bulk PII: Multiple email + phone combinations (customer data)
    "BULK_PII": {
        "pattern": re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'),
        "severity": "high",
        "action": "block",
        "threshold": 5,  # Block when 5+ email addresses detected in one submission
    },
}

def scan_content(content: str, destination_domain: str, ai_domains: set) -> dict:
    """Scan outbound content for DLP violations when destined for AI tools."""
    if destination_domain not in ai_domains:
        return {"action": "allow", "reason": "destination not an AI tool"}

    violations = []
    for name, classifier in dlp_classifiers.items():
        matches = classifier["pattern"].findall(content)
        if len(matches) >= classifier["threshold"]:
            violations.append({
                "classifier": name,
                "severity": classifier["severity"],
                "action": classifier["action"],
                "match_count": len(matches),
            })

    if not violations:
        return {"action": "allow", "reason": "no sensitive data detected"}

    worst = max(violations, key=lambda v: {"critical":3,"high":2,"medium":1}[v["severity"]])
    return {
        "action": worst["action"],
        "violations": violations,
        "destination": destination_domain,
    }

#!/usr/bin/env python3
"""Load AI Tools Blocklist into DLP platform as a custom URL category.
   Supports automated daily refresh via cron or scheduled task."""

import requests
import json
from datetime import datetime

API_BASE = "https://aitoolsblocklist.com/api/v1"
API_KEY  = "your-enterprise-api-key"

def fetch_ai_domains_by_risk():
    """Fetch classified AI domains grouped by risk tier for DLP policy mapping."""
    headers = {"Authorization": f"Bearer {API_KEY}"}

    # High-risk: categories that typically process sensitive text/code
    high_risk_categories = [
        "Text Generation & Language",
        "Code & Development",
        "Data & Analytics",
        "Document & Content Processing",
    ]

    # Medium-risk: categories that accept user-provided content
    medium_risk_categories = [
        "Image & Visual",
        "Audio & Voice",
        "Video & Animation",
        "AI Agents & Automation",
    ]

    risk_tiers = {}
    for tier, categories in [("high", high_risk_categories), ("medium", medium_risk_categories)]:
        domains = []
        for cat in categories:
            resp = requests.get(
                f"{API_BASE}/domains",
                headers=headers,
                params={"category": cat, "format": "plain"}
            )
            domains.extend(resp.text.strip().split("\n"))
        risk_tiers[tier] = sorted(set(domains))

    return risk_tiers

def generate_dlp_policy(risk_tiers):
    """Generate DLP policy rules for each risk tier."""
    policies = []

    # High-risk AI tools: block all sensitive data, log everything
    policies.append({
        "name": "AI-High-Risk-Block-Sensitive",
        "url_category": "AI-Tools-High-Risk",
        "domain_count": len(risk_tiers["high"]),
        "content_types": ["SSN", "CREDIT_CARD", "API_SECRET", "MRN", "FINANCIAL_ACCOUNT", "LEGAL_PRIVILEGE", "BULK_PII"],
        "action": "block",
        "notification": ["soc_team", "user_manager"],
        "log_level": "full_content",
    })

    # Medium-risk AI tools: alert on sensitive data, block critical
    policies.append({
        "name": "AI-Medium-Risk-Alert-Sensitive",
        "url_category": "AI-Tools-Medium-Risk",
        "domain_count": len(risk_tiers["medium"]),
        "content_types": ["SSN", "CREDIT_CARD", "API_SECRET", "MRN"],
        "action": "alert_and_log",
        "notification": ["soc_team"],
        "log_level": "metadata",
    })

    print(f"DLP Policy Generation — {datetime.now().isoformat()}")
    print(f"High-risk AI domains: {len(risk_tiers['high']):,}")
    print(f"Medium-risk AI domains: {len(risk_tiers['medium']):,}")
    for p in policies:
        print(f"  Rule: {p['name']} — {p['action']} on {len(p['content_types'])} classifiers")

    return policies