use std::collections::HashMap;
use std::sync::Mutex;
use async_trait::async_trait;
use base64::Engine as _;
use sha2::{Digest as _, Sha256};
use rustbasic_passport::entity::{AccessToken, AuthCode, Client, DeviceCode, RefreshToken};
use rustbasic_passport::error::Error;
use rustbasic_passport::jwt::SigningKey;
use rustbasic_passport::server::{
AuthorizeRequest, Config, DEVICE_CODE_GRANT_TYPE, PassportServer, TokenRequest,
};
use rustbasic_passport::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()))
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
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: "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,
},
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,
},
]));
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 server = PassportServer::new(
stores,
SigningKey::generate("default")?,
Config {
device_code_interval_secs: 1,
..Config::default()
},
);
println!("== password grant ==");
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?;
println!("token_type: {}", resp.token_type);
println!("expires_in: {}", resp.expires_in);
println!("scope: {:?}", resp.scope);
println!(
"access_token (first 40 chars): {}",
&resp.access_token[..40]
);
println!("refresh_token: {}", resp.refresh_token.as_deref().unwrap());
let validated = server.validate_access_token(&resp.access_token).await?;
println!(
"validated sub: {} scopes: {:?}",
validated.claims.sub, validated.claims.scopes
);
println!("\n== refresh rotation ==");
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: resp.refresh_token.clone(),
..Default::default()
})
.await?;
println!(
"old refresh revoked, new refresh issued: {}",
rotated.refresh_token.is_some()
);
println!("\n== authorization code + PKCE (S256) ==");
let verifier = "s3cr3tv3r1f13r-0123456789";
let digest = Sha256::digest(verifier.as_bytes());
let challenge = 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),
code_challenge_method: Some("S256".into()),
..Default::default()
},
)
.await?;
println!(
"redirect: {}?code={}&state={}",
decision.redirect_uri,
decision.code,
decision.state.unwrap_or_default()
);
let exchanged = 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(verifier.into()),
..Default::default()
})
.await?;
println!(
"exchanged code for access token: {}",
exchanged.access_token.len() > 40
);
println!("\n== device authorization grant (RFC 8628) ==");
let device = server
.issue_device_code(&rustbasic_passport::server::DeviceAuthorizationRequest {
client_id: Some("tv".into()),
client_secret: Some("secret-tv".into()),
scope: Some("read".into()),
})
.await?;
println!("device_code: {}", device.device_code);
println!("user_code: {}", device.user_code);
println!("verification_uri: {}", device.verification_uri_complete);
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(device.device_code.clone()),
..Default::default()
})
.await
.unwrap_err();
println!("poll before approval: {}", err.to_oauth_error().error);
server
.approve_device_code("user-1", &device.user_code)
.await?;
println!("waiting for polling interval ({}s)...", 1);
tokio::time::sleep(std::time::Duration::from_secs(2)).await;
let device_token = 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(device.device_code),
..Default::default()
})
.await?;
println!(
"poll after approval: access token issued ({})",
device_token.access_token.len() > 40
);
println!("\n== personal access token ==");
let pat = server
.create_personal_access_token("user-1", "API Token", vec!["read".into()])
.await?;
println!(
"PAT name: {} scopes: {:?}",
pat.token.name.unwrap_or_default(),
pat.token.scopes
);
let validated = server.validate_access_token(&pat.access_token).await?;
println!("PAT validated for user: {}", validated.claims.sub);
println!("\nAll flows completed successfully.");
Ok(())
}