Hashes (std::hash)

Nesta página

std::hash reúne funções determinísticas de digest: algoritmos SHA e MD5 para impressão digital de conteúdo, CRC32 para checksums rápidos, e HMAC para autenticação de mensagens com chave secreta. Todas as funções são computações puras e rodam no sandbox.

SHA-256, SHA-512, SHA-1 e MD5

Cada função retorna o digest em hexadecimal minúsculo. SHA-256 é a escolha padrão; MD5 e SHA-1 apenas para compatibilidade com sistemas legados. O determinismo garante que a mesma entrada sempre produz a mesma saída.

Digests determinísticos com SHA-256/512/1, MD5 e CRC32.

01-sha-md5.zolo

Playground

// Feature: hash.sha256 / hash.sha1 / hash.md5 — hash functions

// When to use: content identity (caching, dedupe), checksums.

// SHA-256 is the default choice; MD5 and SHA-1 only for legacy compatibility.


use std::hash

// Each function returns the lowercase hexadecimal digest representation.

print(hash.sha256("hello"))  // expected: 64 hex chars (2cf24...e9c8c)

print(hash.sha512("hello").len())  // expected: 128

print(hash.sha1("hello"))  // expected: aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d

print(hash.md5("hello"))  // expected: 5d41402abc4b2a76b9719d911017c592


// Hashes are deterministic: same input -> same output.

print(hash.sha256("zolo") == hash.sha256("zolo"))  // expected: true

print(hash.sha256("a") == hash.sha256("b"))  // expected: false


// CRC32: fast, non-cryptographic — good for detecting corruption, bad

// for security.

print(hash.crc32("hello"))  // expected: int

HMAC — autenticação com chave

hash.hmac(algo, chave, mensagem) produz um código de autenticação que não pode ser forjado sem a chave secreta, mesmo que o atacante conheça o algoritmo de hash. Aplicações típicas: validação de webhooks, cookies assinados e tokens HS256.

HMAC-SHA256 para validar webhooks; comparação de MACs com chaves diferentes.

02-hmac.zolo

Playground

// Feature: hash.hmac — Hash-based Message Authentication Code

// When to use: authenticate payloads (webhooks, HS* JWTs, signed cookies).

// Tamper-resistant — even knowing the hash, you can't forge it without the key.


use std::hash

let secret = "my-secret-key"
let payload = "user_id=42&action=transfer"

// hmac(algo, key, message) -> hex digest.

let mac = hash.hmac("sha256", secret, payload)
print(mac.len())  // expected: 64 hex chars


// A different key produces a completely different HMAC (avalanche effect).

let mac2 = hash.hmac("sha256", "another-key", payload)
print(mac == mac2)  // expected: false


// Useful to validate webhooks: compare the header against the expected HMAC.

fn validate_webhook(body: str, signature: str, key: str) -> bool {
  return hash.hmac("sha256", key, body) == signature
}

let ok = validate_webhook(payload, mac, secret)
print(ok)  // expected: true

Desafio

Implemente uma função sign_jwt_payload(payload, secret) que retorne base64_url(header) + "." + base64_url(payload) + "." + hmac_sha256(...). Use std::hash e std::base64 juntos.

Veja também

Editar no GitHub