use std::sync::Arc;
use base64::Engine as _;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use subtle::ConstantTimeEq as _;
use crate::entity::{
AccessToken, AuthCode, Client, DeviceCode, PersonalAccessTokenResult, RefreshToken, UserId,
};
use crate::error::Error;
use crate::jwt::{AccessTokenClaims, SigningKey, now_secs, sign_access_token, verify_access_token};
use crate::store::Stores;
pub const DEVICE_CODE_GRANT_TYPE: &str = "urn:ietf:params:oauth:grant-type:device_code";
#[derive(Debug, Clone)]
pub struct Config {
pub issuer: String,
pub audience: String,
pub access_token_ttl_secs: i64,
pub refresh_token_ttl_secs: i64,
pub auth_code_ttl_secs: i64,
pub personal_access_token_ttl_secs: i64,
pub device_code_ttl_secs: i64,
pub device_code_interval_secs: i64,
pub verification_uri: String,
pub allow_plain_pkce: bool,
}
impl Default for Config {
fn default() -> Self {
let year = 365 * 24 * 60 * 60;
Self {
issuer: "rustbasic-passport".into(),
audience: "rustbasic-passport".into(),
access_token_ttl_secs: year,
refresh_token_ttl_secs: year,
auth_code_ttl_secs: 10 * 60,
personal_access_token_ttl_secs: year,
device_code_ttl_secs: 10 * 60,
device_code_interval_secs: 5,
verification_uri: "https://localhost/oauth/device".into(),
allow_plain_pkce: true,
}
}
}
#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct TokenRequest {
pub grant_type: Option<String>,
pub client_id: Option<String>,
pub client_secret: Option<String>,
pub username: Option<String>,
pub password: Option<String>,
pub scope: Option<String>,
pub code: Option<String>,
pub redirect_uri: Option<String>,
pub code_verifier: Option<String>,
pub refresh_token: Option<String>,
pub device_code: Option<String>,
pub user_id: Option<String>,
}
#[derive(Debug, Clone, Serialize)]
pub struct TokenResponse {
pub token_type: String,
pub expires_in: i64,
pub access_token: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct AuthorizeRequest {
pub client_id: Option<String>,
pub redirect_uri: Option<String>,
pub response_type: Option<String>,
pub scope: Option<String>,
pub state: Option<String>,
pub code_challenge: Option<String>,
pub code_challenge_method: Option<String>,
pub user_id: Option<String>,
}
#[derive(Debug, Clone)]
pub struct AuthorizeDecision {
pub redirect_uri: String,
pub code: String,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct DeviceAuthorizationRequest {
pub client_id: Option<String>,
pub client_secret: Option<String>,
pub scope: Option<String>,
}
#[derive(Debug, Clone, Serialize)]
pub struct DeviceAuthorizationResponse {
pub device_code: String,
pub user_code: String,
pub verification_uri: String,
pub verification_uri_complete: String,
pub expires_in: i64,
pub interval: i64,
}
#[derive(Debug, Clone)]
pub struct ValidatedToken {
pub claims: AccessTokenClaims,
pub token: AccessToken,
}
struct ServerInner<S: Stores> {
config: Config,
key: SigningKey,
stores: S,
}
pub struct PassportServer<S: Stores> {
inner: Arc<ServerInner<S>>,
}
impl<S: Stores> Clone for PassportServer<S> {
fn clone(&self) -> Self {
Self {
inner: Arc::clone(&self.inner),
}
}
}
impl<S: Stores> PassportServer<S> {
pub fn new(stores: S, key: SigningKey, config: Config) -> Self {
Self {
inner: Arc::new(ServerInner {
config,
key,
stores,
}),
}
}
pub fn config(&self) -> &Config {
&self.inner.config
}
pub fn stores(&self) -> &S {
&self.inner.stores
}
pub fn signing_key(&self) -> &SigningKey {
&self.inner.key
}
pub async fn issue_token(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
let grant = req
.grant_type
.as_deref()
.ok_or_else(|| Error::InvalidRequest("grant_type is required".into()))?;
match grant {
"authorization_code" => self.grant_authorization_code(req).await,
"password" => self.grant_password(req).await,
"client_credentials" => self.grant_client_credentials(req).await,
"refresh_token" => self.grant_refresh_token(req).await,
"personal_access" => self.grant_personal_access(req).await,
DEVICE_CODE_GRANT_TYPE => self.grant_device_code(req).await,
other => Err(Error::UnknownGrant(other.into())),
}
}
pub async fn grant_password(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
let client = self.resolve_client(req, "password").await?;
let username = req
.username
.as_deref()
.ok_or_else(|| Error::InvalidRequest("username is required".into()))?;
let password = req
.password
.as_deref()
.ok_or_else(|| Error::InvalidRequest("password is required".into()))?;
let user_id = self
.inner
.stores
.users()
.find_by_credentials(username, password)
.await?
.ok_or_else(|| Error::InvalidGrant("invalid username or password".into()))?;
let scopes = parse_scopes(req.scope.as_deref());
let (access, jwt) = self
.create_access_token(&client.id, Some(user_id), scopes, None)
.await?;
let refresh = self
.create_refresh_token(&client.id, &access.id, self.inner.config.refresh_token_ttl_secs)
.await?;
Ok(TokenResponse {
token_type: "Bearer".into(),
expires_in: self.inner.config.access_token_ttl_secs,
access_token: jwt,
refresh_token: Some(refresh.id),
scope: join_scopes(&access.scopes),
})
}
pub async fn grant_client_credentials(
&self,
req: &TokenRequest,
) -> Result<TokenResponse, Error> {
let client = self.resolve_client(req, "client_credentials").await?;
let scopes = parse_scopes(req.scope.as_deref());
let (access, jwt) = self
.create_access_token(&client.id, None, scopes, None)
.await?;
Ok(TokenResponse {
token_type: "Bearer".into(),
expires_in: self.inner.config.access_token_ttl_secs,
access_token: jwt,
refresh_token: None,
scope: join_scopes(&access.scopes),
})
}
pub async fn grant_authorization_code(
&self,
req: &TokenRequest,
) -> Result<TokenResponse, Error> {
let client = self.resolve_client(req, "authorization_code").await?;
let code_id = req
.code
.as_deref()
.ok_or_else(|| Error::InvalidRequest("code is required".into()))?;
let code = self
.inner
.stores
.auth_codes()
.find_by_id(code_id)
.await?
.ok_or_else(|| Error::InvalidGrant("authorization code not found".into()))?;
if code.revoked {
return Err(Error::InvalidGrant(
"authorization code has been used".into(),
));
}
if code.expires_at < now_secs() {
return Err(Error::InvalidGrant("authorization code has expired".into()));
}
if code.client_id != client.id {
return Err(Error::InvalidGrant(
"authorization code was issued to another client".into(),
));
}
let redirect_uri = req
.redirect_uri
.as_deref()
.ok_or_else(|| Error::InvalidRequest("redirect_uri is required".into()))?;
if redirect_uri != code.redirect_uri {
return Err(Error::RedirectUriMismatch);
}
self.verify_pkce(req, &code).await?;
let revoked = self
.inner
.stores
.auth_codes()
.revoke_if_unrevoked(code_id)
.await?;
if !revoked {
return Err(Error::InvalidGrant(
"authorization code has been used".into(),
));
}
let scopes = if let Some(requested) = req.scope.as_deref() {
let requested = parse_scopes(Some(requested));
if !is_subset(&requested, &code.scopes) {
return Err(Error::InvalidScope(
"requested scope exceeds the authorized scope".into(),
));
}
requested
} else {
code.scopes.clone()
};
let (access, jwt) = self
.create_access_token(&client.id, code.user_id.clone(), scopes, None)
.await?;
let refresh = self
.create_refresh_token(&client.id, &access.id, self.inner.config.refresh_token_ttl_secs)
.await?;
Ok(TokenResponse {
token_type: "Bearer".into(),
expires_in: self.inner.config.access_token_ttl_secs,
access_token: jwt,
refresh_token: Some(refresh.id),
scope: join_scopes(&access.scopes),
})
}
pub async fn grant_refresh_token(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
let client = self.resolve_client(req, "refresh_token").await?;
let rt_id = req
.refresh_token
.as_deref()
.ok_or_else(|| Error::InvalidRequest("refresh_token is required".into()))?;
let refresh = self
.inner
.stores
.refresh_tokens()
.find_by_id(rt_id)
.await?
.ok_or_else(|| Error::InvalidGrant("refresh token not found".into()))?;
if refresh.revoked {
return Err(Error::InvalidGrant("refresh token has been used".into()));
}
if refresh.expires_at < now_secs() {
return Err(Error::InvalidGrant("refresh token has expired".into()));
}
if refresh.client_id != client.id {
return Err(Error::InvalidGrant(
"refresh token was issued to another client".into(),
));
}
let revoked = self
.inner
.stores
.refresh_tokens()
.revoke_if_unrevoked(rt_id)
.await?;
if !revoked {
return Err(Error::InvalidGrant("refresh token has been used".into()));
}
let old_access = self
.inner
.stores
.tokens()
.find_by_id(&refresh.access_token_id)
.await?
.ok_or_else(|| Error::InvalidGrant("access token not found".into()))?;
let scopes = if let Some(requested) = req.scope.as_deref() {
let requested = parse_scopes(Some(requested));
if !is_subset(&requested, &old_access.scopes) {
return Err(Error::InvalidScope(
"requested scope exceeds the original token scope".into(),
));
}
requested
} else {
old_access.scopes.clone()
};
let (access, jwt) = self
.create_access_token(
&client.id,
old_access.user_id.clone(),
scopes,
old_access.name.clone(),
)
.await?;
let new_refresh = self
.create_refresh_token(&client.id, &access.id, self.inner.config.refresh_token_ttl_secs)
.await?;
Ok(TokenResponse {
token_type: "Bearer".into(),
expires_in: self.inner.config.access_token_ttl_secs,
access_token: jwt,
refresh_token: Some(new_refresh.id),
scope: join_scopes(&access.scopes),
})
}
pub async fn grant_personal_access(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
let client = self.resolve_client(req, "personal_access").await?;
let user_id = req
.user_id
.clone()
.ok_or_else(|| Error::InvalidRequest("user_id is required".into()))?;
let scopes = parse_scopes(req.scope.as_deref());
let (access, jwt) = self
.create_access_token(&client.id, Some(user_id), scopes, None)
.await?;
Ok(TokenResponse {
token_type: "Bearer".into(),
expires_in: self.inner.config.personal_access_token_ttl_secs,
access_token: jwt,
refresh_token: None,
scope: join_scopes(&access.scopes),
})
}
pub async fn issue_device_code(
&self,
req: &DeviceAuthorizationRequest,
) -> Result<DeviceAuthorizationResponse, Error> {
let client = self.resolve_device_client(req).await?;
let scopes = parse_scopes(req.scope.as_deref());
let now = now_secs();
let ttl = self.inner.config.device_code_ttl_secs;
let user_code = generate_user_code();
let code = DeviceCode {
id: uuid::Uuid::new_v4().to_string(),
user_id: None,
client_id: client.id,
user_code: user_code.clone(),
scopes,
revoked: false,
user_approved_at: None,
last_polled_at: None,
expires_at: now + ttl,
};
self.inner.stores.device_codes().save(&code).await?;
let verification_uri_complete = format!(
"{}?user_code={}",
self.inner.config.verification_uri, user_code
);
Ok(DeviceAuthorizationResponse {
device_code: code.id,
user_code,
verification_uri: self.inner.config.verification_uri.clone(),
verification_uri_complete,
expires_in: ttl,
interval: self.inner.config.device_code_interval_secs,
})
}
pub async fn approve_device_code(
&self,
user_id: impl Into<String>,
user_code: &str,
) -> Result<DeviceCode, Error> {
let normalized = normalize_user_code(user_code);
let mut code = self
.inner
.stores
.device_codes()
.find_by_user_code(&normalized)
.await?
.ok_or_else(|| Error::InvalidGrant("user code not found".into()))?;
if code.expires_at < now_secs() {
return Err(Error::DeviceCodeExpired);
}
code.user_id = Some(user_id.into());
code.user_approved_at = Some(now_secs());
self.inner.stores.device_codes().save(&code).await?;
Ok(code)
}
pub async fn grant_device_code(&self, req: &TokenRequest) -> Result<TokenResponse, Error> {
let client = self.resolve_client(req, DEVICE_CODE_GRANT_TYPE).await?;
let code_id = req
.device_code
.as_deref()
.ok_or_else(|| Error::InvalidRequest("device_code is required".into()))?;
let mut code = self
.inner
.stores
.device_codes()
.find_by_device_code(code_id)
.await?
.ok_or_else(|| Error::InvalidGrant("device code not found".into()))?;
if code.client_id != client.id {
return Err(Error::InvalidGrant(
"device code was issued to another client".into(),
));
}
if code.expires_at < now_secs() {
return Err(Error::DeviceCodeExpired);
}
if code.revoked {
return if code.user_approved_at.is_some() {
Err(Error::InvalidGrant("device code has been used".into()))
} else {
Err(Error::AccessDenied)
};
}
let now = now_secs();
if let Some(last) = code.last_polled_at
&& now - last < self.inner.config.device_code_interval_secs
{
return Err(Error::SlowDown);
}
code.last_polled_at = Some(now);
self.inner.stores.device_codes().save(&code).await?;
if code.user_approved_at.is_none() {
return Err(Error::AuthorizationPending);
}
code.revoked = true;
self.inner.stores.device_codes().save(&code).await?;
let (access, jwt) = self
.create_access_token(&client.id, code.user_id.clone(), code.scopes.clone(), None)
.await?;
let refresh = self
.create_refresh_token(&client.id, &access.id, self.inner.config.refresh_token_ttl_secs)
.await?;
Ok(TokenResponse {
token_type: "Bearer".into(),
expires_in: self.inner.config.access_token_ttl_secs,
access_token: jwt,
refresh_token: Some(refresh.id),
scope: join_scopes(&access.scopes),
})
}
async fn resolve_device_client(
&self,
req: &DeviceAuthorizationRequest,
) -> Result<Client, Error> {
let id = req
.client_id
.as_deref()
.ok_or_else(|| Error::InvalidRequest("client_id is required".into()))?;
let client = self
.inner
.stores
.clients()
.find_by_id(id)
.await?
.ok_or(Error::InvalidClient)?;
if client.revoked {
return Err(Error::InvalidClient);
}
if !client.has_grant_type(DEVICE_CODE_GRANT_TYPE) {
return Err(Error::InvalidGrant(
"client is not allowed to use the device authorization grant".into(),
));
}
match (&client.secret, req.client_secret.as_deref()) {
(Some(expected), Some(provided)) if constant_time_eq(expected, provided) => {}
(None, None) => {}
(None, Some("")) => {}
_ => return Err(Error::InvalidClient),
}
Ok(client)
}
pub async fn create_personal_access_token(
&self,
user_id: impl Into<String>,
name: impl Into<String>,
scopes: Vec<String>,
) -> Result<PersonalAccessTokenResult, Error> {
let client = self
.inner
.stores
.clients()
.find_personal_access_client()
.await?
.ok_or(Error::PersonalAccessClientNotFound)?;
if client.revoked {
return Err(Error::InvalidClient);
}
let (token, jwt) = self
.create_access_token(&client.id, Some(user_id.into()), scopes, Some(name.into()))
.await?;
Ok(PersonalAccessTokenResult {
access_token: jwt,
token,
})
}
pub async fn authorize(
&self,
user_id: impl Into<String>,
req: &AuthorizeRequest,
) -> Result<AuthorizeDecision, Error> {
if req.response_type.as_deref() != Some("code") {
return Err(Error::UnsupportedResponseType(
req.response_type
.clone()
.unwrap_or_else(|| "missing".into()),
));
}
let client_id = req
.client_id
.clone()
.ok_or_else(|| Error::InvalidRequest("client_id is required".into()))?;
let client = self
.inner
.stores
.clients()
.find_by_id(&client_id)
.await?
.ok_or(Error::ClientNotFound)?;
if client.revoked {
return Err(Error::InvalidClient);
}
if !client.has_grant_type("authorization_code") {
return Err(Error::InvalidGrant(
"client is not allowed to use the authorization_code grant".into(),
));
}
let redirect_uri = req.redirect_uri.clone().ok_or(Error::RedirectUriMismatch)?;
if !client.redirect_uris.iter().any(|uri| uri == &redirect_uri) {
return Err(Error::RedirectUriMismatch);
}
let scopes = parse_scopes(req.scope.as_deref());
let now = now_secs();
let code = AuthCode {
id: uuid::Uuid::new_v4().to_string(),
user_id: Some(user_id.into()),
client_id,
scopes,
revoked: false,
expires_at: now + self.inner.config.auth_code_ttl_secs,
redirect_uri: redirect_uri.clone(),
code_challenge: req.code_challenge.clone(),
code_challenge_method: req.code_challenge_method.clone(),
};
self.inner.stores.auth_codes().save(&code).await?;
Ok(AuthorizeDecision {
redirect_uri,
code: code.id,
state: req.state.clone(),
})
}
pub async fn validate_access_token(&self, token_str: &str) -> Result<ValidatedToken, Error> {
let claims = verify_access_token(
&self.inner.key,
token_str,
&self.inner.config.issuer,
&self.inner.config.audience,
)?;
let token = self
.inner
.stores
.tokens()
.find_by_id(&claims.jti)
.await?
.ok_or_else(|| Error::Unauthorized("token not found".into()))?;
if token.revoked {
return Err(Error::TokenRevoked);
}
Ok(ValidatedToken { claims, token })
}
pub async fn revoke_token(&self, token_str: &str) -> Result<(), Error> {
let claims = verify_access_token(
&self.inner.key,
token_str,
&self.inner.config.issuer,
&self.inner.config.audience,
)?;
let mut token = self
.inner
.stores
.tokens()
.find_by_id(&claims.jti)
.await?
.ok_or(Error::Unauthorized("token not found".into()))?;
token.revoked = true;
self.inner.stores.tokens().save(&token).await?;
Ok(())
}
async fn resolve_client(&self, req: &TokenRequest, grant_type: &str) -> Result<Client, Error> {
let id = req
.client_id
.as_deref()
.ok_or_else(|| Error::InvalidRequest("client_id is required".into()))?;
let client = self
.inner
.stores
.clients()
.find_by_id(id)
.await?
.ok_or(Error::InvalidClient)?;
if client.revoked {
return Err(Error::InvalidClient);
}
if !client.has_grant_type(grant_type) {
return Err(Error::InvalidGrant(format!(
"client is not allowed to use the {grant_type} grant"
)));
}
match (&client.secret, req.client_secret.as_deref()) {
(Some(expected), Some(provided)) if constant_time_eq(expected, provided) => {}
(None, None) => {}
(None, Some("")) => {}
_ => return Err(Error::InvalidClient),
}
Ok(client)
}
async fn verify_pkce(&self, req: &TokenRequest, code: &AuthCode) -> Result<(), Error> {
let Some(challenge) = code.code_challenge.as_deref() else {
return Ok(());
};
let verifier = req
.code_verifier
.as_deref()
.ok_or(Error::PkceVerificationFailed)?;
let method = code.code_challenge_method.as_deref().unwrap_or("plain");
let ok = match method {
"S256" => {
let digest = Sha256::digest(verifier.as_bytes());
let expected = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(digest);
expected == challenge
}
"plain" => {
if self.inner.config.allow_plain_pkce {
constant_time_eq(verifier, challenge)
} else {
return Err(Error::UnsupportedPkceMethod(method.into()));
}
}
other => return Err(Error::UnsupportedPkceMethod(other.into())),
};
if !ok {
return Err(Error::PkceVerificationFailed);
}
Ok(())
}
async fn create_access_token(
&self,
client_id: &str,
user_id: Option<UserId>,
scopes: Vec<String>,
name: Option<String>,
) -> Result<(AccessToken, String), Error> {
let now = now_secs();
let ttl = self.inner.config.access_token_ttl_secs;
let id = uuid::Uuid::new_v4().to_string();
let token = AccessToken {
id: id.clone(),
user_id: user_id.clone(),
client_id: client_id.into(),
name,
scopes: scopes.clone(),
revoked: false,
expires_at: now + ttl,
created_at: now,
updated_at: now,
};
self.inner.stores.tokens().save(&token).await?;
let claims = AccessTokenClaims {
iss: self.inner.config.issuer.clone(),
sub: user_id.unwrap_or_else(|| client_id.to_string()),
aud: self.inner.config.audience.clone(),
jti: id,
iat: now,
nbf: now,
exp: now + ttl,
scopes,
client_id: client_id.into(),
};
let jwt = sign_access_token(&self.inner.key, claims)?;
Ok((token, jwt))
}
async fn create_refresh_token(
&self,
client_id: &str,
access_token_id: &str,
ttl_secs: i64,
) -> Result<RefreshToken, Error> {
let now = now_secs();
let id = uuid::Uuid::new_v4().to_string();
let token = RefreshToken {
id: id.clone(),
client_id: client_id.into(),
access_token_id: access_token_id.into(),
revoked: false,
expires_at: now + ttl_secs,
};
self.inner.stores.refresh_tokens().save(&token).await?;
Ok(token)
}
}
fn parse_scopes(scope: Option<&str>) -> Vec<String> {
let mut out: Vec<String> = Vec::new();
if let Some(scope) = scope {
for part in scope.split_whitespace() {
if !out.iter().any(|p| p == part) {
out.push(part.to_string());
}
}
}
out
}
fn join_scopes(scopes: &[String]) -> Option<String> {
if scopes.is_empty() {
None
} else {
Some(scopes.join(" "))
}
}
fn is_subset(requested: &[String], allowed: &[String]) -> bool {
requested.iter().all(|r| allowed.contains(r))
}
fn constant_time_eq(a: &str, b: &str) -> bool {
let a = Sha256::digest(a.as_bytes());
let b = Sha256::digest(b.as_bytes());
bool::from(a.as_slice().ct_eq(b.as_slice()))
}
const USER_CODE_ALPHABET: &[u8] = b"BCDFGHJKLMNPQRSTVWXZ23456789";
fn generate_user_code() -> String {
use rand::Rng;
let mut rng = rand::thread_rng();
let mut out = String::with_capacity(8);
for _ in 0..8 {
let idx = rng.gen_range(0..USER_CODE_ALPHABET.len());
out.push(USER_CODE_ALPHABET[idx] as char);
}
out
}
fn normalize_user_code(user_code: &str) -> String {
user_code
.chars()
.filter(|c| !c.is_whitespace() && *c != '-')
.flat_map(char::to_uppercase)
.collect()
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use std::sync::Mutex;
use async_trait::async_trait;
use super::*;
use crate::entity::{AuthCode, Client, DeviceCode, RefreshToken};
use crate::store::{
AccessTokenStore, AuthCodeStore, ClientStore, DeviceCodeStore, RefreshTokenStore,
StoreBundle, UserProvider,
};
struct MemClients(Mutex<Vec<Client>>);
struct MemTokens(Mutex<Vec<AccessToken>>);
struct MemAuthCodes(Mutex<Vec<AuthCode>>);
struct MemRefreshTokens(Mutex<Vec<RefreshToken>>);
struct MemDeviceCodes(Mutex<Vec<DeviceCode>>);
struct MemUsers(Mutex<HashMap<String, String>>);
#[async_trait]
impl ClientStore for MemClients {
async fn find_by_id(&self, id: &str) -> Result<Option<Client>, Error> {
Ok(self.0.lock().unwrap().iter().find(|c| c.id == id).cloned())
}
async fn find_personal_access_client(&self) -> Result<Option<Client>, Error> {
Ok(self
.0
.lock()
.unwrap()
.iter()
.find(|c| !c.revoked && c.has_grant_type("personal_access"))
.cloned())
}
async fn save(&self, client: &Client) -> Result<(), Error> {
let mut list = self.0.lock().unwrap();
if let Some(existing) = list.iter_mut().find(|c| c.id == client.id) {
*existing = client.clone();
} else {
list.push(client.clone());
}
Ok(())
}
}
#[async_trait]
impl AccessTokenStore for MemTokens {
async fn find_by_id(&self, id: &str) -> Result<Option<AccessToken>, Error> {
Ok(self.0.lock().unwrap().iter().find(|t| t.id == id).cloned())
}
async fn save(&self, token: &AccessToken) -> Result<(), Error> {
let mut list = self.0.lock().unwrap();
if let Some(existing) = list.iter_mut().find(|t| t.id == token.id) {
*existing = token.clone();
} else {
list.push(token.clone());
}
Ok(())
}
}
#[async_trait]
impl AuthCodeStore for MemAuthCodes {
async fn find_by_id(&self, id: &str) -> Result<Option<AuthCode>, Error> {
Ok(self.0.lock().unwrap().iter().find(|c| c.id == id).cloned())
}
async fn save(&self, code: &AuthCode) -> Result<(), Error> {
let mut list = self.0.lock().unwrap();
if let Some(existing) = list.iter_mut().find(|c| c.id == code.id) {
*existing = code.clone();
} else {
list.push(code.clone());
}
Ok(())
}
async fn revoke_if_unrevoked(&self, id: &str) -> Result<bool, Error> {
let mut list = self.0.lock().unwrap();
if let Some(existing) = list.iter_mut().find(|c| c.id == id) {
if existing.revoked {
return Ok(false);
}
existing.revoked = true;
return Ok(true);
}
Ok(false)
}
}
#[async_trait]
impl RefreshTokenStore for MemRefreshTokens {
async fn find_by_id(&self, id: &str) -> Result<Option<RefreshToken>, Error> {
Ok(self.0.lock().unwrap().iter().find(|t| t.id == id).cloned())
}
async fn save(&self, token: &RefreshToken) -> Result<(), Error> {
let mut list = self.0.lock().unwrap();
if let Some(existing) = list.iter_mut().find(|t| t.id == token.id) {
*existing = token.clone();
} else {
list.push(token.clone());
}
Ok(())
}
async fn revoke_if_unrevoked(&self, id: &str) -> Result<bool, Error> {
let mut list = self.0.lock().unwrap();
if let Some(existing) = list.iter_mut().find(|t| t.id == id) {
if existing.revoked {
return Ok(false);
}
existing.revoked = true;
return Ok(true);
}
Ok(false)
}
}
#[async_trait]
impl DeviceCodeStore for MemDeviceCodes {
async fn find_by_device_code(&self, id: &str) -> Result<Option<DeviceCode>, Error> {
Ok(self.0.lock().unwrap().iter().find(|c| c.id == id).cloned())
}
async fn find_by_user_code(&self, user_code: &str) -> Result<Option<DeviceCode>, Error> {
Ok(self
.0
.lock()
.unwrap()
.iter()
.find(|c| c.user_code == user_code)
.cloned())
}
async fn save(&self, code: &DeviceCode) -> Result<(), Error> {
let mut list = self.0.lock().unwrap();
if let Some(existing) = list.iter_mut().find(|c| c.id == code.id) {
*existing = code.clone();
} else {
list.push(code.clone());
}
Ok(())
}
}
#[async_trait]
impl UserProvider for MemUsers {
async fn find_by_credentials(
&self,
identifier: &str,
password: &str,
) -> Result<Option<String>, Error> {
Ok(self
.0
.lock()
.unwrap()
.get(identifier)
.filter(|p| p.as_str() == password)
.map(|_| identifier.to_string()))
}
}
fn test_server() -> PassportServer<
StoreBundle<
MemClients,
MemTokens,
MemAuthCodes,
MemRefreshTokens,
MemDeviceCodes,
MemUsers,
>,
> {
test_server_with_config(Config::default())
}
fn test_server_with_config(
config: Config,
) -> PassportServer<
StoreBundle<
MemClients,
MemTokens,
MemAuthCodes,
MemRefreshTokens,
MemDeviceCodes,
MemUsers,
>,
> {
let clients = MemClients(Mutex::new(vec![
Client {
id: "web".into(),
owner_type: None,
owner_id: None,
name: "Web App".into(),
secret: Some("secret-web".into()),
provider: None,
redirect_uris: vec!["https://app.example/callback".into()],
grant_types: vec![
"authorization_code".into(),
"password".into(),
"refresh_token".into(),
],
revoked: false,
},
Client {
id: "machine".into(),
owner_type: None,
owner_id: None,
name: "Machine".into(),
secret: Some("secret-machine".into()),
provider: None,
redirect_uris: vec![],
grant_types: vec!["client_credentials".into()],
revoked: false,
},
Client {
id: "pat".into(),
owner_type: None,
owner_id: None,
name: "Personal Access".into(),
secret: Some("secret-pat".into()),
provider: None,
redirect_uris: vec![],
grant_types: vec!["personal_access".into()],
revoked: false,
},
Client {
id: "tv".into(),
owner_type: None,
owner_id: None,
name: "Smart TV".into(),
secret: Some("secret-tv".into()),
provider: None,
redirect_uris: vec![],
grant_types: vec![DEVICE_CODE_GRANT_TYPE.into(), "refresh_token".into()],
revoked: false,
},
]));
let mut users = HashMap::new();
users.insert("user-1".to_string(), "password-1".to_string());
let stores = StoreBundle::new(
clients,
MemTokens(Mutex::new(vec![])),
MemAuthCodes(Mutex::new(vec![])),
MemRefreshTokens(Mutex::new(vec![])),
MemDeviceCodes(Mutex::new(vec![])),
MemUsers(Mutex::new(users)),
);
let key = SigningKey::generate("test").unwrap();
PassportServer::new(stores, key, config)
}
#[tokio::test]
async fn password_grant_issues_and_validates_token() {
let server = test_server();
let resp = server
.issue_token(&TokenRequest {
grant_type: Some("password".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
username: Some("user-1".into()),
password: Some("password-1".into()),
scope: Some("read write".into()),
..Default::default()
})
.await
.unwrap();
assert_eq!(resp.token_type, "Bearer");
assert!(resp.refresh_token.is_some());
assert_eq!(resp.scope.as_deref(), Some("read write"));
let validated = server
.validate_access_token(&resp.access_token)
.await
.unwrap();
assert_eq!(validated.claims.sub, "user-1");
assert_eq!(validated.claims.client_id, "web");
assert_eq!(validated.claims.scopes, vec!["read", "write"]);
assert_eq!(validated.token.user_id.as_deref(), Some("user-1"));
}
#[tokio::test]
async fn password_grant_rejects_bad_credentials() {
let server = test_server();
let err = server
.issue_token(&TokenRequest {
grant_type: Some("password".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
username: Some("user-1".into()),
password: Some("wrong".into()),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "invalid_grant");
}
#[tokio::test]
async fn password_grant_rejects_wrong_client_secret() {
let server = test_server();
let err = server
.issue_token(&TokenRequest {
grant_type: Some("password".into()),
client_id: Some("web".into()),
client_secret: Some("nope".into()),
username: Some("user-1".into()),
password: Some("password-1".into()),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "invalid_client");
}
#[tokio::test]
async fn client_credentials_grant() {
let server = test_server();
let resp = server
.issue_token(&TokenRequest {
grant_type: Some("client_credentials".into()),
client_id: Some("machine".into()),
client_secret: Some("secret-machine".into()),
scope: Some("read".into()),
..Default::default()
})
.await
.unwrap();
assert!(resp.refresh_token.is_none());
let validated = server
.validate_access_token(&resp.access_token)
.await
.unwrap();
assert_eq!(validated.claims.sub, "machine");
assert!(validated.token.user_id.is_none());
}
#[tokio::test]
async fn authorization_code_grant_with_pkce() {
let server = test_server();
let challenge = {
let verifier = "s3cr3tv3r1f13r-0123456789";
let digest = Sha256::digest(verifier.as_bytes());
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(digest)
};
let decision = server
.authorize(
"user-1",
&AuthorizeRequest {
client_id: Some("web".into()),
redirect_uri: Some("https://app.example/callback".into()),
response_type: Some("code".into()),
scope: Some("read".into()),
state: Some("xyz".into()),
code_challenge: Some(challenge.clone()),
code_challenge_method: Some("S256".into()),
..Default::default()
},
)
.await
.unwrap();
assert_eq!(decision.state.as_deref(), Some("xyz"));
assert!(decision.redirect_uri.starts_with("https://app.example"));
let resp = server
.issue_token(&TokenRequest {
grant_type: Some("authorization_code".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
code: Some(decision.code.clone()),
redirect_uri: Some("https://app.example/callback".into()),
code_verifier: Some("s3cr3tv3r1f13r-0123456789".into()),
..Default::default()
})
.await
.unwrap();
let validated = server
.validate_access_token(&resp.access_token)
.await
.unwrap();
assert_eq!(validated.claims.sub, "user-1");
let err = server
.issue_token(&TokenRequest {
grant_type: Some("authorization_code".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
code: Some(decision.code),
redirect_uri: Some("https://app.example/callback".into()),
code_verifier: Some("s3cr3tv3r1f13r-0123456789".into()),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "invalid_grant");
}
#[tokio::test]
async fn authorization_code_rejects_wrong_verifier() {
let server = test_server();
let decision = server
.authorize(
"user-1",
&AuthorizeRequest {
client_id: Some("web".into()),
redirect_uri: Some("https://app.example/callback".into()),
response_type: Some("code".into()),
code_challenge: Some("wrong-challenge".into()),
code_challenge_method: Some("plain".into()),
..Default::default()
},
)
.await
.unwrap();
let err = server
.issue_token(&TokenRequest {
grant_type: Some("authorization_code".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
code: Some(decision.code),
redirect_uri: Some("https://app.example/callback".into()),
code_verifier: Some("also-wrong".into()),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "invalid_grant");
}
#[tokio::test]
async fn refresh_token_cannot_be_redeemed_by_another_client() {
let server = test_server();
let resp = server
.issue_token(&TokenRequest {
grant_type: Some("password".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
username: Some("user-1".into()),
password: Some("password-1".into()),
..Default::default()
})
.await
.unwrap();
let err = server
.issue_token(&TokenRequest {
grant_type: Some("refresh_token".into()),
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
refresh_token: resp.refresh_token.clone(),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "invalid_grant");
let rt = resp.refresh_token.unwrap();
let stored = server
.inner
.stores
.refresh_tokens()
.find_by_id(&rt)
.await
.unwrap()
.unwrap();
assert!(!stored.revoked, "failed redemption must not revoke");
}
#[tokio::test]
async fn auth_code_redeemed_concurrently_is_single_use() {
let server = test_server();
let decision = server
.authorize(
"user-1",
&AuthorizeRequest {
client_id: Some("web".into()),
redirect_uri: Some("https://app.example/callback".into()),
response_type: Some("code".into()),
..Default::default()
},
)
.await
.unwrap();
let server = Arc::new(server);
let mut handles = Vec::new();
for _ in 0..8 {
let server = Arc::clone(&server);
let code = decision.code.clone();
handles.push(tokio::spawn(async move {
server
.issue_token(&TokenRequest {
grant_type: Some("authorization_code".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
code: Some(code),
redirect_uri: Some("https://app.example/callback".into()),
..Default::default()
})
.await
}));
}
let mut successes = 0;
for handle in handles {
if handle.await.unwrap().is_ok() {
successes += 1;
}
}
assert_eq!(successes, 1, "auth code must be single use even under concurrency");
}
#[tokio::test]
async fn refresh_token_is_rotated() {
let server = test_server();
let first = server
.issue_token(&TokenRequest {
grant_type: Some("password".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
username: Some("user-1".into()),
password: Some("password-1".into()),
..Default::default()
})
.await
.unwrap();
let rotated = server
.issue_token(&TokenRequest {
grant_type: Some("refresh_token".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
refresh_token: first.refresh_token.clone(),
..Default::default()
})
.await
.unwrap();
assert_ne!(rotated.refresh_token, first.refresh_token);
let err = server
.issue_token(&TokenRequest {
grant_type: Some("refresh_token".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
refresh_token: first.refresh_token.clone(),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "invalid_grant");
}
#[tokio::test]
async fn personal_access_token_creation() {
let server = test_server();
let result = server
.create_personal_access_token("user-1", "My Token", vec!["read".into(), "write".into()])
.await
.unwrap();
assert_eq!(result.token.name.as_deref(), Some("My Token"));
let validated = server
.validate_access_token(&result.access_token)
.await
.unwrap();
assert_eq!(validated.claims.sub, "user-1");
assert_eq!(validated.claims.scopes, vec!["read", "write"]);
}
#[tokio::test]
async fn revoked_token_is_rejected() {
let server = test_server();
let resp = server
.issue_token(&TokenRequest {
grant_type: Some("password".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
username: Some("user-1".into()),
password: Some("password-1".into()),
..Default::default()
})
.await
.unwrap();
server.revoke_token(&resp.access_token).await.unwrap();
let err = server
.validate_access_token(&resp.access_token)
.await
.unwrap_err();
assert!(matches!(err, Error::TokenRevoked));
}
#[tokio::test]
async fn unsupported_grant_type() {
let server = test_server();
let err = server
.issue_token(&TokenRequest {
grant_type: Some("implicit".into()),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "unsupported_grant_type");
}
#[tokio::test]
async fn client_must_declare_grant_type() {
let server = test_server();
let err = server
.issue_token(&TokenRequest {
grant_type: Some("client_credentials".into()),
client_id: Some("web".into()),
client_secret: Some("secret-web".into()),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "invalid_grant");
}
#[tokio::test]
async fn device_authorization_flow() {
let server = test_server_with_config(Config {
device_code_interval_secs: 0,
..Config::default()
});
let issued = server
.issue_device_code(&DeviceAuthorizationRequest {
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
scope: Some("read".into()),
})
.await
.unwrap();
assert_eq!(issued.user_code.len(), 8);
assert_eq!(issued.expires_in, server.config().device_code_ttl_secs);
assert_eq!(issued.interval, server.config().device_code_interval_secs);
assert!(issued.verification_uri_complete.contains(&issued.user_code));
let pending = server
.issue_token(&TokenRequest {
grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
device_code: Some(issued.device_code.clone()),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(pending.to_oauth_error().error, "authorization_pending");
server
.approve_device_code("user-1", &issued.user_code)
.await
.unwrap();
let resp = server
.issue_token(&TokenRequest {
grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
device_code: Some(issued.device_code.clone()),
..Default::default()
})
.await
.unwrap();
let validated = server
.validate_access_token(&resp.access_token)
.await
.unwrap();
assert_eq!(validated.claims.sub, "user-1");
assert_eq!(validated.claims.scopes, vec!["read"]);
assert!(resp.refresh_token.is_some());
}
#[tokio::test]
async fn device_code_is_one_time_use() {
let server = test_server();
let issued = server
.issue_device_code(&DeviceAuthorizationRequest {
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
..Default::default()
})
.await
.unwrap();
server
.approve_device_code("user-1", &issued.user_code)
.await
.unwrap();
server
.issue_token(&TokenRequest {
grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
device_code: Some(issued.device_code.clone()),
..Default::default()
})
.await
.unwrap();
let err = server
.issue_token(&TokenRequest {
grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
device_code: Some(issued.device_code),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "invalid_grant");
}
#[tokio::test]
async fn device_polling_respects_interval() {
let server = test_server();
let issued = server
.issue_device_code(&DeviceAuthorizationRequest {
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
..Default::default()
})
.await
.unwrap();
let _pending = server
.issue_token(&TokenRequest {
grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
device_code: Some(issued.device_code.clone()),
..Default::default()
})
.await;
server
.approve_device_code("user-1", &issued.user_code)
.await
.unwrap();
let err = server
.issue_token(&TokenRequest {
grant_type: Some(DEVICE_CODE_GRANT_TYPE.into()),
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
device_code: Some(issued.device_code),
..Default::default()
})
.await
.unwrap_err();
assert_eq!(err.to_oauth_error().error, "slow_down");
}
}