use std::collections::HashMap;
use std::sync::Arc;
use serde::{Deserialize, Serialize};
use secrecy::ExposeSecret;
use crate::cel::{PolicyDecision, PolicyEngine, PolicyInput};
use crate::config::{BackendConfig, Bundle, ResolverMode};
use crate::error::{AgentError, Result};
use crate::auth::JwtVerifier;
use crate::signing::KeyzeroSigner;
use crate::tags::TagMapper;
const VAULT_TOKEN_ENV: &str = "VAULT_TOKEN";
const SIGNING_KEY_PATH_ENV: &str = "KEYZERO_SIGNING_KEY_PATH";
const PROXY_URL_ENV: &str = "KEYZERO_PROXY_URL";
pub fn to_resolve_request(config: &crate::config::ResolverConfig) -> secret_resolvers::Request {
let mut params = std::collections::HashMap::new();
if let Some(ref path) = config.path {
params.insert(secret_resolvers::params::REF.to_string(), toml::Value::String(path.clone()));
}
if let Some(ref field) = config.field {
if config.path.is_none() && config.secret_id.is_none() && config.role_arn.is_none() {
params.insert(secret_resolvers::params::REF.to_string(), toml::Value::String(field.clone()));
} else {
params.insert(secret_resolvers::params::FIELD.to_string(), toml::Value::String(field.clone()));
}
}
if let Some(ref secret_id) = config.secret_id {
params.insert(secret_resolvers::params::REF.to_string(), toml::Value::String(format!("sm://{}", secret_id)));
}
if let Some(ref role_arn) = config.role_arn {
params.insert(secret_resolvers::params::REF.to_string(), toml::Value::String(role_arn.clone()));
}
if let Some(duration) = config.duration_seconds {
params.insert(secret_resolvers::params::DURATION_SECONDS.to_string(), toml::Value::String(duration.to_string()));
}
secret_resolvers::Request::resolve(params)
}
pub fn backend_to_config(backend: &BackendConfig) -> HashMap<String, toml::Value> {
let mut config = HashMap::new();
if let Some(ref addr) = backend.address {
config.insert("address".to_string(), toml::Value::String(addr.clone()));
}
if let Some(ref region) = backend.region {
config.insert("region".to_string(), toml::Value::String(region.clone()));
}
if let Some(ref path) = backend.path {
config.insert("path".to_string(), toml::Value::String(path.clone()));
}
if let Some(ref vault) = backend.vault {
config.insert("vault".to_string(), toml::Value::String(vault.clone()));
}
if let Ok(token) = std::env::var(VAULT_TOKEN_ENV) {
config.insert("token".to_string(), toml::Value::String(token));
}
config
}
#[derive(Debug, Deserialize)]
pub struct ResolveRequest {
pub resource: String,
}
#[derive(Debug, Serialize)]
pub struct SecretEntry {
pub mode: String,
#[serde(skip_serializing_if = "String::is_empty")]
pub value: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub ttl: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub token: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub proxy: Option<String>,
}
#[derive(Debug, Serialize)]
pub struct ResolveResponse {
pub allowed: bool,
pub resource: String,
pub policy: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(skip_serializing_if = "HashMap::is_empty")]
pub secrets: HashMap<String, SecretEntry>,
}
pub struct Pipeline {
bundle: Bundle,
jwt_verifier: JwtVerifier,
tag_mapper: TagMapper,
policy_engine: PolicyEngine,
resolvers: HashMap<String, Arc<dyn secret_resolvers::SecretResolver>>,
signer: Option<KeyzeroSigner>,
proxy_url: Option<String>,
}
impl Pipeline {
pub async fn new(bundle: Bundle) -> Result<Self> {
let jwt_verifier = JwtVerifier::new(bundle.issuers.clone());
let tag_mapper = TagMapper::new(bundle.tag_mappings.clone());
let policy_engine = PolicyEngine::new(bundle.policies.clone())?;
let mut resolvers: HashMap<String, Arc<dyn secret_resolvers::SecretResolver>> = HashMap::new();
for (name, backend_config) in &bundle.backends {
let config = backend_to_config(backend_config);
let resolver = secret_resolvers::registry::create_resolver(
backend_config.backend_type.as_resolver_name(), config,
).await.map_err(|e| AgentError::Config(format!("{} resolver: {e}", name)))?;
resolvers.insert(name.clone(), resolver);
}
let signer = match std::env::var(SIGNING_KEY_PATH_ENV) {
Ok(path) => match std::fs::read(&path) {
Ok(key) => match KeyzeroSigner::new(&key, crate::signing::PROXY_JWT_ISSUER) {
Ok(s) => Some(s),
Err(e) => {
tracing::warn!(path = %path, error = %e, "KEYZERO_SIGNING_KEY_PATH is set but signer initialization failed");
None
}
},
Err(e) => {
tracing::warn!(path = %path, error = %e, "KEYZERO_SIGNING_KEY_PATH is set but key file could not be read");
None
}
},
Err(_) => None,
};
let proxy_url = std::env::var(PROXY_URL_ENV).ok();
Ok(Self {
bundle,
jwt_verifier,
tag_mapper,
policy_engine,
resolvers,
signer,
proxy_url,
})
}
async fn auth_and_authorize(
&self,
token: &str,
resource: &crate::config::Resource,
) -> Result<PolicyDecision> {
let verified_claims = self.jwt_verifier.verify(token).await?;
let caller_tags = self.tag_mapper.map(&verified_claims);
Ok(self.policy_engine.evaluate(&PolicyInput {
caller_tags,
resource_tags: resource.tags.clone(),
claims: verified_claims.claims,
}))
}
pub async fn resolve(&self, token: &str, request: &ResolveRequest) -> Result<ResolveResponse> {
let resource = self
.bundle
.resources
.iter()
.find(|r| r.id == request.resource)
.ok_or_else(|| AgentError::UnknownResource(request.resource.clone()))?;
let decision = self.auth_and_authorize(token, resource).await?;
match decision {
PolicyDecision::Deny { policy, reason } => Ok(ResolveResponse {
allowed: false,
resource: request.resource.clone(),
policy,
reason: Some(reason),
secrets: HashMap::new(),
}),
PolicyDecision::Allow { policy } => {
let mut secrets = HashMap::new();
for resolver_config in &resource.resolvers {
match resolver_config.mode {
ResolverMode::Direct => {
let backend =
self.resolvers
.get(&resolver_config.backend)
.ok_or_else(|| {
AgentError::SecretResolution(format!(
"backend '{}' not found for resolver '{}'",
resolver_config.backend, resolver_config.name
))
})?;
let request = to_resolve_request(resolver_config);
let resolved = backend.resolve(&request).await
.map_err(|e| AgentError::SecretResolution(e.to_string()))?;
secrets.insert(
resolver_config.name.clone(),
SecretEntry {
mode: "direct".into(),
value: resolved.value.expose_secret().to_string(),
ttl: resolver_config.ttl,
token: None,
proxy: None,
},
);
}
ResolverMode::ShortLived => {
if let Some(signer) = &self.signer {
let ttl = resolver_config.ttl.unwrap_or(300);
let token = signer.sign_short_lived(
&request.resource,
&resolver_config.name,
ttl,
)?;
secrets.insert(
resolver_config.name.clone(),
SecretEntry {
mode: "short_lived".into(),
value: String::new(),
ttl: Some(ttl),
token: Some(token),
proxy: self.proxy_url.clone(),
},
);
} else {
return Err(AgentError::Config(
format!("short_lived mode requires {SIGNING_KEY_PATH_ENV}").into(),
));
}
}
}
}
Ok(ResolveResponse {
allowed: true,
resource: request.resource.clone(),
policy,
reason: None,
secrets,
})
}
}
}
pub async fn resolve_single(
&self,
token: &str,
resource_id: &str,
resolver_name: &str,
) -> Result<(String, crate::config::ResolverConfig)> {
let resource = self
.bundle
.resources
.iter()
.find(|r| r.id == resource_id)
.ok_or_else(|| AgentError::UnknownResource(resource_id.into()))?;
let decision = self.auth_and_authorize(token, resource).await?;
match decision {
PolicyDecision::Deny { policy, reason } => Err(
AgentError::SecretResolution(format!("denied by policy '{policy}': {reason}")),
),
PolicyDecision::Allow { .. } => {
let resolver_config = resource
.resolvers
.iter()
.find(|r| r.name == resolver_name)
.ok_or_else(|| {
AgentError::Config(format!(
"resolver '{resolver_name}' not found on resource '{resource_id}'"
))
})?;
let backend = self
.resolvers
.get(&resolver_config.backend)
.ok_or_else(|| {
AgentError::SecretResolution(format!(
"backend '{}' not found",
resolver_config.backend
))
})?;
let request = to_resolve_request(resolver_config);
let resolved = backend.resolve(&request).await
.map_err(|e| AgentError::SecretResolution(e.to_string()))?;
Ok((resolved.value.expose_secret().to_string(), resolver_config.clone()))
}
}
}
pub fn into_resolvers(self) -> HashMap<String, Arc<dyn secret_resolvers::SecretResolver>> {
self.resolvers
}
}