From e68f103c29f739d178a5167b7197a5d5b442313d Mon Sep 17 00:00:00 2001 From: Rogier Reerink Date: Fri, 9 Oct 2026 12:11:42 +0200 Subject: [PATCH] Added ownership and app existence validation to the user app secrets routes. --- ...c92e30ca688f496cc02c79f265f870540153.json} | 4 +- ...e4c27664bf4a0dbc2e71b2ade48df2e8dcd6e.json | 28 +++++++++++ ...20261007000001_create_user_app_secrets.sql | 5 +- server/src/database/user_app_secrets.rs | 3 +- server/src/database/user_apps.rs | 16 +++++++ server/src/error.rs | 13 +++++ server/src/repository.rs | 3 ++ server/src/repository/user_app_secrets.rs | 20 ++++---- server/src/repository/user_apps.rs | 12 +++++ server/src/routes/dtos/user_app_secret.rs | 15 ++---- server/src/routes/user_app_secrets.rs | 47 +++++++++++++++---- 11 files changed, 129 insertions(+), 37 deletions(-) rename server/.sqlx/{query-b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c.json => query-594090231079a7874dbe6d8b9696c92e30ca688f496cc02c79f265f870540153.json} (74%) create mode 100644 server/.sqlx/query-f9a9d0e201e0f1c912d940fb6d0e4c27664bf4a0dbc2e71b2ade48df2e8dcd6e.json diff --git a/server/.sqlx/query-b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c.json b/server/.sqlx/query-594090231079a7874dbe6d8b9696c92e30ca688f496cc02c79f265f870540153.json similarity index 74% rename from server/.sqlx/query-b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c.json rename to server/.sqlx/query-594090231079a7874dbe6d8b9696c92e30ca688f496cc02c79f265f870540153.json index 4578eae..0b55c09 100644 --- a/server/.sqlx/query-b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c.json +++ b/server/.sqlx/query-594090231079a7874dbe6d8b9696c92e30ca688f496cc02c79f265f870540153.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "\n INSERT INTO user_app_secrets (id, app_id, secret_hash, expires_at)\n VALUES ($1, $2, $3, $4)\n ON CONFLICT (id) DO UPDATE SET\n secret_hash = EXCLUDED.secret_hash,\n expires_at = EXCLUDED.expires_at\n WHERE user_app_secrets.app_id = EXCLUDED.app_id\n RETURNING WITH (OLD AS old_row, NEW AS new_row)\n old_row.id AS \"old_id?\",\n new_row.id AS \"id!\",\n new_row.app_id AS \"app_id!\",\n new_row.secret_hash AS \"secret_hash!\",\n new_row.expires_at AS \"expires_at!\",\n new_row.created_at AS \"created_at!\"\n ", + "query": "\n INSERT INTO user_app_secrets (id, app_id, secret_hash, expires_at)\n VALUES ($1, $2, $3, $4)\n ON CONFLICT (id, app_id) DO UPDATE SET\n secret_hash = EXCLUDED.secret_hash,\n expires_at = EXCLUDED.expires_at\n RETURNING WITH (OLD AS old_row, NEW AS new_row)\n old_row.id AS \"old_id?\",\n new_row.id AS \"id!\",\n new_row.app_id AS \"app_id!\",\n new_row.secret_hash AS \"secret_hash!\",\n new_row.expires_at AS \"expires_at!\",\n new_row.created_at AS \"created_at!\"\n ", "describe": { "columns": [ { @@ -87,5 +87,5 @@ false ] }, - "hash": "b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c" + "hash": "594090231079a7874dbe6d8b9696c92e30ca688f496cc02c79f265f870540153" } diff --git a/server/.sqlx/query-f9a9d0e201e0f1c912d940fb6d0e4c27664bf4a0dbc2e71b2ade48df2e8dcd6e.json b/server/.sqlx/query-f9a9d0e201e0f1c912d940fb6d0e4c27664bf4a0dbc2e71b2ade48df2e8dcd6e.json new file mode 100644 index 0000000..b0608e5 --- /dev/null +++ b/server/.sqlx/query-f9a9d0e201e0f1c912d940fb6d0e4c27664bf4a0dbc2e71b2ade48df2e8dcd6e.json @@ -0,0 +1,28 @@ +{ + "db_name": "PostgreSQL", + "query": "SELECT user_id FROM user_apps WHERE id = $1 FOR SHARE", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "user_id", + "type_info": "Uuid", + "origin": { + "Table": { + "table": "user_apps", + "name": "user_id" + } + } + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false + ] + }, + "hash": "f9a9d0e201e0f1c912d940fb6d0e4c27664bf4a0dbc2e71b2ade48df2e8dcd6e" +} diff --git a/server/migrations/20261007000001_create_user_app_secrets.sql b/server/migrations/20261007000001_create_user_app_secrets.sql index c910c95..ba5cc06 100644 --- a/server/migrations/20261007000001_create_user_app_secrets.sql +++ b/server/migrations/20261007000001_create_user_app_secrets.sql @@ -1,11 +1,12 @@ CREATE TABLE user_app_secrets ( - id UUID PRIMARY KEY DEFAULT gen_random_uuid (), + id UUID DEFAULT gen_random_uuid (), app_id UUID NOT NULL CONSTRAINT fk_user_app_secrets_app REFERENCES user_apps (id) ON DELETE CASCADE, secret_hash BYTEA NOT NULL CHECK ( octet_length(secret_hash) = 32 ), expires_at TIMESTAMPTZ NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT now() + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (id, app_id) ); CREATE INDEX ix_user_app_secrets_app_id ON user_app_secrets (app_id); \ No newline at end of file diff --git a/server/src/database/user_app_secrets.rs b/server/src/database/user_app_secrets.rs index af9c526..29f8712 100644 --- a/server/src/database/user_app_secrets.rs +++ b/server/src/database/user_app_secrets.rs @@ -68,10 +68,9 @@ where r#" INSERT INTO user_app_secrets (id, app_id, secret_hash, expires_at) VALUES ($1, $2, $3, $4) - ON CONFLICT (id) DO UPDATE SET + ON CONFLICT (id, app_id) DO UPDATE SET secret_hash = EXCLUDED.secret_hash, expires_at = EXCLUDED.expires_at - WHERE user_app_secrets.app_id = EXCLUDED.app_id RETURNING WITH (OLD AS old_row, NEW AS new_row) old_row.id AS "old_id?", new_row.id AS "id!", diff --git a/server/src/database/user_apps.rs b/server/src/database/user_apps.rs index a6a08eb..80286d5 100644 --- a/server/src/database/user_apps.rs +++ b/server/src/database/user_apps.rs @@ -57,6 +57,22 @@ where .map_err(DatabaseError::from) } +pub async fn find_owner_by_id<'e, E>( + executor: E, + app_id: Uuid, +) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_scalar!( + "SELECT user_id FROM user_apps WHERE id = $1 FOR SHARE", + app_id, + ) + .fetch_optional(executor) + .await + .map_err(DatabaseError::from) +} + pub async fn upsert<'e, E>( executor: E, app: UserAppRow, diff --git a/server/src/error.rs b/server/src/error.rs index 6f26a59..228545f 100644 --- a/server/src/error.rs +++ b/server/src/error.rs @@ -56,9 +56,22 @@ impl IntoResponse for AppError { tracing::warn!("user app ownership conflict"); return error_response(StatusCode::CONFLICT, "User app belongs to another user"); } + Self::Repository(RepositoryError::NotFound { + relation: ReferenceRelation::User, + }) => { + return error_response(StatusCode::NOT_FOUND, "User cannot be found"); + } + Self::Repository(RepositoryError::NotFound { + relation: ReferenceRelation::UserApp, + }) => { + return error_response(StatusCode::NOT_FOUND, "User app cannot be found"); + } Self::Repository(RepositoryError::OwnershipConflict { relation }) => { tracing::error!(%relation, "unhandled ownership conflict"); } + Self::Repository(RepositoryError::NotFound { relation }) => { + tracing::error!(%relation, "unhandled not found"); + } Self::Repository(RepositoryError::ReferenceViolation { relation: ReferenceRelation::User, kind: ReferenceViolationKind::Missing, diff --git a/server/src/repository.rs b/server/src/repository.rs index bac7c22..760dd33 100644 --- a/server/src/repository.rs +++ b/server/src/repository.rs @@ -24,6 +24,9 @@ pub enum RepositoryError { #[error("{relation} is owned by another user")] OwnershipConflict { relation: ReferenceRelation }, + #[error("{relation} cannot be found")] + NotFound { relation: ReferenceRelation }, + #[error("reference violation ({kind}: {relation})")] ReferenceViolation { relation: ReferenceRelation, diff --git a/server/src/repository/user_app_secrets.rs b/server/src/repository/user_app_secrets.rs index dd596f2..4923bf9 100644 --- a/server/src/repository/user_app_secrets.rs +++ b/server/src/repository/user_app_secrets.rs @@ -138,6 +138,16 @@ mod tests { use super::*; + fn row() -> UserAppSecretRow { + UserAppSecretRow { + id: Uuid::new_v4(), + app_id: Uuid::new_v4(), + secret_hash: vec![0; 32], + expires_at: Utc::now(), + created_at: Utc::now(), + } + } + fn foreign_key_violation(constraint: Constraint) -> DatabaseError { DatabaseError::ForeignKeyViolation { constraint, @@ -164,16 +174,6 @@ mod tests { assert!(matches!(error, RepositoryError::Database(_))); } - fn row() -> UserAppSecretRow { - UserAppSecretRow { - id: Uuid::new_v4(), - app_id: Uuid::new_v4(), - secret_hash: vec![7; 32], - expires_at: Utc::now(), - created_at: Utc::now(), - } - } - #[test] fn round_trips_through_rows() { let secret = decode(row()).unwrap(); diff --git a/server/src/repository/user_apps.rs b/server/src/repository/user_apps.rs index 1dab819..0ad3391 100644 --- a/server/src/repository/user_apps.rs +++ b/server/src/repository/user_apps.rs @@ -58,6 +58,18 @@ where Ok(app) } +pub async fn find_owner_by_id<'e, E>( + executor: E, + app_id: Uuid, +) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let owner = db::find_owner_by_id(executor, app_id).await?; + + Ok(owner) +} + pub async fn upsert<'e, E>(executor: E, app: UserApp) -> Result, RepositoryError> where E: sqlx::Executor<'e, Database = sqlx::Postgres>, diff --git a/server/src/routes/dtos/user_app_secret.rs b/server/src/routes/dtos/user_app_secret.rs index 781e7ff..5c1ca56 100644 --- a/server/src/routes/dtos/user_app_secret.rs +++ b/server/src/routes/dtos/user_app_secret.rs @@ -1,4 +1,4 @@ -use chrono::{DateTime, FixedOffset, Utc}; +use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use uuid::Uuid; @@ -6,13 +6,7 @@ use crate::domain; #[derive(Debug, Clone, Deserialize)] pub struct UserAppSecretRequest { - pub expires_at: DateTime, -} - -impl UserAppSecretRequest { - pub fn expires_at_utc(&self) -> DateTime { - self.expires_at.with_timezone(&Utc) - } + pub expires_at: DateTime, } #[derive(Debug, Clone, Serialize)] @@ -50,10 +44,7 @@ mod tests { let request: UserAppSecretRequest = serde_json::from_str(r#"{"expires_at":"2030-01-01T12:00:00+02:00"}"#).unwrap(); - assert_eq!( - request.expires_at_utc().to_rfc3339(), - "2030-01-01T10:00:00+00:00" - ); + assert_eq!(request.expires_at.to_rfc3339(), "2030-01-01T10:00:00+00:00"); } #[test] diff --git a/server/src/routes/user_app_secrets.rs b/server/src/routes/user_app_secrets.rs index bc3a432..33f358e 100644 --- a/server/src/routes/user_app_secrets.rs +++ b/server/src/routes/user_app_secrets.rs @@ -14,7 +14,7 @@ use crate::{ domain::UserAppSecret, error::AppError, repository::{ - self, + self, ReferenceRelation, RepositoryError, dtos::{Delete, Upsert}, }, }; @@ -49,11 +49,14 @@ async fn list_user_app_secrets( offset: query.offset, }; - let secrets = repository::user_app_secrets::list(&pool, query) + let mut tx = pool.begin().await.map_err(RepositoryError::from)?; + ensure_app_ownership(&mut tx, user_id, app_id).await?; + let secrets = repository::user_app_secrets::list(&mut *tx, query) .await? .into_iter() .map(UserAppSecretResponse::from) .collect(); + tx.commit().await.map_err(RepositoryError::from)?; Ok(Json(secrets)) } @@ -64,9 +67,12 @@ async fn get_user_app_secret( State(pool): State, Path((user_id, app_id, secret_id)): Path<(Uuid, Uuid, Uuid)>, ) -> Result, AppError> { - let secret = repository::user_app_secrets::get_by_id(&pool, app_id, secret_id) + let mut tx = pool.begin().await.map_err(RepositoryError::from)?; + ensure_app_ownership(&mut tx, user_id, app_id).await?; + let secret = repository::user_app_secrets::get_by_id(&mut *tx, app_id, secret_id) .await? .ok_or(AppError::NotFound)?; + tx.commit().await.map_err(RepositoryError::from)?; Ok(Json(secret.into())) } @@ -78,8 +84,8 @@ async fn upsert_user_app_secret( Path((user_id, app_id, secret_id)): Path<(Uuid, Uuid, Uuid)>, Json(request): Json, ) -> Result<(StatusCode, Json), AppError> { - let expires_at = request.expires_at_utc(); - if expires_at <= chrono::Utc::now() { + let now = chrono::Utc::now(); + if request.expires_at <= now { return Err(AppError::BadRequest( "expires_at must be in the future".to_owned(), )); @@ -90,10 +96,14 @@ async fn upsert_user_app_secret( id: secret_id, app_id, secret_hash: hash_secret(&generated_secret), - expires_at, - created_at: chrono::Utc::now(), + expires_at: request.expires_at, + created_at: now, }; - let upsert = repository::user_app_secrets::upsert(&pool, secret).await?; + + let mut tx = pool.begin().await.map_err(RepositoryError::from)?; + ensure_app_ownership(&mut tx, user_id, app_id).await?; + let upsert = repository::user_app_secrets::upsert(&mut *tx, secret).await?; + tx.commit().await.map_err(RepositoryError::from)?; let (status, secret) = match upsert { Upsert::Created(secret) => (StatusCode::CREATED, secret), @@ -115,8 +125,27 @@ async fn delete_user_app_secret( State(pool): State, Path((user_id, app_id, secret_id)): Path<(Uuid, Uuid, Uuid)>, ) -> Result { - match repository::user_app_secrets::delete_by_id(&pool, app_id, secret_id).await? { + let mut tx = pool.begin().await.map_err(RepositoryError::from)?; + ensure_app_ownership(&mut tx, user_id, app_id).await?; + let result = repository::user_app_secrets::delete_by_id(&mut *tx, app_id, secret_id).await?; + tx.commit().await.map_err(RepositoryError::from)?; + + match result { Delete::Deleted => Ok(StatusCode::NO_CONTENT), Delete::NotFound => Err(AppError::NotFound), } } + +async fn ensure_app_ownership( + connection: &mut sqlx::PgConnection, + user_id: Uuid, + app_id: Uuid, +) -> Result<(), AppError> { + match repository::user_apps::find_owner_by_id(&mut *connection, app_id).await? { + Some(owner) if owner == user_id => Ok(()), + Some(_) | None => Err(RepositoryError::NotFound { + relation: ReferenceRelation::UserApp, + } + .into()), + } +}