use super::funejson::Value; use super::auth_totp_hotp_code::{ check_totp_settings, hotp_from_key, totp_int_arg, totp_secret_key, totp_settings_from_value, totp_text_arg, }; use super::auth_totp_totp_code::check_totp_now; use super::crypto_constant_time_equal::constant_time_equal; fn ascii(text: &str) -> Vec { text.bytes().map(|b| b as i64).collect() } /// Checks a typed code against the steps around now (centred on the user's /// known drift), closest first, earlier first on a tie. Every step in the /// window is compared in constant time. A step at or before last_used_step /// is refused as replayed. /// /// # Panics /// Panics on a bad now, settings, window (0-10), drift (-1000 to 1000) or /// secret. pub fn verify_totp( secret: &str, code: &str, now: i64, settings: &TotpSettings, window: i64, drift: i64, last_used_step: Option, ) -> TotpCheck { check_totp_now(now); check_totp_settings(settings); if !(0..=10).contains(&window) { panic!("window must be a whole number from 0 to 10"); } if !(-1000..=1000).contains(&drift) { panic!("drift must be a whole number from -1000 to 1000"); } let key = totp_secret_key(secret); let typed: String = code.chars().filter(|c| *c != ' ').collect(); if typed.len() as i64 != settings.digits || !typed.bytes().all(|b| b.is_ascii_digit()) { return TotpCheck { valid: false, step: None, drift: None, reason: Some("malformed_code".to_string()) }; } let expected = now / settings.period; let centre = expected + drift; let typed_bytes = ascii(&typed); let mut accepted: Option = None; let mut replayed = false; for distance in 0..=window { let steps = if distance == 0 { vec![centre] } else { vec![centre - distance, centre + distance] }; for step in steps { if step < 0 { continue; } let made = hotp_from_key(&key, step, settings.digits, &settings.algorithm); if !constant_time_equal(&ascii(&made), &typed_bytes) { continue; } match last_used_step { Some(last) if step <= last => replayed = true, _ => { if accepted.is_none() { accepted = Some(step); } } } } } match accepted { Some(step) => TotpCheck { valid: true, step: Some(step), drift: Some(step - expected), reason: None }, None => TotpCheck { valid: false, step: None, drift: None, reason: Some(if replayed { "replayed" } else { "wrong_code" }.to_string()), }, } } pub fn totp_check_to_value(check: &TotpCheck) -> Value { let int_or_null = |v: Option| match v { Some(i) => Value::Int(i), None => Value::Null, }; Value::obj(vec![ ("valid", Value::Bool(check.valid)), ("step", int_or_null(check.step)), ("drift", int_or_null(check.drift)), ( "reason", match &check.reason { Some(r) => Value::str(r), None => Value::Null, }, ), ]) } pub fn fune_vector(args: &[Value]) -> Value { let last_used_step = match &args[6] { Value::Null => None, Value::Int(i) => Some(*i), _ => panic!("lastUsedStep must be a whole number or null"), }; totp_check_to_value(&verify_totp( &totp_text_arg(&args[0], "base32 text must be a string"), &totp_text_arg(&args[1], "code must be text"), totp_int_arg(&args[2], "now must be a whole number of seconds from 0 to 2^53 - 1"), &totp_settings_from_value(&args[3]), totp_int_arg(&args[4], "window must be a whole number from 0 to 10"), totp_int_arg(&args[5], "drift must be a whole number from -1000 to 1000"), last_used_step, )) }