use super::{
ApiKey, ApiKeyInfo, ApiKeyOpts, ApiKeySecret, Auth, MAX_API_KEY_METADATA_BYTES,
MAX_API_KEY_SCOPES, MAX_ID_BYTES, MAX_LABEL_BYTES, MAX_PASSWORD_BYTES, MAX_PHC_BYTES,
MAX_PURPOSE_BYTES, MAX_TOKEN_PAYLOAD_BYTES, OneTimeToken, PhcString, Session, SessionOpts,
SessionToken, TokenConsumption,
};
use crate::error::{ForgeError, Result};
use crate::obs;
use crate::util::{hex, key_hash, sha256_hex};
use argon2::password_hash::SaltString;
use argon2::{Argon2, Params, PasswordHash, PasswordHasher, PasswordVerifier};
use async_trait::async_trait;
use bytes::Bytes;
use rand_core::{OsRng, RngCore};
use sqlx::PgPool;
use sqlx::types::Json;
use std::collections::HashMap;
use std::time::Duration;
use tracing::field::Empty;
use uuid::Uuid;
const ARGON2_M_COST: u32 = 19_456; const ARGON2_T_COST: u32 = 2;
const ARGON2_P_COST: u32 = 1;
fn forge_argon2() -> Result<Argon2<'static>> {
let params = Params::new(ARGON2_M_COST, ARGON2_T_COST, ARGON2_P_COST, None)
.map_err(|e| ForgeError::backend(format!("invalid argon2 params: {e}")))?;
Ok(Argon2::new(
argon2::Algorithm::Argon2id,
argon2::Version::V0x13,
params,
))
}
const TOKEN_BYTES: usize = 32;
const MAX_ABSOLUTE_SECS: f64 = 10.0 * 365.0 * 24.0 * 60.0 * 60.0;
const KEY_PREFIX: &str = "fk_";
pub(crate) struct PgAuth {
pool: PgPool,
app: String,
}
impl PgAuth {
pub(crate) fn new(pool: PgPool, app: String) -> Self {
Self { pool, app }
}
pub(crate) async fn sweep(&self) -> Result<u64> {
let sessions = sqlx::query!(
"DELETE FROM forge_sessions WHERE idle_deadline <= now() AND app = $1",
self.app,
)
.execute(&self.pool)
.await?;
let tokens = sqlx::query!(
"DELETE FROM forge_auth_tokens WHERE expires_at <= now() AND app = $1",
self.app,
)
.execute(&self.pool)
.await?;
let keys = sqlx::query!(
"DELETE FROM forge_api_keys WHERE expires_at <= now() AND app = $1",
self.app,
)
.execute(&self.pool)
.await?;
Ok(sessions.rows_affected() + tokens.rows_affected() + keys.rows_affected())
}
}
fn random_token() -> String {
let mut buf = [0u8; TOKEN_BYTES];
OsRng.fill_bytes(&mut buf);
hex(&buf)
}
fn check_id(id: &str) -> Result<()> {
if id.is_empty() {
return Err(ForgeError::invalid("user/owner id must not be empty"));
}
if id.len() > MAX_ID_BYTES {
return Err(ForgeError::limit(format!(
"id is {} bytes; max is {MAX_ID_BYTES}",
id.len()
)));
}
Ok(())
}
fn check_label(label: &str) -> Result<()> {
if label.len() > MAX_LABEL_BYTES {
return Err(ForgeError::limit(format!(
"label is {} bytes; max is {MAX_LABEL_BYTES}",
label.len()
)));
}
Ok(())
}
fn check_api_key_opts(opts: &ApiKeyOpts) -> Result<()> {
if opts.expires_in.is_some_and(|duration| duration.is_zero()) {
return Err(ForgeError::invalid("API key expiry must be positive"));
}
if opts.scopes.len() > MAX_API_KEY_SCOPES
|| opts
.scopes
.iter()
.any(|scope| scope.is_empty() || scope.len() > 128)
{
return Err(ForgeError::limit("API key scopes exceed their bounds"));
}
let metadata_bytes = serde_json::to_vec(&opts.metadata).map_err(|error| {
ForgeError::backend_with("API key metadata could not be encoded", false, error)
})?;
if metadata_bytes.len() > MAX_API_KEY_METADATA_BYTES {
return Err(ForgeError::limit("API key metadata exceeds 4096 bytes"));
}
Ok(())
}
fn check_password(plain: &str) -> Result<()> {
if plain.is_empty() {
return Err(ForgeError::invalid("password must not be empty"));
}
if plain.len() > MAX_PASSWORD_BYTES {
return Err(ForgeError::limit(format!(
"password is {} bytes; max is {MAX_PASSWORD_BYTES}",
plain.len()
)));
}
Ok(())
}
fn check_purpose(purpose: &str) -> Result<()> {
if purpose.is_empty() {
return Err(ForgeError::invalid("purpose must not be empty"));
}
if purpose.len() > MAX_PURPOSE_BYTES {
return Err(ForgeError::limit(format!(
"purpose is {} bytes; max is {MAX_PURPOSE_BYTES}",
purpose.len()
)));
}
Ok(())
}
fn check_token_ttl(ttl: Duration) -> Result<()> {
if ttl.is_zero() {
return Err(ForgeError::invalid("token ttl must be positive"));
}
if ttl.as_secs_f64() > MAX_ABSOLUTE_SECS {
return Err(ForgeError::limit("token ttl exceeds the maximum"));
}
Ok(())
}
fn check_session_opts(opts: &SessionOpts) -> Result<()> {
if opts.idle_timeout.is_zero() || opts.absolute_timeout.is_zero() {
return Err(ForgeError::invalid("session timeouts must be positive"));
}
if opts.idle_timeout > opts.absolute_timeout {
return Err(ForgeError::invalid(
"idle_timeout must be <= absolute_timeout",
));
}
if opts.absolute_timeout.as_secs_f64() > MAX_ABSOLUTE_SECS {
return Err(ForgeError::limit("absolute_timeout exceeds the maximum"));
}
Ok(())
}
#[async_trait]
impl Auth for PgAuth {
async fn hash_password(&self, plain: &str) -> Result<PhcString> {
let span = tracing::info_span!(
"forge.auth.hash_password",
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "hash_password", span, async move {
check_password(plain)?;
let owned = plain.to_string();
let argon = forge_argon2()?;
let phc = tokio::task::spawn_blocking(move || {
let salt = SaltString::generate(&mut OsRng);
argon
.hash_password(owned.as_bytes(), &salt)
.map(|h| h.to_string())
})
.await
.map_err(|e| ForgeError::backend(format!("hash task failed: {e}")))?
.map_err(|e| ForgeError::backend(format!("argon2 hashing failed: {e}")))?;
Ok(PhcString::new(phc))
})
.await
}
async fn verify_password(&self, plain: &str, hash: &PhcString) -> Result<bool> {
let span = tracing::info_span!(
"forge.auth.verify_password",
auth.verify_ok = Empty,
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "verify_password", span, async move {
check_password(plain)?;
if hash.as_str().len() > MAX_PHC_BYTES {
return Err(ForgeError::limit("password hash exceeds the maximum size"));
}
let owned = plain.to_string();
let hash_str = hash.as_str().to_string();
let argon = forge_argon2()?;
let result = tokio::task::spawn_blocking(move || {
let parsed = PasswordHash::new(&hash_str)?;
argon.verify_password(owned.as_bytes(), &parsed)
})
.await
.map_err(|e| ForgeError::backend(format!("verify task failed: {e}")))?;
let ok = match result {
Ok(()) => true,
Err(argon2::password_hash::Error::Password) => false,
Err(argon2::password_hash::Error::Crypto) => {
return Err(ForgeError::backend("argon2 verification failed"));
}
Err(e) => return Err(ForgeError::invalid(format!("malformed password hash: {e}"))),
};
tracing::Span::current().record("auth.verify_ok", ok);
Ok(ok)
})
.await
}
fn needs_rehash(&self, hash: &PhcString) -> bool {
let Ok(parsed) = PasswordHash::new(hash.as_str()) else {
return true;
};
if parsed.algorithm.as_str() != "argon2id" {
return true;
}
let Ok(params) = Params::try_from(&parsed) else {
return true;
};
params.m_cost() < ARGON2_M_COST
|| params.t_cost() < ARGON2_T_COST
|| params.p_cost() < ARGON2_P_COST
}
async fn create_session(&self, user_id: &str, opts: SessionOpts) -> Result<SessionToken> {
let span = tracing::info_span!(
"forge.auth.create_session",
auth.user_hash = %key_hash(user_id),
auth.idle_secs = opts.idle_timeout.as_secs(),
auth.absolute_secs = opts.absolute_timeout.as_secs(),
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "create_session", span, async move {
check_id(user_id)?;
check_session_opts(&opts)?;
let token = random_token();
let token_hash = sha256_hex(token.as_bytes());
let idle = opts.idle_timeout.as_secs_f64();
let abs = opts.absolute_timeout.as_secs_f64();
sqlx::query!(
"INSERT INTO forge_sessions \
(token_hash, user_id, idle_secs, idle_deadline, abs_deadline, app) \
VALUES ($1, $2, $3, now() + make_interval(secs => $3), \
now() + make_interval(secs => $4), $5)",
token_hash,
user_id,
idle,
abs,
self.app,
)
.execute(&self.pool)
.await?;
Ok(SessionToken::new(token))
})
.await
}
async fn validate_session(&self, token: &str) -> Result<Option<Session>> {
let token_hash = sha256_hex(token.as_bytes());
let span = tracing::info_span!(
"forge.auth.validate_session",
auth.session_valid = Empty,
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "validate_session", span, async move {
let row = sqlx::query!(
r#"UPDATE forge_sessions
SET idle_deadline = LEAST(now() + make_interval(secs => idle_secs), abs_deadline)
WHERE token_hash = $1 AND app = $2 AND idle_deadline > now() AND abs_deadline > now()
RETURNING user_id, created_at, idle_deadline AS expires_at"#,
token_hash,
self.app,
)
.fetch_optional(&self.pool)
.await?;
tracing::Span::current().record("auth.session_valid", row.is_some());
Ok(row.map(|r| Session::new(r.user_id, r.created_at.into(), r.expires_at.into())))
})
.await
}
async fn revoke_session(&self, token: &str) -> Result<()> {
let token_hash = sha256_hex(token.as_bytes());
let span = tracing::info_span!(
"forge.auth.revoke_session",
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "revoke_session", span, async move {
sqlx::query!(
"DELETE FROM forge_sessions WHERE token_hash = $1 AND app = $2",
token_hash,
self.app,
)
.execute(&self.pool)
.await?;
Ok(())
})
.await
}
async fn revoke_all_sessions(&self, user_id: &str) -> Result<u64> {
let span = tracing::info_span!(
"forge.auth.revoke_all_sessions",
auth.user_hash = %key_hash(user_id),
auth.revoked_count = Empty,
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "revoke_all_sessions", span, async move {
let r = sqlx::query!(
"DELETE FROM forge_sessions WHERE user_id = $1 AND app = $2",
user_id,
self.app,
)
.execute(&self.pool)
.await?;
tracing::Span::current().record("auth.revoked_count", r.rows_affected());
Ok(r.rows_affected())
})
.await
}
async fn create_api_key(&self, owner_id: &str, label: &str) -> Result<ApiKey> {
self.create_api_key_with(owner_id, label, ApiKeyOpts::default())
.await
}
async fn create_api_key_with(
&self,
owner_id: &str,
label: &str,
opts: ApiKeyOpts,
) -> Result<ApiKey> {
let id = Uuid::new_v4().to_string();
let span = tracing::info_span!(
"forge.auth.create_api_key",
auth.user_hash = %key_hash(owner_id),
auth.key_id = %id,
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "create_api_key", span, async move {
check_id(owner_id)?;
check_label(label)?;
check_api_key_opts(&opts)?;
let secret = format!("{KEY_PREFIX}{}", random_token());
let key_hash = sha256_hex(secret.as_bytes());
let expires_secs = opts.expires_in.map(|duration| duration.as_secs_f64());
let row = sqlx::query!(
"INSERT INTO forge_api_keys (id, key_hash, owner_id, label, app, expires_at, scopes, metadata) \
VALUES ($1, $2, $3, $4, $5, CASE WHEN $6::float8 IS NULL THEN NULL ELSE now() + make_interval(secs => $6) END, $7, $8) \
RETURNING created_at, expires_at",
id,
key_hash,
owner_id,
label,
self.app,
expires_secs,
&opts.scopes,
Json(&opts.metadata) as _,
)
.fetch_one(&self.pool)
.await?;
Ok(ApiKey::new(
id,
label.to_string(),
ApiKeySecret::new(secret),
row.created_at.into(),
row.expires_at.map(Into::into),
opts.scopes,
opts.metadata,
))
})
.await
}
async fn verify_api_key(&self, key: &str) -> Result<Option<ApiKeyInfo>> {
let key_hash = sha256_hex(key.as_bytes());
let span = tracing::info_span!(
"forge.auth.verify_api_key",
auth.key_valid = Empty,
auth.key_id = Empty,
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "verify_api_key", span, async move {
let row = sqlx::query!(
r#"SELECT id, owner_id, label, expires_at, scopes, metadata AS "metadata!: Json<HashMap<String, String>>"
FROM forge_api_keys WHERE key_hash = $1 AND app = $2
AND (expires_at IS NULL OR expires_at > now())"#,
key_hash,
self.app,
)
.fetch_optional(&self.pool)
.await?;
let s = tracing::Span::current();
s.record("auth.key_valid", row.is_some());
if let Some(r) = &row {
s.record("auth.key_id", r.id.as_str());
}
Ok(row.map(|r| ApiKeyInfo::new(
r.id,
r.owner_id,
r.label,
r.expires_at.map(Into::into),
r.scopes,
r.metadata.0,
)))
})
.await
}
async fn revoke_api_key(&self, key_id: &str) -> Result<bool> {
let span = tracing::info_span!(
"forge.auth.revoke_api_key",
auth.key_id = %key_id,
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "revoke_api_key", span, async move {
let removed = sqlx::query_scalar!(
"DELETE FROM forge_api_keys WHERE id = $1 AND app = $2 RETURNING id",
key_id,
self.app,
)
.fetch_optional(&self.pool)
.await?
.is_some();
Ok(removed)
})
.await
}
async fn create_token(
&self,
user_id: &str,
purpose: &str,
ttl: Duration,
) -> Result<OneTimeToken> {
self.create_token_with_payload(user_id, purpose, ttl, Bytes::new())
.await
}
async fn create_token_with_payload(
&self,
user_id: &str,
purpose: &str,
ttl: Duration,
payload: Bytes,
) -> Result<OneTimeToken> {
let span = tracing::info_span!(
"forge.auth.create_token",
auth.user_hash = %key_hash(user_id),
auth.purpose = %purpose,
auth.ttl_secs = ttl.as_secs(),
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "create_token", span, async move {
check_id(user_id)?;
check_purpose(purpose)?;
check_token_ttl(ttl)?;
if payload.len() > MAX_TOKEN_PAYLOAD_BYTES {
return Err(ForgeError::limit("one-time token payload exceeds 4096 bytes"));
}
let token = random_token();
let token_hash = sha256_hex(token.as_bytes());
let ttl_secs = ttl.as_secs_f64();
sqlx::query!(
"INSERT INTO forge_auth_tokens (token_hash, user_id, purpose, expires_at, app, payload) \
VALUES ($1, $2, $3, now() + make_interval(secs => $4), $5, $6)",
token_hash,
user_id,
purpose,
ttl_secs,
self.app,
payload.as_ref(),
)
.execute(&self.pool)
.await?;
Ok(OneTimeToken::new(token))
})
.await
}
async fn consume_token(&self, token: &str, purpose: &str) -> Result<Option<String>> {
Ok(self
.consume_token_with_payload(token, purpose)
.await?
.map(|consumption| consumption.user_id))
}
async fn consume_token_with_payload(
&self,
token: &str,
purpose: &str,
) -> Result<Option<TokenConsumption>> {
let token_hash = sha256_hex(token.as_bytes());
let span = tracing::info_span!(
"forge.auth.consume_token",
auth.purpose = %purpose,
auth.token_valid = Empty,
outcome = Empty,
error.variant = Empty,
);
obs::instrument("auth", "consume_token", span, async move {
check_purpose(purpose)?;
let consumption = sqlx::query!(
"DELETE FROM forge_auth_tokens \
WHERE token_hash = $1 AND app = $2 AND purpose = $3 AND expires_at > now() \
RETURNING user_id, payload",
token_hash,
self.app,
purpose,
)
.fetch_optional(&self.pool)
.await?;
tracing::Span::current().record("auth.token_valid", consumption.is_some());
Ok(consumption.map(|record| TokenConsumption {
user_id: record.user_id,
payload: Bytes::from(record.payload),
}))
})
.await
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::panic)]
mod tests {
use super::*;
use std::time::Duration;
#[test]
fn random_tokens_are_unique_and_256_bit() {
let a = random_token();
let b = random_token();
assert_eq!(a.len(), TOKEN_BYTES * 2, "hex of 32 bytes = 64 chars");
assert_ne!(a, b);
}
#[test]
fn session_opts_validation() {
assert!(check_session_opts(&SessionOpts::default()).is_ok());
let zero = SessionOpts::default().with_idle_timeout(Duration::ZERO);
assert!(matches!(
check_session_opts(&zero),
Err(ForgeError::Invalid(_))
));
let inverted = SessionOpts::default()
.with_idle_timeout(Duration::from_secs(100))
.with_absolute_timeout(Duration::from_secs(10));
assert!(matches!(
check_session_opts(&inverted),
Err(ForgeError::Invalid(_))
));
}
}