821 lines
29 KiB
Rust
821 lines
29 KiB
Rust
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<Private>,
|
|
}
|
|
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<Signing>,
|
|
codes: Mutex<HashMap<String, Code>>,
|
|
jwks_calls: AtomicUsize,
|
|
exchanges: AtomicUsize,
|
|
mutate: Mutex<Option<(&'static str, Value)>>,
|
|
discovery_override: Mutex<Option<Value>>,
|
|
response_override: Mutex<Option<ResponseOverride>>,
|
|
unexpected_calls: AtomicUsize,
|
|
}
|
|
#[derive(Clone)]
|
|
struct ResponseOverride {
|
|
path: String,
|
|
status: &'static str,
|
|
location: Option<String>,
|
|
body: String,
|
|
}
|
|
struct Provider {
|
|
state: Arc<Mock>,
|
|
root: reqwest::Certificate,
|
|
task: tokio::task::JoinHandle<()>,
|
|
}
|
|
impl Drop for Provider {
|
|
fn drop(&mut self) {
|
|
self.task.abort();
|
|
}
|
|
}
|
|
fn certificates() -> (Vec<u8>, Vec<u8>, Vec<u8>) {
|
|
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::<usize>().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>, 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<String, String> = 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<SecretString> {
|
|
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)
|
|
));
|
|
}
|