Criptografía (std::crypto)
En esta página
std::crypto cubre la generación de IDs únicos y la aleatoriedad segura.
Las funciones de hash y HMAC residen en std::hash (página siguiente). Al
depender de la entropía del sistema operativo, este módulo no está disponible en
el sandbox WASM — ejecuta los ejemplos con zolo run en la línea de comandos.
UUID y NanoID
crypto.uuid() genera un UUID v4 aleatorio en el formato canónico con guiones.
crypto.nanoid() produce un identificador URL-safe de 21 caracteres — más
compacto que UUID e igual de improbable de colisionar. Acepta un tamaño
personalizado mediante nanoid(n).
UUID v4 y NanoID con tamaño predeterminado y personalizado.
// Feature: crypto.uuid / crypto.nanoid — unique IDs
// When to use: primary keys, request IDs, session tokens.
// parity-normalize: uuid
// crypto.uuid() is random per run; the canonical UUID is collapsed to <UUID>
// on both backends. A `nil` (unbridged) would NOT match <UUID>, so a real
// native regression still diverges. nanoid lengths (21/10) stay exact.
use std::crypto
// UUID v4 (random, 128 bits, canonical hyphenated format).
let id = crypto.uuid()
print(id) // expected: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
// nanoid: 21 chars URL-safe — collisions extremely unlikely and more compact than UUID.
let nid = crypto.nanoid()
print(nid.len()) // expected: 21
// nanoid(n) with custom length.
let short = crypto.nanoid(10)
print(short.len()) // expected: 10
Requiere la CLI o el host de Zolo; ábrelo en el playground o ejecútalo localmente.
Bytes e enteros aleatorios
crypto.random_bytes(n) devuelve un array de n bytes con entropía del SO,
adecuado para salts y tokens. crypto.random_int(min, max) proporciona un
entero uniformemente distribuido en el intervalo inclusivo [min, max].
Generación de bytes aleatorios y enteros en rango — útil para salts y simulaciones.
// Feature: crypto.random_bytes / crypto.random_int — secure randomness
// When to use: salt for hashing, secrets, tokens, crypto simulations.
use std::crypto
// random_bytes(n) -> array of N bytes (0..255).
let bytes = crypto.random_bytes(16)
print(bytes.len()) // expected: 16
// random_int(min, max) -> integer in the range [min, max] (inclusive).
let dice = crypto.random_int(1, 6)
print(dice >= 1 && dice <= 6) // expected: true
let port = crypto.random_int(1024, 65535)
print(port >= 1024) // expected: true
Requiere la CLI o el host de Zolo; ábrelo en el playground o ejecútalo localmente.
Hashes y HMAC vía std::hash
El tercer archivo de esta carpeta demuestra las funciones de std::hash
(SHA-256, MD5, HMAC-SHA256 y CRC32). El contenido completo está documentado en
la siguiente sección (Hash); el ejemplo a continuación sirve como referencia
cruzada.
Referencia rápida de hash.sha256, hash.hmac y hash.crc32.
// Feature: cryptographic hashes via the `hash` module
// When to use: integrity, fingerprints, message authentication.
// Note: `crypto` handles randomness/IDs; hashes live in `hash`.
use std::hash
// SHA-256 — deterministic 32-byte fingerprint (64 hex chars).
print(hash.sha256("zolo")) // expected: 64 hex chars
// SHA-512 / SHA-1 / MD5 also available (legacy: prefer sha256+).
print(hash.sha1("zolo").len()) // expected: 40 (hex of 20 bytes)
print(hash.md5("zolo").len()) // expected: 32 (hex of 16 bytes)
// HMAC-SHA256 — symmetric authentication (message + secret key).
let mac = hash.hmac("sha256", "secret-key", "important message")
print(mac.len()) // expected: 64 hex chars
// CRC32 (non-cryptographic, but useful for cheap checksums).
print(hash.crc32("zolo")) // expected: int
Requiere la CLI o el host de Zolo; ábrelo en el playground o ejecútalo localmente.
Consulta también