refactor: structure of an hexagonal architecture

Created a kernel crate to store models and future action implementations.
Will be useful to create admin cli.

lib/utils/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "utils"
+edition = "2021"
+
+[dependencies]
+anyhow = { workspace = true }
+argon2 = "0.5"
+base64 = "0.22"
+rand = "0.8.5"
+rand_core = { version = "0.6.4", features = ["std"] }

lib/utils/src/lib.rs

@@ -0,0 +1,67 @@
+use anyhow::{anyhow, Result, Context};
+use argon2::{
+    password_hash::{
+        rand_core::OsRng,
+        PasswordHash, PasswordHasher, PasswordVerifier, SaltString
+    },
+    Argon2
+};
+use base64::{prelude::BASE64_STANDARD, Engine};
+use rand::{distributions::Alphanumeric, thread_rng, Rng};
+
+pub fn get_password_hash(password: String) -> Result<(String, String)> {
+    let salt = SaltString::generate(&mut OsRng);
+
+    // Argon2 with default params (Argon2id v19)
+    let argon2 = Argon2::default();
+
+    // Hash password to PHC string ($argon2id$v=19$...)
+    match argon2.hash_password(password.as_bytes(), &salt) {
+        Ok(val) => Ok((salt.to_string(), val.to_string())),
+        Err(_) => Err(anyhow!("Failed to process password."))
+    }
+}
+
+pub fn verify_password_hash(password_hash: String, password: String) -> Result<()> {
+    let parsed_hash = match PasswordHash::new(&password_hash) {
+        Ok(val) => val,
+        Err(_) => {
+            return Err(anyhow!("Failed to parse password hash"));
+        }
+    };
+    match Argon2::default().verify_password(password.as_bytes(), &parsed_hash) {
+        Ok(()) => Ok(()),
+        Err(_) => Err(anyhow!("Failed to verify password."))
+    }
+}
+
+pub fn get_random_alphanumerical(length: usize) -> String {
+    thread_rng()
+        .sample_iter(&Alphanumeric)
+        .take(length)
+        .map(char::from)
+        .collect()
+}
+
+pub fn parse_basic_auth(header_value: &str) -> Result<(String, String)> {
+    let header_val_components: Vec<&str> = header_value.split(" ").collect();
+    let encoded_header_value: &str = header_val_components
+        .get(1)
+        .ok_or(anyhow!("Could not find encoded part of Authorization header value"))?;
+    let basic_auth_str: String = String::from_utf8(
+        BASE64_STANDARD
+            .decode(encoded_header_value)
+            .context("Could not decode base64 in Authorization header value.")?
+    )?;
+    let components: Vec<&str> = basic_auth_str.split(':').collect();
+
+    Ok((
+        components.first().ok_or(anyhow!("Expected username in encoded Authorization header value."))?.to_string(),
+        components.get(1).ok_or(anyhow!("Expected password in encoded Authorization header value."))?.to_string()
+    ))
+}
+
+pub fn encode_base64_picture(picture_bytes: Vec<u8>) -> String {
+    let encoded = BASE64_STANDARD.encode(picture_bytes);
+    return format!("data:image/*;base64,{}", encoded);
+}