credentials.rs 89.2%

365 of 409 lines run, 46 of 76 functions · run #282 on main · run missed

//! Per-user credentials for hubs: one sign-in serves every repository on a
//! hub, and nothing secret is written into a checkout.
//!
//! The store is `credentials.toml` in the user's oxy directory (see
//! [`crate::repo::default_home`]), one section per hub:
//!
//! ```text
//! [https://oxygenhub.io]
//! account = "andymccall"
//! token = "oxyhub_…"
//! ```
//!
//! A hub is a scheme, host and port: a token is only ever sent to the hub
//! it was stored for. The file is written readable by its owner only, and
//! is ignored with a warning when anyone else can read it. With
//! `auth.helper` set in the user's `config.toml`, tokens go to that helper
//! instead (Git's credential-helper protocol, so `libsecret`,
//! `osxkeychain` and `manager` keep them in the system keyring) and the
//! file keeps only what is not secret.
//!
//! A token is sent over `https`, or over plain `http` to this machine only
//! ([`token_allowed`]); hub transports drop it on any redirect.

use crate::protocol::RemoteOptions;
use std::collections::{BTreeMap, HashMap};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::{Mutex, OnceLock};

/// The user name oxy's tokens are stored under in a credential helper, so
/// they stay apart from Git credentials for the same host.
const HELPER_USER: &str = "oxy-token";

/// The hub of a URL: `scheme://host[:port]`, lower case, for `http` and
/// `https` URLs only.
pub fn hub_of(url: &str) -> Option<String> {
    let (scheme, rest) = url.split_once("://")?;
    let scheme = scheme.to_ascii_lowercase();
    if scheme != "http" && scheme != "https" {
        return None;
    }
    let host = rest.split(['/', '?', '#']).next()?;
    // Never key a hub on credentials embedded in the URL.
    let host = host.rsplit('@').next()?;
    if host.is_empty() {
        return None;
    }
    Some(format!("{scheme}://{}", host.to_ascii_lowercase()))
}

/// Whether a token may be sent to `url`: always over `https`, and over
/// plain `http` only to this machine (a hub under test, or a runner's own).
pub fn token_allowed(url: &str) -> bool {
    let Some(hub) = hub_of(url) else {
        return true;
    };
    match hub.split_once("://") {
        Some(("https", _)) => true,
        Some((_, host)) => {
            let name = match host.strip_prefix('[') {
                Some(v6) => v6.split(']').next().unwrap_or(""),
                None => host.rsplit_once(':').map_or(host, |(h, _)| h),
            };
            name == "localhost"
                || name == "::1"
                || name
                    .parse::<std::net::Ipv4Addr>()
                    .is_ok_and(|a| a.is_loopback())
        }
        None => false,
    }
}

/// What the store holds for one hub.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct HubEntry {
    /// `scheme://host[:port]`.
    pub hub: String,
    /// The account the token signs in as, recorded at sign-in.
    pub account: Option<String>,
    /// The token, when it is in the file (not with a helper).
    pub token: Option<String>,
    /// Extra roots to trust for this hub (a self-signed hub).
    pub ca: Option<PathBuf>,
}

/// Where a saved token went.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Stored {
    /// The credentials file, owner-only.
    File(PathBuf),
    /// A credential helper, by its `auth.helper` value.
    Helper(String),
}

/// The credential store of one oxy home directory.
#[derive(Clone, Debug)]
pub struct Credentials {
    home: PathBuf,
}

impl Credentials {
    /// The store in `home` (an oxy home directory).
    pub fn at(home: impl Into<PathBuf>) -> Credentials {
        Credentials { home: home.into() }
    }

    /// The store in the user's oxy home directory.
    pub fn user() -> Credentials {
        Credentials::at(crate::repo::default_home())
    }

    /// `credentials.toml` in the home directory.
    pub fn path(&self) -> PathBuf {
        self.home.join("credentials.toml")
    }

    /// The configured credential helper (`auth.helper` in the user file).
    pub fn helper(&self) -> Option<String> {
        crate::repo::read_config_file(&self.home.join("config.toml"))
            .ok()?
            .remove("auth.helper")
            .filter(|h| !h.trim().is_empty())
    }

    /// Every hub in the file, tokens as stored there (none with a helper).
    pub fn entries(&self) -> Result<Vec<HubEntry>, String> {
        Ok(self.read()?.into_values().collect())
    }

    /// Whether the file can be read by anyone but its owner, in which case
    /// lookups ignore it.
    pub fn too_open(&self) -> bool {
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            if let Ok(m) = std::fs::metadata(self.path()) {
                return m.permissions().mode() & 0o077 != 0;
            }
        }
        false
    }

    /// The entry for `hub`, its token fetched from the helper if one is set.
    pub fn get(&self, hub: &str) -> Result<Option<HubEntry>, String> {
        let entry = self.read()?.remove(hub);
        let helper = self.helper();
        let mut entry = match (entry, &helper) {
            (Some(e), _) => e,
            // A helper may hold a token stored before the file was cleared.
            (None, Some(_)) => HubEntry {
                hub: hub.to_string(),
                ..HubEntry::default()
            },
            (None, None) => return Ok(None),
        };
        if entry.token.is_none() {
            if let Some(h) = &helper {
                entry.token = run_helper(h, "get", hub, None)?;
            }
        }
        if entry.token.is_none() && entry.account.is_none() && entry.ca.is_none() {
            return Ok(None);
        }
        Ok(Some(entry))
    }

    /// Save a token (and what is known about it) for `hub`.
    pub fn save(
        &self,
        hub: &str,
        token: &str,
        account: Option<&str>,
        ca: Option<&Path>,
    ) -> Result<Stored, String> {
        let mut all = self.read()?;
        let helper = self.helper();
        let entry = all.entry(hub.to_string()).or_insert_with(|| HubEntry {
            hub: hub.to_string(),
            ..HubEntry::default()
        });
        entry.account = account.map(String::from).or(entry.account.take());
        if let Some(ca) = ca {
            entry.ca = Some(ca.to_path_buf());
        }
        let stored = match &helper {
            Some(h) => {
                run_helper(h, "store", hub, Some(token))?;
                entry.token = None;
                Stored::Helper(h.clone())
            }
            None => {
                entry.token = Some(token.to_string());
                Stored::File(self.path())
            }
        };
        self.write(&all)?;
        forget_cached();
        Ok(stored)
    }

    /// Remove `hub` from the file and the helper; returns what it held,
    /// with the token, so the caller can revoke it.
    pub fn remove(&self, hub: &str) -> Result<Option<HubEntry>, String> {
        let found = self.get(hub)?;
        let mut all = self.read()?;
        if all.remove(hub).is_some() {
            self.write(&all)?;
        }
        if let Some(h) = self.helper() {
            run_helper(&h, "erase", hub, None)?;
        }
        forget_cached();
        Ok(found)
    }

    fn read(&self) -> Result<BTreeMap<String, HubEntry>, String> {
        let path = self.path();
        let text = match std::fs::read_to_string(&path) {
            Ok(t) => t,
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(BTreeMap::new()),
            Err(e) => return Err(format!("reading {}: {e}", path.display())),
        };
        let mut out = BTreeMap::new();
        let mut current: Option<HubEntry> = None;
        for (n, line) in text.lines().enumerate() {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') {
                continue;
            }
            if let Some(hub) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) {
                if let Some(e) = current.take() {
                    out.insert(e.hub.clone(), e);
                }
                current = Some(HubEntry {
                    hub: hub.trim().to_string(),
                    ..HubEntry::default()
                });
                continue;
            }
            let bad = || {
                format!(
                    "{} line {}: expected key = \"value\"",
                    path.display(),
                    n + 1
                )
            };
            let (k, v) = line.split_once('=').ok_or_else(bad)?;
            let v = unquote(v.trim()).ok_or_else(bad)?;
            let Some(e) = current.as_mut() else {
                return Err(format!(
                    "{} line {}: a key before any [hub] section",
                    path.display(),
                    n + 1
                ));
            };
            match k.trim() {
                "account" => e.account = Some(v),
                "token" => e.token = Some(v),
                "ca" => e.ca = Some(PathBuf::from(v)),
                // Unknown keys are kept out of lookups, not fatal.
                _ => {}
            }
        }
        if let Some(e) = current {
            out.insert(e.hub.clone(), e);
        }
        Ok(out)
    }

    fn write(&self, all: &BTreeMap<String, HubEntry>) -> Result<(), String> {
        let mut text =
            String::from("# oxy credentials: a token for each hub. Keep this file private.\n");
        for e in all.values() {
            text.push_str(&format!("\n[{}]\n", e.hub));
            if let Some(a) = &e.account {
                text.push_str(&format!("account = {}\n", quote(a)));
            }
            if let Some(t) = &e.token {
                text.push_str(&format!("token = {}\n", quote(t)));
            }
            if let Some(c) = &e.ca {
                text.push_str(&format!("ca = {}\n", quote(&c.to_string_lossy())));
            }
        }
        let path = self.path();
        std::fs::create_dir_all(&self.home)
            .map_err(|e| format!("creating {}: {e}", self.home.display()))?;
        crate::durable::write_atomic_private(&path, text.as_bytes())
            .map_err(|e| format!("writing {}: {e}", path.display()))
    }

    /// The stored token and CA for `url`'s hub, if any: memoized, so a
    /// helper runs once per hub in a process. A file anyone else can read
    /// is ignored, with a warning.
    pub fn lookup(&self, url: &str) -> (Option<String>, Option<PathBuf>) {
        let Some(hub) = hub_of(url) else {
            return (None, None);
        };
        let key = (self.home.clone(), hub.clone());
        if let Some(hit) = cache().lock().unwrap().get(&key) {
            return hit.clone();
        }
        let found = if self.too_open() {
            warn_once(&format!(
                "warning: {} can be read by other users, so oxy ignores it; run chmod 600 on it",
                self.path().display()
            ));
            (None, None)
        } else {
            match self.get(&hub) {
                Ok(Some(e)) => (e.token, e.ca),
                Ok(None) => (None, None),
                Err(e) => {
                    warn_once(&format!("warning: credentials for {hub}: {e}"));
                    (None, None)
                }
            }
        };
        cache().lock().unwrap().insert(key, found.clone());
        found
    }

    /// Options for reaching `url` without a configured remote: `$OXY_TOKEN`
    /// and `$OXY_CA`, else what this store holds for its hub.
    pub fn options_for(&self, url: &str) -> RemoteOptions {
        let env_token = std::env::var("OXY_TOKEN").ok().filter(|t| !t.is_empty());
        let env_ca = std::env::var("OXY_CA").ok().map(PathBuf::from);
        let (token, ca) = match (&env_token, &env_ca) {
            (Some(_), Some(_)) => (None, None),
            _ => self.lookup(url),
        };
        RemoteOptions {
            token: env_token.or(token),
            ca: env_ca.or(ca),
            repo_id: None,
            cache_dir: None,
        }
    }
}

type Cache = Mutex<HashMap<(PathBuf, String), (Option<String>, Option<PathBuf>)>>;

fn cache() -> &'static Cache {
    static CACHE: OnceLock<Cache> = OnceLock::new();
    CACHE.get_or_init(Default::default)
}

fn forget_cached() {
    cache().lock().unwrap().clear();
}

fn warn_once(message: &str) {
    static SEEN: OnceLock<Mutex<std::collections::HashSet<String>>> = OnceLock::new();
    if SEEN
        .get_or_init(Default::default)
        .lock()
        .unwrap()
        .insert(message.to_string())
    {
        eprintln!("{message}");
    }
}

fn quote(v: &str) -> String {
    let mut out = String::from('"');
    for c in v.chars() {
        match c {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\n' => out.push_str("\\n"),
            c => out.push(c),
        }
    }
    out.push('"');
    out
}

fn unquote(v: &str) -> Option<String> {
    let inner = v.strip_prefix('"')?.strip_suffix('"')?;
    let mut out = String::new();
    let mut chars = inner.chars();
    while let Some(c) = chars.next() {
        if c == '\\' {
            match chars.next()? {
                'n' => out.push('\n'),
                c => out.push(c),
            }
        } else {
            out.push(c);
        }
    }
    Some(out)
}

/// Run a credential helper (Git's protocol): `get`, `store` or `erase` for
/// `hub`. `get` returns the password the helper answered with.
///
/// `auth.helper` is a helper name (run as `git credential-NAME`), an
/// absolute path, or a shell command after `!`, as in Git.
fn run_helper(
    helper: &str,
    action: &str,
    hub: &str,
    token: Option<&str>,
) -> Result<Option<String>, String> {
    let (protocol, host) = hub
        .split_once("://")
        .ok_or_else(|| format!("{hub} is not a hub URL"))?;
    let mut cmd = if let Some(shell) = helper.strip_prefix('!') {
        let mut c = Command::new("sh");
        c.arg("-c").arg(format!("{shell} {action}"));
        c
    } else if Path::new(helper).is_absolute() {
        let mut c = Command::new(helper);
        c.arg(action);
        c
    } else {
        let mut c = Command::new("git");
        c.arg(format!("credential-{helper}")).arg(action);
        c
    };
    let mut input = format!("protocol={protocol}\nhost={host}\nusername={HELPER_USER}\n");
    if let Some(t) = token {
        input.push_str(&format!("password={t}\n"));
    }
    input.push('\n');
    let mut child = cmd
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::inherit())
        .spawn()
        .map_err(|e| format!("running credential helper {helper:?}: {e}"))?;
    child
        .stdin
        .take()
        .expect("piped")
        .write_all(input.as_bytes())
        .map_err(|e| format!("credential helper {helper:?}: {e}"))?;
    let out = child
        .wait_with_output()
        .map_err(|e| format!("credential helper {helper:?}: {e}"))?;
    if !out.status.success() {
        return Err(format!("credential helper {helper:?} {action} failed"));
    }
    if action != "get" {
        return Ok(None);
    }
    Ok(String::from_utf8_lossy(&out.stdout)
        .lines()
        .find_map(|l| l.strip_prefix("password="))
        .map(String::from)
        .filter(|p| !p.is_empty()))
}

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

    #[test]
    fn hubs_are_scheme_host_and_port() {
        assert_eq!(
            hub_of("https://OxygenHub.io/doomsdayone/metalgear").as_deref(),
            Some("https://oxygenhub.io")
        );
        assert_eq!(
            hub_of("http://127.0.0.1:7300/a/b").as_deref(),
            Some("http://127.0.0.1:7300")
        );
        assert_eq!(
            hub_of("https://user:[email protected]/x").as_deref(),
            Some("https://hub.example")
        );
        assert_eq!(hub_of("/srv/repo"), None);
        assert_eq!(hub_of("file:///srv/repo"), None);
    }

    #[test]
    fn tokens_go_over_https_or_to_this_machine() {
        assert!(token_allowed("https://oxygenhub.io/a/b"));
        assert!(token_allowed("http://127.0.0.1:7300/a/b"));
        assert!(token_allowed("http://localhost/a"));
        assert!(token_allowed("http://[::1]:8080/a"));
        assert!(!token_allowed("http://oxygenhub.io/a/b"));
        assert!(!token_allowed("http://10.0.0.1/a"));
        assert!(!token_allowed("http://127.0.0.1.evil.example/a"));
    }

    #[test]
    fn save_get_and_remove_round_trip_privately() {
        let dir = tempfile::tempdir().unwrap();
        let store = Credentials::at(dir.path());
        assert_eq!(store.get("https://hub.example").unwrap(), None);
        let stored = store
            .save("https://hub.example", "tok\"en", Some("andy"), None)
            .unwrap();
        assert_eq!(stored, Stored::File(store.path()));
        store
            .save(
                "http://127.0.0.1:7300",
                "local",
                None,
                Some(Path::new("/ca.pem")),
            )
            .unwrap();
        let e = store.get("https://hub.example").unwrap().unwrap();
        assert_eq!(e.token.as_deref(), Some("tok\"en"));
        assert_eq!(e.account.as_deref(), Some("andy"));
        assert!(!store.too_open());
        assert_eq!(
            store.lookup("https://hub.example/o/r"),
            (Some("tok\"en".into()), None)
        );
        // Another host, scheme or port gets nothing.
        assert_eq!(store.lookup("https://other.example/o/r"), (None, None));
        assert_eq!(store.lookup("http://hub.example/o/r"), (None, None));
        assert_eq!(store.lookup("https://hub.example:8443/o/r"), (None, None));
        let gone = store.remove("https://hub.example").unwrap().unwrap();
        assert_eq!(gone.token.as_deref(), Some("tok\"en"));
        assert_eq!(store.lookup("https://hub.example/o/r"), (None, None));
        assert_eq!(store.entries().unwrap().len(), 1);
    }

    #[cfg(unix)]
    #[test]
    fn a_file_others_can_read_is_ignored() {
        use std::os::unix::fs::PermissionsExt;
        let dir = tempfile::tempdir().unwrap();
        let store = Credentials::at(dir.path());
        store.save("https://open.example", "t", None, None).unwrap();
        let mode = std::fs::metadata(store.path())
            .unwrap()
            .permissions()
            .mode();
        assert_eq!(mode & 0o777, 0o600);
        std::fs::set_permissions(store.path(), std::fs::Permissions::from_mode(0o644)).unwrap();
        assert!(store.too_open());
        assert_eq!(store.lookup("https://open.example/o/r"), (None, None));
    }

    #[cfg(unix)]
    #[test]
    fn a_helper_keeps_the_token_out_of_the_file() {
        let dir = tempfile::tempdir().unwrap();
        let vault = dir.path().join("vault");
        // A helper that keeps one password in a file, as a keyring would.
        let helper = format!(
            "!f() {{ case $1 in get) [ -f {v} ] && echo password=$(cat {v});; store) sed -n 's/^password=//p' > {v};; erase) rm -f {v};; esac; }}; f",
            v = vault.display()
        );
        std::fs::write(
            dir.path().join("config.toml"),
            format!("auth.helper = \"{helper}\"\n"),
        )
        .unwrap();
        let store = Credentials::at(dir.path());
        assert!(store.helper().is_some());
        let stored = store
            .save("https://hub.example", "secret", Some("andy"), None)
            .unwrap();
        assert!(matches!(stored, Stored::Helper(_)));
        let text = std::fs::read_to_string(store.path()).unwrap();
        assert!(!text.contains("secret"), "{text}");
        assert_eq!(
            store
                .get("https://hub.example")
                .unwrap()
                .unwrap()
                .token
                .as_deref(),
            Some("secret")
        );
        store.remove("https://hub.example").unwrap();
        assert!(!vault.exists());
    }
}

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

1		//! Per-user credentials for hubs: one sign-in serves every repository on a
2		//! hub, and nothing secret is written into a checkout.
3		//!
4		//! The store is `credentials.toml` in the user's oxy directory (see
5		//! [`crate::repo::default_home`]), one section per hub:
6		//!
7		//! ```text
8		//! [https://oxygenhub.io]
9		//! account = "andymccall"
10		//! token = "oxyhub_…"
11		//! ```
12		//!
13		//! A hub is a scheme, host and port: a token is only ever sent to the hub
14		//! it was stored for. The file is written readable by its owner only, and
15		//! is ignored with a warning when anyone else can read it. With
16		//! `auth.helper` set in the user's `config.toml`, tokens go to that helper
17		//! instead (Git's credential-helper protocol, so `libsecret`,
18		//! `osxkeychain` and `manager` keep them in the system keyring) and the
19		//! file keeps only what is not secret.
20		//!
21		//! A token is sent over `https`, or over plain `http` to this machine only
22		//! ([`token_allowed`]); hub transports drop it on any redirect.
23
24		use crate::protocol::RemoteOptions;
25		use std::collections::{BTreeMap, HashMap};
26		use std::io::Write;
27		use std::path::{Path, PathBuf};
28		use std::process::{Command, Stdio};
29		use std::sync::{Mutex, OnceLock};
30
31		/// The user name oxy's tokens are stored under in a credential helper, so
32		/// they stay apart from Git credentials for the same host.
33		const HELPER_USER: &str = "oxy-token";
34
35		/// The hub of a URL: `scheme://host[:port]`, lower case, for `http` and
36		/// `https` URLs only.
37	2247×	pub fn hub_of(url: &str) -> Option<String> {
38	2247×	let (scheme, rest) = url.split_once("://")?;
39	414×	let scheme = scheme.to_ascii_lowercase();
40	414×	if scheme != "http" && scheme != "https" {
41	102×	return None;
42	312×	}
43	312×	let host = rest.split(['/', '?', '#']).next()?;
44		// Never key a hub on credentials embedded in the URL.
45	312×	let host = host.rsplit('@').next()?;
46	312×	if host.is_empty() {
47	0×	return None;
48	312×	}
49	312×	Some(format!("{scheme}://{}", host.to_ascii_lowercase()))
50	2247×	}
51
52		/// Whether a token may be sent to `url`: always over `https`, and over
53		/// plain `http` only to this machine (a hub under test, or a runner's own).
54	11×	pub fn token_allowed(url: &str) -> bool {
55	11×	let Some(hub) = hub_of(url) else {
56	0×	return true;
57		};
58	11×	match hub.split_once("://") {
59	11×	Some(("https", _)) => true,
60	10×	Some((_, host)) => {
61	10×	let name = match host.strip_prefix('[') {
62	1×	Some(v6) => v6.split(']').next().unwrap_or(""),
63	9×	None => host.rsplit_once(':').map_or(host, \|(h, _)\| h),
64		};
65	10×	name == "localhost"
66	9×	\|\| name == "::1"
67	8×	\|\| name
68	8×	.parse::<std::net::Ipv4Addr>()
69	8×	.is_ok_and(\|a\| a.is_loopback())
70		}
71	0×	None => false,
72		}
73	11×	}
74
75		/// What the store holds for one hub.
76		#[derive(Clone, Debug, Default, PartialEq, Eq)]
77		pub struct HubEntry {
78		/// `scheme://host[:port]`.
79		pub hub: String,
80		/// The account the token signs in as, recorded at sign-in.
81		pub account: Option<String>,
82		/// The token, when it is in the file (not with a helper).
83		pub token: Option<String>,
84		/// Extra roots to trust for this hub (a self-signed hub).
85		pub ca: Option<PathBuf>,
86		}
87
88		/// Where a saved token went.
89		#[derive(Clone, Debug, PartialEq, Eq)]
90		pub enum Stored {
91		/// The credentials file, owner-only.
92		File(PathBuf),
93		/// A credential helper, by its `auth.helper` value.
94		Helper(String),
95		}
96
97		/// The credential store of one oxy home directory.
98		#[derive(Clone, Debug)]
99		pub struct Credentials {
100		home: PathBuf,
101		}
102
103		impl Credentials {
104		/// The store in `home` (an oxy home directory).
105	1232×	pub fn at(home: impl Into<PathBuf>) -> Credentials {
106	1232×	Credentials { home: home.into() }
107	1232×	}
108
109		/// The store in the user's oxy home directory.
110	234×	pub fn user() -> Credentials {
111	234×	Credentials::at(crate::repo::default_home())
112	234×	}
113
114		/// `credentials.toml` in the home directory.
115	86×	pub fn path(&self) -> PathBuf {
116	86×	self.home.join("credentials.toml")
117	86×	}
118
119		/// The configured credential helper (`auth.helper` in the user file).
120	40×	pub fn helper(&self) -> Option<String> {
121	40×	crate::repo::read_config_file(&self.home.join("config.toml"))
122	40×	.ok()?
123	40×	.remove("auth.helper")
124	40×	.filter(\|h\| !h.trim().is_empty())
125	40×	}
126
127		/// Every hub in the file, tokens as stored there (none with a helper).
128	1×	pub fn entries(&self) -> Result<Vec<HubEntry>, String> {
129	1×	Ok(self.read()?.into_values().collect())
130	1×	}
131
132		/// Whether the file can be read by anyone but its owner, in which case
133		/// lookups ignore it.
134	30×	pub fn too_open(&self) -> bool {
135		#[cfg(unix)]
136		{
137		use std::os::unix::fs::PermissionsExt;
138	30×	if let Ok(m) = std::fs::metadata(self.path()) {
139	9×	return m.permissions().mode() & 0o077 != 0;
140	21×	}
141		}
142	21×	false
143	30×	}
144
145		/// The entry for `hub`, its token fetched from the helper if one is set.
146	32×	pub fn get(&self, hub: &str) -> Result<Option<HubEntry>, String> {
147	32×	let entry = self.read()?.remove(hub);
148	32×	let helper = self.helper();
149	32×	let mut entry = match (entry, &helper) {
150	6×	(Some(e), _) => e,
151		// A helper may hold a token stored before the file was cleared.
152	0×	(None, Some(_)) => HubEntry {
153	0×	hub: hub.to_string(),
154	0×	..HubEntry::default()
155	0×	},
156	26×	(None, None) => return Ok(None),
157		};
158	6×	if entry.token.is_none() {
159	2×	if let Some(h) = &helper {
160	2×	entry.token = run_helper(h, "get", hub, None)?;
161	0×	}
162	4×	}
163	6×	if entry.token.is_none() && entry.account.is_none() && entry.ca.is_none() {
164	0×	return Ok(None);
165	6×	}
166	6×	Ok(Some(entry))
167	32×	}
168
169		/// Save a token (and what is known about it) for `hub`.
170	5×	pub fn save(
171	5×	&self,
172	5×	hub: &str,
173	5×	token: &str,
174	5×	account: Option<&str>,
175	5×	ca: Option<&Path>,
176	5×	) -> Result<Stored, String> {
177	5×	let mut all = self.read()?;
178	5×	let helper = self.helper();
179	5×	let entry = all.entry(hub.to_string()).or_insert_with(\|\| HubEntry {
180	5×	hub: hub.to_string(),
181	5×	..HubEntry::default()
182	5×	});
183	5×	entry.account = account.map(String::from).or(entry.account.take());
184	5×	if let Some(ca) = ca {
185	1×	entry.ca = Some(ca.to_path_buf());
186	4×	}
187	5×	let stored = match &helper {
188	1×	Some(h) => {
189	1×	run_helper(h, "store", hub, Some(token))?;
190	1×	entry.token = None;
191	1×	Stored::Helper(h.clone())
192		}
193		None => {
194	4×	entry.token = Some(token.to_string());
195	4×	Stored::File(self.path())
196		}
197		};
198	5×	self.write(&all)?;
199	5×	forget_cached();
200	5×	Ok(stored)
201	5×	}
202
203		/// Remove `hub` from the file and the helper; returns what it held,
204		/// with the token, so the caller can revoke it.
205	2×	pub fn remove(&self, hub: &str) -> Result<Option<HubEntry>, String> {
206	2×	let found = self.get(hub)?;
207	2×	let mut all = self.read()?;
208	2×	if all.remove(hub).is_some() {
209	2×	self.write(&all)?;
210	0×	}
211	2×	if let Some(h) = self.helper() {
212	1×	run_helper(&h, "erase", hub, None)?;
213	1×	}
214	2×	forget_cached();
215	2×	Ok(found)
216	2×	}
217
218	40×	fn read(&self) -> Result<BTreeMap<String, HubEntry>, String> {
219	40×	let path = self.path();
220	40×	let text = match std::fs::read_to_string(&path) {
221	14×	Ok(t) => t,
222	26×	Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(BTreeMap::new()),
223	0×	Err(e) => return Err(format!("reading {}: {e}", path.display())),
224		};
225	14×	let mut out = BTreeMap::new();
226	14×	let mut current: Option<HubEntry> = None;
227	95×	for (n, line) in text.lines().enumerate() {
228	95×	let line = line.trim();
229	95×	if line.is_empty() \|\| line.starts_with('#') {
230	35×	continue;
231	60×	}
232	60×	if let Some(hub) = line.strip_prefix('[').and_then(\|l\| l.strip_suffix(']')) {
233	21×	if let Some(e) = current.take() {
234	7×	out.insert(e.hub.clone(), e);
235	14×	}
236	21×	current = Some(HubEntry {
237	21×	hub: hub.trim().to_string(),
238	21×	..HubEntry::default()
239	21×	});
240	21×	continue;
241	39×	}
242	39×	let bad = \|\| {
243	0×	format!(
244		"{} line {}: expected key = \"value\"",
245	0×	path.display(),
246	0×	n + 1
247		)
248	0×	};
249	39×	let (k, v) = line.split_once('=').ok_or_else(bad)?;
250	39×	let v = unquote(v.trim()).ok_or_else(bad)?;
251	39×	let Some(e) = current.as_mut() else {
252	0×	return Err(format!(
253	0×	"{} line {}: a key before any [hub] section",
254	0×	path.display(),
255	0×	n + 1
256	0×	));
257		};
258	39×	match k.trim() {
259	39×	"account" => e.account = Some(v),
260	27×	"token" => e.token = Some(v),
261	9×	"ca" => e.ca = Some(PathBuf::from(v)),
262		// Unknown keys are kept out of lookups, not fatal.
263	0×	_ => {}
264		}
265		}
266	14×	if let Some(e) = current {
267	14×	out.insert(e.hub.clone(), e);
268	14×	}
269	14×	Ok(out)
270	40×	}
271
272	7×	fn write(&self, all: &BTreeMap<String, HubEntry>) -> Result<(), String> {
273	7×	let mut text =
274	7×	String::from("# oxy credentials: a token for each hub. Keep this file private.\n");
275	7×	for e in all.values() {
276	7×	text.push_str(&format!("\n[{}]\n", e.hub));
277	7×	if let Some(a) = &e.account {
278	4×	text.push_str(&format!("account = {}\n", quote(a)));
279	4×	}
280	7×	if let Some(t) = &e.token {
281	6×	text.push_str(&format!("token = {}\n", quote(t)));
282	6×	}
283	7×	if let Some(c) = &e.ca {
284	2×	text.push_str(&format!("ca = {}\n", quote(&c.to_string_lossy())));
285	5×	}
286		}
287	7×	let path = self.path();
288	7×	std::fs::create_dir_all(&self.home)
289	7×	.map_err(\|e\| format!("creating {}: {e}", self.home.display()))?;
290	7×	crate::durable::write_atomic_private(&path, text.as_bytes())
291	7×	.map_err(\|e\| format!("writing {}: {e}", path.display()))
292	7×	}
293
294		/// The stored token and CA for `url`'s hub, if any: memoized, so a
295		/// helper runs once per hub in a process. A file anyone else can read
296		/// is ignored, with a warning.
297	1234×	pub fn lookup(&self, url: &str) -> (Option<String>, Option<PathBuf>) {
298	1234×	let Some(hub) = hub_of(url) else {
299	1072×	return (None, None);
300		};
301	162×	let key = (self.home.clone(), hub.clone());
302	162×	if let Some(hit) = cache().lock().unwrap().get(&key) {
303	134×	return hit.clone();
304	28×	}
305	28×	let found = if self.too_open() {
306	1×	warn_once(&format!(
307	1×	"warning: {} can be read by other users, so oxy ignores it; run chmod 600 on it",
308	1×	self.path().display()
309	1×	));
310	1×	(None, None)
311		} else {
312	27×	match self.get(&hub) {
313	2×	Ok(Some(e)) => (e.token, e.ca),
314	25×	Ok(None) => (None, None),
315	0×	Err(e) => {
316	0×	warn_once(&format!("warning: credentials for {hub}: {e}"));
317	0×	(None, None)
318		}
319		}
320		};
321	28×	cache().lock().unwrap().insert(key, found.clone());
322	28×	found
323	1234×	}
324
325		/// Options for reaching `url` without a configured remote: `$OXY_TOKEN`
326		/// and `$OXY_CA`, else what this store holds for its hub.
327	1228×	pub fn options_for(&self, url: &str) -> RemoteOptions {
328	1228×	let env_token = std::env::var("OXY_TOKEN").ok().filter(\|t\| !t.is_empty());
329	1228×	let env_ca = std::env::var("OXY_CA").ok().map(PathBuf::from);
330	1228×	let (token, ca) = match (&env_token, &env_ca) {
331	0×	(Some(_), Some(_)) => (None, None),
332	1228×	_ => self.lookup(url),
333		};
334	1228×	RemoteOptions {
335	1228×	token: env_token.or(token),
336	1228×	ca: env_ca.or(ca),
337	1228×	repo_id: None,
338	1228×	cache_dir: None,
339	1228×	}
340	1228×	}
341		}
342
343		type Cache = Mutex<HashMap<(PathBuf, String), (Option<String>, Option<PathBuf>)>>;
344
345	197×	fn cache() -> &'static Cache {
346		static CACHE: OnceLock<Cache> = OnceLock::new();
347	197×	CACHE.get_or_init(Default::default)
348	197×	}
349
350	7×	fn forget_cached() {
351	7×	cache().lock().unwrap().clear();
352	7×	}
353
354	1×	fn warn_once(message: &str) {
355		static SEEN: OnceLock<Mutex<std::collections::HashSet<String>>> = OnceLock::new();
356	1×	if SEEN
357	1×	.get_or_init(Default::default)
358	1×	.lock()
359	1×	.unwrap()
360	1×	.insert(message.to_string())
361	1×	{
362	1×	eprintln!("{message}");
363	1×	}
364	1×	}
365
366	12×	fn quote(v: &str) -> String {
367	12×	let mut out = String::from('"');
368	59×	for c in v.chars() {
369	59×	match c {
370	2×	'"' => out.push_str("\\\""),
371	0×	'\\' => out.push_str("\\\\"),
372	0×	'\n' => out.push_str("\\n"),
373	57×	c => out.push(c),
374		}
375		}
376	12×	out.push('"');
377	12×	out
378	12×	}
379
380	39×	fn unquote(v: &str) -> Option<String> {
381	39×	let inner = v.strip_prefix('"')?.strip_suffix('"')?;
382	39×	let mut out = String::new();
383	39×	let mut chars = inner.chars();
384	249×	while let Some(c) = chars.next() {
385	210×	if c == '\\' {
386	8×	match chars.next()? {
387	0×	'n' => out.push('\n'),
388	8×	c => out.push(c),
389		}
390	202×	} else {
391	202×	out.push(c);
392	202×	}
393		}
394	39×	Some(out)
395	39×	}
396
397		/// Run a credential helper (Git's protocol): `get`, `store` or `erase` for
398		/// `hub`. `get` returns the password the helper answered with.
399		///
400		/// `auth.helper` is a helper name (run as `git credential-NAME`), an
401		/// absolute path, or a shell command after `!`, as in Git.
402	4×	fn run_helper(
403	4×	helper: &str,
404	4×	action: &str,
405	4×	hub: &str,
406	4×	token: Option<&str>,
407	4×	) -> Result<Option<String>, String> {
408	4×	let (protocol, host) = hub
409	4×	.split_once("://")
410	4×	.ok_or_else(\|\| format!("{hub} is not a hub URL"))?;
411	4×	let mut cmd = if let Some(shell) = helper.strip_prefix('!') {
412	4×	let mut c = Command::new("sh");
413	4×	c.arg("-c").arg(format!("{shell} {action}"));
414	4×	c
415	0×	} else if Path::new(helper).is_absolute() {
416	0×	let mut c = Command::new(helper);
417	0×	c.arg(action);
418	0×	c
419		} else {
420	0×	let mut c = Command::new("git");
421	0×	c.arg(format!("credential-{helper}")).arg(action);
422	0×	c
423		};
424	4×	let mut input = format!("protocol={protocol}\nhost={host}\nusername={HELPER_USER}\n");
425	4×	if let Some(t) = token {
426	1×	input.push_str(&format!("password={t}\n"));
427	3×	}
428	4×	input.push('\n');
429	4×	let mut child = cmd
430	4×	.stdin(Stdio::piped())
431	4×	.stdout(Stdio::piped())
432	4×	.stderr(Stdio::inherit())
433	4×	.spawn()
434	4×	.map_err(\|e\| format!("running credential helper {helper:?}: {e}"))?;
435	4×	child
436	4×	.stdin
437	4×	.take()
438	4×	.expect("piped")
439	4×	.write_all(input.as_bytes())
440	4×	.map_err(\|e\| format!("credential helper {helper:?}: {e}"))?;
441	4×	let out = child
442	4×	.wait_with_output()
443	4×	.map_err(\|e\| format!("credential helper {helper:?}: {e}"))?;
444	4×	if !out.status.success() {
445	0×	return Err(format!("credential helper {helper:?} {action} failed"));
446	4×	}
447	4×	if action != "get" {
448	2×	return Ok(None);
449	2×	}
450	2×	Ok(String::from_utf8_lossy(&out.stdout)
451	2×	.lines()
452	2×	.find_map(\|l\| l.strip_prefix("password="))
453	2×	.map(String::from)
454	2×	.filter(\|p\| !p.is_empty()))
455	4×	}
456
457		#[cfg(test)]
458		mod tests {
459		use super::*;
460
461		#[test]
462	1×	fn hubs_are_scheme_host_and_port() {
463	1×	assert_eq!(
464	1×	hub_of("https://OxygenHub.io/doomsdayone/metalgear").as_deref(),
465		Some("https://oxygenhub.io")
466		);
467	1×	assert_eq!(
468	1×	hub_of("http://127.0.0.1:7300/a/b").as_deref(),
469		Some("http://127.0.0.1:7300")
470		);
471	1×	assert_eq!(
472	1×	hub_of("https://user:[email protected]/x").as_deref(),
473		Some("https://hub.example")
474		);
475	1×	assert_eq!(hub_of("/srv/repo"), None);
476	1×	assert_eq!(hub_of("file:///srv/repo"), None);
477	1×	}
478
479		#[test]
480	1×	fn tokens_go_over_https_or_to_this_machine() {
481	1×	assert!(token_allowed("https://oxygenhub.io/a/b"));
482	1×	assert!(token_allowed("http://127.0.0.1:7300/a/b"));
483	1×	assert!(token_allowed("http://localhost/a"));
484	1×	assert!(token_allowed("http://[::1]:8080/a"));
485	1×	assert!(!token_allowed("http://oxygenhub.io/a/b"));
486	1×	assert!(!token_allowed("http://10.0.0.1/a"));
487	1×	assert!(!token_allowed("http://127.0.0.1.evil.example/a"));
488	1×	}
489
490		#[test]
491	1×	fn save_get_and_remove_round_trip_privately() {
492	1×	let dir = tempfile::tempdir().unwrap();
493	1×	let store = Credentials::at(dir.path());
494	1×	assert_eq!(store.get("https://hub.example").unwrap(), None);
495	1×	let stored = store
496	1×	.save("https://hub.example", "tok\"en", Some("andy"), None)
497	1×	.unwrap();
498	1×	assert_eq!(stored, Stored::File(store.path()));
499	1×	store
500	1×	.save(
501	1×	"http://127.0.0.1:7300",
502	1×	"local",
503	1×	None,
504	1×	Some(Path::new("/ca.pem")),
505		)
506	1×	.unwrap();
507	1×	let e = store.get("https://hub.example").unwrap().unwrap();
508	1×	assert_eq!(e.token.as_deref(), Some("tok\"en"));
509	1×	assert_eq!(e.account.as_deref(), Some("andy"));
510	1×	assert!(!store.too_open());
511	1×	assert_eq!(
512	1×	store.lookup("https://hub.example/o/r"),
513	1×	(Some("tok\"en".into()), None)
514		);
515		// Another host, scheme or port gets nothing.
516	1×	assert_eq!(store.lookup("https://other.example/o/r"), (None, None));
517	1×	assert_eq!(store.lookup("http://hub.example/o/r"), (None, None));
518	1×	assert_eq!(store.lookup("https://hub.example:8443/o/r"), (None, None));
519	1×	let gone = store.remove("https://hub.example").unwrap().unwrap();
520	1×	assert_eq!(gone.token.as_deref(), Some("tok\"en"));
521	1×	assert_eq!(store.lookup("https://hub.example/o/r"), (None, None));
522	1×	assert_eq!(store.entries().unwrap().len(), 1);
523	1×	}
524
525		#[cfg(unix)]
526		#[test]
527	1×	fn a_file_others_can_read_is_ignored() {
528		use std::os::unix::fs::PermissionsExt;
529	1×	let dir = tempfile::tempdir().unwrap();
530	1×	let store = Credentials::at(dir.path());
531	1×	store.save("https://open.example", "t", None, None).unwrap();
532	1×	let mode = std::fs::metadata(store.path())
533	1×	.unwrap()
534	1×	.permissions()
535	1×	.mode();
536	1×	assert_eq!(mode & 0o777, 0o600);
537	1×	std::fs::set_permissions(store.path(), std::fs::Permissions::from_mode(0o644)).unwrap();
538	1×	assert!(store.too_open());
539	1×	assert_eq!(store.lookup("https://open.example/o/r"), (None, None));
540	1×	}
541
542		#[cfg(unix)]
543		#[test]
544	1×	fn a_helper_keeps_the_token_out_of_the_file() {
545	1×	let dir = tempfile::tempdir().unwrap();
546	1×	let vault = dir.path().join("vault");
547		// A helper that keeps one password in a file, as a keyring would.
548	1×	let helper = format!(
549		"!f() {{ case $1 in get) [ -f {v} ] && echo password=$(cat {v});; store) sed -n 's/^password=//p' > {v};; erase) rm -f {v};; esac; }}; f",
550	1×	v = vault.display()
551		);
552	1×	std::fs::write(
553	1×	dir.path().join("config.toml"),
554	1×	format!("auth.helper = \"{helper}\"\n"),
555		)
556	1×	.unwrap();
557	1×	let store = Credentials::at(dir.path());
558	1×	assert!(store.helper().is_some());
559	1×	let stored = store
560	1×	.save("https://hub.example", "secret", Some("andy"), None)
561	1×	.unwrap();
562	1×	assert!(matches!(stored, Stored::Helper(_)));
563	1×	let text = std::fs::read_to_string(store.path()).unwrap();
564	1×	assert!(!text.contains("secret"), "{text}");
565	1×	assert_eq!(
566	1×	store
567	1×	.get("https://hub.example")
568	1×	.unwrap()
569	1×	.unwrap()
570	1×	.token
571	1×	.as_deref(),
572		Some("secret")
573		);
574	1×	store.remove("https://hub.example").unwrap();
575	1×	assert!(!vault.exists());
576	1×	}
577		}

Coverage / crates/oxy-core/src/credentials.rs 89.2%

Keyboard