Skip to main content

graphrt_bundle/
secrets.rs

1//! Guard against secrets travelling inside bundles.
2
3use crate::error::BundleError;
4
5/// Keys whose literal string values are credentials.
6const SECRET_KEYS: &[&str] = &[
7    "api_key",
8    "apikey",
9    "api-key",
10    "x-api-key",
11    "secret",
12    "secret_key",
13    "client_secret",
14    "token",
15    "access_token",
16    "bearer_token",
17    "session_token",
18    "password",
19    "secret_access_key",
20    "authorization",
21    "private_key",
22];
23
24/// Fail when `value` contains an inline credential: a non-empty string under a
25/// secret-looking key (`api_key`, `token`, `password`, an `Authorization` header...)
26/// that is not an environment reference (`${VAR}`). Keys ending in `_env` name a
27/// variable and are allowed. `what` names the file in the error message.
28pub fn check_no_inline_secrets(value: &serde_json::Value, what: &str) -> Result<(), BundleError> {
29    let mut path = Vec::new();
30    walk(value, &mut path, what)
31}
32
33fn walk(value: &serde_json::Value, path: &mut Vec<String>, what: &str) -> Result<(), BundleError> {
34    match value {
35        serde_json::Value::Object(map) => {
36            for (key, child) in map {
37                if is_secret_key(key) {
38                    if let serde_json::Value::String(s) = child {
39                        if !s.trim().is_empty() && !is_env_reference(s) {
40                            path.push(key.clone());
41                            let at = path.join(".");
42                            return Err(BundleError::Secret(format!(
43                                "{what}: `{at}` holds an inline secret; bundles never carry credentials — \
44                                 reference an environment variable (`{key}_env` or `${{VAR}}`) instead"
45                            )));
46                        }
47                    }
48                }
49                path.push(key.clone());
50                walk(child, path, what)?;
51                path.pop();
52            }
53            Ok(())
54        }
55        serde_json::Value::Array(items) => {
56            for (i, child) in items.iter().enumerate() {
57                path.push(i.to_string());
58                walk(child, path, what)?;
59                path.pop();
60            }
61            Ok(())
62        }
63        _ => Ok(()),
64    }
65}
66
67fn is_secret_key(key: &str) -> bool {
68    let k = key.to_ascii_lowercase();
69    if k.ends_with("_env") || k.ends_with("_var") {
70        return false;
71    }
72    SECRET_KEYS.contains(&k.as_str()) || k.ends_with("_secret") || k.ends_with("_password") || k.ends_with("_token")
73}
74
75/// `${VAR}` (optionally with surrounding text such as `Bearer ${TOKEN}`).
76fn is_env_reference(value: &str) -> bool {
77    value.contains("${") && value.contains('}')
78}
79
80#[cfg(test)]
81mod tests {
82    use super::*;
83
84    #[test]
85    fn detects_inline_secrets() {
86        let ok = serde_json::json!({"providers": [{"name": "openai", "api_key_env": "OPENAI_API_KEY",
87            "headers": {"Authorization": "Bearer ${TOKEN}"}}]});
88        assert!(check_no_inline_secrets(&ok, "providers.yaml").is_ok());
89
90        let bad = serde_json::json!({"providers": [{"name": "openai", "api_key": "sk-123"}]});
91        let err = check_no_inline_secrets(&bad, "providers.yaml").unwrap_err().to_string();
92        assert!(err.contains("providers.0.api_key"), "{err}");
93        assert!(!err.contains("sk-123"));
94
95        let header = serde_json::json!({"headers": {"Authorization": "Bearer abc"}});
96        assert!(check_no_inline_secrets(&header, "x").is_err());
97        let custom = serde_json::json!({"crm_token": "t"});
98        assert!(check_no_inline_secrets(&custom, "x").is_err());
99    }
100}