use super::funejson::Value; use super::crypto_hmac_sha1::hmac_sha1; use super::crypto_hmac_sha256::hmac_sha256; use super::encoding_base32_base32_decode::base32_decode; const MAX_SAFE: i64 = 9007199254740991; /// Whole number from 0 to 2^53 - 1: the range all three languages agree on. pub fn is_totp_whole(value: i64) -> bool { (0..=MAX_SAFE).contains(&value) } pub fn check_totp_digits(digits: i64) { if !(6..=8).contains(&digits) { panic!("digits must be 6, 7 or 8"); } } pub fn check_totp_algorithm(algorithm: &str) { if algorithm != "SHA1" && algorithm != "SHA256" { panic!("algorithm must be SHA1 or SHA256"); } } pub fn check_totp_settings(settings: &TotpSettings) { check_totp_algorithm(&settings.algorithm); check_totp_digits(settings.digits); if !is_totp_whole(settings.period) || settings.period < 1 { panic!("period must be a whole number of seconds, 1 or more"); } } /// The secret's bytes. Old Google Authenticator secrets are 80 bits, so 10 /// bytes is the least accepted; new ones from totp_secret are 16 or more. pub fn totp_secret_key(secret: &str) -> Vec { let key = base32_decode(secret); if key.len() < 10 { panic!("secret must decode to at least 10 bytes"); } key } /// RFC 4226 section 5.3: HMAC of the 8-byte big-endian counter, then dynamic /// truncation. pub fn hotp_from_key(key: &[i64], counter: i64, digits: i64, algorithm: &str) -> String { let message: Vec = (counter as u64).to_be_bytes().iter().map(|b| *b as i64).collect(); let mac = if algorithm == "SHA1" { hmac_sha1(key, &message) } else { hmac_sha256(key, &message) }; let offset = (mac[mac.len() - 1] & 15) as usize; let binary = ((mac[offset] & 127) << 24) | (mac[offset + 1] << 16) | (mac[offset + 2] << 8) | mac[offset + 3]; let modulus = 10i64.pow(digits as u32); format!("{:0width$}", binary % modulus, width = digits as usize) } /// The RFC 4226 HOTP code for one counter value. /// /// # Panics /// Panics on a counter outside 0 to 2^53 - 1, digits other than 6-8, an /// unknown algorithm, or a secret that is not base32 of at least 10 bytes. pub fn hotp_code(secret: &str, counter: i64, digits: i64, algorithm: &str) -> String { if !is_totp_whole(counter) { panic!("counter must be a whole number from 0 to 2^53 - 1"); } check_totp_digits(digits); check_totp_algorithm(algorithm); hotp_from_key(&totp_secret_key(secret), counter, digits, algorithm) } pub fn totp_text_arg(value: &Value, message: &str) -> String { match value { Value::Str(s) => s.clone(), _ => panic!("{}", message), } } pub fn totp_int_arg(value: &Value, message: &str) -> i64 { match value { Value::Int(i) => *i, _ => panic!("{}", message), } } pub fn totp_settings_from_value(value: &Value) -> TotpSettings { TotpSettings { algorithm: totp_text_arg(value.get("algorithm"), "algorithm must be SHA1 or SHA256"), digits: totp_int_arg(value.get("digits"), "digits must be 6, 7 or 8"), period: totp_int_arg(value.get("period"), "period must be a whole number of seconds, 1 or more"), } } pub fn fune_vector(args: &[Value]) -> Value { Value::str(&hotp_code( &totp_text_arg(&args[0], "base32 text must be a string"), totp_int_arg(&args[1], "counter must be a whole number from 0 to 2^53 - 1"), totp_int_arg(&args[2], "digits must be 6, 7 or 8"), &totp_text_arg(&args[3], "algorithm must be SHA1 or SHA256"), )) }