cas-typescript-sdk 1.0.31 → 1.0.32

package/README.md

@@ -8,8 +8,7 @@ The official NPM page can be found [here](https://www.npmjs.com/package/cas-type
 
 **Note: All work is experimental and we understand some benchmarks might not be the most optimal.**
 
-
-
+**[You can find some usage examples here](https://github.com/Cryptographic-API-Services/cas-typescript-sdk/blob/main/docs/EXAMPLES.md)**
 
 ## Consuming Library Documentation
 This Node.js NPM module is dependent on our Rust layer [cas-lib](https://github.com/Cryptographic-API-Services/cas-lib). that contains methods to run industry-standard cryptographic operations sequentially, on threads, and the thread pool.

package/index.d.ts

@@ -19,6 +19,14 @@ export declare function sha512(dataToHash: Array<number>): Array<number>
 export declare function sha512Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
 export declare function sha256(dataToHash: Array<number>): Array<number>
 export declare function sha256Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
+export declare function blake2Sha512(dataToHash: Array<number>): Array<number>
+export declare function blake2Sha512Threadpool(dataToHash: Array<number>): Array<number>
+export declare function blake2Sha512Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
+export declare function blake2Sha512VerifyThreadpool(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
+export declare function blake2Sha256(dataToHash: Array<number>): Array<number>
+export declare function blake2Sha256Threadpool(dataToHash: Array<number>): Array<number>
+export declare function blake2Sha256Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
+export declare function blake2Sha256VerifyThreadpool(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
 export declare function x25519GenerateSecretAndPublicKey(): CASx25519SecretPublicKeyResult
 export declare function x25519DiffieHellman(mySecretKey: Array<number>, usersPublicKey: Array<number>): Array<number>
 export declare function aesNonce(): Array<number>

package/lib/hashers/blake2-wrapper.d.ts

@@ -0,0 +1,55 @@
+import { IHasherBase } from "./hasher-base";
+export declare class Blake2Wrapper implements IHasherBase {
+    /**
+     * Hashes the input data using Blake2b 512
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash512(dataToHash: number[]): number[];
+    /**
+     * Hashes the input data using Blake2b 512 in a thread pool
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash512Threadpool(dataToHash: number[]): number[];
+    /**
+     * Verifies the input data against the hashed output using Blake2b 512
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    /**
+     * Verifies the input data against the hashed output using Blake2b 512 in a thread pool
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify512Threadpool(dataToHash: number[], dataToVerify: number[]): boolean;
+    /**
+     * Hashes the input data using Blake2b 256
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash256(dataToHash: number[]): number[];
+    /**
+     * Hashes the input data using Blake2b 256 in a thread pool
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash256Threadpool(dataToHash: number[]): number[];
+    /**
+     * Verifies the input data against the hashed output using Blake2b 256
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean;
+    /**
+     * Verifies the input data against the hashed output using Blake2b 256 in a thread pool
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify256Threadpool(dataToHash: number[], dataToVerify: number[]): boolean;
+}

package/lib/hashers/blake2-wrapper.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blake2Wrapper = void 0;
+const index_1 = require("../../index");
+class Blake2Wrapper {
+    /**
+     * Hashes the input data using Blake2b 512
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash512(dataToHash) {
+        return (0, index_1.blake2Sha512)(dataToHash);
+    }
+    /**
+     * Hashes the input data using Blake2b 512 in a thread pool
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash512Threadpool(dataToHash) {
+        return (0, index_1.blake2Sha512Threadpool)(dataToHash);
+    }
+    /**
+     * Verifies the input data against the hashed output using Blake2b 512
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify512(dataToHash, dataToVerify) {
+        return (0, index_1.blake2Sha512Verify)(dataToHash, dataToVerify);
+    }
+    /**
+     * Verifies the input data against the hashed output using Blake2b 512 in a thread pool
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify512Threadpool(dataToHash, dataToVerify) {
+        return (0, index_1.blake2Sha512VerifyThreadpool)(dataToHash, dataToVerify);
+    }
+    /**
+     * Hashes the input data using Blake2b 256
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash256(dataToHash) {
+        return (0, index_1.blake2Sha256)(dataToHash);
+    }
+    /**
+     * Hashes the input data using Blake2b 256 in a thread pool
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash256Threadpool(dataToHash) {
+        return (0, index_1.blake2Sha256Threadpool)(dataToHash);
+    }
+    /**
+     * Verifies the input data against the hashed output using Blake2b 256
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify256(dataToHash, dataToVerify) {
+        return (0, index_1.blake2Sha256Verify)(dataToHash, dataToVerify);
+    }
+    /**
+     * Verifies the input data against the hashed output using Blake2b 256 in a thread pool
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify256Threadpool(dataToHash, dataToVerify) {
+        return (0, index_1.blake2Sha256VerifyThreadpool)(dataToHash, dataToVerify);
+    }
+}
+exports.Blake2Wrapper = Blake2Wrapper;

package/lib/hashers/hasher-factory.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HasherFactory = void 0;
+const blake2_wrapper_1 = require("./blake2-wrapper");
+const hasher_type_1 = require("./hasher-type");
 const sha_wrapper_1 = require("./sha-wrapper");
 class HasherFactory {
     /**
@@ -11,6 +13,8 @@ class HasherFactory {
     getHasher(type) {
         let result = new sha_wrapper_1.SHAWrapper();
         switch (type) {
+            case hasher_type_1.HasherType.Blake2:
+                result = new blake2_wrapper_1.Blake2Wrapper();
         }
         return result;
     }

package/lib/hashers/hasher-type.d.ts

@@ -1,3 +1,4 @@
 export declare enum HasherType {
-    SHA = 1
+    SHA = 1,
+    Blake2 = 2
 }

package/lib/hashers/hasher-type.js

@@ -4,4 +4,5 @@ exports.HasherType = void 0;
 var HasherType;
 (function (HasherType) {
     HasherType[HasherType["SHA"] = 1] = "SHA";
+    HasherType[HasherType["Blake2"] = 2] = "Blake2";
 })(HasherType || (exports.HasherType = HasherType = {}));

package/lib/hashers/index.d.ts

@@ -1,4 +1,5 @@
 import { HasherFactory } from "./hasher-factory";
 import { HasherType } from "./hasher-type";
 import { SHAWrapper } from "./sha-wrapper";
-export { SHAWrapper, HasherFactory, HasherType };
+import { Blake2Wrapper } from "./blake2-wrapper";
+export { SHAWrapper, HasherFactory, HasherType, Blake2Wrapper };

package/lib/hashers/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HasherType = exports.HasherFactory = exports.SHAWrapper = void 0;
+exports.Blake2Wrapper = exports.HasherType = exports.HasherFactory = exports.SHAWrapper = void 0;
 const hasher_factory_1 = require("./hasher-factory");
 Object.defineProperty(exports, "HasherFactory", { enumerable: true, get: function () { return hasher_factory_1.HasherFactory; } });
 const hasher_type_1 = require("./hasher-type");
 Object.defineProperty(exports, "HasherType", { enumerable: true, get: function () { return hasher_type_1.HasherType; } });
 const sha_wrapper_1 = require("./sha-wrapper");
 Object.defineProperty(exports, "SHAWrapper", { enumerable: true, get: function () { return sha_wrapper_1.SHAWrapper; } });
+const blake2_wrapper_1 = require("./blake2-wrapper");
+Object.defineProperty(exports, "Blake2Wrapper", { enumerable: true, get: function () { return blake2_wrapper_1.Blake2Wrapper; } });

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
-    "test": "cargo test --release && npm run build && mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
+    "test": "npm run rust:test && npm run build && npm run node:test",
     "node:test": "mocha -r ts-node/register ./test-ts/**/*.test.spec.ts --timeout 20000 --recursive",
     "rust:test": "cargo test --release",
     "build": "npm run build:rust && rimraf lib && tsc",
@@ -29,13 +29,13 @@
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
-    "@types/chai": "^4.3.11",
-    "@types/mocha": "^10.0.6",
-    "@types/node-fetch": "^2.6.3",
-    "chai": "^4.4.1",
-    "mocha": "^10.2.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.0.3",
-    "rimraf": "^6.0.1"
+    "@types/chai": "^4.3.20",
+    "@types/mocha": "^10.0.10",
+    "@types/node-fetch": "^2.6.12",
+    "chai": "^4.5.0",
+    "mocha": "^10.8.2",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
   }
 }

package/src/hashers/blake2.rs

@@ -0,0 +1,127 @@
+use cas_lib::hashers::{blake2::CASBlake2, cas_hasher::CASHasher};
+use napi_derive::napi;
+
+#[napi]
+pub fn blake2_sha_512(data_to_hash: Vec<u8>) -> Vec<u8> {
+    return CASBlake2::hash_512(data_to_hash);
+}
+
+#[napi]
+pub fn blake2_sha_512_threadpool(data_to_hash: Vec<u8>) -> Vec<u8> {
+    return CASBlake2::hash_512_threadpool(data_to_hash);
+}
+
+#[napi]
+pub fn blake2_sha_512_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+    return CASBlake2::verify_512(data_to_hash, data_to_verify);
+}
+
+#[napi]
+pub fn blake2_sha_512_verify_threadpool(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+    return CASBlake2::verify_512_threadpool(data_to_hash, data_to_verify);
+}
+
+#[napi]
+pub fn blake2_sha_256(data_to_hash: Vec<u8>) -> Vec<u8> {
+    return CASBlake2::hash_256(data_to_hash);
+}
+
+#[napi]
+pub fn blake2_sha_256_threadpool(data_to_hash: Vec<u8>) -> Vec<u8> {
+    return CASBlake2::hash_256_threadpool(data_to_hash);
+}
+
+#[napi]
+pub fn blake2_sha_256_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+    return CASBlake2::verify_256(data_to_hash, data_to_verify);
+}
+
+#[napi]
+pub fn blake2_sha_256_verify_threadpool(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+    return CASBlake2::verify_256_threadpool(data_to_hash, data_to_verify);
+}
+
+#[test]
+pub fn blake2_sha_512_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let hashed_data = blake2_sha_512(data_to_hash.clone());
+    assert_ne!(true, hashed_data.eq(&data_to_hash));
+}
+
+#[test]
+pub fn blake2_sha_512_threadpool_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let hashed_data = blake2_sha_512_threadpool(data_to_hash.clone());
+    assert_ne!(true, hashed_data.eq(&data_to_hash));
+}
+
+#[test]
+pub fn blake2_sha_512_verify_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let hashed_data = blake2_sha_512(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
+    assert_ne!(true, blake2_sha_512_verify_threadpool(data_to_hash, data_to_verify));
+}
+
+#[test]
+pub fn blake2_sha_512_threadpool_verify_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let hashed_data = blake2_sha_512_threadpool(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
+    assert_ne!(true, blake2_sha_512_verify_threadpool(data_to_hash, data_to_verify));
+}
+
+#[test]
+pub fn blake2_sha_512_verify_fail_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let _hashed_data = blake2_sha_512(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
+    assert_ne!(true, blake2_sha_512_verify(data_to_hash, data_to_verify));
+}
+
+#[test]
+pub fn blake2_sha_512_verify_threadpool_fail_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let _hashed_data = blake2_sha_512_threadpool(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
+    assert_ne!(true, blake2_sha_512_verify_threadpool(data_to_hash, data_to_verify));
+}
+
+#[test]
+pub fn blake2_sha_256_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let hashed_data = blake2_sha_256(data_to_hash.clone());
+    assert_ne!(true, hashed_data.eq(&data_to_hash));
+}
+
+#[test]
+pub fn blake2_sha_256_verify_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let _hashed_data = blake2_sha_256(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
+    assert_ne!(true, blake2_sha_256_verify(data_to_hash, data_to_verify));
+}
+
+#[test]
+pub fn blake2_sha_256_verify_threadpool_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let _hashed_data = blake2_sha_256_threadpool(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
+    assert_ne!(true, blake2_sha_256_verify_threadpool(data_to_hash, data_to_verify));
+}
+
+#[test]
+pub fn blake2_sha_256_verify_fail_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let _hashed_data = blake2_sha_256(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
+    assert_ne!(true, blake2_sha_256_verify(data_to_hash, data_to_verify));
+}
+
+#[test]
+pub fn blake2_sha_256_verify_threadpool_fail_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let _hashed_data = blake2_sha_256_threadpool(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
+    assert_ne!(true, blake2_sha_256_verify_threadpool(data_to_hash, data_to_verify));
+}

package/src/lib.rs

@@ -6,6 +6,7 @@ mod password_hashers {
 
 mod hashers {
     pub mod sha;
+    pub mod blake2;
 }
 
 mod key_exchange {

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

@@ -0,0 +1,83 @@
+import { blake2Sha512Verify, blake2Sha256Verify, blake2Sha256, blake2Sha512, blake2Sha512Threadpool, blake2Sha512VerifyThreadpool, blake2Sha256Threadpool, blake2Sha256VerifyThreadpool } from "../../index";
+import { IHasherBase } from "./hasher-base";
+
+export class Blake2Wrapper implements IHasherBase {
+
+    /**
+     * Hashes the input data using Blake2b 512
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash512(dataToHash: number[]): number[] {
+        return blake2Sha512(dataToHash);
+    }
+
+    /**
+     * Hashes the input data using Blake2b 512 in a thread pool
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+    hash512Threadpool(dataToHash: number[]): number[] {
+        return blake2Sha512Threadpool(dataToHash);
+    }
+
+    /**
+     * Verifies the input data against the hashed output using Blake2b 512
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean {
+        return blake2Sha512Verify(dataToHash, dataToVerify);
+    }
+
+    /**
+     * Verifies the input data against the hashed output using Blake2b 512 in a thread pool
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify512Threadpool(dataToHash: number[], dataToVerify: number[]): boolean {
+        return blake2Sha512VerifyThreadpool(dataToHash, dataToVerify);
+    }
+
+    /**
+     * Hashes the input data using Blake2b 256
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+
+    hash256(dataToHash: number[]): number[] {
+        return blake2Sha256(dataToHash);
+    }
+
+    /**
+     * Hashes the input data using Blake2b 256 in a thread pool
+     * @param dataToHash The data to hash
+     * @returns The hashed output
+     */
+
+    hash256Threadpool(dataToHash: number[]): number[] {
+        return blake2Sha256Threadpool(dataToHash);
+    }
+    
+    /**
+     * Verifies the input data against the hashed output using Blake2b 256
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean {
+        return blake2Sha256Verify(dataToHash, dataToVerify);
+    }
+
+    /**
+     * Verifies the input data against the hashed output using Blake2b 256 in a thread pool
+     * @param dataToHash The data to hash
+     * @param dataToVerify The data to verify
+     * @returns True if the verification is successful, false otherwise
+     */
+    verify256Threadpool(dataToHash: number[], dataToVerify: number[]): boolean {
+        return blake2Sha256VerifyThreadpool(dataToHash, dataToVerify);
+    }
+}

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

@@ -1,3 +1,4 @@
+import { Blake2Wrapper } from "./blake2-wrapper";
 import { HasherType } from "./hasher-type";
 import { SHAWrapper } from "./sha-wrapper";
 
@@ -10,7 +11,8 @@ export class HasherFactory {
     getHasher(type: HasherType): any {
         let result: SHAWrapper = new SHAWrapper();
         switch(type) {
-
+            case HasherType.Blake2:
+                result = new Blake2Wrapper(); 
         }
         return result;
     }

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

@@ -1,3 +1,4 @@
 export enum HasherType {
-    SHA = 1
+    SHA = 1,
+    Blake2 = 2
 }

package/src-ts/hashers/index.ts

@@ -1,5 +1,6 @@
 import { HasherFactory } from "./hasher-factory";
 import { HasherType } from "./hasher-type";
 import { SHAWrapper } from "./sha-wrapper";
+import { Blake2Wrapper } from "./blake2-wrapper";
 
-export { SHAWrapper, HasherFactory, HasherType };
+export { SHAWrapper, HasherFactory, HasherType, Blake2Wrapper };

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

@@ -1,5 +1,5 @@
 import { assert } from "chai";
-import { SHAWrapper } from "../src-ts/hashers/index";
+import { Blake2Wrapper, SHAWrapper } from "../src-ts/hashers/index";
 
 describe("SHA512 Tests", () => {
   it("hash", () => {
@@ -37,17 +37,116 @@ describe("SHA512 Tests", () => {
 
 
 describe("SHA256 Tests", () => {
+  it("hash", () => {
+    const wrapper = new SHAWrapper();
+    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.hash256(tohashBytes);
+    assert.notEqual(tohashBytes, hashed);
+  });
+
+  it("verify pass", () => {
+    const wrapper = new SHAWrapper();
+    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.hash256(tohashBytes);
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
+    const verified = wrapper.verify256(hashed, toVerifyBytes);
+    assert.equal(true, verified);
+  });
+
+  it("verify fail", () => {
+    const wrapper = new SHAWrapper();
+    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.hash256(tohashBytes);
+    const toVerify = "This Is Not The Same";
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
+    const verified = wrapper.verify256(hashed, toVerifyBytes);
+    assert.equal(false, verified);
+  });
+});
+
+describe("Blake2 512", () => {
+  it("hash", () => {
+    const wrapper = new Blake2Wrapper();
+    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.hash512(tohashBytes);
+    assert.notEqual(tohashBytes, hashed);
+  });
+
+  it("verify pass", () => {
+    const wrapper = new Blake2Wrapper();
+    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.hash512(tohashBytes);
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
+    const verified = wrapper.verify512(hashed, toVerifyBytes);
+    assert.equal(true, verified);
+  });
+
+  it("verify fail", () => {
+    const wrapper = new Blake2Wrapper();
+    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.hash512(tohashBytes);
+    const toVerify = "This Is Not The Same";
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
+    const verified = wrapper.verify512(hashed, toVerifyBytes);
+    assert.equal(false, verified);
+  });
+
+  it("hash threadpool", () => {
+    const wrapper = new Blake2Wrapper();
+    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.hash512Threadpool(tohashBytes);
+    assert.notEqual(tohashBytes, hashed);
+  });
+
+  it("verify threadpool pass", () => {
+    const wrapper = new Blake2Wrapper();
+    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.hash512Threadpool(tohashBytes);
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
+    const verified = wrapper.verify512Threadpool(hashed, toVerifyBytes);
+    assert.equal(true, verified);
+  });
+
+  it("verify threadpool fail", () => {
+    const wrapper = new Blake2Wrapper();
+    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.hash512Threadpool(tohashBytes);
+    const toVerify = "This Is Not The Same";
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
+    const verified = wrapper.verify512Threadpool(hashed, toVerifyBytes);
+    assert.equal(false, verified);
+  });
+
+  describe("Blake2 256", () => {
     it("hash", () => {
-      const wrapper = new SHAWrapper();
+      const wrapper = new Blake2Wrapper();
       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.hash256(tohashBytes);
       assert.notEqual(tohashBytes, hashed);
     });
-  
+
     it("verify pass", () => {
-      const wrapper = new SHAWrapper();
+      const wrapper = new Blake2Wrapper();
       const tohashed: string = "This is my array to hash";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
@@ -56,9 +155,9 @@ describe("SHA256 Tests", () => {
       const verified = wrapper.verify256(hashed, toVerifyBytes);
       assert.equal(true, verified);
     });
-  
+
     it("verify fail", () => {
-      const wrapper = new SHAWrapper();
+      const wrapper = new Blake2Wrapper();
       const tohashed: string = "This is my array to hash";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
@@ -68,4 +167,37 @@ describe("SHA256 Tests", () => {
       const verified = wrapper.verify256(hashed, toVerifyBytes);
       assert.equal(false, verified);
     });
-  });
+
+    it("hash threadpool", () => {
+      const wrapper = new Blake2Wrapper();
+      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.hash256Threadpool(tohashBytes);
+      assert.notEqual(tohashBytes, hashed);
+    });
+
+    it("verify threadpool pass", () => {
+      const wrapper = new Blake2Wrapper();
+      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.hash256Threadpool(tohashBytes);
+      const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
+      const verified = wrapper.verify256Threadpool(hashed, toVerifyBytes);
+      assert.equal(true, verified);
+    });
+
+    it("verify threadpool fail", () => {
+      const wrapper = new Blake2Wrapper();
+      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.hash256Threadpool(tohashBytes);
+      const toVerify = "This Is Not The Same";
+      const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
+      const verified = wrapper.verify256Threadpool(hashed, toVerifyBytes);
+      assert.equal(false, verified);
+    });
+  });
+});

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

@@ -1,5 +1,6 @@
 import { assert } from "chai";
 import { AESWrapper } from "../src-ts/symmetric/aes-wrapper";
+import { X25519Wrapper } from '../src-ts/key_exchange/x25519';
 import { areEqual } from "./helpers/array";
 
 describe("Symmetric Tests", () => {
@@ -28,4 +29,50 @@ describe("Symmetric Tests", () => {
     var result = areEqual(plaintxt, tohashBytes);
     assert.isTrue(result);
   });
+
+  it("ase 256 X25519 Diffie-Hellman encrypt and decrypt", () => {
+    const x25519 = new X25519Wrapper();
+    const alice= x25519.generateSecretAndPublicKey();
+    const bob = x25519.generateSecretAndPublicKey();
+
+    const aliceSharedSecret = x25519.generateSharedSecret(alice.secretKey, bob.publicKey);
+    const bobSharedSecret = x25519.generateSharedSecret(bob.secretKey, alice.publicKey);
+
+    const aesWrapper: AESWrapper = new AESWrapper();
+    const aliceAesKey = aesWrapper.aes256KeyNonceX25519DiffieHellman(aliceSharedSecret);
+    const bobAesKey = aesWrapper.aes256KeyNonceX25519DiffieHellman(bobSharedSecret);
+
+    const tohashed: string = "This is my array to encrypt";
+    const encoder = new TextEncoder();
+    const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+
+    const aliceCiphertext = aesWrapper.aes256Encrypt(aliceAesKey.aesKey, aliceAesKey.aesNonce, tohashBytes);
+    const bobPlaintext = aesWrapper.aes256Decrypt(bobAesKey.aesKey, aliceAesKey.aesNonce, aliceCiphertext);
+
+    var result = areEqual(bobPlaintext, tohashBytes);
+    assert.isTrue(result);
+  });
+
+  it("ase 128 X25519 Diffie-Hellman encrypt and decrypt", () => {
+    const x25519 = new X25519Wrapper();
+    const alice= x25519.generateSecretAndPublicKey();
+    const bob = x25519.generateSecretAndPublicKey();
+
+    const aliceSharedSecret = x25519.generateSharedSecret(alice.secretKey, bob.publicKey);
+    const bobSharedSecret = x25519.generateSharedSecret(bob.secretKey, alice.publicKey);
+
+    const aesWrapper: AESWrapper = new AESWrapper();
+    const aliceAesKey = aesWrapper.aes128KeyNonceX25519DiffieHellman(aliceSharedSecret);
+    const bobAesKey = aesWrapper.aes128KeyNonceX25519DiffieHellman(bobSharedSecret);
+
+    const tohashed: string = "This is my array to encrypt";
+    const encoder = new TextEncoder();
+    const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+
+    const aliceCiphertext = aesWrapper.aes128Encrypt(aliceAesKey.aesKey, aliceAesKey.aesNonce, tohashBytes);
+    const bobPlaintext = aesWrapper.aes128Decrypt(bobAesKey.aesKey, aliceAesKey.aesNonce, aliceCiphertext);
+
+    var result = areEqual(bobPlaintext, tohashBytes);
+    assert.isTrue(result);
+  });
 });