diff --git a/Cargo.toml b/Cargo.toml index a5e6dd9..5f7c271 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,4 +14,4 @@ crate-type = ["dylib"] [dependencies] libc = "0.2.146" -cas-lib = "0.2.6" \ No newline at end of file +cas-lib = "0.2.45" \ No newline at end of file diff --git a/src/digital_signature.rs b/src/digital_signature.rs index 29bf0ab..9de4105 100644 --- a/src/digital_signature.rs +++ b/src/digital_signature.rs @@ -18,9 +18,9 @@ pub struct SHARSADigitalSignatureResult { #[repr(C)] pub struct SHAED25519DalekDigitalSignatureResult { - pub public_key: *mut c_uchar, + pub public_key: *mut u8, pub public_key_length: usize, - pub signature_raw_ptr: *mut c_uchar, + pub signature_raw_ptr: *mut u8, pub signature_length: usize, } @@ -65,10 +65,11 @@ pub extern "C" fn sha_512_rsa_digital_signature_threadpool( if rsa_key_size != 1024 && rsa_key_size != 2048 && rsa_key_size != 4096 { panic!("Not a valid RSA key length"); } - let result = ::digital_signature_rsa_threadpool( - rsa_key_size as u32, - data_to_sign_slice, - ); + let result = + ::digital_signature_rsa_threadpool( + rsa_key_size as u32, + data_to_sign_slice, + ); let mut signed_data = result.signature; let capacity = signed_data.capacity(); signed_data.reserve_exact(capacity); @@ -123,10 +124,11 @@ pub extern "C" fn sha_256_rsa_digital_signature_threadpool( if rsa_key_size != 1024 && rsa_key_size != 2048 && rsa_key_size != 4096 { panic!("Not a valid RSA key length"); } - let result = ::digital_signature_rsa_threadpool( - rsa_key_size as u32, - data_to_sign_slice, - ); + let result = + ::digital_signature_rsa_threadpool( + rsa_key_size as u32, + data_to_sign_slice, + ); let mut signed_data = result.signature; let capacity = signed_data.capacity(); signed_data.reserve_exact(capacity); @@ -280,26 +282,29 @@ pub extern "C" fn sha512_ed25519_digital_signature( let data_to_sign_slice = unsafe { assert!(!data_to_sign.is_null()); std::slice::from_raw_parts(data_to_sign, data_length) - } - .to_vec(); + }; let result = ::digital_signature_ed25519( data_to_sign_slice, ); - let mut public_key = result.public_key; - let public_key_capacity = public_key.capacity(); - public_key.reserve_exact(public_key_capacity); - let mut signature = result.signature; - let signature_capacity = signature.capacity(); - signature.reserve_exact(signature_capacity); + let public_key = result.public_key; + let public_key_pair_ptr = unsafe { + let ptr = libc::malloc(public_key.len()) as *mut u8; + std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len()); + ptr + }; + let signature = result.signature; + let signature_ptr = unsafe { + let ptr = libc::malloc(signature.len()) as *mut u8; + std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len()); + ptr + }; let result = SHAED25519DalekDigitalSignatureResult { - public_key: public_key.as_mut_ptr(), + public_key: public_key_pair_ptr, public_key_length: public_key.len(), - signature_raw_ptr: signature.as_mut_ptr(), + signature_raw_ptr: signature_ptr, signature_length: signature.len(), }; - std::mem::forget(public_key); - std::mem::forget(signature); result } @@ -311,26 +316,29 @@ pub extern "C" fn sha512_ed25519_digital_signature_threadpool( let data_to_sign_slice = unsafe { assert!(!data_to_sign.is_null()); std::slice::from_raw_parts(data_to_sign, data_length) - } - .to_vec(); + }; let result = ::digital_signature_ed25519_threadpool( data_to_sign_slice, ); - let mut public_key = result.public_key; - let public_key_capacity = public_key.capacity(); - public_key.reserve_exact(public_key_capacity); - let mut signature = result.signature; - let signature_capacity = signature.capacity(); - signature.reserve_exact(signature_capacity); + let public_key = result.public_key; + let public_key_pair_ptr = unsafe { + let ptr = libc::malloc(public_key.len()) as *mut u8; + std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len()); + ptr + }; + let signature = result.signature; + let signature_ptr = unsafe { + let ptr = libc::malloc(signature.len()) as *mut u8; + std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len()); + ptr + }; let result = SHAED25519DalekDigitalSignatureResult { - public_key: public_key.as_mut_ptr(), + public_key: public_key_pair_ptr, public_key_length: public_key.len(), - signature_raw_ptr: signature.as_mut_ptr(), + signature_raw_ptr: signature_ptr, signature_length: signature.len(), }; - std::mem::forget(public_key); - std::mem::forget(signature); result } @@ -342,26 +350,29 @@ pub extern "C" fn sha256_ed25519_digital_signature( let data_to_sign_slice = unsafe { assert!(!data_to_sign.is_null()); std::slice::from_raw_parts(data_to_sign, data_length) - } - .to_vec(); + }; let result = ::digital_signature_ed25519( data_to_sign_slice, ); - let mut public_key = result.public_key; - let public_key_capacity = public_key.capacity(); - public_key.reserve_exact(public_key_capacity); - let mut signature = result.signature; - let signature_capacity = signature.capacity(); - signature.reserve_exact(signature_capacity); + let public_key = result.public_key; + let public_key_pair_ptr = unsafe { + let ptr = libc::malloc(public_key.len()) as *mut u8; + std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len()); + ptr + }; + let signature = result.signature; + let signature_ptr = unsafe { + let ptr = libc::malloc(signature.len()) as *mut u8; + std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len()); + ptr + }; let result = SHAED25519DalekDigitalSignatureResult { - public_key: public_key.as_mut_ptr(), + public_key: public_key_pair_ptr, public_key_length: public_key.len(), - signature_raw_ptr: signature.as_mut_ptr(), + signature_raw_ptr: signature_ptr, signature_length: signature.len(), }; - std::mem::forget(public_key); - std::mem::forget(signature); result } @@ -373,26 +384,29 @@ pub extern "C" fn sha256_ed25519_digital_signature_threadpool( let data_to_sign_slice = unsafe { assert!(!data_to_sign.is_null()); std::slice::from_raw_parts(data_to_sign, data_length) - } - .to_vec(); + }; let result = ::digital_signature_ed25519_threadpool( data_to_sign_slice, ); - let mut public_key = result.public_key; - let public_key_capacity = public_key.capacity(); - public_key.reserve_exact(public_key_capacity); - let mut signature = result.signature; - let signature_capacity = signature.capacity(); - signature.reserve_exact(signature_capacity); + let public_key = result.public_key; + let public_key_pair_ptr = unsafe { + let ptr = libc::malloc(public_key.len()) as *mut u8; + std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len()); + ptr + }; + let signature = result.signature; + let signature_ptr = unsafe { + let ptr = libc::malloc(signature.len()) as *mut u8; + std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len()); + ptr + }; let result = SHAED25519DalekDigitalSignatureResult { - public_key: public_key.as_mut_ptr(), + public_key: public_key_pair_ptr, public_key_length: public_key.len(), - signature_raw_ptr: signature.as_mut_ptr(), + signature_raw_ptr: signature_ptr, signature_length: signature.len(), }; - std::mem::forget(public_key); - std::mem::forget(signature); result } @@ -407,19 +421,24 @@ pub extern "C" fn sha512_ed25519_digital_signature_verify( ) -> bool { let public_key_slice = unsafe { assert!(!public_key.is_null()); - std::slice::from_raw_parts(public_key, public_key_length) - } - .to_vec(); + assert!(public_key_length == 32, "Public key must be 32 key bytes"); + let slice = std::slice::from_raw_parts(public_key, public_key_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; let data_to_verify_slice = unsafe { assert!(!data_to_verify.is_null()); std::slice::from_raw_parts(data_to_verify, data_to_verify_length) - } - .to_vec(); + }; let signature_slice = unsafe { assert!(!signature.is_null()); - std::slice::from_raw_parts(signature, signature_length) - } - .to_vec(); + assert!(signature_length == 64, "Signature must be 64 key bytes"); + let slice = std::slice::from_raw_parts(signature, signature_length); + let mut array = [0u8; 64]; + array.copy_from_slice(slice); + array + }; let result = ::digital_signature_ed25519_verify(public_key_slice, data_to_verify_slice, signature_slice); result } @@ -435,19 +454,24 @@ pub extern "C" fn sha512_ed25519_digital_signature_verify_threadpool( ) -> bool { let public_key_slice = unsafe { assert!(!public_key.is_null()); - std::slice::from_raw_parts(public_key, public_key_length) - } - .to_vec(); + assert!(public_key_length == 32, "Public key must be 32 key bytes"); + let slice = std::slice::from_raw_parts(public_key, public_key_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; let data_to_verify_slice = unsafe { assert!(!data_to_verify.is_null()); std::slice::from_raw_parts(data_to_verify, data_to_verify_length) - } - .to_vec(); + }; let signature_slice = unsafe { assert!(!signature.is_null()); - std::slice::from_raw_parts(signature, signature_length) - } - .to_vec(); + assert!(signature_length == 64, "Signature must be 64 key bytes"); + let slice = std::slice::from_raw_parts(signature, signature_length); + let mut array = [0u8; 64]; + array.copy_from_slice(slice); + array + }; let result = ::digital_signature_ed25519_verify_threadpool(public_key_slice, data_to_verify_slice, signature_slice); result } @@ -463,19 +487,30 @@ pub extern "C" fn sha256_ed25519_digital_signature_verify( ) -> bool { let public_key_slice = unsafe { assert!(!public_key.is_null()); - std::slice::from_raw_parts(public_key, public_key_length) - } - .to_vec(); + assert!( + public_key_length == 32, + "Public key must be 32 byes in length" + ); + let slice = std::slice::from_raw_parts(public_key, public_key_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; let data_to_verify_slice = unsafe { assert!(!data_to_verify.is_null()); std::slice::from_raw_parts(data_to_verify, data_to_verify_length) - } - .to_vec(); + }; let signature_slice = unsafe { assert!(!signature.is_null()); - std::slice::from_raw_parts(signature, signature_length) - } - .to_vec(); + assert!( + signature_length == 64, + "Signature must be 64 byes in length" + ); + let slice = std::slice::from_raw_parts(signature, signature_length); + let mut array = [0u8; 64]; + array.copy_from_slice(slice); + array + }; let result = ::digital_signature_ed25519_verify(public_key_slice, data_to_verify_slice, signature_slice); result } @@ -491,19 +526,30 @@ pub extern "C" fn sha256_ed25519_digital_signature_verify_threadpool( ) -> bool { let public_key_slice = unsafe { assert!(!public_key.is_null()); - std::slice::from_raw_parts(public_key, public_key_length) - } - .to_vec(); + assert!( + public_key_length == 32, + "Public Key must be 32 bytes in length" + ); + let slice = std::slice::from_raw_parts(public_key, public_key_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; let data_to_verify_slice = unsafe { assert!(!data_to_verify.is_null()); std::slice::from_raw_parts(data_to_verify, data_to_verify_length) - } - .to_vec(); + }; let signature_slice = unsafe { assert!(!signature.is_null()); - std::slice::from_raw_parts(signature, signature_length) - } - .to_vec(); + assert!( + signature_length == 64, + "Signature must be 64 bytes in length" + ); + let slice = std::slice::from_raw_parts(signature, signature_length); + let mut array = [0u8; 64]; + array.copy_from_slice(slice); + array + }; let result = ::digital_signature_ed25519_verify_threadpool(public_key_slice, data_to_verify_slice, signature_slice); result -} \ No newline at end of file +} diff --git a/src/ed25519.rs b/src/ed25519.rs index 5625c33..08b0e4c 100644 --- a/src/ed25519.rs +++ b/src/ed25519.rs @@ -1,43 +1,49 @@ use cas_lib::signatures::ed25519::{ed25519_sign_with_key_pair, ed25519_sign_with_key_pair_threadpool, ed25519_verify_with_key_pair, ed25519_verify_with_key_pair_threadpool, ed25519_verify_with_public_key, ed25519_verify_with_public_key_threadpool, get_ed25519_key_pair, get_ed25519_key_pair_threadpool}; -use libc::c_uchar; +use libc::{c_uchar, printf}; #[repr(C)] pub struct Ed25519KeyPairBytesResult { - key_pair: *mut c_uchar, + key_pair: *mut u8, length: usize, } #[repr(C)] pub struct Ed25519ByteSignatureResult { - pub signature_byte_ptr: *mut c_uchar, + pub signature_byte_ptr: *mut u8, pub signature_length: usize, - pub public_key: *mut c_uchar, + pub public_key: *mut u8, pub public_key_length: usize, } #[no_mangle] pub extern "C" fn get_ed25519_key_pair_bytes() -> Ed25519KeyPairBytesResult { - let mut keypair = get_ed25519_key_pair(); - let capacity = keypair.capacity(); - keypair.reserve_exact(capacity); + let keypair = get_ed25519_key_pair(); + let len = keypair.len(); + let key_pair_ptr = unsafe { + let ptr = libc::malloc(len) as *mut u8; + std::ptr::copy_nonoverlapping(keypair.as_ptr(), ptr, len); + ptr + }; let result = Ed25519KeyPairBytesResult { length: keypair.len(), - key_pair: keypair.as_mut_ptr(), + key_pair: key_pair_ptr, }; - std::mem::forget(keypair); result } #[no_mangle] pub extern "C" fn get_ed25519_key_pair_bytes_threadpool() -> Ed25519KeyPairBytesResult { - let mut keypair = get_ed25519_key_pair_threadpool(); - let capacity = keypair.capacity(); - keypair.reserve_exact(capacity); + let keypair = get_ed25519_key_pair_threadpool(); + let len = keypair.len(); + let key_pair_ptr = unsafe { + let ptr = libc::malloc(len) as *mut u8; + std::ptr::copy_nonoverlapping(keypair.as_ptr(), ptr, len); + ptr + }; let result = Ed25519KeyPairBytesResult { length: keypair.len(), - key_pair: keypair.as_mut_ptr(), + key_pair: key_pair_ptr, }; - std::mem::forget(keypair); result } @@ -58,29 +64,35 @@ pub extern "C" fn sign_with_key_pair_bytes( ) -> Ed25519ByteSignatureResult { let key_pair_slice = unsafe { assert!(!key_pair.is_null()); - std::slice::from_raw_parts(key_pair, key_pair_length) - } - .to_vec(); + assert!(key_pair_length == 32, "Key pair must be 32 bytes"); + let slice = std::slice::from_raw_parts(key_pair, key_pair_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; let message_to_sign_slice = unsafe { assert!(!message_to_sign.is_null()); std::slice::from_raw_parts(message_to_sign, message_to_sign_length) - } - .to_vec(); + }; let result = ed25519_sign_with_key_pair(key_pair_slice, message_to_sign_slice); - let mut public_key = result.public_key; - let public_key_capacity = public_key.capacity(); - public_key.reserve_exact(public_key_capacity); - let mut signature = result.signature; - let siganture_capacity = signature.capacity(); - signature.reserve_exact(siganture_capacity); + let public_key = result.public_key; + let signature = result.signature; + let public_key_pointer = unsafe { + let ptr = libc::malloc(public_key.len()) as *mut u8; + std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len()); + ptr + }; + let signature_pointer = unsafe { + let ptr = libc::malloc(signature.len()) as *mut u8; + std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len()); + ptr + }; let result = Ed25519ByteSignatureResult { - signature_byte_ptr: signature.as_mut_ptr(), + signature_byte_ptr: signature_pointer, signature_length: signature.len(), - public_key: public_key.as_mut_ptr(), + public_key: public_key_pointer, public_key_length: public_key.len(), }; - std::mem::forget(public_key); - std::mem::forget(signature); result } @@ -93,29 +105,35 @@ pub extern "C" fn sign_with_key_pair_bytes_threadpool( ) -> Ed25519ByteSignatureResult { let key_pair_slice = unsafe { assert!(!key_pair.is_null()); - std::slice::from_raw_parts(key_pair, key_pair_length) - } - .to_vec(); + assert!(key_pair_length == 32, "Key pair must be 32 bytes in length"); + let slice = std::slice::from_raw_parts(key_pair, key_pair_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; let message_to_sign_slice = unsafe { assert!(!message_to_sign.is_null()); std::slice::from_raw_parts(message_to_sign, message_to_sign_length) - } - .to_vec(); + }; let result = ed25519_sign_with_key_pair_threadpool(key_pair_slice, message_to_sign_slice); - let mut public_key = result.public_key; - let public_key_capacity = public_key.capacity(); - public_key.reserve_exact(public_key_capacity); - let mut signature = result.signature; - let siganture_capacity = signature.capacity(); - signature.reserve_exact(siganture_capacity); + let public_key = result.public_key; + let signature = result.signature; + let public_key_pointer = unsafe { + let ptr = libc::malloc(public_key.len()) as *mut u8; + std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len()); + ptr + }; + let signature_pointer = unsafe { + let ptr = libc::malloc(signature.len()) as *mut u8; + std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len()); + ptr + }; let result = Ed25519ByteSignatureResult { - signature_byte_ptr: signature.as_mut_ptr(), + signature_byte_ptr: signature_pointer, signature_length: signature.len(), - public_key: public_key.as_mut_ptr(), + public_key: public_key_pointer, public_key_length: public_key.len(), }; - std::mem::forget(public_key); - std::mem::forget(signature); result } @@ -147,16 +165,24 @@ pub extern "C" fn verify_with_key_pair_bytes( ) -> bool { let key_pair_slice = unsafe { assert!(!key_pair.is_null()); - std::slice::from_raw_parts(key_pair, key_pair_length) - }.to_vec(); + assert!(key_pair_length == 32, "Key pair length must be 32 bytes"); + let slice = std::slice::from_raw_parts(key_pair, key_pair_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; let signature_slice = unsafe { assert!(!signature.is_null()); - std::slice::from_raw_parts(signature, signature_length) - }.to_vec(); + assert!(signature_length == 64, "Key pair length must be 64 bytes"); + let slice = std::slice::from_raw_parts(signature, signature_length); + let mut array = [0u8; 64]; + array.copy_from_slice(slice); + array + }; let message_slice = unsafe { assert!(!message.is_null()); std::slice::from_raw_parts(message, message_length) - }.to_vec(); + }; return ed25519_verify_with_key_pair(key_pair_slice, signature_slice, message_slice); } @@ -169,18 +195,26 @@ pub extern "C" fn verify_with_key_pair_bytes_threadpool( message: *const c_uchar, message_length: usize, ) -> bool { - let key_pair_slice = unsafe { + let key_pair_slice: [u8; 32] = unsafe { assert!(!key_pair.is_null()); - std::slice::from_raw_parts(key_pair, key_pair_length) - }.to_vec(); + assert!(key_pair_length == 32, "Key pair length must be 32 bytes"); + let slice = std::slice::from_raw_parts(key_pair, key_pair_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; let signature_slice = unsafe { assert!(!signature.is_null()); - std::slice::from_raw_parts(signature, signature_length) - }.to_vec(); + assert!(signature_length == 64, "Signature length must be 64 bytes"); + let slice = std::slice::from_raw_parts(signature, signature_length); + let mut array = [0u8; 64]; + array.copy_from_slice(slice); + array + }; let message_slice = unsafe { assert!(!message.is_null()); std::slice::from_raw_parts(message, message_length) - }.to_vec(); + }; return ed25519_verify_with_key_pair_threadpool(key_pair_slice, signature_slice, message_slice); } @@ -214,18 +248,26 @@ pub extern "C" fn verify_with_public_key_bytes( message: *const c_uchar, message_length: usize, ) -> bool { - let public_key_slice = unsafe { + let public_key_slice: [u8; 32] = unsafe { assert!(!public_key.is_null()); - std::slice::from_raw_parts(public_key, public_key_length) - }.to_vec(); - let signature_slice = unsafe { + assert!(public_key_length == 32); + let slice = std::slice::from_raw_parts(public_key, public_key_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; + let signature_slice: [u8; 64] = unsafe { assert!(!signature.is_null()); - std::slice::from_raw_parts(signature, signature_length) - }.to_vec(); + assert!(signature_length == 64, "Signature slice must be 64 bytes"); + let slice = std::slice::from_raw_parts(signature, signature_length); + let mut array = [0u8; 64]; + array.copy_from_slice(slice); + array + }; let message_slice = unsafe { assert!(!message.is_null()); std::slice::from_raw_parts(message, message_length) - }.to_vec(); + }; return ed25519_verify_with_public_key(public_key_slice, signature_slice, message_slice); } @@ -238,18 +280,26 @@ pub extern "C" fn verify_with_public_key_bytes_threadpool( message: *const c_uchar, message_length: usize, ) -> bool { - let public_key_slice = unsafe { + let public_key_slice: [u8; 32] = unsafe { assert!(!public_key.is_null()); - std::slice::from_raw_parts(public_key, public_key_length) - }.to_vec(); - let signature_slice = unsafe { + assert!(public_key_length == 32, "Public key length must be 64 bytes"); + let slice = std::slice::from_raw_parts(public_key, public_key_length); + let mut array = [0u8; 32]; + array.copy_from_slice(slice); + array + }; + let signature_slice: [u8; 64] = unsafe { assert!(!signature.is_null()); - std::slice::from_raw_parts(signature, signature_length) - }.to_vec(); + assert!(signature_length == 64, "Signature Slice must be 32 bytes"); + let slice = std::slice::from_raw_parts(signature, signature_length); + let mut array = [0u8; 64]; + array.copy_from_slice(slice); + array + }; let message_slice = unsafe { assert!(!message.is_null()); std::slice::from_raw_parts(message, message_length) - }.to_vec(); + }; return ed25519_verify_with_public_key_threadpool(public_key_slice, signature_slice, message_slice); } diff --git a/src/lib.rs b/src/lib.rs index b9919a2..8b0f9a9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,6 +12,7 @@ mod zstd; mod hpke; pub mod password_hashers { + mod types; pub mod argon2; pub mod scrypt; pub mod bcrypt; diff --git a/src/password_hashers/argon2.rs b/src/password_hashers/argon2.rs index d8dabd4..1bb9301 100644 --- a/src/password_hashers/argon2.rs +++ b/src/password_hashers/argon2.rs @@ -1,5 +1,51 @@ use std::ffi::{c_char, CStr, CString}; -use cas_lib::password_hashers::{argon2::CASArgon, cas_password_hasher::CASPasswordHasher}; +use cas_lib::password_hashers::argon2::CASArgon; + +use super::types::Argon2KDFAes128; + +#[no_mangle] +pub extern "C" fn argon2_derive_aes_128_key(hashed_password: *const c_char) -> Argon2KDFAes128{ + let hashed_password_bytes = unsafe { + assert!(!hashed_password.is_null()); + CStr::from_ptr(hashed_password) + } + .to_str() + .unwrap() + .as_bytes(); + let key: [u8; 16] = CASArgon::derive_aes_128_key(hashed_password_bytes); + let key_ptr = unsafe { + let ptr = libc::malloc(key.len()) as *mut u8; + std::ptr::copy_nonoverlapping(key.as_ptr(), ptr, key.len()); + ptr + }; + let result = Argon2KDFAes128 { + key: key_ptr, + length: key.len() + }; + result +} + +#[no_mangle] +pub extern "C" fn argon2_derive_aes_256_key(hashed_password: *const c_char) -> Argon2KDFAes128 { + let hashed_password_bytes = unsafe { + assert!(!hashed_password.is_null()); + CStr::from_ptr(hashed_password) + } + .to_str() + .unwrap() + .as_bytes(); + let key: [u8; 32] = CASArgon::derive_aes_256_key(hashed_password_bytes); + let key_ptr = unsafe { + let ptr = libc::malloc(key.len()) as *mut u8; + std::ptr::copy_nonoverlapping(key.as_ptr(), ptr, key.len()); + ptr + }; + let result = Argon2KDFAes128 { + key: key_ptr, + length: key.len() + }; + result +} #[no_mangle] pub extern "C" fn argon2_verify(hashed_pass: *const c_char, password: *const c_char) -> bool { @@ -18,7 +64,7 @@ pub extern "C" fn argon2_verify(hashed_pass: *const c_char, password: *const c_c .to_str() .unwrap() .to_string(); - return ::verify_password(hashed_password, password_to_verify); + return CASArgon::verify_password(hashed_password, password_to_verify); } #[test] @@ -52,7 +98,7 @@ pub extern "C" fn argon2_verify_threadpool(hashed_pass: *const c_char, password: .to_str() .unwrap() .to_string(); - let result: bool = ::verify_password_threadpool(hashed_pass_string, password_string); + let result: bool = CASArgon::verify_password_threadpool(hashed_pass_string, password_string); result } @@ -79,7 +125,7 @@ pub extern "C" fn argon2_hash(pass_to_hash: *const c_char) -> *mut c_char { .to_str() .unwrap() .to_string(); - let new_hash = ::hash_password(password); + let new_hash = CASArgon::hash_password(password); let password_hash = CString::new(new_hash).unwrap().into_raw(); return password_hash; } @@ -105,7 +151,7 @@ pub extern "C" fn argon2_hash_threadpool(pass_to_hash: *const c_char) -> *mut c_ .to_str() .unwrap() .to_string(); - let new_hash = ::hash__password_threadpool(password); + let new_hash = CASArgon::hash_password_threadpool(password); let result = CString::new(new_hash).unwrap().into_raw(); result } diff --git a/src/password_hashers/bcrypt.rs b/src/password_hashers/bcrypt.rs index 2badb80..b49bd91 100644 --- a/src/password_hashers/bcrypt.rs +++ b/src/password_hashers/bcrypt.rs @@ -39,7 +39,7 @@ pub extern "C" fn bcrypt_hash_threadpool(pass_to_hash: *const c_char) -> *mut c_ .to_str() .unwrap() .to_string(); - let new_hash = ::hash__password_threadpool(string_pass); + let new_hash = ::hash_password_threadpool(string_pass); return CString::new(new_hash).unwrap().into_raw(); } diff --git a/src/password_hashers/scrypt.rs b/src/password_hashers/scrypt.rs index 2273222..ae25fb1 100644 --- a/src/password_hashers/scrypt.rs +++ b/src/password_hashers/scrypt.rs @@ -37,7 +37,7 @@ pub extern "C" fn scrypt_hash_threadpool(pass_to_hash: *const c_char) -> *mut c_ .to_str() .unwrap() .to_string(); - let new_hash = ::hash__password_threadpool(string_pass); + let new_hash = ::hash_password_threadpool(string_pass); return CString::new(new_hash).unwrap().into_raw(); } diff --git a/src/password_hashers/types.rs b/src/password_hashers/types.rs new file mode 100644 index 0000000..79d81be --- /dev/null +++ b/src/password_hashers/types.rs @@ -0,0 +1,7 @@ +use std::ffi::c_uchar; + +#[repr(C)] +pub struct Argon2KDFAes128 { + pub key: *mut c_uchar, + pub length: usize, +} \ No newline at end of file