130 lines
No EOL
4.6 KiB
Rust
130 lines
No EOL
4.6 KiB
Rust
// Libraries
|
|
use bincode;
|
|
use rand::Rng;
|
|
use serde::{Serialize, Deserialize};
|
|
use crate::{interface, resource, secure};
|
|
|
|
|
|
// Structs
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct Password {
|
|
pub name: String,
|
|
pub user: String,
|
|
pub phrase: String,
|
|
}
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct Manager{
|
|
passwords: Vec<Password>,
|
|
key: String
|
|
}
|
|
|
|
// Implementations
|
|
impl Manager {
|
|
// Constructors
|
|
pub fn init(key: String) -> Self {
|
|
let mut manager: Manager = Manager { passwords: vec![], key: key };
|
|
|
|
if resource::ResourceFileBin::exists("res/manager.dat") {
|
|
manager.load();
|
|
}
|
|
|
|
return manager;
|
|
}
|
|
|
|
// Functions
|
|
fn save(&self) {
|
|
// Going through each password and encrypting them
|
|
let mut enc_manager: Manager = Manager { passwords: vec![], key: String::new() };
|
|
|
|
for pla_password in &self.passwords {
|
|
enc_manager.passwords.push(Password {
|
|
name: secure::Secure::encrypt(pla_password.name.clone(), self.key.clone()),
|
|
user: secure::Secure::encrypt(pla_password.user.clone(), self.key.clone()),
|
|
phrase: secure::Secure::encrypt(pla_password.phrase.clone(), self.key.clone())
|
|
});
|
|
}
|
|
|
|
// Turning the manager into binary data
|
|
let manager_binary: Vec<u8> = bincode::serialize(&enc_manager).expect("Failed to serialize manager");
|
|
|
|
// Saving via Binary Reader
|
|
resource::ResourceFileBin::write("res/manager.dat", manager_binary);
|
|
|
|
// Message:
|
|
println!("{}[Saved]{}", interface::COLOR_GREEN, interface::COLOR_RESET);
|
|
}
|
|
fn load(&mut self) {
|
|
// Saving via Binary Reader
|
|
let content: resource::ResourceFileBin = resource::ResourceFileBin::read("res/manager.dat");
|
|
|
|
// Turning the manager into binary data
|
|
let manager: Manager = bincode::deserialize(&content.content).expect("Failed to serialize manager");
|
|
|
|
// Decrypt all passwords
|
|
for enc_password in manager.passwords {
|
|
self.passwords.push(Password {
|
|
name: secure::Secure::decrypt(enc_password.name.clone(), self.key.clone()),
|
|
user: secure::Secure::decrypt(enc_password.user.clone(), self.key.clone()),
|
|
phrase: secure::Secure::decrypt(enc_password.phrase.clone(), self.key.clone())
|
|
});
|
|
}
|
|
|
|
// Message:
|
|
println!("{}[Loaded]{}", interface::COLOR_GREEN, interface::COLOR_RESET);
|
|
}
|
|
|
|
pub fn password_generate(length: u32, numbers: bool, special: bool) -> String {
|
|
// Variables
|
|
let mut result: String = String::new();
|
|
let mut possible_characters: String = String::new();
|
|
|
|
// Making lists of possibilities
|
|
let ascii_letters: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
let ascii_numbers: &str = "1234567890";
|
|
let ascii_special: &str = "!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~";
|
|
|
|
// Putting everything together!
|
|
possible_characters += ascii_letters;
|
|
if numbers {possible_characters += ascii_numbers;}
|
|
if special {possible_characters += ascii_special;}
|
|
|
|
// Creating the password!
|
|
for _ in 0..length {
|
|
let rand_index: usize = rand::thread_rng().gen_range(0..=possible_characters.len()-1);
|
|
let rand_character: char = possible_characters.chars().nth(rand_index).unwrap();
|
|
result += &rand_character.to_string();
|
|
}
|
|
|
|
// Giving back the result
|
|
return result;
|
|
}
|
|
pub fn password_create(&mut self, name: String, user: String, pass: String) {
|
|
// Create the password object
|
|
let new_password: Password = Password{name: name, user: user, phrase: pass};
|
|
|
|
// Adding it to our list
|
|
self.passwords.push(new_password);
|
|
|
|
// Saving the password manager
|
|
self.save();
|
|
}
|
|
pub fn password_view(&mut self, name: String) -> (bool, Password) {
|
|
// Variables
|
|
let mut success: bool = false;
|
|
let mut selected_password: Password = Password { name: String::new(), user: String::new(), phrase: String::new() };
|
|
|
|
// Getting the right password
|
|
for c_pass in &self.passwords {
|
|
success = name.to_lowercase() == c_pass.name.to_lowercase();
|
|
if success {
|
|
selected_password.name = c_pass.name.clone();
|
|
selected_password.user = c_pass.user.clone();
|
|
selected_password.phrase = c_pass.phrase.clone();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Returning the password
|
|
return (success, selected_password);
|
|
}
|
|
} |