systemprompt_security/credential/
mod.rs

1//! One model for every upstream credential this instance holds.
2//!
3//! A secret is parsed once into a [`ProviderCredential`]; everything
4//! downstream asks the credential for its scope and its auth header and never
5//! inspects the secret again. That single rule is what makes the next
6//! credential type — a workload identity, an OIDC client, a scoped key with a
7//! tenant id — a new variant here rather than another branch in the gateway,
8//! the loader and the bridge.
9//!
10//! The kinds are told apart by the secret's own content rather than by a
11//! catalog flag. A Google service-account key is a JSON document that names
12//! itself in a `type` field (`"service_account"`), which is an explicit,
13//! Google-defined self-description rather than a guess about shape; anything
14//! that is not such a document is an API key. So the provider catalog carries
15//! no credential-type column, and an operator who pastes a service account
16//! gets the right behaviour without having to know a flag exists.
17//! [`ProviderCredential::parse`] is the only place that decision is made.
18//!
19//! A minted token is cached under the secret *name*, not its value, so two
20//! providers sharing a secret share one minted token.
21//!
22//! Copyright (c) systemprompt.io — Business Source License 1.1.
23//! See <https://systemprompt.io> for licensing details.
24
25pub mod cache;
26mod error;
27pub(crate) mod http;
28mod scope;
29
30use std::fmt;
31
32pub use error::CredentialError;
33pub use scope::{
34    AuthHeader, AuthScheme, CredentialScope, PROJECT_PLACEHOLDER, REGION_PLACEHOLDER, fill_endpoint,
35};
36
37use crate::google::{SERVICE_ACCOUNT_TYPE, ServiceAccountKey, access_token};
38
39#[derive(Debug, serde::Deserialize)]
40struct SelfDescription {
41    #[serde(rename = "type")]
42    kind: Option<String>,
43}
44
45/// An API key, held in a type that will not print itself. `expose` hands out
46/// the key itself; every call site is one that is about to send it.
47#[derive(Clone, PartialEq, Eq)]
48pub struct ApiKeySecret(String);
49
50impl ApiKeySecret {
51    #[must_use]
52    pub fn expose(&self) -> &str {
53        &self.0
54    }
55}
56
57impl fmt::Debug for ApiKeySecret {
58    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
59        f.write_str("ApiKeySecret(<redacted>)")
60    }
61}
62
63/// What kind of credential a secret turned out to hold.
64///
65/// Stable strings: they key the token cache and name the kind in operator
66/// output, so they are not derived from the variant name.
67#[derive(Debug, Clone, Copy, PartialEq, Eq)]
68pub enum CredentialKind {
69    ApiKey,
70    GoogleServiceAccount,
71}
72
73impl CredentialKind {
74    #[must_use]
75    pub const fn as_str(self) -> &'static str {
76        match self {
77            Self::ApiKey => "api_key",
78            Self::GoogleServiceAccount => "google_service_account",
79        }
80    }
81}
82
83/// A credential an upstream provider will accept, parsed from its secret.
84///
85/// An API key is the credential and is sent verbatim; a Google service-account
86/// key is exchanged for a short-lived OAuth bearer token. `scope` is the
87/// coordinates the credential supplies to the endpoint it authenticates, and
88/// `fill_endpoint` resolves a catalog endpoint template against them.
89#[derive(Debug, Clone)]
90pub enum ProviderCredential {
91    ApiKey(ApiKeySecret),
92    GoogleServiceAccount(Box<ServiceAccountKey>),
93}
94
95impl ProviderCredential {
96    pub fn parse(secret: &str) -> Result<Self, CredentialError> {
97        let self_described = serde_json::from_str::<SelfDescription>(secret)
98            .is_ok_and(|probe| probe.kind.as_deref() == Some(SERVICE_ACCOUNT_TYPE));
99        if !self_described {
100            return Ok(Self::ApiKey(ApiKeySecret(secret.to_owned())));
101        }
102        serde_json::from_str::<ServiceAccountKey>(secret)
103            .map(|key| Self::GoogleServiceAccount(Box::new(key)))
104            .map_err(CredentialError::Malformed)
105    }
106
107    #[must_use]
108    pub const fn kind(&self) -> CredentialKind {
109        match self {
110            Self::ApiKey(_) => CredentialKind::ApiKey,
111            Self::GoogleServiceAccount(_) => CredentialKind::GoogleServiceAccount,
112        }
113    }
114
115    #[must_use]
116    pub fn scope(&self) -> CredentialScope {
117        match self {
118            Self::ApiKey(_) => CredentialScope::empty(),
119            Self::GoogleServiceAccount(key) => CredentialScope {
120                project: Some(key.project_id.clone()),
121                region: None,
122                principal: Some(key.client_email.clone()),
123            },
124        }
125    }
126
127    pub async fn bearer(&self, cache_key: &str) -> Result<AuthHeader, CredentialError> {
128        match self {
129            Self::ApiKey(key) => Ok(AuthHeader {
130                scheme: AuthScheme::ApiKey,
131                value: key.expose().to_owned(),
132            }),
133            Self::GoogleServiceAccount(key) => {
134                let key_id = format!("{}:{cache_key}", self.kind().as_str());
135                Ok(AuthHeader {
136                    scheme: AuthScheme::Bearer,
137                    value: access_token(&key_id, key).await?,
138                })
139            },
140        }
141    }
142
143    pub fn fill_endpoint(&self, template: &str) -> Result<String, CredentialError> {
144        fill_endpoint(template, &self.scope())
145    }
146}
systemprompt_security/credential/mod.rs

systemprompt_security/credential/
mod.rs
