AI Security Playbook - Technical Implementation

# Input validation with structured intent schema
from pydantic import BaseModel, validator

class UserPrompt(BaseModel):
    intent: str
    parameters: dict
    
    @validator('intent')
    def validate_intent(cls, v):
        allowed_intents = ['search', 'summarize', 'translate']
        if v not in allowed_intents:
            raise ValueError(f'Intent must be one of {allowed_intents}')
        return v

# Multi-layer safety checks
class SafetyGuardrail:
    def __init__(self):
        self.blocked_patterns = [
            r'ignore.*instructions',
            r'bypass.*safety',
            r'pretend.*you.*are',
        ]
        
    def check_input(self, text: str) -> bool:
        for pattern in self.blocked_patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return False
        return True

# Corpus signing and verification
import hashlib

class CorpusSigner:
    def __init__(self, secret_key: str):
        self.secret_key = secret_key
    
    def sign_document(self, doc: str) -> dict:
        signature = hashlib.sha256(
            f"{doc}{self.secret_key}".encode()
        ).hexdigest()
        return {"content": doc, "signature": signature}

# Least-privilege function calling
class FunctionRegistry:
    def __init__(self):
        self.functions = {}
        self.permissions = {}
    
    def register(self, name: str, func: callable, role: str):
        self.functions[name] = func
        self.permissions[name] = role
    
    def call(self, name: str, user_role: str, **kwargs):
        if user_role != self.permissions[name]:
            raise PermissionError(f"Role {user_role} cannot call {name}")
        return self.functions[name](**kwargs)