Salvaguardia: oscurare chiavi API e password

Salvaguardia che oscura chiavi API, token, password, chiavi private e stringhe di connessione prima di inviare un testo, un file o un'esportazione a un'IA. Regole, 14 casi di test, codice.

Regole

Oscurare prima dell'invio all'IA ogni segreto che dà accesso a un account o a un servizio:
- chiavi API (OpenAI, Anthropic, Mistral, Stripe, AWS…) e token di accesso (GitHub, JWT);
- password scritte in chiaro (password=…, pwd: …);
- chiavi private (-----BEGIN … PRIVATE KEY-----);
- credenziali dentro un indirizzo (postgres://utente:password@server).
Lasciar passare: valori di esempio (TUA_CHIAVE_API, xxx, <chiave>), indirizzi senza credenziali, numeri d'ordine o di commit, testi che parlano di password senza contenerne.
Da applicare prima di incollare un file .env, un'esportazione del database o dei log in un assistente.

Casi di test

Codice

import re

PATTERNS = {
    "private_key": r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----",
    "aws_key": r"\bAKIA[0-9A-Z]{16}\b",
    "github_token": r"\bgh[pousr]_[A-Za-z0-9]{36,}\b",
    "llm_api_key": r"\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}\b",
    "stripe_key": r"\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b",
    "jwt": r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b",
    "url_credentials": r"\b[a-z][a-z0-9+.-]*://[^\s:/@]+:[^\s@/]+@",
    "password_assignment": r"(?i)\b(?:password|passwd|pwd|secret|api_?key|token|parola_chiave|chiave)\s*[:=]\s*[\"']?[^\s\"']{6,}",
}
PLACEHOLDERS = ("xxx", "...", "<", "your", "tua_", "example_value")

def mask_secrets(text: str) -> tuple[str, bool]:
    """Sostituisce i segreti con [tipo oscurato]; restituisce il testo e True se qualcosa è stato oscurato."""
    found = False
    for name, pattern in PATTERNS.items():
        def repl(m):
            nonlocal found
            if any(p in m.group(0).lower() for p in PLACEHOLDERS):
                return m.group(0)
            found = True
            return f"[{name} oscurato]"
        text = re.sub(pattern, repl, text)
    return text, found

Identificativo

contextetech--oscurare-segreti-chiavi-api

File

oscurare-segreti-chiavi-api.guardrail.json

Formato

JSON (application/json)

Dimensione

2589 byte (2,5 KB)

Codifica

UTF-8

Token stimati

≈ 716

Uso commerciale

Consentito

Dati personali

Nessuno

Versione

1.0

Pubblicato il

10 ottobre 2026 alle ore 04:24

Aggiornato il

16 ottobre 2026 alle ore 23:20

Archiviazione

nel database

Costo stimato

Token di input per chiamata

≈ 1062

Solo costo di input, esclusa la risposta del modello. Prezzi pubblici standard dei fornitori (Mistral AI, DeepSeek, OpenAI, Anthropic) convertiti da USD in euro al cambio BCE del 13 ottobre 2026. Stima: 1 token ≈ 3,6 caratteri.

oscurare-segreti-chiavi-api.guardrail.json

{
  "format": "contextetech/guardrail/v1",
  "id": "contextetech/oscurare-segreti-chiavi-api",
  "description": "Salvaguardia che oscura chiavi API, token, password, chiavi private e stringhe di connessione prima di inviare un testo, un file o un'esportazione a un'IA. Regole, 14 casi di test, codice.",
  "license": "MIT",
  "language": "it",
  "type": "other",
  "action": "mask",
  "rules": "Oscurare prima dell'invio all'IA ogni segreto che dà accesso a un account o a un servizio:\n- chiavi API (OpenAI, Anthropic, Mistral, Stripe, AWS…) e token di accesso (GitHub, JWT);\n- password scritte in chiaro (password=…, pwd: …);\n- chiavi private (-----BEGIN … PRIVATE KEY-----);\n- credenziali dentro un indirizzo (postgres://utente:password@server).\nLasciar passare: valori di esempio (TUA_CHIAVE_API, xxx, <chiave>), indirizzi senza credenziali, numeri d'ordine o di commit, testi che parlano di password senza contenerne.\nDa applicare prima di incollare un file .env, un'esportazione del database o dei log in un assistente.",
  "cases": [
    {
      "input": "AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE",
      "expected": "block"
    },
    {
      "input": "token: ghp_000000000000000000000000000000000000",
      "expected": "block"
    },
    {
      "input": "ANTHROPIC_API_KEY=sk-ant-00000000000000000000000000000000",
      "expected": "block"
    },
    {
      "input": "STRIPE_SECRET=sk_live_0000000000000000000000",
      "expected": "block"
    },
    {
      "input": "DATABASE_URL=postgres://admin:S3cretPass@db.internal:5432/app",
      "expected": "block"
    },
    {
      "input": "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA0000000000000000\n-----END RSA PRIVATE KEY-----",
      "expected": "block"
    },
    {
      "input": "Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIwMDAwMDAifQ.0000000000000000000000",
      "expected": "block"
    },
    {
      "input": "password = Estate2026!",
      "expected": "block"
    },
    {
      "input": "La password deve avere almeno 12 caratteri.",
      "expected": "allow"
    },
    {
      "input": "Sostituisci TUA_CHIAVE_API con la chiave del tuo account.",
      "expected": "allow"
    },
    {
      "input": "La documentazione è su https://docs.esempio.it/api.",
      "expected": "allow"
    },
    {
      "input": "Il commit a1b2c3d corregge il bug di accesso.",
      "expected": "allow"
    },
    {
      "input": "Ordine n. 2026-10-458712 spedito.",
      "expected": "allow"
    },
    {
      "input": "Accedi con il tuo account abituale.",
      "expected": "allow"
    }
  ]
}

Verificare un testo (Python)

import re

PATTERNS = {
    "private_key": r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----",
    "aws_key": r"\bAKIA[0-9A-Z]{16}\b",
    "github_token": r"\bgh[pousr]_[A-Za-z0-9]{36,}\b",
    "llm_api_key": r"\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}\b",
    "stripe_key": r"\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b",
    "jwt": r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b",
    "url_credentials": r"\b[a-z][a-z0-9+.-]*://[^\s:/@]+:[^\s@/]+@",
    "password_assignment": r"(?i)\b(?:password|passwd|pwd|secret|api_?key|token|parola_chiave|chiave)\s*[:=]\s*[\"']?[^\s\"']{6,}",
}
PLACEHOLDERS = ("xxx", "...", "<", "your", "tua_", "example_value")

def mask_secrets(text: str) -> tuple[str, bool]:
    """Sostituisce i segreti con [tipo oscurato]; restituisce il testo e True se qualcosa è stato oscurato."""
    found = False
    for name, pattern in PATTERNS.items():
        def repl(m):
            nonlocal found
            if any(p in m.group(0).lower() for p in PLACEHOLDERS):
                return m.group(0)
            found = True
            return f"[{name} oscurato]"
        text = re.sub(pattern, repl, text)
    return text, found