cas-typescript-sdk 1.0.23 → 1.0.24

package/src/digital_signature/sha_256_rsa.rs

@@ -1,70 +1,14 @@
+use cas_lib::digital_signature::{cas_digital_signature_rsa::RSADigitalSignature, sha_256_rsa::SHA256RSADigitalSignature};
 use napi_derive::napi;
-use rand::rngs::OsRng;
-use rsa::{
-    pkcs1::{DecodeRsaPublicKey, EncodeRsaPublicKey},
-    pkcs8::EncodePrivateKey,
-    Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey,
-};
-use sha3::{Digest, Sha3_256};
 
-
-use super::cas_digital_signature_rsa::{RSADigitalSignatureResult, RSADigitalSignature};
-
-pub struct SHA256RSADigitalSignature;
-
-impl RSADigitalSignature for SHA256RSADigitalSignature {
-    fn digital_signature_rsa(
-        rsa_key_size: u32,
-        data_to_sign: Vec<u8>,
-    ) -> RSADigitalSignatureResult {
-        let mut hasher = Sha3_256::new();
-        hasher.update(data_to_sign);
-        let sha_hasher_result = hasher.finalize();
-        let mut rng: OsRng = OsRng;
-        let private_key: RsaPrivateKey =
-            RsaPrivateKey::new(&mut rng, rsa_key_size as usize).expect("failed to generate a key");
-        let public_key = private_key.to_public_key();
-        let mut signed_data = private_key
-            .sign(Pkcs1v15Sign::new_unprefixed(), &sha_hasher_result)
-            .unwrap();
-        let result = RSADigitalSignatureResult {
-            private_key: private_key
-                .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
-                .unwrap()
-                .to_string(),
-            public_key: public_key
-                .to_pkcs1_pem(rsa::pkcs8::LineEnding::LF)
-                .unwrap()
-                .to_string(),
-            signature: signed_data,
-        };
-        result
-    }
-
-    fn verify_rsa(public_key: String, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-        let mut hasher = Sha3_256::new();
-        hasher.update(data_to_verify);
-        let sha_hasher_result = hasher.finalize();
-        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
-        let verified = public_key.verify(
-            Pkcs1v15Sign::new_unprefixed(),
-            &sha_hasher_result,
-            &signature,
-        );
-        if verified.is_err() == false {
-            return true;
-        } else {
-            return false;
-        }
-    }
-}
+use super::types::CASRSADigitalSignatureResult;
 
 #[napi]
 pub fn sha_256_rsa_digital_signature(
     rsa_key_size: u32,
     data_to_sign: Vec<u8>,
-) -> RSADigitalSignatureResult {
-    return SHA256RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign);
+) -> CASRSADigitalSignatureResult {
+    return <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(rsa_key_size, data_to_sign).into();
 }
 
 #[napi]
@@ -73,14 +17,14 @@ pub fn sha_256_rsa_verify_digital_signature(
     data_to_verify: Vec<u8>,
     signature: Vec<u8>,
 ) -> bool {
-    return SHA256RSADigitalSignature::verify_rsa(public_key, data_to_verify, signature);
+    return <SHA256RSADigitalSignature as RSADigitalSignature>::verify_rsa(public_key, data_to_verify, signature);
 }
 
 #[test]
 fn sha_256_rsa_digital_signature_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: RSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: CASRSADigitalSignatureResult = <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(key_size, data_to_sign.clone()).into();
     let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -89,7 +33,7 @@ fn sha_256_rsa_digital_signature_test() {
 fn sha_256_rsa_digital_signature_fail_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: RSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: CASRSADigitalSignatureResult = <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(key_size, data_to_sign.clone()).into();
     let new_data = b"NOtTheOriginalData".to_vec();
     let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
     assert_eq!(is_verified, false);

package/src/digital_signature/sha_512_ed25519.rs

@@ -1,65 +1,25 @@
-use ed25519_dalek::{Keypair, Signature, Signer, Verifier};
-use napi_derive::napi;
-use sha3::{Digest, Sha3_512};
-
-use super::cas_digital_signature_rsa::{
-    ED25519DigitalSignature, SHAED25519DalekDigitalSignatureResult,
-};
-
-pub struct SHA512ED25519DigitalSignature;
+use cas_lib::digital_signature::{cas_digital_signature_rsa::{ED25519DigitalSignature, SHAED25519DalekDigitalSignatureResult}, sha_512_ed25519::SHA512ED25519DigitalSignature};
 
-impl ED25519DigitalSignature for SHA512ED25519DigitalSignature {
-    fn digital_signature_ed25519(
-        data_to_sign: Vec<u8>,
-    ) -> SHAED25519DalekDigitalSignatureResult {
-        let mut hasher = Sha3_512::new();
-        hasher.update(data_to_sign);
-        let sha_hasher_result = hasher.finalize();
-        let mut csprng = rand_07::rngs::OsRng {};
-        let keypair = Keypair::generate(&mut csprng);
-
-        let signature = keypair.sign(&sha_hasher_result);
-        let signature_bytes = signature.to_bytes();
-        let public_keypair_bytes = keypair.public.to_bytes();
-        let result = SHAED25519DalekDigitalSignatureResult {
-            public_key: public_keypair_bytes.to_vec(),
-            signature: signature_bytes.to_vec(),
-        };
-        result
-    }
+use napi_derive::napi;
 
-    fn digital_signature_ed25519_verify(
-        public_key: Vec<u8>,
-        data_to_verify: Vec<u8>,
-        signature: Vec<u8>,
-    ) -> bool {
-        let mut hasher = Sha3_512::new();
-        hasher.update(data_to_verify);
-        let sha_hasher_result = hasher.finalize();
+use super::types::CASSHAED25519DalekDigitalSignatureResult;
 
-        let public_key_parsed = ed25519_dalek::PublicKey::from_bytes(&public_key).unwrap();
-        let signature_parsed = Signature::from_bytes(&signature).unwrap();
-        return public_key_parsed
-            .verify(&sha_hasher_result, &signature_parsed)
-            .is_ok();
-    }
-}
 
 #[napi]
-pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult {
-    return SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign);
+pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
+    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign).into();
 }
 
 #[napi]
 pub fn sha_512_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-    return SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(public_key, data_to_verify, signature)
+    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(public_key, data_to_verify, signature)
 }
 
 #[test]
 fn sha_512_ed25519_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: SHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let signature_result: SHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign.clone());
     let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -68,7 +28,7 @@ fn sha_512_ed25519_test() {
 fn sha_512_ed25519_test_fail() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: SHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign.clone()).into();
     let not_original_data = b"NOtTHoseBytes".to_vec();
     let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, not_original_data, signature_result.signature);
     assert_eq!(is_verified, false);

package/src/digital_signature/sha_512_rsa.rs

@@ -1,67 +1,14 @@
+use cas_lib::digital_signature::{cas_digital_signature_rsa::RSADigitalSignature, sha_512_rsa::SHA512RSADigitalSignature};
 use napi_derive::napi;
-use rand::rngs::OsRng;
-use rsa::{
-    pkcs1::{DecodeRsaPublicKey, EncodeRsaPublicKey},
-    pkcs8::EncodePrivateKey,
-    Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey,
-};
-use sha3::{Digest, Sha3_512};
-use super::cas_digital_signature_rsa::{RSADigitalSignatureResult, RSADigitalSignature};
-pub struct SHA512RSADigitalSignature;
 
-impl RSADigitalSignature for SHA512RSADigitalSignature {
-    fn digital_signature_rsa(
-        rsa_key_size: u32,
-        data_to_sign: Vec<u8>,
-    ) -> RSADigitalSignatureResult {
-        let mut hasher = Sha3_512::new();
-        hasher.update(data_to_sign);
-        let sha_hasher_result = hasher.finalize();
-        let mut rng: OsRng = OsRng;
-        let private_key: RsaPrivateKey =
-            RsaPrivateKey::new(&mut rng, rsa_key_size as usize).expect("failed to generate a key");
-        let public_key = private_key.to_public_key();
-        let mut signed_data = private_key
-            .sign(Pkcs1v15Sign::new_unprefixed(), &sha_hasher_result)
-            .unwrap();
-        let result = RSADigitalSignatureResult {
-            private_key: private_key
-                .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
-                .unwrap()
-                .to_string(),
-            public_key: public_key
-                .to_pkcs1_pem(rsa::pkcs8::LineEnding::LF)
-                .unwrap()
-                .to_string(),
-            signature: signed_data,
-        };
-        result
-    }
-
-    fn verify_rsa(public_key: String, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-        let mut hasher = Sha3_512::new();
-        hasher.update(data_to_verify);
-        let sha_hasher_result = hasher.finalize();
-        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
-        let verified = public_key.verify(
-            Pkcs1v15Sign::new_unprefixed(),
-            &sha_hasher_result,
-            &signature,
-        );
-        if verified.is_err() == false {
-            return true;
-        } else {
-            return false;
-        }
-    }
-}
+use super::types::CASRSADigitalSignatureResult;
 
 #[napi]
 pub fn sha_512_rsa_digital_signature(
     rsa_key_size: u32,
     data_to_sign: Vec<u8>,
-) -> RSADigitalSignatureResult {
-    return SHA512RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign);
+) -> CASRSADigitalSignatureResult {
+    return <SHA512RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(rsa_key_size, data_to_sign).into();
 }
 
 #[napi]
@@ -70,15 +17,15 @@ pub fn sha_512_rsa_verify_digital_signature(
     data_to_verify: Vec<u8>,
     signature: Vec<u8>,
 ) -> bool {
-    return SHA512RSADigitalSignature::verify_rsa(public_key, data_to_verify, signature);
+    return <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(public_key, data_to_verify, signature);
 }
 
 #[test]
 fn sha_512_rsa_digital_signature_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: RSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
-    let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
+    let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone()).into();
+    let is_verified: bool = <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
 
@@ -86,8 +33,8 @@ fn sha_512_rsa_digital_signature_test() {
 fn sha_512_rsa_digital_signature_fail_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: RSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone()).into();
     let new_data = b"NOtTheOriginalData".to_vec();
-    let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
+    let is_verified: bool = <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
     assert_eq!(is_verified, false);
 }

package/src/digital_signature/types.rs

@@ -0,0 +1,34 @@
+use cas_lib::digital_signature::cas_digital_signature_rsa::{RSADigitalSignatureResult, SHAED25519DalekDigitalSignatureResult};
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct CASSHAED25519DalekDigitalSignatureResult {
+    pub public_key: Vec<u8>,
+    pub signature: Vec<u8>
+}
+
+impl From<SHAED25519DalekDigitalSignatureResult> for CASSHAED25519DalekDigitalSignatureResult {
+    fn from(value: SHAED25519DalekDigitalSignatureResult) -> Self {
+        CASSHAED25519DalekDigitalSignatureResult {
+            public_key: value.public_key,
+            signature: value.signature
+        }
+    }
+}
+
+#[napi(constructor)]
+pub struct CASRSADigitalSignatureResult {
+    pub public_key: String,
+    pub private_key: String,
+    pub signature: Vec<u8>,
+}
+
+impl From<RSADigitalSignatureResult> for CASRSADigitalSignatureResult {
+    fn from(value: RSADigitalSignatureResult) -> Self {
+        CASRSADigitalSignatureResult {
+            public_key: value.public_key,
+            private_key: value.private_key,
+            signature: value.signature
+        }
+    }
+}

package/src/hashers/sha.rs

@@ -1,40 +1,6 @@
-use napi::bindgen_prelude::Array;
+use cas_lib::hashers::{cas_hasher::CASHasher, sha::CASSHA};
 use napi_derive::napi;
 
-use super::cas_hasher::CASHasher;
-use sha3::{Digest, Sha3_256, Sha3_512};
-pub struct CASSHA;
-
-impl CASHasher for CASSHA {
-    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8> {
-        let mut hasher = Sha3_512::new();
-        hasher.update(data_to_hash);
-        let result = hasher.finalize();
-        return result.to_vec();
-    }
-
-    fn verify_512(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-        let mut hasher = Sha3_512::new();
-        hasher.update(data_to_verify);
-        let result = hasher.finalize();
-        return hash_to_verify.eq(&result.to_vec());
-    }
-
-    fn hash_256(data_to_hash: Vec<u8>) -> Vec<u8> {
-        let mut hasher = Sha3_256::new();
-        hasher.update(data_to_hash);
-        let result = hasher.finalize();
-        return result.to_vec();
-    }
-
-    fn verify_256(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-        let mut hasher = Sha3_256::new();
-        hasher.update(data_to_verify);
-        let result = hasher.finalize();
-        return hash_to_verify.eq(&result.to_vec());
-    }
-}
-
 #[napi]
 pub fn sha_512(data_to_hash: Vec<u8>) -> Vec<u8> {
     return <CASSHA as CASHasher>::hash_512(data_to_hash);

package/src/key_exchange/types.rs

@@ -0,0 +1,17 @@
+use cas_lib::key_exchange::x25519::x25519SecretPublicKeyResult;
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct CASx25519SecretPublicKeyResult {
+    pub public_key: Vec<u8>,
+    pub secret_key: Vec<u8>,
+}
+
+impl From<x25519SecretPublicKeyResult> for CASx25519SecretPublicKeyResult {
+    fn from(value: x25519SecretPublicKeyResult) -> Self {
+        CASx25519SecretPublicKeyResult {
+            public_key: value.public_key,
+            secret_key: value.secret_key
+        }
+    }
+}

package/src/key_exchange/x25519.rs

@@ -1,44 +1,12 @@
-use napi::bindgen_prelude::ClassInstance;
+use cas_lib::key_exchange::{cas_key_exchange::CASKeyExchange, x25519::X25519};
 use napi_derive::napi;
-use rand::rngs::OsRng;
-use x25519_dalek::{PublicKey, StaticSecret};
 
-use super::cas_key_exchange::CASKeyExchange;
+use super::types::CASx25519SecretPublicKeyResult;
 
-#[napi(constructor)]
-pub struct x25519SecretPublicKeyResult {
-    pub public_key: Vec<u8>,
-    pub secret_key: Vec<u8>,
-}
-
-pub struct X25519;
-
-impl CASKeyExchange for X25519 {
-    fn generate_secret_and_public_key() -> x25519SecretPublicKeyResult {
-        let secret_key = StaticSecret::random_from_rng(OsRng);
-        let public_key = PublicKey::from(&secret_key);
-        let result = x25519SecretPublicKeyResult {
-            secret_key: secret_key.as_bytes().to_vec(),
-            public_key: public_key.as_bytes().to_vec(),
-        };
-        result
-    }
-
-    fn diffie_hellman(my_secret_key: Vec<u8>, users_public_key: Vec<u8>) -> Vec<u8> {
-        let mut secret_key_array: [u8; 32] = Default::default();
-        secret_key_array.copy_from_slice(&my_secret_key);
-        let mut users_public_key_array: [u8; 32] = Default::default();
-        users_public_key_array.copy_from_slice(&users_public_key);
-
-        let secret_key = StaticSecret::from(secret_key_array);
-        let public_key = PublicKey::from(users_public_key_array);
-        return secret_key.diffie_hellman(&public_key).as_bytes().to_vec();
-    }
-}
 
 #[napi]
-pub fn x25519_generate_secret_and_public_key() -> x25519SecretPublicKeyResult {
-    return <X25519 as CASKeyExchange>::generate_secret_and_public_key();
+pub fn x25519_generate_secret_and_public_key() -> CASx25519SecretPublicKeyResult {
+    return <X25519 as CASKeyExchange>::generate_secret_and_public_key().into();
 }
 
 #[napi]

package/src/lib.rs

@@ -1,40 +1,35 @@
 mod password_hashers {
     pub mod argon2;
     pub mod bcrypt;
-    pub mod cas_password_hasher;
     pub mod scrypt;
 }
 
 mod hashers {
-    pub mod blake2;
-    pub mod cas_hasher;
     pub mod sha;
 }
 
 mod key_exchange {
-    pub mod cas_key_exchange;
     pub mod x25519;
+    mod types;
 }
 
 mod symmetric {
     pub mod aes;
-    pub mod cas_symmetric_encryption;
+    mod types;
 }
 
 mod asymmetric {
-    pub mod cas_asymmetric_encryption;
     pub mod cas_rsa;
 }
 
 mod digital_signature {
-    pub mod cas_digital_signature_rsa;
     pub mod sha_512_rsa;
     pub mod sha_256_rsa;
     pub mod sha_512_ed25519;
     pub mod sha_256_ed25519;
+    mod types;
 }
 
 mod sponges {
-    pub mod cas_ascon_aead;
     pub mod ascon_aead;
 }

package/src/password_hashers/argon2.rs

@@ -1,35 +1,7 @@
 
 use napi_derive::napi;
-
-use argon2::{
-    password_hash::{rand_core::OsRng, SaltString},
-    Argon2, PasswordHash, PasswordHasher, PasswordVerifier,
-};
-
-use crate::symmetric::aes::CASAES128;
-
-use super::cas_password_hasher::CASPasswordHasher;
-
-pub struct CASArgon;
-
-impl CASPasswordHasher for CASArgon {
-    fn hash_password(password_to_hash: String) -> String {
-        let salt = SaltString::generate(&mut OsRng);
-        let argon2 = Argon2::default();
-        let hashed_password = argon2
-            .hash_password(password_to_hash.as_bytes(), &salt)
-            .unwrap()
-            .to_string();
-        return hashed_password;
-    }
-
-    fn verify_password(hashed_password: String, password_to_verify: String) -> bool {
-        let hashed_password = PasswordHash::new(&hashed_password).unwrap();
-        return Argon2::default()
-            .verify_password(password_to_verify.as_bytes(), &hashed_password)
-            .is_ok();
-    }
-}
+use cas_lib::password_hashers::argon2::CASArgon;
+use cas_lib::password_hashers::cas_password_hasher::CASPasswordHasher;
 
 #[napi]
 pub fn argon2_hash(password: String) -> String {
@@ -38,13 +10,7 @@ pub fn argon2_hash(password: String) -> String {
 
 #[napi] 
 pub fn argon2_hash_thread_pool(password: String) -> String {
-    let (sender, receiver) = std::sync::mpsc::channel();
-    rayon::spawn(move || {
-        let hash_result = <CASArgon as CASPasswordHasher>::hash_password(password);
-        sender.send(hash_result);
-    });
-    let result = receiver.recv().unwrap();
-    result
+    return <CASArgon as CASPasswordHasher>::hash__password_threadpool(password);
 }
 
 #[napi]
@@ -54,13 +20,7 @@ pub fn argon2_verify(hashed_password: String, password_to_verify: String) -> boo
 
 #[napi]
 pub fn argon2_verify_threadpool(hashed_password: String, password_to_verify: String) -> bool {
-    let (sender, receiver) = std::sync::mpsc::channel();
-    rayon::spawn(move || {
-        let verify_result = <CASArgon as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
-        sender.send(verify_result);
-    });
-    let result = receiver.recv().unwrap();
-    result
+    return <CASArgon as CASPasswordHasher>::verify_password_threadpool(hashed_password, password_to_verify);
 }
 
 #[test]

package/src/password_hashers/bcrypt.rs

@@ -1,22 +1,7 @@
-use std::sync::mpsc;
-
-use bcrypt::{hash, verify, DEFAULT_COST};
+use cas_lib::password_hashers::bcrypt::CASBCrypt;
+use cas_lib::password_hashers::cas_password_hasher::CASPasswordHasher;
 use napi_derive::napi;
 
-use super::cas_password_hasher::CASPasswordHasher;
-
-pub struct CASBCrypt;
-
-impl CASPasswordHasher for CASBCrypt {
-    fn hash_password(password_to_hash: String) -> String {
-        return hash(password_to_hash, DEFAULT_COST).unwrap();
-    }
-
-    fn verify_password(hashed_password: String, password_to_verify: String) -> bool {
-        return verify(password_to_verify, &hashed_password).unwrap();
-    }
-}
-
 #[napi]
 pub fn bcrypt_hash(password_to_hash: String) -> String {
     return <CASBCrypt as CASPasswordHasher>::hash_password(password_to_hash);
@@ -24,13 +9,7 @@ pub fn bcrypt_hash(password_to_hash: String) -> String {
 
 #[napi]
 pub fn bcrypt_hash_threadpool(password_to_hash: String) -> String {
-    let (sender, receiver) =  mpsc::channel();
-    rayon::spawn(move || {
-        let thread_result = <CASBCrypt as CASPasswordHasher>::hash_password(password_to_hash);
-        sender.send(thread_result); 
-    });
-    let result = receiver.recv().unwrap();
-    result
+    return <CASBCrypt as CASPasswordHasher>::hash__password_threadpool(password_to_hash);
 }
 
 #[napi]
@@ -40,13 +19,7 @@ pub fn bcrypt_verify(hashed_password: String, password_to_verify: String) -> boo
 
 #[napi]
 pub fn bcrypt_verify_threadpool(password_to_hash: String, password_to_verify: String) -> bool {
-    let (sender, receiver) =  mpsc::channel();
-    rayon::spawn(move || {
-        let thread_result = <CASBCrypt as CASPasswordHasher>::verify_password(password_to_hash, password_to_verify);
-        sender.send(thread_result); 
-    });
-    let result = receiver.recv().unwrap();
-    result
+    return <CASBCrypt as CASPasswordHasher>::verify_password_threadpool(password_to_hash, password_to_verify);
 }
 
 #[test]

package/src/password_hashers/scrypt.rs

@@ -1,33 +1,6 @@
-use std::sync::mpsc;
-
+use cas_lib::password_hashers::{cas_password_hasher::CASPasswordHasher, scrypt::CASScrypt};
 use napi_derive::napi;
 
-use scrypt::{
-    password_hash::{rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString},
-    Scrypt,
-};
-
-use super::cas_password_hasher::CASPasswordHasher;
-
-pub struct CASScrypt;
-
-impl CASPasswordHasher for CASScrypt {
-    fn hash_password(password_to_hash: String) -> String {
-        let salt = SaltString::generate(&mut OsRng);
-        return Scrypt
-            .hash_password(password_to_hash.as_bytes(), &salt)
-            .unwrap()
-            .to_string();
-    }
-
-    fn verify_password(hashed_password: String, password_to_verify: String) -> bool {
-        let parsed_hash = PasswordHash::new(&hashed_password).unwrap();
-        return Scrypt
-            .verify_password(password_to_verify.as_bytes(), &parsed_hash)
-            .is_ok();
-    }
-}
-
 #[napi]
 pub fn scrypt_hash(password_to_hash: String) -> String {
     return <CASScrypt as CASPasswordHasher>::hash_password(password_to_hash);
@@ -40,24 +13,12 @@ pub fn scrypt_verify(hashed_password: String, password_to_verify: String) -> boo
 
 #[napi]
 pub fn scrypt_hash_threadpool(password_to_hash: String) -> String {
-    let (sender, receiver) = mpsc::channel();
-    rayon::spawn(move || {
-        let thread_result = <CASScrypt as CASPasswordHasher>::hash_password(password_to_hash);
-        sender.send(thread_result);
-    });
-    let result = receiver.recv().unwrap();
-    result
+    return <CASScrypt as CASPasswordHasher>::hash__password_threadpool(password_to_hash);
 }
 
 #[napi]
 pub fn scrypt_verify_threadpool(hashed_password: String, password_to_verify: String) -> bool {
-    let (sender, receiver) = mpsc::channel();
-    rayon::spawn(move || {
-        let thread_result = <CASScrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
-        sender.send(thread_result);
-    });
-    let result = receiver.recv().unwrap();
-    result
+    return <CASScrypt as CASPasswordHasher>::verify_password_threadpool(hashed_password, password_to_verify);
 }
 
 #[test]