Funções de derivação de chaves - PBKDF2, HKDF, scrypt, Argon2
Transforme senhas fracas em chaves criptográficas fortes. Proteção contra ataques de força bruta e rainbow tables.
Vencedor da Password Hashing Competition. Resistente a ataques GPU/ASIC com uso de memória configurável.
HMAC-based Key Derivation Function. Ideal para expandir material chave em múltiplas chaves derivadas.
Padrão NIST amplamente adotado. Múltiplas iterações para aumentar custo computacional de ataques.
| Tipo | Descrição | Uso Principal |
|---|---|---|
Argon2id |
Argon2 modo híbrido | Senhas de usuários |
Argon2i |
Resistente a side-channels | Derivação de chaves |
Argon2d |
Máxima resistência a GPU | Aplicações específicas |
Pbkdf2 |
PBKDF2 com HMAC-SHA256 | Compatibilidade legada |
Hkdf |
HMAC-based KDF | Expansão de chaves |
Scrypt |
Memory-hard KDF | Derivação intensiva |
use avx_kdf::Argon2id;
fn main() {
let password = b"senha_usuario_123";
let salt = b"salt_aleatorio_unico"; // 16+ bytes
// Configuração recomendada
let config = Argon2id::default_config()
.memory_cost(64 * 1024) // 64 MB
.time_cost(3) // 3 iterações
.parallelism(4); // 4 threads
// Derivar chave de 32 bytes
let mut key = [0u8; 32];
Argon2id::derive_key(&config, password, salt, &mut key)
.expect("Falha na derivação");
println!("Chave derivada: {}", hex::encode(key));
}use avx_kdf::Hkdf;
use avx_hash::Sha256;
fn main() {
// Material chave inicial
let ikm = b"material_chave_compartilhado";
let salt = b"application_salt";
let info = b"context_info";
// Extrair e expandir
let hkdf = Hkdf::::new(Some(salt), ikm);
// Derivar múltiplas chaves
let mut key1 = [0u8; 32];
let mut key2 = [0u8; 32];
hkdf.expand(b"encryption_key", &mut key1).unwrap();
hkdf.expand(b"mac_key", &mut key2).unwrap();
println!("✅ Chaves derivadas com HKDF!");
} use avx_kdf::Pbkdf2;
use avx_hash::Sha256;
fn main() {
let password = b"SenhaForte!2024";
let salt = b"random_salt_16bytes";
let iterations = 100_000; // Recomendado: 100k+
let mut key = [0u8; 32];
Pbkdf2::::derive(
password,
salt,
iterations,
&mut key
).expect("Erro no PBKDF2");
println!("PBKDF2 key: {}", hex::encode(key));
} use avx_kdf::Argon2id;
fn hash_password(password: &[u8]) -> String {
let salt = generate_random_salt();
let config = Argon2id::default_config();
let mut hash = [0u8; 32];
Argon2id::derive_key(&config, password, &salt, &mut hash)
.unwrap();
// Codificar hash + salt + params
encode_hash(&hash, &salt, &config)
}
fn verify_password(password: &[u8], encoded: &str) -> bool {
let (hash, salt, config) = decode_hash(encoded);
let mut computed = [0u8; 32];
Argon2id::derive_key(&config, password, &salt, &mut computed)
.unwrap();
// Comparação em tempo constante
constant_time_eq(&hash, &computed)
}pub fn default_config() -> Config
Retorna configuração padrão recomendada.
pub fn derive_key(config: &Config, password: &[u8], salt: &[u8], output: &mut [u8]) -> Result<(), KdfError>
Deriva chave usando Argon2id.
pub fn new(salt: Option<&[u8]>, ikm: &[u8]) -> Self
Cria instância HKDF com salt opcional.
pub fn expand(&self, info: &[u8], output: &mut [u8]) -> Result<(), KdfError>
Expande material chave com contexto.
pub fn derive(password: &[u8], salt: &[u8], iterations: u32, output: &mut [u8]) -> Result<(), KdfError>
Deriva chave usando PBKDF2.
Hash seguro de senhas de usuários com Argon2id. Proteção contra rainbow tables e força bruta.
Derivar chaves de criptografia a partir de senhas para proteção de arquivos e dados.
HKDF para derivar múltiplas chaves a partir de segredo compartilhado em protocolos como TLS.
Geração de tokens seguros e derivação de chaves de sessão para autenticação.
AVX KDF é software proprietário desenvolvido pela Ávila Inc. Todos os direitos reservados.
Para licenciamento comercial, entre em contato: nicolas@avila.inc