//! OAuth encoding and signature engine facade (`SMH-SPEC-SPEC0001`). use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD}; use serde_json::Value; pub fn encode(bytes: &[u8]) -> String { URL_SAFE_NO_PAD.encode(bytes) } pub fn decode(text: &str) -> Result, &'static str> { URL_SAFE_NO_PAD .decode(text) .map_err(|_| "invalid OAuth base64url") } pub fn challenge(verifier: &str) -> String { encode(ring::digest::digest(&ring::digest::SHA256, verifier.as_bytes()).as_ref()) } pub fn verify_identity(token: &str, keys: &Value) -> Result { const TOKEN_BYTES_MAX: usize = 32 * 1024; if token.len() > TOKEN_BYTES_MAX { return Err("OAuth ID token exceeds byte bound"); } let mut parts = token.split('.'); let header = parts.next().ok_or("missing OAuth JWT header")?; let payload = parts.next().ok_or("missing OAuth JWT payload")?; let signature = parts.next().ok_or("missing OAuth JWT signature")?; if parts.next().is_some() { return Err("invalid OAuth JWT segments"); } let header: Value = serde_json::from_slice(&decode(header)?).map_err(|_| "invalid OAuth JWT header")?; let fields = header.as_object().ok_or("invalid OAuth JWT header")?; if fields .keys() .any(|name| !matches!(name.as_str(), "alg" | "kid" | "typ")) || header.get("typ").is_some_and(|kind| kind != "JWT") { return Err("unsupported OAuth JWT header"); } let algorithm = header["alg"] .as_str() .ok_or("missing OAuth JWT algorithm")?; let key_id = header["kid"] .as_str() .filter(|id| !id.is_empty()) .ok_or("missing OAuth JWT key id")?; let keys = keys["keys"] .as_array() .filter(|keys| keys.len() <= 64) .ok_or("invalid OAuth JWKS key bound")?; let mut matching = keys .iter() .filter(|key| key["kid"].as_str() == Some(key_id)); let key = matching.next().ok_or("unknown OAuth signing key")?; if matching.next().is_some() || key .get("alg") .is_some_and(|value| value.as_str() != Some(algorithm)) || key.get("use").is_some_and(|value| value != "sig") || key .get("key_ops") .is_some_and(|value| value != &serde_json::json!(["verify"])) { return Err("ambiguous or unauthorized OAuth signing key"); } let signature = decode(signature)?; // The signature covers original encoded segments, never reserialized JSON. let message = token .rsplit_once('.') .ok_or("invalid OAuth JWT")? .0 .as_bytes(); match (algorithm, key["kty"].as_str()) { ("RS256", Some("RSA")) => { let modulus = decode(key["n"].as_str().ok_or("missing OAuth RSA modulus")?)?; let exponent = decode(key["e"].as_str().ok_or("missing OAuth RSA exponent")?)?; ring::signature::RsaPublicKeyComponents { n: modulus, e: exponent, } .verify( &ring::signature::RSA_PKCS1_2048_8192_SHA256, message, &signature, ) .map_err(|_| "invalid OAuth ID signature")?; } ("EdDSA", Some("OKP")) if key["crv"] == "Ed25519" => { let public = decode(key["x"].as_str().ok_or("missing OAuth Ed25519 key")?)?; ring::signature::UnparsedPublicKey::new(&ring::signature::ED25519, public) .verify(message, &signature) .map_err(|_| "invalid OAuth ID signature")?; } _ => return Err("unsupported OAuth signature algorithm or key type"), } serde_json::from_slice(&decode(payload)?).map_err(|_| "invalid OAuth JWT claims") } #[cfg(test)] pub(crate) mod tests { //! SMH-SPEC-SPEC0001: signed synthetic identities, no provider keys. use super::*; use ring::signature::{Ed25519KeyPair, KeyPair}; use serde_json::json; pub(crate) fn signed(payload: &Value) -> (String, Value) { let pair = Ed25519KeyPair::from_seed_unchecked(&[42; 32]).unwrap(); let header = encode(br#"{"alg":"EdDSA","kid":"fixture","typ":"JWT"}"#); let body = encode(&serde_json::to_vec(payload).unwrap()); let message = format!("{header}.{body}"); let signature = encode(pair.sign(message.as_bytes()).as_ref()); let keys = json!({"keys":[{"kty":"OKP","crv":"Ed25519","alg":"EdDSA","use":"sig","kid":"fixture","x":encode(pair.public_key().as_ref())}]}); (format!("{message}.{signature}"), keys) } #[test] fn signed_identity_requires_authentic_signature_and_unambiguous_key() { let payload = json!({"sub":"synthetic-account","aud":"oaiapp_fixture"}); let (token, keys) = signed(&payload); assert_eq!(verify_identity(&token, &keys).unwrap(), payload); let tampered = token.replace( &encode(&serde_json::to_vec(&payload).unwrap()), &encode(br#"{"sub":"attacker"}"#), ); assert!(verify_identity(&tampered, &keys).is_err()); let mut duplicate = keys.clone(); duplicate["keys"] .as_array_mut() .unwrap() .push(keys["keys"][0].clone()); assert!(verify_identity(&token, &duplicate).is_err()); let mut wrong = keys.clone(); wrong["keys"][0]["kty"] = json!("RSA"); assert!(verify_identity(&token, &wrong).is_err()); } #[test] fn pkce_matches_rfc7636_s256_example() { assert_eq!( challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"), "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM" ); } }