cas-typescript-sdk 1.0.16 → 1.0.18

package/src/digital_signature/sha_512_rsa.rs

@@ -6,14 +6,14 @@ use rsa::{
     Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey,
 };
 use sha3::{Digest, Sha3_512};
-use super::cas_digital_signature_rsa::{CASRSADigitalSignatureResult, CASRSADigitalSignature};
+use super::cas_digital_signature_rsa::{RSADigitalSignatureResult, RSADigitalSignature};
 pub struct SHA512RSADigitalSignature;
 
-impl CASRSADigitalSignature for SHA512RSADigitalSignature {
+impl RSADigitalSignature for SHA512RSADigitalSignature {
     fn digital_signature_rsa(
         rsa_key_size: u32,
         data_to_sign: Vec<u8>,
-    ) -> CASRSADigitalSignatureResult {
+    ) -> RSADigitalSignatureResult {
         let mut hasher = Sha3_512::new();
         hasher.update(data_to_sign);
         let sha_hasher_result = hasher.finalize();
@@ -24,7 +24,7 @@ impl CASRSADigitalSignature for SHA512RSADigitalSignature {
         let mut signed_data = private_key
             .sign(Pkcs1v15Sign::new_unprefixed(), &sha_hasher_result)
             .unwrap();
-        let result = CASRSADigitalSignatureResult {
+        let result = RSADigitalSignatureResult {
             private_key: private_key
                 .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
                 .unwrap()
@@ -60,7 +60,7 @@ impl CASRSADigitalSignature for SHA512RSADigitalSignature {
 pub fn sha_512_rsa_digital_signature(
     rsa_key_size: u32,
     data_to_sign: Vec<u8>,
-) -> CASRSADigitalSignatureResult {
+) -> RSADigitalSignatureResult {
     return SHA512RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign);
 }
 
@@ -77,7 +77,7 @@ pub fn sha_512_rsa_verify_digital_signature(
 fn sha_512_rsa_digital_signature_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: RSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
     let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -86,7 +86,7 @@ fn sha_512_rsa_digital_signature_test() {
 fn sha_512_rsa_digital_signature_fail_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: RSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
     let new_data = b"NOtTheOriginalData".to_vec();
     let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
     assert_eq!(is_verified, false);

package/src/lib.rs

@@ -31,4 +31,5 @@ mod digital_signature {
     pub mod sha_512_rsa;
     pub mod sha_256_rsa;
     pub mod sha_512_ed25519;
+    pub mod sha_256_ed25519;
 }

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

@@ -1,9 +1,29 @@
-import { CasrsaDigitalSignatureResult, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
+import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult, sha512Ed25519DigitalSignature, sha512Ed25519DigitalSignatureVerify, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 
 export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
 
-    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult {
+    createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return sha512Ed25519DigitalSignature(dataToSign);
+    }
+    
+    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean {
+        if (!publicKey) {
+            throw new Error("You must provide a public key for verify with ED25519");
+        }
+        if (dataToVerify?.length === 0) {
+            throw new Error("Must provide allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide allocated signature to verify");
+        }
+        return sha512Ed25519DigitalSignatureVerify(publicKey, dataToVerify, signature);
+    }
+
+    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult {
         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,6 +1,8 @@
-import { CASRSADigitalSignatureResult } from "../../index";
+import { RSADigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index";
 
 export interface IDigitalSignature {
-    createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
+    createRsa(rsa_key_size: number, data_to_sign: Array<number>): RSADigitalSignatureResult;
     verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
+    createED25519(dataToSign: Array<number>): SHAED25519DalekDigitalSignatureResult;
+    verifyED25519(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean;
 }

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

@@ -1,9 +1,29 @@
-import { CasrsaDigitalSignatureResult, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature } from "../../index";
+import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult, Shaed25519DalekDigitalSignatureResult, sha256Ed25519DigitalSignature, sha256Ed25519DigitalSignatureVerify, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature, sha512Ed25519DigitalSignature } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 
 export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
+    
+    createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return sha256Ed25519DigitalSignature(dataToSign);
+    }
+
+    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean {
+        if (!publicKey) {
+            throw new Error("You must provide a public key for verify with ED25519");
+        }
+        if (dataToVerify?.length === 0) {
+            throw new Error("Must provide allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide allocated signature to verify");
+        }
+        return sha256Ed25519DigitalSignatureVerify(publicKey, dataToVerify, signature);
+    }
 
-    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult {
+    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult {
         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

@@ -1,4 +1,11 @@
-export enum DigitalSignatureType {
-    SHA512 = 1,
-    SHA256 = 2
-}
+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";
+
+export {
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType
+};

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

@@ -1,6 +1,6 @@
 export interface IHasherBase {
-    hash_512(dataToHash: number[]): number[];
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean;
-    hash_256(dataToHash: number[]): number[];
-    verify_256(dataToHash: number[], dataToVerify: number[]): boolean;
+    hash512(dataToHash: number[]): number[];
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    hash256(dataToHash: number[]): number[];
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

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

@@ -2,14 +2,14 @@ import { sha256, sha256Verify, sha512, sha512Verify } from "../../index";
 import { IHasherBase } from "./hasher-base";
 
 export class SHAWrapper implements IHasherBase {
-    hash_512(dataToHash: number[]): number[] {
+    hash512(dataToHash: number[]): number[] {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return sha512(dataToHash);
     }
 
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean {
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
@@ -19,14 +19,14 @@ export class SHAWrapper implements IHasherBase {
         return sha512Verify(dataToHash, dataToVerify);
     }
 
-    hash_256(dataToHash: number[]): number[] {
+    hash256(dataToHash: number[]): number[] {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return sha256(dataToHash);
     }
 
-    verify_256(dataToHash: number[], dataToVerify: number[]): 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/types/aes-rsa-hybrid-initializer.ts

@@ -15,7 +15,7 @@ export class AESRSAHybridInitializer {
         this.aesType = aesType;
         let aesWrapper = new AESWrapper();
         this.aesKey = (aesType === 128) ? aesWrapper.aes128Key() : aesWrapper.aes256Key();
-        this.aesNonce = aesWrapper.aesNonce();
+        this.aesNonce = aesWrapper.generateAESNonce();
         if (rsaSize !== 1028 && rsaSize !== 2048 && rsaSize !== 4096) {
             throw new Error("You must provide an appropriate RSA Key pair size to generate a hybrid initalizer");
         }

package/src-ts/index.ts

@@ -14,6 +14,12 @@ import {
   AESRSAHybridInitializer,
   HybridEncryptionWrapper,
 } from "./hybrid/index";
+import {
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType,
+} from "./digital-signature";
 
 export {
   AesRsaHybridEncryptResult,
@@ -31,4 +37,8 @@ export {
   ScryptWrapper,
   SHAWrapper,
   X25519Wrapper,
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType,
 };

package/src-ts/key_exchange/x25519.ts

@@ -5,7 +5,7 @@ export class X25519Wrapper {
         return x25519GenerateSecretAndPublicKey();
     }
 
-    public diffieHellman(secretKey: Array<number>, publicKey: Array<number>) {
+    public generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>) {
         return x25519DiffieHellman(secretKey, publicKey);
     }
 }

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

@@ -9,7 +9,7 @@ export class Argon2Wrapper implements IPasswordHasherBase {
     return argon2Hash(password);
   }
 
-  public verifyPassword(hashedPassword: string, passwordToVerify: string): boolean {
+  public verify(hashedPassword: string, passwordToVerify: string): boolean {
     if (!hashedPassword || !passwordToVerify) {
       throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
     }

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

@@ -9,7 +9,7 @@ export class BCryptWrapper implements IPasswordHasherBase {
     return bcryptHash(password);
   }
 
-  public verifyPassword(
+  public verify(
     hashedPassword: string,
     passwordToVerify: string,
   ): boolean {

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

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

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

@@ -10,7 +10,7 @@ export class ScryptWrapper implements IPasswordHasherBase {
         return scryptHash(password);
       }
     
-      public verifyPassword(hashedPassword: string, passwordToVerify: string): boolean {
+      public verify(hashedPassword: string, passwordToVerify: string): boolean {
         if (!hashedPassword || !passwordToVerify) {
           throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");
         }

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

@@ -20,7 +20,7 @@ export class AESWrapper {
         return aes256Key();
     }
 
-    public aesNonce(): Array<number> {
+    public generateAESNonce(): Array<number> {
         return aesNonce();
     }
 
@@ -40,11 +40,11 @@ export class AESWrapper {
         return aes256Decrypt(aesKey, nonce, ciphertext);
     }
 
-    public aes256KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
          return aes256KeyFromX25519SharedSecret(shared_secret);
     }
 
-    public aes128KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
         return aes128KeyFromX25519SharedSecret(shared_secret);
    }
 }

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 { CASRSADigitalSignatureResult } from "../index";
+import { RSADigitalSignatureResult } 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: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
+        const dsResult: RSADigitalSignatureResult = 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: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
+        const dsResult: RSADigitalSignatureResult = 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: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
+        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
         assert.equal(verify, true);
     });
@@ -42,8 +42,52 @@ 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: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
+        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
         assert.equal(verify, false);
     });
+
+    it("SHA 512 ED25519 pass", () => {
+        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
+        const toHash: string = "This is my array to encrypt";
+        const encoder = new TextEncoder();
+        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
+        const dsResult = shaDsWrapper.createED25519(toHashBytes);
+        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, toHashBytes, dsResult.signature);
+        assert.equal(verify, true);
+    });
+
+    it("SHA 512 ED25519 fails", () => {
+        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
+        const toHash: string = "This is my array to encrypt";
+        const notOriginal: string = "This is not a fun time";
+        const encoder = new TextEncoder();
+        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
+        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
+        const dsResult = shaDsWrapper.createED25519(toHashBytes);
+        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, badBytes, dsResult.signature);
+        assert.equal(verify, false);
+    });
+
+    it("SHA 256 ED25519 pass", () => {
+        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
+        const toHash: string = "This is my array to encrypt";
+        const encoder = new TextEncoder();
+        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
+        const dsResult = shaDsWrapper.createED25519(toHashBytes);
+        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, toHashBytes, dsResult.signature);
+        assert.equal(verify, true);
+    });
+
+    it("SHA 256 ED25519 fails", () => {
+        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
+        const toHash: string = "This is my array to encrypt";
+        const notOriginal: string = "This is not a fun time";
+        const encoder = new TextEncoder();
+        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
+        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
+        const dsResult = shaDsWrapper.createED25519(toHashBytes);
+        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, badBytes, dsResult.signature);
+        assert.equal(verify, false);
+    });
 });

package/test-ts/hasher.test.spec.ts

@@ -7,7 +7,7 @@ describe("SHA512 Tests", () => {
     const tohashed: string = "This is my array to hash";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const hashed = wrapper.hash_512(tohashBytes);
+    const hashed = wrapper.hash512(tohashBytes);
     assert.notEqual(tohashBytes, hashed);
   });
 
@@ -16,9 +16,9 @@ describe("SHA512 Tests", () => {
     const tohashed: string = "This is my array to hash";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const hashed = wrapper.hash_512(tohashBytes);
+    const hashed = wrapper.hash512(tohashBytes);
     const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const verified = wrapper.verify_512(hashed, toVerifyBytes);
+    const verified = wrapper.verify512(hashed, toVerifyBytes);
     assert.equal(true, verified);
   });
 
@@ -27,10 +27,10 @@ describe("SHA512 Tests", () => {
     const tohashed: string = "This is my array to hash";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const hashed = wrapper.hash_512(tohashBytes);
+    const hashed = wrapper.hash512(tohashBytes);
     const toVerify = "This Is Not The Same";
     const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
-    const verified = wrapper.verify_512(hashed, toVerifyBytes);
+    const verified = wrapper.verify512(hashed, toVerifyBytes);
     assert.equal(false, verified);
   });
 });
@@ -42,7 +42,7 @@ describe("SHA256 Tests", () => {
       const tohashed: string = "This is my array to hash";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const hashed = wrapper.hash_256(tohashBytes);
+      const hashed = wrapper.hash256(tohashBytes);
       assert.notEqual(tohashBytes, hashed);
     });
   
@@ -51,9 +51,9 @@ describe("SHA256 Tests", () => {
       const tohashed: string = "This is my array to hash";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const hashed = wrapper.hash_256(tohashBytes);
+      const hashed = wrapper.hash256(tohashBytes);
       const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const verified = wrapper.verify_256(hashed, toVerifyBytes);
+      const verified = wrapper.verify256(hashed, toVerifyBytes);
       assert.equal(true, verified);
     });
   
@@ -62,10 +62,10 @@ describe("SHA256 Tests", () => {
       const tohashed: string = "This is my array to hash";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const hashed = wrapper.hash_256(tohashBytes);
+      const hashed = wrapper.hash256(tohashBytes);
       const toVerify = "This Is Not The Same";
       const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
-      const verified = wrapper.verify_256(hashed, toVerifyBytes);
+      const verified = wrapper.verify256(hashed, toVerifyBytes);
       assert.equal(false, verified);
     });
   });

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

@@ -11,11 +11,11 @@ describe("Insecure Channel Tests", () => {
       const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       
-      const alice_shared_secret = x25519Wrapper.diffieHellman(alice_keys.secretKey, bob_keys.publicKey);
-      const bob_shared_secret = x25519Wrapper.diffieHellman(bob_keys.secretKey, alice_keys.publicKey);
+      const alice_shared_secret = x25519Wrapper.generateSharedSecret(alice_keys.secretKey, bob_keys.publicKey);
+      const bob_shared_secret = x25519Wrapper.generateSharedSecret(bob_keys.secretKey, alice_keys.publicKey);
 
-      const alice_aes_key = aesWrapper.aes256KeyFromX25519SharedSecret(alice_shared_secret);
-      const bob_aes_key = aesWrapper.aes256KeyFromX25519SharedSecret(bob_shared_secret);
+      const alice_aes_key = aesWrapper.aes256KeyNonceX25519DiffieHellman(alice_shared_secret);
+      const bob_aes_key = aesWrapper.aes256KeyNonceX25519DiffieHellman(bob_shared_secret);
 
       const tohashed: string = "This is my encrypt text";
       const encoder = new TextEncoder();
@@ -33,11 +33,11 @@ describe("Insecure Channel Tests", () => {
       const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       
-      const alice_shared_secret = x25519Wrapper.diffieHellman(alice_keys.secretKey, bob_keys.publicKey);
-      const bob_shared_secret = x25519Wrapper.diffieHellman(bob_keys.secretKey, alice_keys.publicKey);
+      const alice_shared_secret = x25519Wrapper.generateSharedSecret(alice_keys.secretKey, bob_keys.publicKey);
+      const bob_shared_secret = x25519Wrapper.generateSharedSecret(bob_keys.secretKey, alice_keys.publicKey);
 
-      const alice_aes_key = aesWrapper.aes128KeyFromX25519SharedSecret(alice_shared_secret);
-      const bob_aes_key = aesWrapper.aes128KeyFromX25519SharedSecret(bob_shared_secret);
+      const alice_aes_key = aesWrapper.aes128KeyNonceX25519DiffieHellman(alice_shared_secret);
+      const bob_aes_key = aesWrapper.aes128KeyNonceX25519DiffieHellman(bob_shared_secret);
 
       const tohashed: string = "This is my encrypt text";
       const encoder = new TextEncoder();

package/test-ts/key-exchange-test.spec.ts

@@ -8,11 +8,11 @@ describe("X25519 Key Exchange", () => {
     const alice = wrapper.generateSecretAndPublicKey();
     const bob = wrapper.generateSecretAndPublicKey();
 
-    const alice_shared_secret = wrapper.diffieHellman(
+    const alice_shared_secret = wrapper.generateSharedSecret(
       alice.secretKey,
       bob.publicKey,
     );
-    const bob_shared_secret = wrapper.diffieHellman(
+    const bob_shared_secret = wrapper.generateSharedSecret(
       bob.secretKey,
       alice.publicKey,
     );

package/test-ts/password-hasher-test.spec.ts

@@ -18,7 +18,7 @@ describe("Bcrypt Tests", () => {
     const hasher: BCryptWrapper = new BCryptWrapper();
     const password: string = "NotThisPassword!@";
     const hashedPassword: string = hasher.hashPassword(password);
-    const isValid: boolean = hasher.verifyPassword(hashedPassword, password);
+    const isValid: boolean = hasher.verify(hashedPassword, password);
     expect(isValid).to.equal(true);
   });
 
@@ -26,7 +26,7 @@ describe("Bcrypt Tests", () => {
     const hasher: BCryptWrapper = new BCryptWrapper();
     const password: string = "NotThisPassword!@";
     const hashedPassword: string = hasher.hashPassword(password);
-    const isValid: boolean = hasher.verifyPassword(
+    const isValid: boolean = hasher.verify(
       hashedPassword,
       "ThesePasswordsDoNotMatch",
     );
@@ -50,7 +50,7 @@ describe("Scrypt Tests", () => {
     );
     const password: string = "ScryptRocks1231231";
     const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(hashed, password);
+    const verified: boolean = hasher.verify(hashed, password);
     assert.isTrue(verified);
   });
 
@@ -60,7 +60,7 @@ describe("Scrypt Tests", () => {
     );
     const password: string = "ScryptRocksSomeGarbageText";
     const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(
+    const verified: boolean = hasher.verify(
       hashed,
       "make this fail, its not the same",
     );
@@ -84,7 +84,7 @@ describe("Argon2 Tests", () => {
     );
     const password: string = "ScryptRocks1231231";
     const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(hashed, password);
+    const verified: boolean = hasher.verify(hashed, password);
     assert.isTrue(verified);
   });
 
@@ -94,7 +94,7 @@ describe("Argon2 Tests", () => {
     );
     const password: string = "ScryptRocksSomeGarbageText";
     const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(
+    const verified: boolean = hasher.verify(
       hashed,
       "make this fail, its not the same",
     );

package/test-ts/symmetric.test.spec.ts

@@ -6,7 +6,7 @@ describe("Symmetric Tests", () => {
   it("aes 128 encrypt and decrypt equals", () => {
     const aesWrapper: AESWrapper = new AESWrapper();
     const aesKey = aesWrapper.aes128Key();
-    const aesNonce = aesWrapper.aesNonce();
+    const aesNonce = aesWrapper.generateAESNonce();
     const tohashed: string = "This is my array to encrypt";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
@@ -19,7 +19,7 @@ describe("Symmetric Tests", () => {
   it("aes 256 encrypt and decrypt equals", () => {
     const aesWrapper: AESWrapper = new AESWrapper();
     const aesKey = aesWrapper.aes256Key();
-    const aesNonce = aesWrapper.aesNonce();
+    const aesNonce = aesWrapper.generateAESNonce();
     const tohashed: string = "This is my array to encrypt";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));

package/src-ts/global.d.ts

@@ -1,2 +0,0 @@
-declare var pathToWindowsDll: string;
-declare var pathToLinuxSO: string;