use serde::{Deserialize, Serialize};
use thiserror::Error;
#[cfg(feature = "kas-client")]
use reqwest::Client;
#[cfg(feature = "kas-client")]
use aws_lc_rs::rsa::PublicEncryptingKey;
#[cfg(feature = "kas-client")]
use crate::p256::{PublicKey as P256PublicKey, pkcs8::DecodePublicKey};
#[derive(Debug, Error)]
pub enum KasKeyError {
#[error("HTTP error: {0}")]
HttpError(String),
#[error("Invalid response: {0}")]
InvalidResponse(String),
#[error("JSON parse error: {0}")]
JsonError(#[from] serde_json::Error),
#[error("RSA parse error: {0}")]
RsaParseError(String),
#[error("EC parse error: {0}")]
EcParseError(String),
#[cfg(feature = "kas-client")]
#[error("Reqwest error: {0}")]
ReqwestError(#[from] reqwest::Error),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct KasPublicKeyResponse {
#[serde(rename = "publicKey")]
pub public_key: String, pub kid: String, }
#[derive(Debug, Serialize, Deserialize)]
pub struct KasEcPublicKeyResponse {
#[serde(alias = "public_key", alias = "publicKey")]
pub public_key: String, pub kid: String, }
#[deprecated(
since = "0.13.0",
note = "Legacy /kas/v2/* REST endpoint. Use fetch_kas_public_key_connect with a URL resolved from OpentdfConfiguration or fetch_well_known()."
)]
#[cfg(feature = "kas-client")]
pub async fn fetch_kas_public_key(
kas_url: &str,
http_client: &Client,
) -> Result<KasPublicKeyResponse, KasKeyError> {
let endpoint = if kas_url.ends_with("/kas") {
format!("{}/v2/kas_public_key", kas_url)
} else if kas_url.ends_with('/') {
format!("{}v2/kas_public_key", kas_url)
} else {
format!("{}/v2/kas_public_key", kas_url)
};
let response = http_client.get(&endpoint).send().await?;
let status = response.status();
if !status.is_success() {
let error_body = response.text().await.unwrap_or_default();
return Err(KasKeyError::HttpError(format!(
"HTTP {}: {}",
status, error_body
)));
}
let key_response: KasPublicKeyResponse = response.json().await?;
Ok(key_response)
}
#[cfg(feature = "kas-client")]
pub async fn fetch_kas_public_key_connect(
public_key_url: &str,
http_client: &Client,
) -> Result<KasPublicKeyResponse, KasKeyError> {
let response = http_client
.post(public_key_url)
.header("Content-Type", "application/json")
.body("{}")
.send()
.await?;
let status = response.status();
if !status.is_success() {
let error_body = response.text().await.unwrap_or_default();
return Err(KasKeyError::HttpError(format!(
"POST {} -> HTTP {}: {}",
public_key_url, status, error_body
)));
}
let key_response: KasPublicKeyResponse = response.json().await?;
Ok(key_response)
}
#[cfg(feature = "kas-client")]
pub fn validate_rsa_public_key_pem(pem: &str) -> Result<String, KasKeyError> {
let parsed_pem = pem::parse(pem)
.map_err(|e| KasKeyError::RsaParseError(format!("Failed to parse PEM: {}", e)))?;
PublicEncryptingKey::from_der(parsed_pem.contents()).map_err(|e| {
KasKeyError::RsaParseError(format!("Failed to parse RSA public key: {:?}", e))
})?;
Ok(pem.to_string())
}
#[deprecated(
since = "0.13.0",
note = "Legacy /kas/v2/* REST endpoint. Use fetch_kas_ec_public_key_connect with a URL resolved from OpentdfConfiguration or fetch_well_known()."
)]
#[cfg(feature = "kas-client")]
pub async fn fetch_kas_ec_public_key(
kas_url: &str,
http_client: &Client,
) -> Result<KasEcPublicKeyResponse, KasKeyError> {
let endpoint = if kas_url.ends_with("/kas") {
format!("{}/v2/kas_public_key", kas_url)
} else if kas_url.ends_with('/') {
format!("{}kas/v2/kas_public_key", kas_url)
} else {
format!("{}/kas/v2/kas_public_key", kas_url)
};
let response = http_client.get(&endpoint).send().await?;
let status = response.status();
if !status.is_success() {
let error_body = response.text().await.unwrap_or_default();
return Err(KasKeyError::HttpError(format!(
"HTTP {}: {}",
status, error_body
)));
}
let key_response: KasEcPublicKeyResponse = response.json().await?;
validate_ec_public_key_pem(&key_response.public_key)?;
Ok(key_response)
}
#[cfg(feature = "kas-client")]
pub async fn fetch_kas_ec_public_key_connect(
public_key_url: &str,
http_client: &Client,
) -> Result<KasEcPublicKeyResponse, KasKeyError> {
let response = http_client
.post(public_key_url)
.header("Content-Type", "application/json")
.body("{}")
.send()
.await?;
let status = response.status();
if !status.is_success() {
let error_body = response.text().await.unwrap_or_default();
return Err(KasKeyError::HttpError(format!(
"POST {} -> HTTP {}: {}",
public_key_url, status, error_body
)));
}
let key_response: KasEcPublicKeyResponse = response.json().await?;
validate_ec_public_key_pem(&key_response.public_key)?;
Ok(key_response)
}
#[cfg(feature = "kas-client")]
pub fn validate_ec_public_key_pem(pem: &str) -> Result<String, KasKeyError> {
use crate::pkcs8::EncodePublicKey;
let normalized = pem.replace("\r\n", "\n");
if let Ok(_key) = P256PublicKey::from_public_key_pem(&normalized) {
return Ok(normalized);
}
let parsed = pem::parse(&normalized)
.map_err(|e| KasKeyError::EcParseError(format!("Failed to parse PEM: {}", e)))?;
let der_bytes = parsed.contents();
if der_bytes.first() == Some(&0x04) && der_bytes.len() == 65 {
let key = P256PublicKey::from_sec1_bytes(der_bytes).map_err(|e| {
KasKeyError::EcParseError(format!("Failed to parse SEC1 EC public key: {}", e))
})?;
let spki_pem = key
.to_public_key_pem(Default::default())
.map_err(|e| KasKeyError::EcParseError(format!("Failed to encode as SPKI: {}", e)))?;
return Ok(spki_pem.to_string());
}
if (der_bytes.first() == Some(&0x02) || der_bytes.first() == Some(&0x03))
&& der_bytes.len() == 33
{
let key = P256PublicKey::from_sec1_bytes(der_bytes).map_err(|e| {
KasKeyError::EcParseError(format!("Failed to parse compressed SEC1 key: {}", e))
})?;
let spki_pem = key
.to_public_key_pem(Default::default())
.map_err(|e| KasKeyError::EcParseError(format!("Failed to encode as SPKI: {}", e)))?;
return Ok(spki_pem.to_string());
}
Err(KasKeyError::EcParseError(
"Unrecognized EC public key format".to_string(),
))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_kas_public_key_response_deserialization() {
let json = r#"{
"publicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\n-----END PUBLIC KEY-----\n",
"kid": "r1"
}"#;
let response: KasPublicKeyResponse = serde_json::from_str(json).unwrap();
assert!(
response
.public_key
.starts_with("-----BEGIN PUBLIC KEY-----")
);
assert_eq!(response.kid, "r1");
}
#[cfg(feature = "kas-client")]
#[test]
fn test_validate_rsa_public_key_pem() {
let valid_pem = r#"-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2dMTGDH4QhhB4aYg4d48
SrapeZD128mpRTRCvbQa5ZaDykVvs8jJ5USJSZErNZ/HVvPyX6gqvQv4HeprAT7i
En445s6sOqObeAYWc5FUatvk3R5KPtgqHOgQIPtXQXnahT7HwvZPCjYoawc2MGax
ejRg20the6MtJHh1K2hUGJ/ic7Hbvk2QMHqYvwjFva4q4Uz3cjiA4RXn4joxm8SE
gLUOPV7pWvv7JzZRRLYiXQAcTb4QvJMIwY997/r228sr+fgYjxK6O0QKPZI2iJ5H
PvJX+E+ceUD7JIZc87FvaA5OqwFUFXqJfYNU4ZE7d6ovRja8JwnErHa+7pEk6KkN
8wIDAQAB
-----END PUBLIC KEY-----"#;
let result = validate_rsa_public_key_pem(valid_pem);
assert!(result.is_ok());
let invalid_pem = "not a valid pem";
let result = validate_rsa_public_key_pem(invalid_pem);
assert!(result.is_err());
}
#[test]
fn test_kas_ec_public_key_response_deserialization_snake_case() {
let json = r#"{
"public_key": "-----BEGIN PUBLIC KEY-----\nBP7ISW0/0W1VJIFfv+Zvij25a+WVxx1PtiuVcrRLBkCSdH8YpLGVwwu7cAjwF2YB\nNyzrzkRqm0K4inv5zOIqiLg=\n-----END PUBLIC KEY-----\n",
"kid": "ec:secp256r1"
}"#;
let response: KasEcPublicKeyResponse = serde_json::from_str(json).unwrap();
assert!(
response
.public_key
.starts_with("-----BEGIN PUBLIC KEY-----")
);
assert_eq!(response.kid, "ec:secp256r1");
}
#[test]
fn test_kas_ec_public_key_response_deserialization_camel_case() {
let json = r#"{
"publicKey": "-----BEGIN PUBLIC KEY-----\ntest\n-----END PUBLIC KEY-----\n",
"kid": "ec:secp256r1"
}"#;
let response: KasEcPublicKeyResponse = serde_json::from_str(json).unwrap();
assert!(
response
.public_key
.starts_with("-----BEGIN PUBLIC KEY-----")
);
assert_eq!(response.kid, "ec:secp256r1");
}
#[cfg(feature = "kas-client")]
#[tokio::test]
async fn test_fetch_kas_public_key_connect_against_mock() {
let mut server = mockito::Server::new_async().await;
let _m = server
.mock("POST", "/kas.AccessService/PublicKey")
.with_status(200)
.with_header("content-type", "application/json")
.with_body(r#"{"publicKey":"-----BEGIN PUBLIC KEY-----\ntestkey\n-----END PUBLIC KEY-----\n","kid":"r1"}"#)
.create_async()
.await;
let url = format!("{}/kas.AccessService/PublicKey", server.url());
let http = reqwest::Client::new();
let resp = fetch_kas_public_key_connect(&url, &http).await.unwrap();
assert!(resp.public_key.starts_with("-----BEGIN PUBLIC KEY-----"));
assert_eq!(resp.kid, "r1");
}
#[cfg(feature = "kas-client")]
#[tokio::test]
async fn test_fetch_kas_ec_public_key_connect_against_mock() {
let mut server = mockito::Server::new_async().await;
let _m = server
.mock("POST", "/kas.AccessService/PublicKey")
.with_status(200)
.with_header("content-type", "application/json")
.with_body(r#"{"publicKey":"-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/shJbT/RbVUkgV+/5m+KPblr5ZXH\nHU+2K5VytEsGQJJ0fxiksZXDC7twCPAXZgE3LOvORGqbQriKe/nM4iqIuA==\n-----END PUBLIC KEY-----\n","kid":"ec:secp256r1"}"#)
.create_async()
.await;
let url = format!("{}/kas.AccessService/PublicKey", server.url());
let http = reqwest::Client::new();
let resp = fetch_kas_ec_public_key_connect(&url, &http).await.unwrap();
assert_eq!(resp.kid, "ec:secp256r1");
}
#[cfg(feature = "kas-client")]
#[test]
fn test_validate_ec_public_key_pem() {
let valid_pem = r#"-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/shJbT/RbVUkgV+/5m+KPblr5ZXH
HU+2K5VytEsGQJJ0fxiksZXDC7twCPAXZgE3LOvORGqbQriKe/nM4iqIuA==
-----END PUBLIC KEY-----"#;
let result = validate_ec_public_key_pem(valid_pem);
assert!(result.is_ok());
let crlf_pem = "-----BEGIN PUBLIC KEY-----\r\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/shJbT/RbVUkgV+/5m+KPblr5ZXH\r\nHU+2K5VytEsGQJJ0fxiksZXDC7twCPAXZgE3LOvORGqbQriKe/nM4iqIuA==\r\n-----END PUBLIC KEY-----\r\n";
let result = validate_ec_public_key_pem(crlf_pem);
assert!(result.is_ok());
let invalid_pem = "not a valid pem";
let result = validate_ec_public_key_pem(invalid_pem);
assert!(result.is_err());
}
}