Reimplemented access and refresh tokens.

This commit is contained in:
2026-10-18 13:21:48 +02:00
parent 4343959c74
commit 26999d690f
28 changed files with 1510 additions and 480 deletions
+197 -61
View File
@@ -1,94 +1,230 @@
use chrono::{DateTime, Utc};
use super::RepositoryError;
use super::{ReferenceRelation, ReferenceViolationKind, RepositoryError};
use crate::{
database::{self, dtos::TokenRow},
domain::Token,
database::{
self, Constraint, DatabaseError,
dtos::{AccessTokenRow, RefreshTokenRow},
},
domain::{HashedAccessToken, HashedRefreshToken, HashedSecret},
};
pub async fn get_by_access_token_hash<'e, E>(
#[tracing::instrument(skip(executor, secret_hash))]
pub async fn get_access_token_by_hash<'e, E>(
executor: E,
access_token_hash: &[u8],
) -> Result<Option<Token>, RepositoryError>
secret_hash: &HashedSecret,
) -> Result<Option<HashedAccessToken>, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
let token = database::tokens::get_by_access_token_hash(executor, access_token_hash)
let token = database::tokens::get_access_token_by_hash(executor, secret_hash.hash())
.await?
.map(decode)
.transpose()?;
.map(decode_access_token);
Ok(token)
}
pub async fn issue<'e, E>(executor: E, token: Token) -> Result<(), RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
database::tokens::issue(executor, encode(token)).await?;
Ok(())
}
pub async fn rotate_refresh_token<'e, E>(
#[tracing::instrument(skip(executor, secret_hash))]
pub async fn get_access_token_by_refresh_hash<'e, E>(
executor: E,
old_refresh_hash: &[u8],
access_token_hash: &[u8],
refresh_token_hash: &[u8],
access_expires_at: DateTime<Utc>,
refresh_expires_at: DateTime<Utc>,
) -> Result<bool, RepositoryError>
secret_hash: &HashedSecret,
) -> Result<Option<HashedAccessToken>, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
let rotated = database::tokens::rotate_refresh_token(
let token =
database::tokens::get_access_token_by_refresh_secret_hash(executor, secret_hash.hash())
.await?
.map(decode_access_token);
Ok(token)
}
#[tracing::instrument(skip(executor, access_token))]
pub async fn insert_access_token<'e, E>(
executor: E,
access_token: HashedAccessToken,
) -> Result<HashedAccessToken, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
let token = database::tokens::insert_access_token(executor, encode_access_token(access_token))
.await
.map_err(classify_insert_error)?;
Ok(decode_access_token(token))
}
#[tracing::instrument(skip(executor, secret_hash, new_secret_hash))]
pub async fn update_access_token_by_hash<'e, E>(
executor: E,
secret_hash: &HashedSecret,
new_secret_hash: &HashedSecret,
new_expires_at: DateTime<Utc>,
new_issued_at: DateTime<Utc>,
) -> Result<Option<HashedAccessToken>, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
let token = database::tokens::update_access_token_by_hash(
executor,
old_refresh_hash,
access_token_hash,
refresh_token_hash,
access_expires_at,
refresh_expires_at,
secret_hash.hash(),
new_secret_hash.hash(),
new_expires_at,
new_issued_at,
)
.await?;
.await?
.map(decode_access_token);
Ok(rotated)
Ok(token)
}
pub async fn revoke<'e, E>(executor: E, token_hash: &[u8]) -> Result<(), RepositoryError>
#[tracing::instrument(skip(executor, secret_hash))]
pub async fn delete_access_token_by_hash<'e, E>(
executor: E,
secret_hash: &HashedSecret,
) -> Result<Option<HashedAccessToken>, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
database::tokens::revoke(executor, token_hash).await?;
let token = database::tokens::delete_access_token_by_hash(executor, secret_hash.hash())
.await?
.map(decode_access_token);
Ok(())
Ok(token)
}
fn decode(token: TokenRow) -> Result<Token, RepositoryError> {
Ok(Token {
id: token.id,
user_id: token.user_id,
user_app_id: token.user_app_id,
access_token_hash: token.access_token_hash,
refresh_token_hash: token.refresh_token_hash,
access_expires_at: token.access_expires_at,
refresh_expires_at: token.refresh_expires_at,
refreshed_at: token.refreshed_at,
revoked_at: token.revoked_at,
created_at: token.created_at,
})
#[tracing::instrument(skip(executor, secret_hash))]
pub async fn get_refresh_token_by_hash<'e, E>(
executor: E,
secret_hash: &HashedSecret,
) -> Result<Option<HashedRefreshToken>, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
let token = database::tokens::get_refresh_token_by_hash(executor, secret_hash.hash())
.await?
.map(decode_refresh_token);
Ok(token)
}
fn encode(token: Token) -> TokenRow {
TokenRow {
id: token.id,
user_id: token.user_id,
user_app_id: token.user_app_id,
access_token_hash: token.access_token_hash,
refresh_token_hash: token.refresh_token_hash,
access_expires_at: token.access_expires_at,
refresh_expires_at: token.refresh_expires_at,
refreshed_at: token.refreshed_at,
revoked_at: token.revoked_at,
created_at: token.created_at,
// pub async fn insert_refresh_token<'e, E>(
// executor: E,
// refresh_token: HashedRefreshToken,
// ) -> Result<HashedRefreshToken, RepositoryError>
// where
// E: sqlx::Executor<'e, Database = sqlx::Postgres>,
// {
// let token =
// database::tokens::insert_refresh_token(executor, encode_refresh_token(refresh_token))
// .await
// .map_err(classify_insert_error)?;
// Ok(decode_refresh_token(token))
// }
#[tracing::instrument(skip(executor, secret_hash, new_secret_hash))]
pub async fn update_refresh_token_by_hash<'e, E>(
executor: E,
secret_hash: &HashedSecret,
new_secret_hash: &HashedSecret,
new_expires_at: DateTime<Utc>,
new_issued_at: DateTime<Utc>,
) -> Result<Option<HashedRefreshToken>, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
let token = database::tokens::update_refresh_token_by_hash(
executor,
secret_hash.hash(),
new_secret_hash.hash(),
new_expires_at,
new_issued_at,
)
.await?
.map(decode_refresh_token);
Ok(token)
}
#[tracing::instrument(skip(executor, secret_hash))]
pub async fn delete_refresh_token_by_hash<'e, E>(
executor: E,
secret_hash: &HashedSecret,
) -> Result<Option<HashedRefreshToken>, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
let token = database::tokens::delete_refresh_token_by_hash(executor, secret_hash.hash())
.await?
.map(decode_refresh_token);
Ok(token)
}
fn classify_insert_error(error: DatabaseError) -> RepositoryError {
let relation = match &error {
DatabaseError::ForeignKeyViolation {
constraint: Constraint::AccessTokenUser,
..
} => ReferenceRelation::User,
DatabaseError::ForeignKeyViolation {
constraint: Constraint::AccessTokenUserApp,
..
} => ReferenceRelation::UserApp,
DatabaseError::ForeignKeyViolation {
constraint: Constraint::RefreshTokenAccessToken,
..
} => ReferenceRelation::AccessToken,
_ => return RepositoryError::Database(error),
};
RepositoryError::ReferenceViolation {
relation,
kind: ReferenceViolationKind::Missing,
source: error,
}
}
fn decode_access_token(row: AccessTokenRow) -> HashedAccessToken {
HashedAccessToken {
id: row.id,
user_id: row.user_id,
user_app_id: row.user_app_id,
secret_hash: HashedSecret::from(row.secret_hash),
expires_at: row.expires_at,
issued_at: row.issued_at,
}
}
fn encode_access_token(token: HashedAccessToken) -> AccessTokenRow {
AccessTokenRow {
id: token.id,
user_id: token.user_id,
user_app_id: token.user_app_id,
secret_hash: token.secret_hash.hash().to_vec(),
expires_at: token.expires_at,
issued_at: token.issued_at,
}
}
fn decode_refresh_token(row: RefreshTokenRow) -> HashedRefreshToken {
HashedRefreshToken {
id: row.id,
token_id: row.access_token_id,
secret_hash: HashedSecret::from(row.secret_hash),
expires_at: row.expires_at,
issued_at: row.issued_at,
}
}
// fn encode_refresh_token(token: HashedRefreshToken) -> RefreshTokenRow {
// RefreshTokenRow {
// id: token.id,
// access_token_id: token.token_id,
// secret_hash: token.secret_hash.hash().to_vec(),
// expires_at: token.expires_at,
// issued_at: token.issued_at,
// }
// }
+3 -3
View File
@@ -5,7 +5,7 @@ use super::{
};
use crate::{
database::{self, Constraint, DatabaseError, dtos::UserAppSecretRow},
domain::UserAppSecret,
domain::{HashedSecret, UserAppSecret},
repository::DecodeError,
};
@@ -95,12 +95,12 @@ fn classify_upsert_error(error: DatabaseError) -> RepositoryError {
pub async fn verify<'e, E>(
executor: E,
app_id: Uuid,
secret_hash: &[u8],
secret_hash: &HashedSecret,
) -> Result<bool, RepositoryError>
where
E: sqlx::Executor<'e, Database = sqlx::Postgres>,
{
let is_valid = database::user_app_secrets::verify(executor, app_id, secret_hash).await?;
let is_valid = database::user_app_secrets::verify(executor, app_id, secret_hash.hash()).await?;
Ok(is_valid)
}