setup.rs 89.4%

42 of 47 lines run, 10 of 20 functions · run #544 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	314×	pub fn path(app: &Shared) -> PathBuf {
14	314×	app.config.data.join("setup-code")
15	314×	}
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	208×	pub async fn ensure(app: &Shared) -> anyhow::Result<()> {
20	208×	let file = path(app);
21	208×	if accounts::account_count(&app.db).await? > 0 {
22	0×	let _ = std::fs::remove_file(&file);
23	0×	return Ok(());
24	208×	}
25	208×	let code = match expected(app) {
26	200×	Some(code) => code,
27		None => {
28	8×	let code = crate::auth::random_hex(12);
29	8×	write_private(&file, &code)?;
30	8×	code
31		}
32		};
33	208×	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	208×	Ok(())
39	208×	}
40
41		/// The code the first registration must bring, if there is one.
42	305×	pub fn expected(app: &Shared) -> Option<String> {
43	305×	let configured = app.config.registration.setup_code.trim();
44	305×	if !configured.is_empty() {
45	294×	return Some(configured.to_string());
46	11×	}
47	11×	std::fs::read_to_string(path(app)).ok().map(\|s\| s.trim().to_string()).filter(\|s\| !s.is_empty())
48	305×	}
49
50		/// Whether `given` is the setup code, compared in constant time.
51	97×	pub fn matches(app: &Shared, given: &str) -> bool {
52	97×	match expected(app) {
53	97×	Some(code) => {
54	97×	let (a, b) = (code.as_bytes(), given.trim().as_bytes());
55	988×	a.len() == b.len() && a.iter().zip(b).fold(0u8, \|acc, (x, y)\| acc \| (x ^ y)) == 0
56		}
57	0×	None => false,
58		}
59	97×	}
60
61		/// The first administrator exists: the code is spent.
62	95×	pub fn spend(app: &Shared) {
63	95×	let _ = std::fs::remove_file(path(app));
64	95×	}
65
66	8×	fn write_private(file: &std::path::Path, code: &str) -> std::io::Result<()> {
67		use std::io::Write;
68	8×	let mut options = std::fs::OpenOptions::new();
69	8×	options.write(true).create(true).truncate(true);
70		#[cfg(unix)]
71		{
72		use std::os::unix::fs::OpenOptionsExt;
73	8×	options.mode(0o600);
74		}
75	8×	let mut f = options.open(file)?;
76	8×	writeln!(f, "{code}")
77	8×	}

`/`	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