影像隱寫注入

from dataclasses import dataclass
from typing import Optional
import json
 
@dataclass
class SecurityAnalysis:
    """Framework for analyzing security properties of LLM systems."""
    target: str
    model: str
    defenses: list
    vulnerabilities: list
 
    def assess_risk(self, attack_type: str) -> dict:
        """Assess risk for a specific attack type."""
        # Check if any defense addresses this attack type
        relevant_defenses = [
            d for d in self.defenses
            if attack_type in d.get("covers", [])
        ]
 
        # Risk factors
        likelihood = "high" if not relevant_defenses else "medium"
        impact = self._assess_impact(attack_type)
 
        return {
            "attack_type": attack_type,
            "likelihood": likelihood,
            "impact": impact,
            "defenses": len(relevant_defenses),
            "risk_level": self._calculate_risk(likelihood, impact),
        }
 
    def _assess_impact(self, attack_type: str) -> str:
        """Assess the potential impact of an attack type."""
        high_impact = ["data_exfiltration", "unauthorized_actions", "privilege_escalation"]
        return "high" if attack_type in high_impact else "medium"
 
    def _calculate_risk(self, likelihood: str, impact: str) -> str:
        """Calculate overall risk from likelihood and impact."""
        risk_matrix = {
            ("high", "high"): "critical",
            ("high", "medium"): "high",
            ("medium", "high"): "high",
            ("medium", "medium"): "medium",
        }
        return risk_matrix.get((likelihood, impact), "medium")
 
    def generate_report(self) -> str:
        """Generate a risk assessment report."""
        attacks = ["prompt_injection", "data_exfiltration", "unauthorized_actions"]
        assessments = [self.assess_risk(a) for a in attacks]
 
        report = f"# Risk Assessment: {self.target}\n\n"
        for assessment in assessments:
            report += (
                f"## {assessment['attack_type']}\n"
                f"- Risk: {assessment['risk_level']}\n"
                f"- Likelihood: {assessment['likelihood']}\n"
                f"- Impact: {assessment['impact']}\n"
                f"- Active defenses: {assessment['defenses']}\n\n"
            )
        return report

class PracticalFramework:
    """Practical framework for applying the concepts in this article."""
 
    def __init__(self, target_config: dict):
        self.config = target_config
        self.findings = []
        self.tested_vectors = set()
 
    def test_vector(self, vector: str, payload: str) -> dict:
        """Test a specific attack vector against the target."""
        self.tested_vectors.add(vector)
 
        # Send the payload
        response = self._send(payload)
 
        # Evaluate the result
        finding = {
            "vector": vector,
            "payload_length": len(payload),
            "response_length": len(response),
            "success": self._evaluate(response),
            "defense_triggered": self._detect_defense(response),
        }
 
        if finding["success"]:
            self.findings.append(finding)
 
        return finding
 
    def coverage_report(self) -> dict:
        """Report on testing coverage."""
        all_vectors = {
            "direct_injection", "indirect_injection", "function_abuse",
            "memory_manipulation", "context_manipulation",
        }
        return {
            "tested": list(self.tested_vectors),
            "untested": list(all_vectors - self.tested_vectors),
            "coverage": f"{len(self.tested_vectors)/len(all_vectors)*100:.0f}%",
            "findings": len(self.findings),
        }
 
    def _send(self, payload: str) -> str:
        """Send payload to target (implementation varies by target)."""
        pass
 
    def _evaluate(self, response: str) -> bool:
        """Evaluate whether the attack was successful."""
        pass
 
    def _detect_defense(self, response: str) -> Optional[str]:
        """Detect which defense mechanism was triggered."""
        pass

from dataclasses import dataclass
from typing import Optional
import time
 
@dataclass
class SecurityGateway:
    """Gateway pattern for securing LLM application access."""
 
    input_classifier: object  # ML-based input classifier
    output_filter: object     # Output content filter
    rate_limiter: object      # Rate limiting service
    audit_logger: object      # Audit trail logger
 
    def process_request(self, user_id: str, message: str, session_id: str) -> dict:
        """Process a request through all security layers."""
        request_id = self._generate_request_id()
 
        # Layer 1: Rate limiting
        if not self.rate_limiter.allow(user_id):
            self.audit_logger.log(request_id, "rate_limited", user_id)
            return {"error": "Rate limit exceeded", "retry_after": 60}
 
        # Layer 2: Input classification
        classification = self.input_classifier.classify(message)
        if classification.is_adversarial:
            self.audit_logger.log(
                request_id, "input_blocked",
                user_id, classification.category
            )
            return {"error": "Request could not be processed"}
 
        # Layer 3: LLM processing
        response = self._call_llm(message, session_id)
 
        # Layer 4: Output filtering
        filtered = self.output_filter.filter(response)
        if filtered.was_modified:
            self.audit_logger.log(
                request_id, "output_filtered",
                user_id, filtered.reason
            )
 
        # Layer 5: Audit logging
        self.audit_logger.log(
            request_id, "completed",
            user_id, len(message), len(filtered.content)
        )
 
        return {"response": filtered.content}
 
    def _generate_request_id(self) -> str:
        import uuid
        return str(uuid.uuid4())
 
    def _call_llm(self, message: str, session_id: str) -> str:
        # LLM API call implementation
        pass

from dataclasses import dataclass
from collections import defaultdict
import time
 
@dataclass
class SecurityMetrics:
    """Track security-relevant metrics for LLM applications."""
 
    # Counters
    total_requests: int = 0
    blocked_requests: int = 0
    filtered_outputs: int = 0
    anomalous_sessions: int = 0
 
    # Rate tracking
    _request_times: list = None
    _block_times: list = None
 
    def __post_init__(self):
        self._request_times = []
        self._block_times = []
 
    def record_request(self, was_blocked: bool = False, was_filtered: bool = False):
        """Record a request and its disposition."""
        now = time.time()
        self.total_requests += 1
        self._request_times.append(now)
 
        if was_blocked:
            self.blocked_requests += 1
            self._block_times.append(now)
 
        if was_filtered:
            self.filtered_outputs += 1
 
    def get_block_rate(self, window_seconds: int = 300) -> float:
        """Calculate the block rate over a time window."""
        now = time.time()
        cutoff = now - window_seconds
        recent_requests = sum(1 for t in self._request_times if t > cutoff)
        recent_blocks = sum(1 for t in self._block_times if t > cutoff)
        if recent_requests == 0:
            return 0.0
        return recent_blocks / recent_requests
 
    def should_alert(self) -> bool:
        """Determine if current metrics warrant an alert."""
        block_rate = self.get_block_rate()
        # Alert if block rate exceeds threshold
        if block_rate > 0.3:  # >30% of requests blocked in last 5 min
            return True
        return False

class OrganizationalIntegration:
    """Framework for integrating AI security with organizational security programs."""
 
    def __init__(self, org_config: dict):
        self.config = org_config
        self.gaps = []
 
    def assess_maturity(self) -> dict:
        """Assess the organization's AI security maturity."""
        domains = {
            "governance": self._check_governance(),
            "technical_controls": self._check_technical(),
            "monitoring": self._check_monitoring(),
            "incident_response": self._check_ir(),
            "training": self._check_training(),
        }
        overall = sum(d["score"] for d in domains.values()) / len(domains)
        return {"domains": domains, "overall_maturity": round(overall, 1)}
 
    def _check_governance(self) -> dict:
        has_policy = self.config.get("ai_security_policy", False)
        has_framework = self.config.get("risk_framework", False)
        score = (int(has_policy) + int(has_framework)) * 2.5
        return {"score": score, "max": 5.0}
 
    def _check_technical(self) -> dict:
        controls = ["input_classification", "output_filtering", "rate_limiting", "sandboxing"]
        active = sum(1 for c in controls if self.config.get(c, False))
        return {"score": active * 1.25, "max": 5.0}
 
    def _check_monitoring(self) -> dict:
        has_monitoring = self.config.get("ai_monitoring", False)
        has_alerting = self.config.get("ai_alerting", False)
        score = (int(has_monitoring) + int(has_alerting)) * 2.5
        return {"score": score, "max": 5.0}
 
    def _check_ir(self) -> dict:
        has_playbook = self.config.get("ai_ir_playbook", False)
        return {"score": 5.0 if has_playbook else 0.0, "max": 5.0}
 
    def _check_training(self) -> dict:
        has_training = self.config.get("ai_security_training", False)
        return {"score": 5.0 if has_training else 0.0, "max": 5.0}