Skip to content

argon2 ​

El namespace argon2 proporciona hashing de contraseñas Argon2id con parámetros configurables.

tyrus
import { CryptoError, argon2, jwt, rand } from "tyrus:crypto";

interface SessionClaims {
    role: string;
}

// Password hashing
match (await argon2.hash("my-password")) {
    Ok(hash) => {
        match (await argon2.verify(hash, "my-password")) {
            Ok(valid) => { print(valid); } // true
            Err(error) => { printError(error.code); } // ERR_CRYPTO_ARGON2_*
        }
        match (argon2.needsRehash(hash)) {
            Ok(migrate) => { print(migrate); } // false
            Err(error) => { printError(error.code); } // ERR_CRYPTO_ARGON2_INVALID_HASH
        }
    }
    Err(error) => { printError(error.code); } // ERR_CRYPTO_ARGON2_*
}

// JWT HMAC requires at least 32 bytes of secret material.
try {
    const key: string = "0123456789abcdef0123456789abcdef";
    const inputClaims: SessionClaims = { role: "reader" };
    const signed: Result<string, CryptoError> = jwt.sign(inputClaims, key, { algorithm: "HS384", expiresIn: "1h", subject: "123" });
    match (signed) {
        Ok(token) => {
            const verified: Result<SessionClaims, CryptoError> = jwt.verify<SessionClaims>(token, key, { algorithms: ["HS384"], subject: "123" });
            match (verified) {
                Ok(claims) => {
                    print(claims.role); // reader
                }
                Err(error) => { printError(error.code); } // ERR_CRYPTO_*
            }
        }
        Err(error) => { printError(error.code); } // ERR_CRYPTO_*
    }
} catch (error: Error) {
    printError(error.message);
}

// Secure random
const id: string = rand.uuidv7();
try {
    const bytes: u8[] = rand.randomBytes(32);
    print(bytes.length);
} catch (error: Error) {
    printError(error.message);
}

Funciones ​

FunciónFirma
argon2.hash(string | u8[], options?) => Promise<Result<string, CryptoError>>
argon2.verify(string, string | u8[], options?) => Promise<Result<boolean, CryptoError>>
argon2.needsRehash(string) => Result<boolean, CryptoError>

argon2.hash cumple con Ok(hash) si tiene éxito y Err(CryptoError) ante una entrada u opciones no válidas, falta de cupos de concurrencia, fallos del generador aleatorio o del worker. Usa Argon2id con salt aleatorio de 16 bytes, salida de 32 bytes y el perfil predeterminado m=65536, t=3, p=4. Las opciones pueden definir type: "argon2id", memoryCost de 19.456 a 262.144 KiB, timeCost de 2 a 10, parallelism de 1 a 16 y un secret binario no vacío de hasta 1.024 bytes. Las contraseñas textuales y binarias se limitan a 1.024 bytes.

argon2.verify cumple con Ok(matches) para un hash válido y Err(CryptoError) para cadenas PHC malformadas, parámetros no válidos, falta del pepper requerido, falta de cupos de concurrencia o fallo del worker. Limita las cadenas PHC a 4 KiB y valida los parámetros no confiables antes de asignar trabajo. Un hash con pepper contiene un marcador autenticado no secreto; omitir secret devuelve ERR_CRYPTO_ARGON2_PEPPER_REQUIRED, mientras que proporcionar un secret incorrecto devuelve Ok(false). Almacene y rote el pepper por separado de los hashes de contraseña.

argon2.needsRehash devuelve Ok(true) cuando la cadena PHC es válida, pero su algoritmo, versión, parámetros, longitud del salt o longitud de salida difieren del perfil predeterminado. Las cadenas PHC no válidas o demasiado grandes devuelven Err(CryptoError) con el código ERR_CRYPTO_ARGON2_INVALID_HASH.

Límite de concurrencia

Como máximo cuatro operaciones Argon2 se ejecutan simultáneamente. Las llamadas adicionales se cumplen con Err(CryptoError) y el código ERR_CRYPTO_ARGON2_BUSY.