totp.rs 100.0%

68 of 68 lines run, 29 of 30 functions · run #544 on main · run missed

//! Time-based one-time passwords (RFC 6238, SHA-1, six digits, 30 s) and
//! recovery codes (hub spec §15.3).

use hmac::{Hmac, Mac};
use sha1::Sha1;

pub fn new_secret() -> String {
    let mut b = [0u8; 20];
    rand::RngCore::fill_bytes(&mut rand::rngs::OsRng, &mut b);
    base32::encode(base32::Alphabet::Rfc4648 { padding: false }, &b)
}

fn code_at(secret: &str, counter: u64) -> Option<String> {
    let key = base32::decode(base32::Alphabet::Rfc4648 { padding: false }, secret)?;
    let mut mac = Hmac::<Sha1>::new_from_slice(&key).ok()?;
    mac.update(&counter.to_be_bytes());
    let digest = mac.finalize().into_bytes();
    let offset = (digest[19] & 0x0f) as usize;
    let bin = ((digest[offset] as u32 & 0x7f) << 24)
        | ((digest[offset + 1] as u32) << 16)
        | ((digest[offset + 2] as u32) << 8)
        | digest[offset + 3] as u32;
    Some(format!("{:06}", bin % 1_000_000))
}

/// The current code, for tests and the enrolment check.
pub fn current(secret: &str, now_s: u64) -> Option<String> {
    code_at(secret, now_s / 30)
}

/// Accept the code for this step and its neighbours (one step of drift).
pub fn verify(secret: &str, code: &str, now_s: u64) -> bool {
    let code = code.trim().replace(' ', "");
    let step = now_s / 30;
    [step.wrapping_sub(1), step, step + 1].iter().any(|c| code_at(secret, *c).is_some_and(|x| x == code))
}

/// `otpauth://` URI for authenticator apps.
pub fn uri(site: &str, username: &str, secret: &str) -> String {
    let label = format!("{site}:{username}").replace(' ', "%20");
    format!("otpauth://totp/{label}?secret={secret}&issuer={}&algorithm=SHA1&digits=6&period=30", site.replace(' ', "%20"))
}

/// The provisioning URI as an SVG QR code.
pub fn qr_svg(uri: &str) -> Option<String> {
    let code = qrcode::QrCode::new(uri.as_bytes()).ok()?;
    Some(code.render::<qrcode::render::svg::Color>().min_dimensions(180, 180).quiet_zone(true).build())
}

/// Ten recovery codes; stored as BLAKE3 hashes separated by commas.
pub fn new_recovery_codes() -> (Vec<String>, String) {
    let codes: Vec<String> = (0..10).map(|_| super::random_hex(5)).collect();
    let stored = codes.iter().map(|c| hex::encode(blake3::hash(c.as_bytes()).as_bytes())).collect::<Vec<_>>().join(",");
    (codes, stored)
}

/// Use a recovery code: the remaining stored codes if it matched.
pub fn use_recovery_code(stored: &str, code: &str) -> Option<String> {
    let hash = hex::encode(blake3::hash(code.trim().as_bytes()).as_bytes());
    let all: Vec<&str> = stored.split(',').filter(|s| !s.is_empty()).collect();
    if !all.contains(&hash.as_str()) {
        return None;
    }
    Some(all.into_iter().filter(|h| *h != hash).collect::<Vec<_>>().join(","))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn rfc_6238_vector() {
        // RFC 6238 appendix B, SHA-1, secret "12345678901234567890", 59 s → 94287082 (8 digits); 6 digits are the last six.
        let secret = base32::encode(base32::Alphabet::Rfc4648 { padding: false }, b"12345678901234567890");
        assert_eq!(current(&secret, 59).unwrap(), "287082");
        assert_eq!(current(&secret, 1111111109).unwrap(), "081804");
        assert!(verify(&secret, "287082", 59));
        assert!(verify(&secret, "287 082", 75), "drift of one step");
        assert!(!verify(&secret, "000000", 59));
    }

    #[test]
    fn recovery_codes() {
        let (codes, stored) = new_recovery_codes();
        assert_eq!(codes.len(), 10);
        let rest = use_recovery_code(&stored, &codes[3]).unwrap();
        assert!(use_recovery_code(&rest, &codes[3]).is_none(), "a code is single use");
        assert!(use_recovery_code(&rest, &codes[4]).is_some());
        assert!(qr_svg(&uri("OxygenHub", "andy", &new_secret())).unwrap().contains("<svg"));
    }
}

1		//! Time-based one-time passwords (RFC 6238, SHA-1, six digits, 30 s) and
2		//! recovery codes (hub spec §15.3).
3
4		use hmac::{Hmac, Mac};
5		use sha1::Sha1;
6
7	3×	pub fn new_secret() -> String {
8	3×	let mut b = [0u8; 20];
9	3×	rand::RngCore::fill_bytes(&mut rand::rngs::OsRng, &mut b);
10	3×	base32::encode(base32::Alphabet::Rfc4648 { padding: false }, &b)
11	3×	}
12
13	29×	fn code_at(secret: &str, counter: u64) -> Option<String> {
14	29×	let key = base32::decode(base32::Alphabet::Rfc4648 { padding: false }, secret)?;
15	29×	let mut mac = Hmac::<Sha1>::new_from_slice(&key).ok()?;
16	29×	mac.update(&counter.to_be_bytes());
17	29×	let digest = mac.finalize().into_bytes();
18	29×	let offset = (digest[19] & 0x0f) as usize;
19	29×	let bin = ((digest[offset] as u32 & 0x7f) << 24)
20	29×	\| ((digest[offset + 1] as u32) << 16)
21	29×	\| ((digest[offset + 2] as u32) << 8)
22	29×	\| digest[offset + 3] as u32;
23	29×	Some(format!("{:06}", bin % 1_000_000))
24	29×	}
25
26		/// The current code, for tests and the enrolment check.
27	7×	pub fn current(secret: &str, now_s: u64) -> Option<String> {
28	7×	code_at(secret, now_s / 30)
29	7×	}
30
31		/// Accept the code for this step and its neighbours (one step of drift).
32	10×	pub fn verify(secret: &str, code: &str, now_s: u64) -> bool {
33	10×	let code = code.trim().replace(' ', "");
34	10×	let step = now_s / 30;
35	22×	[step.wrapping_sub(1), step, step + 1].iter().any(\|c\| code_at(secret, *c).is_some_and(\|x\| x == code))
36	10×	}
37
38		/// `otpauth://` URI for authenticator apps.
39	3×	pub fn uri(site: &str, username: &str, secret: &str) -> String {
40	3×	let label = format!("{site}:{username}").replace(' ', "%20");
41	3×	format!("otpauth://totp/{label}?secret={secret}&issuer={}&algorithm=SHA1&digits=6&period=30", site.replace(' ', "%20"))
42	3×	}
43
44		/// The provisioning URI as an SVG QR code.
45	3×	pub fn qr_svg(uri: &str) -> Option<String> {
46	3×	let code = qrcode::QrCode::new(uri.as_bytes()).ok()?;
47	3×	Some(code.render::<qrcode::render::svg::Color>().min_dimensions(180, 180).quiet_zone(true).build())
48	3×	}
49
50		/// Ten recovery codes; stored as BLAKE3 hashes separated by commas.
51	3×	pub fn new_recovery_codes() -> (Vec<String>, String) {
52	30×	let codes: Vec<String> = (0..10).map(\|_\| super::random_hex(5)).collect();
53	30×	let stored = codes.iter().map(\|c\| hex::encode(blake3::hash(c.as_bytes()).as_bytes())).collect::<Vec<_>>().join(",");
54	3×	(codes, stored)
55	3×	}
56
57		/// Use a recovery code: the remaining stored codes if it matched.
58	4×	pub fn use_recovery_code(stored: &str, code: &str) -> Option<String> {
59	4×	let hash = hex::encode(blake3::hash(code.trim().as_bytes()).as_bytes());
60	38×	let all: Vec<&str> = stored.split(',').filter(\|s\| !s.is_empty()).collect();
61	4×	if !all.contains(&hash.as_str()) {
62	2×	return None;
63	2×	}
64	19×	Some(all.into_iter().filter(\|h\| *h != hash).collect::<Vec<_>>().join(","))
65	4×	}
66
67		#[cfg(test)]
68		mod tests {
69		use super::*;
70
71		#[test]
72	1×	fn rfc_6238_vector() {
73		// RFC 6238 appendix B, SHA-1, secret "12345678901234567890", 59 s → 94287082 (8 digits); 6 digits are the last six.
74	1×	let secret = base32::encode(base32::Alphabet::Rfc4648 { padding: false }, b"12345678901234567890");
75	1×	assert_eq!(current(&secret, 59).unwrap(), "287082");
76	1×	assert_eq!(current(&secret, 1111111109).unwrap(), "081804");
77	1×	assert!(verify(&secret, "287082", 59));
78	1×	assert!(verify(&secret, "287 082", 75), "drift of one step");
79	1×	assert!(!verify(&secret, "000000", 59));
80	1×	}
81
82		#[test]
83	1×	fn recovery_codes() {
84	1×	let (codes, stored) = new_recovery_codes();
85	1×	assert_eq!(codes.len(), 10);
86	1×	let rest = use_recovery_code(&stored, &codes[3]).unwrap();
87	1×	assert!(use_recovery_code(&rest, &codes[3]).is_none(), "a code is single use");
88	1×	assert!(use_recovery_code(&rest, &codes[4]).is_some());
89	1×	assert!(qr_svg(&uri("OxygenHub", "andy", &new_secret())).unwrap().contains("<svg"));
90	1×	}
91		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/auth/totp.rs 100.0%

Keyboard