//! Token CRUD and the `slinuxm token` CLI. //! //! Tokens have the prefix `slinuxm_` and 32 random bytes. Only the sha256 hex //! digest is stored; the plaintext is printed once on create. use anyhow::{bail, Context, Result}; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use base64::Engine; use clap::Subcommand; use rand::rngs::SysRng; use rand::TryRng; use sha2::{Digest, Sha256}; use sqlx::SqlitePool; use crate::config::Config; pub const TOKEN_PREFIX: &str = "slinuxm_"; const TS_FORMAT: &str = "%Y-%m-%dT%H:%M:%SZ"; #[derive(Debug, Clone, Subcommand)] pub enum TokenCmd { /// Create a token and print it once. Create { /// Unique token name. name: String, }, /// List tokens (never prints secrets). List, /// Revoke a token by name. Revoke { name: String }, } /// A token row without its hash. #[derive(Debug, Clone, sqlx::FromRow)] pub struct TokenInfo { pub name: String, pub created_at: String, pub revoked_at: Option, pub last_used_at: Option, } /// Hex sha256 of a token string. pub fn hash_token(token: &str) -> String { Sha256::digest(token.as_bytes()) .iter() .map(|b| format!("{b:02x}")) .collect() } /// UTC timestamp in a fixed-width format that sorts lexicographically. fn now_string() -> String { jiff::Timestamp::now().strftime(TS_FORMAT).to_string() } /// Create a token and return the plaintext (shown once, never stored). pub async fn create(pool: &SqlitePool, name: &str) -> Result { let name = name.trim(); if name.is_empty() { bail!("token name must not be empty"); } if name.chars().any(char::is_control) { bail!("token name must not contain control characters"); } let mut bytes = [0u8; 32]; SysRng .try_fill_bytes(&mut bytes) .map_err(|e| anyhow::anyhow!("OS RNG failure: {e}"))?; let token = format!("{TOKEN_PREFIX}{}", URL_SAFE_NO_PAD.encode(bytes)); let res = sqlx::query("INSERT INTO tokens (name, token_hash, created_at) VALUES (?, ?, ?)") .bind(name) .bind(hash_token(&token)) .bind(now_string()) .execute(pool) .await; match res { Ok(_) => Ok(token), Err(sqlx::Error::Database(e)) if e.is_unique_violation() => { bail!("a token named {name:?} already exists") } Err(e) => Err(e).context("inserting token"), } } /// List tokens by creation order. Hashes are never selected. pub async fn list(pool: &SqlitePool) -> Result> { sqlx::query_as::<_, TokenInfo>( "SELECT name, created_at, revoked_at, last_used_at FROM tokens ORDER BY id", ) .fetch_all(pool) .await .context("listing tokens") } /// Outcome of [`revoke`]. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Revoked { Now, Already, NotFound, } pub async fn revoke(pool: &SqlitePool, name: &str) -> Result { let r = sqlx::query("UPDATE tokens SET revoked_at = ? WHERE name = ? AND revoked_at IS NULL") .bind(now_string()) .bind(name) .execute(pool) .await .context("revoking token")?; if r.rows_affected() > 0 { return Ok(Revoked::Now); } let exists: Option = sqlx::query_scalar("SELECT id FROM tokens WHERE name = ?") .bind(name) .fetch_optional(pool) .await .context("looking up token")?; Ok(if exists.is_some() { Revoked::Already } else { Revoked::NotFound }) } /// Check a presented token. The DB matches on the hash (the secret itself is /// never compared), and `last_used_at` is touched at most once a minute. pub async fn verify(pool: &SqlitePool, token: &str) -> Result { if !token.starts_with(TOKEN_PREFIX) { return Ok(false); } let id: Option = sqlx::query_scalar("SELECT id FROM tokens WHERE token_hash = ? AND revoked_at IS NULL") .bind(hash_token(token)) .fetch_optional(pool) .await .context("token lookup")?; let Some(id) = id else { return Ok(false) }; let cutoff = (jiff::Timestamp::now() - std::time::Duration::from_secs(60)) .strftime(TS_FORMAT) .to_string(); // Best effort: a failed touch must not reject a valid token. let _ = sqlx::query( "UPDATE tokens SET last_used_at = ? WHERE id = ? AND (last_used_at IS NULL OR last_used_at < ?)", ) .bind(now_string()) .bind(id) .bind(cutoff) .execute(pool) .await; Ok(true) } /// Execute a token subcommand against the DB at `config.auth.db_path`. pub async fn run(cmd: TokenCmd, config: &Config) -> Result<()> { let pool = crate::db::open(config).await?; match cmd { TokenCmd::Create { name } => { let token = create(&pool, &name).await?; println!("{token}"); eprintln!("Token {name:?} created. Store it now: it cannot be shown again."); } TokenCmd::List => { println!( "{:<24} {:<22} {:<22} LAST USED", "NAME", "CREATED", "REVOKED" ); for t in list(&pool).await? { println!( "{:<24} {:<22} {:<22} {}", t.name, t.created_at, t.revoked_at.as_deref().unwrap_or("-"), t.last_used_at.as_deref().unwrap_or("-") ); } } TokenCmd::Revoke { name } => match revoke(&pool, &name).await? { Revoked::Now => println!("Token {name:?} revoked."), Revoked::Already => println!("Token {name:?} was already revoked."), Revoked::NotFound => bail!("no token named {name:?}"), }, } pool.close().await; Ok(()) }