Código

Acompaña al artículo sobre prompt injection y jailbreaking

Guardrails para asistentes con LLM

Siete ataques reales que se escriben en un chat, y las capas que los detienen.

Python 98%TOML 2%13 archivos558 líneas de código 21/21 pruebas
"""Capa 1: normalización de entrada.

Un filtro que compara texto literal se rompe con "d4rm3", con una "а" cirílica
o con un carácter invisible en medio de una palabra. Antes de evaluar cualquier
regla, el texto se lleva a una forma canónica.
"""

from __future__ import annotations

import base64
import binascii
import re
import unicodedata
from dataclasses import dataclass, field

# Caracteres invisibles que se usan para partir palabras sin que se note.
_ZERO_WIDTH = dict.fromkeys(map(ord, "​‌‍⁠­"), None)

# Letras de otros alfabetos que se ven idénticas a las latinas (homóglifos).
_CONFUSABLES = str.maketrans({
    "а": "a", "е": "e", "о": "o", "р": "p", "с": "c", "х": "x", "у": "y",
    "і": "i", "ј": "j", "ѕ": "s", "ԁ": "d", "ɡ": "g", "ո": "n", "ս": "u",
    "Α": "a", "Β": "b", "Ε": "e", "Ι": "i", "Κ": "k", "Μ": "m", "Ν": "n",
    "Ο": "o", "Ρ": "p", "Τ": "t", "Χ": "x", "Υ": "y", "ο": "o", "ν": "v",
})

_LEET = str.maketrans({"0": "o", "1": "i", "3": "e", "4": "a", "5": "s", "7": "t", "@": "a", "$": "s"})

# Una "palabra" con letras y dígitos mezclados (d4rm3, b1n4r10) probablemente es leetspeak.
# Los números puros ("1", "9", "2026") se dejan intactos.
_MIXED_TOKEN = re.compile(r"\b(?=[\w@$]*[a-záéíóúñ])(?=[\w@$]*[0-9@$])[\w@$]+\b", re.IGNORECASE)

_BASE64_BLOB = re.compile(r"\b[A-Za-z0-9+/]{16,}={0,2}")


@dataclass
class Normalized:
    original: str
    text: str
    flags: list[str] = field(default_factory=list)

    def __str__(self) -> str:  # pragma: no cover - comodidad
        return self.text


def _strip_accents(text: str) -> str:
    decomposed = unicodedata.normalize("NFD", text)
    return "".join(c for c in decomposed if unicodedata.category(c) != "Mn")


def _decode_base64_blobs(text: str, flags: list[str]) -> str:
    def repl(match: re.Match[str]) -> str:
        blob = match.group(0)
        try:
            decoded = base64.b64decode(blob, validate=True).decode("utf-8")
        except (binascii.Error, UnicodeDecodeError, ValueError):
            return blob
        if decoded.isprintable():
            flags.append("contenido_codificado")
            return f"{blob} {decoded}"
        return blob

    return _BASE64_BLOB.sub(repl, text)


def normalize(text: str) -> Normalized:
    """Devuelve el texto en forma canónica y las señales que se detectaron en el camino."""
    flags: list[str] = []

    out = unicodedata.normalize("NFKC", text)  # fullwidth, ligaduras, etc.

    without_zw = out.translate(_ZERO_WIDTH)
    if without_zw != out:
        flags.append("caracteres_invisibles")
    out = without_zw

    folded = out.translate(_CONFUSABLES)
    if folded != out:
        flags.append("homoglifos")
    out = folded

    out = _decode_base64_blobs(out, flags)

    def unleet(match: re.Match[str]) -> str:
        flags.append("leetspeak")
        return match.group(0).translate(_LEET)

    out = _MIXED_TOKEN.sub(unleet, out)

    out = _strip_accents(out).lower()
    out = re.sub(r"\s+", " ", out).strip()

    return Normalized(original=text, text=out, flags=sorted(set(flags)))