block on hashing

ffplayout-api/src/api/routes.rs

@@ -32,6 +32,7 @@ use regex::Regex;
 use serde::{Deserialize, Serialize};
 use simplelog::*;
 use sqlx::{Pool, Sqlite};
+use tokio::task;
 
 use crate::db::{
     handles,
@@ -160,40 +161,48 @@ pub async fn login(pool: web::Data<Pool<Sqlite>>, credentials: web::Json<User>)
     let conn = pool.into_inner();
     match handles::select_login(&conn, &credentials.username).await {
         Ok(mut user) => {
-            let pass = user.password.clone();
+            let role = handles::select_role(&conn, &user.role_id.unwrap_or_default())
-            let hash = PasswordHash::new(&pass).unwrap();
+                .await
-            user.password = "".into();
+                .unwrap_or(Role::Guest);
 
-            if Argon2::default()
+            let res = task::spawn_blocking(move || {
-                .verify_password(credentials.password.as_bytes(), &hash)
+                let pass = user.password.clone();
-                .is_ok()
+                let hash = PasswordHash::new(&pass).unwrap();
-            {
+                user.password = "".into();
-                let role = handles::select_role(&conn, &user.role_id.unwrap_or_default())
-                    .await
-                    .unwrap_or(Role::Guest);
-                let claims = Claims::new(user.id, user.username.clone(), role.clone());
 
-                if let Ok(token) = create_jwt(claims) {
+                if Argon2::default()
-                    user.token = Some(token);
+                    .verify_password(credentials.password.as_bytes(), &hash)
-                };
+                    .is_ok()
+                {
+                    let claims = Claims::new(user.id, user.username.clone(), role.clone());
 
-                info!("user {} login, with role: {role}", credentials.username);
+                    if let Ok(token) = create_jwt(claims) {
+                        user.token = Some(token);
+                    };
 
-                web::Json(UserObj {
+                    info!("user {} login, with role: {role}", credentials.username);
-                    message: "login correct!".into(),
+
-                    user: Some(user),
+                    web::Json(UserObj {
-                })
+                        message: "login correct!".into(),
-                .customize()
+                        user: Some(user),
-                .with_status(StatusCode::OK)
+                    })
-            } else {
+                    .customize()
-                error!("Wrong password for {}!", credentials.username);
+                    .with_status(StatusCode::OK)
-                web::Json(UserObj {
+                } else {
-                    message: "Wrong password!".into(),
+                    error!("Wrong password for {}!", credentials.username);
-                    user: None,
+
-                })
+                    web::Json(UserObj {
-                .customize()
+                        message: "Wrong password!".into(),
-                .with_status(StatusCode::FORBIDDEN)
+                        user: None,
-            }
+                    })
+                    .customize()
+                    .with_status(StatusCode::FORBIDDEN)
+                }
+            })
+            .await
+            .unwrap();
+
+            res
         }
         Err(e) => {
             error!("Login {} failed! {e}", credentials.username);

ffplayout-api/src/db/handles.rs

@@ -8,6 +8,7 @@ use argon2::{
 use rand::{distributions::Alphanumeric, Rng};
 use simplelog::*;
 use sqlx::{migrate::MigrateDatabase, sqlite::SqliteQueryResult, Pool, Sqlite};
+use tokio::task;
 
 use crate::db::{
     db_pool,
@@ -243,17 +244,23 @@ pub async fn insert_user(
     conn: &Pool<Sqlite>,
     user: User,
 ) -> Result<SqliteQueryResult, sqlx::Error> {
-    let salt = SaltString::generate(&mut OsRng);
+    let password_hash = task::spawn_blocking(move || {
-    let password_hash = Argon2::default()
+        let salt = SaltString::generate(&mut OsRng);
-        .hash_password(user.password.clone().as_bytes(), &salt)
+        let hash = Argon2::default()
-        .unwrap();
+            .hash_password(user.password.clone().as_bytes(), &salt)
+            .unwrap();
+
+        hash.to_string()
+    })
+    .await
+    .unwrap();
 
     let query = "INSERT INTO user (mail, username, password, role_id) VALUES($1, $2, $3, $4)";
 
     sqlx::query(query)
         .bind(user.mail)
         .bind(user.username)
-        .bind(password_hash.to_string())
+        .bind(password_hash)
         .bind(user.role_id)
         .execute(conn)
         .await