use anyhow::{bail, Context, Result}; use serde::Deserialize; use std::path::PathBuf; /// Written by services/identity/pass-broker.nix; path in $PASS_BROKER_CONFIG. #[derive(Deserialize)] pub struct Config { pub host: String, pub default_vault: String, /// Peer uids are checked against these; root is always allowed. pub allowed_users: Vec, pub pass_cli: String, pub session_dir: PathBuf, pub pat_file: PathBuf, pub approval_timeout_secs: u64, pub approval: ApprovalConfig, /// First match wins; no match means deny. pub rules: Vec, } /// Who shows the prompt: this broker's own bot, or the shared gateway. #[derive(Deserialize)] #[serde(rename_all = "snake_case")] pub enum ApprovalConfig { Telegram(TelegramConfig), Gateway(GatewayClientConfig), } #[derive(Deserialize)] pub struct TelegramConfig { pub api_base: String, pub token_file: PathBuf, pub chat_id_file: PathBuf, } #[derive(Deserialize)] pub struct GatewayClientConfig { pub url: String, pub token_file: PathBuf, } /// Written by services/identity/pass-broker-gateway.nix; path in /// $PASS_BROKER_GATEWAY_CONFIG. #[derive(Deserialize)] pub struct GatewayConfig { pub listen: String, pub telegram: TelegramConfig, /// Hashes only: the gateway host never holds a broker's token. pub hosts: Vec, pub max_timeout_secs: u64, } #[derive(Deserialize)] pub struct GatewayHost { pub name: String, pub token_sha256: String, } pub fn load(var: &str) -> Result { let path = std::env::var(var).with_context(|| format!("{var} unset"))?; let text = std::fs::read_to_string(&path).with_context(|| format!("reading {path}"))?; serde_json::from_str(&text).with_context(|| format!("parsing {path}")) } #[derive(Deserialize)] pub struct Rule { pub vault: Option, /// Item title; `*` matches any run of characters. pub item: String, pub approval: Approval, /// After an approval, further requests for the item skip the prompt for this long. pub grant_minutes: u64, } #[derive(Deserialize, Clone, Copy, PartialEq, Debug)] #[serde(rename_all = "snake_case")] pub enum Approval { Auto, Ask, Deny, } impl Config { pub fn load() -> Result { load("PASS_BROKER_CONFIG") } pub fn rule_for(&self, vault: &str, item: &str) -> Option<&Rule> { self.rules.iter().find(|r| { r.vault.as_deref().unwrap_or(&self.default_vault) == vault && glob(&r.item, item) }) } /// Resolved once at startup: a user added later needs a broker restart. pub fn allowed_uids(&self) -> Result> { let passwd = std::fs::read_to_string("/etc/passwd")?; let mut uids = vec![0]; for name in &self.allowed_users { let uid = passwd .lines() .map(|l| l.split(':').collect::>()) .find(|f| f.len() > 2 && f[0] == name) .and_then(|f| f[2].parse().ok()); match uid { Some(uid) => uids.push(uid), None => bail!("allowed user {name:?} not in /etc/passwd"), } } Ok(uids) } } fn glob(pat: &str, s: &str) -> bool { let parts: Vec<&str> = pat.split('*').collect(); if parts.len() == 1 { return pat == s; } let (first, last) = (parts[0], parts[parts.len() - 1]); if !s.starts_with(first) || s.len() < first.len() + last.len() || !s.ends_with(last) { return false; } let mut rest = &s[first.len()..s.len() - last.len()]; for mid in &parts[1..parts.len() - 1] { match rest.find(mid) { Some(i) => rest = &rest[i + mid.len()..], None => return false, } } true } #[cfg(test)] mod tests { use super::glob; #[test] fn globs() { assert!(glob("root@*", "root@jupiter")); assert!(!glob("root@*", "darman@jupiter")); assert!(glob("*", "")); assert!(glob("a*b*c", "aXbYc")); assert!(!glob("a*b*c", "acb")); assert!(!glob("ab*ba", "aba")); assert!(glob("exact", "exact")); assert!(!glob("exact", "exact2")); } }