139 lines
3.8 KiB
Rust
139 lines
3.8 KiB
Rust
use crypto_utils::sha::{Algorithm, CryptographicHash};
|
|
use uuid::Uuid;
|
|
|
|
/// SQL user table
|
|
#[derive(Debug, sqlx::FromRow)]
|
|
pub struct User {
|
|
/// UUID of the user
|
|
pub id: String,
|
|
/// Username
|
|
pub username: String,
|
|
/// Encryped user password
|
|
pub password: String,
|
|
}
|
|
|
|
impl User {
|
|
/// The function create a unique user UUID and create SHA-512 hash from salted user password
|
|
/// and returns the [User] type.
|
|
///
|
|
/// **Note: This doesn't create a user in the database!**
|
|
///
|
|
/// ```
|
|
/// use homedisk_types::database::User;
|
|
///
|
|
/// let user = User::new("medzik", "SuperSecretPassword123!");
|
|
///
|
|
/// # assert_eq!(user.username, "medzik")
|
|
/// ```
|
|
pub fn new(username: &str, password: &str) -> Self {
|
|
// change username to lowercase
|
|
let username = username.to_lowercase();
|
|
|
|
// salting the password
|
|
let password = format!("{username}${password}");
|
|
|
|
// hash password using SHA-512 and encode it to String from Vec<u8>
|
|
let password = hex::encode(CryptographicHash::hash(
|
|
Algorithm::SHA512,
|
|
password.as_bytes(),
|
|
));
|
|
|
|
// generate a user UUID
|
|
let id_sha1 = CryptographicHash::hash(
|
|
Algorithm::SHA1,
|
|
(format!("{username}${password}")).as_bytes(),
|
|
);
|
|
let id = Uuid::new_v5(&Uuid::NAMESPACE_X500, &id_sha1).to_string();
|
|
|
|
// return `User`
|
|
Self {
|
|
id,
|
|
username,
|
|
password,
|
|
}
|
|
}
|
|
|
|
/// The function returns the directory where the user file is located.
|
|
///
|
|
/// ```
|
|
/// use homedisk_types::database::User;
|
|
///
|
|
/// let user = User::new("medzik", "whatever");
|
|
///
|
|
/// let dir = user.user_dir("/storage"); // will return `/storage/medzik`
|
|
///
|
|
/// assert_eq!(dir, "/storage/medzik")
|
|
/// ```
|
|
pub fn user_dir(&self, storage: &str) -> String {
|
|
// get a user storage path
|
|
let path = format!(
|
|
"{path}/{username}",
|
|
path = storage,
|
|
username = self.username,
|
|
);
|
|
|
|
// return user storage path
|
|
path
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crypto_utils::sha::{Algorithm, CryptographicHash};
|
|
|
|
use super::User;
|
|
|
|
/// Check if the id is reproducable
|
|
#[test]
|
|
fn check_id_reproducable() {
|
|
// example user data
|
|
let username = "test";
|
|
let password = "password";
|
|
|
|
let user_a = User::new(username, password);
|
|
let user_b = User::new(username, password);
|
|
|
|
assert_eq!(user_a.id, user_b.id)
|
|
}
|
|
|
|
/// Check if the username is in lowercase
|
|
#[test]
|
|
fn check_username_is_in_lowercase() {
|
|
// example user data
|
|
let username = "mEDZIk";
|
|
let password = "password";
|
|
|
|
// username in lowercase (expected username)
|
|
let username_expected = "medzik";
|
|
|
|
// create a new `User` type
|
|
let user = User::new(username, password);
|
|
|
|
// username validation with expected username
|
|
assert_eq!(user.username, username_expected)
|
|
}
|
|
|
|
/// Check that the password is a checksum with a salt
|
|
#[test]
|
|
fn check_if_password_is_hashed_and_salted() {
|
|
// example user data
|
|
let username = "username";
|
|
let password = "password";
|
|
|
|
// create a new `User` type
|
|
let user = User::new(username, password);
|
|
|
|
// expected password salt (string)
|
|
let password_expected_salt = format!("{username}${password}");
|
|
|
|
// expected password (hashed)
|
|
let password_expected = hex::encode(CryptographicHash::hash(
|
|
Algorithm::SHA512,
|
|
password_expected_salt.as_bytes(),
|
|
));
|
|
|
|
// password validation with expected password salt
|
|
assert_eq!(user.password, password_expected)
|
|
}
|
|
}
|