Files
crank/crates/crank-runtime/src/auth.rs
T

392 lines
14 KiB
Rust

use std::collections::BTreeMap;
use base64::{Engine as _, engine::general_purpose::STANDARD};
use crank_core::{AuthConfig, AuthProfile, SecretId};
use serde_json::Value;
use crate::{PreparedRequest, RuntimeError};
#[derive(Clone, PartialEq, Eq)]
pub enum ResolvedAuth {
Bearer { header_name: String, token: String },
Basic { username: String, password: String },
ApiKeyHeader { header_name: String, value: String },
ApiKeyQuery { param_name: String, value: String },
}
impl std::fmt::Debug for ResolvedAuth {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let kind = match self {
Self::Bearer { .. } => "bearer",
Self::Basic { .. } => "basic",
Self::ApiKeyHeader { .. } => "api_key_header",
Self::ApiKeyQuery { .. } => "api_key_query",
};
formatter
.debug_struct("ResolvedAuth")
.field("kind", &kind)
.field("material", &"[REDACTED]")
.finish()
}
}
impl ResolvedAuth {
pub fn from_profile(
profile: &AuthProfile,
secrets: &BTreeMap<SecretId, Value>,
) -> Result<Self, RuntimeError> {
if profile.kind != profile.config.kind() {
return Err(RuntimeError::InvalidAuthProfileConfig {
auth_profile_id: profile.id.as_str().to_owned(),
reason: "auth kind and config kind do not match".to_owned(),
});
}
match &profile.config {
AuthConfig::Bearer(config) => Ok(Self::Bearer {
header_name: config.header_name.clone(),
token: extract_secret_string(secrets, &config.secret_id, &["token", "value"])?,
}),
AuthConfig::Basic(config) => Ok(Self::Basic {
username: extract_secret_string(
secrets,
&config.username_secret_id,
&["username", "value"],
)?,
password: extract_secret_string(
secrets,
&config.password_secret_id,
&["password", "value"],
)?,
}),
AuthConfig::ApiKeyHeader(config) => Ok(Self::ApiKeyHeader {
header_name: config.header_name.clone(),
value: extract_secret_string(secrets, &config.secret_id, &["token", "value"])?,
}),
AuthConfig::ApiKeyQuery(config) => Ok(Self::ApiKeyQuery {
param_name: config.param_name.clone(),
value: extract_secret_string(secrets, &config.secret_id, &["token", "value"])?,
}),
}
}
pub fn apply(&self, prepared_request: &mut PreparedRequest) {
match self {
Self::Bearer { header_name, token } => {
remove_header_case_insensitive(&mut prepared_request.headers, header_name);
prepared_request
.headers
.insert(header_name.clone(), format!("Bearer {token}"));
prepared_request
.trusted_header_names
.insert(header_name.to_ascii_lowercase());
}
Self::Basic { username, password } => {
let credentials = STANDARD.encode(format!("{username}:{password}"));
remove_header_case_insensitive(&mut prepared_request.headers, "Authorization");
prepared_request
.headers
.insert("Authorization".to_owned(), format!("Basic {credentials}"));
prepared_request
.trusted_header_names
.insert("authorization".to_owned());
}
Self::ApiKeyHeader { header_name, value } => {
remove_header_case_insensitive(&mut prepared_request.headers, header_name);
prepared_request
.headers
.insert(header_name.clone(), value.clone());
prepared_request
.trusted_header_names
.insert(header_name.to_ascii_lowercase());
}
Self::ApiKeyQuery { param_name, value } => {
prepared_request
.query_params
.insert(param_name.clone(), value.clone());
}
}
}
}
fn remove_header_case_insensitive(headers: &mut BTreeMap<String, String>, header_name: &str) {
let existing = headers
.keys()
.filter(|candidate| candidate.eq_ignore_ascii_case(header_name))
.cloned()
.collect::<Vec<_>>();
for existing in existing {
headers.remove(&existing);
}
}
pub(crate) fn apply_resolved_auth(
mut prepared_request: PreparedRequest,
resolved_auth: Option<&ResolvedAuth>,
) -> PreparedRequest {
if let Some(resolved_auth) = resolved_auth {
resolved_auth.apply(&mut prepared_request);
}
prepared_request
}
fn extract_secret_string(
secrets: &BTreeMap<SecretId, Value>,
secret_id: &SecretId,
preferred_fields: &[&str],
) -> Result<String, RuntimeError> {
let Some(value) = secrets.get(secret_id) else {
return Err(RuntimeError::MissingSecret {
secret_id: secret_id.as_str().to_owned(),
});
};
if let Some(text) = value.as_str() {
return Ok(text.to_owned());
}
let Some(object) = value.as_object() else {
return Err(RuntimeError::InvalidAuthSecretValue {
secret_id: secret_id.as_str().to_owned(),
reason: "secret payload must be a string or object".to_owned(),
});
};
for field in preferred_fields {
if let Some(text) = object.get(*field).and_then(Value::as_str) {
return Ok(text.to_owned());
}
}
Err(RuntimeError::InvalidAuthSecretValue {
secret_id: secret_id.as_str().to_owned(),
reason: format!(
"secret payload must contain one of: {}",
preferred_fields.join(", ")
),
})
}
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use crank_core::{
ApiKeyHeaderAuthConfig, ApiKeyQueryAuthConfig, AuthConfig, AuthKind, AuthProfile,
BasicAuthConfig, BearerAuthConfig, SecretId, WorkspaceId,
};
use serde_json::json;
use time::{OffsetDateTime, format_description::well_known::Rfc3339};
use crate::{PreparedRequest, auth::ResolvedAuth};
fn timestamp(value: &str) -> OffsetDateTime {
OffsetDateTime::parse(value, &Rfc3339).unwrap()
}
#[test]
fn applies_bearer_auth_to_headers() {
let auth = ResolvedAuth::from_profile(
&AuthProfile {
id: "auth_01".into(),
workspace_id: WorkspaceId::new("ws_default"),
name: "bearer".to_owned(),
kind: AuthKind::Bearer,
config: AuthConfig::Bearer(BearerAuthConfig {
header_name: "Authorization".to_owned(),
secret_id: SecretId::new("secret_token"),
}),
created_at: timestamp("2026-04-07T00:00:00Z"),
updated_at: timestamp("2026-04-07T00:00:00Z"),
},
&BTreeMap::from([(SecretId::new("secret_token"), json!({"token":"abc"}))]),
)
.unwrap();
let mut request = PreparedRequest::default();
auth.apply(&mut request);
assert_eq!(
request.headers.get("Authorization").map(String::as_str),
Some("Bearer abc")
);
}
#[test]
fn bearer_auth_overwrites_untrusted_mapped_header_and_marks_it_trusted() {
let auth = ResolvedAuth::Bearer {
header_name: "Authorization".to_owned(),
token: "system-token".to_owned(),
};
let mut request = PreparedRequest {
headers: BTreeMap::from([
("authorization".to_owned(), "Bearer attacker".to_owned()),
(
"AUTHORIZATION".to_owned(),
"Bearer second-attacker".to_owned(),
),
]),
..PreparedRequest::default()
};
auth.apply(&mut request);
assert_eq!(
request.headers.get("Authorization").map(String::as_str),
Some("Bearer system-token")
);
assert!(!request.headers.contains_key("authorization"));
assert!(!request.headers.contains_key("AUTHORIZATION"));
assert!(request.trusted_header_names.contains("authorization"));
}
#[test]
fn api_key_header_auth_overwrites_untrusted_mapped_header_and_marks_it_trusted() {
let auth = ResolvedAuth::ApiKeyHeader {
header_name: "X-Api-Key".to_owned(),
value: "system-key".to_owned(),
};
let mut request = PreparedRequest {
headers: BTreeMap::from([
("x-api-key".to_owned(), "attacker".to_owned()),
("X-API-KEY".to_owned(), "second-attacker".to_owned()),
]),
..PreparedRequest::default()
};
auth.apply(&mut request);
assert_eq!(
request.headers.get("X-Api-Key").map(String::as_str),
Some("system-key")
);
assert!(!request.headers.contains_key("x-api-key"));
assert!(!request.headers.contains_key("X-API-KEY"));
assert!(request.trusted_header_names.contains("x-api-key"));
}
#[test]
fn rejects_auth_profile_kind_config_mismatch_before_secret_use() {
let error = ResolvedAuth::from_profile(
&AuthProfile {
id: "auth_01".into(),
workspace_id: WorkspaceId::new("ws_default"),
name: "mismatch".to_owned(),
kind: AuthKind::Bearer,
config: AuthConfig::ApiKeyHeader(ApiKeyHeaderAuthConfig {
header_name: "X-Api-Key".to_owned(),
secret_id: SecretId::new("secret_api_key"),
}),
created_at: timestamp("2026-04-07T00:00:00Z"),
updated_at: timestamp("2026-04-07T00:00:00Z"),
},
&BTreeMap::from([(SecretId::new("secret_api_key"), json!("key-123"))]),
)
.unwrap_err();
assert!(matches!(
error,
crate::RuntimeError::InvalidAuthProfileConfig { .. }
));
}
#[test]
fn resolved_auth_debug_never_exposes_secret_material() {
let auth = ResolvedAuth::Bearer {
header_name: "Authorization".to_owned(),
token: "story18-secret-canary".to_owned(),
};
let rendered = format!("{auth:?}");
assert!(!rendered.contains("story18-secret-canary"));
assert!(rendered.contains("[REDACTED]"));
}
#[test]
fn applies_basic_auth_to_headers() {
let auth = ResolvedAuth::from_profile(
&AuthProfile {
id: "auth_01".into(),
workspace_id: WorkspaceId::new("ws_default"),
name: "basic".to_owned(),
kind: AuthKind::Basic,
config: AuthConfig::Basic(BasicAuthConfig {
username_secret_id: SecretId::new("secret_user"),
password_secret_id: SecretId::new("secret_pass"),
}),
created_at: timestamp("2026-04-07T00:00:00Z"),
updated_at: timestamp("2026-04-07T00:00:00Z"),
},
&BTreeMap::from([
(SecretId::new("secret_user"), json!({"username":"demo"})),
(SecretId::new("secret_pass"), json!({"password":"s3cr3t"})),
]),
)
.unwrap();
let mut request = PreparedRequest::default();
auth.apply(&mut request);
assert_eq!(
request.headers.get("Authorization").map(String::as_str),
Some("Basic ZGVtbzpzM2NyM3Q=")
);
}
#[test]
fn applies_api_key_header_auth() {
let auth = ResolvedAuth::from_profile(
&AuthProfile {
id: "auth_01".into(),
workspace_id: WorkspaceId::new("ws_default"),
name: "api-header".to_owned(),
kind: AuthKind::ApiKeyHeader,
config: AuthConfig::ApiKeyHeader(ApiKeyHeaderAuthConfig {
header_name: "X-Api-Key".to_owned(),
secret_id: SecretId::new("secret_api_key"),
}),
created_at: timestamp("2026-04-07T00:00:00Z"),
updated_at: timestamp("2026-04-07T00:00:00Z"),
},
&BTreeMap::from([(SecretId::new("secret_api_key"), json!("key-123"))]),
)
.unwrap();
let mut request = PreparedRequest::default();
auth.apply(&mut request);
assert_eq!(
request.headers.get("X-Api-Key").map(String::as_str),
Some("key-123")
);
}
#[test]
fn applies_api_key_query_auth() {
let auth = ResolvedAuth::from_profile(
&AuthProfile {
id: "auth_01".into(),
workspace_id: WorkspaceId::new("ws_default"),
name: "api-query".to_owned(),
kind: AuthKind::ApiKeyQuery,
config: AuthConfig::ApiKeyQuery(ApiKeyQueryAuthConfig {
param_name: "api_key".to_owned(),
secret_id: SecretId::new("secret_api_key"),
}),
created_at: timestamp("2026-04-07T00:00:00Z"),
updated_at: timestamp("2026-04-07T00:00:00Z"),
},
&BTreeMap::from([(SecretId::new("secret_api_key"), json!({"value":"key-123"}))]),
)
.unwrap();
let mut request = PreparedRequest::default();
auth.apply(&mut request);
assert_eq!(
request.query_params.get("api_key").map(String::as_str),
Some("key-123")
);
}
}