session.rs 95.6%

43 of 45 lines run, 12 of 17 functions · run #31 on main · run missed

//! The owner's browser sign-in, shared by Radar and the API (spec §8.3): the owner's CLI signs a request for a
//! one-time link (`POST /radar/link`, valid 60 s); opening it starts a
//! browser session whose events carry that signed request as their proof
//! (level 2). The passkey (level 3) is 0.2. Sessions live in memory: a
//! restart signs the browser out.

use rand::RngCore;
use std::collections::HashMap;
use std::sync::Mutex;

/// How long a sign-in link is good for, and a session.
pub const LINK_MS: u64 = 60_000;
pub const SESSION_MS: u64 = 12 * 3_600_000;

/// What a session holds: the owner's key and the proof that opened it.
#[derive(Clone, Debug)]
pub struct Session {
    pub key: [u8; 32],
    pub proof: Vec<u8>,
    pub csrf: String,
    pub expires_ms: u64,
}

#[derive(Debug, Default)]
pub struct Sessions {
    codes: Mutex<HashMap<String, (Session, u64)>>,
    live: Mutex<HashMap<String, Session>>,
}

fn random_hex() -> String {
    let mut b = [0u8; 32];
    rand::rngs::OsRng.fill_bytes(&mut b);
    hex::encode(b)
}

impl Sessions {
    /// A one-time code for the owner, from their signed request.
    pub fn link(&self, key: [u8; 32], proof: Vec<u8>, now: u64) -> String {
        let code = random_hex();
        let s = Session { key, proof, csrf: random_hex(), expires_ms: now + SESSION_MS };
        let mut codes = self.codes.lock().unwrap();
        codes.retain(|_, (_, until)| *until > now);
        codes.insert(code.clone(), (s, now + LINK_MS));
        code
    }

    /// Spend a code: the session id, once, within a minute of the link.
    pub fn open(&self, code: &str, now: u64) -> Option<String> {
        let (s, until) = self.codes.lock().unwrap().remove(code)?;
        if until < now {
            return None;
        }
        let id = random_hex();
        let mut live = self.live.lock().unwrap();
        live.retain(|_, s| s.expires_ms > now);
        live.insert(id.clone(), s);
        Some(id)
    }

    pub fn get(&self, id: &str, now: u64) -> Option<Session> {
        self.live.lock().unwrap().get(id).filter(|s| s.expires_ms > now).cloned()
    }

    pub fn close(&self, id: &str) {
        self.live.lock().unwrap().remove(id);
    }
}

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

    #[test]
    fn a_link_opens_one_session_once_and_only_while_fresh() {
        let s = Sessions::default();
        let code = s.link([1; 32], vec![9], 1_000);
        let id = s.open(&code, 2_000).expect("fresh");
        assert!(s.open(&code, 2_000).is_none(), "spent");
        assert_eq!(s.get(&id, 3_000).unwrap().key, [1; 32]);
        assert!(s.get(&id, 1_000 + SESSION_MS + 1).is_none(), "expired");
        let stale = s.link([1; 32], vec![9], 1_000);
        assert!(s.open(&stale, 1_000 + LINK_MS + 1).is_none());
        s.close(&id);
        assert!(s.get(&id, 3_000).is_none());
    }
}

1		//! The owner's browser sign-in, shared by Radar and the API (spec §8.3): the owner's CLI signs a request for a
2		//! one-time link (`POST /radar/link`, valid 60 s); opening it starts a
3		//! browser session whose events carry that signed request as their proof
4		//! (level 2). The passkey (level 3) is 0.2. Sessions live in memory: a
5		//! restart signs the browser out.
6
7		use rand::RngCore;
8		use std::collections::HashMap;
9		use std::sync::Mutex;
10
11		/// How long a sign-in link is good for, and a session.
12		pub const LINK_MS: u64 = 60_000;
13		pub const SESSION_MS: u64 = 12 * 3_600_000;
14
15		/// What a session holds: the owner's key and the proof that opened it.
16		#[derive(Clone, Debug)]
17		pub struct Session {
18		pub key: [u8; 32],
19		pub proof: Vec<u8>,
20		pub csrf: String,
21		pub expires_ms: u64,
22		}
23
24		#[derive(Debug, Default)]
25		pub struct Sessions {
26		codes: Mutex<HashMap<String, (Session, u64)>>,
27		live: Mutex<HashMap<String, Session>>,
28		}
29
30	11×	fn random_hex() -> String {
31	11×	let mut b = [0u8; 32];
32	11×	rand::rngs::OsRng.fill_bytes(&mut b);
33	11×	hex::encode(b)
34	11×	}
35
36		impl Sessions {
37		/// A one-time code for the owner, from their signed request.
38	4×	pub fn link(&self, key: [u8; 32], proof: Vec<u8>, now: u64) -> String {
39	4×	let code = random_hex();
40	4×	let s = Session { key, proof, csrf: random_hex(), expires_ms: now + SESSION_MS };
41	4×	let mut codes = self.codes.lock().unwrap();
42	4×	codes.retain(\|_, (_, until)\| *until > now);
43	4×	codes.insert(code.clone(), (s, now + LINK_MS));
44	4×	code
45	4×	}
46
47		/// Spend a code: the session id, once, within a minute of the link.
48	6×	pub fn open(&self, code: &str, now: u64) -> Option<String> {
49	6×	let (s, until) = self.codes.lock().unwrap().remove(code)?;
50	4×	if until < now {
51	1×	return None;
52	3×	}
53	3×	let id = random_hex();
54	3×	let mut live = self.live.lock().unwrap();
55	3×	live.retain(\|_, s\| s.expires_ms > now);
56	3×	live.insert(id.clone(), s);
57	3×	Some(id)
58	6×	}
59
60	24×	pub fn get(&self, id: &str, now: u64) -> Option<Session> {
61	24×	self.live.lock().unwrap().get(id).filter(\|s\| s.expires_ms > now).cloned()
62	24×	}
63
64	1×	pub fn close(&self, id: &str) {
65	1×	self.live.lock().unwrap().remove(id);
66	1×	}
67		}
68
69		#[cfg(test)]
70		mod tests {
71		use super::*;
72
73		#[test]
74	1×	fn a_link_opens_one_session_once_and_only_while_fresh() {
75	1×	let s = Sessions::default();
76	1×	let code = s.link([1; 32], vec![9], 1_000);
77	1×	let id = s.open(&code, 2_000).expect("fresh");
78	1×	assert!(s.open(&code, 2_000).is_none(), "spent");
79	1×	assert_eq!(s.get(&id, 3_000).unwrap().key, [1; 32]);
80	1×	assert!(s.get(&id, 1_000 + SESSION_MS + 1).is_none(), "expired");
81	1×	let stale = s.link([1; 32], vec![9], 1_000);
82	1×	assert!(s.open(&stale, 1_000 + LINK_MS + 1).is_none());
83	1×	s.close(&id);
84	1×	assert!(s.get(&id, 3_000).is_none());
85	1×	}
86		}

`/`	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/spectra-mcp/src/session.rs 95.6%

Keyboard