address review: one query per file with Args, order every session insert against a reset, re-purge session cache after commit

This commit is contained in:
Dylan M. Taylor committed 2026-11-11 04:52:52 +00:00
1 parent a0626b5bbd
commit ed360d5dc0
14 files changed
+177 -119

No files matched your search

@@ -1,12 +0,0 @@
{
"db_name": "MySQL",
"describe": {
"columns": [],
"nullable": [],
"parameters": {
"Right": 6
}
},
"hash": "2ddd5589138c822385b39dde58fc0d44ffa003b09018f1799e243d8f09530981",
"query": "\nINSERT INTO user_sessions (\n token,\n user_token,\n maybe_impersonation_user_token,\n ip_address_creation,\n maybe_creation_type,\n expires_at\n)\nVALUES (?, ?, ?, ?, ?, ?)\n "
}
@@ -1,12 +0,0 @@
{
"db_name": "MySQL",
"query": "\nINSERT INTO user_sessions (\n token,\n user_token,\n maybe_impersonation_user_token,\n ip_address_creation,\n expires_at\n)\nVALUES (?, ?, ?, ?, ?)\n ",
"describe": {
"columns": [],
"parameters": {
"Right": 5
},
"nullable": []
},
"hash": "ba5b0a542d4b95b781077b8895529d222dd682eb28c9d00031a820ec6f37e095"
}
@@ -1,12 +0,0 @@
{
"db_name": "MySQL",
"describe": {
"columns": [],
"nullable": [],
"parameters": {
"Right": 4
}
},
"hash": "eb5fdd0e93978edfbe97c58238ea81f0c21dba047975beb53a39224894e9d41c",
"query": "\nINSERT INTO user_sessions (token, user_token, ip_address_creation, maybe_creation_type, expires_at)\nSELECT ?, token, ?, ?, NOW() + INTERVAL 1 YEAR FROM users\nWHERE token = ? AND is_banned = FALSE AND user_deleted_at IS NULL AND mod_deleted_at IS NULL\n"
}
@@ -2,7 +2,8 @@ use anyhow::anyhow;
use sqlx::{MySql, Transaction};
use errors::AnyhowResult;
use crate::queries::users::user_sessions::revoke_all_user_sessions::{list_live_session_tokens, revoke_all_user_sessions};
use crate::queries::users::user_sessions::list_live_session_tokens::{list_live_session_tokens, ListLiveSessionTokensArgs};
use crate::queries::users::user_sessions::revoke_all_user_sessions::{revoke_all_user_sessions, RevokeAllUserSessionsArgs};
use tokens::tokens::password_reset::PasswordResetToken;
use tokens::tokens::users::UserToken;
@@ -70,7 +71,10 @@ LIMIT 1
// NB: Recovery must lock out whoever held the account before it, so revoke every existing session
// in the same transaction. The handler issues a fresh session after commit.
let revoked_session_tokens = match list_live_session_tokens(args.user_token, &mut *args.mysql_transaction).await {
let revoked_session_tokens = match list_live_session_tokens(ListLiveSessionTokensArgs {
user_token: args.user_token,
mysql_executor: &mut *args.mysql_transaction,
}).await {
Ok(tokens) => tokens,
Err(err) => {
let _r = args.mysql_transaction.rollback().await.ok();
@@ -78,7 +82,10 @@ LIMIT 1
}
};
let query_result = revoke_all_user_sessions(args.user_token, &mut *args.mysql_transaction).await;
let query_result = revoke_all_user_sessions(RevokeAllUserSessionsArgs {
user_token: args.user_token,
mysql_executor: &mut *args.mysql_transaction,
}).await;
if let Err(err) = query_result {
let _r = args.mysql_transaction.rollback().await.ok();
@@ -16,17 +16,18 @@ where
T: Executor<'c, Database = MySql>,
{
let token = UserSessionToken::generate();
let inserted = sqlx::query!(
// NB: runtime query; FOR UPDATE takes the user's row lock so this insert is ordered against a password reset.
let inserted = sqlx::query(
r#"
INSERT INTO user_sessions (token, user_token, ip_address_creation, maybe_creation_type, expires_at)
SELECT ?, token, ?, ?, NOW() + INTERVAL 1 YEAR FROM users
WHERE token = ? AND is_banned = FALSE AND user_deleted_at IS NULL AND mod_deleted_at IS NULL
"#,
token.as_str(),
args.ip_address,
UserWebSessionCreationType::DeviceApproval.to_str(),
args.user_token
)
FOR UPDATE
"#)
.bind(token.as_str())
.bind(args.ip_address)
.bind(UserWebSessionCreationType::DeviceApproval.to_str())
.bind(args.user_token)
.execute(args.mysql_executor)
.await?;
if inserted.rows_affected() != 1 {
@@ -30,7 +30,8 @@ pub async fn create_impersonated_user_session<'a, 'c, E>(
{
let session_token = UserSessionToken::generate();
sqlx::query!(
// NB: runtime query; FOR UPDATE takes the user's row lock so this insert is ordered against a password reset.
let result = sqlx::query(
r#"
INSERT INTO user_sessions (
token,
@@ -40,17 +41,23 @@ INSERT INTO user_sessions (
maybe_creation_type,
expires_at
)
VALUES (?, ?, ?, ?, ?, ?)
"#,
session_token.as_str(),
args.user_token.as_str(),
args.impersonator_user_token.as_str(),
args.ip_address,
UserWebSessionCreationType::Impersonation.to_str(),
args.expires_at,
)
SELECT ?, token, ?, ?, ?, ?
FROM users
WHERE token = ?
FOR UPDATE
"#)
.bind(session_token.as_str())
.bind(args.impersonator_user_token.as_str())
.bind(args.ip_address)
.bind(UserWebSessionCreationType::Impersonation.to_str())
.bind(args.expires_at)
.bind(args.user_token.as_str())
.execute(args.mysql_executor)
.await?;
if result.rows_affected() == 0 {
return Err(sqlx::Error::RowNotFound);
}
Ok(session_token)
}
@@ -4,19 +4,26 @@ use sqlx::{Executor, MySql};
use tokens::tokens::user_sessions::UserSessionToken;
use tokens::tokens::users::UserToken;
/// Creates a password-login session only if `users.password_version` still equals the version the
/// caller verified the password against. The version check and the INSERT are one statement, and
/// the `FOR UPDATE` row lock orders it against a password reset (which updates that row, then
/// revokes sessions, in one transaction): either the session exists before the reset's revoke, or
/// the version has moved and no session is created. Returns `Ok(None)` when the version moved.
pub async fn create_user_session_if_password_version<'e, 'c: 'e, E>(
user_token: &UserToken,
expected_password_version: u32,
ip_address: &str,
mysql_executor: E,
pub struct CreateUserSessionIfPasswordVersionArgs<'a, T> {
pub user_token: &'a UserToken,
/// The `password_version` the caller verified a password against. `None` for paths that verify no
/// password (SSO): the version is then read inside the statement, under the same row lock.
pub maybe_expected_password_version: Option<u32>,
pub ip_address: &'a str,
pub creation_type: UserWebSessionCreationType,
pub mysql_executor: T,
}
/// Creates a session only if `users.password_version` still equals the expected version (when one is
/// given). The version check and the INSERT are one statement, and the `FOR UPDATE` row lock orders
/// it against a password reset (which updates that row, then revokes sessions, in one transaction):
/// either the session exists before the reset's revoke, or it is created after the reset committed.
/// Returns `Ok(None)` when the user is missing or the version moved.
pub async fn create_user_session_if_password_version<'c, T>(
args: CreateUserSessionIfPasswordVersionArgs<'_, T>,
) -> Result<Option<UserSessionToken>, sqlx::Error>
where
E: 'e + Executor<'c, Database = MySql>,
T: Executor<'c, Database = MySql>,
{
let session_token = UserSessionToken::generate();
@@ -33,15 +40,16 @@ INSERT INTO user_sessions (
SELECT ?, token, ?, ?, NOW() + interval 1 year
FROM users
WHERE token = ?
AND password_version = ?
AND (? IS NULL OR password_version = ?)
FOR UPDATE
"#)
.bind(session_token.as_str())
.bind(ip_address)
.bind(UserWebSessionCreationType::DirectLogin.to_str())
.bind(user_token.as_str())
.bind(expected_password_version)
.execute(mysql_executor)
.bind(args.ip_address)
.bind(args.creation_type.to_str())
.bind(args.user_token.as_str())
.bind(args.maybe_expected_password_version)
.bind(args.maybe_expected_password_version)
.execute(args.mysql_executor)
.await?;
if result.rows_affected() == 0 {
@@ -0,0 +1,19 @@
use sqlx::{Executor, MySql};
use tokens::tokens::users::UserToken;
pub struct ListLiveSessionTokensArgs<'a, T> {
pub user_token: &'a UserToken,
pub mysql_executor: T,
}
/// Returns the tokens of the user's live sessions, so callers can purge their cache entries after revoking.
pub async fn list_live_session_tokens<'c, T>(args: ListLiveSessionTokensArgs<'_, T>) -> Result<Vec<String>, sqlx::Error>
where
T: Executor<'c, Database = MySql>,
{
// NB: runtime (non-macro) query so no offline sqlx metadata is needed.
sqlx::query_scalar::<_, String>("SELECT token FROM user_sessions WHERE user_token = ? AND deleted_at IS NULL")
.bind(args.user_token.as_str())
.fetch_all(args.mysql_executor)
.await
}
@@ -10,4 +10,5 @@ pub mod find_approving_session;
pub mod find_redeemed_session;
pub mod get_user_session_by_token;
pub mod get_user_session_by_token_light;
pub mod list_live_session_tokens;
pub mod revoke_all_user_sessions;
@@ -1,28 +1,15 @@
use sqlx::{Executor, MySql};
use tokens::tokens::users::UserToken;
/// Returns the tokens of the user's live sessions, so callers can purge their cache entries after revoking.
pub async fn list_live_session_tokens<'e, 'c: 'e, E>(
user_token: &UserToken,
mysql_executor: E,
) -> Result<Vec<String>, sqlx::Error>
where
E: 'e + Executor<'c, Database = MySql>,
{
// NB: runtime (non-macro) query so no offline sqlx metadata is needed.
sqlx::query_scalar::<_, String>("SELECT token FROM user_sessions WHERE user_token = ? AND deleted_at IS NULL")
.bind(user_token.as_str())
.fetch_all(mysql_executor)
.await
pub struct RevokeAllUserSessionsArgs<'a, T> {
pub user_token: &'a UserToken,
pub mysql_executor: T,
}
/// Soft-deletes every live session of the user. Takes any executor so callers can run it inside a transaction.
pub async fn revoke_all_user_sessions<'e, 'c: 'e, E>(
user_token: &UserToken,
mysql_executor: E,
) -> Result<(), sqlx::Error>
pub async fn revoke_all_user_sessions<'c, T>(args: RevokeAllUserSessionsArgs<'_, T>) -> Result<(), sqlx::Error>
where
E: 'e + Executor<'c, Database = MySql>,
T: Executor<'c, Database = MySql>,
{
sqlx::query!(
r#"
@@ -32,9 +19,9 @@ WHERE
user_token = ?
AND deleted_at IS NULL
"#,
user_token.as_str(),
args.user_token.as_str(),
)
.execute(mysql_executor)
.execute(args.mysql_executor)
.await?;
Ok(())
@@ -1,6 +1,7 @@
//! A login that verified the password against an older `password_version` (a reset committed in
//! between) must not get a session. Needs the disposable local MySQL, like the other tests here.
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::create_user_session_if_password_version;
use enums::by_table::user_sessions::user_web_session_creation_type::UserWebSessionCreationType;
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::{create_user_session_if_password_version, CreateUserSessionIfPasswordVersionArgs};
use mysql_testing::fixtures::users::create_test_user;
use mysql_testing::isolated::IsolatedTestDatabase;
@@ -14,7 +15,13 @@ async fn session_is_created_only_while_password_version_matches() {
.await
.unwrap();
let ok = create_user_session_if_password_version(&user.user_token, version, "127.0.0.1", &db.pool).await.unwrap();
let ok = create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
user_token: &user.user_token,
maybe_expected_password_version: Some(version),
ip_address: "127.0.0.1",
creation_type: UserWebSessionCreationType::DirectLogin,
mysql_executor: &db.pool,
}).await.unwrap();
assert!(ok.is_some());
// Simulates the reset committing after the login looked the user up.
@@ -24,7 +31,13 @@ async fn session_is_created_only_while_password_version_matches() {
.await
.unwrap();
let stale = create_user_session_if_password_version(&user.user_token, version, "127.0.0.1", &db.pool).await.unwrap();
let stale = create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
user_token: &user.user_token,
maybe_expected_password_version: Some(version),
ip_address: "127.0.0.1",
creation_type: UserWebSessionCreationType::DirectLogin,
mysql_executor: &db.pool,
}).await.unwrap();
assert!(stale.is_none());
let live: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM user_sessions WHERE user_token = ? AND deleted_at IS NULL")
.bind(user.user_token.as_str())
@@ -32,4 +45,14 @@ async fn session_is_created_only_while_password_version_matches() {
.await
.unwrap();
assert_eq!(live, 2); // fixture session + the first login only
// No expected version (SSO): the session is created against whatever the current version is.
let sso = create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
user_token: &user.user_token,
maybe_expected_password_version: None,
ip_address: "127.0.0.1",
creation_type: UserWebSessionCreationType::DirectLogin,
mysql_executor: &db.pool,
}).await.unwrap();
assert!(sso.is_some());
}
@@ -16,8 +16,8 @@ use http_server_common::request::get_request_ip::get_request_ip;
use log::{info, warn};
use mysql_queries::queries::google_sign_in_accounts::get_google_sign_in_account_by_subject::get_google_sign_in_account;
use mysql_queries::queries::user_referrals::insert_user_referral::{insert_user_referral, InsertUserReferralArgs};
use mysql_queries::queries::users::user_sessions::create_user_session_with_transactor::create_user_session_with_transactor;
use mysql_queries::utils::transactor::Transactor;
use enums::by_table::user_sessions::user_web_session_creation_type::UserWebSessionCreationType;
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::{create_user_session_if_password_version, CreateUserSessionIfPasswordVersionArgs};
use sqlx::{Acquire, MySqlPool};
use tokens::tokens::user_sessions::UserSessionToken;
use tokens::tokens::users::UserToken;
@@ -244,15 +244,20 @@ pub async fn google_sso_handler(
let ip_address = get_request_ip(&http_request);
let session_token = create_user_session_with_transactor(
&user_token,
&ip_address,
Transactor::for_connection(&mut mysql_connection))
// NB: no password is verified here, so the version is read inside the insert, under the user's row lock.
let session_token = create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
user_token: &user_token,
maybe_expected_password_version: None,
ip_address: &ip_address,
creation_type: UserWebSessionCreationType::DirectLogin,
mysql_executor: &mut *mysql_connection,
})
.await
.map_err(|e| {
warn!("error creating user session: {:?}", e);
CommonWebError::from_anyhow_error(e)
})?;
CommonWebError::from_error(e)
})?
.ok_or(CommonWebError::NotAuthorized)?;
info!("new user session created");
@@ -24,7 +24,8 @@ use mysql_queries::queries::users::user::get::lookup_user_for_login_by_username:
use mysql_queries::queries::users::user_sessions::create_impersonated_user_session::{
create_impersonated_user_session, CreateImpersonatedUserSessionArgs,
};
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::create_user_session_if_password_version;
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::{create_user_session_if_password_version, CreateUserSessionIfPasswordVersionArgs};
use enums::by_table::user_sessions::user_web_session_creation_type::UserWebSessionCreationType;
use password::bcrypt_confirm_password::bcrypt_confirm_password;
use sqlx::MySqlPool;
use tokens::tokens::user_sessions::UserSessionToken;
@@ -164,8 +165,13 @@ pub async fn login_handler(
// Normal login path — password matched.
// NB: bound to the password_version we verified against, so a password reset that committed
// after the lookup cannot be followed by a session for the old password.
let token = match create_user_session_if_password_version(
&user.token, user.password_version, &ip_address, &**mysql_pool).await
let token = match create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
user_token: &user.token,
maybe_expected_password_version: Some(user.password_version),
ip_address: &ip_address,
creation_type: UserWebSessionCreationType::DirectLogin,
mysql_executor: &**mysql_pool,
}).await
{
Ok(Some(token)) => token.to_string(),
Ok(None) => {
@@ -163,18 +163,15 @@ pub async fn password_reset_redeem_handler(
};
// Revoked sessions would otherwise keep passing the Redis session cache until it expires.
match redis_ttl_cache.get_connection() {
Ok(mut redis) => {
for session_token in &revoked_session_tokens {
for key in [RedisCacheKeys::session_record_user(session_token), RedisCacheKeys::session_record_light(session_token)] {
if let Err(err) = redis.delete_from_cache(&key) {
warn!("failed to purge revoked session cache: {err}");
}
}
}
}
Err(err) => warn!("failed to purge revoked session cache (no redis connection): {err}"),
}
// A session check that read its row before the commit can still fill the cache after this first
// purge, so purge again after a delay longer than a cache fill takes; anything later than that
// is bounded by the cache TTL.
purge_session_cache(&redis_ttl_cache, &revoked_session_tokens);
let delayed_cache = redis_ttl_cache.get_ref().clone();
tokio::spawn(async move {
tokio::time::sleep(SESSION_CACHE_RECHECK_DELAY).await;
purge_session_cache(&delayed_cache, &revoked_session_tokens);
});
let create_session_result =
create_user_session(&transaction_and_state.reset_state.user_token.0, &ip_address, &mysql_pool).await;
@@ -221,3 +218,36 @@ pub async fn password_reset_redeem_handler(
.content_type("application/json")
.body(body))
}
/// Longer than a session check's DB read plus Redis write normally takes.
const SESSION_CACHE_RECHECK_DELAY: std::time::Duration = std::time::Duration::from_secs(5);
fn session_cache_keys(session_tokens: &[String]) -> Vec<String> {
session_tokens.iter()
.flat_map(|t| [RedisCacheKeys::session_record_user(t), RedisCacheKeys::session_record_light(t)])
.collect()
}
fn purge_session_cache(redis_ttl_cache: &RedisTtlCache, session_tokens: &[String]) {
match redis_ttl_cache.get_connection() {
Ok(mut redis) => {
for key in session_cache_keys(session_tokens) {
if let Err(err) = redis.delete_from_cache(&key) {
warn!("failed to purge revoked session cache: {err}");
}
}
}
Err(err) => warn!("failed to purge revoked session cache (no redis connection): {err}"),
}
}
#[cfg(test)]
mod tests {
use super::session_cache_keys;
#[test]
fn purges_both_cache_entries_for_every_revoked_session() {
let keys = session_cache_keys(&["a".to_string(), "b".to_string()]);
assert_eq!(keys, vec!["ses_user:a", "ses_light:a", "ses_user:b", "ses_light:b"]);
}
}