Skip to content

Commit b36bd85

Browse files
AlixANNERAUDAlixANNERAUD
committed
Refactor authentication
1 parent b67293e commit b36bd85

File tree

4 files changed

+327
-310
lines changed

4 files changed

+327
-310
lines changed

‎Modules/Authentication/src/Group.rs

+84
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,12 @@
11
use miniserde::{Deserialize, Serialize};
2+
use File_system::{Flags_type, Mode_type, Open_type, Path_owned_type, Path_type};
23
use Users::{
34
Group_identifier_inner_type, Group_identifier_type, User_identifier_inner_type,
45
User_identifier_type,
56
};
7+
use Virtual_file_system::{File_type, Virtual_file_system_type};
8+
9+
use crate::{Error_type, Group_folder_path, Result_type};
610

711
#[derive(Clone, Debug, Deserialize, Serialize)]
812
pub struct Group_type {
@@ -37,3 +41,83 @@ impl Group_type {
3741
unsafe { core::mem::transmute(self.Users.as_slice()) }
3842
}
3943
}
44+
45+
pub fn Get_group_file_path(Group_name: &str) -> Result_type<Path_owned_type> {
46+
Path_type::New(Group_folder_path)
47+
.to_owned()
48+
.Append(Group_name)
49+
.ok_or(Error_type::Failed_to_get_group_file_path)
50+
}
51+
52+
pub fn Read_group_file<'a>(
53+
Virtual_file_system: &'a Virtual_file_system_type<'a>,
54+
Buffer: &mut Vec<u8>,
55+
File: &str,
56+
) -> Result_type<Group_type> {
57+
let Group_file_path = Path_type::New(Group_folder_path)
58+
.to_owned()
59+
.Append(File)
60+
.ok_or(Error_type::Failed_to_get_group_file_path)?;
61+
62+
let Group_file = File_type::Open(
63+
Virtual_file_system,
64+
Group_file_path,
65+
Mode_type::Read_only.into(),
66+
)
67+
.map_err(Error_type::Failed_to_read_group_directory)?;
68+
69+
Buffer.clear();
70+
71+
Group_file
72+
.Read_to_end(Buffer)
73+
.map_err(Error_type::Failed_to_read_group_file)?;
74+
75+
miniserde::json::from_str(core::str::from_utf8(Buffer).unwrap())
76+
.map_err(Error_type::Failed_to_parse_group_file)
77+
}
78+
79+
pub fn Create_group<'a>(
80+
Virtual_file_system: &'a Virtual_file_system_type<'a>,
81+
Group_name: &str,
82+
Group_identifier: Option<Group_identifier_type>,
83+
) -> Result_type<Group_identifier_type> {
84+
let Users_manager = Users::Get_instance();
85+
86+
// - New group identifier if not provided.
87+
let Group_identifier = if let Some(Group_identifier) = Group_identifier {
88+
Group_identifier
89+
} else {
90+
Users_manager
91+
.Get_new_group_identifier()
92+
.map_err(Error_type::Failed_to_get_new_group_identifier)?
93+
};
94+
95+
// - Add it to the users manager.
96+
Users_manager
97+
.Add_group(Group_identifier, Group_name, &[])
98+
.map_err(Error_type::Failed_to_add_group)?;
99+
100+
// - Write group file.
101+
let Group = Group_type::New(
102+
Group_identifier.Into_inner(),
103+
Group_name.to_string(),
104+
vec![],
105+
);
106+
107+
let Group_file_path = Get_group_file_path(Group_name)?;
108+
109+
let Group_file = File_type::Open(
110+
Virtual_file_system,
111+
Group_file_path,
112+
Flags_type::New(Mode_type::Write_only, Some(Open_type::Create_only), None),
113+
)
114+
.map_err(Error_type::Failed_to_open_group_file)?;
115+
116+
let Group_json = miniserde::json::to_string(&Group);
117+
118+
Group_file
119+
.Write(Group_json.as_bytes())
120+
.map_err(Error_type::Failed_to_write_group_file)?;
121+
122+
Ok(Group_identifier)
123+
}

‎Modules/Authentication/src/Hash.rs

+38
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
use File_system::Mode_type;
2+
use Virtual_file_system::File_type;
3+
4+
use crate::{Error_type, Random_device_path, Result_type};
5+
6+
pub fn Generate_salt() -> Result_type<String> {
7+
let Random_file = File_type::Open(
8+
Virtual_file_system::Get_instance(),
9+
Random_device_path,
10+
Mode_type::Read_only.into(),
11+
)
12+
.map_err(Error_type::Failed_to_open_random_device)?;
13+
14+
let mut Buffer = [0_u8; 16];
15+
16+
Random_file
17+
.Read(&mut Buffer)
18+
.map_err(Error_type::Failed_to_read_random_device)?;
19+
20+
Buffer.iter_mut().for_each(|Byte| {
21+
*Byte = *Byte % 26 + 97;
22+
});
23+
24+
Ok(core::str::from_utf8(&Buffer).unwrap().to_string())
25+
}
26+
27+
pub fn Hash_password(Password: &str, Salt: &str) -> String {
28+
use sha2::Digest;
29+
30+
let mut Hasher = sha2::Sha512::new();
31+
32+
Hasher.update(Password.as_bytes());
33+
Hasher.update(Salt.as_bytes());
34+
35+
let Hash = Hasher.finalize();
36+
37+
format!("{:x}", Hash)
38+
}

‎Modules/Authentication/src/User.rs

+199
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,16 @@
11
use miniserde::{Deserialize, Serialize};
2+
use File_system::{Flags_type, Mode_type, Open_type, Path_owned_type, Path_type};
23
use Users::{
34
Group_identifier_inner_type, Group_identifier_type, User_identifier_inner_type,
45
User_identifier_type,
56
};
7+
use Virtual_file_system::{File_type, Virtual_file_system_type};
8+
9+
use crate::{
10+
Error_type,
11+
Hash::{Generate_salt, Hash_password},
12+
Result_type, Users_folder_path,
13+
};
614

715
#[derive(Clone, Debug, Deserialize, Serialize)]
816
pub struct User_type {
@@ -66,3 +74,194 @@ impl User_type {
6674
self.Name = Name;
6775
}
6876
}
77+
78+
pub fn Get_user_file_path(User_name: &str) -> Result_type<Path_owned_type> {
79+
Path_type::New(Users_folder_path)
80+
.to_owned()
81+
.Append(User_name)
82+
.ok_or(Error_type::Failed_to_get_user_file_path)
83+
}
84+
85+
pub fn Authenticate_user<'a>(
86+
Virtual_file_system: &'a Virtual_file_system_type<'a>,
87+
User_name: &str,
88+
Password: &str,
89+
) -> Result_type<User_identifier_type> {
90+
let Path = Get_user_file_path(User_name)?;
91+
92+
let User_file = File_type::Open(Virtual_file_system, Path, Mode_type::Read_only.into())
93+
.map_err(Error_type::Failed_to_open_user_file)?;
94+
95+
let mut Buffer = Vec::new();
96+
97+
User_file
98+
.Read_to_end(&mut Buffer)
99+
.map_err(Error_type::Failed_to_read_user_file)?;
100+
101+
let User: User_type = miniserde::json::from_str(core::str::from_utf8(&Buffer).unwrap())
102+
.map_err(Error_type::Failed_to_parse_user_file)?;
103+
104+
if Hash_password(Password, User.Get_salt()) == User.Get_hash() {
105+
Ok(User.Get_identifier())
106+
} else {
107+
Err(Error_type::Invalid_password)
108+
}
109+
}
110+
111+
pub fn Create_user<'a>(
112+
Virtual_file_system: &'a Virtual_file_system_type<'a>,
113+
User_name: &str,
114+
Password: &str,
115+
Primary_group: Group_identifier_type,
116+
User_identifier: Option<User_identifier_type>,
117+
) -> Result_type<User_identifier_type> {
118+
let Users_manager = Users::Get_instance();
119+
120+
// - New user identifier if not provided.
121+
let User_identifier = if let Some(User_identifier) = User_identifier {
122+
User_identifier
123+
} else {
124+
Users_manager
125+
.Get_new_user_identifier()
126+
.map_err(Error_type::Failed_to_get_new_user_identifier)?
127+
};
128+
129+
// - Add it to the users manager.
130+
Users_manager
131+
.Add_user(User_identifier, User_name, Primary_group)
132+
.map_err(Error_type::Failed_to_create_user)?;
133+
134+
// - Hash password.
135+
let Salt = Generate_salt()?;
136+
137+
let Hash = Hash_password(Password, &Salt);
138+
139+
// - Write user file.
140+
let User = User_type::New(
141+
User_identifier.Into_inner(),
142+
User_name.to_string(),
143+
Primary_group.Into_inner(),
144+
Hash,
145+
Salt,
146+
);
147+
148+
let User_file_path = Path_type::New(Users_folder_path)
149+
.to_owned()
150+
.Append(User_name)
151+
.ok_or(Error_type::Failed_to_get_user_file_path)?;
152+
153+
let User_file = File_type::Open(
154+
Virtual_file_system,
155+
User_file_path,
156+
Flags_type::New(Mode_type::Write_only, Some(Open_type::Create_only), None),
157+
)
158+
.map_err(Error_type::Failed_to_open_user_file)?;
159+
160+
let User_json = miniserde::json::to_string(&User);
161+
162+
User_file
163+
.Write(User_json.as_bytes())
164+
.map_err(Error_type::Failed_to_write_user_file)?;
165+
166+
Ok(User_identifier)
167+
}
168+
169+
pub fn Change_user_password<'a>(
170+
Virtual_file_system: &'a Virtual_file_system_type<'a>,
171+
User_name: &str,
172+
New_password: &str,
173+
) -> Result_type<()> {
174+
let Salt = Generate_salt()?;
175+
176+
let Hash = Hash_password(New_password, &Salt);
177+
178+
let User_file_path = Path_type::New(Users_folder_path)
179+
.to_owned()
180+
.Append(User_name)
181+
.ok_or(Error_type::Failed_to_get_user_file_path)?;
182+
183+
let User_file = File_type::Open(
184+
Virtual_file_system,
185+
User_file_path,
186+
Flags_type::New(Mode_type::Read_write, Some(Open_type::Truncate), None),
187+
)
188+
.map_err(Error_type::Failed_to_open_user_file)?;
189+
190+
let mut Buffer = Vec::new();
191+
192+
User_file
193+
.Read_to_end(&mut Buffer)
194+
.map_err(Error_type::Failed_to_read_user_file)?;
195+
196+
let mut User: User_type = miniserde::json::from_str(core::str::from_utf8(&Buffer).unwrap())
197+
.map_err(Error_type::Failed_to_parse_user_file)?;
198+
199+
User.Set_hash(Hash);
200+
User.Set_salt(Salt);
201+
202+
let User_json = miniserde::json::to_string(&User);
203+
204+
User_file
205+
.Write(User_json.as_bytes())
206+
.map_err(Error_type::Failed_to_write_user_file)?;
207+
208+
Ok(())
209+
}
210+
211+
pub fn Change_user_name<'a>(
212+
Virtual_file_system: &'a Virtual_file_system_type<'a>,
213+
Current_name: &str,
214+
New_name: &str,
215+
) -> Result_type<()> {
216+
let File_path = Get_user_file_path(Current_name)?;
217+
218+
let User_file = File_type::Open(
219+
Virtual_file_system,
220+
File_path,
221+
Flags_type::New(Mode_type::Read_write, Some(Open_type::Truncate), None),
222+
)
223+
.map_err(Error_type::Failed_to_open_user_file)?;
224+
225+
let mut Buffer = Vec::new();
226+
227+
User_file
228+
.Read_to_end(&mut Buffer)
229+
.map_err(Error_type::Failed_to_read_user_file)?;
230+
231+
let mut User: User_type = miniserde::json::from_str(core::str::from_utf8(&Buffer).unwrap())
232+
.map_err(Error_type::Failed_to_parse_user_file)?;
233+
234+
User.Set_name(New_name.to_string());
235+
236+
let User_json = miniserde::json::to_string(&User);
237+
238+
User_file
239+
.Write(User_json.as_bytes())
240+
.map_err(Error_type::Failed_to_write_user_file)?;
241+
242+
Ok(())
243+
}
244+
245+
pub fn Read_user_file<'a>(
246+
Virtual_file_system: &'a Virtual_file_system_type<'a>,
247+
Buffer: &mut Vec<u8>,
248+
File: &str,
249+
) -> Result_type<User_type> {
250+
let User_file_path = Get_user_file_path(File)?;
251+
252+
let User_file = File_type::Open(
253+
Virtual_file_system,
254+
User_file_path,
255+
Mode_type::Read_only.into(),
256+
)
257+
.map_err(Error_type::Failed_to_read_users_directory)?;
258+
259+
Buffer.clear();
260+
261+
User_file
262+
.Read_to_end(Buffer)
263+
.map_err(Error_type::Failed_to_read_user_file)?;
264+
265+
miniserde::json::from_str(core::str::from_utf8(Buffer).unwrap())
266+
.map_err(Error_type::Failed_to_parse_user_file)
267+
}

0 commit comments

Comments
 (0)