use argon2::password_hash::{Error as PasswordHashError, PasswordHash, SaltString};
use argon2::{Argon2, PasswordHasher, PasswordVerifier};
use rand_core::OsRng;
use std::sync::Arc;
use tokio::sync::Semaphore;
use yang_base::BaseError;
const DUMMY_PASSWORD_HASH: &str = "$argon2id$v=19$m=19456,t=2,p=1$KeT08Pv9+LVzDxDOmS18Tw$f1ITNKuxgUMXlkesQPqcEpIDZlQZ8FOm1wadvq9lxiU";
#[derive(Clone)]
pub struct PasswordEngine {
permits: Arc<Semaphore>,
}
impl PasswordEngine {
pub fn new(max_concurrency: usize) -> Result<Self, BaseError> {
if max_concurrency == 0 {
return Err(BaseError::ConfigError(
"argon2_max_concurrency 必须大于 0".to_string(),
));
}
Ok(Self {
permits: Arc::new(Semaphore::new(max_concurrency)),
})
}
pub async fn hash(&self, password: &str) -> Result<String, BaseError> {
let password = password.to_owned();
self.run_blocking(move || {
let salt = SaltString::generate(&mut OsRng);
Argon2::default()
.hash_password(password.as_bytes(), &salt)
.map(|value| value.to_string())
.map_err(|_| BaseError::Unknown("密码哈希失败".to_string()))
})
.await
}
pub async fn verify(&self, password: &str, encoded: &str) -> Result<bool, BaseError> {
let password = password.to_owned();
let encoded = encoded.to_owned();
self.run_blocking(move || {
let parsed = PasswordHash::new(&encoded)
.map_err(|_| BaseError::Unknown("数据库中的密码哈希格式无效".to_string()))?;
match Argon2::default().verify_password(password.as_bytes(), &parsed) {
Ok(()) => Ok(true),
Err(PasswordHashError::Password) => Ok(false),
Err(_) => Err(BaseError::Unknown("密码校验失败".to_string())),
}
})
.await
}
pub async fn verify_or_dummy(
&self,
password: &str,
encoded: Option<&str>,
) -> Result<bool, BaseError> {
match encoded {
Some(encoded) => self.verify(password, encoded).await,
None => self
.verify(password, DUMMY_PASSWORD_HASH)
.await
.map(|_| false),
}
}
async fn run_blocking<T>(
&self,
operation: impl FnOnce() -> Result<T, BaseError> + Send + 'static,
) -> Result<T, BaseError>
where
T: Send + 'static,
{
let permit = Arc::clone(&self.permits)
.acquire_owned()
.await
.map_err(|_| BaseError::Unknown("密码执行器已关闭".to_string()))?;
tokio::task::spawn_blocking(move || {
let _permit = permit;
operation()
})
.await
.map_err(|error| BaseError::Unknown(format!("密码任务执行失败: {error}")))?
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn password_hash_round_trip() {
let engine =
PasswordEngine::new(1).unwrap_or_else(|error| panic!("密码执行器应构建成功: {error}"));
let encoded = engine
.hash("correct-horse-battery-staple")
.await
.unwrap_or_else(|error| panic!("密码应成功哈希: {error}"));
assert!(engine
.verify("correct-horse-battery-staple", &encoded)
.await
.unwrap_or_else(|error| panic!("密码应成功校验: {error}")));
assert!(!engine
.verify("wrong-password", &encoded)
.await
.unwrap_or_else(|error| panic!("错误密码应得到 false: {error}")));
assert!(!encoded.contains("correct-horse-battery-staple"));
}
#[tokio::test]
async fn dummy_hash_parameters_match_engine_output() {
let engine =
PasswordEngine::new(1).unwrap_or_else(|error| panic!("密码执行器应构建成功: {error}"));
let real = engine
.hash("parameter-probe")
.await
.unwrap_or_else(|error| panic!("密码应成功哈希: {error}"));
let dummy_segments: Vec<&str> = DUMMY_PASSWORD_HASH.split('$').take(4).collect();
let real_segments: Vec<&str> = real.split('$').take(4).collect();
assert_eq!(
dummy_segments, real_segments,
"dummy 哈希参数已漂移,请用 PasswordEngine::hash 重新生成 DUMMY_PASSWORD_HASH"
);
}
#[tokio::test]
async fn verify_or_dummy_runs_full_pipeline_for_none() {
let engine =
PasswordEngine::new(1).unwrap_or_else(|error| panic!("密码执行器应构建成功: {error}"));
assert!(!engine
.verify_or_dummy("any-password", None)
.await
.unwrap_or_else(|error| panic!("None 分支应走完整校验并返回 false: {error}")));
assert!(!engine
.verify("any-password", DUMMY_PASSWORD_HASH)
.await
.unwrap_or_else(|error| panic!("dummy 哈希应能正常校验: {error}")));
}
#[tokio::test]
async fn verify_or_dummy_matches_verify_for_real_hash() {
let engine =
PasswordEngine::new(1).unwrap_or_else(|error| panic!("密码执行器应构建成功: {error}"));
let encoded = engine
.hash("real-password")
.await
.unwrap_or_else(|error| panic!("密码应成功哈希: {error}"));
assert!(engine
.verify_or_dummy("real-password", Some(&encoded))
.await
.unwrap_or_else(|error| panic!("正确密码应通过等时校验: {error}")));
assert!(!engine
.verify_or_dummy("wrong-password", Some(&encoded))
.await
.unwrap_or_else(|error| panic!("错误密码应校验失败: {error}")));
}
#[test]
fn zero_concurrency_is_rejected() {
assert!(matches!(
PasswordEngine::new(0),
Err(BaseError::ConfigError(message)) if message.contains("argon2_max_concurrency")
));
}
}