NOMBRE

CryptX - Kit de herramientas criptográficas

SINOPSIS

CryptX es el punto de entrada de la distribución. En el código normal, cargue uno de los módulos concretos que se enumeran a continuación.

## one-shot hashing
use Crypt::Digest qw(digest_data_hex);
my $sha256 = digest_data_hex('SHA256', 'hello world');

## classic AES-CBC encryption with padding
use Crypt::Mode::CBC;
my $cbc = Crypt::Mode::CBC->new('AES');
my $iv = random_bytes(16); # 16-byte AES block-size IV
my $cbc_ciphertext = $cbc->encrypt('hello world', $key, $iv);

## authenticated encryption (AEAD) with AES
use Crypt::AuthEnc::GCM qw(gcm_encrypt_authenticate);
my $key = random_bytes(32);   # 32-byte AES-256 key
my $nonce = random_bytes(12); # 12-byte unique nonce
my ($ciphertext, $tag) = gcm_encrypt_authenticate('AES', $key, $nonce, 'header', 'hello world');

## message authentication
use Crypt::Mac::HMAC qw(hmac_hex);
my $mac = hmac_hex('SHA256', $key, 'hello world');

## secure random data + UUID helpers
use Crypt::PRNG qw(random_bytes random_string);
use Crypt::Misc qw(random_v4uuid random_v7uuid);
my $salt = random_bytes(16);
my $token = random_string(24);
my $uuid4 = random_v4uuid();
my $uuid7 = random_v7uuid();

## classic password-based key derivation
use Crypt::KeyDerivation qw(pbkdf2);
my $dk = pbkdf2('password', $salt, 100_000, 'SHA256', 32);

## bare stream cipher (authenticate separately)
use Crypt::Stream::ChaCha;
my $stream = Crypt::Stream::ChaCha->new($key, $nonce);
my $stream_ciphertext = $stream->crypt('hello world');

## modern signatures
use Crypt::PK::Ed25519;
my $signer = Crypt::PK::Ed25519->new->generate_key;
my $sig = $signer->sign_message('hello world');
my $ok = $signer->verify_message($sig, 'hello world');

## key agreement
use Crypt::PK::X25519;
my $alice = Crypt::PK::X25519->new->generate_key;
my $bob = Crypt::PK::X25519->new->generate_key;
my $shared_secret = $alice->shared_secret($bob);

DESCRIPCIÓN

Módulos criptográficos Perl construidos sobre la librería LibTomCrypt incluida. La distribución también incluye Math::BigInt::LTM, un backend de Math::BigInt construido sobre la librería LibTomMath incluida, utilizada internamente por LibTomCrypt.

Este módulo sirve principalmente como página de nivel superior de la distribución/documentación. Para el trabajo real, use uno de los módulos concretos que se enumeran a continuación.

Guía de selección de algoritmos

Cifrado autenticado (AEAD)

Para diseños nuevos, prefiera el cifrado autenticado (AEAD) sobre los modos de cifrado simples:

ChaCha20-Poly1305 (Crypt::AuthEnc::ChaCha20Poly1305) - Rápido, de tiempo constante, ampliamente desplegado (TLS 1.3, WireGuard, SSH). Úselo como la opción AEAD por defecto.
XChaCha20-Poly1305 (Crypt::AuthEnc::XChaCha20Poly1305) - Variante de nonce extendido de 24 bytes. Prefiérala sobre ChaCha20-Poly1305 cuando los nonces se generen aleatoriamente.
AES-GCM (Crypt::AuthEnc::GCM) - El modo AEAD estándar para AES. Acelerado por hardware en CPUs modernas. Requiere nonces únicos; reutilizar un nonce rompe la seguridad por completo.
AES-SIV (Crypt::AuthEnc::SIV) - AEAD determinista, resistente al mal uso del nonce. Algo más lento, pero más seguro cuando no se puede garantizar la unicidad del nonce.
AES-GCM-SIV (Crypt::AuthEnc::GCMSIV) - AEAD resistente al mal uso del nonce (RFC 8452). Más rápido que AES-SIV; elija esta opción cuando necesite un rendimiento similar a GCM con seguridad frente a la reutilización de nonces.
AES-OCB (Crypt::AuthEnc::OCB) - AEAD de una sola pasada muy rápido. Verifique el estado de las patentes en su jurisdicción.
AES-EAX (Crypt::AuthEnc::EAX) - AEAD de dos pasadas basado en CTR+OMAC. Sin patentes, sin restricciones de longitud de nonce.
AES-CCM (Crypt::AuthEnc::CCM) - Utilizado en WiFi (WPA2) y Bluetooth. Requiere conocer la longitud del texto plano de antemano.

Aleatoriedad criptográficamente segura y UUIDs

Bytes / cadenas aleatorios (Crypt::PRNG) - Úselo para sales, claves, nonces, tokens y cualquier otro valor aleatorio secreto. Los asistentes funcionales random_bytes, random_bytes_hex, random_bytes_b64, random_bytes_b64u, random_string y random_string_from cubren la mayoría de los casos de uso. La API orientada a objetos y los envoltorios específicos de algoritmo (Crypt::PRNG::ChaCha20, Crypt::PRNG::Fortuna, etc.) se usan principalmente para flujos deterministas o interoperabilidad con un PRNG concreto.
UUIDs ("random_v4uuid" en Crypt::Misc, "random_v7uuid" en Crypt::Misc) - Use random_v4uuid para identificadores aleatorios opacos. Use random_v7uuid cuando desee identificadores aproximadamente ordenados por tiempo que se ordenen por hora de creación con granularidad de milisegundos. Los UUID son identificadores, no sustituyen a los bytes aleatorios secretos.

Cifrados de flujo

Los cifrados de flujo encriptan los datos byte a byte sin relleno de bloque. Para la mayoría de las aplicaciones, prefiera un modo AEAD (ver arriba) que combine el cifrado con la autenticación. Use cifrados de flujo simples únicamente cuando maneje la autenticación por separado.

ChaCha (Crypt::Stream::ChaCha) - La opción de cifrado de flujo por defecto. El mismo núcleo que ChaCha20-Poly1305 sin el MAC integrado.
XChaCha (Crypt::Stream::XChaCha) - Variante de nonce extendido de 24 bytes de ChaCha. Prefiérala cuando los nonces se generen aleatoriamente.
Salsa20 / XSalsa20 (Crypt::Stream::Salsa20, Crypt::Stream::XSalsa20) - Predecesor de ChaCha. Prefiera ChaCha para diseños nuevos; Salsa20 solo para interoperabilidad (p. ej. NaCl/libsodium).
RC4 (Crypt::Stream::RC4) - Roto; no lo use para diseños nuevos. Se proporciona únicamente para interoperabilidad heredada.
Rabbit, Sober128, Sosemanuk (Crypt::Stream::Rabbit, Crypt::Stream::Sober128, Crypt::Stream::Sosemanuk) - Cifrados de nicho del portafolio eSTREAM. Use ChaCha a menos que un protocolo específico requiera uno de estos.

Modos de cifrado por bloques (sin autenticación)

Use estos modos únicamente cuando la autenticación se maneje por separado o no sea necesaria:

CTR (Crypt::Mode::CTR) - Convierte un cifrado por bloques en un cifrado de flujo. Paralelizable.
CBC (Crypt::Mode::CBC) - Modo clásico, necesita relleno. Prefiera CTR o un modo AEAD.
ECB (Crypt::Mode::ECB) - Inseguro para la mayoría de los usos. Cada bloque se cifra de forma independiente.

Los módulos individuales Crypt::Cipher::AES, Crypt::Cipher::Twofish, etc. implementan el cifrado bruto de un solo bloque y rara vez se utilizan directamente. En casi todos los casos, debe usarlos a través de un modo AEAD (Crypt::AuthEnc::GCM, Crypt::AuthEnc::CCM) o de un modo de cifrado por bloques (Crypt::Mode::CBC, Crypt::Mode::CTR). Al elegir un cifrado, AES es la opción por defecto; está acelerado por hardware en la mayoría de las CPUs modernas.

Funciones hash

SHA-256 / SHA-384 / SHA-512 (Crypt::Digest::SHA256, etc.) - La opción por defecto para el hash general. Ampliamente soportada y bien analizada.
SHA3-256 / SHA3-512 (Crypt::Digest::SHA3_256, etc.) - Alternativa a SHA-2 con una construcción completamente diferente (esponja Keccak).
BLAKE2b / BLAKE2s (Crypt::Digest::BLAKE2b_256, etc.) - Muy rápidas, especialmente en software. BLAKE2b para plataformas de 64 bits, BLAKE2s para 32 bits.
SHAKE / TurboSHAKE / KangarooTwelve - Funciones de salida extensible (XOFs). Úselas cuando necesite una salida de longitud variable.

Sumas de verificación

Use Crypt::Checksum::CRC32 y Crypt::Checksum::Adler32 únicamente para comprobaciones de integridad no adversariales, como la detección de corrupción accidental. No son mecanismos criptográficos de integridad ni autenticidad. Para uso criptográfico, prefiera Crypt::Digest, Crypt::Mac o un modo AEAD de Crypt::AuthEnc.

Códigos de autenticación de mensajes

HMAC (Crypt::Mac::HMAC) - La construcción MAC estándar. Funciona con cualquier hash. Use HMAC-SHA256 como opción por defecto.
Poly1305 (Crypt::Mac::Poly1305) - MAC de un solo uso, muy rápido. Se usa como parte de ChaCha20-Poly1305. Requiere una clave única por mensaje.
BLAKE2b-MAC (Crypt::Mac::BLAKE2b) - BLAKE2 con clave. Más rápido que HMAC-SHA256 en software.
CMAC/OMAC (Crypt::Mac::OMAC) - MAC basado en cifrado por bloques. Úselo cuando ya tenga AES pero no una función hash.

Criptografía de clave pública

Ed25519 (Crypt::PK::Ed25519) - Firmas digitales modernas. Rápida, de tiempo constante, con claves/firmas pequeñas. La opción por defecto para nuevos esquemas de firma.
Ed448 (Crypt::PK::Ed448) - Mayor margen de seguridad que Ed25519 (~224 bits frente a ~128 bits).
X25519 (Crypt::PK::X25519) - Acuerdo de claves Diffie-Hellman de curva elíptica. La opción por defecto para el intercambio de claves.
X448 (Crypt::PK::X448) - Mayor margen de seguridad que X25519.
ECDSA (Crypt::PK::ECC) - Ampliamente utilizado (TLS, Bitcoin). Prefiera Ed25519 para diseños nuevos a menos que ECDSA sea necesario para la interoperabilidad.
RSA (Crypt::PK::RSA) - Legado pero muy utilizado. Use claves mínimas de 2048 bits, preferiblemente de 4096 bits. Prefiera OAEP para el cifrado y PSS para las firmas.
DSA (Crypt::PK::DSA) - Legado. Prefiera Ed25519 o ECDSA.
DH (Crypt::PK::DH) - Diffie-Hellman clásico. Prefiera X25519 para diseños nuevos.

Derivación de claves / hash de contraseñas

HKDF ("hkdf" en Crypt::KeyDerivation) - KDF de extraer y expandir. Úselo para derivar claves de secretos compartidos (p. ej. tras ECDH).
Argon2 ("argon2_pbkdf" en Crypt::KeyDerivation) - Hash de contraseñas resistente a memoria. La opción recomendada para el almacenamiento de contraseñas.
Bcrypt ("bcrypt_pbkdf" en Crypt::KeyDerivation) - Úselo principalmente por compatibilidad con formatos y protocolos que requieren específicamente derivación de claves basada en bcrypt (por ejemplo, algunos flujos de trabajo de OpenSSH). Prefiera Argon2 para nuevos diseños de almacenamiento de contraseñas.
Scrypt ("scrypt_pbkdf" en Crypt::KeyDerivation) - KDF resistente a memoria. Use Argon2 si está disponible.
PBKDF2 ("pbkdf2" en Crypt::KeyDerivation) - Ampliamente soportado, pero con dureza solo de CPU. Use Argon2 o Scrypt cuando sea posible.
PBKDF1 ("pbkdf1" en Crypt::KeyDerivation, "pbkdf1_openssl" en Crypt::KeyDerivation) - Derivación solo para legado. Consérvela para interoperabilidad con formatos antiguos; no la use para diseños nuevos.

Manejo de errores

La mayoría de los módulos CryptX informan de errores llamando a croak (de Carp). Los parámetros no válidos, los algoritmos no soportados, los tamaños de clave incorrectos, las entradas malformadas y los fallos internos de la librería normalmente provocan un croak con un mensaje descriptivo. Capture las excepciones con eval o Try::Tiny.

Algunos asistentes de estilo validación devuelven un valor en lugar de croak. Los ejemplos más importantes son las funciones *_decrypt_verify en los módulos de cifrado autenticado Crypt::AuthEnc::*. Estas devuelven undef cuando falla la autenticación, lo que indica que el texto cifrado fue manipulado o que se usó una clave/nonce incorrecta. Algunos asistentes de análisis/decodificación de otros módulos también devuelven undef o falso ante entradas malformadas, así que consulte el POD del módulo concreto cuando necesite una semántica de fallo exacta.

Mapa de módulos

Módulos de familia de nivel superior

Crypt::Cipher, Crypt::Mode, Crypt::AuthEnc, Crypt::Digest, Crypt::Mac, Crypt::Checksum, Crypt::PRNG, Crypt::PK, Crypt::KeyDerivation, Crypt::Misc, Crypt::ASN1
Cifrados simétricos

Crypt::Cipher::AES, Crypt::Cipher::Anubis, Crypt::Cipher::ARIA, Crypt::Cipher::Blowfish, Crypt::Cipher::Camellia, Crypt::Cipher::CAST5, Crypt::Cipher::DES, Crypt::Cipher::DES_EDE, Crypt::Cipher::IDEA, Crypt::Cipher::KASUMI, Crypt::Cipher::Khazad, Crypt::Cipher::MULTI2, Crypt::Cipher::Noekeon, Crypt::Cipher::RC2, , , , , , , , , , , , ,

Funciones de diagnóstico

Estas funciones de bajo nivel exponen detalles de la compilación de LibTomCrypt incluida. Están pensadas para la resolución de problemas y para informes de errores, no para un uso habitual.

ltc_build_settings

my $str = CryptX::ltc_build_settings();

Devuelve una cadena de varias líneas que describe cada opción de compilación que se habilitó al compilar la biblioteca LibTomCrypt incluida (cifrados, hashes, MACs, algoritmos PK, opciones del compilador, etc.).

ltc_mp_name

my $name = CryptX::ltc_mp_name();
# e.g. "LTM" (LibTomMath)

Devuelve el nombre del back-end del proveedor matemático en uso.

ltc_mp_bits_per_digit

my $bits = CryptX::ltc_mp_bits_per_digit();
# e.g. 60

Devuelve el número de bits por dígito utilizado por el proveedor matemático.

Backend Math::BigInt

Parte de CryptX es Math::BigInt::LTM, un backend de Math::BigInt basado en la biblioteca LibTomMath incluida. Es independiente de las APIs criptográficas anteriores, pero se distribuye en la misma distribución y utiliza el mismo motor de enteros grandes del que depende LibTomCrypt.

LICENCIA

Este programa es software libre; puede redistribuirlo y/o modificarlo bajo los mismos términos que Perl.

perl-CryptX

Más Populares