MiloTheFox/argon2-with-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

main.rs gelöscht

Browse source
This commit is contained in:
Milo 2024-09-07 11:44:21 +00:00
parent 3db77df5cd
commit cd80522952
1 changed files with 0 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

136
main.rs
View file

@ -1,136 +0,0 @@
use argon2::{password_hash::SaltString, Algorithm, Argon2, Params, PasswordHasher, Version};
use colored::Colorize;
use passwords::{analyzer, scorer, PasswordGenerator};
use rand_core::OsRng;
use rayon::prelude::*;
use zeroize::Zeroize;
mod errors;
use errors::{ArgonError, MyError};
// Configuration Constants
const MEMORY_COST: u32 = 50;
const TIME_COST: u32 = 2;
const PARALLELISM: u32 = 2;
const OUTPUT_LEN: usize = 32;
const NUMBER_OF_PASSWORDS: u32 = 50;
type PasswordWithScore = (String, f64);
fn main() -> Result<(), MyError> {
let argon2 = create_argon2();
// Generate and hash passwords in parallel
let results: Result<Vec<_>, _> = (0..NUMBER_OF_PASSWORDS)
.into_par_iter()
.map(|_| {
let password_gen = create_password_generator();
let (mut password, _) = generate_password(&password_gen)?;
let salt = SaltString::generate(&mut OsRng);
let hash_result = hash_password(&argon2, &password, &salt);
password.zeroize(); // Zeroize the password to prevent memory-based attacks
hash_result
})
.collect();
match results {
Ok(hashes) => {
hashes
.into_par_iter()
.for_each(|hash| println!("Hash output: {}", hash));
println!(
"{}",
"[LOG] All passwords have been hashed successfully".green()
);
Ok(())
}
Err(e) => Err(e),
}
}
fn create_argon2() -> Argon2<'static> {
let params = Params::new(MEMORY_COST, TIME_COST, PARALLELISM, Some(OUTPUT_LEN))
.expect("Failed to set Argon2 parameters");
Argon2::new(Algorithm::Argon2id, Version::V0x13, params)
}
fn hash_password(
argon2: &Argon2<'_>,
password: &str,
salt: &SaltString,
) -> Result<String, MyError> {
argon2
.hash_password(password.as_bytes(), salt)
.map_err(|source| MyError::HashingError {
source: ArgonError::from(errors::ArgonError(source)),
salt: salt.clone(),
})
.map(|hash| hash.to_string())
}
fn create_password_generator() -> PasswordGenerator {
PasswordGenerator {
length: 16,
numbers: true,
lowercase_letters: true,
uppercase_letters: true,
symbols: true,
spaces: false,
exclude_similar_characters: true,
strict: true,
}
}
fn generate_password(password_gen: &PasswordGenerator) -> Result<PasswordWithScore, MyError> {
let password = password_gen
.generate_one()
.map_err(|_| MyError::PasswordGenerationError)?;
let analyzed = analyzer::analyze(&password);
let score = scorer::score(&analyzed);
Ok((password, score))
}
#[cfg(test)]
mod tests {
use super::*;
use lazy_static::lazy_static;
lazy_static! {
static ref PASSWORDGENERATOR: PasswordGenerator = PasswordGenerator {
length: 16,
numbers: true,
lowercase_letters: true,
uppercase_letters: true,
symbols: true,
spaces: false,
exclude_similar_characters: true,
strict: true,
};
}
#[test]
fn test_generate_password() {
match generate_password(&PASSWORDGENERATOR) {
Ok((password, _score)) => {
assert!(password.len() == 16 && password.chars().all(|c| c.is_ascii_graphic()));
}
Err(e) => {
panic!("Password generation failed with error: {}", e);
}
}
}
#[test]
fn test_hash_password() {
let (mut password, _score) = match generate_password(&PASSWORDGENERATOR) {
Ok(result) => result,
Err(e) => panic!("Password generation failed with error: {}", e),
};
let argon2 = create_argon2();
let salt = SaltString::generate(&mut OsRng);
let result = argon2.hash_password(&password.as_bytes(), &salt);
assert!(result.is_ok());
password.zeroize();
}
}