cas-typescript-sdk 1.0.15 → 1.0.16

package/src/key_exchange/x25519.rs

@@ -1,57 +1,57 @@
-use napi::bindgen_prelude::ClassInstance;
-use napi_derive::napi;
-use rand::rngs::OsRng;
-use x25519_dalek::{PublicKey, StaticSecret};
-
-use super::cas_key_exchange::CASKeyExchange;
-
-#[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();
-}
-
-#[napi]
-pub fn x25519_diffie_hellman(my_secret_key: Vec<u8>, users_public_key: Vec<u8>) -> Vec<u8> {
-    return <X25519 as CASKeyExchange>::diffie_hellman(my_secret_key, users_public_key);
-}
-
-#[test]
-pub fn x25519_diffie_hellman_test() {
-    let alice = x25519_generate_secret_and_public_key();
-    let bob = x25519_generate_secret_and_public_key();
-
-    let alice_shared_secret = x25519_diffie_hellman(alice.secret_key, bob.public_key);
-    let bob_shared_secret = x25519_diffie_hellman(bob.secret_key, alice.public_key);
-    assert_eq!(true, alice_shared_secret.eq(&bob_shared_secret));
-}
+use napi::bindgen_prelude::ClassInstance;
+use napi_derive::napi;
+use rand::rngs::OsRng;
+use x25519_dalek::{PublicKey, StaticSecret};
+
+use super::cas_key_exchange::CASKeyExchange;
+
+#[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();
+}
+
+#[napi]
+pub fn x25519_diffie_hellman(my_secret_key: Vec<u8>, users_public_key: Vec<u8>) -> Vec<u8> {
+    return <X25519 as CASKeyExchange>::diffie_hellman(my_secret_key, users_public_key);
+}
+
+#[test]
+pub fn x25519_diffie_hellman_test() {
+    let alice = x25519_generate_secret_and_public_key();
+    let bob = x25519_generate_secret_and_public_key();
+
+    let alice_shared_secret = x25519_diffie_hellman(alice.secret_key, bob.public_key);
+    let bob_shared_secret = x25519_diffie_hellman(bob.secret_key, alice.public_key);
+    assert_eq!(true, alice_shared_secret.eq(&bob_shared_secret));
+}

package/src/lib.rs

@@ -1,27 +1,34 @@
-mod password_hashers {
-    pub mod argon2;
-    pub mod bcrypt;
-    pub mod scrypt;
-    pub mod cas_password_hasher;
-}
-
-mod hashers {
-    pub mod sha;
-    pub mod cas_hasher;
-    pub mod blake2;
-}
-
-mod key_exchange {
-    pub mod x25519;
-    pub mod cas_key_exchange;
-}
-
-mod symmetric {
-    pub mod aes;
-    pub mod cas_symmetric_encryption;
-}
-
-mod asymmetric {
-    pub mod cas_asymmetric_encryption;
-    pub mod cas_rsa;
-}
+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 symmetric {
+    pub mod aes;
+    pub mod cas_symmetric_encryption;
+}
+
+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;
+}

package/src/password_hashers/argon2.rs

@@ -1,64 +1,65 @@
-use std::net::ToSocketAddrs;
-
-use napi_derive::napi;
-
-use argon2::{
-    password_hash::{rand_core::OsRng, SaltString},
-    Argon2, PasswordHasher, PasswordHash, PasswordVerifier,
-};
-
-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()
-    }
-}
-
-#[napi]
-pub fn argon2_hash(password: String) -> String {
-    return <CASArgon as CASPasswordHasher>::hash_password(password);
-}
-
-#[napi]
-pub fn argon2_verify(hashed_password: String, password_to_verify: String) -> bool {
-    return <CASArgon as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
-}
-
-
-#[test]
-pub fn argon2_hash_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = argon2_hash(password.clone());
-    assert_ne!(password, hashed);
-}
-
-#[test]
-pub fn argon2_verify_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = argon2_hash(password.clone());
-    let verified = argon2_verify(hashed, password);
-    assert_eq!(true, verified);
-}
-
-#[test]
-pub fn argon2_verify_fail_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = argon2_hash(password.clone());
-    let verified = "Nope".to_string();
-    let verified = argon2_verify(hashed, verified);
-    assert_eq!(false, verified);
-}
+use std::net::ToSocketAddrs;
+
+use napi_derive::napi;
+
+use argon2::{
+    password_hash::{rand_core::OsRng, SaltString},
+    Argon2, PasswordHash, PasswordHasher, PasswordVerifier,
+};
+
+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();
+    }
+}
+
+#[napi]
+pub fn argon2_hash(password: String) -> String {
+    return <CASArgon as CASPasswordHasher>::hash_password(password);
+}
+
+#[napi]
+pub fn argon2_verify(hashed_password: String, password_to_verify: String) -> bool {
+    return <CASArgon as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+}
+
+#[test]
+pub fn argon2_hash_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = argon2_hash(password.clone());
+    assert_ne!(password, hashed);
+}
+
+#[test]
+pub fn argon2_verify_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = argon2_hash(password.clone());
+    let verified = argon2_verify(hashed, password);
+    assert_eq!(true, verified);
+}
+
+#[test]
+pub fn argon2_verify_fail_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = argon2_hash(password.clone());
+    let verified = "Nope".to_string();
+    let verified = argon2_verify(hashed, verified);
+    assert_eq!(false, verified);
+}

package/src/password_hashers/bcrypt.rs

@@ -1,51 +1,50 @@
-use napi_derive::napi;
-use bcrypt::{hash, verify, DEFAULT_COST};
-
-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);
-}
-
-#[napi]
-pub fn bcrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
-    return <CASBCrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
-}
-
-#[test]
-pub fn bcrypt_hash_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = bcrypt_hash(password.clone());
-    assert_ne!(password, hashed);
-}
-
-#[test]
-pub fn bcrypt_verify_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = bcrypt_hash(password.clone());
-    let verified = bcrypt_verify(hashed, password);
-    assert_eq!(true, verified);
-}
-
-#[test]
-pub fn bcrypt_verify_fail_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = bcrypt_hash(password.clone());
-    let verified = "nope".to_string();
-    let verified = bcrypt_verify(hashed, verified);
-    assert_eq!(false, verified);
-}
+use bcrypt::{hash, verify, DEFAULT_COST};
+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);
+}
+
+#[napi]
+pub fn bcrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
+    return <CASBCrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+}
+
+#[test]
+pub fn bcrypt_hash_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = bcrypt_hash(password.clone());
+    assert_ne!(password, hashed);
+}
+
+#[test]
+pub fn bcrypt_verify_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = bcrypt_hash(password.clone());
+    let verified = bcrypt_verify(hashed, password);
+    assert_eq!(true, verified);
+}
+
+#[test]
+pub fn bcrypt_verify_fail_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = bcrypt_hash(password.clone());
+    let verified = "nope".to_string();
+    let verified = bcrypt_verify(hashed, verified);
+    assert_eq!(false, verified);
+}

package/src/password_hashers/cas_password_hasher.rs

@@ -1,4 +1,4 @@
-pub trait CASPasswordHasher {
-    fn hash_password(password_to_hash: String) -> String;
-    fn verify_password(hashed_password: String, password_to_verify: String) -> bool;
-}
+pub trait CASPasswordHasher {
+    fn hash_password(password_to_hash: String) -> String;
+    fn verify_password(hashed_password: String, password_to_verify: String) -> bool;
+}

package/src/password_hashers/scrypt.rs

@@ -1,56 +1,61 @@
-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);
-}
-
-#[napi]
-pub fn scrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
-    return <CASScrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
-}
-
-#[test]
-pub fn scrypt_hash_test() {
-    let password = "BadPassword".to_string();
-    let hashed_password = scrypt_hash(password.clone());
-    assert_ne!(password, hashed_password);
-}
-
-#[test]
-pub fn scrypt_verify_test() {
-    let password = "BadPassword".to_string();
-    let hashed_password = scrypt_hash(password.clone());
-    let verified = scrypt_verify(hashed_password, password);
-    assert_eq!(true, verified);
-}
-
-#[test]
-pub fn scrypt_verify_fail_test() {
-    let password = "BadPassword".to_string();
-    let hashed_password = scrypt_hash(password.clone());
-    let verified = "Nope".to_string();
-    let verified = scrypt_verify(hashed_password, verified);
-    assert_eq!(false, verified);
-}
+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);
+}
+
+#[napi]
+pub fn scrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
+    return <CASScrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+}
+
+#[test]
+pub fn scrypt_hash_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash(password.clone());
+    assert_ne!(password, hashed_password);
+}
+
+#[test]
+pub fn scrypt_verify_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash(password.clone());
+    let verified = scrypt_verify(hashed_password, password);
+    assert_eq!(true, verified);
+}
+
+#[test]
+pub fn scrypt_verify_fail_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash(password.clone());
+    let verified = "Nope".to_string();
+    let verified = scrypt_verify(hashed_password, verified);
+    assert_eq!(false, verified);
+}