Scrivere policy Gate per LiteLLM

1Una parola chiave

La regola più semplice blocca le richieste che nominano un progetto riservato. any scorre le stringhe di texts e # indica la stringa corrente.

Direzione request · verificata

any(doc.texts ?? [], {# contains "PROGETTO-ORIONE"})

Cosa resta fuori. contains distingue le maiuscole: “progetto-orione” passa. Senza ?? [], il terzo payload produrrebbe un errore di valutazione e la decisione passerebbe a on_error.

2Maiuscole, accenti e confini di parola

Un’espressione regolare con (?i) ignora le maiuscole e \b richiede un confine di parola, così “Orionide” non corrisponde.

Direzione request · verificata

any(doc.texts ?? [], {# matches "(?i)\\bprogetto[ -]orione\\b"})

Le lettere accentate possono arrivare in due forme: “à” come un solo carattere, oppure “a” seguita dall’accento combinante U+0300. Le due forme si vedono uguali ma sono stringhe diverse. normalize_nfc le porta alla stessa forma prima del confronto:

any(doc.texts ?? [], {lower(normalize_nfc(#)) contains "società veicolo"})

Cosa resta fuori. Senza normalize_nfc il primo payload passerebbe. In RE2 \b considera lettere solo quelle ASCII: subito dopo “à” non c’è un confine di parola. Evitate \b accanto a lettere accentate.

3Richiesta o risposta

La direzione della regola decide in quale fase viene valutata. Una chiave privata nella risposta del modello va fermata in fase response. Se preferite un’unica regola in direzione both, scrivete la fase nell’espressione con doc.input_type:

Direzione both · verificata

doc.input_type == "response"
&& any(doc.texts ?? [], {# matches "-----BEGIN [A-Z ]*PRIVATE KEY-----"})

Cosa resta fuori. In streaming parte della risposta può essere già arrivata al client quando un frammento successivo viene bloccato. Un blocco in risposta senza streaming trattiene il testo, ma il modello lo ha comunque generato.

4Chi chiama e quale modello

request_data porta i metadati della chiave virtuale LiteLLM. Questa regola consente solo due modelli, tranne per il team “ricerca”:

Direzione request · verificata

let model = doc.model ?? "";
let team = doc.request_data?.user_api_key_team_alias ?? "";
model not in ["gpt-4o-eu", "mistral-large-eu"] && team != "ricerca"

L’ultimo payload non ha model e viene bloccato: con ?? "" la regola tratta il modello mancante come non ammesso. È una scelta da fare in modo esplicito; con ?? "gpt-4o-eu" lo lascereste passare.

I metadati si combinano con il contenuto. Qui un utente con un indirizzo fuori dal dominio aziendale non può inviare testo marcato come riservato:

let email = lower(doc.request_data?.user_api_key_user_email ?? "");
!hasSuffix(email, "@example.it")
&& any(doc.texts ?? [], {lower(#) contains "riservato"})

Cosa resta fuori. I metadati ci sono solo se la chiave virtuale li ha: una chiave senza team o email li lascia vuoti. In risposta model può contenere il nome del provider anziché l’alias richiesto, quindi applicate la lista dei modelli in direzione request.

5Messaggi per ruolo

texts mescola il testo senza dire chi lo ha scritto. Il prompt di sistema, scritto dalla vostra applicazione, può citare legittimamente una frase che non volete dall’utente. structured_messages conserva il ruolo: questa regola guarda solo i messaggi user e gestisce entrambe le forme di content.

Direzione request · verificata

any(doc.structured_messages ?? [], {
  let m = #;
  m.role == "user" && (
    type(m.content) == "string"
      ? lower(m.content) matches "ignora (tutte )?le istruzioni precedenti"
      : any(m.content ?? [], {
          .type == "text" && lower(.text ?? "") matches "ignora (tutte )?le istruzioni precedenti"
        })
  )
})

Il let m = # serve perché dentro il secondo any il simbolo # indica la parte del messaggio, non più il messaggio.

Cosa resta fuori. Una frase fissa ferma solo chi la scrive così: una parafrasi passa. Le immagini allegate non vengono lette. Nella fase di risposta structured_messages può essere null e la regola restituisce false.

6Chiamate a strumenti

Quando il modello decide di chiamare uno strumento, la chiamata arriva in tool_calls nella fase di risposta. Bloccarla lì impedisce al client di riceverla. Il caso più semplice è un elenco di strumenti vietati:

Direzione response · verificata

any(doc.tool_calls ?? [], {(.function?.name ?? "") in ["send_email", "http_post"]})

Per guardare dentro gli argomenti serve fromJSON, perché sono una stringa. Questa regola consente send_email solo verso il dominio aziendale:

any(doc.tool_calls ?? [], {
  let raw = trim(.function?.arguments ?? "");
  (.function?.name ?? "") == "send_email" && hasPrefix(raw, "{") && (
    let to = fromJSON(raw)?.to;
    type(to) != "string" || !hasSuffix(lower(to), "@example.it")
  )
})

Un destinatario mancante blocca: type(to) != "string" tratta l’assenza come sospetta. Il controllo hasPrefix(raw, "{") evita di passare a fromJSON una stringa vuota, ma non può garantire che il JSON sia completo: l’ultimo payload ha argomenti troncati, fromJSON fallisce e la decisione spetta a on_error.

Cosa resta fuori. In streaming LiteLLM può inviare le chiamate a strumenti a frammenti; gli argomenti di un frammento possono non essere JSON completo. fromJSON restituisce i numeri come decimali: confrontateli con > e <, non con l’uguaglianza su interi. In fase di richiesta tool_calls riporta le chiamate già presenti nella cronologia della conversazione, non quelle nuove.

7Dati personali italiani nel testo libero

Il catalogo Noozle di regole deterministiche sui dati personali contiene voci italiane per codice fiscale, partita IVA, carta d’identità, passaporto e patente. Quelle regole sono scritte per un campo doc.value che contiene un solo identificativo, o per un campo doc.text. Il documento di Gate non ha questi campi: il testo è in doc.texts, una lista. Per adattarle:

• avvolgete la condizione in any(doc.texts ?? [], {...}) e sostituite doc.text con #;
• togliete gli ancoraggi ^ e $ delle regole VAL-. Con gli ancoraggi la regola corrisponde solo se l’intera stringa è l’identificativo, cosa che in un prompt non succede quasi mai;
• al loro posto, chiedete un’etichetta davanti al valore o un confine di parola, perché molte forme si somigliano: undici cifre possono essere una partita IVA, un codice fiscale numerico o un numero d’ordine.

Il codice fiscale dopo un’etichetta, dalla voce TXT-IT-FISCAL-LABEL del catalogo:

Direzione request · verificata

any(doc.texts ?? [], {
  # matches "(?i)\\b(?:codice fiscale|fiscal code)[ \\t]*[:=]?[ \\t]*[A-Z]{6}[0-9]{2}[A-Z][0-9]{2}[A-Z][0-9]{3}[A-Z]\\b"
})

Il terzo payload passa anche se è un codice fiscale valido: è un caso di omocodia, in cui l’Agenzia delle Entrate sostituisce alcune cifre con lettere per distinguere persone che avrebbero lo stesso codice. La regola del catalogo non lo prevede; il livello 8 sì.

L’IBAN italiano ha sempre 27 caratteri: IT, due cifre di controllo e 23 caratteri. Questa forma accetta sia la scrittura compatta sia quella a gruppi di quattro:

any(doc.texts ?? [], {
  upper(#) matches "\\bIT[0-9]{2}(?: ?[0-9A-Z]{4}){5} ?[0-9A-Z]{3}\\b"
})

La voce del catalogo per la data di nascita accetta solo il formato ISO. In italiano si scrive più spesso giorno/mese/anno, quindi la regola accetta entrambi:

any(doc.texts ?? [], {
  # matches "(?i)\\bdata di nascita[ \\t]*[:=]?[ \\t]*(?:[0-3]?[0-9]/[01]?[0-9]/[12][0-9]{3}|[12][0-9]{3}-[01][0-9]-[0-3][0-9])\\b"
})

Cosa resta fuori. Una forma non dice se il valore è stato davvero rilasciato né a chi appartiene. Le etichette sono una scelta della policy: “nato il 10/12/1985” passa. (?i) rende insensibili alle maiuscole anche le lettere del codice fiscale.

8Caratteri di controllo sui token

Codice fiscale, IBAN e partita IVA contengono un controllo aritmetico. Verificarlo riduce i falsi positivi, ma richiede di isolare il singolo valore. Il linguaggio non ha una funzione che estrae tutte le corrispondenze di una regex: si divide il testo in parole e si controlla ogni parola. Tutte le regole di questo livello iniziano con la stessa riga:

let words = flatten(map(doc.texts ?? [], {split(replace(replace(#, "\n", " "), "\t", " "), " ")}));

Ogni parola viene poi ripulita della punteggiatura ai bordi con trim.

Codice fiscale con omocodia e carattere di controllo

Le posizioni numeriche possono contenere le lettere L M N P Q R S T U V (omocodia) e il mese è una lettera tra A B C D E H L M P R S T. Il sedicesimo carattere si calcola dai primi quindici: nelle posizioni dispari (prima, terza, ...) ogni carattere vale secondo una tabella, nelle posizioni pari vale la sua posizione nell’alfabeto o la cifra stessa; il resto della somma diviso 26 indica la lettera.

Direzione request · verificata

let words = flatten(map(doc.texts ?? [], {split(replace(replace(#, "\n", " "), "\t", " "), " ")}));
let alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
let odd = [1, 0, 5, 7, 9, 13, 15, 17, 19, 21, 2, 4, 18, 20, 11, 3, 6, 8, 12, 14, 16, 10, 22, 25, 24, 23];
any(words, {
  let cf = upper(trim(#, ".,;:()[]<>\"'"));
  cf matches "^[A-Z]{6}[0-9LMNP-V]{2}[ABCDEHLMPRST][0-9LMNP-V]{2}[A-Z][0-9LMNP-V]{3}[A-Z]$"
  && reduce(split(cf[:15], ""), {
       let i = # matches "^[0-9]$" ? int(#) : indexOf(alpha, #);
       #acc + (#index % 2 == 0 ? odd[i] : i)
     }, 0) % 26 == indexOf(alpha, cf[15:])
})

Le cifre e le lettere usano la stessa tabella: la cifra 0 vale come la A, la 1 come la B e così via. Per questo basta un solo indice i.

Decidete cosa fare dei codici con un errore. Il riconoscitore di riferimento, quello di Microsoft Presidio, non scarta un codice con il carattere di controllo sbagliato: gli dà solo un punteggio più basso. Questa regola invece lo lascia passare, come l’ultimo payload. Un codice con un errore di battitura resta però un dato personale. Se volete fermare anche quelli, usate solo la condizione matches senza il reduce.

IBAN con controllo mod-97

Si spostano i primi quattro caratteri in fondo, le lettere diventano numeri da 10 a 35 e il resto della divisione per 97 deve essere 1. Il calcolo procede cifra per cifra per non superare i limiti degli interi. Dalla voce CHK-IBAN-MOD97 del catalogo, ristretta agli IBAN italiani:

let words = flatten(map(doc.texts ?? [], {split(replace(replace(#, "\n", " "), "\t", " "), " ")}));
let alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
any(words, {
  let v = upper(trim(#, ".,;:()[]<>\"'"));
  v matches "^IT[0-9]{2}[A-Z][0-9]{10}[0-9A-Z]{12}$"
  && reduce(split(v[4:] + v[:4], ""), {
       let n = indexOf(alphabet, #);
       (#acc * (n < 10 ? 10 : 100) + n) % 97
     }, 0) == 1
})

Questa regola vede solo l’IBAN scritto senza spazi, perché la divisione in parole spezza la forma a gruppi. Tenete anche la regola del livello 7 per quella forma.

Partita IVA dopo un’etichetta

Undici cifre senza contesto sono troppo comuni. Qui la parola precedente deve essere un’etichetta come “IVA” o “P.IVA”. Per leggere la parola precedente si scorrono le posizioni con l’intervallo 1..(len(words) - 1), e # diventa un indice. Il controllo è lo stesso algoritmo di Luhn delle carte di pagamento; il valore tutto a zero viene escluso come fa Presidio.

let words = flatten(map(doc.texts ?? [], {split(replace(replace(#, "\n", " "), "\t", " "), " ")}));
any(1..(len(words) - 1), {
  let v = trim(words[#], ".,;:()[]<>\"'");
  let label = lower(words[# - 1]);
  label in ["iva", "iva:", "p.iva", "p.iva:", "p.i.", "p.i.:"]
  && v matches "^[0-9]{11}$"
  && v != "00000000000"
  && reduce(split(v, ""), {
       let d = int(#);
       #acc + (#index % 2 == 1 ? (d * 2 > 9 ? d * 2 - 9 : d * 2) : d)
     }, 0) % 10 == 0
})

Trattate la partita IVA come un possibile dato personale. Non appartiene solo alle società: la hanno anche professionisti e ditte individuali, e dal numero non si capisce chi sia il titolare.

Cosa resta fuori. Un valore spezzato su due righe o tra due messaggi non viene ricomposto. Il controllo aritmetico dice che il numero è coerente, non che sia stato rilasciato. Le tabelle del codice fiscale e la forma dell’IBAN sono quelle pubbliche; lo stesso approccio vale per le carte di pagamento con la voce CHK-CARD-LUHN del catalogo.

9Combinazioni ed eccezioni

Un indirizzo email da solo può essere legittimo: quello dell’ufficio privacy, per esempio. Questa regola blocca gli indirizzi fuori da un elenco approvato. Ogni indirizzo viene valutato da solo: la presenza di un indirizzo ammesso non esenta gli altri. Deriva dalla voce POL-CONTACT-EXCEPTION del catalogo.

Direzione request · verificata

let words = flatten(map(doc.texts ?? [], {split(replace(replace(#, "\n", " "), "\t", " "), " ")}));
any(words, {
  let w = lower(trim(#, ".,;:()[]<>\"'"));
  w matches "^[a-z0-9._%+-]+@[a-z0-9.-]+[.][a-z]{2,}$"
  && w not in ["[email protected]", "[email protected]"]
})

Il rischio cresce quando più dati della stessa persona compaiono insieme. Questa regola blocca un messaggio che contiene almeno due tipi di dato tra email, IBAN, codice fiscale etichettato e data di nascita. Il team “assistenza-clienti”, che lavora con i dati dei clienti, è esentato con una condizione esplicita:

let team = doc.request_data?.user_api_key_team_alias ?? "";
team != "assistenza-clienti" && any(doc.texts ?? [], {
  let t = #;
  count([
    t matches "(?i)[a-z0-9._%+-]+@[a-z0-9.-]+[.][a-z]{2,}",
    upper(t) matches "\\bIT[0-9]{2}(?: ?[0-9A-Z]{4}){5} ?[0-9A-Z]{3}\\b",
    t matches "(?i)\\b(?:codice fiscale|fiscal code)[ \\t]*[:=]?[ \\t]*[A-Z]{6}[0-9]{2}[A-Z][0-9]{2}[A-Z][0-9]{3}[A-Z]\\b",
    t matches "(?i)\\bdata di nascita[ \\t]*[:=]?[ \\t]*(?:[0-3]?[0-9]/[01]?[0-9]/[12][0-9]{3}|[12][0-9]{3}-[01][0-9]-[0-3][0-9])\\b"
  ]) >= 2
})

count senza secondo argomento conta i valori true della lista. Preferite regole separate per ogni tipo di dato quando volete sapere quale ha bloccato: Gate riporta la regola che corrisponde, non la condizione interna.

Cosa resta fuori. L’ultimo payload passa: i due dati sono in due elementi diversi di texts, e la regola li conta separatamente. Se volete contarli insieme, usate join(doc.texts ?? [], "\n") al posto di any, accettando di unire messaggi che possono riguardare persone diverse.

10Il significato del testo

Le regole viste finora cercano forme. about confronta il significato del testo con un argomento scritto nella regola, usando gli embedding del provider semantico configurato, e corrisponde sopra una soglia:

Direzione request · non eseguita in questa guida

about(doc.texts ?? [], "richiesta di parere legale su una causa in corso", 0.8)

L’argomento deve essere una stringa costante. Una lista vuota dà false. Se il provider non risponde o il testo supera i suoi limiti, la valutazione fallisce e decide on_error: con on_error=block un guasto del provider blocca le richieste.

Cosa resta fuori. La soglia 0.8 è un punto di partenza, non un valore tarato: calibratela su payload reali della vostra organizzazione, con esempi da bloccare e da lasciar passare. Combinare about con una condizione di forma, per esempio un codice fiscale, rende la regola più prevedibile.