cas-typescript-sdk 1.0.22 → 1.0.24

package/src-ts/hashers/hasher-factory.ts

@@ -2,6 +2,11 @@ import { HasherType } from "./hasher-type";
 import { SHAWrapper } from "./sha-wrapper";
 
 export class HasherFactory {
+    /**
+     * Get the appropriate hasher wrapper based upon the type based in.
+     * @param type 
+     * @returns 
+     */
     getHasher(type: HasherType): any {
         let result: SHAWrapper = new SHAWrapper();
         switch(type) {

package/src-ts/hashers/sha-wrapper.ts

@@ -2,6 +2,11 @@ import { sha256, sha256Verify, sha512, sha512Verify } from "../../index";
 import { IHasherBase } from "./hasher-base";
 
 export class SHAWrapper implements IHasherBase {
+    /**
+     * Hashes a byte array with SHA3-512.
+     * @param dataToHash 
+     * @returns number[]
+     */
     hash512(dataToHash: number[]): number[] {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
@@ -9,6 +14,12 @@ export class SHAWrapper implements IHasherBase {
         return sha512(dataToHash);
     }
 
+    /**
+     * Verifies unsigned data against an SHA3-512 hash.
+     * @param dataToHash 
+     * @param dataToVerify 
+     * @returns boolean
+     */
     verify512(dataToHash: number[], dataToVerify: number[]): boolean {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
@@ -19,6 +30,11 @@ export class SHAWrapper implements IHasherBase {
         return sha512Verify(dataToHash, dataToVerify);
     }
 
+    /**
+     * Hashes a byte array with SHA3-256.
+     * @param dataToHash 
+     * @returns number[]
+     */
     hash256(dataToHash: number[]): number[] {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
@@ -26,6 +42,12 @@ export class SHAWrapper implements IHasherBase {
         return sha256(dataToHash);
     }
 
+    /**
+     * Verifies unsigned data against an SHA3-256 hash.
+     * @param dataToHash 
+     * @param dataToVerify 
+     * @returns boolean
+     */
     verify256(dataToHash: number[], dataToVerify: number[]): boolean {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");

package/src-ts/hybrid/hybrid-encryption-wrapper.ts

@@ -12,6 +12,12 @@ export class HybridEncryptionWrapper {
     this.rsaWrapper = new RSAWrapper();
   }
 
+  /**
+   * Encrypts data with RSA/AES hybrid encryption. The data is encrypted with AES-GCM and the AES key is encrypted with the RSA public key.
+   * @param dataToEncrypt 
+   * @param initalizer 
+   * @returns AesRsaHybridEncryptResult
+   */
   public encrypt(
     dataToEncrypt: Array<number>,
     initalizer: AESRSAHybridInitializer,
@@ -40,6 +46,12 @@ export class HybridEncryptionWrapper {
     return result;
   }
 
+  /**
+   * Decrypts data with RSA/AES hybrid encryption. The RSA private key decrypts the AES key and then the data is decrypted with AES-GCM.
+   * @param dataToEncrypt 
+   * @param initalizer 
+   * @returns AesRsaHybridEncryptResult
+   */
   public decrypt(
     privateKey: string,
     encryptResult: AesRsaHybridEncryptResult,

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,8 +6,13 @@ 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.
+     * @param aesType 
+     * @param rsaSize 
+     */
     constructor(aesType: number, rsaSize: number) {
         if (aesType !== 128 && aesType !== 256) {
             throw new Error("Need an appropriate AES size to generate a hybrid initalizer");

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,11 +1,23 @@
-import { x25519DiffieHellman, x25519GenerateSecretAndPublicKey, X25519SecretPublicKeyResult } from "../../index"
+import { CASx25519SecretPublicKeyResult, x25519DiffieHellman, x25519GenerateSecretAndPublicKey } from "../../index"
 
 export class X25519Wrapper {
-    public generateSecretAndPublicKey(): X25519SecretPublicKeyResult {
+    /**
+     * Generates and secret and public key to be used to create a shared secret with Diffie Hellman.
+     * 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(): CASx25519SecretPublicKeyResult {
         return x25519GenerateSecretAndPublicKey();
     }
 
-    public generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>) {
+    /**
+     * User takes their secret key and the other user's public key to generate a shared secret.
+     * Can be used to derive an AES key over insecure channel.
+     * @param secretKey 
+     * @param publicKey 
+     * @returns Array<number>
+     */
+    public generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>): Array<number> {
         return x25519DiffieHellman(secretKey, publicKey);
     }
 }

package/src-ts/password-hashers/argon2-wrapper.ts

@@ -3,6 +3,12 @@ import { IPasswordHasherBase } from "./password-hasher-base";
 
 export class Argon2Wrapper implements IPasswordHasherBase {
 
+  /**
+   * Verifies a password with Argon2 on the threadpool.
+   * @param hashedPassword 
+   * @param passwordToCheck 
+   * @returns boolean
+   */
   verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean {
     if (!hashedPassword) {
       throw new Error("You must provide a password to verify with Argon2");
@@ -13,6 +19,11 @@ export class Argon2Wrapper implements IPasswordHasherBase {
     return argon2VerifyThreadpool(hashedPassword, passwordToCheck);
   }
 
+  /**
+   * Hashes a password with Argon2 on the threadpool.
+   * @param password 
+   * @returns string
+   */
   public hashPasswordThreadPool(password: string): string {
     if (!password) {
       throw new Error("You must provide a password to hash with Argon2");
@@ -20,6 +31,11 @@ export class Argon2Wrapper implements IPasswordHasherBase {
     return argon2HashThreadPool(password);
   }
 
+  /**
+   * Hashes a password with Argon2
+   * @param password 
+   * @returns string
+   */
   public hashPassword(password: string): string {
     if (!password) {
       throw new Error("You must provide a password to hash with Argon2");
@@ -27,6 +43,12 @@ export class Argon2Wrapper implements IPasswordHasherBase {
     return argon2Hash(password);
   }
 
+  /**
+   * Verifies that a password is the same as the hashed password with Argon2.
+   * @param hashedPassword 
+   * @param passwordToVerify 
+   * @returns boolean
+   */
   public verify(hashedPassword: string, passwordToVerify: string): boolean {
     if (!hashedPassword || !passwordToVerify) {
       throw new Error(

package/src-ts/password-hashers/bcrypt-wrapper.ts

@@ -3,6 +3,12 @@ import { bcryptHash, bcryptHashThreadpool, bcryptVerify, bcryptVerifyThreadpool
 
 export class BCryptWrapper implements IPasswordHasherBase {
 
+  /**
+   * Verifies a password with BCrypt on the threadpool.
+   * @param hashedPassword 
+   * @param passwordToCheck 
+   * @returns boolean
+   */
   verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean {
     if (!hashedPassword || !passwordToCheck) {
       throw new Error(
@@ -12,6 +18,11 @@ export class BCryptWrapper implements IPasswordHasherBase {
     return bcryptVerifyThreadpool(hashedPassword, passwordToCheck);
   }
 
+  /**
+   * Hashes a password with BCrypt on the threadpool.
+   * @param password 
+   * @returns string
+   */
   public hashPasswordThreadPool(password: string): string {
     if (!password) {
       throw new Error("You must provide a password to hash with Argon2");
@@ -19,6 +30,11 @@ export class BCryptWrapper implements IPasswordHasherBase {
     return bcryptHashThreadpool(password);
   }
 
+  /**
+   * Hashes a password with BCrypt
+   * @param password 
+   * @returns string
+   */
   public hashPassword(password: string): string {
     if (!password) {
       throw new Error("You must provide a password to hash with Argon2");
@@ -26,6 +42,12 @@ export class BCryptWrapper implements IPasswordHasherBase {
     return bcryptHash(password);
   }
 
+  /**
+   * Verifies that a password is the same as the hashed password with BCrypt.
+   * @param hashedPassword 
+   * @param passwordToVerify 
+   * @returns boolean
+   */
   public verify(
     hashedPassword: string,
     passwordToVerify: string,

package/src-ts/password-hashers/password-hasher-factory.ts

@@ -4,6 +4,11 @@ import { PasswordHasherType } from "./password-hasher-type";
 import { ScryptWrapper } from "./scrypt-wrapper";
 
 export class PasswordHasherFactory {
+  /**
+   * Returns the appropriate hasher type based upon the type passed in.
+   * @param type 
+   * @returns 
+   */
   static getHasher(type: PasswordHasherType): any {
     // Argon2 by default
     let hasher = new Argon2Wrapper();

package/src-ts/password-hashers/scrypt-wrapper.ts

@@ -3,6 +3,12 @@ import { IPasswordHasherBase } from "./password-hasher-base";
 
 export class ScryptWrapper implements IPasswordHasherBase {
 
+  /**
+   * Verifies a password with SCrypt on the threadpool.
+   * @param hashedPassword 
+   * @param passwordToCheck 
+   * @returns boolean
+   */
   verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean {
     if (!hashedPassword || !passwordToCheck) {
       throw new Error(
@@ -12,6 +18,11 @@ export class ScryptWrapper implements IPasswordHasherBase {
     return scryptVerifyThreadpool(hashedPassword, passwordToCheck);
   }
 
+  /**
+   * Hashes a password with SCrypt on the threadpool.
+   * @param password 
+   * @returns string
+   */
   hashPasswordThreadPool(password: string): string {
     if (!password) {
       throw new Error("You must provide a password to hash with Scrypt");
@@ -19,6 +30,11 @@ export class ScryptWrapper implements IPasswordHasherBase {
     return scryptHashThreadpool(password);
   }
 
+  /**
+   * Hashes a password with SCrypt
+   * @param password 
+   * @returns string
+   */
   public hashPassword(password: string): string {
     if (!password) {
       throw new Error("You must provide a password to hash with Scrypt");
@@ -26,6 +42,12 @@ export class ScryptWrapper implements IPasswordHasherBase {
     return scryptHash(password);
   }
 
+  /**
+   * Verifies that a password is the same as the hashed password with SCrypt.
+   * @param hashedPassword 
+   * @param passwordToVerify 
+   * @returns boolean
+   */
   public verify(hashedPassword: string, passwordToVerify: string): boolean {
     if (!hashedPassword || !passwordToVerify) {
       throw new Error(

package/src-ts/sponges/ascon-wrapper.ts

@@ -6,14 +6,29 @@ import {
 } from "../../index";
 
 export class AsconWrapper {
+  /**
+   * Generates an Ascon 128 key
+   * @returns Array<number>
+   */
   ascon128Key(): Array<number> {
     return ascon128KeyGenerate();
   }
 
+  /**
+   * Generates and Ascon 128 nonce.
+   * @returns Array<number>
+   */
   ascon128Nonce(): Array<number> {
     return 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: Array<number>,
     nonce: Array<number>,
@@ -31,6 +46,13 @@ export class AsconWrapper {
     return 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: Array<number>,
     nonce: Array<number>,

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

@@ -1,5 +1,5 @@
 import {
-  AesKeyFromX25519SharedSecret,
+  CASAesKeyFromX25519SharedSecret,
   aes128Decrypt,
   aes128Encrypt,
   aes128Key,
@@ -11,18 +11,7 @@ import {
   aesNonce,
 } 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 class AESWrapper {
 
     /**
@@ -41,31 +30,73 @@ export class AESWrapper {
         return aes256Key();
     }
 
+    /**
+     * Generates an 96 bit AES nonce
+     * @returns Array<number>
+     */
     public generateAESNonce(): Array<number> {
         return aesNonce();
     }
 
+    /**
+     * Encrypts with AES 128.
+     * @param aesKey 
+     * @param nonce 
+     * @param plaintext 
+     * @returns Array<number>
+     */
     public aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
         return aes128Encrypt(aesKey, nonce, plaintext);
     }
 
+    /**
+     * Decrypts with AES 128
+     * @param aesKey 
+     * @param nonce 
+     * @param ciphertext 
+     * @returns Array<number>
+     */
     public aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
         return aes128Decrypt(aesKey, nonce, ciphertext);
     }
 
+    /**
+     * Encrypts with AES-256
+     * @param aesKey 
+     * @param nonce 
+     * @param plaintext 
+     * @returns 
+     */
     public aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
         return aes256Encrypt(aesKey, nonce, plaintext);
     }
 
+    /**
+     * Decrypts with AES 256
+     * @param aesKey 
+     * @param nonce 
+     * @param ciphertext 
+     * @returns 
+     */
     public aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
         return aes256Decrypt(aesKey, nonce, ciphertext);
     }
 
-    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    /**
+     * Derives an AES-256 key from a X25519 Diffie Hellman shared secret.
+     * @param shared_secret 
+     * @returns 
+     */
+    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret {
          return aes256KeyFromX25519SharedSecret(shared_secret);
     }
 
-    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    /**
+     * Derives an AES-128 key from a X25519 Diffie Hellman shared secret.
+     * @param shared_secret 
+     * @returns 
+     */
+    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/lib/helpers/nonce-generator.d.ts

@@ -1,3 +0,0 @@
-export declare class NonceGenerator {
-    generateNonce(): string;
-}

package/lib/helpers/nonce-generator.js

@@ -1,34 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NonceGenerator = void 0;
-const crypto = __importStar(require("crypto"));
-class NonceGenerator {
-    generateNonce() {
-        const nonceBytes = crypto.randomBytes(12);
-        return nonceBytes.toString('hex').substring(0, 12);
-    }
-}
-exports.NonceGenerator = NonceGenerator;

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