use std::sync::OnceLock;
use argon2::password_hash::rand_core::OsRng;
use argon2::password_hash::{PasswordHash, SaltString};
use argon2::{Argon2, PasswordVerifier};
use async_trait::async_trait;
use puerto_nucleo::auth::{ErrorHash, HasherContrasena};
pub fn hash_contrasena(password: &str) -> Result<String, ErrorHash> {
let salt = SaltString::generate(&mut OsRng);
argon2::PasswordHasher::hash_password(&Argon2::default(), password.as_bytes(), &salt)
.map(|hash| hash.to_string())
.map_err(|err| {
tracing::error!(error = %err, "hash_contrasena falló");
ErrorHash
})
}
pub fn verificar_contrasena(password: &str, hash: &str) -> bool {
let Ok(parsed) = PasswordHash::new(hash) else {
tracing::warn!("verificar_contrasena: el hash guardado no es una cadena PHC");
return false;
};
Argon2::default()
.verify_password(password.as_bytes(), &parsed)
.is_ok()
}
fn decoy() -> Option<&'static str> {
static DECOY: OnceLock<Option<String>> = OnceLock::new();
DECOY
.get_or_init(|| hash_contrasena("puerto: no account has this password").ok())
.as_deref()
}
#[derive(Debug, Clone, Copy, Default)]
pub struct HasherArgon2;
impl HasherArgon2 {
pub fn new() -> Self {
Self
}
}
#[async_trait]
impl HasherContrasena for HasherArgon2 {
async fn hash(&self, password: &str) -> Result<String, ErrorHash> {
let password = password.to_string();
tokio::task::spawn_blocking(move || hash_contrasena(&password))
.await
.map_err(|err| {
tracing::error!(error = %err, "hash: falló la tarea bloqueante");
ErrorHash
})?
}
async fn verificar(&self, password: &str, hash: Option<String>) -> bool {
let password = password.to_string();
tokio::task::spawn_blocking(move || match hash {
Some(hash) => verificar_contrasena(&password, &hash),
None => {
if let Some(decoy) = decoy() {
let _ = verificar_contrasena(&password, decoy);
}
false
}
})
.await
.unwrap_or(false)
}
}