#![allow(deprecated)]
use crate::manifest::TdfManifest;
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
use opentdf_protocol::{KasError, kas::Policy, *};
#[cfg(feature = "kas-client")]
use {
crate::hkdf::Hkdf,
crate::p256::{
PublicKey, SecretKey,
pkcs8::{DecodePublicKey, EncodePublicKey},
},
crate::sha2::{Digest, Sha256},
aes_gcm::{
Aes256Gcm, Nonce,
aead::{Aead, KeyInit},
},
aws_lc_rs::{
encoding::{AsDer, Pkcs8V1Der, PublicKeyX509Der},
rsa::{KeySize, OAEP_SHA1_MGF1SHA1, OaepPrivateDecryptingKey, PrivateDecryptingKey},
},
reqwest::Client,
};
#[cfg(feature = "kas-client")]
pub use crate::kas_dpop::CallerKey;
#[cfg(feature = "kas-client")]
use crate::kas_dpop::{CONNECT_REWRAP_PROCEDURE, REWRAP_HTM};
#[cfg(feature = "kas-client")]
#[derive(Debug, Clone, Copy)]
pub enum KeyType {
EC,
RSA,
}
pub enum EphemeralKeyPair {
#[cfg(feature = "kas-client")]
EC {
private_key: SecretKey,
public_key_pem: String,
},
#[cfg(feature = "kas-client")]
RSA {
private_key: PrivateDecryptingKey,
public_key_pem: String,
},
}
#[cfg(feature = "kas-client")]
impl EphemeralKeyPair {
pub fn new(key_type: KeyType) -> Result<Self, KasError> {
use crate::p256::elliptic_curve::Generate;
match key_type {
KeyType::EC => {
let private_key = SecretKey::generate();
let public_key = private_key.public_key();
let public_key_pem = public_key
.to_public_key_pem(crate::p256::pkcs8::LineEnding::LF)
.map_err(|e| KasError::Pkcs8Error(e.to_string()))?;
Ok(EphemeralKeyPair::EC {
private_key,
public_key_pem,
})
}
KeyType::RSA => {
let private_key =
PrivateDecryptingKey::generate(KeySize::Rsa2048).map_err(|e| {
KasError::CryptoError {
operation: "RSA_key_generation".to_string(),
reason: format!("RSA key generation failed: {:?}", e),
}
})?;
let public_key = private_key.public_key();
let public_key_der =
AsDer::<PublicKeyX509Der>::as_der(&public_key).map_err(|e| {
KasError::Pkcs8Error(format!("Failed to export public key: {:?}", e))
})?;
let mut public_key_pem =
pem::encode(&pem::Pem::new("PUBLIC KEY", public_key_der.as_ref()));
if !public_key_pem.ends_with('\n') {
public_key_pem.push('\n');
}
Ok(EphemeralKeyPair::RSA {
private_key,
public_key_pem,
})
}
}
}
pub fn public_key_pem(&self) -> &str {
match self {
EphemeralKeyPair::EC { public_key_pem, .. } => public_key_pem,
EphemeralKeyPair::RSA { public_key_pem, .. } => public_key_pem,
}
}
}
#[cfg(feature = "kas-client")]
pub struct KasClient {
http_client: Client,
endpoints: crate::kas_discovery::KasEndpoints,
oauth_token: String,
signing_key: PrivateDecryptingKey,
caller_key: Option<CallerKey>,
}
#[cfg(feature = "kas-client")]
impl KasClient {
pub fn new(
config: &crate::kas_discovery::OpentdfConfiguration,
oauth_token: impl Into<String>,
) -> Result<Self, KasError> {
let endpoints = crate::kas_discovery::KasEndpoints::from_config(config)?;
let http_client = Client::builder()
.timeout(std::time::Duration::from_secs(30))
.redirect(reqwest::redirect::Policy::none())
.build()
.map_err(|e| KasError::HttpError {
status: 0,
message: format!("Failed to build HTTP client: {}", e),
})?;
let signing_key = PrivateDecryptingKey::generate(KeySize::Rsa2048).map_err(|e| {
KasError::CryptoError {
operation: "generate_signing_key".to_string(),
reason: format!("Failed to generate RSA signing key: {:?}", e),
}
})?;
Ok(Self {
http_client,
endpoints,
oauth_token: oauth_token.into(),
signing_key,
caller_key: None,
})
}
pub fn with_caller_key(mut self, key: CallerKey) -> Self {
self.caller_key = Some(key);
self
}
pub fn set_access_token(&mut self, oauth_token: impl Into<String>) {
self.oauth_token = oauth_token.into();
}
fn require_connect_rewrap(&self) -> Result<(), KasError> {
use crate::kas_discovery::KasTransport;
let is_connect_rewrap = self.endpoints.transport == KasTransport::Connect
&& url::Url::parse(&self.endpoints.rewrap_url)
.is_ok_and(|u| u.path().ends_with(CONNECT_REWRAP_PROCEDURE));
if is_connect_rewrap {
Ok(())
} else {
Err(KasError::ConfigError {
reason: format!(
"caller-key (DPoP) rewrap requires the Connect endpoint {}; resolved rewrap URL is {}",
CONNECT_REWRAP_PROCEDURE, self.endpoints.rewrap_url
),
})
}
}
async fn send_rewrap_request(
&self,
signed_request: &SignedRewrapRequest,
) -> Result<RewrapResponse, KasError> {
let request = self
.http_client
.post(&self.endpoints.rewrap_url)
.header("Content-Type", "application/json");
let request = match &self.caller_key {
None => request.header("Authorization", format!("Bearer {}", self.oauth_token)),
Some(caller_key) => {
self.require_connect_rewrap()?;
let proof = caller_key.dpop_proof(
REWRAP_HTM,
CONNECT_REWRAP_PROCEDURE,
&self.oauth_token,
)?;
request
.header("Authorization", format!("DPoP {}", self.oauth_token))
.header("DPoP", proof)
.header("Connect-Protocol-Version", "1")
}
};
let response =
request
.json(signed_request)
.send()
.await
.map_err(|e| KasError::RequestError {
method: "POST".to_string(),
url: self.endpoints.rewrap_url.clone(),
reason: e.to_string(),
})?;
let status = response.status();
if !status.is_success() {
let error_body = response.text().await.unwrap_or_default();
let detail = crate::kas_discovery::parse_connect_error(&error_body)
.map(|e| format!("{}: {}", e.code, e.message))
.unwrap_or_else(|| {
if error_body.is_empty() {
format!("HTTP {}", status)
} else {
error_body.clone()
}
});
return Err(match status.as_u16() {
401 => KasError::AuthenticationFailed { reason: detail },
403 => KasError::AccessDenied {
resource: "KAS endpoint".to_string(),
reason: detail,
},
_ => KasError::HttpError {
status: status.as_u16(),
message: detail,
},
});
}
response
.json()
.await
.map_err(|e| KasError::InvalidResponse {
reason: format!("Failed to parse JSON response: {}", e),
expected: Some("RewrapResponse".to_string()),
})
}
pub async fn rewrap_nanotdf(
&self,
header_bytes: &[u8],
kas_url: &str,
) -> Result<Vec<u8>, KasError> {
let unsigned_request = self.build_nanotdf_rewrap_request(header_bytes, kas_url)?;
let signed_request_token = self.sign_rewrap_request(&unsigned_request)?;
let signed_request = SignedRewrapRequest {
signed_request_token,
};
let rewrap_response = self.send_rewrap_request(&signed_request).await?;
self.extract_nanotdf_key(&rewrap_response)
}
pub async fn rewrap_standard_tdf(&self, manifest: &TdfManifest) -> Result<Vec<u8>, KasError> {
let ephemeral_key_pair = EphemeralKeyPair::new(KeyType::RSA)?;
let unsigned_request = self.build_rewrap_request(manifest, &ephemeral_key_pair)?;
let signed_request_token = self.sign_rewrap_request(&unsigned_request)?;
let signed_request = SignedRewrapRequest {
signed_request_token,
};
let rewrap_response = self.send_rewrap_request(&signed_request).await?;
let (wrapped_key, session_public_key_pem) = self.extract_wrapped_key(&rewrap_response)?;
let payload_key =
self.unwrap_key(&wrapped_key, &session_public_key_pem, &ephemeral_key_pair)?;
Ok(payload_key)
}
fn sign_rewrap_request(&self, request: &UnsignedRewrapRequest) -> Result<String, KasError> {
use jsonwebtoken::{Algorithm, EncodingKey, Header, encode};
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize)]
struct Claims {
#[serde(rename = "requestBody")]
request_body: String,
iat: i64,
exp: i64,
}
let request_json = serde_json::to_string(request).map_err(KasError::SerializationError)?;
let now = chrono::Utc::now().timestamp();
if let Some(caller_key) = &self.caller_key {
return caller_key.signed_request_token_at(&request_json, now);
}
let claims = Claims {
request_body: request_json,
iat: now,
exp: now + 60, };
let key_der = AsDer::<Pkcs8V1Der>::as_der(&self.signing_key)
.map_err(|e| KasError::Pkcs8Error(format!("Failed to encode signing key: {:?}", e)))?;
let key_pem = pem::encode(&pem::Pem::new("PRIVATE KEY", key_der.as_ref()));
let encoding_key = EncodingKey::from_rsa_pem(key_pem.as_bytes())
.map_err(|e| KasError::Pkcs8Error(format!("Failed to parse RSA PEM: {}", e)))?;
let token =
encode(&Header::new(Algorithm::RS256), &claims, &encoding_key).map_err(|e| {
KasError::JwtError {
operation: "sign_jwt".to_string(),
reason: format!("Failed to sign JWT: {}", e),
}
})?;
Ok(token)
}
fn extract_policy_uuid(&self, base64_policy: &str) -> Result<String, KasError> {
let policy_bytes = BASE64
.decode(base64_policy)
.map_err(KasError::Base64Error)?;
let policy_json: serde_json::Value =
serde_json::from_slice(&policy_bytes).map_err(|e| KasError::InvalidResponse {
reason: format!("Failed to parse policy JSON: {}", e),
expected: Some("valid JSON policy".to_string()),
})?;
let uuid = policy_json
.get("uuid")
.and_then(|v| v.as_str())
.ok_or_else(|| KasError::InvalidResponse {
reason: "Policy missing 'uuid' field".to_string(),
expected: Some("uuid field in policy".to_string()),
})?;
if uuid.len() != 36 {
return Err(KasError::InvalidResponse {
reason: format!(
"Invalid UUID format: expected 36 characters, got {}",
uuid.len()
),
expected: Some("36-character UUID".to_string()),
});
}
Ok(uuid.to_string())
}
fn build_rewrap_request(
&self,
manifest: &TdfManifest,
ephemeral_key_pair: &EphemeralKeyPair,
) -> Result<UnsignedRewrapRequest, KasError> {
let key_access_wrappers: Vec<KeyAccessObjectWrapper> = manifest
.encryption_information
.key_access
.iter()
.enumerate()
.map(|(idx, kao)| {
let wrapped_key_bytes = BASE64
.decode(&kao.wrapped_key)
.map_err(KasError::Base64Error)?;
Ok(KeyAccessObjectWrapper {
key_access_object_id: format!("kao-{}", idx),
key_access_object: KeyAccessObject {
key_type: kao.access_type.clone(),
url: kao.url.clone(),
protocol: kao.protocol.clone(),
wrapped_key: BASE64.encode(&wrapped_key_bytes),
policy_binding: KasPolicyBinding {
hash: kao.policy_binding.hash.clone(),
algorithm: Some(kao.policy_binding.alg.clone()),
},
encrypted_metadata: kao.encrypted_metadata.clone(),
kid: kao.kid.clone(),
header: None, ephemeral_public_key: kao.ephemeral_public_key.clone(),
},
})
})
.collect::<Result<Vec<_>, KasError>>()?;
let policy_uuid = self.extract_policy_uuid(&manifest.encryption_information.policy)?;
let policy = Policy {
id: policy_uuid,
body: manifest.encryption_information.policy.clone(),
};
let policy_request = PolicyRequest {
algorithm: None, policy,
key_access_objects: key_access_wrappers,
};
Ok(UnsignedRewrapRequest {
client_public_key: ephemeral_key_pair.public_key_pem().to_string(),
requests: vec![policy_request],
})
}
fn build_nanotdf_rewrap_request(
&self,
header_bytes: &[u8],
kas_url: &str,
) -> Result<UnsignedRewrapRequest, KasError> {
use base64::Engine;
let header_b64 = BASE64.encode(header_bytes);
let key_access_object = KeyAccessObjectWrapper {
key_access_object_id: "kao-0".to_string(),
key_access_object: KeyAccessObject {
key_type: "wrapped".to_string(),
url: kas_url.to_string(),
protocol: "kas".to_string(),
wrapped_key: String::new(), policy_binding: KasPolicyBinding {
hash: String::new(), algorithm: Some("HS256".to_string()),
},
encrypted_metadata: None,
kid: None,
header: Some(header_b64), ephemeral_public_key: None, },
};
let policy_request = PolicyRequest {
algorithm: Some("ec:secp256r1".to_string()), policy: Policy {
id: "policy".to_string(),
body: String::new(), },
key_access_objects: vec![key_access_object],
};
Ok(UnsignedRewrapRequest {
client_public_key: String::new(), requests: vec![policy_request],
})
}
fn extract_nanotdf_key(&self, response: &RewrapResponse) -> Result<Vec<u8>, KasError> {
let policy_result =
response
.responses
.first()
.ok_or_else(|| KasError::InvalidResponse {
reason: "Empty response from KAS".to_string(),
expected: Some("at least one policy response".to_string()),
})?;
let key_result =
policy_result
.results
.first()
.ok_or_else(|| KasError::InvalidResponse {
reason: "No key access object in response".to_string(),
expected: Some("at least one KAO result".to_string()),
})?;
let dek_b64 =
key_result
.entity_wrapped_key
.as_ref()
.ok_or_else(|| KasError::InvalidResponse {
reason: "No DEK in NanoTDF rewrap response".to_string(),
expected: Some("entity_wrapped_key field".to_string()),
})?;
BASE64.decode(dek_b64).map_err(KasError::Base64Error)
}
fn extract_wrapped_key(
&self,
response: &RewrapResponse,
) -> Result<(Vec<u8>, String), KasError> {
let policy_result =
response
.responses
.first()
.ok_or_else(|| KasError::InvalidResponse {
reason: "Empty response from KAS".to_string(),
expected: Some("at least one policy response".to_string()),
})?;
let key_result =
policy_result
.results
.first()
.ok_or_else(|| KasError::InvalidResponse {
reason: "No key results in response".to_string(),
expected: Some("at least one key result".to_string()),
})?;
if key_result.status != "permit" {
let error_msg = key_result
.error
.clone()
.unwrap_or_else(|| "Access denied".to_string());
return Err(KasError::AccessDenied {
resource: "key".to_string(),
reason: error_msg,
});
}
let wrapped_key_b64 = key_result
.kas_wrapped_key
.as_ref()
.or(key_result.entity_wrapped_key.as_ref())
.ok_or_else(|| KasError::InvalidResponse {
reason: "Missing wrapped key in response".to_string(),
expected: Some("kasWrappedKey or entityWrappedKey".to_string()),
})?;
let wrapped_key = BASE64.decode(wrapped_key_b64)?;
let session_public_key = response.session_public_key.clone().unwrap_or_default();
Ok((wrapped_key, session_public_key))
}
fn unwrap_key(
&self,
wrapped_key: &[u8],
session_public_key_pem: &str,
ephemeral_key_pair: &EphemeralKeyPair,
) -> Result<Vec<u8>, KasError> {
match ephemeral_key_pair {
EphemeralKeyPair::RSA { private_key, .. } => {
let oaep_key = OaepPrivateDecryptingKey::new(private_key.clone()).map_err(|e| {
KasError::CryptoError {
operation: "create_oaep_key".to_string(),
reason: format!("Failed to create OAEP key: {:?}", e),
}
})?;
let mut plaintext = vec![0u8; oaep_key.min_output_size()];
let plaintext_slice = oaep_key
.decrypt(&OAEP_SHA1_MGF1SHA1, wrapped_key, &mut plaintext, None)
.map_err(|e| KasError::UnwrapError {
algorithm: "RSA-OAEP".to_string(),
reason: format!("RSA-OAEP decryption failed: {:?}", e),
})?;
Ok(plaintext_slice.to_vec())
}
EphemeralKeyPair::EC { private_key, .. } => {
if session_public_key_pem.trim().is_empty() {
return Err(KasError::InvalidResponse {
reason: "Missing session public key in response".to_string(),
expected: Some("sessionPublicKey".to_string()),
});
}
let session_public_key = PublicKey::from_public_key_pem(session_public_key_pem)
.map_err(|e| KasError::CryptoError {
operation: "parse_session_public_key".to_string(),
reason: format!("Failed to parse session public key: {}", e),
})?;
let shared_secret = crate::p256::ecdh::diffie_hellman(
private_key.to_nonzero_scalar(),
session_public_key.as_affine(),
);
let mut salt_hasher = Sha256::new();
salt_hasher.update(b"TDF");
let salt = salt_hasher.finalize();
let hkdf = Hkdf::<Sha256>::new(Some(&salt), shared_secret.raw_secret_bytes());
let mut symmetric_key = [0u8; 32];
hkdf.expand(&[], &mut symmetric_key)
.map_err(|e| KasError::CryptoError {
operation: "HKDF".to_string(),
reason: format!("HKDF expansion failed: {}", e),
})?;
if wrapped_key.len() < 28 {
return Err(KasError::UnwrapError {
algorithm: "ECDH-AES-GCM".to_string(),
reason: format!(
"Wrapped key too short: {} bytes (expected at least 28)",
wrapped_key.len()
),
});
}
let nonce = Nonce::from_slice(&wrapped_key[..12]);
let ciphertext_and_tag = &wrapped_key[12..];
let cipher = Aes256Gcm::new_from_slice(&symmetric_key).map_err(|e| {
KasError::CryptoError {
operation: "AES-GCM-init".to_string(),
reason: format!("Failed to create cipher: {}", e),
}
})?;
let payload_key = cipher.decrypt(nonce, ciphertext_and_tag).map_err(|e| {
KasError::UnwrapError {
algorithm: "AES-GCM".to_string(),
reason: format!("AES-GCM decryption failed: {}", e),
}
})?;
Ok(payload_key)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_ephemeral_key_pair_generation() {
#[cfg(feature = "kas-client")]
{
let key_pair_rsa =
EphemeralKeyPair::new(KeyType::RSA).expect("Failed to generate RSA key pair");
assert!(
key_pair_rsa
.public_key_pem()
.starts_with("-----BEGIN PUBLIC KEY-----")
);
let key_pair_ec =
EphemeralKeyPair::new(KeyType::EC).expect("Failed to generate EC key pair");
assert!(
key_pair_ec
.public_key_pem()
.starts_with("-----BEGIN PUBLIC KEY-----")
);
}
}
#[test]
fn test_policy_serialization() {
let policy = Policy {
id: "test-policy".to_string(),
body: BASE64.encode(b"test-policy-body"),
};
let json = serde_json::to_string(&policy).expect("Failed to serialize");
assert!(json.contains("test-policy"));
}
#[cfg(feature = "kas-client")]
mod url_validation_tests {
use super::*;
use crate::kas_discovery::OpentdfConfiguration;
fn expect_err(url: &str) -> KasError {
let cfg = OpentdfConfiguration::for_kas_connect(url);
match KasClient::new(&cfg, "token") {
Err(e) => e,
Ok(_) => panic!("Expected error for {url}, got Ok"),
}
}
#[test]
fn test_kas_rejects_http_url() {
let err = expect_err("http://evil.com");
assert!(matches!(err, KasError::InvalidUrl(_)), "got: {err}");
assert!(err.to_string().contains("HTTPS"));
}
#[test]
fn test_kas_accepts_https_url() {
let cfg = OpentdfConfiguration::for_kas_connect("https://kas.example.com");
assert!(KasClient::new(&cfg, "token").is_ok());
}
#[test]
fn test_kas_allows_http_localhost() {
for base in [
"http://127.0.0.1:8080",
"http://localhost:8080",
"http://[::1]:8080",
] {
let cfg = OpentdfConfiguration::for_kas_connect(base);
assert!(
KasClient::new(&cfg, "token").is_ok(),
"HTTP loopback {base} should be allowed"
);
}
}
#[test]
fn test_kas_rejects_private_ip() {
for base in [
"https://10.0.0.1",
"https://172.16.0.1",
"https://192.168.1.1",
] {
let err = expect_err(base);
assert!(matches!(err, KasError::InvalidUrl(_)), "{base}: {err}");
}
}
#[test]
fn test_kas_rejects_metadata_ip() {
let err = expect_err("http://169.254.169.254");
assert!(matches!(err, KasError::InvalidUrl(_)), "got: {err}");
}
#[test]
fn test_kas_rejects_invalid_scheme() {
let err = expect_err("ftp://kas.example.com");
assert!(matches!(err, KasError::InvalidUrl(_)), "got: {err}");
assert!(err.to_string().contains("ftp"));
}
#[test]
fn test_kas_rejects_invalid_url() {
let err = expect_err("not-a-url");
assert!(matches!(err, KasError::InvalidUrl(_)), "got: {err}");
}
}
}