Quipu

Librería de codificación con protección criptográfica y simbología propia.

🇬🇧 Quipu is a free/libre (AGPL-3.0) library that encrypts and encodes data using only vetted cryptographic primitives (XChaCha20-Poly1305, Argon2id, HKDF), with a hybrid post-quantum mode (X25519 + ML-KEM-1024) and a verifiable online hardening mode (VOPRF + DLEQ). It never invents primitives — security lives in the keys, not in hiding the format.

Filosofía "rueda y oruga": donde existe buena criptografía, la reutilizamos (XChaCha20-Poly1305, Argon2id, HKDF, ML-KEM, X25519); donde hay terreno nuevo (representación, simbología, formato), innovamos. Nunca inventamos primitivas criptográficas: la seguridad vive en la clave + el AEAD, no en la representación.

Qué hace

Protege datos y los representa como símbolos (texto denso, glifos, o una imagen), de forma reversible y autenticada.

datos → KDF(passphrase+pepper) → AEAD → contenedor → codec base-N → diccionario → símbolos

Modos

Diccionarios (simbología enchufable)

• dictionaries::ascii94() — 94 símbolos ASCII (copy-paste universal).
• dictionaries::flagship() — 4096 glifos (12 bits/símbolo, ~2× más denso).
• dictionaries::from_range(start, count) — alfabeto a medida.
• glyphopt — selección de glifos por máxima separabilidad (base para glifos por IA).

Galería de glifos

La misma carga cifrada puede representarse como texto denso, como una imagen PNG, o con un alfabeto de glifos propio (geométrico o generado orgánicamente). La simbología es pública (Kerckhoffs): no aporta ni resta seguridad, solo representación.

Alfabeto de glifos	Secreto en glifos	Glifos nativos	Glifos generativos

Seguridad y endurecimiento

• Precapas: normalización NFKC, pepper, padding Padmé (oculta longitud), binding de contexto (AAD), HKDF (separación de subclaves).
• Antihacker: borrado de claves en memoria (zeroize), comparación en tiempo constante, validación de parámetros KDF, errores uniformes.
• Hackerbot: red-team interno (tamper/truncation/uniqueness). Encontró y se corrigió un DoS por parámetros Argon2 maliciosos.
• Security Lab (features lab / lab-offline, no viajan en el build publicado): red-team adaptativo que se ataca a sí mismo. Núcleo en CI (fuga de formato + falsificación de firmas) con corpus encadenado y meta-tests que fallan si se debilita una defensa antihacker; y un banco offline aislado (contenedor sin red) para timing y coste de guessing acelerado por IA. cargo run --example securitylab --features lab · bash lab/run.sh. Ver lab/README.md y THREAT_MODEL.md §9.

Uso (Rust)

use quipu::api::{encode, decode, Options};
use quipu::dictionaries;

let dict = dictionaries::ascii94();
let sym = encode(b"secreto", "passphrase", &dict, &Options::default());
let data = decode(&sym, "passphrase", &dict, b"").unwrap();

Firma híbrida (autenticidad verificable por terceros, post-cuántica):

use quipu::api::{encode_signed, decode_verified};
use quipu::{dictionaries, pqsign};

let dict = dictionaries::ascii94();
let (vk, sk) = pqsign::generate_keypair();
let signed = encode_signed(b"acta oficial", &sk, &dict);
let msg = decode_verified(&signed, &vk, &dict).unwrap(); // falla si se altera

Uso (Python)

pip install quipu-crypto   # se instala como "quipu-crypto", se importa como "quipu"

import quipu
s = quipu.encode(b"secreto", "passphrase")
assert quipu.decode(s, "passphrase") == b"secreto"

# Post-cuántico
pub, sec = quipu.generate_keypair()
s = quipu.encode_to_recipient(b"secreto", pub)
assert quipu.decode_as_recipient(s, sec) == b"secreto"

# Firma híbrida (autenticidad, post-cuántica)
vk, sk = quipu.generate_signing_keypair()
signed = quipu.encode_signed(b"acta oficial", sk)
assert quipu.decode_verified(signed, vk) == b"acta oficial"  # falla si se altera

# Streaming AEAD para datos grandes (salida binaria, no símbolos)
blob = quipu.encrypt_stream(b"...datos grandes...", "passphrase")
assert quipu.decrypt_stream(blob, "passphrase") == b"...datos grandes..."

Ejemplos funcionales

Round-trip de todos los modos, listo para correr:

cargo run --example quickstart          # Rust  (examples/quickstart.rs)
python examples/quickstart.py           # Python (examples/quickstart.py)

Construir y probar

cargo test                      # tests unit + property
cargo clippy --all-targets      # lint
cargo run --example demo        # demo simétrico + glifos
cargo run --example v2demo      # post-cuántico + OPRF + imagen
cargo run --example hackerbot   # red-team
cargo run --example testplatform --release   # batería completa
cargo run --example securitylab --features lab   # laboratorio de seguridad (red-team adaptativo)
bash lab/run.sh   # banco offline aislado (timing + guessing) — Etapa B

# Fuzzing (nightly)
cargo +nightly fuzz run parse_container

# Bindings Python
source venv/bin/activate
maturin develop --features python
python tests/python/test_quipu.py

Estado

v1 + v1.1 + v2 + firmas implementados con TDD estricto. 106 tests Rust + Wycheproof + 8 Python verdes, clippy limpio, fuzzing sin crashes, Miri sin UB. Parámetros post-cuánticos en categoría de seguridad NIST 5 (CNSA 2.0): ML-KEM-1024 y ML-DSA-87. Modo online con VOPRF verificable (prueba DLEQ), KEM híbrido con transcript ligado estilo X-Wing, firma híbrida Ed25519 + ML-DSA-87 (combinador AND), y pre-auditoría propia (ver INFORME_PREAUDITORIA.txt y MODELO_DE_AMENAZA.txt). Security Lab (red-team adaptativo auto-hospedado): 14 ataques en CI (--features lab) + banco offline de timing/guessing (--features lab-offline).

⚠️ Proyecto en desarrollo. La pre-auditoría interna NO sustituye una auditoría criptográfica independiente: no usar para proteger datos críticos reales hasta ese sello externo.

Documentación

• docs/SPEC.md — especificación técnica (formato del contenedor, KDF, modo híbrido, VOPRF/DLEQ, separación de dominios).
• docs/THREAT_MODEL.md — modelo de amenaza (EN) · original MODELO_DE_AMENAZA.txt (ES).
• docs/PRE_AUDIT.md — pre-auditoría interna (EN) · original INFORME_PREAUDITORIA.txt (ES).
• SECURITY.md — política de seguridad y reporte de fallos.
• docs/RELEASES.md — cómo verificar la autenticidad de un release (attestations PEP 740 + firmas sigstore/cosign).
• CONTRIBUTING.md — cómo contribuir · CHANGELOG.md.
• LICENSING.md — modelo de licenciamiento dual.
• docs/announcement.md — artículo de diseño (EN/ES).
• docs/superpowers/specs/2026-07-01-quipu-security-lab-design.md — diseño del Security Lab (red-team adaptativo, feature lab).

⚠️ La pre-auditoría interna es preparación, no sustituye una auditoría independiente. Ese sello externo es el siguiente paso del proyecto (solicitud enviada al OTF Security Lab).

Licencia

Modelo de licencia dual (open-core):

• AGPL-3.0-or-later para uso abierto (ver LICENSE).
• Licencia comercial para producto propietario cerrado o SaaS sin abrir código.
• El servidor OPRF se ofrece además como servicio gestionado de pago.

Detalles en LICENSING.md. Contacto: isazajuancarlos@gmail.com