AI 漏洞賞金計畫（社群挑戰）

# Demonstration of the core concept
from openai import OpenAI
 
client = OpenAI()
 
def demonstrate_concept(system_prompt: str, user_input: str) -> str:
    """Demonstrate the fundamental behavior pattern."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_input},
        ],
        temperature=0.0,
    )
    return response.choices[0].message.content
 
# Baseline behavior
baseline = demonstrate_concept(
    system_prompt="You are a helpful assistant that only discusses cooking.",
    user_input="What is the capital of France?",
)
print(f"Baseline: {baseline}")

import json
from typing import Optional
 
class TechniqueFramework:
    """Framework for implementing and testing the described technique."""
 
    def __init__(self, target_config: dict):
        self.config = target_config
        self.results = []
 
    def prepare_payload(self, objective: str, constraints: dict) -> str:
        """Prepare the attack payload based on the objective and target constraints."""
        payload = self._base_payload(objective)
 
        if constraints.get("input_classifier"):
            payload = self._apply_obfuscation(payload)
 
        if constraints.get("output_filter"):
            payload = self._add_extraction_channel(payload)
 
        return payload
 
    def execute(self, payload: str) -> dict:
        """Execute the technique and collect results."""
        response = self._send_to_target(payload)
        success = self._evaluate_response(response)
 
        result = {
            "payload_hash": hash(payload),
            "success": success,
            "response_length": len(str(response)),
        }
        self.results.append(result)
        return result
 
    def report(self) -> dict:
        """Generate a summary report of all execution results."""
        total = len(self.results)
        successes = sum(1 for r in self.results if r["success"])
        return {
            "total_attempts": total,
            "successes": successes,
            "success_rate": successes / total if total > 0 else 0,
        }

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."""
 
    total_requests: int = 0
    blocked_requests: int = 0
    filtered_outputs: int = 0
    anomalous_sessions: int = 0
 
    _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()
        if block_rate > 0.3:
            return True
        return False