cas-typescript-sdk 1.0.22 → 1.0.24

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]

package/src/sponges/ascon_aead.rs

@@ -1,40 +1,10 @@
 
-use aes_gcm::AeadCore;
-use ascon_aead::{aead::{generic_array::GenericArray, Aead, KeyInit, OsRng}, Ascon128};
+use cas_lib::sponges::{ascon_aead::AsconAead, cas_ascon_aead::CASAsconAead};
 use napi_derive::napi;
 
-use super::cas_ascon_aead::{CASAsconAead};
-pub struct AsconAead;
-
-impl CASAsconAead for AsconAead {
-    fn encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-        let key_generic_array = GenericArray::from_slice(&key);
-        let nonce_generic_array = GenericArray::from_slice(&nonce);
-        let cipher = Ascon128::new(key_generic_array);
-        let ciphertext = cipher.encrypt(&nonce_generic_array, plaintext.as_ref()).unwrap();
-        ciphertext
-    }
-
-    fn decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-        let key_generic_array = GenericArray::from_slice(&key);
-        let nonce_generic_array = GenericArray::from_slice(&nonce);
-        let cipher = Ascon128::new(key_generic_array);
-        let plaintext = cipher.decrypt(&nonce_generic_array, ciphertext.as_ref()).unwrap();
-        plaintext
-    }
-    
-    fn generate_key() -> Vec<u8> {
-        return Ascon128::generate_key(&mut OsRng).to_vec();
-    }
-    
-    fn generate_nonce() -> Vec<u8> {
-        return Ascon128::generate_nonce(&mut OsRng).to_vec();
-    }
-}
-
 #[napi]
 pub fn ascon128_key_generate() -> Vec<u8> {
-    return AsconAead::generate_key();
+    return <AsconAead as CASAsconAead>::generate_key();
 }
 
 #[test]
@@ -45,7 +15,7 @@ fn test_ascon128_key_generate() {
 
 #[napi]
 pub fn ascon128_nonce_generate() -> Vec<u8> {
-    return AsconAead::generate_nonce();
+    return <AsconAead as CASAsconAead>::generate_nonce();
 }
 
 #[test]
@@ -56,13 +26,13 @@ pub fn test_ascon128_nonce_generate() {
 
 #[napi]
 pub fn ascon128_encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return AsconAead::encrypt(key, nonce, plaintext);
+    return <AsconAead as CASAsconAead>::encrypt(key, nonce, plaintext);
 }
 
 #[test]
 pub fn test_ascon128_encrypt() {
-    let key = AsconAead::generate_key();
-    let nonce = AsconAead::generate_nonce();
+    let key = <AsconAead as CASAsconAead>::generate_key();
+    let nonce = <AsconAead as CASAsconAead>::generate_nonce();
     let plaintext = b"Hello, World!".to_vec();
     let ciphertext = ascon128_encrypt(key.clone(), nonce.clone(), plaintext.clone());
     assert_ne!(ciphertext, plaintext);
@@ -70,13 +40,13 @@ pub fn test_ascon128_encrypt() {
 
 #[napi]
 pub fn ascon128_decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return AsconAead::decrypt(key, nonce, ciphertext);
+    return <AsconAead as CASAsconAead>::decrypt(key, nonce, ciphertext);
 }
 
 #[test]
 pub fn test_ascon128_decrypt() {
-    let key = AsconAead::generate_key();
-    let nonce = AsconAead::generate_nonce();
+    let key = <AsconAead as CASAsconAead>::generate_key();
+    let nonce = <AsconAead as CASAsconAead>::generate_nonce();
     let plaintext = b"Hello, World!".to_vec();
     let ciphertext = ascon128_encrypt(key.clone(), nonce.clone(), plaintext.clone());
     let decrypted = ascon128_decrypt(key.clone(), nonce.clone(), ciphertext.clone());

package/src/symmetric/aes.rs

@@ -1,85 +1,9 @@
-use aes_gcm::Key;
+use cas_lib::symmetric::{aes::{CASAES128, CASAES256}, cas_symmetric_encryption::CASAESEncryption};
 use napi_derive::napi;
-use rand::rngs::OsRng;
 use rand::{RngCore, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 
-use aes_gcm::{
-    aead::{generic_array::GenericArray, Aead},
-    Aes128Gcm, Aes256Gcm, KeyInit, Nonce,
-};
-
-use super::cas_symmetric_encryption::{AesKeyFromX25519SharedSecret, CASAESEncryption};
-pub struct CASAES128;
-pub struct CASAES256;
-
-impl CASAESEncryption for CASAES256 {
-    fn generate_key() -> Vec<u8> {
-        return Aes256Gcm::generate_key(&mut OsRng).to_vec();
-    }
-
-    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes256Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let ciphertext = cipher.encrypt(nonce, plaintext.as_ref()).unwrap();
-        ciphertext
-    }
-
-    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes256Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).unwrap();
-        plaintext
-    }
-
-    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
-        let aes_key = Key::<Aes256Gcm>::from_slice(&shared_secret);
-        let mut aes_nonce: [u8; 12] = Default::default();
-        aes_nonce.copy_from_slice(&shared_secret[..12]);
-        let result = AesKeyFromX25519SharedSecret {
-            aes_key: aes_key.to_vec(),
-            aes_nonce: aes_nonce.to_vec(),
-        };
-        result
-    }
-}
-
-impl CASAESEncryption for CASAES128 {
-    fn generate_key() -> Vec<u8> {
-        return Aes128Gcm::generate_key(&mut OsRng).to_vec();
-    }
-
-    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes128Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let ciphertext = cipher.encrypt(nonce, plaintext.as_ref()).unwrap();
-        ciphertext
-    }
-
-    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes128Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).unwrap();
-        plaintext
-    }
-
-    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
-        let mut aes_key: [u8; 16] = Default::default();
-        aes_key.copy_from_slice(&shared_secret[..16]);
-        let aes_key_slice = Key::<Aes128Gcm>::from_slice(&aes_key);
-        let mut aes_nonce: [u8; 12] = Default::default();
-        aes_nonce.copy_from_slice(&shared_secret[..12]);
-        let result = AesKeyFromX25519SharedSecret {
-            aes_key: aes_key_slice.to_vec(),
-            aes_nonce: aes_nonce.to_vec(),
-        };
-        result
-    }
-}
+use super::types::CASAesKeyFromX25519SharedSecret;
 
 #[napi]
 pub fn aes_nonce() -> Vec<u8> {
@@ -92,46 +16,46 @@ pub fn aes_nonce() -> Vec<u8> {
 
 #[napi]
 pub fn aes128_key() -> Vec<u8> {
-    return CASAES128::generate_key();
+    return <CASAES128 as CASAESEncryption>::generate_key();
 }
 
 #[napi]
 pub fn aes256_key() -> Vec<u8> {
-    return CASAES256::generate_key();
+    return <CASAES256 as CASAESEncryption>::generate_key();
 }
 
 #[napi]
 pub fn aes128_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return CASAES128::encrypt_plaintext(aes_key, nonce, plaintext);
+    return <CASAES128 as CASAESEncryption>::encrypt_plaintext(aes_key, nonce, plaintext);
 }
 
 #[napi]
 pub fn aes128_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return CASAES128::decrypt_ciphertext(aes_key, nonce, ciphertext);
+    return <CASAES128 as CASAESEncryption>::decrypt_ciphertext(aes_key, nonce, ciphertext);
 }
 
 #[napi]
 pub fn aes256_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return CASAES256::encrypt_plaintext(aes_key, nonce, plaintext);
+    return <CASAES256 as CASAESEncryption>::encrypt_plaintext(aes_key, nonce, plaintext);
 }
 
 #[napi]
 pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return CASAES256::decrypt_ciphertext(aes_key, nonce, ciphertext);
+    return <CASAES256 as CASAESEncryption>::decrypt_ciphertext(aes_key, nonce, ciphertext);
 }
 
 #[napi]
 pub fn aes_256_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
-) -> AesKeyFromX25519SharedSecret {
-    return CASAES256::key_from_x25519_shared_secret(shared_secret);
+) -> CASAesKeyFromX25519SharedSecret {
+    return <CASAES256 as CASAESEncryption>::key_from_x25519_shared_secret(shared_secret).into();
 }
 
 #[napi]
 pub fn aes_128_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
-) -> AesKeyFromX25519SharedSecret {
-    return CASAES128::key_from_x25519_shared_secret(shared_secret);
+) -> CASAesKeyFromX25519SharedSecret {
+    return <CASAES128 as CASAESEncryption>::key_from_x25519_shared_secret(shared_secret).into();
 }
 
 #[test]

package/src/symmetric/types.rs

@@ -0,0 +1,17 @@
+use cas_lib::symmetric::cas_symmetric_encryption::AesKeyFromX25519SharedSecret;
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct CASAesKeyFromX25519SharedSecret {
+    pub aes_key: Vec<u8>,
+    pub aes_nonce: Vec<u8>,
+}
+
+impl From<AesKeyFromX25519SharedSecret> for CASAesKeyFromX25519SharedSecret {
+    fn from(value: AesKeyFromX25519SharedSecret) -> Self {
+        CASAesKeyFromX25519SharedSecret {
+            aes_key: value.aes_key,
+            aes_nonce: value.aes_nonce
+        }
+    }
+}

package/src-ts/asymmetric/RSAWrapper.ts

@@ -1,13 +1,26 @@
-import { decryptCiphertextRsa, encryptPlaintextRsa, generateRsaKeys, RsaKeyPairResult, signRsa, verifyRsa } from "../../index";
+import { CASRSAKeyPairResult, decryptCiphertextRsa, encryptPlaintextRsa, generateRsaKeys, signRsa, verifyRsa } from "../../index";
 
 export class RSAWrapper {
-  public generateKeys(keySize: number): RsaKeyPairResult {
+
+  /**
+   * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
+   * @param keySize 
+   * @returns CASRSAKeyPairResult
+   */
+  public generateKeys(keySize: number): CASRSAKeyPairResult {
     if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
         throw new Error("You must provide an appropriate key size to generate RSA keys");
     }
     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");

package/src-ts/asymmetric/index.ts

@@ -1,4 +1,4 @@
 import { RSAWrapper } from "./RSAWrapper";
-import { RsaKeyPairResult } from "../../index";
+import { CASRSAKeyPairResult } from "../../index";
 
-export { RSAWrapper, RsaKeyPairResult };
+export { RSAWrapper, CASRSAKeyPairResult };

package/src-ts/digital-signature/digital-siganture-sha-512.ts

@@ -1,15 +1,27 @@
-import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult, sha512Ed25519DigitalSignature, sha512Ed25519DigitalSignatureVerify, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult, sha512Ed25519DigitalSignature, sha512Ed25519DigitalSignatureVerify, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 
 export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
 
-    createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult {
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign 
+     * @returns CASSHAED25519DalekDigitalSignatureResult
+     */
+    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult {
         if (dataToSign?.length === 0) {
             throw new Error("Must provide allocated data to sign");
         }
         return sha512Ed25519DigitalSignature(dataToSign);
     }
-    
+
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey 
+     * @param dataToVerify 
+     * @param signature 
+     * @returns boolean
+     */
     verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean {
         if (!publicKey) {
             throw new Error("You must provide a public key for verify with ED25519");
@@ -23,7 +35,13 @@ export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
         return sha512Ed25519DigitalSignatureVerify(publicKey, dataToVerify, signature);
     }
 
-    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult {
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size 
+     * @param data_to_sign 
+     * @returns CASRSADigitalSignatureResult
+     */
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CASRSADigitalSignatureResult {
         if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
             throw new Error("You need to provide an appropriate RSA key size.");
         }
@@ -33,6 +51,13 @@ export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
         return sha512RsaDigitalSignature(rsa_key_size, data_to_sign);
     }
     
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key 
+     * @param data_to_verify 
+     * @param signature 
+     * @returns boolean
+     */
     verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean {
         if (!public_key) {
             throw new Error("Must provide a public key");

package/src-ts/digital-signature/digital-signature-base.ts

@@ -1,8 +1,8 @@
-import { RSADigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
 
 export interface IDigitalSignature {
-    createRsa(rsa_key_size: number, data_to_sign: Array<number>): RSADigitalSignatureResult;
+    createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
     verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
-    createED25519(dataToSign: Array<number>): SHAED25519DalekDigitalSignatureResult;
+    createED25519(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult;
     verifyED25519(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean;
 }

package/src-ts/digital-signature/digital-signature-factory.ts

@@ -7,6 +7,12 @@ export enum DigitalSignatureType {
 }
 
 export class DigitalSignatureFactory {
+
+    /**
+     * Get the appropriate digital signature wrapper based upon the type passed in.
+     * @param type 
+     * @returns 
+     */
     public static get(type: DigitalSignatureType) {
         let ds = new DigitalSignatureSHA512Wrapper();
         switch (type) {

package/src-ts/digital-signature/digital-signaturte-sha-256.ts

@@ -1,15 +1,27 @@
-import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult, Shaed25519DalekDigitalSignatureResult, sha256Ed25519DigitalSignature, sha256Ed25519DigitalSignatureVerify, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature, sha512Ed25519DigitalSignature } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult, sha256Ed25519DigitalSignature, sha256Ed25519DigitalSignatureVerify, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature, sha512Ed25519DigitalSignature } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 
 export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
     
-    createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult {
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign 
+     * @returns SHAED25519DalekDigitalSignatureResult
+     */
+    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult {
         if (dataToSign?.length === 0) {
             throw new Error("Must provide allocated data to sign");
         }
         return sha256Ed25519DigitalSignature(dataToSign);
     }
 
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey 
+     * @param dataToVerify 
+     * @param signature 
+     * @returns boolean
+     */
     verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean {
         if (!publicKey) {
             throw new Error("You must provide a public key for verify with ED25519");
@@ -23,7 +35,13 @@ export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
         return sha256Ed25519DigitalSignatureVerify(publicKey, dataToVerify, signature);
     }
 
-    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult {
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size 
+     * @param data_to_sign 
+     * @returns RsaDigitalSignatureResult
+     */
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CASRSADigitalSignatureResult {
         if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
             throw new Error("You need to provide an appropriate RSA key size.");
         }
@@ -33,6 +51,13 @@ export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
         return sha256RsaDigitalSignature(rsa_key_size, data_to_sign);
     }
     
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key 
+     * @param data_to_verify 
+     * @param signature 
+     * @returns boolean
+     */
     verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean {
         if (!public_key) {
             throw new Error("Must provide a public key");

package/src-ts/digital-signature/index.ts

@@ -2,10 +2,13 @@ import { DigitalSignatureType } from "./digital-signature-factory";
 import { DigitalSignatureFactory } from "./digital-signature-factory";
 import { DigitalSignatureSHA256Wrapper } from "./digital-signaturte-sha-256";
 import { DigitalSignatureSHA512Wrapper } from "./digital-siganture-sha-512";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
 
 export {
   DigitalSignatureFactory,
   DigitalSignatureSHA256Wrapper,
   DigitalSignatureSHA512Wrapper,
-  DigitalSignatureType
+  DigitalSignatureType,
+  CASSHAED25519DalekDigitalSignatureResult,
+  CASRSADigitalSignatureResult
 };