cas-typescript-sdk 1.0.17 → 1.0.18

package/lib/hashers/hasher-base.d.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/lib/hashers/sha-wrapper.d.ts

@@ -1,7 +1,7 @@
 import { IHasherBase } from "./hasher-base";
 export declare class SHAWrapper implements 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/lib/hashers/sha-wrapper.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SHAWrapper = void 0;
 const index_1 = require("../../index");
 class SHAWrapper {
-    hash_512(dataToHash) {
+    hash512(dataToHash) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return (0, index_1.sha512)(dataToHash);
     }
-    verify_512(dataToHash, dataToVerify) {
+    verify512(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
@@ -18,13 +18,13 @@ class SHAWrapper {
         }
         return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
     }
-    hash_256(dataToHash) {
+    hash256(dataToHash) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return (0, index_1.sha256)(dataToHash);
     }
-    verify_256(dataToHash, dataToVerify) {
+    verify256(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }

package/lib/hybrid/types/aes-rsa-hybrid-initializer.js

@@ -15,7 +15,7 @@ class AESRSAHybridInitializer {
         this.aesType = aesType;
         let aesWrapper = new symmetric_1.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/lib/key_exchange/x25519.d.ts

@@ -1,5 +1,5 @@
 import { X25519SecretPublicKeyResult } from "../../index";
 export declare class X25519Wrapper {
     generateSecretAndPublicKey(): X25519SecretPublicKeyResult;
-    diffieHellman(secretKey: Array<number>, publicKey: Array<number>): number[];
+    generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>): number[];
 }

package/lib/key_exchange/x25519.js

@@ -6,7 +6,7 @@ class X25519Wrapper {
     generateSecretAndPublicKey() {
         return (0, index_1.x25519GenerateSecretAndPublicKey)();
     }
-    diffieHellman(secretKey, publicKey) {
+    generateSharedSecret(secretKey, publicKey) {
         return (0, index_1.x25519DiffieHellman)(secretKey, publicKey);
     }
 }

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

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class Argon2Wrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

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

@@ -9,7 +9,7 @@ class Argon2Wrapper {
         }
         return (0, index_1.argon2Hash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
         }

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

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class BCryptWrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

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

@@ -9,7 +9,7 @@ class BCryptWrapper {
         }
         return (0, index_1.bcryptHash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
         }

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

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

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

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class ScryptWrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

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

@@ -9,7 +9,7 @@ class ScryptWrapper {
         }
         return (0, index_1.scryptHash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");
         }

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

@@ -2,11 +2,11 @@ import { AesKeyFromX25519SharedSecret } from "../../index";
 export declare class AESWrapper {
     aes128Key(): Array<number>;
     aes256Key(): Array<number>;
-    aesNonce(): Array<number>;
+    generateAESNonce(): Array<number>;
     aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
     aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
     aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
     aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
-    aes256KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
-    aes128KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
 }

package/lib/symmetric/aes-wrapper.js

@@ -9,7 +9,7 @@ class AESWrapper {
     aes256Key() {
         return (0, index_1.aes256Key)();
     }
-    aesNonce() {
+    generateAESNonce() {
         return (0, index_1.aesNonce)();
     }
     aes128Encrypt(aesKey, nonce, plaintext) {
@@ -24,10 +24,10 @@ class AESWrapper {
     aes256Decrypt(aesKey, nonce, ciphertext) {
         return (0, index_1.aes256Decrypt)(aesKey, nonce, ciphertext);
     }
-    aes256KeyFromX25519SharedSecret(shared_secret) {
+    aes256KeyNonceX25519DiffieHellman(shared_secret) {
         return (0, index_1.aes256KeyFromX25519SharedSecret)(shared_secret);
     }
-    aes128KeyFromX25519SharedSecret(shared_secret) {
+    aes128KeyNonceX25519DiffieHellman(shared_secret) {
         return (0, index_1.aes128KeyFromX25519SharedSecret)(shared_secret);
     }
 }

package/package.json

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

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/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/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));