cas-typescript-sdk 1.0.23 → 1.0.24

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,13 @@
-import { decryptCiphertextRsa, encryptPlaintextRsa, generateRsaKeys, RsaKeyPairResult, signRsa, verifyRsa } from "../../index";
+import { CASRSAKeyPairResult, decryptCiphertextRsa, encryptPlaintextRsa, generateRsaKeys, 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
+   * @returns CASRSAKeyPairResult
    */
-  public generateKeys(keySize: number): RsaKeyPairResult {
+  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");
     }

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,4 +1,4 @@
-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 {
@@ -6,9 +6,9 @@ export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
     /**
      * Creates an ED25519 siganture from an array of bytes with SHA3-512.
      * @param dataToSign 
-     * @returns SHAED25519DalekDigitalSignatureResult
+     * @returns CASSHAED25519DalekDigitalSignatureResult
      */
-    createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult {
+    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult {
         if (dataToSign?.length === 0) {
             throw new Error("Must provide allocated data to sign");
         }
@@ -39,9 +39,9 @@ export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
      * Generates and RSA digital signature with SHA3-512
      * @param rsa_key_size 
      * @param data_to_sign 
-     * @returns RsaDigitalSignatureResult
+     * @returns CASRSADigitalSignatureResult
      */
-    createRsa(rsa_key_size: number, data_to_sign: number[]): 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.");
         }

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-signaturte-sha-256.ts

@@ -1,4 +1,4 @@
-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 {
@@ -8,7 +8,7 @@ export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
      * @param dataToSign 
      * @returns SHAED25519DalekDigitalSignatureResult
      */
-    createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult {
+    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult {
         if (dataToSign?.length === 0) {
             throw new Error("Must provide allocated data to sign");
         }
@@ -41,7 +41,7 @@ export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
      * @param data_to_sign 
      * @returns RsaDigitalSignatureResult
      */
-    createRsa(rsa_key_size: number, data_to_sign: number[]): 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.");
         }

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
 };

package/src-ts/hybrid/types/aes-rsa-hybrid-initializer.ts

@@ -1,4 +1,4 @@
-import { RsaKeyPairResult } from "../../..";
+import { CASRSAKeyPairResult } from "../../..";
 import { RSAWrapper } from "../../asymmetric";
 import { AESWrapper } from "../../symmetric";
 
@@ -6,7 +6,7 @@ export class AESRSAHybridInitializer {
     public aesType: number;
     public aesKey: Array<number>;
     public aesNonce: Array<number>;
-    public rsaKeyPair: RsaKeyPairResult;
+    public rsaKeyPair: CASRSAKeyPairResult;
 
     /**
      * Constructs an initalizer to use with Hybrid Encryption wrapper. Generates your RSA key pair, AES nonce, and AES key based on the parameters passed in.

package/src-ts/index.ts

@@ -1,46 +1,8 @@
-import {
-  Argon2Wrapper,
-  BCryptWrapper,
-  PasswordHasherFactory,
-  PasswordHasherType,
-  ScryptWrapper,
-} from "./password-hashers/index";
-import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
-import { X25519Wrapper } from "./key_exchange/index";
-import { AESWrapper } from "./symmetric/index";
-import { RsaKeyPairResult, RSAWrapper } from "./asymmetric/index";
-import {
-  AesRsaHybridEncryptResult,
-  AESRSAHybridInitializer,
-  HybridEncryptionWrapper,
-} from "./hybrid/index";
-import {
-  DigitalSignatureFactory,
-  DigitalSignatureSHA256Wrapper,
-  DigitalSignatureSHA512Wrapper,
-  DigitalSignatureType,
-} from "./digital-signature";
-import { AsconWrapper } from "./sponges/index";
-
-export {
-  AesRsaHybridEncryptResult,
-  AESRSAHybridInitializer,
-  AESWrapper,
-  Argon2Wrapper,
-  AsconWrapper,
-  BCryptWrapper,
-  DigitalSignatureFactory,
-  DigitalSignatureSHA256Wrapper,
-  DigitalSignatureSHA512Wrapper,
-  DigitalSignatureType,
-  HasherFactory,
-  HasherType,
-  HybridEncryptionWrapper,
-  PasswordHasherFactory,
-  PasswordHasherType,
-  RsaKeyPairResult,
-  RSAWrapper,
-  ScryptWrapper,
-  SHAWrapper,
-  X25519Wrapper,
-};
+export * from "./password-hashers/index";
+export * from "./hashers/index";
+export * from "./key_exchange/index";
+export * from "./symmetric/index";
+export * from "./asymmetric/index";
+export * from "./hybrid/index";
+export * from "./digital-signature";
+export * from "./sponges/index";

package/src-ts/key_exchange/index.ts

@@ -1,3 +1,4 @@
+import { CASx25519SecretPublicKeyResult } from "../../index";
 import { X25519Wrapper } from "./x25519";
 
-export { X25519Wrapper };
+export { X25519Wrapper, CASx25519SecretPublicKeyResult };

package/src-ts/key_exchange/x25519.ts

@@ -1,4 +1,4 @@
-import { x25519DiffieHellman, x25519GenerateSecretAndPublicKey, X25519SecretPublicKeyResult } from "../../index"
+import { CASx25519SecretPublicKeyResult, x25519DiffieHellman, x25519GenerateSecretAndPublicKey } from "../../index"
 
 export class X25519Wrapper {
     /**
@@ -6,7 +6,7 @@ export class X25519Wrapper {
      * User should share their public key with the other user and take the other user's public key and they can generate a Shared Secret.
      * @returns X25519SecretPublicKeyResult
      */
-    public generateSecretAndPublicKey(): X25519SecretPublicKeyResult {
+    public generateSecretAndPublicKey(): CASx25519SecretPublicKeyResult {
         return x25519GenerateSecretAndPublicKey();
     }
 

package/src-ts/symmetric/aes-wrapper.ts

@@ -1,5 +1,5 @@
 import {
-  AesKeyFromX25519SharedSecret,
+  CASAesKeyFromX25519SharedSecret,
   aes128Decrypt,
   aes128Encrypt,
   aes128Key,
@@ -87,7 +87,7 @@ export class AESWrapper {
      * @param shared_secret 
      * @returns 
      */
-    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret {
          return aes256KeyFromX25519SharedSecret(shared_secret);
     }
 
@@ -96,7 +96,7 @@ export class AESWrapper {
      * @param shared_secret 
      * @returns 
      */
-    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret {
         return aes128KeyFromX25519SharedSecret(shared_secret);
    }
 }

package/src-ts/symmetric/index.ts

@@ -1,3 +1,4 @@
+import { CASAesKeyFromX25519SharedSecret } from "../../index";
 import { AESWrapper } from "./aes-wrapper";
 
-export { AESWrapper };
+export { AESWrapper, CASAesKeyFromX25519SharedSecret };

package/test-ts/asymmetric.test.spec.ts

@@ -1,11 +1,11 @@
 import { assert } from "chai";
-import { RSAWrapper, RsaKeyPairResult } from "..";
+import { CASRSAKeyPairResult, RSAWrapper } from "..";
 import { areEqual } from "./helpers/array";
 
 describe("Asymmetric Tests", () => {
     it("RSA 4096 encrypt and decrypt equals", () => {
       const rsaWrapper: RSAWrapper = new RSAWrapper();
-      const keys: RsaKeyPairResult = rsaWrapper.generateKeys(4096);
+      const keys: CASRSAKeyPairResult = rsaWrapper.generateKeys(4096);
       const tohashed: string = "This is my array to encrypt";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
@@ -17,7 +17,7 @@ describe("Asymmetric Tests", () => {
 
     it("RSA 2048 Sign and Verify", () => {
       const rsaWrapper = new RSAWrapper();
-      const keys: RsaKeyPairResult = rsaWrapper.generateKeys(2048);
+      const keys: CASRSAKeyPairResult = rsaWrapper.generateKeys(2048);
       const tohashed: string = "This is my encrypt";
       const encoder = new TextEncoder();
       const toSignBytes: Array<number> = Array.from(encoder.encode(tohashed));

package/test-ts/digital-signature.test.spec.ts

@@ -1,6 +1,6 @@
 import { assert } from "chai";
 import { DigitalSignatureFactory, DigitalSignatureType } from "../src-ts/digital-signature/digital-signature-factory";
-import { RSADigitalSignatureResult } from "../index";
+import { CASRSADigitalSignatureResult } from "../index";
 
 describe("Digital Signature", () => {
     it("SHA 512 RSA pass", () => {
@@ -8,7 +8,7 @@ describe("Digital Signature", () => {
         const tohashed: string = "This is my array to encrypt";
         const encoder = new TextEncoder();
         const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
+        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
         assert.equal(verify, true);
     });
@@ -20,7 +20,7 @@ describe("Digital Signature", () => {
         const encoder = new TextEncoder();
         const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
         const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
+        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
         assert.equal(verify, false);
     });
@@ -30,7 +30,7 @@ describe("Digital Signature", () => {
         const tohashed: string = "This is my array to encrypt";
         const encoder = new TextEncoder();
         const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
+        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
         assert.equal(verify, true);
     });
@@ -42,7 +42,7 @@ describe("Digital Signature", () => {
         const encoder = new TextEncoder();
         const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
         const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
+        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
         assert.equal(verify, false);
     });

package/test-ts/insecure-channel.test.spec.ts

@@ -1,6 +1,6 @@
 import {AESWrapper} from "../src-ts/symmetric/index";
 import {X25519Wrapper} from "../src-ts/key_exchange/index";
-import {X25519SecretPublicKeyResult} from "../index";
+import {CASx25519SecretPublicKeyResult} from "../index";
 import { areEqual } from "./helpers/array";
 import { assert } from "chai";
 
@@ -8,8 +8,8 @@ describe("Insecure Channel Tests", () => {
     it("AES256-GBC Diffie Hellman X25519", () => {
       const aesWrapper = new AESWrapper();
       const x25519Wrapper = new X25519Wrapper();
-      const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
+      const alice_keys: CASx25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
+      const bob_keys: CASx25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       
       const alice_shared_secret = x25519Wrapper.generateSharedSecret(alice_keys.secretKey, bob_keys.publicKey);
       const bob_shared_secret = x25519Wrapper.generateSharedSecret(bob_keys.secretKey, alice_keys.publicKey);
@@ -30,8 +30,8 @@ describe("Insecure Channel Tests", () => {
     it("AES128-GBC Diffie Hellman X25519", () => {
       const aesWrapper = new AESWrapper();
       const x25519Wrapper = new X25519Wrapper();
-      const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
+      const alice_keys: CASx25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
+      const bob_keys: CASx25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       
       const alice_shared_secret = x25519Wrapper.generateSharedSecret(alice_keys.secretKey, bob_keys.publicKey);
       const bob_shared_secret = x25519Wrapper.generateSharedSecret(bob_keys.secretKey, alice_keys.publicKey);

package/src/asymmetric/cas_asymmetric_encryption.rs

@@ -1,15 +0,0 @@
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct RSAKeyPairResult {
-    pub private_key: String,
-    pub public_key: String,
-}
-
-pub trait CASRSAEncryption {
-    fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult;
-    fn encrypt_plaintext(public_key: String, plaintext: Vec<u8>) -> Vec<u8>;
-    fn decrypt_ciphertext(private_key: String, ciphertext: Vec<u8>) -> Vec<u8>;
-    fn sign(private_key: String, hash: Vec<u8>) -> Vec<u8>;
-    fn verify(public_key: String, hash: Vec<u8>, signed_text: Vec<u8>) -> bool;
-}

package/src/digital_signature/cas_digital_signature_rsa.rs

@@ -1,27 +0,0 @@
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct RSADigitalSignatureResult {
-    pub public_key: String,
-    pub private_key: String,
-    pub signature: Vec<u8>,
-}
-
-#[napi(constructor)]
-pub struct SHAED25519DalekDigitalSignatureResult {
-    pub public_key: Vec<u8>,
-    pub signature: Vec<u8>
-}
-
-pub trait RSADigitalSignature {
-    fn digital_signature_rsa(
-        rsa_key_size: u32,
-        data_to_sign: Vec<u8>,
-    ) -> RSADigitalSignatureResult;
-    fn verify_rsa(public_key: String, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
-}
-
-pub trait ED25519DigitalSignature {
-    fn digital_signature_ed25519(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult;
-    fn digital_signature_ed25519_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
-}