AI Hacking
Risorse per la sicurezza AI

Sviluppo sicuro dell'intelligenza artificiale

Guida completa per gli sviluppatori per creare applicazioni IA sicure, dalla convalida dell'input alla distribuzione

Updated: November 2026

Principi di sicurezza

1. Difesa approfondita

Implementa più livelli di controlli di sicurezza. Non si dovrebbe fare affidamento esclusivamente su un singolo controllo.

2. Privilegio minimo

Concedi le autorizzazioni minime necessarie a utenti, API e componenti AI.

3. Fail Secure

Quando si verificano errori, imposta per impostazione predefinita stati protetti anziché permissivi.

4. Zero Trust

Non fidarti mai, verifica sempre. Convalida a ogni confine, compresi i sistemi interni.

Convalida dell'input

Tutti gli input dell'utente devono essere convalidati e disinfettati prima dell'elaborazione. Questa è la prima linea di difesa contro l'iniezione tempestiva e altri attacchi.

Classe di convalida dell'input

```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()
```

Elenco di controllo della convalida

  • Convalida al limite dell'applicazione
  • Controlla la lunghezza dell'input
  • Pattern match per l'iniezione
  • Rileva tentativi di codifica
  • Convalida del tipo
  • Disinfettazione prima dell'elaborazione
  • Registra errori di convalida
  • Limitazione della velocità

Gestione dell'output

Gli output LLM devono essere convalidati e disinfettati prima di essere presentati agli utenti o passati ad altri sistemi.

Filtro dei contenuti

  • Verifica dell'esposizione di dati sensibili
  • Verifica che non siano trapelati messaggi di sistema
  • Convalida il formato di output
  • Verifica la presenza di contenuti inseriti

Rilevamento PII

  • Scansiona informazioni personali
  • Mascherare o oscurare dati sensibili
  • Registra tentativi di esposizione PII
  • Notifica all'utente quando rilevato

Convalida del formato

  • Convalida degli output JSON
  • Controllare la struttura prevista
  • Verifica dei valori consentiti
  • Disinfettare l'HTML se applicabile

Esempio di gestore dell'output

```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
```

Sicurezza API

Autenticazione

  • Utilizza una solida gestione delle chiavi API
  • Implementare OAuth 2.0 ove possibile
  • Convalida token JWT
  • Rotazione delle chiavi API

Autorizzazione

  • Controllo degli accessi basato sui ruoli (RBAC)
  • Ambito chiave API
  • Limiti di velocità per utente
  • Isolamento del tenant

Limitazione della velocità

  • Limiti basati su token
  • Limiti basati su richiesta
  • Controllo dei costi
  • Limitazione a più livelli

Elenco di controllo per la sicurezza API

  • Utilizza solo HTTPS
  • Implementa limitazioni della velocità
  • Convalidare tutti gli input
  • Disinfetta tutti gli output
  • Utilizza chiavi API, non integrate
  • Implementa la firma delle richieste
  • Accesso API registro
  • Implementa CORS correttamente

Autenticazione e autorizzazione

Autenticazione utente

  • Politiche di password efficaci
  • Supporto MFA
  • Gestione delle sessioni
  • Scadenza token

Autenticazione API

  • Gestione delle chiavi API
  • Ambiti OAuth
  • Convalida JWT
  • Rotazione delle chiavi

Autorizzazione

  • Implementazione RBAC
  • Controlli delle autorizzazioni
  • Accesso a livello di risorsa
  • Logging di controllo

Sicurezza dei dati

Classificazione dei dati

  • Identificare i dati sensibili
  • Categorizza in base alla sensibilità
  • Applica controlli per categoria
  • Controlli regolari

Crittografia

  • TLS in transito
  • AES at rest
  • Gestione delle chiavi
  • Rotazione delle chiavi

Gestione delle PII

  • Rilevamento
  • Minimizzazione
  • Gestione del consenso
  • Diritto all'eliminazione

Logging e monitoraggio

Che cosa registrare

Eventi di sicurezza

  • Tentativi di autenticazione
  • Errori di autorizzazione
  • Limite di velocità superato
  • Modelli sospetti

Eventi specifici dell'intelligenza artificiale

  • Tentativi di inserimento rapidi
  • Accesso rapido al sistema
  • Invocazioni di strumenti
  • Accesso ai dati tramite AI

Eventi operativi

  • Chiamate API
  • Errori ed eccezioni
  • Metriche delle prestazioni
  • Tracciamento dei costi

Best practice per il monitoraggio

  • Avvisi in tempo reale per eventi di sicurezza
  • Dashboard per metriche di sicurezza
  • Rilevamento automatico delle anomalie
  • Integrazione con SIEM
  • Revisione regolare del registro
  • Politiche di conservazione

Vulnerabilità comuni

1. IDOR nelle funzionalità AI

Riferimento diretto agli oggetti non sicuro quando l'intelligenza artificiale accede alle risorse

Esempio

L'utente chiede all'AI di "leggere il file X" e l'AI ha accesso senza adeguati controlli di autorizzazione.

2. SSRF tramite LLM

Falsi di richieste lato server tramite chiamate allo strumento AI

Esempio

Il prompt induce l'IA a effettuare richieste ai servizi interni.

3. Bypass dell'autenticazione

Autenticazione debole o mancante per endpoint AI

Esempio

Endpoint API AI senza controlli di autenticazione adeguati.

4. Esposizione al DB vettoriale

Database vettoriale non protetto con incorporamenti sensibili

Esempio

DB vettoriale accessibile al pubblico con dati sensibili incorporati.

Conformità

GDPR (EU)

  • Base legale per l'elaborazione
  • Minimizzazione dei dati
  • Diritto di accesso/cancellazione
  • Portabilità dei dati

CCPA (California)

  • Diritto di sapere
  • Diritto di eliminare
  • Diritto di opt-out
  • Non discriminazione

Specifico per AI

  • Requisiti della legge sull'intelligenza artificiale dell'UE
  • Valutazioni dei rischi IA
  • Obblighi di trasparenza
  • Supervisione umana

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.