#![cfg(feature = "kas-client")]
use opentdf_protocol::KasError;
use serde::Deserialize;
#[derive(Debug, Clone, Deserialize)]
pub struct OpentdfConfiguration {
pub kas: Option<KasConfig>,
pub idp: Option<IdpConfig>,
pub platform_issuer: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct KasConfig {
pub uri: String,
#[serde(default)]
pub algorithms: Vec<String>,
pub public_key_url: Option<String>,
pub rewrap_url: Option<String>,
pub connect_public_key_url: Option<String>,
pub connect_rewrap_url: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct IdpConfig {
pub issuer: String,
pub jwks_uri: Option<String>,
pub cose_keys_uri: Option<String>,
pub token_endpoint: Option<String>,
pub authorization_endpoint: Option<String>,
pub userinfo_endpoint: Option<String>,
pub access_token_format: Option<String>,
#[serde(default)]
pub id_token_signing_alg_values_supported: Vec<String>,
#[serde(default)]
pub response_types_supported: Vec<String>,
#[serde(default)]
pub subject_types_supported: Vec<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KasTransport {
Connect,
LegacyRest,
}
impl OpentdfConfiguration {
pub fn for_kas_connect(base_url: impl Into<String>) -> Self {
let base = base_url.into();
let base = base.trim_end_matches('/').to_string();
Self {
kas: Some(KasConfig {
uri: base.clone(),
algorithms: vec![],
public_key_url: None,
rewrap_url: None,
connect_public_key_url: Some(format!("{}/kas.AccessService/PublicKey", base)),
connect_rewrap_url: Some(format!("{}/kas.AccessService/Rewrap", base)),
}),
idp: None,
platform_issuer: None,
}
}
pub fn for_kas_legacy_rest(base_url: impl Into<String>) -> Self {
let base = base_url.into();
let base = base.trim_end_matches('/').to_string();
Self {
kas: Some(KasConfig {
uri: base.clone(),
algorithms: vec![],
public_key_url: Some(format!("{}/kas/v2/kas_public_key", base)),
rewrap_url: Some(format!("{}/kas/v2/rewrap", base)),
connect_public_key_url: None,
connect_rewrap_url: None,
}),
idp: None,
platform_issuer: None,
}
}
}
#[derive(Debug, Clone)]
pub struct KasEndpoints {
pub rewrap_url: String,
pub public_key_url: String,
pub transport: KasTransport,
}
impl KasEndpoints {
pub fn from_config(cfg: &OpentdfConfiguration) -> Result<Self, KasError> {
let kas = cfg.kas.as_ref().ok_or_else(|| KasError::ConfigError {
reason: "well-known configuration is missing a 'kas' block".to_string(),
})?;
let endpoints = if let (Some(rewrap), Some(public_key)) =
(&kas.connect_rewrap_url, &kas.connect_public_key_url)
{
KasEndpoints {
rewrap_url: rewrap.clone(),
public_key_url: public_key.clone(),
transport: KasTransport::Connect,
}
} else if let (Some(rewrap), Some(public_key)) = (&kas.rewrap_url, &kas.public_key_url) {
KasEndpoints {
rewrap_url: rewrap.clone(),
public_key_url: public_key.clone(),
transport: KasTransport::LegacyRest,
}
} else {
return Err(KasError::ConfigError {
reason: "well-known kas block exposes neither Connect nor REST URLs".to_string(),
});
};
validate_kas_url(&endpoints.rewrap_url)?;
validate_kas_url(&endpoints.public_key_url)?;
Ok(endpoints)
}
}
pub fn validate_kas_url(url_str: &str) -> Result<(), KasError> {
use std::net::IpAddr;
let parsed = url::Url::parse(url_str)
.map_err(|e| KasError::InvalidUrl(format!("Failed to parse URL: {e}")))?;
match parsed.scheme() {
"https" => {}
"http" => {
let is_loopback = match parsed.host() {
Some(url::Host::Domain("localhost")) => true,
Some(url::Host::Ipv4(ip)) => ip.is_loopback(),
Some(url::Host::Ipv6(ip)) => ip.is_loopback(),
_ => false,
};
if !is_loopback {
return Err(KasError::InvalidUrl(
"KAS URL must use HTTPS (HTTP only allowed for localhost)".to_string(),
));
}
}
scheme => {
return Err(KasError::InvalidUrl(format!(
"Unsupported URL scheme '{scheme}', must be https"
)));
}
}
let ip = match parsed.host() {
Some(url::Host::Ipv4(v4)) => Some(IpAddr::V4(v4)),
Some(url::Host::Ipv6(v6)) => Some(IpAddr::V6(v6).to_canonical()),
_ => None,
};
if let Some(ip) = ip
&& is_blocked_ip(&ip)
{
return Err(KasError::InvalidUrl(
"KAS URL must not target private or link-local IP addresses".to_string(),
));
}
Ok(())
}
fn is_blocked_ip(ip: &std::net::IpAddr) -> bool {
use std::net::IpAddr;
match ip {
IpAddr::V4(v4) => v4.is_private() || v4.is_link_local() || v4.is_unspecified(),
IpAddr::V6(v6) => {
if v6.is_unspecified() {
return true;
}
let first = v6.segments()[0];
(first & 0xfe00) == 0xfc00 || (first & 0xffc0) == 0xfe80
}
}
}
#[derive(Debug, Clone, Deserialize)]
pub struct ConnectError {
pub code: String,
pub message: String,
}
pub fn parse_connect_error(body: &str) -> Option<ConnectError> {
if body.is_empty() {
return None;
}
let parsed: ConnectError = serde_json::from_str(body).ok()?;
if parsed.code.is_empty() {
return None;
}
Some(parsed)
}
pub async fn fetch_well_known(
platform_url: &str,
http_client: &reqwest::Client,
) -> Result<OpentdfConfiguration, KasError> {
let base = platform_url.trim_end_matches('/');
let url = format!("{}/.well-known/opentdf-configuration", base);
let response = http_client
.get(&url)
.send()
.await
.map_err(|e| KasError::RequestError {
method: "GET".to_string(),
url: url.clone(),
reason: e.to_string(),
})?;
let status = response.status();
if !status.is_success() {
let body = response.text().await.unwrap_or_default();
return Err(KasError::HttpError {
status: status.as_u16(),
message: format!("GET {} -> {}: {}", url, status, body),
});
}
response
.json::<OpentdfConfiguration>()
.await
.map_err(|e| KasError::InvalidResponse {
reason: format!("Failed to parse well-known JSON: {}", e),
expected: Some("OpentdfConfiguration".to_string()),
})
}
#[cfg(test)]
mod tests {
use super::*;
const PLATFORM_WELL_KNOWN: &str = r#"{
"health": { "endpoint": "/healthz" },
"idp": {
"access_token_format": "application/cwt",
"authorization_endpoint": "https://identity.arkavo.net/oauth/authorize",
"cose_keys_uri": "https://identity.arkavo.net/.well-known/cose-keys",
"id_token_signing_alg_values_supported": ["ES256"],
"issuer": "https://identity.arkavo.net",
"jwks_uri": "https://identity.arkavo.net/.well-known/jwks.json",
"response_types_supported": ["code"],
"subject_types_supported": ["public"],
"token_endpoint": "https://identity.arkavo.net/oauth/token",
"userinfo_endpoint": "https://identity.arkavo.net/oauth/userinfo"
},
"kas": {
"algorithms": ["ec:secp256r1", "rsa:2048"],
"connect_public_key_url": "https://platform.arkavo.net/kas.AccessService/PublicKey",
"connect_rewrap_url": "https://platform.arkavo.net/kas.AccessService/Rewrap",
"public_key_url": "https://platform.arkavo.net/kas/v2/kas_public_key",
"rewrap_url": "https://platform.arkavo.net/kas/v2/rewrap",
"uri": "https://platform.arkavo.net"
},
"platform_issuer": "https://identity.arkavo.net"
}"#;
#[test]
fn deserializes_platform_well_known() {
let cfg: OpentdfConfiguration = serde_json::from_str(PLATFORM_WELL_KNOWN).unwrap();
let kas = cfg.kas.expect("kas block present");
assert_eq!(kas.uri, "https://platform.arkavo.net");
assert_eq!(kas.algorithms, vec!["ec:secp256r1", "rsa:2048"]);
assert_eq!(
kas.connect_rewrap_url.as_deref(),
Some("https://platform.arkavo.net/kas.AccessService/Rewrap")
);
assert_eq!(
kas.rewrap_url.as_deref(),
Some("https://platform.arkavo.net/kas/v2/rewrap")
);
let idp = cfg.idp.expect("idp block present");
assert_eq!(idp.issuer, "https://identity.arkavo.net");
assert_eq!(idp.access_token_format.as_deref(), Some("application/cwt"));
assert_eq!(
cfg.platform_issuer.as_deref(),
Some("https://identity.arkavo.net")
);
}
#[test]
fn deserializes_minimal_kas_only() {
let json = r#"{
"kas": {
"uri": "https://k.example.com",
"algorithms": [],
"rewrap_url": "https://k.example.com/kas/v2/rewrap",
"public_key_url": "https://k.example.com/kas/v2/kas_public_key"
}
}"#;
let cfg: OpentdfConfiguration = serde_json::from_str(json).unwrap();
let kas = cfg.kas.unwrap();
assert!(kas.connect_rewrap_url.is_none());
assert_eq!(
kas.rewrap_url.as_deref(),
Some("https://k.example.com/kas/v2/rewrap")
);
assert!(cfg.idp.is_none());
}
#[test]
fn from_config_picks_connect_when_present() {
let cfg: OpentdfConfiguration = serde_json::from_str(PLATFORM_WELL_KNOWN).unwrap();
let endpoints = KasEndpoints::from_config(&cfg).unwrap();
assert_eq!(
endpoints.rewrap_url,
"https://platform.arkavo.net/kas.AccessService/Rewrap"
);
assert_eq!(
endpoints.public_key_url,
"https://platform.arkavo.net/kas.AccessService/PublicKey"
);
assert_eq!(endpoints.transport, KasTransport::Connect);
}
#[test]
fn from_config_falls_back_to_rest_when_connect_absent() {
let json = r#"{
"kas": {
"uri": "https://k.example.com",
"algorithms": [],
"rewrap_url": "https://k.example.com/kas/v2/rewrap",
"public_key_url": "https://k.example.com/kas/v2/kas_public_key"
}
}"#;
let cfg: OpentdfConfiguration = serde_json::from_str(json).unwrap();
let endpoints = KasEndpoints::from_config(&cfg).unwrap();
assert_eq!(endpoints.rewrap_url, "https://k.example.com/kas/v2/rewrap");
assert_eq!(
endpoints.public_key_url,
"https://k.example.com/kas/v2/kas_public_key"
);
assert_eq!(endpoints.transport, KasTransport::LegacyRest);
}
#[test]
fn from_config_errors_when_kas_block_missing() {
let json = r#"{ "platform_issuer": "https://example.com" }"#;
let cfg: OpentdfConfiguration = serde_json::from_str(json).unwrap();
let err = KasEndpoints::from_config(&cfg).unwrap_err();
match err {
opentdf_protocol::KasError::ConfigError { reason } => {
assert!(reason.contains("kas"));
}
other => panic!("expected ConfigError, got {other:?}"),
}
}
#[test]
fn from_config_errors_when_urls_missing() {
let json = r#"{
"kas": { "uri": "https://k.example.com", "algorithms": [] }
}"#;
let cfg: OpentdfConfiguration = serde_json::from_str(json).unwrap();
let err = KasEndpoints::from_config(&cfg).unwrap_err();
assert!(matches!(
err,
opentdf_protocol::KasError::ConfigError { .. }
));
}
#[test]
fn for_kas_connect_constructs_expected_urls() {
let cfg = OpentdfConfiguration::for_kas_connect("https://kas.example.com");
let endpoints = KasEndpoints::from_config(&cfg).unwrap();
assert_eq!(
endpoints.rewrap_url,
"https://kas.example.com/kas.AccessService/Rewrap"
);
assert_eq!(
endpoints.public_key_url,
"https://kas.example.com/kas.AccessService/PublicKey"
);
assert_eq!(endpoints.transport, KasTransport::Connect);
}
#[test]
fn for_kas_connect_handles_trailing_slash() {
let cfg = OpentdfConfiguration::for_kas_connect("https://kas.example.com/");
let endpoints = KasEndpoints::from_config(&cfg).unwrap();
assert_eq!(
endpoints.rewrap_url,
"https://kas.example.com/kas.AccessService/Rewrap"
);
}
#[test]
fn for_kas_legacy_rest_constructs_expected_urls() {
let cfg = OpentdfConfiguration::for_kas_legacy_rest("https://kas.example.com");
let endpoints = KasEndpoints::from_config(&cfg).unwrap();
assert_eq!(
endpoints.rewrap_url,
"https://kas.example.com/kas/v2/rewrap"
);
assert_eq!(
endpoints.public_key_url,
"https://kas.example.com/kas/v2/kas_public_key"
);
assert_eq!(endpoints.transport, KasTransport::LegacyRest);
}
#[test]
fn validate_kas_url_accepts_https_and_loopback_http() {
assert!(validate_kas_url("https://kas.example.com/kas.AccessService/Rewrap").is_ok());
assert!(validate_kas_url("http://localhost:8080/x").is_ok());
assert!(validate_kas_url("http://127.0.0.1:8080/x").is_ok());
assert!(validate_kas_url("http://[::1]:8080/x").is_ok());
}
#[test]
fn validate_kas_url_rejects_non_loopback_http_and_bad_scheme() {
assert!(matches!(
validate_kas_url("http://evil.com/x"),
Err(KasError::InvalidUrl(_))
));
assert!(matches!(
validate_kas_url("ftp://kas.example.com/x"),
Err(KasError::InvalidUrl(_))
));
}
#[test]
fn validate_kas_url_rejects_ipv4_private_and_link_local() {
for url in [
"https://10.0.0.1/x",
"https://172.16.0.1/x",
"https://192.168.1.1/x",
"https://169.254.169.254/x",
] {
assert!(
matches!(validate_kas_url(url), Err(KasError::InvalidUrl(_))),
"{url} should be rejected"
);
}
}
#[test]
fn validate_kas_url_rejects_ipv6_ula_and_link_local() {
for url in [
"https://[fd00::1]/x", "https://[fc00::1]/x", "https://[fe80::1]/x", ] {
assert!(
matches!(validate_kas_url(url), Err(KasError::InvalidUrl(_))),
"{url} should be rejected"
);
}
}
#[test]
fn validate_kas_url_rejects_unspecified_addresses() {
assert!(matches!(
validate_kas_url("https://0.0.0.0/x"),
Err(KasError::InvalidUrl(_))
));
assert!(matches!(
validate_kas_url("https://[::]/x"),
Err(KasError::InvalidUrl(_))
));
}
#[test]
fn validate_kas_url_rejects_ipv4_mapped_metadata_address() {
assert!(matches!(
validate_kas_url("https://[::ffff:169.254.169.254]/x"),
Err(KasError::InvalidUrl(_))
));
assert!(matches!(
validate_kas_url("https://[::ffff:10.0.0.1]/x"),
Err(KasError::InvalidUrl(_))
));
}
#[test]
fn from_config_rejects_hostile_connect_url() {
let json = r#"{
"kas": {
"uri": "https://platform.example.com",
"algorithms": [],
"connect_rewrap_url": "https://169.254.169.254/kas.AccessService/Rewrap",
"connect_public_key_url": "https://platform.example.com/kas.AccessService/PublicKey"
}
}"#;
let cfg: OpentdfConfiguration = serde_json::from_str(json).unwrap();
assert!(matches!(
KasEndpoints::from_config(&cfg),
Err(KasError::InvalidUrl(_))
));
}
#[test]
fn parse_connect_error_with_valid_body() {
let body = r#"{"code":"unauthenticated","message":"missing bearer token"}"#;
let err = parse_connect_error(body).unwrap();
assert_eq!(err.code, "unauthenticated");
assert_eq!(err.message, "missing bearer token");
}
#[test]
fn parse_connect_error_with_garbage_returns_none() {
assert!(parse_connect_error("not json").is_none());
assert!(parse_connect_error("").is_none());
assert!(parse_connect_error(r#"{"unrelated":"shape"}"#).is_none());
}
use mockito::Server;
#[tokio::test]
async fn fetch_well_known_returns_parsed_config() {
let mut server = Server::new_async().await;
let _m = server
.mock("GET", "/.well-known/opentdf-configuration")
.with_status(200)
.with_header("content-type", "application/json")
.with_body(PLATFORM_WELL_KNOWN)
.create_async()
.await;
let http = reqwest::Client::new();
let cfg = fetch_well_known(&server.url(), &http).await.unwrap();
assert!(cfg.kas.is_some());
assert_eq!(
cfg.platform_issuer.as_deref(),
Some("https://identity.arkavo.net")
);
}
#[tokio::test]
async fn fetch_well_known_404_returns_http_error() {
let mut server = Server::new_async().await;
let _m = server
.mock("GET", "/.well-known/opentdf-configuration")
.with_status(404)
.with_body("not found")
.create_async()
.await;
let http = reqwest::Client::new();
let err = fetch_well_known(&server.url(), &http).await.unwrap_err();
match err {
opentdf_protocol::KasError::HttpError { status, .. } => assert_eq!(status, 404),
other => panic!("expected HttpError(404), got {other:?}"),
}
}
#[tokio::test]
async fn fetch_well_known_handles_trailing_slash() {
let mut server = Server::new_async().await;
let _m = server
.mock("GET", "/.well-known/opentdf-configuration")
.with_status(200)
.with_body(PLATFORM_WELL_KNOWN)
.create_async()
.await;
let http = reqwest::Client::new();
let url_with_slash = format!("{}/", server.url());
let cfg = fetch_well_known(&url_with_slash, &http).await.unwrap();
assert!(cfg.kas.is_some());
}
}