Defesa Contra Injeção de Prompt

Mitigue injeções de prompt diretas e indiretas em aplicativos de chat, fluxos de trabalho de agentes e pipelines RAG.

Quando Usar Esta Habilidade

Use esta habilidade quando:

• Estiver construindo ou protegendo qualquer aplicativo baseado em LLM
• Estiver projetando pipelines RAG que ingerem documentos não confiáveis
• Estiver implementando fluxos de trabalho de agentes com capacidades de chamada de ferramentas
• Estiver respondendo a uma vulnerabilidade de injeção de prompt relatada
• Estiver realizando revisões de segurança de produtos integrados com IA

Pré-requisitos

• Python 3.10+ com re, hashlib, json bibliotecas padrão
• Acesso ao código-fonte ou configuração do aplicativo LLM
• Compreensão da arquitetura de prompt do aplicativo (limites de sistema/usuário/ferramenta)
• Ambiente de teste com entradas de usuário e documentos representativos

Superfície de Ataque

• Entrada do usuário tentando substituir instruções do sistema
• Documentos/páginas da web não confiáveis no contexto de recuperação
• Saída de ferramenta que contrabandeia instruções maliciosas
• Vazamento entre inquilinos (cross-tenant) através de janelas de contexto compartilhadas
• Injeção de Markdown ou HTML em saídas renderizadas
• Ataques de múltiplos turnos que mudam gradualmente o contexto

Padrão de Defesa em Profundidade

1. Aplicação de hierarquia de instruções: sistema > desenvolvedor > usuário > saída da ferramenta.
2. Segregação de contexto: isolar texto não confiável de instruções de controle.
3. Permissão de ferramentas: lista explícita de permissões por tarefa e inquilino.
4. Verificações de política de saída: validar esquema, redigir segredos, bloquear ações inseguras.
5. Aprovação humana: necessária para operações de alto impacto.

Funções de Sanitização de Entrada

"""prompt_sanitizer.py - Input sanitization for LLM applications."""

import re
import hashlib
import json
from typing import Optional

# Patterns that commonly appear in injection attempts
INJECTION_PATTERNS = [
    r"(?i)ignore\s+(all\s+)?previous\s+instructions",
    r"(?i)disregard\s+(all\s+)?(above|previous|prior)",
    r"(?i)you\s+are\s+now\s+(DAN|evil|unrestricted|jailbroken)",
    r"(?i)system\s*:\s*override",
    r"(?i)SYSTEM\s+OVERRIDE",
    r"(?i)new\s+instructions?\s*:",
    r"(?i)forget\s+(everything|all|your\s+instructions)",
    r"(?i)act\s+as\s+if\s+you\s+have\s+no\s+(restrictions|limits|rules)",
    r"(?i)pretend\s+(you\s+are|to\s+be)\s+.*(unrestricted|evil|without)",
    r"(?i)BEGIN\s+(TRUSTED|SYSTEM|ADMIN)\s+(CONTEXT|PROMPT|OVERRIDE)",
    r"(?i)```system",
    r"(?i)\[INST\]",
    r"(?i)<\|im_start\|>system",
]

COMPILED_PATTERNS = [re.compile(p) for p in INJECTION_PATTERNS]


def detect_injection(text: str) -> dict:
    """Verifica o texto em busca de padrões conhecidos de injeção de prompt.

    Retorna:
        dict com booleano 'detected', lista 'patterns' de descrições de padrões correspondentes,
        e 'risk_score' float entre 0.0 e 1.0.
    """
    matches = []
    for i, pattern in enumerate(COMPILED_PATTERNS):
        if pattern.search(text):
            matches.append(INJECTION_PATTERNS[i])

    risk_score = min(len(matches) / 3.0, 1.0)
    return {
        "detected": len(matches) > 0,
        "patterns": matches,
        "risk_score": risk_score,
        "input_length": len(text),
    }


def sanitize_input(text: str, max_length: int = 4096) -> str:
    """Sanitiza a entrada do usuário antes de passá-la para o LLM.

    - Trunca para max_length
    - Remove bytes nulos e caracteres de controle
    - Remove truques de homóglifos Unicode
    - Normaliza espaços em branco
    """
    # Trunca
    text = text[:max_length]

    # Remove bytes nulos e a maioria dos caracteres de controle (mantém novas linhas e tabulações)
    text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)

    # Normaliza confusões Unicode (conjunto básico)
    confusable_map = {
        '\u200b': '',   # espaço de largura zero
        '\u200c': '',   # não-juntor de largura zero
        '\u200d': '',   # juntor de largura zero
        '\u2060': '',   # juntor de palavra
        '\ufeff': '',   # BOM
        '\u00a0': ' ',  # espaço inquebrável
    }
    for char, replacement in confusable_map.items():
        text = text.replace(char, replacement)

    # Colapsa espaços em branco excessivos
    text = re.sub(r'\n{4,}', '\n\n\n', text)
    text = re.sub(r' {10,}', '     ', text)

    return text.strip()


def sanitize_retrieved_context(documents: list[str], source_label: str = "RETRIEVED") -> str:
    """Envolve documentos recuperados com marcadores de limite claros.

    Isso torna mais difícil para instruções injetadas em documentos
    serem interpretadas como mensagens do sistema ou do usuário.
    """
    sanitized_parts = []
    for i, doc in enumerate(documents):
        doc_hash = hashlib.sha256(doc.encode()).hexdigest()[:8]

…