Bump argon2 (#12)
Release Tagging / release (push) Successful in 25s
soaricarus_auth Build / Check (push) Successful in 28s
soaricarus_auth Build / Rustfmt (push) Successful in 21s
soaricarus_auth Build / Test Suite (push) Successful in 43s
soaricarus_auth Build / Clippy (push) Successful in 48s
soaricarus_auth Build / build (push) Successful in 2m6s
soaricarus_auth Build / Rustfmt (pull_request) Successful in 21s
soaricarus_auth Build / Clippy (pull_request) Successful in 28s
soaricarus_auth Build / build (pull_request) Successful in 47s
soaricarus_auth Build / Check (pull_request) Successful in 2m22s
soaricarus_auth Build / Test Suite (pull_request) Successful in 2m42s

Reviewed-on: http://git.kundeng.us/phoenix/soaricarus_auth/pulls/12
This commit was merged in pull request #12.
This commit is contained in:
phoenix committed 2026-11-01 19:18:31 -05:00
1 parent de4c698836
commit 778be1f4a2
5 files changed
+89 -76

No files matched your search

+52 -26
View File
@@ -1,17 +1,39 @@
use argon2::{
Argon2, // The Argon2 algorithm struct
PasswordVerifier,
password_hash::{
PasswordHasher,
SaltString,
rand_core::OsRng, // Secure random number generator
},
};
use argon2::{Argon2, PasswordVerifier, password_hash::PasswordHasher};
use rand::distr::SampleString;
pub struct SaltString {
pub raw: String,
pub in_bytes: Vec<u8>,
}
impl SaltString {
pub fn generate() -> Result<SaltString, argon2::Error> {
let mut rng = rand::rng();
let s = rand::distr::Alphanumeric.sample_string(&mut rng, 20);
let salt_string = SaltString {
raw: s.to_string(),
in_bytes: s.into_bytes(),
};
Ok(salt_string)
}
pub fn from_b64(s: &str) -> Result<SaltString, argon2::password_hash::Error> {
let salt_string = SaltString {
raw: (&s).to_string(),
in_bytes: s.to_string().into_bytes(),
};
Ok(salt_string)
}
pub fn to_string(&self) -> &String {
&self.raw
}
}
pub fn generate_salt() -> Result<SaltString, argon2::Error> {
// Generate a random salt
// SaltString::generate uses OsRng internally for cryptographic security
Ok(SaltString::generate(&mut OsRng))
SaltString::generate()
}
pub fn get_salt(s: &str) -> Result<SaltString, argon2::password_hash::Error> {
@@ -24,14 +46,11 @@ pub fn hash_password(
) -> Result<String, argon2::password_hash::Error> {
let password_bytes = password.as_bytes();
// Create an Argon2 instance with default parameters (recommended)
// You could customize parameters here if needed, but defaults are strong
let argon2 = Argon2::default();
// Hash the password with the salt
// The output is a PasswordHash string format that includes algorithm, version,
// parameters, salt, and the hash itself.
Ok(argon2.hash_password(password_bytes, salt)?.to_string())
Ok(argon2
.hash_password_with_salt(password_bytes, &salt.in_bytes)?
.to_string())
}
pub fn verify_password(
@@ -48,9 +67,9 @@ pub fn verify_password(
// Verify the password against the parsed hash
// This automatically uses the correct salt and parameters embedded in `parsed_hash`
match Argon2::default().verify_password(password_bytes, &parsed_hash) {
Ok(()) => Ok(true), // Passwords match
Err(argon2::password_hash::Error::Password) => Ok(false), // Passwords don't match
Err(e) => Err(e), // Some other error occurred (e.g., invalid hash format)
Ok(()) => Ok(true), // Passwords match
Err(argon2::password_hash::Error::PasswordInvalid) => Ok(false), // Passwords don't match
Err(e) => Err(e), // Some other error occurred (e.g., invalid hash format)
}
}
@@ -58,10 +77,15 @@ pub fn verify_password(
mod tests {
use super::*;
pub const TEST_PASSWORD: &str = "somethingrandom";
pub const TEST_WRONG_PASSWORD: &str = "Differentanotherlevel";
#[test]
fn test_hash_password() {
let some_password = String::from("somethingrandom");
match hash_password(&some_password, &generate_salt().unwrap()) {
let some_password = String::from(TEST_PASSWORD);
let salt = generate_salt().unwrap();
match hash_password(&some_password, &salt) {
Ok(p) => match verify_password(&some_password, p.clone()) {
Ok(res) => {
assert_eq!(res, true);
@@ -78,8 +102,10 @@ mod tests {
#[test]
fn test_wrong_password() {
let some_password = String::from("somethingrandom");
match hash_password(&some_password, &generate_salt().unwrap()) {
let some_password = String::from(TEST_PASSWORD);
let salt = generate_salt().unwrap();
match hash_password(&some_password, &salt) {
Ok(p) => {
match verify_password(&some_password, p.clone()) {
Ok(res) => {
@@ -89,7 +115,7 @@ mod tests {
assert!(false, "Error: {:?}", err.to_string());
}
}
let wrong_password = String::from("Differentanotherlevel");
let wrong_password = String::from(TEST_WRONG_PASSWORD);
let result = verify_password(&wrong_password, p.clone()).unwrap();
assert_eq!(false, result, "Passwords should not match");
}