use super::*; use jsonwebtoken::{EncodingKey, Header, encode}; use openssl::{ asn1::Asn1Time, bn::{BigNum, MsbOption}, hash::MessageDigest, pkey::{PKey, Private}, rsa::Rsa, x509::{ X509, X509NameBuilder, extension::{BasicConstraints, ExtendedKeyUsage, KeyUsage, SubjectAlternativeName}, }, }; use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer}; use serde_json::{Value, json}; use std::{ collections::HashMap, sync::atomic::{AtomicUsize, Ordering}, }; use tokio::{ io::{AsyncReadExt, AsyncWriteExt}, net::TcpListener, }; struct Signing { kid: String, key: PKey, } impl Signing { fn new(kid: &str) -> Self { Self { kid: kid.into(), key: PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap(), } } fn jwk(&self) -> Value { let rsa = self.key.rsa().unwrap(); json!({"kid":self.kid,"alg":"RS256","kty":"RSA","use":"sig", "n":URL_SAFE_NO_PAD.encode(rsa.n().to_vec()),"e":URL_SAFE_NO_PAD.encode(rsa.e().to_vec())}) } fn token(&self, claims: &Value, access: bool) -> String { let mut header = Header::new(Algorithm::RS256); header.kid = Some(self.kid.clone()); header.typ = Some(if access { "at+jwt" } else { "JWT" }.into()); encode( &header, claims, &EncodingKey::from_rsa_pem(&self.key.private_key_to_pem_pkcs8().unwrap()).unwrap(), ) .unwrap() } } struct Code { challenge: String, nonce: String, redirect: String, } struct Mock { issuer: String, signing: Mutex, codes: Mutex>, jwks_calls: AtomicUsize, exchanges: AtomicUsize, mutate: Mutex>, discovery_override: Mutex>, response_override: Mutex>, unexpected_calls: AtomicUsize, } #[derive(Clone)] struct ResponseOverride { path: String, status: &'static str, location: Option, body: String, } struct Provider { state: Arc, root: reqwest::Certificate, task: tokio::task::JoinHandle<()>, } impl Drop for Provider { fn drop(&mut self) { self.task.abort(); } } fn certificates() -> (Vec, Vec, Vec) { let ca_key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap(); let mut name = X509NameBuilder::new().unwrap(); name.append_entry_by_text("CN", "Ephemeral OIDC test CA") .unwrap(); let name = name.build(); let mut ca = X509::builder().unwrap(); ca.set_version(2).unwrap(); let mut serial = BigNum::new().unwrap(); serial.rand(128, MsbOption::MAYBE_ZERO, false).unwrap(); let serial = serial.to_asn1_integer().unwrap(); ca.set_serial_number(&serial).unwrap(); ca.set_subject_name(&name).unwrap(); ca.set_issuer_name(&name).unwrap(); ca.set_pubkey(&ca_key).unwrap(); ca.set_not_before(&Asn1Time::days_from_now(0).unwrap()) .unwrap(); ca.set_not_after(&Asn1Time::days_from_now(1).unwrap()) .unwrap(); ca.append_extension(BasicConstraints::new().critical().ca().build().unwrap()) .unwrap(); ca.append_extension( KeyUsage::new() .critical() .key_cert_sign() .crl_sign() .build() .unwrap(), ) .unwrap(); ca.sign(&ca_key, MessageDigest::sha256()).unwrap(); let ca = ca.build(); let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap(); let mut leaf = X509::builder().unwrap(); leaf.set_version(2).unwrap(); leaf.set_serial_number(&serial).unwrap(); leaf.set_subject_name(&name).unwrap(); leaf.set_issuer_name(ca.subject_name()).unwrap(); leaf.set_pubkey(&key).unwrap(); leaf.set_not_before(&Asn1Time::days_from_now(0).unwrap()) .unwrap(); leaf.set_not_after(&Asn1Time::days_from_now(1).unwrap()) .unwrap(); leaf.append_extension(BasicConstraints::new().critical().build().unwrap()) .unwrap(); leaf.append_extension( KeyUsage::new() .critical() .digital_signature() .build() .unwrap(), ) .unwrap(); leaf.append_extension(ExtendedKeyUsage::new().server_auth().build().unwrap()) .unwrap(); let san = SubjectAlternativeName::new() .dns("localhost") .build(&leaf.x509v3_context(Some(&ca), None)) .unwrap(); leaf.append_extension(san).unwrap(); leaf.sign(&ca_key, MessageDigest::sha256()).unwrap(); ( ca.to_pem().unwrap(), leaf.build().to_der().unwrap(), key.private_key_to_pkcs8().unwrap(), ) } impl Provider { async fn start() -> Self { let (ca, cert, key) = certificates(); let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); let config = rustls::ServerConfig::builder_with_provider(Arc::new( rustls::crypto::ring::default_provider(), )) .with_safe_default_protocol_versions() .unwrap() .with_no_client_auth() .with_single_cert( vec![CertificateDer::from(cert)], PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(key)), ) .unwrap(); let acceptor = tokio_rustls::TlsAcceptor::from(Arc::new(config)); let state = Arc::new(Mock { issuer: format!("https://localhost:{port}/"), signing: Mutex::new(Signing::new("first")), codes: Mutex::new(HashMap::new()), jwks_calls: AtomicUsize::new(0), exchanges: AtomicUsize::new(0), mutate: Mutex::new(None), discovery_override: Mutex::new(None), response_override: Mutex::new(None), unexpected_calls: AtomicUsize::new(0), }); let server_state = state.clone(); let task = tokio::spawn(async move { loop { let (socket, _) = listener.accept().await.unwrap(); let acceptor = acceptor.clone(); let state = server_state.clone(); tokio::spawn(async move { let Ok(mut stream) = acceptor.accept(socket).await else { return; }; let mut request = vec![]; let mut chunk = [0u8; 4096]; let (head_end, length) = loop { let n = stream.read(&mut chunk).await.unwrap_or(0); if n == 0 { return; } request.extend_from_slice(&chunk[..n]); if request.len() > 32768 { return; } if let Some(end) = request.windows(4).position(|w| w == b"\r\n\r\n") { let headers = String::from_utf8_lossy(&request[..end]); let length = headers .lines() .find_map(|line| { line.to_ascii_lowercase() .strip_prefix("content-length:") .and_then(|s| s.trim().parse::().ok()) }) .unwrap_or(0); break (end + 4, length); } }; while request.len() < head_end + length { let n = stream.read(&mut chunk).await.unwrap_or(0); if n == 0 { return; } request.extend_from_slice(&chunk[..n]); } let first = String::from_utf8_lossy(&request[..head_end]); let target = first.split_whitespace().nth(1).unwrap(); let url = Url::parse(&format!("{}{}", state.issuer.trim_end_matches('/'), target)) .unwrap(); let (status, location, body) = state .respond(url, &request[head_end..head_end + length]) .await; let response = format!( "HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n{}\r\n{body}", body.len(), location .map(|l| format!("Location: {l}\r\n")) .unwrap_or_default() ); let _ = stream.write_all(response.as_bytes()).await; let _ = stream.shutdown().await; }); } }); Self { state, root: reqwest::Certificate::from_pem(&ca).unwrap(), task, } } fn config(&self) -> Config { Config { issuer: Url::parse(&self.state.issuer).unwrap(), browser_client_id: "browser".into(), client_secret_ref: "test-only-secret-reference".into(), redirect_uri: Url::parse("https://rmm.example/callback").unwrap(), mcp_audience: "https://rmm.example/mcp".into(), mcp_client_ids: BTreeSet::from(["mcp-client".into()]), } } async fn auth(&self) -> OidcAuth { OidcAuth::discover( self.config(), Profile::DevTest, Arc::new(dev::InMemoryStateStore::new(dev::DevTestOnly)), Arc::new(Secrets), vec![self.root.clone()], ) .await .unwrap() } fn http(&self) -> reqwest::Client { reqwest::Client::builder() .no_proxy() .add_root_certificate(self.root.clone()) .redirect(reqwest::redirect::Policy::none()) .build() .unwrap() } async fn authorize(&self, start: &LoginStart) -> (String, String, String) { let response = self .http() .get(start.authorization_url.clone()) .send() .await .unwrap(); assert_eq!(response.status(), 302); let callback = Url::parse(response.headers()["location"].to_str().unwrap()).unwrap(); let pairs: HashMap<_, _> = callback.query_pairs().into_owned().collect(); let binding = start .binding_set_cookie .split(';') .next() .unwrap() .split_once('=') .unwrap() .1 .to_owned(); (pairs["code"].clone(), pairs["state"].clone(), binding) } async fn access_token(&self, field: Option<(&str, Value)>) -> String { let mut claims = self.state.claims("https://rmm.example/mcp"); claims["scope"] = json!("inventory:read operations:submit"); claims["client_id"] = json!("mcp-client"); if let Some((key, value)) = field { claims[key] = value; } self.state.signing.lock().await.token(&claims, true) } } impl Mock { fn claims(&self, aud: &str) -> Value { json!({"iss":self.issuer,"sub":"stable-subject","aud":aud,"iat":now(),"exp":now()+300,"nbf":now()-1,"jti":random()}) } async fn respond(&self, url: Url, body: &[u8]) -> (&'static str, Option, String) { if let Some(response) = self.response_override.lock().await.clone() && response.path == url.path() { return (response.status, response.location, response.body); } let output = match url.path() { "/.well-known/openid-configuration" => { if let Some(value) = self.discovery_override.lock().await.clone() { value } else { json!({"issuer":self.issuer,"authorization_endpoint":format!("{}authorize",self.issuer),"token_endpoint":format!("{}token",self.issuer),"jwks_uri":format!("{}jwks",self.issuer),"response_types_supported":["code"],"id_token_signing_alg_values_supported":["RS256"],"code_challenge_methods_supported":["S256"],"token_endpoint_auth_methods_supported":["client_secret_post"]}) } } "/jwks" => { self.jwks_calls.fetch_add(1, Ordering::SeqCst); json!({"keys":[self.signing.lock().await.jwk()]}) } "/authorize" => { let q: HashMap<_, _> = url.query_pairs().into_owned().collect(); if q.get("client_id").map(String::as_str) != Some("browser") || q.get("code_challenge_method").map(String::as_str) != Some("S256") || q.get("redirect_uri").map(String::as_str) != Some("https://rmm.example/callback") { return ("400 Bad Request", None, "{}".into()); } let code = random(); self.codes.lock().await.insert( code.clone(), Code { challenge: q["code_challenge"].clone(), nonce: q["nonce"].clone(), redirect: q["redirect_uri"].clone(), }, ); let mut callback = Url::parse(&q["redirect_uri"]).unwrap(); callback .query_pairs_mut() .extend_pairs([("code", code.as_str()), ("state", q["state"].as_str())]); return ("302 Found", Some(callback.to_string()), "{}".into()); } "/token" => { self.exchanges.fetch_add(1, Ordering::SeqCst); let q: HashMap = serde_urlencoded::from_bytes(body).unwrap(); let Some(code) = self.codes.lock().await.remove(&q["code"]) else { return ("400 Bad Request", None, "{}".into()); }; if q.get("grant_type").map(String::as_str) != Some("authorization_code") || q.get("client_id").map(String::as_str) != Some("browser") || q.get("client_secret").map(String::as_str) != Some("ephemeral-test-secret") || q.get("redirect_uri") != Some(&code.redirect) || q.get("code_verifier") .is_none_or(|v| hash(v) != code.challenge) { return ("400 Bad Request", None, "{}".into()); } let mut claims = self.claims("browser"); claims["nonce"] = json!(code.nonce); if let Some((key, value)) = self.mutate.lock().await.clone() { claims[key] = value; } json!({"id_token":self.signing.lock().await.token(&claims, false),"token_type":"Bearer","access_token":"unused-by-rmm"}) } _ => { self.unexpected_calls.fetch_add(1, Ordering::SeqCst); return ("404 Not Found", None, "{}".into()); } }; ("200 OK", None, output.to_string()) } } struct Secrets; #[async_trait] impl SecretResolver for Secrets { async fn resolve(&self, _: &str) -> Result { Ok(SecretString::from("ephemeral-test-secret")) } } #[tokio::test] async fn browser_code_exchange_pkce_nonce_binding_and_replay() { let provider = Provider::start().await; let auth = provider.auth().await; let start = auth.login_start().await.unwrap(); assert!(start.binding_set_cookie.contains("SameSite=Lax")); let (code, state, binding) = provider.authorize(&start).await; assert_eq!( auth.callback(Callback { code: &code, state: &state, browser_binding: &random() }) .await, Err(Error::State) ); let identity = auth .callback(Callback { code: &code, state: &state, browser_binding: &binding, }) .await .unwrap(); assert_eq!(identity.subject, "stable-subject"); assert_eq!(identity.issuer, provider.state.issuer); assert_eq!( auth.callback(Callback { code: &code, state: &state, browser_binding: &binding }) .await, Err(Error::State) ); assert_eq!(provider.state.exchanges.load(Ordering::SeqCst), 1); } #[tokio::test] async fn invalid_nonce_and_multi_audience_authorized_party() { let provider = Provider::start().await; let auth = provider.auth().await; for (field, value, expected) in [ ("nonce", json!("wrong"), Error::Nonce), ("aud", json!(["browser", "other"]), Error::InvalidAudience), ("azp", json!("other-client"), Error::InvalidAudience), ] { *provider.state.mutate.lock().await = Some((field, value)); let start = auth.login_start().await.unwrap(); let (code, state, binding) = provider.authorize(&start).await; assert_eq!( auth.callback(Callback { code: &code, state: &state, browser_binding: &binding }) .await, Err(expected) ); } *provider.state.mutate.lock().await = Some(("azp", json!("browser"))); let start = auth.login_start().await.unwrap(); let (code, state, binding) = provider.authorize(&start).await; assert!( auth.callback(Callback { code: &code, state: &state, browser_binding: &binding }) .await .is_ok() ); } #[tokio::test] async fn pkce_failure_and_one_use_provider_code() { let provider = Provider::start().await; let auth = provider.auth().await; let start = auth.login_start().await.unwrap(); let (code, state, binding) = provider.authorize(&start).await; provider .state .codes .lock() .await .get_mut(&code) .unwrap() .challenge = "mismatched-challenge".into(); assert_eq!( auth.callback(Callback { code: &code, state: &state, browser_binding: &binding }) .await, Err(Error::CodeExchange) ); assert!(!provider.state.codes.lock().await.contains_key(&code)); let response = provider .http() .post(format!("{}token", provider.state.issuer)) .form(&[("code", code)]) .send() .await .unwrap(); assert_eq!(response.status(), 400); } #[tokio::test] async fn bearer_issuer_audience_expiry_nbf_scope_and_client() { let provider = Provider::start().await; let auth = provider.auth().await; let token = provider.access_token(None).await; let principal = auth .verify_mcp_bearer(&token, &["inventory:read"]) .await .unwrap(); assert_eq!(principal.identity.subject, "stable-subject"); assert!(matches!( auth.verify_mcp_bearer(&token, &["approvals:write"]).await, Err(Error::MissingScope) )); for (field, value, expected) in [ ( "iss", json!("https://attacker.example/"), Error::InvalidIssuer, ), ("aud", json!("browser"), Error::InvalidAudience), ("exp", json!(now() - 60), Error::Expired), ("nbf", json!(now() + 300), Error::NotYetValid), ("client_id", json!("unknown-client"), Error::InvalidAudience), ] { let token = provider.access_token(Some((field, value))).await; assert_eq!( auth.verify_mcp_bearer(&token, &[]).await.unwrap_err(), expected ); } } #[tokio::test] async fn signature_algorithm_and_id_token_confusion_rejected() { let provider = Provider::start().await; let auth = provider.auth().await; let signing = provider.state.signing.lock().await; let id = signing.token(&provider.state.claims("https://rmm.example/mcp"), false); assert!(matches!( auth.verify_mcp_bearer(&id, &[]).await, Err(Error::InvalidToken) )); let mut header = Header::new(Algorithm::HS256); header.kid = Some(signing.kid.clone()); header.typ = Some("at+jwt".into()); let hs = encode( &header, &provider.state.claims("https://rmm.example/mcp"), &EncodingKey::from_secret(b"not-an-rsa-key"), ) .unwrap(); assert!(matches!( auth.verify_mcp_bearer(&hs, &[]).await, Err(Error::InvalidToken) )); drop(signing); let unsigned = format!( "{}.{}.", URL_SAFE_NO_PAD.encode(br#"{"alg":"none","typ":"at+jwt"}"#), URL_SAFE_NO_PAD.encode(b"{}") ); assert!(matches!( auth.verify_mcp_bearer(&unsigned, &[]).await, Err(Error::InvalidToken) )); let forged = Signing::new("first").token(&provider.state.claims("https://rmm.example/mcp"), true); assert!(matches!( auth.verify_mcp_bearer(&forged, &[]).await, Err(Error::InvalidToken) )); } #[tokio::test] async fn jwks_cache_unknown_kid_and_real_rotation() { let provider = Provider::start().await; let auth = provider.auth().await; let first = provider.access_token(None).await; auth.verify_mcp_bearer(&first, &[]).await.unwrap(); auth.verify_mcp_bearer(&first, &[]).await.unwrap(); assert_eq!(provider.state.jwks_calls.load(Ordering::SeqCst), 1); *provider.state.signing.lock().await = Signing::new("rotated"); let rotated = provider.access_token(None).await; assert!(matches!( auth.verify_mcp_bearer(&rotated, &[]).await, Err(Error::UnknownKid) )); tokio::time::sleep(Duration::from_millis(1100)).await; auth.verify_mcp_bearer(&rotated, &[]).await.unwrap(); assert_eq!(provider.state.jwks_calls.load(Ordering::SeqCst), 2); assert!(matches!( auth.verify_mcp_bearer(&first, &[]).await, Err(Error::UnknownKid) )); } #[tokio::test] async fn tls_trust_and_hostname_are_actually_checked() { let provider = Provider::start().await; let store = || Arc::new(dev::InMemoryStateStore::new(dev::DevTestOnly)); assert!(matches!( OidcAuth::discover( provider.config(), Profile::DevTest, store(), Arc::new(Secrets), vec![] ) .await, Err(Error::Transport) )); let mut config = provider.config(); config.issuer.set_host(Some("127.0.0.1")).unwrap(); assert!(matches!( OidcAuth::discover( config, Profile::DevTest, store(), Arc::new(Secrets), vec![provider.root.clone()] ) .await, Err(Error::Transport) )); provider.auth().await; } #[tokio::test] async fn insecure_configuration_and_volatile_production_store_rejected() { let provider = Provider::start().await; for variant in 0..4 { let mut config = provider.config(); let mut profile = Profile::DevTest; match variant { 0 => { config.issuer.set_scheme("http").unwrap(); } 1 => { config.mcp_audience = config.browser_client_id.clone(); } 2 => { profile = Profile::Production; } _ => { config.redirect_uri.set_fragment(Some("untrusted")); } } assert!(matches!( OidcAuth::discover( config, profile, Arc::new(dev::InMemoryStateStore::new(dev::DevTestOnly)), Arc::new(Secrets), vec![provider.root.clone()] ) .await, Err(Error::Configuration) )); } } #[tokio::test] async fn untrusted_discovery_endpoints_and_issuer_rejected() { let provider = Provider::start().await; for (issuer, jwks) in [ ( provider.state.issuer.clone(), "https://attacker.example/jwks".to_owned(), ), ( "https://attacker.example/".to_owned(), format!("{}jwks", provider.state.issuer), ), ( provider.state.issuer.clone(), "http://localhost/jwks".to_owned(), ), ] { *provider.state.discovery_override.lock().await = Some( json!({"issuer":issuer,"authorization_endpoint":format!("{}authorize",provider.state.issuer),"token_endpoint":format!("{}token",provider.state.issuer),"jwks_uri":jwks,"response_types_supported":["code"],"id_token_signing_alg_values_supported":["RS256"],"code_challenge_methods_supported":["S256"],"token_endpoint_auth_methods_supported":["client_secret_post"]}), ); assert!(matches!( OidcAuth::discover( provider.config(), Profile::DevTest, Arc::new(dev::InMemoryStateStore::new(dev::DevTestOnly)), Arc::new(Secrets), vec![provider.root.clone()] ) .await, Err(Error::Discovery) )); } } #[tokio::test] async fn state_expiry_and_concurrent_single_use() { let store = Arc::new(dev::InMemoryStateStore::new(dev::DevTestOnly)); store .insert( "expired".into(), PendingLogin { binding_hash: "binding".into(), nonce: random(), pkce_verifier: random(), expires_at: now() - 1, }, ) .await .unwrap(); assert!(matches!( store.consume("expired", "binding", now()).await, Err(Error::State) )); store .insert( "once".into(), PendingLogin { binding_hash: "binding".into(), nonce: random(), pkce_verifier: random(), expires_at: now() + 30, }, ) .await .unwrap(); let (a, b) = tokio::join!( store.consume("once", "binding", now()), store.consume("once", "binding", now()) ); assert_eq!(usize::from(a.is_ok()) + usize::from(b.is_ok()), 1); } #[tokio::test] async fn discovery_jwks_and_exchange_never_follow_redirects() { let provider = Provider::start().await; let auth = provider.auth().await; let token = provider.access_token(None).await; for path in ["/jwks", "/token", "/.well-known/openid-configuration"] { *provider.state.response_override.lock().await = Some(ResponseOverride { path: path.into(), status: "302 Found", location: Some(format!("{}untrusted-trap", provider.state.issuer)), body: "{}".into(), }); match path { "/jwks" => assert!(matches!( auth.verify_mcp_bearer(&token, &[]).await, Err(Error::Transport) )), "/token" => { let start = auth.login_start().await.unwrap(); let (code, state, binding) = provider.authorize(&start).await; assert_eq!( auth.callback(Callback { code: &code, state: &state, browser_binding: &binding }) .await, Err(Error::CodeExchange) ); } _ => assert!(matches!( OidcAuth::discover( provider.config(), Profile::DevTest, Arc::new(dev::InMemoryStateStore::new(dev::DevTestOnly)), Arc::new(Secrets), vec![provider.root.clone()] ) .await, Err(Error::Transport) )), } } assert_eq!(provider.state.unexpected_calls.load(Ordering::SeqCst), 0); } #[tokio::test] async fn oversized_responses_and_tokens_fail_closed() { let provider = Provider::start().await; let auth = provider.auth().await; let token = provider.access_token(None).await; *provider.state.response_override.lock().await = Some(ResponseOverride { path: "/jwks".into(), status: "200 OK", location: None, body: "x".repeat(131073), }); assert!(matches!( auth.verify_mcp_bearer(&token, &[]).await, Err(Error::Transport) )); assert!(matches!( auth.verify_mcp_bearer(&"x".repeat(32769), &[]).await, Err(Error::InvalidToken) )); } #[tokio::test] async fn required_claims_and_future_iat_are_rejected() { let provider = Provider::start().await; let auth = provider.auth().await; for field in ["exp", "iss", "aud", "sub", "iat", "jti"] { let mut claims = provider.state.claims("https://rmm.example/mcp"); claims.as_object_mut().unwrap().remove(field); let token = provider.state.signing.lock().await.token(&claims, true); assert!( auth.verify_mcp_bearer(&token, &[]).await.is_err(), "missing required claim must fail" ); } let token = provider .access_token(Some(("iat", json!(now() + 300)))) .await; assert!(matches!( auth.verify_mcp_bearer(&token, &[]).await, Err(Error::InvalidToken) )); }