use crate::errors::{AuthError, Result};
use crate::security::secure_jwt::{SecureJwtConfig, SecureJwtValidator};
use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
use chrono::{DateTime, Duration, Utc};
use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use std::collections::HashMap;
use std::sync::Arc;
use tracing::{debug, error, info, warn};
use uuid::Uuid;
#[derive(Clone)]
pub struct AdvancedJarmConfig {
pub supported_algorithms: Vec<Algorithm>,
pub default_token_expiry: Duration,
pub enable_jwe_encryption: bool,
pub supported_delivery_modes: Vec<JarmDeliveryMode>,
pub enable_custom_claims: bool,
pub max_custom_claims: usize,
pub enable_response_validation: bool,
pub jarm_issuer: String,
pub enable_audit_logging: bool,
pub jwe_algorithm: Option<String>,
pub jwe_content_encryption: Option<String>,
pub rsa_private_key_pem: Option<String>,
pub rsa_public_key_pem: Option<String>,
pub jwe_recipient_public_key_pem: Option<String>,
pub jwe_recipient_private_key_pem: Option<String>,
}
impl std::fmt::Debug for AdvancedJarmConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut d = f.debug_struct("AdvancedJarmConfig");
d.field("supported_algorithms", &self.supported_algorithms);
d.field("default_token_expiry", &self.default_token_expiry);
d.field("enable_jwe_encryption", &self.enable_jwe_encryption);
d.field("supported_delivery_modes", &self.supported_delivery_modes);
d.field("enable_custom_claims", &self.enable_custom_claims);
d.field("max_custom_claims", &self.max_custom_claims);
d.field(
"enable_response_validation",
&self.enable_response_validation,
);
d.field("jarm_issuer", &self.jarm_issuer);
d.field("enable_audit_logging", &self.enable_audit_logging);
d.field("jwe_algorithm", &self.jwe_algorithm);
d.field("jwe_content_encryption", &self.jwe_content_encryption);
d.field(
"rsa_private_key_pem",
&crate::utils::redact::redacted(&self.rsa_private_key_pem),
);
d.field("rsa_public_key_pem", &self.rsa_public_key_pem);
d.field(
"jwe_recipient_public_key_pem",
&self.jwe_recipient_public_key_pem,
);
d.field(
"jwe_recipient_private_key_pem",
&crate::utils::redact::redacted(&self.jwe_recipient_private_key_pem),
);
d.finish()
}
}
impl Default for AdvancedJarmConfig {
fn default() -> Self {
Self {
supported_algorithms: vec![Algorithm::RS256, Algorithm::RS384, Algorithm::RS512],
default_token_expiry: Duration::minutes(10),
enable_jwe_encryption: false,
supported_delivery_modes: vec![
JarmDeliveryMode::Query,
JarmDeliveryMode::Fragment,
JarmDeliveryMode::FormPost,
JarmDeliveryMode::Push,
],
enable_custom_claims: true,
max_custom_claims: 20,
enable_response_validation: true,
jarm_issuer: "https://auth-server.example.com".to_string(),
enable_audit_logging: true,
jwe_algorithm: Some("RSA-OAEP-256".to_string()),
jwe_content_encryption: Some("A256GCM".to_string()),
rsa_private_key_pem: None,
rsa_public_key_pem: None,
jwe_recipient_public_key_pem: None,
jwe_recipient_private_key_pem: None,
}
}
}
impl AdvancedJarmConfig {
pub fn builder() -> AdvancedJarmConfigBuilder {
AdvancedJarmConfigBuilder {
inner: Self::default(),
}
}
}
pub struct AdvancedJarmConfigBuilder {
inner: AdvancedJarmConfig,
}
impl AdvancedJarmConfigBuilder {
pub fn supported_algorithms(mut self, algos: Vec<Algorithm>) -> Self {
self.inner.supported_algorithms = algos;
self
}
pub fn default_token_expiry(mut self, expiry: Duration) -> Self {
self.inner.default_token_expiry = expiry;
self
}
pub fn enable_jwe_encryption(mut self, enable: bool) -> Self {
self.inner.enable_jwe_encryption = enable;
self
}
pub fn supported_delivery_modes(mut self, modes: Vec<JarmDeliveryMode>) -> Self {
self.inner.supported_delivery_modes = modes;
self
}
pub fn enable_custom_claims(mut self, enable: bool) -> Self {
self.inner.enable_custom_claims = enable;
self
}
pub fn max_custom_claims(mut self, max: usize) -> Self {
self.inner.max_custom_claims = max;
self
}
pub fn enable_response_validation(mut self, enable: bool) -> Self {
self.inner.enable_response_validation = enable;
self
}
pub fn jarm_issuer(mut self, issuer: impl Into<String>) -> Self {
self.inner.jarm_issuer = issuer.into();
self
}
pub fn enable_audit_logging(mut self, enable: bool) -> Self {
self.inner.enable_audit_logging = enable;
self
}
pub fn jwe_content_encryption(mut self, enc: impl Into<String>) -> Self {
self.inner.jwe_content_encryption = Some(enc.into());
self
}
pub fn jwe_algorithm(mut self, alg: impl Into<String>) -> Self {
self.inner.jwe_algorithm = Some(alg.into());
self
}
pub fn rsa_private_key_pem(mut self, pem: impl Into<String>) -> Self {
self.inner.rsa_private_key_pem = Some(pem.into());
self
}
pub fn rsa_public_key_pem(mut self, pem: impl Into<String>) -> Self {
self.inner.rsa_public_key_pem = Some(pem.into());
self
}
pub fn jwe_recipient_public_key_pem(mut self, pem: impl Into<String>) -> Self {
self.inner.jwe_recipient_public_key_pem = Some(pem.into());
self
}
pub fn jwe_recipient_private_key_pem(mut self, pem: impl Into<String>) -> Self {
self.inner.jwe_recipient_private_key_pem = Some(pem.into());
self
}
pub fn build(self) -> AdvancedJarmConfig {
self.inner
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum JarmDeliveryMode {
Query,
Fragment,
FormPost,
Push,
}
pub struct AdvancedJarmManager {
config: AdvancedJarmConfig,
jwt_validator: Arc<SecureJwtValidator>,
encoding_key: EncodingKey,
decoding_key: DecodingKey,
http_client: crate::server::core::common_http::HttpClient,
#[cfg(feature = "rsa-private-key-ops")]
jwe_public_key: Option<aws_lc_rs::rsa::OaepPublicEncryptingKey>,
#[cfg(feature = "rsa-private-key-ops")]
jwe_private_key: Option<aws_lc_rs::rsa::OaepPrivateDecryptingKey>,
}
#[cfg(feature = "rsa-private-key-ops")]
fn pem_to_der(pem: &str) -> Result<Vec<u8>> {
let b64: String = pem
.lines()
.filter(|line| {
!line.starts_with("-----BEGIN") && !line.starts_with("-----END") && !line.is_empty()
})
.collect();
base64::engine::general_purpose::STANDARD
.decode(&b64)
.map_err(|e| AuthError::crypto(format!("Failed to base64-decode PEM: {e}")))
}
impl AdvancedJarmManager {
pub fn new(config: AdvancedJarmConfig) -> Result<Self> {
let private_pem = config
.rsa_private_key_pem
.clone()
.or_else(|| std::env::var("JARM_RSA_PRIVATE_KEY_PEM").ok());
let public_pem = config
.rsa_public_key_pem
.clone()
.or_else(|| std::env::var("JARM_RSA_PUBLIC_KEY_PEM").ok());
fn make_validator_secret() -> Result<String> {
use ring::rand::{SecureRandom, SystemRandom};
let rng = SystemRandom::new();
let mut bytes = [0u8; 32];
rng.fill(&mut bytes).map_err(|_| {
AuthError::crypto("System CSPRNG unavailable; cannot initialize JARM secrets")
})?;
Ok(bytes.iter().fold(String::with_capacity(64), |mut s, b| {
s.push_str(&format!("{b:02x}"));
s
}))
}
let (encoding_key, decoding_key, validator_jwt_secret, rsa_pub_pem) =
match (private_pem, public_pem) {
(Some(priv_pem), Some(pub_pem)) => {
match (
EncodingKey::from_rsa_pem(priv_pem.as_bytes()),
DecodingKey::from_rsa_pem(pub_pem.as_bytes()),
) {
(Ok(enc), Ok(dec)) => {
info!("JARM: loaded RSA signing/verification keys from configuration");
let secret = match std::env::var("JARM_JWT_SECRET") {
Ok(secret) => secret,
Err(_) => make_validator_secret()?,
};
(enc, dec, secret, Some(pub_pem))
}
(Err(e), _) | (_, Err(e)) => {
return Err(AuthError::config(format!(
"JARM: the configured RSA keys could not be parsed: {e}"
)));
}
}
}
_ => {
warn!(
"SECURITY WARNING: AdvancedJarmManager has no RSA key and is using a \
random per-instance symmetric key for JARM signing. Its responses \
cannot be verified outside this process. Supply an RSA private key \
via AdvancedJarmConfig::rsa_private_key_pem or the \
JARM_RSA_PRIVATE_KEY_PEM environment variable before deploying to \
production."
);
let signing_secret = make_validator_secret()?;
(
EncodingKey::from_secret(signing_secret.as_bytes()),
DecodingKey::from_secret(signing_secret.as_bytes()),
make_validator_secret()?,
None,
)
}
};
#[cfg(not(feature = "rsa-private-key-ops"))]
if config.jwe_recipient_public_key_pem.is_some()
|| config.jwe_recipient_private_key_pem.is_some()
|| std::env::var("JARM_JWE_RECIPIENT_PUBLIC_KEY_PEM").is_ok()
|| std::env::var("JARM_JWE_RECIPIENT_PRIVATE_KEY_PEM").is_ok()
{
warn!(
"JARM JWE recipient keys were configured, but the `rsa-private-key-ops` \
feature is not enabled -- JWE encryption/decryption will be \
unavailable. Enable `rsa-private-key-ops` to use it."
);
}
#[cfg(feature = "rsa-private-key-ops")]
let jwe_public_key = {
let jwe_pub_pem = config
.jwe_recipient_public_key_pem
.clone()
.or_else(|| std::env::var("JARM_JWE_RECIPIENT_PUBLIC_KEY_PEM").ok());
jwe_pub_pem.as_deref().and_then(|pem| {
let der = match pem_to_der(pem) {
Ok(der) => der,
Err(e) => {
warn!("JARM JWE: could not decode recipient public key PEM: {e}");
return None;
}
};
let encrypting_key = match aws_lc_rs::rsa::PublicEncryptingKey::from_der(&der) {
Ok(k) => k,
Err(e) => {
warn!(
"JARM JWE: recipient public key is not a valid RSA key \
(aws-lc-rs requires 2048-8192 bit keys): {e}"
);
return None;
}
};
match aws_lc_rs::rsa::OaepPublicEncryptingKey::new(encrypting_key) {
Ok(k) => {
info!("JARM JWE: loaded RSA recipient public key");
Some(k)
}
Err(_) => {
warn!("JARM JWE: recipient public key rejected for OAEP use");
None
}
}
})
};
#[cfg(feature = "rsa-private-key-ops")]
let jwe_private_key = {
let jwe_priv_pem = config
.jwe_recipient_private_key_pem
.clone()
.or_else(|| std::env::var("JARM_JWE_RECIPIENT_PRIVATE_KEY_PEM").ok());
jwe_priv_pem.as_deref().and_then(|pem| {
let der = match pem_to_der(pem) {
Ok(der) => der,
Err(e) => {
warn!("JARM JWE: could not decode recipient private key PEM: {e}");
return None;
}
};
let decrypting_key = match aws_lc_rs::rsa::PrivateDecryptingKey::from_pkcs8(&der) {
Ok(k) => k,
Err(e) => {
warn!(
"JARM JWE: recipient private key is not a valid RSA key \
(aws-lc-rs requires 2048-8192 bit keys): {e}"
);
return None;
}
};
match aws_lc_rs::rsa::OaepPrivateDecryptingKey::new(decrypting_key) {
Ok(k) => {
info!("JARM JWE: loaded RSA recipient private key");
Some(k)
}
Err(_) => {
warn!("JARM JWE: recipient private key rejected for OAEP use");
None
}
}
})
};
let mut required_issuers = std::collections::HashSet::new();
required_issuers.insert(config.jarm_issuer.clone());
let jwt_config = SecureJwtConfig {
allowed_algorithms: config.supported_algorithms.clone(),
required_issuers,
required_audiences: std::collections::HashSet::new(), max_token_lifetime: std::time::Duration::from_secs(
config.default_token_expiry.num_seconds() as u64,
),
clock_skew: std::time::Duration::from_secs(30),
require_jti: true,
validate_nbf: true,
allowed_token_types: {
let mut types = std::collections::HashSet::new();
types.insert("JARM".to_string());
types
},
require_secure_transport: true,
jwt_secret: validator_jwt_secret.into(),
rsa_public_key_pem: rsa_pub_pem,
ec_public_key_pem: None,
ed_public_key_pem: None,
};
let jwt_validator = SecureJwtValidator::new(jwt_config).map_err(|e| {
tracing::error!("Failed to initialize SecureJwtValidator for JARM: {e}");
e
})?;
let http_client = {
use crate::server::core::common_config::EndpointConfig;
let endpoint_config = EndpointConfig::new("https://localhost");
crate::server::core::common_http::HttpClient::new(endpoint_config).map_err(|e| {
tracing::error!("Failed to initialize HttpClient for JARM: {e}");
e
})?
};
Ok(Self {
config,
jwt_validator: Arc::new(jwt_validator),
encoding_key,
decoding_key,
http_client,
#[cfg(feature = "rsa-private-key-ops")]
jwe_public_key,
#[cfg(feature = "rsa-private-key-ops")]
jwe_private_key,
})
}
pub async fn create_jarm_response(
&self,
client_id: &str,
authorization_response: &AuthorizationResponse,
delivery_mode: JarmDeliveryMode,
custom_claims: Option<HashMap<String, Value>>,
) -> Result<JarmResponse> {
if !self
.config
.supported_delivery_modes
.contains(&delivery_mode)
{
return Err(AuthError::validation(format!(
"Unsupported delivery mode: {:?}",
delivery_mode
)));
}
if let Some(ref claims) = custom_claims {
if self.config.enable_custom_claims {
if claims.len() > self.config.max_custom_claims {
return Err(AuthError::validation(format!(
"Too many custom claims: {} > {}",
claims.len(),
self.config.max_custom_claims
)));
}
} else {
return Err(AuthError::validation(
"Custom claims are disabled".to_string(),
));
}
}
let now = Utc::now();
let expires_at = now + self.config.default_token_expiry;
let jti = Uuid::new_v4().to_string();
let mut claims = json!({
"iss": self.config.jarm_issuer,
"aud": client_id,
"iat": now.timestamp(),
"exp": expires_at.timestamp(),
"nbf": now.timestamp(), "jti": jti,
"typ": "JARM", "scope": "", "sub": format!("jarm_{}", client_id), });
if let Some(code) = &authorization_response.code {
claims["code"] = json!(code);
}
if let Some(access_token) = &authorization_response.access_token {
claims["access_token"] = json!(access_token);
}
if let Some(id_token) = &authorization_response.id_token {
claims["id_token"] = json!(id_token);
}
if let Some(state) = &authorization_response.state {
claims["state"] = json!(state);
}
if let Some(error) = &authorization_response.error {
claims["error"] = json!(error);
}
if let Some(error_description) = &authorization_response.error_description {
claims["error_description"] = json!(error_description);
}
if authorization_response.access_token.is_some() {
claims["token_type"] = json!("Bearer");
if let Some(expires_in) = authorization_response.expires_in {
claims["expires_in"] = json!(expires_in);
}
}
if let Some(scope) = &authorization_response.scope {
claims["scope"] = json!(scope);
}
if let Some(custom) = custom_claims {
for (key, value) in custom {
claims[key] = value;
}
}
let header = Header {
typ: Some("JWT".to_string()),
alg: self.config.supported_algorithms[0], kid: Some("jarm-key-1".to_string()),
..Default::default()
};
let token = jsonwebtoken::encode(&header, &claims, &self.encoding_key)
.map_err(|e| AuthError::token(format!("Failed to create JARM token: {}", e)))?;
if self.config.enable_response_validation {
let _validated_claims = self
.jwt_validator
.validate_token(&token, &self.decoding_key)
.map_err(|e| {
AuthError::token(format!(
"Created JARM token failed security validation: {}",
e
))
})?;
}
let final_token = if self.config.enable_jwe_encryption {
self.encrypt_jwt_response(&token).await?
} else {
token
};
if self.config.enable_audit_logging {
self.log_jarm_creation(client_id, &delivery_mode).await;
}
Ok(JarmResponse {
response_token: final_token,
delivery_mode,
expires_at,
client_id: client_id.to_string(),
response_id: Uuid::new_v4().to_string(),
})
}
async fn encrypt_jwt_response(&self, jwt_token: &str) -> Result<String> {
use base64::Engine;
let cek = self.generate_content_encryption_key();
let jwe_header = self.create_jwe_header();
let header_b64 = URL_SAFE_NO_PAD.encode(jwe_header.as_bytes());
let encrypted_payload = self.encrypt_payload(jwt_token, &cek, header_b64.as_bytes())?;
let encrypted_key = self.encrypt_key(&cek)?;
let key_b64 = URL_SAFE_NO_PAD.encode(&encrypted_key);
let payload_parts: Vec<&str> = encrypted_payload.split('.').collect();
if payload_parts.len() != 3 {
return Err(AuthError::auth_method(
"jarm",
"Invalid encrypted payload format",
));
}
let jwe_token = format!(
"{}.{}.{}.{}.{}",
header_b64,
key_b64,
payload_parts[0], payload_parts[1], payload_parts[2] );
tracing::debug!("Created JWE-encrypted JARM response");
Ok(jwe_token)
}
fn generate_content_encryption_key(&self) -> Vec<u8> {
use rand::Rng;
let mut key = vec![0u8; 32];
rand::rng().fill_bytes(&mut key);
key
}
fn encrypt_payload(&self, payload: &str, cek: &[u8], aad: &[u8]) -> Result<String> {
use aes_gcm::{
Aes256Gcm, Key, KeyInit, Nonce,
aead::{Aead, Payload},
};
use rand::Rng;
if cek.len() != 32 {
return Err(AuthError::crypto("CEK must be 32 bytes for AES-256-GCM"));
}
let mut nonce_bytes = [0u8; 12];
rand::rng().fill_bytes(&mut nonce_bytes);
let nonce = Nonce::from_slice(&nonce_bytes);
let key = Key::<Aes256Gcm>::from_slice(cek);
let cipher = Aes256Gcm::new(key);
let ciphertext_with_tag = cipher
.encrypt(
nonce,
Payload {
msg: payload.as_bytes(),
aad,
},
)
.map_err(|e| AuthError::crypto(format!("AES-256-GCM encryption failed: {}", e)))?;
let tag_pos = ciphertext_with_tag.len().saturating_sub(16);
let ciphertext = &ciphertext_with_tag[..tag_pos];
let tag = &ciphertext_with_tag[tag_pos..];
Ok(format!(
"{}.{}.{}",
URL_SAFE_NO_PAD.encode(nonce_bytes),
URL_SAFE_NO_PAD.encode(ciphertext),
URL_SAFE_NO_PAD.encode(tag)
))
}
#[cfg(feature = "rsa-private-key-ops")]
fn encrypt_key(&self, cek: &[u8]) -> Result<Vec<u8>> {
let pub_key = self.jwe_public_key.as_ref().ok_or_else(|| {
AuthError::crypto(
"JARM JWE requires an RSA recipient public key for CEK wrapping. \
Set AdvancedJarmConfig::jwe_recipient_public_key_pem or the \
JARM_JWE_RECIPIENT_PUBLIC_KEY_PEM environment variable.",
)
})?;
let mut ciphertext = vec![0u8; pub_key.ciphertext_size()];
let written = pub_key
.encrypt(
&aws_lc_rs::rsa::OAEP_SHA256_MGF1SHA256,
cek,
&mut ciphertext,
None,
)
.map_err(|_| AuthError::crypto("RSA-OAEP CEK wrap failed"))?
.len();
ciphertext.truncate(written);
Ok(ciphertext)
}
#[cfg(not(feature = "rsa-private-key-ops"))]
fn encrypt_key(&self, _cek: &[u8]) -> Result<Vec<u8>> {
Err(AuthError::crypto(
"JARM RSA-OAEP JWE encryption requires the `rsa-private-key-ops` feature.",
))
}
fn create_jwe_header(&self) -> String {
serde_json::json!({
"alg": "RSA-OAEP",
"enc": "A256GCM",
"typ": "JOSE",
"cty": "JWT"
})
.to_string()
}
pub async fn validate_jarm_response(&self, token: &str) -> Result<JarmValidationResult> {
self.validate_jarm_response_with_transport(token, true)
.await
}
pub async fn validate_jarm_response_with_transport(
&self,
token: &str,
_transport_secure: bool,
) -> Result<JarmValidationResult> {
if !self.config.enable_response_validation {
return Ok(JarmValidationResult {
valid: true,
claims: HashMap::new(),
errors: vec![],
});
}
let mut errors = vec![];
let mut claims = HashMap::new();
let jwt_token = if token.starts_with("JWE.") {
match self.decrypt_jwe_response(token).await {
Ok(decrypted) => decrypted,
Err(e) => {
errors.push(format!("JWE decryption failed: {}", e));
return Ok(JarmValidationResult {
valid: false,
claims,
errors,
});
}
}
} else {
token.to_string()
};
match self
.jwt_validator
.validate_token(&jwt_token, &self.decoding_key)
{
Ok(secure_claims) => {
let claims_value = serde_json::to_value(&secure_claims).map_err(|e| {
AuthError::validation(format!("Failed to serialize claims: {}", e))
})?;
if let serde_json::Value::Object(claim_map) = claims_value {
for (key, value) in claim_map {
claims.insert(key, value);
}
}
self.perform_additional_validation(&claims, &mut errors)
.await;
}
Err(e) => {
errors.push(format!("Enhanced JWT validation failed: {}", e));
}
}
let valid = errors.is_empty();
Ok(JarmValidationResult {
valid,
claims,
errors,
})
}
async fn decrypt_jwe_response(&self, jwe_token: &str) -> Result<String> {
let parts: Vec<&str> = jwe_token.split('.').collect();
if parts.len() != 5 {
return Err(AuthError::InvalidRequest(
"JWE must have 5 parts".to_string(),
));
}
let header = URL_SAFE_NO_PAD
.decode(parts[0])
.map_err(|e| AuthError::InvalidRequest(format!("Invalid header: {}", e)))?;
let header_str = String::from_utf8(header)
.map_err(|e| AuthError::InvalidRequest(format!("Invalid header UTF-8: {}", e)))?;
let header_json: serde_json::Value = serde_json::from_str(&header_str)
.map_err(|e| AuthError::InvalidRequest(format!("Invalid header JSON: {}", e)))?;
let algorithm = header_json
.get("alg")
.and_then(|v| v.as_str())
.unwrap_or("unknown");
let encryption = header_json
.get("enc")
.and_then(|v| v.as_str())
.unwrap_or("unknown");
info!(
"JWE decryption - Algorithm: {}, Encryption: {}",
algorithm, encryption
);
match (algorithm, encryption) {
("RSA-OAEP", "A256GCM") | ("RSA-OAEP-256", "A256GCM") => {
debug!(
"Using supported JWE algorithm combination: {} + {}",
algorithm, encryption
);
}
_ => {
warn!(
"Unsupported JWE algorithm combination: {} + {}",
algorithm, encryption
);
return Err(AuthError::token(format!(
"Unsupported JWE algorithm combination: {} + {}",
algorithm, encryption
)));
}
}
match self
.decrypt_jwe_with_algorithm(&parts, algorithm, encryption)
.await
{
Ok(decrypted_payload) => {
debug!(
"JWE decryption successful with {} + {}",
algorithm, encryption
);
Ok(decrypted_payload)
}
Err(e) => {
error!("JWE decryption failed: {}", e);
Err(e)
}
}
}
async fn decrypt_jwe_with_algorithm(
&self,
parts: &[&str],
algorithm: &str,
encryption: &str,
) -> Result<String, AuthError> {
if parts.len() != 5 {
return Err(AuthError::token("Invalid JWE format - must have 5 parts"));
}
let encrypted_key = parts[1];
let initialization_vector = parts[2];
let ciphertext = parts[3];
let authentication_tag = parts[4];
debug!(
"JWE Components - Key: {}, IV: {}, Ciphertext: {}, Tag: {}",
&encrypted_key[..8.min(encrypted_key.len())],
&initialization_vector[..8.min(initialization_vector.len())],
&ciphertext[..8.min(ciphertext.len())],
&authentication_tag[..8.min(authentication_tag.len())]
);
match (algorithm, encryption) {
("RSA-OAEP", "A256GCM") | ("RSA-OAEP-256", "A256GCM") => self.decrypt_rsa_oaep_a256gcm(
encrypted_key,
initialization_vector,
ciphertext,
authentication_tag,
parts[0].as_bytes(),
),
(alg, enc) => {
error!(
"Unsupported JWE algorithm/encryption combination: {} + {}",
alg, enc
);
Err(AuthError::token(format!(
"Unsupported JWE combination: {} + {}",
alg, enc
)))
}
}
}
#[cfg(not(feature = "rsa-private-key-ops"))]
fn decrypt_rsa_oaep_a256gcm(
&self,
_encrypted_key_b64: &str,
_iv_b64: &str,
_ciphertext_b64: &str,
_tag_b64: &str,
_aad: &[u8],
) -> Result<String, AuthError> {
Err(AuthError::crypto(
"JARM RSA-OAEP JWE decryption requires the `rsa-private-key-ops` feature.",
))
}
#[cfg(feature = "rsa-private-key-ops")]
fn decrypt_rsa_oaep_a256gcm(
&self,
encrypted_key_b64: &str,
iv_b64: &str,
ciphertext_b64: &str,
tag_b64: &str,
aad: &[u8],
) -> Result<String, AuthError> {
use aes_gcm::{
Aes256Gcm, Key, KeyInit, Nonce,
aead::{Aead, Payload},
};
let priv_key = self.jwe_private_key.as_ref().ok_or_else(|| {
AuthError::crypto(
"JARM JWE decryption requires an RSA private key. \
Set AdvancedJarmConfig::jwe_recipient_private_key_pem or the \
JARM_JWE_RECIPIENT_PRIVATE_KEY_PEM environment variable.",
)
})?;
let encrypted_cek = URL_SAFE_NO_PAD
.decode(encrypted_key_b64)
.map_err(|e| AuthError::token(format!("Bad encrypted_key encoding: {e}")))?;
let mut cek_buf = zeroize::Zeroizing::new(vec![0u8; priv_key.key_size_bytes()]);
let cek = priv_key
.decrypt(
&aws_lc_rs::rsa::OAEP_SHA256_MGF1SHA256,
&encrypted_cek,
cek_buf.as_mut_slice(),
None,
)
.map_err(|_| AuthError::crypto("RSA-OAEP CEK unwrap failed"))?;
if cek.len() != 32 {
return Err(AuthError::crypto(format!(
"Unwrapped CEK has unexpected length {} (expected 32)",
cek.len()
)));
}
let nonce_bytes = URL_SAFE_NO_PAD
.decode(iv_b64)
.map_err(|e| AuthError::token(format!("Bad IV encoding: {e}")))?;
let mut ciphertext = URL_SAFE_NO_PAD
.decode(ciphertext_b64)
.map_err(|e| AuthError::token(format!("Bad ciphertext encoding: {e}")))?;
let tag = URL_SAFE_NO_PAD
.decode(tag_b64)
.map_err(|e| AuthError::token(format!("Bad tag encoding: {e}")))?;
if nonce_bytes.len() != 12 {
return Err(AuthError::crypto("JWE IV must be 12 bytes for AES-256-GCM"));
}
ciphertext.extend_from_slice(&tag);
let nonce = Nonce::from_slice(&nonce_bytes);
let key = Key::<Aes256Gcm>::from_slice(cek);
let cipher = Aes256Gcm::new(key);
let plaintext = cipher
.decrypt(
nonce,
Payload {
msg: ciphertext.as_slice(),
aad,
},
)
.map_err(|e| AuthError::crypto(format!("AES-256-GCM decryption failed: {e}")))?;
String::from_utf8(plaintext)
.map_err(|e| AuthError::token(format!("Decrypted payload is not valid UTF-8: {e}")))
}
async fn perform_additional_validation(
&self,
claims: &HashMap<String, Value>,
errors: &mut Vec<String>,
) {
if let Some(iss) = claims.get("iss") {
if iss.as_str() != Some(&self.config.jarm_issuer) {
errors.push(format!("Invalid issuer: {:?}", iss));
}
} else {
errors.push("Missing issuer claim".to_string());
}
if let Some(exp) = claims.get("exp") {
if let Some(exp_time) = exp.as_i64() {
if Utc::now().timestamp() > exp_time {
errors.push("Token has expired".to_string());
}
} else {
errors.push("Invalid expiration claim format".to_string());
}
} else {
errors.push("Missing expiration claim".to_string());
}
if !claims.contains_key("jti") {
errors.push("Missing JWT ID claim".to_string());
}
}
pub async fn deliver_jarm_response(
&self,
jarm_response: &JarmResponse,
client_redirect_uri: &str,
push_endpoint: Option<&str>,
) -> Result<DeliveryResult> {
match jarm_response.delivery_mode {
JarmDeliveryMode::Query => {
let url = format!(
"{}?response={}",
client_redirect_uri, jarm_response.response_token
);
Ok(DeliveryResult::Redirect(url))
}
JarmDeliveryMode::Fragment => {
let url = format!(
"{}#response={}",
client_redirect_uri, jarm_response.response_token
);
Ok(DeliveryResult::Redirect(url))
}
JarmDeliveryMode::FormPost => {
let html = self
.generate_form_post_html(client_redirect_uri, &jarm_response.response_token);
Ok(DeliveryResult::FormPost(html))
}
JarmDeliveryMode::Push => {
if let Some(endpoint) = push_endpoint {
self.push_jarm_response(endpoint, jarm_response).await?;
Ok(DeliveryResult::Push {
success: true,
endpoint: endpoint.to_string(),
})
} else {
Err(AuthError::validation(
"Push endpoint required for push delivery".to_string(),
))
}
}
}
}
fn generate_form_post_html(&self, redirect_uri: &str, response_token: &str) -> String {
format!(
r#"<!DOCTYPE html>
<html>
<head>
<title>JARM Response</title>
<meta charset="UTF-8">
</head>
<body>
<form method="post" action="{}" id="jarm_form" style="display: none;">
<input type="hidden" name="response" value="{}" />
</form>
<script>
window.onload = function() {{
document.getElementById('jarm_form').submit();
}};
</script>
<noscript>
<h2>JavaScript Required</h2>
<p>Please enable JavaScript and reload the page, or manually submit the form below:</p>
<form method="post" action="{}">
<input type="hidden" name="response" value="{}" />
<input type="submit" value="Continue" />
</form>
</noscript>
</body>
</html>"#,
redirect_uri, response_token, redirect_uri, response_token
)
}
async fn push_jarm_response(&self, endpoint: &str, jarm_response: &JarmResponse) -> Result<()> {
let payload = json!({
"response": jarm_response.response_token,
"client_id": jarm_response.client_id,
"response_id": jarm_response.response_id,
"delivered_at": Utc::now(),
});
let response = self
.http_client
.post_json(endpoint, &payload)
.await
.map_err(|e| AuthError::internal(format!("Failed to push JARM response: {}", e)))?;
if !response.status().is_success() {
return Err(AuthError::internal(format!(
"Push delivery failed with status: {}",
response.status()
)));
}
Ok(())
}
async fn log_jarm_creation(&self, client_id: &str, delivery_mode: &JarmDeliveryMode) {
tracing::info!(
client_id = %client_id,
delivery_mode = ?delivery_mode,
"AUDIT: JARM response created"
);
}
pub fn config(&self) -> &AdvancedJarmConfig {
&self.config
}
pub fn revoke_jarm_token(&self, jti: &str) -> Result<()> {
self.jwt_validator
.revoke_token(jti)
.map_err(|e| AuthError::validation(format!("Failed to revoke JARM token: {}", e)))
}
pub fn is_jarm_token_revoked(&self, jti: &str) -> Result<bool> {
self.jwt_validator.is_token_revoked(jti).map_err(|e| {
AuthError::validation(format!("Failed to check token revocation status: {}", e))
})
}
pub fn get_jwt_validator(&self) -> &Arc<SecureJwtValidator> {
&self.jwt_validator
}
}
#[derive(Clone, Serialize, Deserialize)]
pub struct AuthorizationResponse {
pub code: Option<String>,
pub access_token: Option<String>,
pub id_token: Option<String>,
pub state: Option<String>,
pub token_type: Option<String>,
pub expires_in: Option<u64>,
pub scope: Option<String>,
pub error: Option<String>,
pub error_description: Option<String>,
}
impl std::fmt::Debug for AuthorizationResponse {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut d = f.debug_struct("AuthorizationResponse");
d.field("code", &crate::utils::redact::redacted(&self.code));
d.field(
"access_token",
&crate::utils::redact::redacted(&self.access_token),
);
d.field("id_token", &crate::utils::redact::redacted(&self.id_token));
d.field("state", &self.state);
d.field("token_type", &self.token_type);
d.field("expires_in", &self.expires_in);
d.field("scope", &self.scope);
d.field("error", &self.error);
d.field("error_description", &self.error_description);
d.finish()
}
}
#[derive(Clone, Serialize, Deserialize)]
pub struct JarmResponse {
pub response_token: String,
pub delivery_mode: JarmDeliveryMode,
pub expires_at: DateTime<Utc>,
pub client_id: String,
pub response_id: String,
}
impl std::fmt::Debug for JarmResponse {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut d = f.debug_struct("JarmResponse");
d.field(
"response_token",
&crate::utils::redact::redacted(&self.response_token),
);
d.field("delivery_mode", &self.delivery_mode);
d.field("expires_at", &self.expires_at);
d.field("client_id", &self.client_id);
d.field("response_id", &self.response_id);
d.finish()
}
}
#[derive(Debug, Clone)]
pub struct JarmValidationResult {
pub valid: bool,
pub claims: HashMap<String, Value>,
pub errors: Vec<String>,
}
#[derive(Clone)]
pub enum DeliveryResult {
Redirect(String),
FormPost(String),
Push {
success: bool,
endpoint: String,
},
}
impl std::fmt::Debug for DeliveryResult {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use crate::utils::redact::redacted;
match self {
Self::Redirect(v) => f.debug_tuple("Redirect").field(&redacted(v)).finish(),
Self::FormPost(v) => f.debug_tuple("FormPost").field(&redacted(v)).finish(),
Self::Push { success, endpoint } => f
.debug_struct("Push")
.field("success", success)
.field("endpoint", endpoint)
.finish(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_jarm_response_creation() {
let config = AdvancedJarmConfig::builder()
.supported_algorithms(vec![Algorithm::HS256]) .enable_response_validation(false) .build();
let manager = AdvancedJarmManager::new(config).expect("jarm manager");
let auth_response = AuthorizationResponse {
code: Some("auth_code_123".to_string()),
state: Some("client_state".to_string()),
access_token: None,
id_token: None,
token_type: None,
expires_in: None,
scope: None,
error: None,
error_description: None,
};
let jarm_response = manager
.create_jarm_response("test_client", &auth_response, JarmDeliveryMode::Query, None)
.await
.unwrap();
assert!(!jarm_response.response_token.is_empty());
assert_eq!(jarm_response.delivery_mode, JarmDeliveryMode::Query);
assert_eq!(jarm_response.client_id, "test_client");
}
#[tokio::test]
async fn test_custom_claims_validation() {
let config = AdvancedJarmConfig::builder()
.max_custom_claims(2)
.supported_algorithms(vec![Algorithm::HS256])
.build();
let manager = AdvancedJarmManager::new(config).expect("jarm manager");
let auth_response = AuthorizationResponse {
code: Some("code123".to_string()),
state: None,
access_token: None,
id_token: None,
token_type: None,
expires_in: None,
scope: None,
error: None,
error_description: None,
};
let mut custom_claims = HashMap::new();
custom_claims.insert("claim1".to_string(), json!("value1"));
custom_claims.insert("claim2".to_string(), json!("value2"));
custom_claims.insert("claim3".to_string(), json!("value3"));
let result = manager
.create_jarm_response(
"test_client",
&auth_response,
JarmDeliveryMode::Query,
Some(custom_claims),
)
.await;
assert!(result.is_err());
}
#[cfg(feature = "rsa-private-key-ops")]
#[tokio::test]
async fn test_jwe_encrypt_decrypt_roundtrip() {
use aws_lc_rs::encoding::AsDer as _;
fn der_to_pem(der: &[u8], label: &str) -> String {
let b64 = base64::engine::general_purpose::STANDARD.encode(der);
let mut pem = format!("-----BEGIN {label}-----\n");
for chunk in b64.as_bytes().chunks(64) {
pem.push_str(std::str::from_utf8(chunk).unwrap());
pem.push('\n');
}
pem.push_str(&format!("-----END {label}-----\n"));
pem
}
let private_key =
aws_lc_rs::rsa::PrivateDecryptingKey::generate(aws_lc_rs::rsa::KeySize::Rsa2048)
.expect("RSA key generation failed");
let public_key = private_key.public_key();
let priv_der = private_key.as_der().expect("private key DER export failed");
let pub_der = public_key.as_der().expect("public key DER export failed");
let priv_pem = der_to_pem(priv_der.as_ref(), "PRIVATE KEY");
let pub_pem = der_to_pem(pub_der.as_ref(), "PUBLIC KEY");
let config = AdvancedJarmConfig::builder()
.supported_algorithms(vec![Algorithm::HS256])
.enable_jwe_encryption(true)
.enable_response_validation(false)
.jwe_recipient_public_key_pem(pub_pem)
.jwe_recipient_private_key_pem(priv_pem)
.build();
let manager = AdvancedJarmManager::new(config).expect("jarm manager");
assert!(
manager.jwe_public_key.is_some(),
"JWE public key should have been loaded"
);
assert!(
manager.jwe_private_key.is_some(),
"JWE private key should have been loaded"
);
let auth_response = AuthorizationResponse {
code: Some("enc_test_code".to_string()),
state: Some("enc_state".to_string()),
access_token: None,
id_token: None,
token_type: None,
expires_in: None,
scope: None,
error: None,
error_description: None,
};
let jarm = manager
.create_jarm_response("enc_client", &auth_response, JarmDeliveryMode::Query, None)
.await
.expect("create_jarm_response with JWE failed");
let parts: Vec<&str> = jarm.response_token.split('.').collect();
assert_eq!(
parts.len(),
5,
"JWE token should have 5 parts, got: {}",
parts.len()
);
let recovered = manager
.decrypt_jwe_with_algorithm(&parts, "RSA-OAEP-256", "A256GCM")
.await
.expect("JWE decryption failed");
assert_eq!(
recovered.split('.').count(),
3,
"Recovered payload should be a 3-part JWT"
);
}
#[cfg(feature = "rsa-private-key-ops")]
fn jwe_test_manager() -> AdvancedJarmManager {
use aws_lc_rs::encoding::AsDer as _;
fn der_to_pem(der: &[u8], label: &str) -> String {
let b64 = base64::engine::general_purpose::STANDARD.encode(der);
let mut pem = format!("-----BEGIN {label}-----\n");
for chunk in b64.as_bytes().chunks(64) {
pem.push_str(std::str::from_utf8(chunk).unwrap());
pem.push('\n');
}
pem.push_str(&format!("-----END {label}-----\n"));
pem
}
let private_key =
aws_lc_rs::rsa::PrivateDecryptingKey::generate(aws_lc_rs::rsa::KeySize::Rsa2048)
.expect("RSA key generation failed");
let public_key = private_key.public_key();
let priv_pem = der_to_pem(
private_key.as_der().expect("private DER").as_ref(),
"PRIVATE KEY",
);
let pub_pem = der_to_pem(
public_key.as_der().expect("public DER").as_ref(),
"PUBLIC KEY",
);
let config = AdvancedJarmConfig::builder()
.supported_algorithms(vec![Algorithm::HS256])
.enable_jwe_encryption(true)
.enable_response_validation(false)
.jwe_recipient_public_key_pem(pub_pem)
.jwe_recipient_private_key_pem(priv_pem)
.build();
AdvancedJarmManager::new(config).expect("jarm manager")
}
#[cfg(feature = "rsa-private-key-ops")]
async fn jwe_test_token(manager: &AdvancedJarmManager) -> String {
let auth_response = AuthorizationResponse {
code: Some("aad_code".to_string()),
state: Some("aad_state".to_string()),
access_token: None,
id_token: None,
token_type: None,
expires_in: None,
scope: None,
error: None,
error_description: None,
};
manager
.create_jarm_response("aad_client", &auth_response, JarmDeliveryMode::Query, None)
.await
.expect("create_jarm_response with JWE failed")
.response_token
}
#[cfg(feature = "rsa-private-key-ops")]
#[tokio::test]
async fn test_jwe_protected_header_is_authenticated() {
let manager = jwe_test_manager();
let token = jwe_test_token(&manager).await;
let parts: Vec<&str> = token.split('.').collect();
assert_eq!(parts.len(), 5);
manager
.decrypt_jwe_with_algorithm(&parts, "RSA-OAEP", "A256GCM")
.await
.expect("the untouched token must decrypt");
let header = String::from_utf8(URL_SAFE_NO_PAD.decode(parts[0]).unwrap()).unwrap();
assert!(header.contains("\"typ\":\"JOSE\""), "header was {header}");
let tampered_header =
URL_SAFE_NO_PAD.encode(header.replace("\"typ\":\"JOSE\"", "\"typ\":\"JOSX\""));
assert_ne!(tampered_header, parts[0]);
let mut tampered = parts.clone();
tampered[0] = &tampered_header;
let err = manager
.decrypt_jwe_with_algorithm(&tampered, "RSA-OAEP", "A256GCM")
.await
.expect_err("a token with a changed protected header must not decrypt");
assert!(
format!("{err}").contains("AES-256-GCM decryption failed"),
"{err}"
);
}
#[cfg(feature = "rsa-private-key-ops")]
#[tokio::test]
async fn test_jwe_content_decrypts_with_the_header_as_aad() {
use aes_gcm::{
Aes256Gcm, Key, KeyInit, Nonce,
aead::{Aead, Payload},
};
let manager = jwe_test_manager();
let token = jwe_test_token(&manager).await;
let parts: Vec<&str> = token.split('.').collect();
let wrapped = URL_SAFE_NO_PAD.decode(parts[1]).unwrap();
let priv_key = manager.jwe_private_key.as_ref().unwrap();
let mut buf = vec![0u8; priv_key.key_size_bytes()];
let cek = priv_key
.decrypt(
&aws_lc_rs::rsa::OAEP_SHA256_MGF1SHA256,
&wrapped,
buf.as_mut_slice(),
None,
)
.expect("CEK unwrap");
let nonce_bytes = URL_SAFE_NO_PAD.decode(parts[2]).unwrap();
let mut sealed = URL_SAFE_NO_PAD.decode(parts[3]).unwrap();
sealed.extend_from_slice(&URL_SAFE_NO_PAD.decode(parts[4]).unwrap());
let cipher = Aes256Gcm::new(Key::<Aes256Gcm>::from_slice(cek));
let nonce = Nonce::from_slice(&nonce_bytes);
let jwt = cipher
.decrypt(
nonce,
Payload {
msg: sealed.as_slice(),
aad: parts[0].as_bytes(),
},
)
.expect("AES-GCM with the protected header as AAD must open the content");
assert_eq!(String::from_utf8(jwt).unwrap().split('.').count(), 3);
assert!(
cipher.decrypt(nonce, sealed.as_slice()).is_err(),
"content must not open without the AAD"
);
}
#[cfg(feature = "rsa-private-key-ops")]
#[tokio::test]
async fn test_jwe_decrypt_rejects_malformed_ciphertext_uniformly() {
use aws_lc_rs::encoding::AsDer as _;
fn der_to_pem(der: &[u8], label: &str) -> String {
let b64 = base64::engine::general_purpose::STANDARD.encode(der);
let mut pem = format!("-----BEGIN {label}-----\n");
for chunk in b64.as_bytes().chunks(64) {
pem.push_str(std::str::from_utf8(chunk).unwrap());
pem.push('\n');
}
pem.push_str(&format!("-----END {label}-----\n"));
pem
}
let private_key =
aws_lc_rs::rsa::PrivateDecryptingKey::generate(aws_lc_rs::rsa::KeySize::Rsa2048)
.expect("RSA key generation failed");
let public_key = private_key.public_key();
let priv_pem = der_to_pem(
private_key
.as_der()
.expect("private key DER export failed")
.as_ref(),
"PRIVATE KEY",
);
let pub_pem = der_to_pem(
public_key
.as_der()
.expect("public key DER export failed")
.as_ref(),
"PUBLIC KEY",
);
let config = AdvancedJarmConfig::builder()
.supported_algorithms(vec![Algorithm::HS256])
.enable_jwe_encryption(true)
.jwe_recipient_public_key_pem(pub_pem)
.jwe_recipient_private_key_pem(priv_pem)
.build();
let manager = AdvancedJarmManager::new(config).expect("jarm manager");
assert!(
manager.jwe_private_key.is_some(),
"JWE private key must have loaded for this test to mean anything"
);
assert!(
manager.jwe_public_key.is_some(),
"JWE public key must have loaded for this test to mean anything"
);
let iv_b64 = URL_SAFE_NO_PAD.encode([0u8; 12]);
let tag_b64 = URL_SAFE_NO_PAD.encode([0u8; 16]);
let ciphertext_b64 = URL_SAFE_NO_PAD.encode([0u8; 16]);
let wrong_key_same_size = URL_SAFE_NO_PAD.encode(vec![0x42u8; 256]);
let too_short = URL_SAFE_NO_PAD.encode(vec![0x42u8; 16]);
let too_long = URL_SAFE_NO_PAD.encode(vec![0x42u8; 512]);
let empty = URL_SAFE_NO_PAD.encode(Vec::<u8>::new());
let mut messages = Vec::new();
for encrypted_key_b64 in [&wrong_key_same_size, &too_short, &too_long, &empty] {
let err = manager
.decrypt_rsa_oaep_a256gcm(
encrypted_key_b64,
&iv_b64,
&ciphertext_b64,
&tag_b64,
b"header",
)
.expect_err("malformed/forged ciphertext must never decrypt successfully");
messages.push(format!("{err}"));
}
let first = &messages[0];
assert!(
first.contains("CEK unwrap failed"),
"expected the RSA-OAEP-layer error, got {first:?} -- if the keys didn't \
load this would be the generic \"requires an RSA private key\" message instead, \
which would make the uniformity check below pass vacuously"
);
for (i, msg) in messages.iter().enumerate() {
assert_eq!(
msg, first,
"input {i} produced a different error message than input 0 ({first:?} vs {msg:?}) -- \
a distinguishable failure mode is exactly the oracle this path must not have"
);
}
}
#[test]
fn test_form_post_html_generation() {
let config = AdvancedJarmConfig::builder()
.supported_algorithms(vec![Algorithm::HS256])
.build();
let manager = AdvancedJarmManager::new(config).expect("jarm manager");
let html = manager.generate_form_post_html(
"https://client.example.com/callback",
"eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...",
);
assert!(html.contains("https://client.example.com/callback"));
assert!(html.contains("eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9"));
assert!(html.contains("jarm_form"));
}
#[tokio::test]
async fn test_delivery_mode_validation() {
let config = AdvancedJarmConfig::builder()
.supported_delivery_modes(vec![JarmDeliveryMode::Query])
.supported_algorithms(vec![Algorithm::HS256]) .build();
let manager = AdvancedJarmManager::new(config).expect("jarm manager");
let auth_response = AuthorizationResponse {
code: Some("code123".to_string()),
state: None,
access_token: None,
id_token: None,
token_type: None,
expires_in: None,
scope: None,
error: None,
error_description: None,
};
let result = manager
.create_jarm_response("test_client", &auth_response, JarmDeliveryMode::Query, None)
.await;
assert!(result.is_ok());
let result = manager
.create_jarm_response("test_client", &auth_response, JarmDeliveryMode::Push, None)
.await;
assert!(result.is_err());
}
}