rustbasic-passport 0.1.1

OAuth2 server and personal access tokens for Rust applications, a port of laravel/passport for the RustBasic ecosystem.
Documentation
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(())
}