use super::{Credential, CredentialModel, CredentialType};
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::secure::totp::TotpHandler;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
struct TotpSecretData {
secret: String,
step: u64,
digits: u32,
}
impl TotpSecretData {
fn from_json(secret_data: &str) -> GarrisonResult<Self> {
serde_json::from_str(secret_data).map_err(|e| {
GarrisonError::InvalidParam(format!(
"TOTP secret_data 解析失败(期望 JSON {{secret, step, digits}}): {}",
e
))
})
}
fn to_handler(&self) -> GarrisonResult<TotpHandler> {
let secret_bytes = TotpHandler::secret_from_base32(&self.secret)?;
TotpHandler::new(secret_bytes, self.step, self.digits)
}
}
#[cfg_attr(
feature = "account-credential-zeroize",
derive(zeroize::Zeroize, zeroize::ZeroizeOnDrop)
)]
pub struct TotpCredential {
model: CredentialModel,
}
impl TotpCredential {
pub fn new(model: CredentialModel) -> Self {
Self { model }
}
pub fn generate_current(&self) -> GarrisonResult<String> {
let data = TotpSecretData::from_json(&self.model.secret_data)?;
let handler = data.to_handler()?;
let now = chrono::Utc::now().timestamp();
Ok(handler.generate(now))
}
pub async fn verify_with_replay_check(
&self,
input: &str,
login_id: &str,
dao: &dyn GarrisonDao,
) -> GarrisonResult<bool> {
let data = TotpSecretData::from_json(&self.model.secret_data)?;
let handler = data.to_handler()?;
let now = chrono::Utc::now().timestamp();
handler
.validate_and_consume(login_id, input, now, dao)
.await
}
}
#[async_trait]
impl Credential for TotpCredential {
fn credential_type(&self) -> CredentialType {
"totp"
}
fn to_model(&self) -> CredentialModel {
self.model.clone()
}
async fn verify(&self, input: &str) -> GarrisonResult<bool> {
let data = TotpSecretData::from_json(&self.model.secret_data)?;
let handler = data.to_handler()?;
let now = chrono::Utc::now().timestamp();
Ok(handler.validate(input, now))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn make_totp_cred() -> (TotpCredential, String) {
let secret_data = r#"{"secret":"GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ","step":30,"digits":6}"#;
let model = CredentialModel {
id: "cred-totp-001".to_string(),
user_id: "alice".to_string(),
credential_type: "totp".to_string(),
secret_data: secret_data.to_string(),
label: Some("iPhone TOTP".to_string()),
created_at: 0,
enabled: true,
priority: 0,
};
let cred = TotpCredential::new(model);
let code = cred.generate_current().expect("generate_current 应成功");
(cred, code)
}
#[test]
fn totp_credential_type_returns_totp() {
let (cred, _) = make_totp_cred();
assert_eq!(cred.credential_type(), "totp");
}
#[test]
fn totp_credential_to_model_returns_original() {
let (cred, _) = make_totp_cred();
let model = cred.to_model();
assert_eq!(model.id, "cred-totp-001");
assert_eq!(model.user_id, "alice");
assert_eq!(model.credential_type, "totp");
assert!(model.secret_data.contains("GEZDGNBVGY3TQOJQ"));
assert_eq!(model.label, Some("iPhone TOTP".to_string()));
}
#[tokio::test]
async fn totp_credential_verify_correct_code() {
let (cred, code) = make_totp_cred();
let result = cred.verify(&code).await.expect("verify 应成功");
assert!(result, "正确 TOTP code 应校验通过");
}
#[tokio::test]
async fn totp_credential_verify_wrong_code() {
let (cred, _) = make_totp_cred();
let result = cred
.verify("000000")
.await
.expect("verify 应成功(返回 false 而非报错)");
assert!(!result, "错误 TOTP code 应校验失败");
}
#[tokio::test]
async fn totp_credential_invalid_secret_data_returns_error() {
let model = CredentialModel {
id: "bad".to_string(),
user_id: "alice".to_string(),
credential_type: "totp".to_string(),
secret_data: "not-json".to_string(),
label: None,
created_at: 0,
enabled: true,
priority: 0,
};
let cred = TotpCredential::new(model);
let result = cred.verify("123456").await;
assert!(
result.is_err(),
"非法 secret_data 应返回错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn totp_credential_invalid_base32_returns_error() {
let model = CredentialModel {
id: "bad2".to_string(),
user_id: "alice".to_string(),
credential_type: "totp".to_string(),
secret_data: r#"{"secret":"invalid!base32","step":30,"digits":6}"#.to_string(),
label: None,
created_at: 0,
enabled: true,
priority: 0,
};
let cred = TotpCredential::new(model);
let result = cred.verify("123456").await;
assert!(result.is_err(), "非法 Base32 应返回错误");
}
#[test]
fn totp_credential_generate_current_returns_6_digits() {
let (cred, _) = make_totp_cred();
let code = cred.generate_current().expect("generate_current 应成功");
assert_eq!(code.len(), 6, "验证码应为 6 位");
assert!(
code.chars().all(|c| c.is_ascii_digit()),
"验证码应全为数字,实际: {}",
code
);
}
#[tokio::test]
async fn totp_credential_usable_as_dyn_credential() {
let (cred, code) = make_totp_cred();
let dyn_cred: Box<dyn Credential> = Box::new(cred);
assert_eq!(dyn_cred.credential_type(), "totp");
let result = dyn_cred.verify(&code).await.expect("verify 应成功");
assert!(result, "dyn Credential 正确 code 应校验通过");
}
#[tokio::test]
async fn totp_credential_verify_with_replay_check_rejects_replay() {
let (cred, code) = make_totp_cred();
let dao = crate::dao::tests::MockDao::new();
let first = cred
.verify_with_replay_check(&code, "user-001", &dao)
.await
.expect("首次校验不应报错");
assert!(first, "首次应通过");
let second = cred
.verify_with_replay_check(&code, "user-001", &dao)
.await
.expect("二次校验不应报错");
assert!(!second, "同一验证码二次使用应被拒绝(C-5 重放防护)");
}
}