feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s
Rust development slice / linux (push) Failing after 1m10s
This commit is contained in:
@@ -0,0 +1,565 @@
|
||||
//! Fixed RS256 OIDC browser and RFC 9068 MCP resource-server profiles.
|
||||
//! Authentication only: persistent tenant memberships and interactive sessions belong to the server.
|
||||
use async_trait::async_trait;
|
||||
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
|
||||
use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode, decode_header};
|
||||
use secrecy::{ExposeSecret, SecretString};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{
|
||||
collections::BTreeSet,
|
||||
sync::Arc,
|
||||
time::{Duration, Instant, SystemTime, UNIX_EPOCH},
|
||||
};
|
||||
use subtle::ConstantTimeEq;
|
||||
use tokio::sync::Mutex;
|
||||
use url::Url;
|
||||
|
||||
#[cfg(feature = "postgres-state")]
|
||||
pub mod postgres;
|
||||
|
||||
#[derive(Debug, thiserror::Error, PartialEq, Eq)]
|
||||
pub enum Error {
|
||||
#[error("not_configured or invalid OIDC configuration")]
|
||||
Configuration,
|
||||
#[error("OIDC transport, TLS or bounded response failed")]
|
||||
Transport,
|
||||
#[error("untrusted or unsupported discovery metadata")]
|
||||
Discovery,
|
||||
#[error("invalid JWT")]
|
||||
InvalidToken,
|
||||
#[error("invalid issuer")]
|
||||
InvalidIssuer,
|
||||
#[error("invalid audience or authorized party")]
|
||||
InvalidAudience,
|
||||
#[error("expired token")]
|
||||
Expired,
|
||||
#[error("token not yet valid")]
|
||||
NotYetValid,
|
||||
#[error("unknown signing key")]
|
||||
UnknownKid,
|
||||
#[error("invalid nonce")]
|
||||
Nonce,
|
||||
#[error("invalid, expired, unbound or replayed login state")]
|
||||
State,
|
||||
#[error("authorization code exchange rejected (including PKCE failure)")]
|
||||
CodeExchange,
|
||||
#[error("missing required resource scope")]
|
||||
MissingScope,
|
||||
#[error("state store unavailable or capacity exceeded")]
|
||||
Store,
|
||||
#[error("client secret unavailable")]
|
||||
Secret,
|
||||
}
|
||||
pub type Result<T> = std::result::Result<T, Error>;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Config {
|
||||
pub issuer: Url,
|
||||
pub browser_client_id: String,
|
||||
pub client_secret_ref: String,
|
||||
pub redirect_uri: Url,
|
||||
/// Dedicated resource audience; MUST differ from the browser client ID.
|
||||
pub mcp_audience: String,
|
||||
/// Explicit authorized OAuth client IDs for the RFC 9068 profile.
|
||||
pub mcp_client_ids: BTreeSet<String>,
|
||||
}
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Profile {
|
||||
Production,
|
||||
DevTest,
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
pub trait SecretResolver: Send + Sync {
|
||||
async fn resolve(&self, reference: &str) -> Result<SecretString>;
|
||||
}
|
||||
|
||||
/// Store encrypted at rest. No Debug: verifier and nonce are sensitive.
|
||||
#[derive(Serialize, Deserialize, zeroize::Zeroize, zeroize::ZeroizeOnDrop)]
|
||||
pub struct PendingLogin {
|
||||
pub binding_hash: String,
|
||||
pub nonce: String,
|
||||
pub pkce_verifier: String,
|
||||
pub expires_at: u64,
|
||||
}
|
||||
#[async_trait]
|
||||
pub trait StateStore: Send + Sync {
|
||||
/// Production adapters must implement durable, shared, atomic storage.
|
||||
fn is_persistent(&self) -> bool;
|
||||
async fn insert(&self, state_hash: String, login: PendingLogin) -> Result<()>;
|
||||
/// Atomically DELETE ... RETURNING only when binding matches and expiry > now.
|
||||
/// Concurrent callbacks must return at most one record. Never restore on failure.
|
||||
async fn consume(&self, state_hash: &str, binding_hash: &str, now: u64)
|
||||
-> Result<PendingLogin>;
|
||||
}
|
||||
|
||||
/// Sensitive URL and cookie: intentionally not Debug/Serialize.
|
||||
pub struct LoginStart {
|
||||
pub authorization_url: Url,
|
||||
/// Set verbatim; Secure, HttpOnly, host-only Lax cookie permits the cross-site GET callback.
|
||||
pub binding_set_cookie: String,
|
||||
}
|
||||
pub struct Callback<'a> {
|
||||
pub code: &'a str,
|
||||
pub state: &'a str,
|
||||
/// Value of __Host-rmm_oidc_binding, NOT the entire Cookie header.
|
||||
pub browser_binding: &'a str,
|
||||
}
|
||||
pub const CLEAR_BINDING_COOKIE: &str =
|
||||
"__Host-rmm_oidc_binding=; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=0";
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Identity {
|
||||
pub issuer: String,
|
||||
pub subject: String,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct BearerIdentity {
|
||||
pub identity: Identity,
|
||||
pub scopes: BTreeSet<String>,
|
||||
pub client_id: String,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Discovery {
|
||||
issuer: String,
|
||||
authorization_endpoint: Url,
|
||||
token_endpoint: Url,
|
||||
jwks_uri: Url,
|
||||
response_types_supported: Vec<String>,
|
||||
id_token_signing_alg_values_supported: Vec<String>,
|
||||
code_challenge_methods_supported: Vec<String>,
|
||||
token_endpoint_auth_methods_supported: Vec<String>,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct Jwk {
|
||||
kid: String,
|
||||
kty: String,
|
||||
alg: String,
|
||||
#[serde(rename = "use")]
|
||||
usage: String,
|
||||
n: String,
|
||||
e: String,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct Jwks {
|
||||
keys: Vec<Jwk>,
|
||||
}
|
||||
struct Cache {
|
||||
keys: Vec<Jwk>,
|
||||
fetched: Option<Instant>,
|
||||
}
|
||||
|
||||
pub struct OidcAuth {
|
||||
config: Config,
|
||||
http: reqwest::Client,
|
||||
discovery: Discovery,
|
||||
keys: Mutex<Cache>,
|
||||
store: Arc<dyn StateStore>,
|
||||
secrets: Arc<dyn SecretResolver>,
|
||||
}
|
||||
|
||||
fn https(url: &Url) -> bool {
|
||||
url.scheme() == "https"
|
||||
&& url.host_str().is_some()
|
||||
&& url.username().is_empty()
|
||||
&& url.password().is_none()
|
||||
&& url.fragment().is_none()
|
||||
}
|
||||
fn now() -> u64 {
|
||||
SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap_or_default()
|
||||
.as_secs()
|
||||
}
|
||||
fn random() -> String {
|
||||
URL_SAFE_NO_PAD.encode(rand::random::<[u8; 32]>())
|
||||
}
|
||||
fn hash(value: &str) -> String {
|
||||
URL_SAFE_NO_PAD.encode(Sha256::digest(value.as_bytes()))
|
||||
}
|
||||
fn equal(a: &str, b: &str) -> bool {
|
||||
bool::from(a.as_bytes().ct_eq(b.as_bytes()))
|
||||
}
|
||||
async fn bounded<T: serde::de::DeserializeOwned>(mut response: reqwest::Response) -> Result<T> {
|
||||
if !response.status().is_success() || response.content_length().is_some_and(|n| n > 131072) {
|
||||
return Err(Error::Transport);
|
||||
}
|
||||
let mut body = Vec::new();
|
||||
while let Some(chunk) = response.chunk().await.map_err(|_| Error::Transport)? {
|
||||
if body.len() + chunk.len() > 131072 {
|
||||
return Err(Error::Transport);
|
||||
}
|
||||
body.extend_from_slice(&chunk);
|
||||
}
|
||||
serde_json::from_slice(&body).map_err(|_| Error::Transport)
|
||||
}
|
||||
|
||||
impl OidcAuth {
|
||||
/// Normal TLS roots; additional roots may be explicitly provisioned for a private IdP.
|
||||
/// No arbitrary HTTP client injection, redirects, environment proxies or insecure TLS switches.
|
||||
pub async fn discover(
|
||||
config: Config,
|
||||
profile: Profile,
|
||||
store: Arc<dyn StateStore>,
|
||||
secrets: Arc<dyn SecretResolver>,
|
||||
extra_roots: Vec<reqwest::Certificate>,
|
||||
) -> Result<Self> {
|
||||
if !https(&config.issuer)
|
||||
|| config.issuer.query().is_some()
|
||||
|| !https(&config.redirect_uri)
|
||||
|| config.redirect_uri.query().is_some()
|
||||
|| config.browser_client_id.is_empty()
|
||||
|| config.client_secret_ref.is_empty()
|
||||
|| config.mcp_audience.is_empty()
|
||||
|| config.mcp_audience == config.browser_client_id
|
||||
|| config.mcp_client_ids.is_empty()
|
||||
|| (profile == Profile::Production && !store.is_persistent())
|
||||
{
|
||||
return Err(Error::Configuration);
|
||||
}
|
||||
let mut builder = reqwest::Client::builder()
|
||||
.https_only(true)
|
||||
.no_proxy()
|
||||
.redirect(reqwest::redirect::Policy::none())
|
||||
.connect_timeout(Duration::from_secs(3))
|
||||
.timeout(Duration::from_secs(10));
|
||||
for root in extra_roots {
|
||||
builder = builder.add_root_certificate(root);
|
||||
}
|
||||
let http = builder.build().map_err(|_| Error::Transport)?;
|
||||
let discovery_url = format!(
|
||||
"{}/.well-known/openid-configuration",
|
||||
config.issuer.as_str().trim_end_matches('/')
|
||||
);
|
||||
let discovery: Discovery = bounded(
|
||||
http.get(discovery_url)
|
||||
.send()
|
||||
.await
|
||||
.map_err(|_| Error::Transport)?,
|
||||
)
|
||||
.await?;
|
||||
if discovery.issuer != config.issuer.as_str()
|
||||
|| [
|
||||
&discovery.authorization_endpoint,
|
||||
&discovery.token_endpoint,
|
||||
&discovery.jwks_uri,
|
||||
]
|
||||
.iter()
|
||||
.any(|u| !https(u) || u.origin() != config.issuer.origin() || u.query().is_some())
|
||||
|| !discovery
|
||||
.response_types_supported
|
||||
.iter()
|
||||
.any(|s| s == "code")
|
||||
|| !discovery
|
||||
.id_token_signing_alg_values_supported
|
||||
.iter()
|
||||
.any(|s| s == "RS256")
|
||||
|| !discovery
|
||||
.code_challenge_methods_supported
|
||||
.iter()
|
||||
.any(|s| s == "S256")
|
||||
|| !discovery
|
||||
.token_endpoint_auth_methods_supported
|
||||
.iter()
|
||||
.any(|s| s == "client_secret_post")
|
||||
{
|
||||
return Err(Error::Discovery);
|
||||
}
|
||||
Ok(Self {
|
||||
config,
|
||||
http,
|
||||
discovery,
|
||||
keys: Mutex::new(Cache {
|
||||
keys: vec![],
|
||||
fetched: None,
|
||||
}),
|
||||
store,
|
||||
secrets,
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn login_start(&self) -> Result<LoginStart> {
|
||||
let state = random();
|
||||
let binding = random();
|
||||
let nonce = random();
|
||||
let verifier = random();
|
||||
let mut url = self.discovery.authorization_endpoint.clone();
|
||||
url.query_pairs_mut().extend_pairs([
|
||||
("response_type", "code"),
|
||||
("client_id", &self.config.browser_client_id),
|
||||
("redirect_uri", self.config.redirect_uri.as_str()),
|
||||
("scope", "openid"),
|
||||
("state", &state),
|
||||
("nonce", &nonce),
|
||||
("code_challenge", &hash(&verifier)),
|
||||
("code_challenge_method", "S256"),
|
||||
]);
|
||||
self.store
|
||||
.insert(
|
||||
hash(&state),
|
||||
PendingLogin {
|
||||
binding_hash: hash(&binding),
|
||||
nonce,
|
||||
pkce_verifier: verifier,
|
||||
expires_at: now() + 300,
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
Ok(LoginStart {
|
||||
authorization_url: url,
|
||||
binding_set_cookie: format!(
|
||||
"__Host-rmm_oidc_binding={binding}; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=300"
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn callback(&self, input: Callback<'_>) -> Result<Identity> {
|
||||
if input.state.len() != 43
|
||||
|| input.browser_binding.len() != 43
|
||||
|| input.code.is_empty()
|
||||
|| input.code.len() > 4096
|
||||
{
|
||||
return Err(Error::State);
|
||||
}
|
||||
let login = self
|
||||
.store
|
||||
.consume(&hash(input.state), &hash(input.browser_binding), now())
|
||||
.await?;
|
||||
if login.expires_at <= now() || !equal(&login.binding_hash, &hash(input.browser_binding)) {
|
||||
return Err(Error::State);
|
||||
}
|
||||
let secret = self.secrets.resolve(&self.config.client_secret_ref).await?;
|
||||
#[derive(Deserialize)]
|
||||
struct Tokens {
|
||||
id_token: String,
|
||||
}
|
||||
let response = self
|
||||
.http
|
||||
.post(self.discovery.token_endpoint.clone())
|
||||
.form(&[
|
||||
("grant_type", "authorization_code"),
|
||||
("code", input.code),
|
||||
("redirect_uri", self.config.redirect_uri.as_str()),
|
||||
("client_id", &self.config.browser_client_id),
|
||||
("client_secret", secret.expose_secret()),
|
||||
("code_verifier", &login.pkce_verifier),
|
||||
])
|
||||
.send()
|
||||
.await
|
||||
.map_err(|_| Error::Transport)?;
|
||||
if !response.status().is_success() {
|
||||
return Err(Error::CodeExchange);
|
||||
}
|
||||
let tokens: Tokens = bounded(response).await?;
|
||||
let claims = self
|
||||
.verify(&tokens.id_token, &self.config.browser_client_id, false)
|
||||
.await?;
|
||||
if !claims
|
||||
.nonce
|
||||
.as_deref()
|
||||
.is_some_and(|n| equal(n, &login.nonce))
|
||||
{
|
||||
return Err(Error::Nonce);
|
||||
}
|
||||
Ok(self.identity(claims))
|
||||
}
|
||||
|
||||
pub async fn verify_mcp_bearer(
|
||||
&self,
|
||||
token: &str,
|
||||
required_scopes: &[&str],
|
||||
) -> Result<BearerIdentity> {
|
||||
let claims = self.verify(token, &self.config.mcp_audience, true).await?;
|
||||
let client_id = claims
|
||||
.client_id
|
||||
.clone()
|
||||
.filter(|id| self.config.mcp_client_ids.contains(id))
|
||||
.ok_or(Error::InvalidAudience)?;
|
||||
let scopes: BTreeSet<String> = claims
|
||||
.scope
|
||||
.as_deref()
|
||||
.unwrap_or_default()
|
||||
.split_ascii_whitespace()
|
||||
.map(str::to_owned)
|
||||
.collect();
|
||||
if required_scopes.iter().any(|s| !scopes.contains(*s)) {
|
||||
return Err(Error::MissingScope);
|
||||
}
|
||||
Ok(BearerIdentity {
|
||||
identity: self.identity(claims),
|
||||
scopes,
|
||||
client_id,
|
||||
})
|
||||
}
|
||||
fn identity(&self, claims: Claims) -> Identity {
|
||||
Identity {
|
||||
issuer: self.config.issuer.to_string(),
|
||||
subject: claims.sub,
|
||||
}
|
||||
}
|
||||
|
||||
async fn verify(&self, token: &str, audience: &str, access: bool) -> Result<Claims> {
|
||||
if token.len() > 32768 {
|
||||
return Err(Error::InvalidToken);
|
||||
}
|
||||
let header = decode_header(token).map_err(|_| Error::InvalidToken)?;
|
||||
if header.alg != Algorithm::RS256 || (access && header.typ.as_deref() != Some("at+jwt")) {
|
||||
return Err(Error::InvalidToken);
|
||||
}
|
||||
let kid = header
|
||||
.kid
|
||||
.filter(|s| !s.is_empty() && s.len() <= 256)
|
||||
.ok_or(Error::UnknownKid)?;
|
||||
// Header kid is only a selector within configured-issuer keys, never a URL/authority.
|
||||
let mut cache = self.keys.lock().await;
|
||||
let unknown = !cache.keys.iter().any(|k| k.kid == kid);
|
||||
let stale = cache
|
||||
.fetched
|
||||
.is_none_or(|t| t.elapsed() >= Duration::from_secs(300));
|
||||
if stale
|
||||
|| (unknown
|
||||
&& cache
|
||||
.fetched
|
||||
.is_some_and(|t| t.elapsed() >= Duration::from_secs(1)))
|
||||
{
|
||||
// Throttle even failed refreshes; one lock prevents concurrent refresh storms.
|
||||
cache.fetched = Some(Instant::now());
|
||||
cache.keys.clear();
|
||||
let jwks: Jwks = bounded(
|
||||
self.http
|
||||
.get(self.discovery.jwks_uri.clone())
|
||||
.send()
|
||||
.await
|
||||
.map_err(|_| Error::Transport)?,
|
||||
)
|
||||
.await?;
|
||||
let mut ids = BTreeSet::new();
|
||||
if jwks.keys.is_empty()
|
||||
|| jwks.keys.len() > 64
|
||||
|| jwks.keys.iter().any(|k| {
|
||||
!ids.insert(&k.kid) || k.kty != "RSA" || k.alg != "RS256" || k.usage != "sig"
|
||||
})
|
||||
{
|
||||
return Err(Error::InvalidToken);
|
||||
}
|
||||
cache.keys = jwks.keys;
|
||||
}
|
||||
let jwk = cache
|
||||
.keys
|
||||
.iter()
|
||||
.find(|k| k.kid == kid)
|
||||
.ok_or(Error::UnknownKid)?;
|
||||
let key =
|
||||
DecodingKey::from_rsa_components(&jwk.n, &jwk.e).map_err(|_| Error::InvalidToken)?;
|
||||
drop(cache);
|
||||
let mut validation = Validation::new(Algorithm::RS256);
|
||||
validation.set_issuer(&[self.config.issuer.as_str()]);
|
||||
validation.set_audience(&[audience]);
|
||||
validation.set_required_spec_claims(&["exp", "iss", "aud", "sub", "iat"]);
|
||||
validation.leeway = 0;
|
||||
validation.validate_nbf = true;
|
||||
let claims = decode::<Claims>(token, &key, &validation)
|
||||
.map_err(|e| match e.kind() {
|
||||
jsonwebtoken::errors::ErrorKind::InvalidIssuer => Error::InvalidIssuer,
|
||||
jsonwebtoken::errors::ErrorKind::InvalidAudience => Error::InvalidAudience,
|
||||
jsonwebtoken::errors::ErrorKind::ExpiredSignature => Error::Expired,
|
||||
jsonwebtoken::errors::ErrorKind::ImmatureSignature => Error::NotYetValid,
|
||||
_ => Error::InvalidToken,
|
||||
})?
|
||||
.claims;
|
||||
if claims.sub.is_empty() || claims.sub.len() > 1024 || claims.iat > now() {
|
||||
return Err(Error::InvalidToken);
|
||||
}
|
||||
if access
|
||||
&& !claims
|
||||
.jti
|
||||
.as_deref()
|
||||
.is_some_and(|jti| !jti.is_empty() && jti.len() <= 1024)
|
||||
{
|
||||
return Err(Error::InvalidToken);
|
||||
}
|
||||
if !access
|
||||
&& ((claims.aud.len() > 1 && claims.azp.is_none())
|
||||
|| claims
|
||||
.azp
|
||||
.as_deref()
|
||||
.is_some_and(|a| a != self.config.browser_client_id))
|
||||
{
|
||||
return Err(Error::InvalidAudience);
|
||||
}
|
||||
Ok(claims)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize)]
|
||||
struct Claims {
|
||||
jti: Option<String>,
|
||||
sub: String,
|
||||
#[serde(deserialize_with = "audiences")]
|
||||
aud: Vec<String>,
|
||||
iat: u64,
|
||||
azp: Option<String>,
|
||||
nonce: Option<String>,
|
||||
scope: Option<String>,
|
||||
client_id: Option<String>,
|
||||
}
|
||||
fn audiences<'de, D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Vec<String>, D::Error> {
|
||||
#[derive(Deserialize)]
|
||||
#[serde(untagged)]
|
||||
enum Aud {
|
||||
One(String),
|
||||
Many(Vec<String>),
|
||||
}
|
||||
Ok(match Aud::deserialize(d)? {
|
||||
Aud::One(s) => vec![s],
|
||||
Aud::Many(v) => v,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(any(test, feature = "dev-memory-store"))]
|
||||
pub mod dev {
|
||||
use super::*;
|
||||
use std::collections::HashMap;
|
||||
/// Explicit dev/test-only volatile adapter. Rejected by the production constructor.
|
||||
pub struct InMemoryStateStore {
|
||||
records: Mutex<HashMap<String, PendingLogin>>,
|
||||
}
|
||||
impl InMemoryStateStore {
|
||||
pub fn new(_profile: DevTestOnly) -> Self {
|
||||
Self {
|
||||
records: Mutex::new(HashMap::new()),
|
||||
}
|
||||
}
|
||||
}
|
||||
pub struct DevTestOnly;
|
||||
#[async_trait]
|
||||
impl StateStore for InMemoryStateStore {
|
||||
fn is_persistent(&self) -> bool {
|
||||
false
|
||||
}
|
||||
async fn insert(&self, state: String, login: PendingLogin) -> Result<()> {
|
||||
let mut records = self.records.lock().await;
|
||||
records.retain(|_, v| v.expires_at > now());
|
||||
if records.len() >= 1024 || records.contains_key(&state) {
|
||||
return Err(Error::Store);
|
||||
}
|
||||
records.insert(state, login);
|
||||
Ok(())
|
||||
}
|
||||
async fn consume(&self, state: &str, binding: &str, time: u64) -> Result<PendingLogin> {
|
||||
let mut records = self.records.lock().await;
|
||||
if !records
|
||||
.get(state)
|
||||
.is_some_and(|v| v.expires_at > time && equal(&v.binding_hash, binding))
|
||||
{
|
||||
return Err(Error::State);
|
||||
}
|
||||
records.remove(state).ok_or(Error::State)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,226 @@
|
||||
//! Encrypted, global pre-auth state. No runtime DDL or tenant access.
|
||||
use crate::{Error, PendingLogin, Result, SecretResolver, StateStore, now};
|
||||
use aes_gcm::{
|
||||
Aes256Gcm, KeyInit, Nonce,
|
||||
aead::{Aead, Payload},
|
||||
};
|
||||
use async_trait::async_trait;
|
||||
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
|
||||
use secrecy::ExposeSecret;
|
||||
use sqlx::{PgPool, Row};
|
||||
use zeroize::Zeroizing;
|
||||
|
||||
pub const MIGRATION_SQL: &str = include_str!("../sql/001_oidc_login_states.sql");
|
||||
pub const MAX_LOGIN_TTL_SECONDS: u64 = 300;
|
||||
pub const MAX_CLEANUP_BATCH: u32 = 1000;
|
||||
// App-specific, database-local insertion admission lock; never an authorization bypass.
|
||||
const ADMISSION_LOCK: i64 = 0x524d4d4f49444301;
|
||||
|
||||
/// No Debug: neither pool configuration nor cryptographic material should enter logs.
|
||||
pub struct PostgresStateStore {
|
||||
pool: PgPool,
|
||||
cipher: Aes256Gcm,
|
||||
key_ref: String,
|
||||
capacity: i64,
|
||||
}
|
||||
|
||||
impl PostgresStateStore {
|
||||
/// `key_ref` must be an immutable/versioned secret reference. Its value is exactly
|
||||
/// 32 random bytes encoded as unpadded base64url. Resolve it from outside the DB.
|
||||
/// This constructor does NOT create tables, grant privileges or verify migrations.
|
||||
pub async fn new(
|
||||
pool: PgPool,
|
||||
resolver: &dyn SecretResolver,
|
||||
key_ref: String,
|
||||
capacity: u32,
|
||||
) -> Result<Self> {
|
||||
if key_ref.is_empty() || key_ref.len() > 256 || !(1..=100_000).contains(&capacity) {
|
||||
return Err(Error::Configuration);
|
||||
}
|
||||
let secret = resolver.resolve(&key_ref).await?;
|
||||
let bytes = Zeroizing::new(
|
||||
URL_SAFE_NO_PAD
|
||||
.decode(secret.expose_secret())
|
||||
.map_err(|_| Error::Configuration)?,
|
||||
);
|
||||
let cipher = Aes256Gcm::new_from_slice(&bytes).map_err(|_| Error::Configuration)?;
|
||||
Ok(Self {
|
||||
pool,
|
||||
cipher,
|
||||
key_ref,
|
||||
capacity: i64::from(capacity),
|
||||
})
|
||||
}
|
||||
|
||||
/// Bounded, concurrent-safe TTL cleanup. Invoke periodically from the global auth
|
||||
/// service; expired rows also count toward admission capacity until removed.
|
||||
pub async fn cleanup_expired(&self, batch: u32) -> Result<u64> {
|
||||
if batch == 0 || batch > MAX_CLEANUP_BATCH {
|
||||
return Err(Error::Configuration);
|
||||
}
|
||||
let mut tx = self.pool.begin().await.map_err(|_| Error::Store)?;
|
||||
limits(&mut tx).await?;
|
||||
let result = sqlx::query(
|
||||
"WITH expired AS (SELECT state_hash FROM rmm_oidc_auth.login_states \
|
||||
WHERE expires_at <= floor(extract(epoch FROM clock_timestamp()))::bigint \
|
||||
ORDER BY expires_at, state_hash LIMIT $1) \
|
||||
DELETE FROM rmm_oidc_auth.login_states AS states USING expired \
|
||||
WHERE states.state_hash = expired.state_hash",
|
||||
)
|
||||
.bind(i64::from(batch))
|
||||
.execute(&mut *tx)
|
||||
.await
|
||||
.map_err(|_| Error::Store)?;
|
||||
tx.commit().await.map_err(|_| Error::Store)?;
|
||||
Ok(result.rows_affected())
|
||||
}
|
||||
|
||||
fn aad(&self, state: &[u8], binding: &[u8], expiry: i64) -> Vec<u8> {
|
||||
let mut aad = b"rmm-oidc-preauth-v1\0".to_vec();
|
||||
aad.extend_from_slice(state);
|
||||
aad.extend_from_slice(binding);
|
||||
aad.extend_from_slice(&expiry.to_be_bytes());
|
||||
aad.extend_from_slice(self.key_ref.as_bytes());
|
||||
aad
|
||||
}
|
||||
}
|
||||
|
||||
async fn limits(tx: &mut sqlx::Transaction<'_, sqlx::Postgres>) -> Result<()> {
|
||||
// Admission must see a fresh snapshot after waiting for the advisory lock,
|
||||
// even if the caller's pool changes the connection's default isolation level.
|
||||
sqlx::query("SET TRANSACTION ISOLATION LEVEL READ COMMITTED")
|
||||
.execute(&mut **tx)
|
||||
.await
|
||||
.map_err(|_| Error::Store)?;
|
||||
sqlx::query("SET LOCAL statement_timeout = '5s'")
|
||||
.execute(&mut **tx)
|
||||
.await
|
||||
.map_err(|_| Error::Store)?;
|
||||
sqlx::query("SET LOCAL lock_timeout = '2s'")
|
||||
.execute(&mut **tx)
|
||||
.await
|
||||
.map_err(|_| Error::Store)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn digest(value: &str) -> Result<Vec<u8>> {
|
||||
let bytes = URL_SAFE_NO_PAD.decode(value).map_err(|_| Error::State)?;
|
||||
if bytes.len() != 32 || URL_SAFE_NO_PAD.encode(&bytes) != value {
|
||||
return Err(Error::State);
|
||||
}
|
||||
Ok(bytes)
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl StateStore for PostgresStateStore {
|
||||
fn is_persistent(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
async fn insert(&self, state_hash: String, login: PendingLogin) -> Result<()> {
|
||||
let state = digest(&state_hash)?;
|
||||
let binding = digest(&login.binding_hash)?;
|
||||
let time = now();
|
||||
if login.expires_at <= time
|
||||
|| login.expires_at > time.saturating_add(MAX_LOGIN_TTL_SECONDS)
|
||||
|| digest(&login.nonce).is_err()
|
||||
|| digest(&login.pkce_verifier).is_err()
|
||||
{
|
||||
return Err(Error::State);
|
||||
}
|
||||
let expiry = i64::try_from(login.expires_at).map_err(|_| Error::State)?;
|
||||
let plaintext = Zeroizing::new(serde_json::to_vec(&login).map_err(|_| Error::Store)?);
|
||||
let nonce = rand::random::<[u8; 12]>();
|
||||
let aad = self.aad(&state, &binding, expiry);
|
||||
let ciphertext = self
|
||||
.cipher
|
||||
.encrypt(
|
||||
&Nonce::from(nonce),
|
||||
Payload {
|
||||
msg: &plaintext,
|
||||
aad: &aad,
|
||||
},
|
||||
)
|
||||
.map_err(|_| Error::Store)?;
|
||||
let mut tx = self.pool.begin().await.map_err(|_| Error::Store)?;
|
||||
limits(&mut tx).await?;
|
||||
// All adapter instances share this lock; concurrent capacity checks cannot race.
|
||||
sqlx::query("SELECT pg_advisory_xact_lock($1)")
|
||||
.bind(ADMISSION_LOCK)
|
||||
.execute(&mut *tx)
|
||||
.await
|
||||
.map_err(|_| Error::Store)?;
|
||||
let result = sqlx::query(
|
||||
"INSERT INTO rmm_oidc_auth.login_states \
|
||||
(state_hash, binding_hash, expires_at, encryption_key_ref, encryption_nonce, ciphertext) \
|
||||
SELECT $1, $2, $3, $4, $5, $6 \
|
||||
WHERE (SELECT count(*) FROM rmm_oidc_auth.login_states) < $7 \
|
||||
AND $3 > floor(extract(epoch FROM clock_timestamp()))::bigint"
|
||||
).bind(&state).bind(&binding).bind(expiry).bind(&self.key_ref).bind(nonce.as_slice()).bind(ciphertext).bind(self.capacity)
|
||||
.execute(&mut *tx).await.map_err(|_| Error::Store)?;
|
||||
if result.rows_affected() != 1 {
|
||||
return Err(Error::Store);
|
||||
}
|
||||
tx.commit().await.map_err(|_| Error::Store)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn consume(
|
||||
&self,
|
||||
state_hash: &str,
|
||||
binding_hash: &str,
|
||||
time: u64,
|
||||
) -> Result<PendingLogin> {
|
||||
let state = digest(state_hash)?;
|
||||
let binding = digest(binding_hash)?;
|
||||
let time = i64::try_from(time).map_err(|_| Error::State)?;
|
||||
let mut tx = self.pool.begin().await.map_err(|_| Error::Store)?;
|
||||
limits(&mut tx).await?;
|
||||
// The binding predicate is inside DELETE: a wrong-cookie attack cannot burn state.
|
||||
// Server time is authoritative even when a caller supplies an earlier time.
|
||||
let row = sqlx::query(
|
||||
"DELETE FROM rmm_oidc_auth.login_states \
|
||||
WHERE state_hash = $1 AND binding_hash = $2 AND encryption_key_ref = $3 \
|
||||
AND expires_at > GREATEST($4, floor(extract(epoch FROM clock_timestamp()))::bigint) \
|
||||
RETURNING expires_at, encryption_nonce, ciphertext",
|
||||
)
|
||||
.bind(&state)
|
||||
.bind(&binding)
|
||||
.bind(&self.key_ref)
|
||||
.bind(time)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await
|
||||
.map_err(|_| Error::Store)?;
|
||||
// Commit consumption BEFORE decrypt/parse: never restore after invalid data or callback failure.
|
||||
tx.commit().await.map_err(|_| Error::Store)?;
|
||||
let row = row.ok_or(Error::State)?;
|
||||
let expiry: i64 = row.try_get("expires_at").map_err(|_| Error::Store)?;
|
||||
let nonce: Vec<u8> = row.try_get("encryption_nonce").map_err(|_| Error::Store)?;
|
||||
let ciphertext: Vec<u8> = row.try_get("ciphertext").map_err(|_| Error::Store)?;
|
||||
if nonce.len() != 12 || ciphertext.len() > 4096 {
|
||||
return Err(Error::Store);
|
||||
}
|
||||
let nonce: [u8; 12] = nonce.try_into().map_err(|_| Error::Store)?;
|
||||
let aad = self.aad(&state, &binding, expiry);
|
||||
let plaintext = Zeroizing::new(
|
||||
self.cipher
|
||||
.decrypt(
|
||||
&Nonce::from(nonce),
|
||||
Payload {
|
||||
msg: &ciphertext,
|
||||
aad: &aad,
|
||||
},
|
||||
)
|
||||
.map_err(|_| Error::Store)?,
|
||||
);
|
||||
let login: PendingLogin = serde_json::from_slice(&plaintext).map_err(|_| Error::Store)?;
|
||||
if login.binding_hash != binding_hash
|
||||
|| i64::try_from(login.expires_at).ok() != Some(expiry)
|
||||
|| digest(&login.nonce).is_err()
|
||||
|| digest(&login.pkce_verifier).is_err()
|
||||
{
|
||||
return Err(Error::Store);
|
||||
}
|
||||
Ok(login)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,820 @@
|
||||
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)
|
||||
));
|
||||
}
|
||||
Reference in New Issue
Block a user