From 71737d31e37a8ce219ed7f12e19c0e3c773fce4c Mon Sep 17 00:00:00 2001 From: John Coffey Date: Wed, 18 Nov 2026 01:16:56 -0700 Subject: [PATCH] OAuth: revoke access and refresh tokens (RFC 7009) /auth/revoke takes an access or refresh token and refuses it from then on, on every node, until it would have expired. Each account keeps a list of revoked tokens in the in-memory store; the list is cached with the account's access token, and a revocation drops that cache entry cluster-wide. A refresh token is also checked against the store when redeemed. A token issued to a client is revoked only by that client, with its secret if it has one; one that doesn't validate is answered 200 as the RFC asks. Both discovery documents list revocation_endpoint. Closes #427 --- crates/common/src/auth/access_token.rs | 47 ++++- crates/common/src/auth/mod.rs | 2 + crates/common/src/auth/oauth/mod.rs | 4 + crates/common/src/auth/oauth/revoke.rs | 272 +++++++++++++++++++++++++ crates/common/src/auth/oauth/token.rs | 38 +++- crates/common/src/lib.rs | 2 + crates/http/src/auth/oauth/auth.rs | 9 + crates/http/src/auth/oauth/mod.rs | 7 + crates/http/src/auth/oauth/openid.rs | 11 + crates/http/src/auth/oauth/token.rs | 98 ++++++++- crates/http/src/request.rs | 7 + docs/spec/contract.md | 10 + tests/src/system/oidc.rs | 180 +++++++++++++++- 13 files changed, 676 insertions(+), 11 deletions(-) create mode 100644 crates/common/src/auth/oauth/revoke.rs diff --git a/crates/common/src/auth/access_token.rs b/crates/common/src/auth/access_token.rs index 8e527546..04ec9168 100644 --- a/crates/common/src/auth/access_token.rs +++ b/crates/common/src/auth/access_token.rs @@ -72,6 +72,25 @@ impl Server { account_id: u32, revision: u64, revision_account: u64, + ) -> trc::Result { + let mut token = self + .build_access_token_inner(account, account_id, revision, revision_account) + .await?; + // inbuxa: K-S4: the account's revoked OAuth tokens are cached with + // it, so revoking one only has to drop this entry on every node + token.revoked_tokens = self + .revoked_oauth_tokens(account_id) + .await + .caused_by(trc::location!())?; + Ok(token.update_size()) + } + + async fn build_access_token_inner( + &self, + account: Account, + account_id: u32, + revision: u64, + revision_account: u64, ) -> trc::Result { // inbuxa: AL-2, AL-5: whether this account is locked, and which // locked accounts are handed to it. The token is their cache: every @@ -310,6 +329,7 @@ impl Server { locked, shared_mailbox, delegations: delegations.clone(), + revoked_tokens: Default::default(), revision, revision_account, credential_version, @@ -364,6 +384,7 @@ impl Server { locked, shared_mailbox, delegations: delegations.clone(), + revoked_tokens: Default::default(), revision, revision_account, credential_version: 0, @@ -402,16 +423,15 @@ impl Server { Collection = "accessToken", ); - let token: Arc = if let Some(account) = + let mut token: AccessTokenInner = if let Some(account) = self.registry().object::(account_id.into()).await? { let revision = rand::random::(); let revision_account = hash_account(&account); self.build_access_token(account, account_id, revision, revision_account) .await? - .into() } else if account_id == RECOVERY_ADMIN_ID { - AccessTokenInner::new_admin().into() + AccessTokenInner::new_admin() } else { return Err(trc::SecurityEvent::Unauthorized .into_err() @@ -420,6 +440,16 @@ impl Server { .caused_by(trc::location!())); }; + if account_id == RECOVERY_ADMIN_ID { + // inbuxa: K-S4: the recovery admin's tokens can be revoked too + token.revoked_tokens = self + .revoked_oauth_tokens(account_id) + .await + .caused_by(trc::location!())?; + token = token.update_size(); + } + let token: Arc = token.into(); + let _ = guard.insert(token.clone()); Ok(token) } @@ -746,6 +776,7 @@ impl AccessToken { locked: old_inner.locked, shared_mailbox: old_inner.shared_mailbox, delegations: old_inner.delegations.clone(), + revoked_tokens: old_inner.revoked_tokens.clone(), }; access_token = AccessToken { @@ -1051,6 +1082,7 @@ impl AccessToken { locked: false, shared_mailbox: false, delegations: Default::default(), + revoked_tokens: Default::default(), }), } } @@ -1086,11 +1118,17 @@ impl AccessTokenInner { self } + /// inbuxa: K-S4: whether this OAuth token of the account was revoked. + pub fn is_oauth_token_revoked(&self, token_id: u128) -> bool { + self.revoked_tokens.binary_search(&token_id).is_ok() + } + pub fn update_size(mut self) -> Self { self.obj_size = (std::mem::size_of::() + (self.member_of.len() * std::mem::size_of::()) + (self.access_to.len() * (std::mem::size_of::() + std::mem::size_of::())) - + (self.scopes.len() * std::mem::size_of::())) + + (self.scopes.len() * std::mem::size_of::()) + + (self.revoked_tokens.len() * std::mem::size_of::())) as u64; self } @@ -1112,6 +1150,7 @@ impl AccessTokenInner { locked: false, shared_mailbox: false, delegations: Default::default(), + revoked_tokens: Default::default(), } } diff --git a/crates/common/src/auth/mod.rs b/crates/common/src/auth/mod.rs index 6f9e5c2f..0ab1f016 100644 --- a/crates/common/src/auth/mod.rs +++ b/crates/common/src/auth/mod.rs @@ -158,6 +158,8 @@ pub struct AccessTokenInner { pub(crate) shared_mailbox: bool, // inbuxa: AL-5: locked accounts handed to this one pub(crate) delegations: Box<[Delegation]>, + // inbuxa: K-S4: this account's revoked OAuth tokens, sorted (RFC 7009) + pub(crate) revoked_tokens: Box<[u128]>, } /// inbuxa: a locked account this one may open, and how (AL-5, AL-6). diff --git a/crates/common/src/auth/oauth/mod.rs b/crates/common/src/auth/oauth/mod.rs index 2beb8192..45bcdd44 100644 --- a/crates/common/src/auth/oauth/mod.rs +++ b/crates/common/src/auth/oauth/mod.rs @@ -2,6 +2,8 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ pub mod client_id; @@ -10,6 +12,8 @@ pub mod crypto; pub mod introspect; pub mod oidc; pub mod registration; +// inbuxa: K-S4 +pub mod revoke; pub mod token; pub const DEVICE_CODE_LEN: usize = 40; diff --git a/crates/common/src/auth/oauth/revoke.rs b/crates/common/src/auth/oauth/revoke.rs new file mode 100644 index 00000000..857b8d6d --- /dev/null +++ b/crates/common/src/auth/oauth/revoke.rs @@ -0,0 +1,272 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! inbuxa: K-S4: revoking OAuth tokens (RFC 7009). +//! +//! Tokens are sealed, not stored, so revoking one means remembering it until +//! it would have expired anyway. Each account keeps one list in the +//! in-memory store, which every node shares. The list is read with the +//! account's access token and cached with it; revoking a token rewrites the +//! list and then drops that cache entry on every node, so the next request +//! anywhere reads the new list. +//! +//! A refresh token is also checked against the store itself when it is +//! redeemed, so a node that was rebuilding its cache entry while the +//! revocation went in can't mint a new access token from it. + +use crate::{ + KV_OAUTH_REVOKED, Server, cache::invalidate::CacheInvalidationBuilder, ipc::CacheInvalidation, +}; +use std::time::Duration; +use store::{dispatch::lookup::KeyValue, write::now}; +use trc::AddContext; +use xxhash_rust::xxh3; + +/// How many unexpired revocations one account may hold. Each needs a token +/// of that account that is still valid, so only its owner (or whoever holds +/// its tokens) can fill it, and they expire with the tokens. +pub const MAX_REVOKED_PER_ACCOUNT: usize = 2048; + +const LOCK_TRIES: usize = 20; +const LOCK_SECONDS: u64 = 10; + +/// What a revoked token is remembered by. +pub fn oauth_token_id(token: &str) -> u128 { + xxh3::xxh3_128(token.as_bytes()) +} + +fn list_key(account_id: u32) -> Vec { + let mut key = Vec::with_capacity(5); + key.push(b'R'); + key.extend_from_slice(&account_id.to_be_bytes()); + key +} + +fn lock_key(account_id: u32) -> Vec { + let mut key = Vec::with_capacity(5); + key.push(b'L'); + key.extend_from_slice(&account_id.to_be_bytes()); + key +} + +/// One revocation: the token's id and when the token expires, in seconds +/// since the Unix epoch. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Revoked { + pub id: u128, + pub expires: u64, +} + +/// Parses a stored list, keeping the entries that haven't expired. Lines +/// that don't parse are skipped: a damaged entry can't revoke anything. +pub fn parse_revoked(text: &str, now: u64) -> Vec { + text.lines() + .filter_map(|line| { + let (id, expires) = line.split_once(':')?; + let id = u128::from_str_radix(id, 16).ok()?; + let expires = expires.parse::().ok()?; + (expires > now).then_some(Revoked { id, expires }) + }) + .collect() +} + +pub fn serialize_revoked(list: &[Revoked]) -> String { + let mut text = String::with_capacity(list.len() * 44); + for entry in list { + text.push_str(&format!("{:032x}:{}\n", entry.id, entry.expires)); + } + text +} + +/// The ids of a list, sorted for a binary search. +pub fn revoked_ids(list: &[Revoked]) -> Box<[u128]> { + let mut ids = list.iter().map(|entry| entry.id).collect::>(); + ids.sort_unstable(); + ids.dedup(); + ids.into_boxed_slice() +} + +#[derive(Debug, PartialEq, Eq)] +pub enum RevokeOutcome { + Revoked, + AlreadyRevoked, + /// The account already holds [`MAX_REVOKED_PER_ACCOUNT`] revocations. + Full, +} + +impl Server { + async fn read_revoked(&self, account_id: u32) -> trc::Result> { + Ok(self + .in_memory_store() + .key_get::(KeyValue::<()>::build_key( + KV_OAUTH_REVOKED, + list_key(account_id), + )) + .await + .caused_by(trc::location!())? + .map(|text| parse_revoked(&text, now())) + .unwrap_or_default()) + } + + /// This account's revoked tokens, for its cached access token. + pub async fn revoked_oauth_tokens(&self, account_id: u32) -> trc::Result> { + self.read_revoked(account_id) + .await + .map(|list| revoked_ids(&list)) + } + + /// Whether the store holds this token as revoked, bypassing the cache. + pub async fn is_oauth_token_revoked_in_store( + &self, + account_id: u32, + token_id: u128, + ) -> trc::Result { + self.read_revoked(account_id) + .await + .map(|list| list.iter().any(|entry| entry.id == token_id)) + } + + /// Remembers a token as revoked until `expires` (Unix seconds), then has + /// every node drop the account's cached access token. + pub async fn revoke_oauth_token( + &self, + account_id: u32, + token_id: u128, + expires: u64, + ) -> trc::Result { + let store = self.in_memory_store(); + let lock = lock_key(account_id); + + // One writer per account at a time, so two revocations can't each + // write a list missing the other's token + let mut locked = false; + for _ in 0..LOCK_TRIES { + if store + .try_lock(KV_OAUTH_REVOKED, &lock, LOCK_SECONDS) + .await + .caused_by(trc::location!())? + { + locked = true; + break; + } + tokio::time::sleep(Duration::from_millis(50)).await; + } + if !locked { + return Err(trc::StoreEvent::UnexpectedError + .into_err() + .details("Timed out waiting to revoke a token") + .account_id(account_id) + .caused_by(trc::location!())); + } + + let result = self + .revoke_oauth_token_locked(account_id, token_id, expires) + .await; + let unlock = store.remove_lock(KV_OAUTH_REVOKED, &lock).await; + let outcome = result?; + unlock.caused_by(trc::location!())?; + + if outcome == RevokeOutcome::Revoked { + let mut changes = CacheInvalidationBuilder::default(); + changes.invalidate(CacheInvalidation::AccessToken(account_id)); + self.invalidate_caches(changes) + .await + .caused_by(trc::location!())?; + } + + Ok(outcome) + } + + async fn revoke_oauth_token_locked( + &self, + account_id: u32, + token_id: u128, + expires: u64, + ) -> trc::Result { + let now = now(); + if expires <= now { + // Expired already: nothing left to refuse + return Ok(RevokeOutcome::AlreadyRevoked); + } + + let mut list = self.read_revoked(account_id).await?; + if list.iter().any(|entry| entry.id == token_id) { + return Ok(RevokeOutcome::AlreadyRevoked); + } + if list.len() >= MAX_REVOKED_PER_ACCOUNT { + return Ok(RevokeOutcome::Full); + } + list.push(Revoked { + id: token_id, + expires, + }); + + // The list lives as long as its longest-lived entry + let ttl = list + .iter() + .map(|entry| entry.expires) + .max() + .unwrap_or(expires) + - now; + self.in_memory_store() + .key_set( + KeyValue::with_prefix( + KV_OAUTH_REVOKED, + list_key(account_id), + serialize_revoked(&list).into_bytes(), + ) + .expires(ttl), + ) + .await + .caused_by(trc::location!())?; + + Ok(RevokeOutcome::Revoked) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn list_round_trips_and_drops_expired() { + let list = vec![ + Revoked { + id: oauth_token_id("sw1.a"), + expires: 2_000, + }, + Revoked { + id: 7, + expires: 900, + }, + ]; + let text = serialize_revoked(&list); + assert_eq!(parse_revoked(&text, 0), list); + assert_eq!(parse_revoked(&text, 1_000), vec![list[0]]); + } + + #[test] + fn damaged_lines_are_skipped() { + let text = "zz:10\n00000000000000000000000000000005:abc\n\ + 00000000000000000000000000000006:50\nnot a line\n"; + assert_eq!(parse_revoked(text, 0), vec![Revoked { id: 6, expires: 50 }]); + } + + #[test] + fn ids_are_sorted_for_search() { + let list = [9u128, 3, 9, 1].map(|id| Revoked { id, expires: 10 }); + let ids = revoked_ids(&list); + assert_eq!(&*ids, &[1, 3, 9]); + assert!(ids.binary_search(&3).is_ok()); + assert!(ids.binary_search(&4).is_err()); + } + + #[test] + fn token_ids_differ() { + assert_ne!(oauth_token_id("sw1.a"), oauth_token_id("sw1.b")); + assert_eq!(oauth_token_id("sw1.a"), oauth_token_id("sw1.a")); + } +} diff --git a/crates/common/src/auth/oauth/token.rs b/crates/common/src/auth/oauth/token.rs index 044c4a7f..173df6b2 100644 --- a/crates/common/src/auth/oauth/token.rs +++ b/crates/common/src/auth/oauth/token.rs @@ -2,6 +2,8 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ use super::{GrantType, crypto::SymmetricEncrypt}; @@ -9,6 +11,7 @@ use crate::Server; use base64::{Engine, engine::general_purpose}; use std::time::SystemTime; use store::rand::{RngExt, rng}; +use trc::AddContext; use utils::codec::leb128::{Leb128Iterator, Leb128Vec}; pub const FAILED_TO_DECODE_TOKEN: &str = concat!( @@ -102,17 +105,42 @@ impl Server { } // Enforce credential revocation for long lived tokens - if token.credential_version != 0 { - let current = self + // inbuxa: K-S4: and revocation of the token itself (RFC 7009). Access + // and refresh tokens are always checked, whatever their credential + // version: an account with no password still has revocable tokens. + let revocable = matches!( + token.grant_type, + GrantType::AccessToken | GrantType::RefreshToken + ); + if token.credential_version != 0 || revocable { + let account = self .access_token(token.account_id) .await - .map_err(|err| trc::AuthEvent::Error.into_err().ctx(trc::Key::Details, err))? - .credential_version(); - if current != token.credential_version { + .map_err(|err| trc::AuthEvent::Error.into_err().ctx(trc::Key::Details, err))?; + if token.credential_version != 0 + && account.credential_version() != token.credential_version + { return Err(trc::AuthEvent::TokenExpired .into_err() .details("Token revoked")); } + if revocable { + let token_id = super::revoke::oauth_token_id(token_); + // A refresh token mints new access tokens, so it is checked + // against the store too, past a cache entry that may have + // been rebuilt while the revocation went in + if account.is_oauth_token_revoked(token_id) + || (token.grant_type == GrantType::RefreshToken + && self + .is_oauth_token_revoked_in_store(token.account_id, token_id) + .await + .caused_by(trc::location!())?) + { + return Err(trc::AuthEvent::TokenExpired + .into_err() + .details("Token revoked")); + } + } } Ok(TokenInfo { diff --git a/crates/common/src/lib.rs b/crates/common/src/lib.rs index de1e8ba6..01fc1ff1 100644 --- a/crates/common/src/lib.rs +++ b/crates/common/src/lib.rs @@ -148,6 +148,8 @@ pub const KV_PORT_REACHABILITY: u8 = 200; // inbuxa: device-flow codes live apart from authorization codes, so neither // grant can redeem the other's code. pub const KV_OAUTH_DEVICE: u8 = 201; +// inbuxa: K-S4: revoked OAuth tokens, one list per account +pub const KV_OAUTH_REVOKED: u8 = 202; #[derive(Clone)] pub struct Server { diff --git a/crates/http/src/auth/oauth/auth.rs b/crates/http/src/auth/oauth/auth.rs index 5f41f0cc..453bea5d 100644 --- a/crates/http/src/auth/oauth/auth.rs +++ b/crates/http/src/auth/oauth/auth.rs @@ -57,6 +57,9 @@ pub struct OAuthMetadata { pub device_authorization_endpoint: String, pub registration_endpoint: String, pub introspection_endpoint: String, + // inbuxa: K-S4: RFC 7009, advertised as RFC 8414 describes + pub revocation_endpoint: String, + pub revocation_endpoint_auth_methods_supported: &'static [&'static str], pub grant_types_supported: &'static [&'static str], pub response_types_supported: &'static [&'static str], pub scopes_supported: &'static [&'static str], @@ -583,6 +586,12 @@ impl OAuthApiHandler for Server { token_endpoint: format!("{base_url}/auth/token"), device_authorization_endpoint: format!("{base_url}/auth/device"), introspection_endpoint: format!("{base_url}/auth/introspect"), + revocation_endpoint: format!("{base_url}/auth/revoke"), + revocation_endpoint_auth_methods_supported: &[ + "none", + "client_secret_post", + "client_secret_basic", + ], registration_endpoint: format!("{base_url}/auth/register"), grant_types_supported: &[ "authorization_code", diff --git a/crates/http/src/auth/oauth/mod.rs b/crates/http/src/auth/oauth/mod.rs index d1b91c1b..c740493c 100644 --- a/crates/http/src/auth/oauth/mod.rs +++ b/crates/http/src/auth/oauth/mod.rs @@ -2,6 +2,8 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ use http_proto::{HttpRequest, request::fetch_body}; @@ -171,6 +173,11 @@ pub enum ErrorType { AccessDenied, #[serde(rename = "expired_token")] ExpiredToken, + // inbuxa: K-S4: RFC 7009 section 2.2.1 + #[serde(rename = "unsupported_token_type")] + UnsupportedTokenType, + #[serde(rename = "temporarily_unavailable")] + TemporarilyUnavailable, } impl TokenResponse { diff --git a/crates/http/src/auth/oauth/openid.rs b/crates/http/src/auth/oauth/openid.rs index 3407f51e..85323fca 100644 --- a/crates/http/src/auth/oauth/openid.rs +++ b/crates/http/src/auth/oauth/openid.rs @@ -2,6 +2,8 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ use common::{Server, auth::oauth::SUPPORTED_SCOPES, auth::oauth::oidc::Userinfo}; @@ -18,6 +20,9 @@ pub struct OpenIdMetadata { pub jwks_uri: String, pub registration_endpoint: String, pub device_authorization_endpoint: String, + // inbuxa: K-S4 + pub revocation_endpoint: String, + pub revocation_endpoint_auth_methods_supported: &'static [&'static str], pub scopes_supported: &'static [&'static str], pub response_types_supported: &'static [&'static str], pub subject_types_supported: &'static [&'static str], @@ -79,6 +84,12 @@ impl OpenIdHandler for Server { jwks_uri: format!("{base_url}/auth/jwks.json"), registration_endpoint: format!("{base_url}/auth/register"), device_authorization_endpoint: format!("{base_url}/auth/device"), + revocation_endpoint: format!("{base_url}/auth/revoke"), + revocation_endpoint_auth_methods_supported: &[ + "none", + "client_secret_post", + "client_secret_basic", + ], response_types_supported: &["code"], grant_types_supported: &[ "authorization_code", diff --git a/crates/http/src/auth/oauth/token.rs b/crates/http/src/auth/oauth/token.rs index 66db7bc2..644d393a 100644 --- a/crates/http/src/auth/oauth/token.rs +++ b/crates/http/src/auth/oauth/token.rs @@ -17,7 +17,11 @@ use base64::{ }; use common::{ KV_OAUTH, KV_OAUTH_DEVICE, Server, - auth::oauth::{GrantType, oidc::StandardClaims}, + auth::oauth::{ + GrantType, + oidc::StandardClaims, + revoke::{RevokeOutcome, oauth_token_id}, + }, }; use http_proto::*; use hyper::StatusCode; @@ -42,6 +46,13 @@ pub trait TokenHandler: Sync + Send { session_id: u64, ) -> impl Future> + Send; + // inbuxa: K-S4 + fn handle_token_revoke( + &self, + req: &mut HttpRequest, + session_id: u64, + ) -> impl Future> + Send; + #[allow(clippy::too_many_arguments)] fn issue_token( &self, @@ -331,6 +342,85 @@ impl TokenHandler for Server { .map(|response| JsonResponse::new(response).no_cache().into_http_response()) } + /// inbuxa: K-S4: RFC 7009. A token that doesn't validate is answered as + /// revoked, as the RFC asks; a valid one is refused from then on, on + /// every node, until it would have expired. A token issued to a client + /// is revoked only by that client, with its secret if it has one. + async fn handle_token_revoke( + &self, + req: &mut HttpRequest, + session_id: u64, + ) -> trc::Result { + let params = FormData::from_request(req, MAX_POST_LEN, session_id).await?; + let (client_id, client_secret) = client_credentials(req, ¶ms); + let Some(token) = params.get("token").filter(|token| !token.is_empty()) else { + return Ok(revoke_error( + StatusCode::BAD_REQUEST, + ErrorType::InvalidRequest, + )); + }; + + let info = match self.validate_access_token(None, token).await { + Ok(info) => info, + Err(err) + if matches!( + err.event_type(), + trc::EventType::Auth(trc::AuthEvent::Error) + | trc::EventType::Auth(trc::AuthEvent::TokenExpired) + ) => + { + return Ok(HttpResponse::new(StatusCode::OK)); + } + Err(err) => return Err(err), + }; + if !matches!( + info.grant_type, + GrantType::AccessToken | GrantType::RefreshToken + ) { + return Ok(revoke_error( + StatusCode::BAD_REQUEST, + ErrorType::UnsupportedTokenType, + )); + } + + // AU-5: the token names the client it was issued to. As with a + // refresh, naming no client stands for the token's own, and a + // confidential one authenticates + if let Some(issued_to) = info.claims.as_deref().filter(|c| !c.is_empty()) { + if client_id.as_deref().is_some_and(|id| id != issued_to) + || self + .verify_client_secret(issued_to, client_secret.as_deref()) + .await? + .is_some() + { + return Ok(revoke_error( + StatusCode::UNAUTHORIZED, + ErrorType::InvalidClient, + )); + } + } + + match self + .revoke_oauth_token(info.account_id, oauth_token_id(token), info.expiry) + .await? + { + RevokeOutcome::Revoked | RevokeOutcome::AlreadyRevoked => { + Ok(HttpResponse::new(StatusCode::OK)) + } + RevokeOutcome::Full => { + trc::event!( + Auth(trc::AuthEvent::Error), + AccountId = info.account_id, + Reason = "Too many revoked tokens held for this account", + ); + Ok(revoke_error( + StatusCode::SERVICE_UNAVAILABLE, + ErrorType::TemporarilyUnavailable, + )) + } + } + } + async fn issue_token( &self, account_id: u32, @@ -404,6 +494,12 @@ impl TokenHandler for Server { } } +fn revoke_error(status: StatusCode, error: ErrorType) -> HttpResponse { + JsonResponse::with_status(status, TokenResponse::error(error)) + .no_cache() + .into_http_response() +} + fn client_credentials<'x>( req: &'x HttpRequest, params: &'x FormData, diff --git a/crates/http/src/request.rs b/crates/http/src/request.rs index 0bbb0d27..b7c7d7b6 100644 --- a/crates/http/src/request.rs +++ b/crates/http/src/request.rs @@ -447,6 +447,13 @@ impl ParseHttp for Server { return self.handle_token_request(&mut req, session).await; } + // inbuxa: K-S4: RFC 7009 + ("revoke", &Method::POST) => { + self.is_http_anonymous_request_allowed(session.remote_ip) + .await?; + + return self.handle_token_revoke(&mut req, session.session_id).await; + } ("introspect", &Method::POST) => { // Authenticate request let (_in_flight, _) = self.authenticate_headers(&req, &session).await?; diff --git a/docs/spec/contract.md b/docs/spec/contract.md index 1716c48a..82b2a82a 100644 --- a/docs/spec/contract.md +++ b/docs/spec/contract.md @@ -28,6 +28,16 @@ Observed in the source at `v0.16.22` and against a running inbuxa-server on which INBUXA Admin uses to find the endpoints. - **There's no revocation endpoint.** Tokens are stateless and sealed, so a token can only be invalidated by changing the account's password. + *27.1 adds one* (K-S4): `/auth/revoke` (RFC 7009), listed as + `revocation_endpoint` in both discovery documents. A revoked access or + refresh token is refused on every node until it would have expired. Each + account keeps a list of revoked tokens in the in-memory store; the list is + cached with the account and the cache entry is dropped cluster-wide on a + revocation. A token issued to a client is revoked only by that client + (with its secret, if it has one). A token that doesn't validate is + answered `200`, as the RFC asks. Revoking a refresh token doesn't revoke + the access tokens it minted, since nothing links them; a client revokes + both. - **Clients aren't required to be registered, by default.** `x:OidcProvider.requireClientRegistration` defaults to `false`. With it off, any `client_id` with any redirect URI is accepted (HTTP ones only with PKCE). diff --git a/tests/src/system/oidc.rs b/tests/src/system/oidc.rs index 688019f7..ed5b102e 100644 --- a/tests/src/system/oidc.rs +++ b/tests/src/system/oidc.rs @@ -57,6 +57,8 @@ pub struct OAuthMetadata { pub device_authorization_endpoint: String, pub registration_endpoint: String, pub introspection_endpoint: String, + pub revocation_endpoint: String, + pub revocation_endpoint_auth_methods_supported: Vec, pub grant_types_supported: Vec, pub response_types_supported: Vec, pub scopes_supported: Vec, @@ -882,7 +884,133 @@ pub async fn test(test: &mut TestServer) { ¶ms, ) .await; - unwrap_token_response(granted); + let (revoke_access, revoke_refresh, _) = unwrap_token_response(granted); + let revoke_refresh = revoke_refresh.expect("offline_access grants a refresh token"); + + // ------------------------ + // inbuxa: K-S4: token revocation (RFC 7009) + // ------------------------ + assert_eq!( + metadata.revocation_endpoint, + "https://127.0.0.1:8899/auth/revoke" + ); + assert!( + metadata + .revocation_endpoint_auth_methods_supported + .contains(&"client_secret_basic".to_string()) + ); + let revoke_form = |token: &str, client_id: Option<&str>, secret: Option<&str>| { + let mut form = AHashMap::from_iter([("token".to_string(), token.to_string())]); + if let Some(client_id) = client_id { + form.insert("client_id".to_string(), client_id.to_string()); + } + if let Some(secret) = secret { + form.insert("client_secret".to_string(), secret.to_string()); + } + form + }; + + // A confidential client's token is revoked only with its secret, and + // never by another client + for (client_id, secret, why) in [ + (None, None, "no secret"), + (Some(confidential_id.as_str()), None, "no secret"), + ( + Some(confidential_id.as_str()), + Some("not-the-secret"), + "a wrong secret", + ), + (Some(client_id.as_str()), None, "another client"), + ] { + assert_eq!( + post_status( + &metadata.revocation_endpoint, + &revoke_form(&revoke_access, client_id, secret) + ) + .await + .0, + 401, + "revoked with {why}" + ); + } + // (Access tokens here live 5 seconds, so each check uses the server + // itself rather than another token that may have expired) + assert_authorized("https://127.0.0.1:8899", &revoke_access).await; + + // Revoked with the secret in the body: refused from then on + assert_eq!( + post_status( + &metadata.revocation_endpoint, + &revoke_form( + &revoke_access, + Some(&confidential_id), + Some(&confidential_secret) + ) + ) + .await, + (200, Bytes::new()) + ); + assert_unauthorized("https://127.0.0.1:8899", &revoke_access).await; + // Again, and a token that was never valid: both answered as revoked + for revoked in [revoke_access.as_str(), "sw1.not-a-token"] { + assert_eq!( + post_status( + &metadata.revocation_endpoint, + &revoke_form(revoked, Some(&confidential_id), Some(&confidential_secret)) + ) + .await + .0, + 200 + ); + } + // No token at all is a bad request + assert_eq!( + post_status(&metadata.revocation_endpoint, &AHashMap::new()) + .await + .0, + 400 + ); + + // Revoking the access token left its refresh token working + let refresh_form = AHashMap::from_iter([ + ("grant_type".to_string(), "refresh_token".to_string()), + ("refresh_token".to_string(), revoke_refresh.clone()), + ]); + let (refreshed, _, _) = unwrap_token_response( + post_form_basic( + &metadata.token_endpoint, + &confidential_id, + &confidential_secret, + &refresh_form, + ) + .await, + ); + assert_authorized("https://127.0.0.1:8899", &refreshed).await; + + // A refresh token revoked with client_secret_basic mints nothing more + assert_eq!( + post_form_basic_status( + &metadata.revocation_endpoint, + &confidential_id, + &confidential_secret, + &revoke_form(&revoke_refresh, None, None), + ) + .await, + 200 + ); + assert_eq!( + post_form_basic::( + &metadata.token_endpoint, + &confidential_id, + &confidential_secret, + &refresh_form, + ) + .await, + TokenResponse::Error { + error: ErrorType::InvalidGrant + }, + "a revoked refresh token was redeemed" + ); // A confidential client created through the management API must have its // secret hashed before storage; authenticating with the plaintext secret @@ -1252,6 +1380,43 @@ async fn post_json_raw(url: &str, body: &impl Serialize) -> (u16, serde_json::Va (status, value) } +/// inbuxa: K-S4: the status and body of a form POST. +async fn post_status(url: &str, params: &AHashMap) -> (u16, Bytes) { + let response = reqwest::Client::builder() + .timeout(Duration::from_millis(500)) + .danger_accept_invalid_certs(true) + .build() + .unwrap_or_default() + .post(url) + .form(params) + .send() + .await + .unwrap(); + let status = response.status().as_u16(); + (status, response.bytes().await.unwrap()) +} + +async fn post_form_basic_status( + url: &str, + username: &str, + password: &str, + params: &AHashMap, +) -> u16 { + reqwest::Client::builder() + .timeout(Duration::from_millis(500)) + .danger_accept_invalid_certs(true) + .build() + .unwrap_or_default() + .post(url) + .basic_auth(username, Some(password)) + .form(params) + .send() + .await + .unwrap() + .status() + .as_u16() +} + async fn post_login_raw(body: &impl Serialize) -> (u16, serde_json::Value) { post_json_raw("https://127.0.0.1:8899/api/auth", body).await } @@ -1286,6 +1451,19 @@ async fn get(url: &str) -> T { serde_json::from_slice(&get_bytes(url).await).unwrap() } +/// inbuxa: K-S4: the token signs in to JMAP. +async fn assert_authorized(base_url: &str, token: &str) { + if let Err(err) = Client::new() + .credentials(Credentials::bearer(token)) + .accept_invalid_certs(true) + .follow_redirects(["127.0.0.1"]) + .connect(base_url) + .await + { + panic!("expected the token to sign in, got {err:?}"); + } +} + async fn assert_unauthorized(base_url: &str, token: &str) { match Client::new() .credentials(Credentials::bearer(token)) -- 2.54.0