setup.rs 89.4%

42 of 47 lines run, 10 of 20 functions · run #470 on main · run missed

//! The first administrator (oxygenhub#245). A hub with no accounts gives
//! administrator to the first account registered, so that account must
//! bring a one-time setup code: the one in `[registration] setup_code`
//! (for automation), or else a random one this module keeps in
//! `<data>/setup-code` (owner-only) and logs at start. It is never served
//! over the web. Registering with it spends it; once there are accounts
//! there is no code.

use crate::db::accounts;
use crate::Shared;
use std::path::PathBuf;

pub fn path(app: &Shared) -> PathBuf {
    app.config.data.join("setup-code")
}

/// At start: with no accounts, make sure there is a code and say where it
/// is; with accounts, make sure none is left lying about.
pub async fn ensure(app: &Shared) -> anyhow::Result<()> {
    let file = path(app);
    if accounts::account_count(&app.db).await? > 0 {
        let _ = std::fs::remove_file(&file);
        return Ok(());
    }
    let code = match expected(app) {
        Some(code) => code,
        None => {
            let code = crate::auth::random_hex(12);
            write_private(&file, &code)?;
            code
        }
    };
    tracing::warn!(
        "this hub has no administrator yet: register the first account at {}/register with setup code {code} (also in {}); it works once",
        app.config.base_url(),
        file.display()
    );
    Ok(())
}

/// The code the first registration must bring, if there is one.
pub fn expected(app: &Shared) -> Option<String> {
    let configured = app.config.registration.setup_code.trim();
    if !configured.is_empty() {
        return Some(configured.to_string());
    }
    std::fs::read_to_string(path(app)).ok().map(|s| s.trim().to_string()).filter(|s| !s.is_empty())
}

/// Whether `given` is the setup code, compared in constant time.
pub fn matches(app: &Shared, given: &str) -> bool {
    match expected(app) {
        Some(code) => {
            let (a, b) = (code.as_bytes(), given.trim().as_bytes());
            a.len() == b.len() && a.iter().zip(b).fold(0u8, |acc, (x, y)| acc | (x ^ y)) == 0
        }
        None => false,
    }
}

/// The first administrator exists: the code is spent.
pub fn spend(app: &Shared) {
    let _ = std::fs::remove_file(path(app));
}

fn write_private(file: &std::path::Path, code: &str) -> std::io::Result<()> {
    use std::io::Write;
    let mut options = std::fs::OpenOptions::new();
    options.write(true).create(true).truncate(true);
    #[cfg(unix)]
    {
        use std::os::unix::fs::OpenOptionsExt;
        options.mode(0o600);
    }
    let mut f = options.open(file)?;
    writeln!(f, "{code}")
}

1		//! The first administrator (oxygenhub#245). A hub with no accounts gives
2		//! administrator to the first account registered, so that account must
3		//! bring a one-time setup code: the one in `[registration] setup_code`
4		//! (for automation), or else a random one this module keeps in
5		//! `<data>/setup-code` (owner-only) and logs at start. It is never served
6		//! over the web. Registering with it spends it; once there are accounts
7		//! there is no code.
8
9		use crate::db::accounts;
10		use crate::Shared;
11		use std::path::PathBuf;
12
13	285×	pub fn path(app: &Shared) -> PathBuf {
14	285×	app.config.data.join("setup-code")
15	285×	}
16
17		/// At start: with no accounts, make sure there is a code and say where it
18		/// is; with accounts, make sure none is left lying about.
19	191×	pub async fn ensure(app: &Shared) -> anyhow::Result<()> {
20	191×	let file = path(app);
21	191×	if accounts::account_count(&app.db).await? > 0 {
22	0×	let _ = std::fs::remove_file(&file);
23	0×	return Ok(());
24	191×	}
25	191×	let code = match expected(app) {
26	186×	Some(code) => code,
27		None => {
28	5×	let code = crate::auth::random_hex(12);
29	5×	write_private(&file, &code)?;
30	5×	code
31		}
32		};
33	191×	tracing::warn!(
34		"this hub has no administrator yet: register the first account at {}/register with setup code {code} (also in {}); it works once",
35	0×	app.config.base_url(),
36	0×	file.display()
37		);
38	191×	Ok(())
39	191×	}
40
41		/// The code the first registration must bring, if there is one.
42	279×	pub fn expected(app: &Shared) -> Option<String> {
43	279×	let configured = app.config.registration.setup_code.trim();
44	279×	if !configured.is_empty() {
45	271×	return Some(configured.to_string());
46	8×	}
47	8×	std::fs::read_to_string(path(app)).ok().map(\|s\| s.trim().to_string()).filter(\|s\| !s.is_empty())
48	279×	}
49
50		/// Whether `given` is the setup code, compared in constant time.
51	88×	pub fn matches(app: &Shared, given: &str) -> bool {
52	88×	match expected(app) {
53	88×	Some(code) => {
54	88×	let (a, b) = (code.as_bytes(), given.trim().as_bytes());
55	898×	a.len() == b.len() && a.iter().zip(b).fold(0u8, \|acc, (x, y)\| acc \| (x ^ y)) == 0
56		}
57	0×	None => false,
58		}
59	88×	}
60
61		/// The first administrator exists: the code is spent.
62	86×	pub fn spend(app: &Shared) {
63	86×	let _ = std::fs::remove_file(path(app));
64	86×	}
65
66	5×	fn write_private(file: &std::path::Path, code: &str) -> std::io::Result<()> {
67		use std::io::Write;
68	5×	let mut options = std::fs::OpenOptions::new();
69	5×	options.write(true).create(true).truncate(true);
70		#[cfg(unix)]
71		{
72		use std::os::unix::fs::OpenOptionsExt;
73	5×	options.mode(0o600);
74		}
75	5×	let mut f = options.open(file)?;
76	5×	writeln!(f, "{code}")
77	5×	}

`/`	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/setup.rs 89.4%

Keyboard