cas-typescript-sdk 1.0.21 → 1.0.23

package/lib/password-hashers/bcrypt-wrapper.d.ts

@@ -1,5 +1,29 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class BCryptWrapper implements IPasswordHasherBase {
+    /**
+     * Verifies a password with BCrypt on the threadpool.
+     * @param hashedPassword
+     * @param passwordToCheck
+     * @returns boolean
+     */
+    verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean;
+    /**
+     * Hashes a password with BCrypt on the threadpool.
+     * @param password
+     * @returns string
+     */
+    hashPasswordThreadPool(password: string): string;
+    /**
+     * Hashes a password with BCrypt
+     * @param password
+     * @returns string
+     */
     hashPassword(password: string): string;
+    /**
+     * Verifies that a password is the same as the hashed password with BCrypt.
+     * @param hashedPassword
+     * @param passwordToVerify
+     * @returns boolean
+     */
     verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/bcrypt-wrapper.js

@@ -3,12 +3,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BCryptWrapper = void 0;
 const index_1 = require("./../../index");
 class BCryptWrapper {
+    /**
+     * Verifies a password with BCrypt on the threadpool.
+     * @param hashedPassword
+     * @param passwordToCheck
+     * @returns boolean
+     */
+    verifyThreadPool(hashedPassword, passwordToCheck) {
+        if (!hashedPassword || !passwordToCheck) {
+            throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
+        }
+        return (0, index_1.bcryptVerifyThreadpool)(hashedPassword, passwordToCheck);
+    }
+    /**
+     * Hashes a password with BCrypt on the threadpool.
+     * @param password
+     * @returns string
+     */
+    hashPasswordThreadPool(password) {
+        if (!password) {
+            throw new Error("You must provide a password to hash with Argon2");
+        }
+        return (0, index_1.bcryptHashThreadpool)(password);
+    }
+    /**
+     * Hashes a password with BCrypt
+     * @param password
+     * @returns string
+     */
     hashPassword(password) {
         if (!password) {
             throw new Error("You must provide a password to hash with Argon2");
         }
         return (0, index_1.bcryptHash)(password);
     }
+    /**
+     * Verifies that a password is the same as the hashed password with BCrypt.
+     * @param hashedPassword
+     * @param passwordToVerify
+     * @returns boolean
+     */
     verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");

package/lib/password-hashers/password-hasher-base.d.ts

@@ -1,4 +1,6 @@
 export interface IPasswordHasherBase {
     hashPassword(password: string): string;
     verify(hashedPassword: string, passwordToVerify: string): boolean;
+    hashPasswordThreadPool(password: string): string;
+    verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean;
 }

package/lib/password-hashers/password-hasher-factory.d.ts

@@ -1,4 +1,9 @@
 import { PasswordHasherType } from "./password-hasher-type";
 export declare class PasswordHasherFactory {
+    /**
+     * Returns the appropriate hasher type based upon the type passed in.
+     * @param type
+     * @returns
+     */
     static getHasher(type: PasswordHasherType): any;
 }

package/lib/password-hashers/password-hasher-factory.js

@@ -6,6 +6,11 @@ const bcrypt_wrapper_1 = require("./bcrypt-wrapper");
 const password_hasher_type_1 = require("./password-hasher-type");
 const scrypt_wrapper_1 = require("./scrypt-wrapper");
 class PasswordHasherFactory {
+    /**
+     * Returns the appropriate hasher type based upon the type passed in.
+     * @param type
+     * @returns
+     */
     static getHasher(type) {
         // Argon2 by default
         let hasher = new argon2_wrapper_1.Argon2Wrapper();

package/lib/password-hashers/scrypt-wrapper.d.ts

@@ -1,5 +1,29 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class ScryptWrapper implements IPasswordHasherBase {
+    /**
+     * Verifies a password with SCrypt on the threadpool.
+     * @param hashedPassword
+     * @param passwordToCheck
+     * @returns boolean
+     */
+    verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean;
+    /**
+     * Hashes a password with SCrypt on the threadpool.
+     * @param password
+     * @returns string
+     */
+    hashPasswordThreadPool(password: string): string;
+    /**
+     * Hashes a password with SCrypt
+     * @param password
+     * @returns string
+     */
     hashPassword(password: string): string;
+    /**
+     * Verifies that a password is the same as the hashed password with SCrypt.
+     * @param hashedPassword
+     * @param passwordToVerify
+     * @returns boolean
+     */
     verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/scrypt-wrapper.js

@@ -3,12 +3,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScryptWrapper = void 0;
 const index_1 = require("../../index");
 class ScryptWrapper {
+    /**
+     * Verifies a password with SCrypt on the threadpool.
+     * @param hashedPassword
+     * @param passwordToCheck
+     * @returns boolean
+     */
+    verifyThreadPool(hashedPassword, passwordToCheck) {
+        if (!hashedPassword || !passwordToCheck) {
+            throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");
+        }
+        return (0, index_1.scryptVerifyThreadpool)(hashedPassword, passwordToCheck);
+    }
+    /**
+     * Hashes a password with SCrypt on the threadpool.
+     * @param password
+     * @returns string
+     */
+    hashPasswordThreadPool(password) {
+        if (!password) {
+            throw new Error("You must provide a password to hash with Scrypt");
+        }
+        return (0, index_1.scryptHashThreadpool)(password);
+    }
+    /**
+     * Hashes a password with SCrypt
+     * @param password
+     * @returns string
+     */
     hashPassword(password) {
         if (!password) {
             throw new Error("You must provide a password to hash with Scrypt");
         }
         return (0, index_1.scryptHash)(password);
     }
+    /**
+     * Verifies that a password is the same as the hashed password with SCrypt.
+     * @param hashedPassword
+     * @param passwordToVerify
+     * @returns boolean
+     */
     verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");

package/lib/sponges/ascon-wrapper.d.ts

@@ -1,6 +1,28 @@
 export declare class AsconWrapper {
+    /**
+     * Generates an Ascon 128 key
+     * @returns Array<number>
+     */
     ascon128Key(): Array<number>;
+    /**
+     * Generates and Ascon 128 nonce.
+     * @returns Array<number>
+     */
     ascon128Nonce(): Array<number>;
+    /**
+     * Encrypts with Ascon 128 using the key and nonce generated from ascon128Key() and ascon128Nonce() respectively.
+     * @param key
+     * @param nonce
+     * @param plaintext
+     * @returns
+     */
     ascon128Encrypt(key: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
+    /**
+    * Decrypts with Ascon 128 using the key and nonce generated from ascon128Key() and ascon128Nonce() respectively.
+    * @param key
+    * @param nonce
+    * @param ciphertext
+    * @returns Array<number>
+    */
     ascon128Decrypt(key: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
 }

package/lib/sponges/ascon-wrapper.js

@@ -3,12 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsconWrapper = void 0;
 const index_1 = require("../../index");
 class AsconWrapper {
+    /**
+     * Generates an Ascon 128 key
+     * @returns Array<number>
+     */
     ascon128Key() {
         return (0, index_1.ascon128KeyGenerate)();
     }
+    /**
+     * Generates and Ascon 128 nonce.
+     * @returns Array<number>
+     */
     ascon128Nonce() {
         return (0, index_1.ascon128NonceGenerate)();
     }
+    /**
+     * Encrypts with Ascon 128 using the key and nonce generated from ascon128Key() and ascon128Nonce() respectively.
+     * @param key
+     * @param nonce
+     * @param plaintext
+     * @returns
+     */
     ascon128Encrypt(key, nonce, plaintext) {
         if (!key || key.length === 0) {
             throw new Error("Key is required");
@@ -21,6 +36,13 @@ class AsconWrapper {
         }
         return (0, index_1.ascon128Encrypt)(key, nonce, plaintext);
     }
+    /**
+    * Decrypts with Ascon 128 using the key and nonce generated from ascon128Key() and ascon128Nonce() respectively.
+    * @param key
+    * @param nonce
+    * @param ciphertext
+    * @returns Array<number>
+    */
     ascon128Decrypt(key, nonce, ciphertext) {
         if (!key || key.length === 0) {
             throw new Error("Key is required");

package/lib/symmetric/aes-wrapper.d.ts

@@ -1,16 +1,4 @@
 import { AesKeyFromX25519SharedSecret } from "../../index";
-/**
- * @description A wrapper class that contains methods to construct keys, nonces, and methods to encrypt and decrypt with AES-128-GCM and AES-256-GCM
- *
- * @example
- * ```ts
- * const nonce = aesWrapper.generateAESNonce();
-const key = aesWrapper.aes128Key();
-const textEncoder = new TextEncoder();
-const array = Array.from(textEncoder.encode("Hello World"));
-const encrypted = aesWrapper.aes128Encrypt(key, nonce, array);
- * ```
- */
 export declare class AESWrapper {
     /**
      * @description Generates a 128 bit AES key
@@ -22,11 +10,53 @@ export declare class AESWrapper {
      * @returns returns a 256 bit AES key
      */
     aes256Key(): Array<number>;
+    /**
+     * Generates an 96 bit AES nonce
+     * @returns Array<number>
+     */
     generateAESNonce(): Array<number>;
+    /**
+     * Encrypts with AES 128.
+     * @param aesKey
+     * @param nonce
+     * @param plaintext
+     * @returns Array<number>
+     */
     aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
+    /**
+     * Decrypts with AES 128
+     * @param aesKey
+     * @param nonce
+     * @param ciphertext
+     * @returns Array<number>
+     */
     aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
+    /**
+     * Encrypts with AES-256
+     * @param aesKey
+     * @param nonce
+     * @param plaintext
+     * @returns
+     */
     aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
+    /**
+     * Decrypts with AES 256
+     * @param aesKey
+     * @param nonce
+     * @param ciphertext
+     * @returns
+     */
     aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
+    /**
+     * Derives an AES-256 key from a X25519 Diffie Hellman shared secret.
+     * @param shared_secret
+     * @returns
+     */
     aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    /**
+     * Derives an AES-128 key from a X25519 Diffie Hellman shared secret.
+     * @param shared_secret
+     * @returns
+     */
     aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
 }

package/lib/symmetric/aes-wrapper.js

@@ -2,18 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AESWrapper = void 0;
 const index_1 = require("../../index");
-/**
- * @description A wrapper class that contains methods to construct keys, nonces, and methods to encrypt and decrypt with AES-128-GCM and AES-256-GCM
- *
- * @example
- * ```ts
- * const nonce = aesWrapper.generateAESNonce();
-const key = aesWrapper.aes128Key();
-const textEncoder = new TextEncoder();
-const array = Array.from(textEncoder.encode("Hello World"));
-const encrypted = aesWrapper.aes128Encrypt(key, nonce, array);
- * ```
- */
 class AESWrapper {
     /**
      * @description Generates a 128 bit AES key
@@ -29,24 +17,66 @@ class AESWrapper {
     aes256Key() {
         return (0, index_1.aes256Key)();
     }
+    /**
+     * Generates an 96 bit AES nonce
+     * @returns Array<number>
+     */
     generateAESNonce() {
         return (0, index_1.aesNonce)();
     }
+    /**
+     * Encrypts with AES 128.
+     * @param aesKey
+     * @param nonce
+     * @param plaintext
+     * @returns Array<number>
+     */
     aes128Encrypt(aesKey, nonce, plaintext) {
         return (0, index_1.aes128Encrypt)(aesKey, nonce, plaintext);
     }
+    /**
+     * Decrypts with AES 128
+     * @param aesKey
+     * @param nonce
+     * @param ciphertext
+     * @returns Array<number>
+     */
     aes128Decrypt(aesKey, nonce, ciphertext) {
         return (0, index_1.aes128Decrypt)(aesKey, nonce, ciphertext);
     }
+    /**
+     * Encrypts with AES-256
+     * @param aesKey
+     * @param nonce
+     * @param plaintext
+     * @returns
+     */
     aes256Encrypt(aesKey, nonce, plaintext) {
         return (0, index_1.aes256Encrypt)(aesKey, nonce, plaintext);
     }
+    /**
+     * Decrypts with AES 256
+     * @param aesKey
+     * @param nonce
+     * @param ciphertext
+     * @returns
+     */
     aes256Decrypt(aesKey, nonce, ciphertext) {
         return (0, index_1.aes256Decrypt)(aesKey, nonce, ciphertext);
     }
+    /**
+     * Derives an AES-256 key from a X25519 Diffie Hellman shared secret.
+     * @param shared_secret
+     * @returns
+     */
     aes256KeyNonceX25519DiffieHellman(shared_secret) {
         return (0, index_1.aes256KeyFromX25519SharedSecret)(shared_secret);
     }
+    /**
+     * Derives an AES-128 key from a X25519 Diffie Hellman shared secret.
+     * @param shared_secret
+     * @returns
+     */
     aes128KeyNonceX25519DiffieHellman(shared_secret) {
         return (0, index_1.aes128KeyFromX25519SharedSecret)(shared_secret);
     }

package/package.json

@@ -1,7 +1,7 @@
 
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/password_hashers/argon2.rs

@@ -1,4 +1,3 @@
-use std::net::ToSocketAddrs;
 
 use napi_derive::napi;
 
@@ -7,6 +6,8 @@ use argon2::{
     Argon2, PasswordHash, PasswordHasher, PasswordVerifier,
 };
 
+use crate::symmetric::aes::CASAES128;
+
 use super::cas_password_hasher::CASPasswordHasher;
 
 pub struct CASArgon;
@@ -35,11 +36,49 @@ pub fn argon2_hash(password: String) -> String {
     return <CASArgon as CASPasswordHasher>::hash_password(password);
 }
 
+#[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
+}
+
 #[napi]
 pub fn argon2_verify(hashed_password: String, password_to_verify: String) -> bool {
     return <CASArgon as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
 }
 
+#[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
+}
+
+#[test]
+pub fn argon2_hash_threadpool_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = argon2_hash_thread_pool(password.clone());
+    assert_ne!(password, hashed);
+}
+
+#[test]
+pub fn argon2_verify_threadpool_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let passwordToCheck = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = argon2_hash_thread_pool(password);
+    let result = argon2_verify_threadpool(hashed, passwordToCheck);
+    assert_eq!(result, true);
+}
+
 #[test]
 pub fn argon2_hash_test() {
     let password = "ThisIsNotMyPasswolrd".to_string();

package/src/password_hashers/bcrypt.rs

@@ -1,3 +1,5 @@
+use std::sync::mpsc;
+
 use bcrypt::{hash, verify, DEFAULT_COST};
 use napi_derive::napi;
 
@@ -20,11 +22,33 @@ pub fn bcrypt_hash(password_to_hash: String) -> String {
     return <CASBCrypt as CASPasswordHasher>::hash_password(password_to_hash);
 }
 
+#[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
+}
+
 #[napi]
 pub fn bcrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
     return <CASBCrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
 }
 
+#[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
+}
+
 #[test]
 pub fn bcrypt_hash_test() {
     let password = "ThisIsNotMyPasswolrd".to_string();
@@ -32,6 +56,13 @@ pub fn bcrypt_hash_test() {
     assert_ne!(password, hashed);
 }
 
+#[test]
+pub fn bcrypt_hash_threadpool_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = bcrypt_hash_threadpool(password.clone());
+    assert_ne!(password, hashed);
+}
+
 #[test]
 pub fn bcrypt_verify_test() {
     let password = "ThisIsNotMyPasswolrd".to_string();
@@ -40,6 +71,14 @@ pub fn bcrypt_verify_test() {
     assert_eq!(true, verified);
 }
 
+#[test]
+pub fn bcrypt_verify_threadpool_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = bcrypt_hash_threadpool(password.clone());
+    let verified = bcrypt_verify_threadpool(hashed, password);
+    assert_eq!(true, verified);
+}
+
 #[test]
 pub fn bcrypt_verify_fail_test() {
     let password = "ThisIsNotMyPasswolrd".to_string();

package/src/password_hashers/scrypt.rs

@@ -1,3 +1,5 @@
+use std::sync::mpsc;
+
 use napi_derive::napi;
 
 use scrypt::{
@@ -36,6 +38,43 @@ pub fn scrypt_verify(hashed_password: String, password_to_verify: String) -> boo
     return <CASScrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
 }
 
+#[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
+}
+
+#[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
+}
+
+#[test]
+pub fn scrypt_hash_threadpool_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash_threadpool(password.clone());
+    assert_ne!(password, hashed_password);
+}
+
+#[test]
+pub fn scrypt_verify_threadpool_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash_threadpool(password.clone());
+    let verified = scrypt_verify_threadpool(hashed_password, password);
+    assert_eq!(true, verified);
+}
+
 #[test]
 pub fn scrypt_hash_test() {
     let password = "BadPassword".to_string();

package/src-ts/asymmetric/RSAWrapper.ts

@@ -1,6 +1,12 @@
 import { decryptCiphertextRsa, encryptPlaintextRsa, generateRsaKeys, RsaKeyPairResult, signRsa, verifyRsa } from "../../index";
 
 export class RSAWrapper {
+
+  /**
+   * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
+   * @param keySize 
+   * @returns RsaKeyPairResult
+   */
   public generateKeys(keySize: number): RsaKeyPairResult {
     if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
         throw new Error("You must provide an appropriate key size to generate RSA keys");
@@ -8,6 +14,13 @@ export class RSAWrapper {
     return generateRsaKeys(keySize);
   }
 
+  /**
+   * Encrypts a plaintext byte array with a RSA public key
+   * @param publicKey 
+   * @param plaintext 
+   * @returns Array<number>
+   */
+
   public encrypt(publicKey: string, plaintext: Array<number>): Array<number> {
     if (!publicKey) {
       throw new Error("You must provide a public key to encrypt with RSA");
@@ -18,6 +31,13 @@ export class RSAWrapper {
     return encryptPlaintextRsa(publicKey, plaintext);
   }
 
+  /**
+   * Decrypts a ciphertext with an RSA private key.
+   * @param privateKey 
+   * @param ciphertext 
+   * @returns Array<number>
+   */
+
   public decrypt(privateKey: string, ciphertext: Array<number>): Array<number> {
     if (!privateKey) {
       throw new Error("You must provide a private key to encrypt with RSA");
@@ -28,16 +48,29 @@ export class RSAWrapper {
     return decryptCiphertextRsa(privateKey, ciphertext);
   }
 
-  public sign(privateKey: string, hash: Array<number>): Array<number> {
+  /**
+   * Signs a byte array with an RSA private key for verification.
+   * @param privateKey 
+   * @param hash 
+   * @returns Array<number>
+   */
+  public sign(privateKey: string, dataToSign: Array<number>): Array<number> {
     if (!privateKey) {
       throw new Error("You must provide a private key to sign with RSA");
     }
-    if (!hash || hash.length === 0) {
+    if (!dataToSign || dataToSign.length === 0) {
       throw new Error("You must provide an allocated hash to sign with RSA");
     }
-    return signRsa(privateKey, hash);
+    return signRsa(privateKey, dataToSign);
   }
 
+  /**
+   * Verifies signed data by the corresponding private key with an RSA public key.
+   * @param publicKey 
+   * @param hash 
+   * @param signature 
+   * @returns boolean
+   */
   public verify(publicKey: string, hash: Array<number>, signature: Array<number>): boolean {
     if (!publicKey) {
       throw new Error("You must provide a public key to verify with RSA");