credentials.rs 89.2%

364 of 408 lines run, 55 of 77 functions · run #299 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),
            ..RemoteOptions::default()
        }
    }
}

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();
}

pub(crate) 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	2290×	pub fn hub_of(url: &str) -> Option<String> {
38	2290×	let (scheme, rest) = url.split_once("://")?;
39	431×	let scheme = scheme.to_ascii_lowercase();
40	431×	if scheme != "http" && scheme != "https" {
41	102×	return None;
42	329×	}
43	329×	let host = rest.split(['/', '?', '#']).next()?;
44		// Never key a hub on credentials embedded in the URL.
45	329×	let host = host.rsplit('@').next()?;
46	329×	if host.is_empty() {
47	0×	return None;
48	329×	}
49	329×	Some(format!("{scheme}://{}", host.to_ascii_lowercase()))
50	2290×	}
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	15×	pub fn token_allowed(url: &str) -> bool {
55	15×	let Some(hub) = hub_of(url) else {
56	0×	return true;
57		};
58	15×	match hub.split_once("://") {
59	15×	Some(("https", _)) => true,
60	14×	Some((_, host)) => {
61	14×	let name = match host.strip_prefix('[') {
62	1×	Some(v6) => v6.split(']').next().unwrap_or(""),
63	13×	None => host.rsplit_once(':').map_or(host, \|(h, _)\| h),
64		};
65	14×	name == "localhost"
66	13×	\|\| name == "::1"
67	12×	\|\| name
68	12×	.parse::<std::net::Ipv4Addr>()
69	12×	.is_ok_and(\|a\| a.is_loopback())
70		}
71	0×	None => false,
72		}
73	15×	}
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	1252×	pub fn at(home: impl Into<PathBuf>) -> Credentials {
106	1252×	Credentials { home: home.into() }
107	1252×	}
108
109		/// The store in the user's oxy home directory.
110	238×	pub fn user() -> Credentials {
111	238×	Credentials::at(crate::repo::default_home())
112	238×	}
113
114		/// `credentials.toml` in the home directory.
115	99×	pub fn path(&self) -> PathBuf {
116	99×	self.home.join("credentials.toml")
117	99×	}
118
119		/// The configured credential helper (`auth.helper` in the user file).
120	46×	pub fn helper(&self) -> Option<String> {
121	46×	crate::repo::read_config_file(&self.home.join("config.toml"))
122	46×	.ok()?
123	46×	.remove("auth.helper")
124	46×	.filter(\|h\| !h.trim().is_empty())
125	46×	}
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	35×	pub fn too_open(&self) -> bool {
135		#[cfg(unix)]
136		{
137		use std::os::unix::fs::PermissionsExt;
138	35×	if let Ok(m) = std::fs::metadata(self.path()) {
139	10×	return m.permissions().mode() & 0o077 != 0;
140	25×	}
141		}
142	25×	false
143	35×	}
144
145		/// The entry for `hub`, its token fetched from the helper if one is set.
146	37×	pub fn get(&self, hub: &str) -> Result<Option<HubEntry>, String> {
147	37×	let entry = self.read()?.remove(hub);
148	37×	let helper = self.helper();
149	37×	let mut entry = match (entry, &helper) {
150	7×	(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	30×	(None, None) => return Ok(None),
157		};
158	7×	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	5×	}
163	7×	if entry.token.is_none() && entry.account.is_none() && entry.ca.is_none() {
164	0×	return Ok(None);
165	7×	}
166	7×	Ok(Some(entry))
167	37×	}
168
169		/// Save a token (and what is known about it) for `hub`.
170	6×	pub fn save(
171	6×	&self,
172	6×	hub: &str,
173	6×	token: &str,
174	6×	account: Option<&str>,
175	6×	ca: Option<&Path>,
176	6×	) -> Result<Stored, String> {
177	6×	let mut all = self.read()?;
178	6×	let helper = self.helper();
179	6×	let entry = all.entry(hub.to_string()).or_insert_with(\|\| HubEntry {
180	6×	hub: hub.to_string(),
181	6×	..HubEntry::default()
182	6×	});
183	6×	entry.account = account.map(String::from).or(entry.account.take());
184	6×	if let Some(ca) = ca {
185	1×	entry.ca = Some(ca.to_path_buf());
186	5×	}
187	6×	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	5×	entry.token = Some(token.to_string());
195	5×	Stored::File(self.path())
196		}
197		};
198	6×	self.write(&all)?;
199	6×	forget_cached();
200	6×	Ok(stored)
201	6×	}
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	46×	fn read(&self) -> Result<BTreeMap<String, HubEntry>, String> {
219	46×	let path = self.path();
220	46×	let text = match std::fs::read_to_string(&path) {
221	15×	Ok(t) => t,
222	31×	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	15×	let mut out = BTreeMap::new();
226	15×	let mut current: Option<HubEntry> = None;
227	100×	for (n, line) in text.lines().enumerate() {
228	100×	let line = line.trim();
229	100×	if line.is_empty() \|\| line.starts_with('#') {
230	37×	continue;
231	63×	}
232	63×	if let Some(hub) = line.strip_prefix('[').and_then(\|l\| l.strip_suffix(']')) {
233	22×	if let Some(e) = current.take() {
234	7×	out.insert(e.hub.clone(), e);
235	15×	}
236	22×	current = Some(HubEntry {
237	22×	hub: hub.trim().to_string(),
238	22×	..HubEntry::default()
239	22×	});
240	22×	continue;
241	41×	}
242	41×	let bad = \|\| {
243	0×	format!(
244		"{} line {}: expected key = \"value\"",
245	0×	path.display(),
246	0×	n + 1
247		)
248	0×	};
249	41×	let (k, v) = line.split_once('=').ok_or_else(bad)?;
250	41×	let v = unquote(v.trim()).ok_or_else(bad)?;
251	41×	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	41×	match k.trim() {
259	41×	"account" => e.account = Some(v),
260	28×	"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	15×	if let Some(e) = current {
267	15×	out.insert(e.hub.clone(), e);
268	15×	}
269	15×	Ok(out)
270	46×	}
271
272	8×	fn write(&self, all: &BTreeMap<String, HubEntry>) -> Result<(), String> {
273	8×	let mut text =
274	8×	String::from("# oxy credentials: a token for each hub. Keep this file private.\n");
275	8×	for e in all.values() {
276	8×	text.push_str(&format!("\n[{}]\n", e.hub));
277	8×	if let Some(a) = &e.account {
278	5×	text.push_str(&format!("account = {}\n", quote(a)));
279	5×	}
280	8×	if let Some(t) = &e.token {
281	7×	text.push_str(&format!("token = {}\n", quote(t)));
282	7×	}
283	8×	if let Some(c) = &e.ca {
284	2×	text.push_str(&format!("ca = {}\n", quote(&c.to_string_lossy())));
285	6×	}
286		}
287	8×	let path = self.path();
288	8×	std::fs::create_dir_all(&self.home)
289	8×	.map_err(\|e\| format!("creating {}: {e}", self.home.display()))?;
290	8×	crate::durable::write_atomic_private(&path, text.as_bytes())
291	8×	.map_err(\|e\| format!("writing {}: {e}", path.display()))
292	8×	}
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	1253×	pub fn lookup(&self, url: &str) -> (Option<String>, Option<PathBuf>) {
298	1253×	let Some(hub) = hub_of(url) else {
299	1086×	return (None, None);
300		};
301	167×	let key = (self.home.clone(), hub.clone());
302	167×	if let Some(hit) = cache().lock().unwrap().get(&key) {
303	134×	return hit.clone();
304	33×	}
305	33×	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	32×	match self.get(&hub) {
313	3×	Ok(Some(e)) => (e.token, e.ca),
314	29×	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	33×	cache().lock().unwrap().insert(key, found.clone());
322	33×	found
323	1253×	}
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	1247×	pub fn options_for(&self, url: &str) -> RemoteOptions {
328	1247×	let env_token = std::env::var("OXY_TOKEN").ok().filter(\|t\| !t.is_empty());
329	1247×	let env_ca = std::env::var("OXY_CA").ok().map(PathBuf::from);
330	1247×	let (token, ca) = match (&env_token, &env_ca) {
331	0×	(Some(_), Some(_)) => (None, None),
332	1247×	_ => self.lookup(url),
333		};
334	1247×	RemoteOptions {
335	1247×	token: env_token.or(token),
336	1247×	ca: env_ca.or(ca),
337	1247×	..RemoteOptions::default()
338	1247×	}
339	1247×	}
340		}
341
342		type Cache = Mutex<HashMap<(PathBuf, String), (Option<String>, Option<PathBuf>)>>;
343
344	208×	fn cache() -> &'static Cache {
345		static CACHE: OnceLock<Cache> = OnceLock::new();
346	208×	CACHE.get_or_init(Default::default)
347	208×	}
348
349	8×	fn forget_cached() {
350	8×	cache().lock().unwrap().clear();
351	8×	}
352
353	2×	pub(crate) fn warn_once(message: &str) {
354		static SEEN: OnceLock<Mutex<std::collections::HashSet<String>>> = OnceLock::new();
355	2×	if SEEN
356	2×	.get_or_init(Default::default)
357	2×	.lock()
358	2×	.unwrap()
359	2×	.insert(message.to_string())
360	2×	{
361	2×	eprintln!("{message}");
362	2×	}
363	2×	}
364
365	14×	fn quote(v: &str) -> String {
366	14×	let mut out = String::from('"');
367	68×	for c in v.chars() {
368	68×	match c {
369	2×	'"' => out.push_str("\\\""),
370	0×	'\\' => out.push_str("\\\\"),
371	0×	'\n' => out.push_str("\\n"),
372	66×	c => out.push(c),
373		}
374		}
375	14×	out.push('"');
376	14×	out
377	14×	}
378
379	41×	fn unquote(v: &str) -> Option<String> {
380	41×	let inner = v.strip_prefix('"')?.strip_suffix('"')?;
381	41×	let mut out = String::new();
382	41×	let mut chars = inner.chars();
383	260×	while let Some(c) = chars.next() {
384	219×	if c == '\\' {
385	8×	match chars.next()? {
386	0×	'n' => out.push('\n'),
387	8×	c => out.push(c),
388		}
389	211×	} else {
390	211×	out.push(c);
391	211×	}
392		}
393	41×	Some(out)
394	41×	}
395
396		/// Run a credential helper (Git's protocol): `get`, `store` or `erase` for
397		/// `hub`. `get` returns the password the helper answered with.
398		///
399		/// `auth.helper` is a helper name (run as `git credential-NAME`), an
400		/// absolute path, or a shell command after `!`, as in Git.
401	4×	fn run_helper(
402	4×	helper: &str,
403	4×	action: &str,
404	4×	hub: &str,
405	4×	token: Option<&str>,
406	4×	) -> Result<Option<String>, String> {
407	4×	let (protocol, host) = hub
408	4×	.split_once("://")
409	4×	.ok_or_else(\|\| format!("{hub} is not a hub URL"))?;
410	4×	let mut cmd = if let Some(shell) = helper.strip_prefix('!') {
411	4×	let mut c = Command::new("sh");
412	4×	c.arg("-c").arg(format!("{shell} {action}"));
413	4×	c
414	0×	} else if Path::new(helper).is_absolute() {
415	0×	let mut c = Command::new(helper);
416	0×	c.arg(action);
417	0×	c
418		} else {
419	0×	let mut c = Command::new("git");
420	0×	c.arg(format!("credential-{helper}")).arg(action);
421	0×	c
422		};
423	4×	let mut input = format!("protocol={protocol}\nhost={host}\nusername={HELPER_USER}\n");
424	4×	if let Some(t) = token {
425	1×	input.push_str(&format!("password={t}\n"));
426	3×	}
427	4×	input.push('\n');
428	4×	let mut child = cmd
429	4×	.stdin(Stdio::piped())
430	4×	.stdout(Stdio::piped())
431	4×	.stderr(Stdio::inherit())
432	4×	.spawn()
433	4×	.map_err(\|e\| format!("running credential helper {helper:?}: {e}"))?;
434	4×	child
435	4×	.stdin
436	4×	.take()
437	4×	.expect("piped")
438	4×	.write_all(input.as_bytes())
439	4×	.map_err(\|e\| format!("credential helper {helper:?}: {e}"))?;
440	4×	let out = child
441	4×	.wait_with_output()
442	4×	.map_err(\|e\| format!("credential helper {helper:?}: {e}"))?;
443	4×	if !out.status.success() {
444	0×	return Err(format!("credential helper {helper:?} {action} failed"));
445	4×	}
446	4×	if action != "get" {
447	2×	return Ok(None);
448	2×	}
449	2×	Ok(String::from_utf8_lossy(&out.stdout)
450	2×	.lines()
451	2×	.find_map(\|l\| l.strip_prefix("password="))
452	2×	.map(String::from)
453	2×	.filter(\|p\| !p.is_empty()))
454	4×	}
455
456		#[cfg(test)]
457		mod tests {
458		use super::*;
459
460		#[test]
461	1×	fn hubs_are_scheme_host_and_port() {
462	1×	assert_eq!(
463	1×	hub_of("https://OxygenHub.io/doomsdayone/metalgear").as_deref(),
464		Some("https://oxygenhub.io")
465		);
466	1×	assert_eq!(
467	1×	hub_of("http://127.0.0.1:7300/a/b").as_deref(),
468		Some("http://127.0.0.1:7300")
469		);
470	1×	assert_eq!(
471	1×	hub_of("https://user:[email protected]/x").as_deref(),
472		Some("https://hub.example")
473		);
474	1×	assert_eq!(hub_of("/srv/repo"), None);
475	1×	assert_eq!(hub_of("file:///srv/repo"), None);
476	1×	}
477
478		#[test]
479	1×	fn tokens_go_over_https_or_to_this_machine() {
480	1×	assert!(token_allowed("https://oxygenhub.io/a/b"));
481	1×	assert!(token_allowed("http://127.0.0.1:7300/a/b"));
482	1×	assert!(token_allowed("http://localhost/a"));
483	1×	assert!(token_allowed("http://[::1]:8080/a"));
484	1×	assert!(!token_allowed("http://oxygenhub.io/a/b"));
485	1×	assert!(!token_allowed("http://10.0.0.1/a"));
486	1×	assert!(!token_allowed("http://127.0.0.1.evil.example/a"));
487	1×	}
488
489		#[test]
490	1×	fn save_get_and_remove_round_trip_privately() {
491	1×	let dir = tempfile::tempdir().unwrap();
492	1×	let store = Credentials::at(dir.path());
493	1×	assert_eq!(store.get("https://hub.example").unwrap(), None);
494	1×	let stored = store
495	1×	.save("https://hub.example", "tok\"en", Some("andy"), None)
496	1×	.unwrap();
497	1×	assert_eq!(stored, Stored::File(store.path()));
498	1×	store
499	1×	.save(
500	1×	"http://127.0.0.1:7300",
501	1×	"local",
502	1×	None,
503	1×	Some(Path::new("/ca.pem")),
504		)
505	1×	.unwrap();
506	1×	let e = store.get("https://hub.example").unwrap().unwrap();
507	1×	assert_eq!(e.token.as_deref(), Some("tok\"en"));
508	1×	assert_eq!(e.account.as_deref(), Some("andy"));
509	1×	assert!(!store.too_open());
510	1×	assert_eq!(
511	1×	store.lookup("https://hub.example/o/r"),
512	1×	(Some("tok\"en".into()), None)
513		);
514		// Another host, scheme or port gets nothing.
515	1×	assert_eq!(store.lookup("https://other.example/o/r"), (None, None));
516	1×	assert_eq!(store.lookup("http://hub.example/o/r"), (None, None));
517	1×	assert_eq!(store.lookup("https://hub.example:8443/o/r"), (None, None));
518	1×	let gone = store.remove("https://hub.example").unwrap().unwrap();
519	1×	assert_eq!(gone.token.as_deref(), Some("tok\"en"));
520	1×	assert_eq!(store.lookup("https://hub.example/o/r"), (None, None));
521	1×	assert_eq!(store.entries().unwrap().len(), 1);
522	1×	}
523
524		#[cfg(unix)]
525		#[test]
526	1×	fn a_file_others_can_read_is_ignored() {
527		use std::os::unix::fs::PermissionsExt;
528	1×	let dir = tempfile::tempdir().unwrap();
529	1×	let store = Credentials::at(dir.path());
530	1×	store.save("https://open.example", "t", None, None).unwrap();
531	1×	let mode = std::fs::metadata(store.path())
532	1×	.unwrap()
533	1×	.permissions()
534	1×	.mode();
535	1×	assert_eq!(mode & 0o777, 0o600);
536	1×	std::fs::set_permissions(store.path(), std::fs::Permissions::from_mode(0o644)).unwrap();
537	1×	assert!(store.too_open());
538	1×	assert_eq!(store.lookup("https://open.example/o/r"), (None, None));
539	1×	}
540
541		#[cfg(unix)]
542		#[test]
543	1×	fn a_helper_keeps_the_token_out_of_the_file() {
544	1×	let dir = tempfile::tempdir().unwrap();
545	1×	let vault = dir.path().join("vault");
546		// A helper that keeps one password in a file, as a keyring would.
547	1×	let helper = format!(
548		"!f() {{ case $1 in get) [ -f {v} ] && echo password=$(cat {v});; store) sed -n 's/^password=//p' > {v};; erase) rm -f {v};; esac; }}; f",
549	1×	v = vault.display()
550		);
551	1×	std::fs::write(
552	1×	dir.path().join("config.toml"),
553	1×	format!("auth.helper = \"{helper}\"\n"),
554		)
555	1×	.unwrap();
556	1×	let store = Credentials::at(dir.path());
557	1×	assert!(store.helper().is_some());
558	1×	let stored = store
559	1×	.save("https://hub.example", "secret", Some("andy"), None)
560	1×	.unwrap();
561	1×	assert!(matches!(stored, Stored::Helper(_)));
562	1×	let text = std::fs::read_to_string(store.path()).unwrap();
563	1×	assert!(!text.contains("secret"), "{text}");
564	1×	assert_eq!(
565	1×	store
566	1×	.get("https://hub.example")
567	1×	.unwrap()
568	1×	.unwrap()
569	1×	.token
570	1×	.as_deref(),
571		Some("secret")
572		);
573	1×	store.remove("https://hub.example").unwrap();
574	1×	assert!(!vault.exists());
575	1×	}
576		}

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

Keyboard