AI Hacking
Recursos de segurança de IA

Desenvolvimento seguro de IA

Guia completo do desenvolvedor para criar aplicativos de IA seguros – desde a validação de entrada até a implantação

Updated: November 2026

Princípios de segurança

1. Defesa em profundidade

Implemente múltiplas camadas de controles de segurança. Nenhum controle único deve ser considerado exclusivamente.

2. Privilégio mínimo

Conceder permissões mínimas necessárias para usuários, APIs e componentes de IA.

3. Fail Secure

Quando ocorrem erros, o padrão é usar estados seguros em vez de estados permissivos.

4. Zero Trust

Nunca confie, sempre verifique. Valide em todos os limites, incluindo sistemas internos.

Validação de entrada

Todas as entradas do usuário devem ser validadas e higienizadas antes do processamento. Esta é a sua primeira linha de defesa contra injeção de prompt e outros ataques.

Classe de validação de entrada

```python
import re
from typing import Optional, List

class InputValidator:
    # Known injection patterns
    INJECTION_PATTERNS = [
        r"ignore\s+(previous|prior|all)\s+(instructions|rules)",
        r"(forget|disregard)\s+(your|all)\s+(instructions|rules)",
        r"you\s+are\s+(now|still)\s+(dan|do\s+anything)",
        r"system\s+prompt:",
        r"{{.*}}",
        r"\[INST\]|\[/INST\]|<\|end\|>",
    ]
    
    # Encoding patterns
    ENCODING_PATTERNS = [
        r"base64:",  # Base64 prefix
        r"\\x[0-9a-fA-F]{2}",  # Hex encoding
        r"%[0-9a-fA-F]{2}",  # URL encoding
    ]
    
    def validate(self, user_input: str) -> dict:
        """Validate user input for potential attacks."""
        issues = []
        
        # Length check
        if len(user_input) > 10000:
            issues.append("Input exceeds maximum length")
        
        # Check for injection patterns
        for pattern in self.INJECTION_PATTERNS:
            if re.search(pattern, user_input, re.IGNORECASE):
                issues.append(f"Suspicious pattern detected: {pattern}")
        
        # Check for encoding attempts
        for pattern in self.ENCODED_PATTERNS:
            if re.search(pattern, user_input):
                issues.append(f"Encoded content detected")
        
        # Check for high entropy (possible encoding)
        unique_chars = len(set(user_input))
        if len(user_input) > 50 and unique_chars / len(user_input) < 0.3:
            issues.append("High entropy detected - possible encoding")
        
        return {
            "valid": len(issues) == 0,
            "issues": issues,
            "sanitized": self._sanitize(user_input)
        }
    
    def _sanitize(self, user_input: str) -> str:
        """Basic sanitization."""
        # Remove control characters
        sanitized = re.sub(r'[\x00-\x1F\x7F]', '', user_input)
        return sanitized.strip()
```

Lista de verificação de validação

  • Validar no limite do aplicativo
  • Verificar comprimento de entrada
  • Correspondência de padrão para injeção
  • Detectar tentativas de codificação
  • Validação de tipo
  • Higienização antes do processamento
  • Falhas de validação de log
  • Limitação de taxa

Manipulação de saída

As saídas do LLM devem ser validadas e higienizadas antes de serem apresentadas aos usuários ou passadas para outros sistemas.

Filtragem de conteúdo

  • Verifique a exposição de dados confidenciais
  • Verifique se nenhum prompt do sistema vazou
  • Validar formato de saída
  • Verificar conteúdo injetado

Detecção de PII

  • Verificar informações pessoais
  • Mascarar ou ocultar dados confidenciais
  • Registrar tentativas de exposição de PII
  • Notificação do usuário quando detectada

Validação de formato

  • Validar saídas JSON
  • Verificar a estrutura esperada
  • Verificar valores permitidos
  • Limpar HTML se aplicável

Exemplo de manipulador de saída

```python
import re
import json

class OutputHandler:
    PII_PATTERNS = {
        "ssn": r"\b\d{3}-\d{2}-\d{4}\b",
        "email": r"\b[\w.-]+@[\w.-]+\.\w+\b",
        "phone": r"\b\d{3}[-.]?\d{3}[-.]?\d{4}\b",
    }
    
    def process_output(self, raw_output: str) -> dict:
        """Process and validate LLM output."""
        result = {
            "original": raw_output,
            "cleaned": raw_output,
            "warnings": [],
            "blocked": False
        }
        
        # Check for system prompt leakage
        if "system prompt" in raw_output.lower():
            result["warnings"].append("System prompt reference detected")
        
        # Scan for PII
        for pii_type, pattern in self.PII_PATTERNS.items():
            matches = re.findall(pattern, raw_output)
            if matches:
                result["warnings"].append(f"{pii_type} detected in output")
                # Optionally mask
                result["cleaned"] = re.sub(pattern, "[REDACTED]", result["cleaned"])
        
        return result
```

Segurança de API

Autenticação

  • Use um gerenciamento forte de chaves de API
  • Implementar OAuth 2.0 sempre que possível
  • Validação de token JWT
  • Rotação de chaves de API

Autorização

  • Controle de acesso baseado em função (RBAC)
  • Escopo da chave de API
  • Limites de taxa por usuário
  • Isolamento de locatário

Limitação de taxa

  • Limites baseados em tokens
  • Limites baseados em solicitações
  • Controles de custos
  • Tiered throttling

Lista de verificação de segurança de API

  • Use apenas HTTPS
  • Implementar limitação de taxa
  • Validar todas as entradas
  • Higienizar todas as saídas
  • Use chaves de API, não incorporadas
  • Implementar assinatura de solicitação
  • Log API access
  • Implementar CORS corretamente

Autenticação e autorização

Autenticação do usuário

  • Políticas de senha fortes
  • Suporte MFA
  • Gerenciamento de sessão
  • Expiração de token

Autenticação de API

  • Gerenciamento de chaves de API
  • Escopos OAuth
  • Validação JWT
  • Rotação de chave

Autorização

  • Implementação RBAC
  • Verificações de permissão
  • Acesso em nível de recurso
  • Registro de auditoria

Segurança de dados

Classificação de dados

  • Identificar dados confidenciais
  • Categorizar por sensibilidade
  • Aplicar controles por categoria
  • Auditorias regulares

Criptografia

  • TLS em trânsito
  • AES em repouso
  • Gerenciamento de chaves
  • Rotação de chave

Manipulação de PII

  • Detecção
  • Minimização
  • Gerenciamento de consentimento
  • Direito de exclusão

Registro e monitoramento

O que registrar

Eventos de segurança

  • Tentativas de autenticação
  • Falhas de autorização
  • Limite de taxa excedido
  • Padrões suspeitos

Eventos específicos de IA

  • Tentativas de injeção de prompt
  • Acesso imediato ao sistema
  • Invocações de ferramentas
  • Acesso a dados via IA

Eventos operacionais

  • Chamadas de API
  • Erros e exceções
  • Métricas de desempenho
  • Rastreamento de custos

Práticas recomendadas de monitoramento

  • Alertas em tempo real para eventos de segurança
  • Painel para métricas de segurança
  • Detecção automatizada de anomalias
  • Integração com SIEM
  • Revisão regular do log
  • Políticas de retenção

Vulnerabilidades comuns

1. IDOR em recursos de IA

Referência de objeto direto inseguro quando a IA acessa recursos

Exemplo

O usuário pede à IA para "ler o arquivo X" e a IA tem acesso sem as devidas verificações de autorização.

2. SSRF via LLM

Falsificação de solicitação do lado do servidor por meio de chamadas de ferramenta de IA

Exemplo

O prompt engana a IA para fazer solicitações a serviços internos.

3. Ignorar autenticação

Autenticação fraca ou ausente para endpoints de IA

Exemplo

Endpoints da API de IA sem verificações de autenticação adequadas.

4. Exposição ao banco de dados vetorial

Banco de dados de vetores desprotegidos com incorporações sensíveis

Exemplo

BD de vetor de acesso público com dados confidenciais incorporados.

Conformidade

GDPR (EU)

  • Base legal para processamento
  • Minimização de dados
  • Direito de acesso/exclusão
  • Portabilidade de dados

CCPA (California)

  • Direito de saber
  • Direito de exclusão
  • Direito de cancelamento
  • Não discriminação

Específico de IA

  • Requisitos da Lei de IA da UE
  • Avaliações de risco de IA
  • Obrigações de transparência
  • Supervisão humana

See the full framework breakdown in our AI security standards reference, including NIST AI RMF and ISO/IEC 42001.

AH
AI Hacking Team

The AI Hacking team researches and documents AI/LLM security vulnerabilities, red teaming techniques, and defensive strategies. Our guides are based on real-world pentesting experience and continuous monitoring of the AI security landscape.

Frequently Asked Questions

What are the key principles of secure AI development?
Key principles include: defense in depth, least privilege, fail secure, input validation, output sanitization, proper authentication/authorization, and comprehensive Logging. Treat all user input as untrusted and validate at every boundary.
How do I validate input in AI applications?
Input validation for AI includes: pattern matching for injection attempts, encoding detection (Base64, URL encoding), length limits, content type validation, and sanitization before processing. Always validate at the application boundary and before any AI processing.
What are common AI application vulnerabilities?
Common vulnerabilities include: prompt injection, IDOR in AI features, SSRF via LLM requests, authentication bypass, vector database exposure, excessive agency, and improper output handling. OWASP LLM Top 10 provides a comprehensive list.
How should I handle AI API keys securely?
Never hardcode API keys. Use environment variables, secrets management services (AWS Secrets Manager, HashiCorp Vault), rotate keys regularly, scope permissions minimally, implement rate limiting, and never expose keys in client-side code.

Stay Ahead of AI Security

Get the latest AI/LLM security research, OWASP updates, and new vulnerabilities delivered straight to your inbox.