Merge pull request #54 from Xila-Project/Feature/Login

Author: AlixANNERAUD

Cargo.toml

@@ -78,6 +78,7 @@ members = [
     "Modules/Executables/WASM",
     "Modules/Executables/Shell/Graphical",
     "Modules/Executables/Terminal",
+    "Modules/Authentication"
 ]
 exclude = [
     "Modules/Virtual_machine/Tests/WASM_test",

Modules/Authentication/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "Authentication"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+Virtual_file_system = { path = "../Virtual_file_system" }
+Users = { path = "../Users" }
+Task = { path = "../Task" }
+File_system = { path = "../File_system" }
+sha2 = { version = "0.10", features = ["asm"] }
+miniserde = "0.1.41"

Modules/Authentication/src/Error.rs

@@ -0,0 +1,116 @@
+use std::fmt::Display;
+
+pub type Result_type<T> = Result<T, Error_type>;
+
+#[derive(Debug, Clone)]
+pub enum Error_type {
+    Failed_to_get_current_task_identifier(Task::Error_type),
+    Failed_to_read_users_directory(File_system::Error_type),
+    Failed_to_get_user_file_path,
+    Failed_to_open_user_file(File_system::Error_type),
+    Failed_to_read_user_file(File_system::Error_type),
+    Failed_to_parse_user_file(miniserde::Error),
+    Failed_to_add_user(Users::Error_type),
+    Failed_to_get_new_user_identifier(Users::Error_type),
+    Failed_to_create_user(Users::Error_type),
+    Failed_to_write_user_file(File_system::Error_type),
+    Failed_to_read_group_directory(File_system::Error_type),
+    Failed_to_get_group_file_path,
+    Failed_to_open_group_file(File_system::Error_type),
+    Failed_to_read_group_file(File_system::Error_type),
+    Failed_to_parse_group_file(miniserde::Error),
+    Failed_to_add_group(Users::Error_type),
+    Failed_to_get_new_group_identifier(Users::Error_type),
+    Failed_to_create_group(Users::Error_type),
+    Failed_to_write_group_file(File_system::Error_type),
+    Invalid_password,
+    Failed_to_open_random_device(File_system::Error_type),
+    Failed_to_read_random_device(File_system::Error_type),
+    Failed_to_get_user_identifier(Users::Error_type),
+}
+
+impl Display for Error_type {
+    fn fmt(&self, Formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::Failed_to_get_current_task_identifier(Error) => {
+                write!(
+                    Formatter,
+                    "Failed to get current task identifier: {}",
+                    Error
+                )
+            }
+            Self::Failed_to_read_users_directory(Error) => {
+                write!(Formatter, "Failed to read users directory: {}", Error)
+            }
+            Self::Failed_to_get_user_file_path => {
+                write!(Formatter, "Failed to get user file path")
+            }
+            Self::Failed_to_read_user_file(Error) => {
+                write!(Formatter, "Failed to read user file: {}", Error)
+            }
+            Self::Failed_to_open_user_file(Error) => {
+                write!(Formatter, "Failed to open user file: {}", Error)
+            }
+            Self::Failed_to_parse_user_file(Error) => {
+                write!(Formatter, "Failed to parse user file: {}", Error)
+            }
+            Self::Failed_to_add_user(Error) => {
+                write!(Formatter, "Failed to add user: {}", Error)
+            }
+            Self::Failed_to_read_group_directory(Error) => {
+                write!(Formatter, "Failed to read group directory: {}", Error)
+            }
+            Self::Failed_to_get_group_file_path => {
+                write!(Formatter, "Failed to get group file path")
+            }
+            Self::Failed_to_open_group_file(Error) => {
+                write!(Formatter, "Failed to open group file: {}", Error)
+            }
+            Self::Failed_to_read_group_file(Error) => {
+                write!(Formatter, "Failed to read group file: {}", Error)
+            }
+            Self::Failed_to_parse_group_file(Error) => {
+                write!(Formatter, "Failed to parse group file: {}", Error)
+            }
+            Self::Failed_to_add_group(Error) => {
+                write!(Formatter, "Failed to add group: {}", Error)
+            }
+            Self::Invalid_password => {
+                write!(Formatter, "Invalid password")
+            }
+            Self::Failed_to_open_random_device(Error) => {
+                write!(Formatter, "Failed to open random device: {}", Error)
+            }
+            Self::Failed_to_read_random_device(Error) => {
+                write!(Formatter, "Failed to read random device: {}", Error)
+            }
+            Self::Failed_to_create_user(Error) => {
+                write!(Formatter, "Failed to create user: {}", Error)
+            }
+            Self::Failed_to_get_new_user_identifier(Error) => {
+                write!(Formatter, "Failed to get new user identifier: {}", Error)
+            }
+            Self::Failed_to_write_user_file(Error) => {
+                write!(Formatter, "Failed to write user file: {}", Error)
+            }
+            Self::Failed_to_get_new_group_identifier(Error) => {
+                write!(Formatter, "Failed to get new group identifier: {}", Error)
+            }
+            Self::Failed_to_create_group(Error) => {
+                write!(Formatter, "Failed to create group: {}", Error)
+            }
+            Self::Failed_to_write_group_file(Error) => {
+                write!(Formatter, "Failed to write group file: {}", Error)
+            }
+            Self::Failed_to_get_user_identifier(Error) => {
+                write!(Formatter, "Failed to get user identifier: {}", Error)
+            }
+        }
+    }
+}
+
+impl From<Task::Error_type> for Error_type {
+    fn from(Error: Task::Error_type) -> Self {
+        Self::Failed_to_get_current_task_identifier(Error)
+    }
+}

Modules/Authentication/src/Group.rs

@@ -0,0 +1,39 @@
+use miniserde::{Deserialize, Serialize};
+use Users::{
+    Group_identifier_inner_type, Group_identifier_type, User_identifier_inner_type,
+    User_identifier_type,
+};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct Group_type {
+    Identifier: Group_identifier_inner_type,
+    Name: String,
+    Users: Vec<User_identifier_inner_type>,
+}
+
+impl Group_type {
+    pub fn New(
+        Identifier: Group_identifier_inner_type,
+        Name: String,
+        Users: Vec<User_identifier_inner_type>,
+    ) -> Self {
+        Self {
+            Identifier,
+            Name,
+            Users,
+        }
+    }
+
+    pub fn Get_identifier(&self) -> Group_identifier_type {
+        Group_identifier_type::New(self.Identifier)
+    }
+
+    pub fn Get_name(&self) -> &str {
+        &self.Name
+    }
+
+    pub fn Get_users(&self) -> &[User_identifier_type] {
+        // Avoid to copy the vector since User_identifier_type is transparent to User_identifier_inner_type.
+        unsafe { core::mem::transmute(self.Users.as_slice()) }
+    }
+}

Modules/Authentication/src/User.rs

@@ -0,0 +1,68 @@
+use miniserde::{Deserialize, Serialize};
+use Users::{
+    Group_identifier_inner_type, Group_identifier_type, User_identifier_inner_type,
+    User_identifier_type,
+};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct User_type {
+    Identifier: User_identifier_inner_type,
+    Name: String,
+    Primary_group: Group_identifier_inner_type,
+    Hash: String,
+    Salt: String,
+}
+
+impl User_type {
+    pub fn New(
+        Identifier: User_identifier_inner_type,
+        Name: String,
+        Primary_group: Group_identifier_inner_type,
+        Hash: String,
+        Salt: String,
+    ) -> Self {
+        Self {
+            Identifier,
+            Name,
+            Primary_group,
+            Hash,
+            Salt,
+        }
+    }
+
+    pub fn Get_identifier(&self) -> User_identifier_type {
+        User_identifier_type::New(self.Identifier)
+    }
+
+    pub fn Get_primary_group(&self) -> Group_identifier_type {
+        Group_identifier_type::New(self.Primary_group)
+    }
+
+    pub fn Get_name(&self) -> &str {
+        &self.Name
+    }
+
+    pub fn Get_hash(&self) -> &str {
+        &self.Hash
+    }
+
+    pub fn Get_salt(&self) -> &str {
+        &self.Salt
+    }
+
+    pub fn Set_hash(&mut self, Hash: String) {
+        self.Hash = Hash;
+    }
+
+    pub fn Set_salt(&mut self, Salt: String) {
+        self.Salt = Salt;
+    }
+
+    pub fn Set_primary_group(&mut self, Primary_group: Group_identifier_inner_type) {
+        self.Primary_group = Primary_group;
+    }
+
+    pub fn Set_name(&mut self, Name: String) {
+        self.Name = Name;
+    }
+}