Password Authentication

$argon2id$v=19$m=19456,t=2,p=1$k3Vw5Z0YbqJkF1x0yGvXQg$9mT0kZ4o3f...

use argon2::{
    Argon2, Params,
    password_hash::{PasswordHasher, PasswordVerifier, phc::PasswordHash},
};

/// Hashes a password into a PHC string with a fresh random salt.
pub fn hash_password(password: &str) -> Result<String, argon2::password_hash::Error> {
    Ok(Argon2::default().hash_password(password.as_bytes())?.to_string())
}

/// Verifies a password; also reports whether the stored hash uses outdated parameters.
pub fn verify_password(password: &str, phc: &str) -> (bool, bool) {
    let Ok(parsed) = PasswordHash::new(phc) else { return (false, false) };
    let ok = Argon2::default().verify_password(password.as_bytes(), &parsed).is_ok();
    let current = Params::default();
    let outdated = Params::try_from(&parsed).map_or(true, |p| {
        (p.m_cost(), p.t_cost(), p.p_cost()) != (current.m_cost(), current.t_cost(), current.p_cost())
    });
    (ok, outdated)
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let phc = hash_password("correct horse battery staple")?;
    println!("{phc}");
    println!("{:?}", verify_password("correct horse battery staple", &phc)); // (true, false)
    println!("{:?}", verify_password("Tr0ub4dor&3", &phc)); // (false, false)
    Ok(())
}

use argon2::{Argon2, password_hash::PasswordHasher};

async fn hash_off_thread(password: String) -> Result<String, &'static str> {
    tokio::task::spawn_blocking(move || {
        Argon2::default().hash_password(password.as_bytes()).map(|h| h.to_string()).map_err(|_| "hashing failed")
    })
    .await
    .map_err(|_| "hashing task panicked")?
}

#[tokio::main]
async fn main() {
    let started = std::time::Instant::now();
    let phc = hash_off_thread("correct horse battery staple".to_owned()).await.expect("hash");
    println!("{} chars in {:?}", phc.len(), started.elapsed());
}

use std::collections::HashMap;
use std::sync::{Arc, RwLock};

use argon2::{
    Argon2,
    password_hash::{PasswordHasher, PasswordVerifier, phc::PasswordHash},
};
use axum::{
    Form, Router,
    http::StatusCode,
    response::{IntoResponse, Redirect},
    routing::{get, post},
};
use axum_login::{AuthManagerLayerBuilder, AuthSession, AuthUser, AuthnBackend, UserId, login_required};
use serde::Deserialize;
use tower_sessions::{MemoryStore, SessionManagerLayer};

// ---------- user and backend ----------
#[derive(Clone)]
pub struct User {
    id: i64,
    username: String,
    password_hash: String, // never serialised, never returned
}

impl std::fmt::Debug for User {
    // a derived Debug would print the hash into logs
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("User").field("id", &self.id).field("username", &self.username).finish_non_exhaustive()
    }
}

impl AuthUser for User {
    type Id = i64;
    fn id(&self) -> i64 {
        self.id
    }
    fn session_auth_hash(&self) -> &[u8] {
        self.password_hash.as_bytes()
    }
}

#[derive(Clone, Deserialize)]
pub struct Credentials {
    username: String,
    password: String,
}

#[derive(Clone, Default)]
pub struct Backend {
    users: Arc<RwLock<HashMap<String, User>>>, // a `users` table in the real application
}

#[derive(Debug, thiserror::Error)]
pub enum AuthError {
    #[error("hashing task failed")]
    Task,
}

/// A valid hash of a random password, verified against when the user does not exist,
/// so that unknown and known usernames take the same time.
static DUMMY_HASH: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
    Argon2::default().hash_password(b"dummy password for timing").expect("hash").to_string()
});

impl AuthnBackend for Backend {
    type User = User;
    type Credentials = Credentials;
    type Error = AuthError;

    async fn authenticate(&self, creds: Credentials) -> Result<Option<User>, AuthError> {
        let user = self.users.read().expect("lock").get(&creds.username).cloned();
        let stored = user.as_ref().map_or_else(|| DUMMY_HASH.clone(), |u| u.password_hash.clone());
        let valid = tokio::task::spawn_blocking(move || {
            PasswordHash::new(&stored)
                .is_ok_and(|parsed| Argon2::default().verify_password(creds.password.as_bytes(), &parsed).is_ok())
        })
        .await
        .map_err(|_| AuthError::Task)?;
        Ok(user.filter(|_| valid))
    }

    async fn get_user(&self, id: &UserId<Self>) -> Result<Option<User>, AuthError> {
        Ok(self.users.read().expect("lock").values().find(|u| u.id == *id).cloned())
    }
}

type Auth = AuthSession<Backend>;

// ---------- out-of-band notifications (stubs) ----------
/// Stub: queue a "someone tried to register with your address" email with a password-reset link
/// (an outbox table or a job queue in production). Never tell the HTTP client.
async fn notify_existing_account(username: String) {
    let _ = username;
    tracing::debug!("registration attempt for an existing account; owner notified by email");
}

/// Stub: queue the welcome/confirmation email for a new account.
async fn send_welcome(username: String) {
    let _ = username;
    tracing::debug!("new account; confirmation email queued");
}

/// The same answer whether or not the address was already registered.
const REGISTERED: &str = "check your email to finish signing up\n";

// ---------- handlers ----------
async fn register(auth: Auth, Form(creds): Form<Credentials>) -> Result<(StatusCode, &'static str), StatusCode> {
    if creds.password.chars().count() < 12 {
        return Err(StatusCode::UNPROCESSABLE_ENTITY); // OWASP: length over complexity rules
    }
    let password = creds.password.clone();
    let hash = tokio::task::spawn_blocking(move || {
        Argon2::default().hash_password(password.as_bytes()).map(|h| h.to_string())
    })
    .await
    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    // the hash above is computed in both cases, so both branches take the same time
    let already_registered = {
        let mut users = auth.backend.users.write().expect("lock");
        if users.contains_key(&creds.username) {
            true
        } else {
            let id = users.len() as i64 + 1;
            users.insert(creds.username.clone(), User { id, username: creds.username.clone(), password_hash: hash });
            false
        }
    };
    // the difference only reaches the mailbox, never the response (no 409 Conflict)
    if already_registered {
        tokio::spawn(notify_existing_account(creds.username));
    } else {
        tokio::spawn(send_welcome(creds.username));
    }
    Ok((StatusCode::ACCEPTED, REGISTERED))
}

async fn login(mut auth: Auth, Form(creds): Form<Credentials>) -> impl IntoResponse {
    match auth.authenticate(creds).await {
        Ok(Some(user)) => match auth.login(&user).await {
            Ok(()) => Redirect::to("/account").into_response(),
            Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
        },
        // one message for "no such user" and "wrong password"
        Ok(None) => (StatusCode::UNAUTHORIZED, "invalid username or password\n").into_response(),
        Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
    }
}

async fn logout(mut auth: Auth) -> impl IntoResponse {
    match auth.logout().await {
        Ok(_) => Redirect::to("/").into_response(),
        Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
    }
}

async fn account(auth: Auth) -> String {
    let user = auth.user.expect("login_required! guarantees a user");
    format!("signed in as {}\n", user.username)
}

#[tokio::main]
async fn main() {
    let sessions = SessionManagerLayer::new(MemoryStore::default()).with_secure(false); // dev only
    let auth_layer = AuthManagerLayerBuilder::new(Backend::default(), sessions).build();

    let app = Router::new()
        .route("/account", get(account))
        .route_layer(login_required!(Backend, login_url = "/login"))
        .route("/register", post(register))
        .route("/login", post(login))
        .route("/logout", post(logout))
        .layer(auth_layer);
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

$ curl -s -w '%{http_code}\n' -d 'username=ursula@bookshelf.example&password=correct horse battery staple' localhost:3000/register
check your email to finish signing up
202
$ curl -s -w '%{http_code}\n' -d "username=ursula@bookshelf.example&password=$(openssl rand -hex 12)" localhost:3000/register
check your email to finish signing up
202
$ curl -s -c jar -o /dev/null -w '%{http_code}\n' -d 'username=ursula@bookshelf.example&password=correct horse battery staple' localhost:3000/login
303
$ curl -s -b jar localhost:3000/account
signed in as ursula@bookshelf.example
$ curl -s -d 'username=nobody&password=whatever-password' localhost:3000/login
invalid username or password
$ curl -si localhost:3000/account | grep -i location
location: /login?next=%2Faccount