cas-typescript-sdk 1.0.30 → 1.0.32

package/Cargo.toml

@@ -11,7 +11,7 @@ crate-type = ["cdylib"]
 napi = "2.16.17"
 napi-derive = "2.16.13"
 csbindgen = "1.9.3"
-cas-lib = "0.1.6"
+cas-lib = "0.2.50"
 
 [build-dependencies]
 napi-build = "1"

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,12 +1,12 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.30",
+  "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",
-    "node:test": "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",
     "build:rust": "napi build --release",
@@ -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/asymmetric/cas_rsa.rs

@@ -1,4 +1,4 @@
-use cas_lib::asymmetric::{cas_asymmetric_encryption::CASRSAEncryption, cas_rsa::CASRSA, types::RSAKeyPairResult};
+use cas_lib::asymmetric::{cas_rsa::CASRSA, types::{CASRSAEncryption, RSAKeyPairResult}};
 use napi_derive::napi;
 
 #[napi(constructor)]

package/src/digital_signature/sha_256_ed25519.rs

@@ -5,29 +5,45 @@ use super::types::CASSHAED25519DalekDigitalSignatureResult;
 
 #[napi]
 pub fn sha_256_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
-    return <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign).into();
+    return <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(&data_to_sign).into();
 }
 
 #[napi]
 pub fn sha_256_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-    return SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(public_key, data_to_verify, signature)
+    if public_key.len() != 32 || signature.len() != 64 {
+        return false;
+    }
+    let mut pk = [0u8; 32];
+    pk.copy_from_slice(&public_key[..32]);
+    let mut sig = [0u8; 64];
+    sig.copy_from_slice(&signature[..64]);
+    SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(pk, &data_to_verify, sig)
 }
 
+
 #[test]
 fn sha_256_ed25519_test() {
     let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone()).into();
-    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
+    let data_to_sign = b"GetTheseBytes";
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(&data_to_sign.clone()).into();
+    let mut pk = [0u8; 32];
+    pk.copy_from_slice(&signature_result.public_key[..32]);
+    let mut sig = [0u8; 64];
+    sig.copy_from_slice(&signature_result.signature[..64]);
+    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(pk, data_to_sign, sig);
     assert_eq!(is_verified, true);
 }
 
 #[test]
 fn sha_512_ed25519_test_fail() {
     let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone()).into();
-    let not_original_data = b"NOtTHoseBytes".to_vec();
-    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, not_original_data, signature_result.signature);
+    let data_to_sign = b"GetTheseBytes";
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(&data_to_sign.clone()).into();
+    let not_original_data = b"NOtTHoseBytes";
+    let mut pk = [0u8; 32];
+    pk.copy_from_slice(&signature_result.public_key[..32]);
+    let mut sig = [0u8; 64];
+    sig.copy_from_slice(&signature_result.signature[..64]);
+    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(pk, not_original_data, sig);
     assert_eq!(is_verified, false);
 }

package/src/digital_signature/sha_512_ed25519.rs

@@ -7,19 +7,25 @@ use super::types::CASSHAED25519DalekDigitalSignatureResult;
 
 #[napi]
 pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
-    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign).into();
+    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(&data_to_sign).into();
 }
 
 #[napi]
 pub fn sha_512_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(public_key, data_to_verify, signature)
+    let public_key_array: [u8; 32] = public_key.try_into().expect("public_key must be 32 bytes");
+    let signature_array: [u8; 64] = signature.try_into().expect("signature must be 64 bytes");
+    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(
+        public_key_array,
+        &data_to_verify,
+        signature_array,
+    );
 }
 
 #[test]
 fn sha_512_ed25519_test() {
     let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: SHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign.clone());
+    let data_to_sign = b"GetTheseBytes";
+    let signature_result: SHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(&data_to_sign.clone());
     let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -27,9 +33,15 @@ fn sha_512_ed25519_test() {
 #[test]
 fn sha_512_ed25519_test_fail() {
     let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign.clone()).into();
+    let data_to_sign = b"GetTheseBytes";
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(&data_to_sign.clone()).into();
     let not_original_data = b"NOtTHoseBytes".to_vec();
-    let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, not_original_data, signature_result.signature);
+    let public_key_array: [u8; 32] = signature_result.public_key.clone().try_into().expect("public_key must be 32 bytes");
+    let signature_array: [u8; 64] = signature_result.signature.clone().try_into().expect("signature must be 64 bytes");
+    let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(
+        public_key_array,
+        &not_original_data,
+        signature_array,
+    );
     assert_eq!(is_verified, false);
 }

package/src/digital_signature/types.rs

@@ -10,8 +10,8 @@ pub struct CASSHAED25519DalekDigitalSignatureResult {
 impl From<SHAED25519DalekDigitalSignatureResult> for CASSHAED25519DalekDigitalSignatureResult {
     fn from(value: SHAED25519DalekDigitalSignatureResult) -> Self {
         CASSHAED25519DalekDigitalSignatureResult {
-            public_key: value.public_key,
-            signature: value.signature
+            public_key: value.public_key.to_vec(),
+            signature: value.signature.to_vec()
         }
     }
 }

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/hashers/sha.rs

@@ -39,7 +39,7 @@ pub fn sha_512_verify_test() {
 #[test]
 pub fn sha_512_verify_fail_test() {
     let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_512(data_to_hash.clone());
+    let _hashed_data = sha_512(data_to_hash.clone());
     let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
     assert_ne!(true, sha_512_verify(data_to_hash, data_to_verify));
 }
@@ -54,7 +54,7 @@ pub fn sha_256_test() {
 #[test]
 pub fn sha_256_verify_test() {
     let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_256(data_to_hash.clone());
+    let _hashed_data = sha_256(data_to_hash.clone());
     let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
     assert_ne!(true, sha_256_verify(data_to_hash, data_to_verify));
 }
@@ -62,7 +62,7 @@ pub fn sha_256_verify_test() {
 #[test]
 pub fn sha_256_verify_fail_test() {
     let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_256(data_to_hash.clone());
+    let _hashed_data = sha_256(data_to_hash.clone());
     let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
     assert_ne!(true, sha_256_verify(data_to_hash, data_to_verify));
 }

package/src/key_exchange/types.rs

@@ -1,4 +1,4 @@
-use cas_lib::key_exchange::x25519::x25519SecretPublicKeyResult;
+use cas_lib::key_exchange::x25519::X25519SecretPublicKeyResult;
 use napi_derive::napi;
 
 #[napi(constructor)]
@@ -7,8 +7,8 @@ pub struct CASx25519SecretPublicKeyResult {
     pub secret_key: Vec<u8>,
 }
 
-impl From<x25519SecretPublicKeyResult> for CASx25519SecretPublicKeyResult {
-    fn from(value: x25519SecretPublicKeyResult) -> Self {
+impl From<X25519SecretPublicKeyResult> for CASx25519SecretPublicKeyResult {
+    fn from(value: X25519SecretPublicKeyResult) -> Self {
         CASx25519SecretPublicKeyResult {
             public_key: value.public_key,
             secret_key: value.secret_key

package/src/key_exchange/x25519.rs

@@ -11,7 +11,7 @@ pub fn x25519_generate_secret_and_public_key() -> CASx25519SecretPublicKeyResult
 
 #[napi]
 pub fn x25519_diffie_hellman(my_secret_key: Vec<u8>, users_public_key: Vec<u8>) -> Vec<u8> {
-    return <X25519 as CASKeyExchange>::diffie_hellman(my_secret_key, users_public_key);
+    return <X25519 as CASKeyExchange>::diffie_hellman(my_secret_key, users_public_key).to_vec();
 }
 
 #[test]

package/src/lib.rs

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

package/src/password_hashers/argon2.rs

@@ -1,26 +1,25 @@
 
 use napi_derive::napi;
 use cas_lib::password_hashers::argon2::CASArgon;
-use cas_lib::password_hashers::cas_password_hasher::CASPasswordHasher;
 
 #[napi]
 pub fn argon2_hash(password: String) -> String {
-    return <CASArgon as CASPasswordHasher>::hash_password(password);
+    return CASArgon::hash_password(password);
 }
 
 #[napi] 
 pub fn argon2_hash_thread_pool(password: String) -> String {
-    return <CASArgon as CASPasswordHasher>::hash__password_threadpool(password);
+    return CASArgon::hash_password_threadpool(password);
 }
 
 #[napi]
 pub fn argon2_verify(hashed_password: String, password_to_verify: String) -> bool {
-    return <CASArgon as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+    return CASArgon::verify_password(hashed_password, password_to_verify);
 }
 
 #[napi]
 pub fn argon2_verify_threadpool(hashed_password: String, password_to_verify: String) -> bool {
-    return <CASArgon as CASPasswordHasher>::verify_password_threadpool(hashed_password, password_to_verify);
+    return CASArgon::verify_password_threadpool(hashed_password, password_to_verify);
 }
 
 #[test]

package/src/password_hashers/bcrypt.rs

@@ -9,7 +9,7 @@ pub fn bcrypt_hash(password_to_hash: String) -> String {
 
 #[napi]
 pub fn bcrypt_hash_threadpool(password_to_hash: String) -> String {
-    return <CASBCrypt as CASPasswordHasher>::hash__password_threadpool(password_to_hash);
+    return <CASBCrypt as CASPasswordHasher>::hash_password_threadpool(password_to_hash);
 }
 
 #[napi]

package/src/password_hashers/scrypt.rs

@@ -13,7 +13,7 @@ pub fn scrypt_verify(hashed_password: String, password_to_verify: String) -> boo
 
 #[napi]
 pub fn scrypt_hash_threadpool(password_to_hash: String) -> String {
-    return <CASScrypt as CASPasswordHasher>::hash__password_threadpool(password_to_hash);
+    return <CASScrypt as CASPasswordHasher>::hash_password_threadpool(password_to_hash);
 }
 
 #[napi]

package/src/sponges/ascon_aead.rs

@@ -4,7 +4,7 @@ use napi_derive::napi;
 
 #[napi]
 pub fn ascon128_key_generate() -> Vec<u8> {
-    return <AsconAead as CASAsconAead>::generate_key();
+    return <AsconAead as CASAsconAead>::generate_key().to_vec();
 }
 
 #[test]
@@ -15,7 +15,7 @@ fn test_ascon128_key_generate() {
 
 #[napi]
 pub fn ascon128_nonce_generate() -> Vec<u8> {
-    return <AsconAead as CASAsconAead>::generate_nonce();
+    return <AsconAead as CASAsconAead>::generate_nonce().to_vec();
 }
 
 #[test]
@@ -26,29 +26,45 @@ pub fn test_ascon128_nonce_generate() {
 
 #[napi]
 pub fn ascon128_encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return <AsconAead as CASAsconAead>::encrypt(key, nonce, plaintext);
+    let key_arr: [u8; 16] = key.try_into().expect("Key must be 16 bytes");
+    let nonce_arr: [u8; 16] = nonce.try_into().expect("Nonce must be 16 bytes");
+    return <AsconAead as CASAsconAead>::encrypt(key_arr, nonce_arr, plaintext);
 }
 
 #[test]
 pub fn test_ascon128_encrypt() {
     let key = <AsconAead as CASAsconAead>::generate_key();
     let nonce = <AsconAead as CASAsconAead>::generate_nonce();
-    let plaintext = b"Hello, World!".to_vec();
-    let ciphertext = ascon128_encrypt(key.clone(), nonce.clone(), plaintext.clone());
-    assert_ne!(ciphertext, plaintext);
+    let plaintext = b"Hello, World!";
+    let ciphertext = ascon128_encrypt(
+        key.clone().to_vec(),
+        nonce.clone().to_vec(),
+        plaintext.to_vec(),
+    );
+    assert_ne!(ciphertext, plaintext.to_vec());
 }
 
 #[napi]
 pub fn ascon128_decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return <AsconAead as CASAsconAead>::decrypt(key, nonce, ciphertext);
+    let key_arr: [u8; 16] = key.try_into().expect("Key must be 16 bytes");
+    let nonce_arr: [u8; 16] = nonce.try_into().expect("Nonce must be 16 bytes");
+    return <AsconAead as CASAsconAead>::decrypt(key_arr, nonce_arr, ciphertext);
 }
 
 #[test]
 pub fn test_ascon128_decrypt() {
     let key = <AsconAead as CASAsconAead>::generate_key();
     let nonce = <AsconAead as CASAsconAead>::generate_nonce();
-    let plaintext = b"Hello, World!".to_vec();
-    let ciphertext = ascon128_encrypt(key.clone(), nonce.clone(), plaintext.clone());
-    let decrypted = ascon128_decrypt(key.clone(), nonce.clone(), ciphertext.clone());
-    assert_eq!(decrypted, plaintext);
+    let plaintext = b"Hello, World!";
+    let ciphertext = ascon128_encrypt(
+        key.clone().to_vec(),
+        nonce.clone().to_vec(),
+        plaintext.to_vec(),
+    );
+    let decrypted = ascon128_decrypt(
+        key.clone().to_vec(),
+        nonce.clone().to_vec(),
+        ciphertext.clone(),
+    );
+    assert_eq!(decrypted, plaintext.to_vec());
 }

package/src/symmetric/aes.rs

@@ -1,55 +1,65 @@
-use cas_lib::symmetric::{aes::{CASAES128, CASAES256}, cas_symmetric_encryption::CASAESEncryption};
+use cas_lib::symmetric::{aes::{CASAES128, CASAES256}, cas_symmetric_encryption::{CASAES128Encryption, CASAES256Encryption}};
 use napi_derive::napi;
 
 use super::types::CASAesKeyFromX25519SharedSecret;
 
 #[napi]
 pub fn aes_nonce() -> Vec<u8> {
-    return <CASAES256 as CASAESEncryption>::generate_nonce();
+    return <CASAES256 as CASAES256Encryption>::generate_nonce().to_vec();
 }
 
 #[napi]
 pub fn aes128_key() -> Vec<u8> {
-    return <CASAES128 as CASAESEncryption>::generate_key();
+    return <CASAES128 as CASAES128Encryption>::generate_key().to_vec();
 }
 
 #[napi]
 pub fn aes256_key() -> Vec<u8> {
-    return <CASAES256 as CASAESEncryption>::generate_key();
+    return <CASAES256 as CASAES256Encryption>::generate_key().to_vec();
 }
 
 #[napi]
 pub fn aes128_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return <CASAES128 as CASAESEncryption>::encrypt_plaintext(aes_key, nonce, plaintext);
+    let key: [u8; 16] = aes_key.try_into().expect("Key must be 16 bytes");
+    let nonce_arr: [u8; 12] = nonce.try_into().expect("Nonce must be 12 bytes");
+    <CASAES128 as CASAES128Encryption>::encrypt_plaintext(key, nonce_arr, plaintext)
 }
 
 #[napi]
 pub fn aes128_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return <CASAES128 as CASAESEncryption>::decrypt_ciphertext(aes_key, nonce, ciphertext);
+    let key: [u8; 16] = aes_key.try_into().expect("Key must be 16 bytes");
+    let nonce_arr: [u8; 12] = nonce.try_into().expect("Nonce must be 12 bytes");
+    <CASAES128 as CASAES128Encryption>::decrypt_ciphertext(key, nonce_arr, ciphertext)
 }
 
 #[napi]
 pub fn aes256_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return <CASAES256 as CASAESEncryption>::encrypt_plaintext(aes_key, nonce, plaintext);
+    let key: [u8; 32] = aes_key.try_into().expect("Key must be 32 bytes");
+    let nonce_arr: [u8; 12] = nonce.try_into().expect("Nonce must be 12 bytes");
+    <CASAES256 as CASAES256Encryption>::encrypt_plaintext(key, nonce_arr, plaintext)
 }
 
 #[napi]
 pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return <CASAES256 as CASAESEncryption>::decrypt_ciphertext(aes_key, nonce, ciphertext);
+    let key: [u8; 32] = aes_key.try_into().expect("Key must be 32 bytes");
+    let nonce_arr: [u8; 12] = nonce.try_into().expect("Nonce must be 12 bytes");
+    <CASAES256 as CASAES256Encryption>::decrypt_ciphertext(key, nonce_arr, ciphertext)
 }
 
 #[napi]
 pub fn aes_256_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
 ) -> CASAesKeyFromX25519SharedSecret {
-    return <CASAES256 as CASAESEncryption>::key_from_x25519_shared_secret(shared_secret).into();
+    let shared_secret_arr: [u8; 32] = shared_secret.try_into().expect("Shared secret must be 32 bytes");
+    return <CASAES256 as CASAES256Encryption>::key_from_x25519_shared_secret(shared_secret_arr).into();
 }
 
 #[napi]
 pub fn aes_128_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
 ) -> CASAesKeyFromX25519SharedSecret {
-    return <CASAES128 as CASAESEncryption>::key_from_x25519_shared_secret(shared_secret).into();
+    let shared_secret_arr: [u8; 32] = shared_secret.try_into().expect("Shared secret must be 32 bytes");
+    return <CASAES128 as CASAES128Encryption>::key_from_x25519_shared_secret(shared_secret_arr).into();
 }
 
 #[test]

package/src/symmetric/types.rs

@@ -1,4 +1,5 @@
-use cas_lib::symmetric::cas_symmetric_encryption::AesKeyFromX25519SharedSecret;
+
+use cas_lib::symmetric::cas_symmetric_encryption::{Aes128KeyFromX25519SharedSecret, Aes256KeyFromX25519SharedSecret};
 use napi_derive::napi;
 
 #[napi(constructor)]
@@ -7,11 +8,20 @@ pub struct CASAesKeyFromX25519SharedSecret {
     pub aes_nonce: Vec<u8>,
 }
 
-impl From<AesKeyFromX25519SharedSecret> for CASAesKeyFromX25519SharedSecret {
-    fn from(value: AesKeyFromX25519SharedSecret) -> Self {
+impl From<Aes128KeyFromX25519SharedSecret> for CASAesKeyFromX25519SharedSecret {
+    fn from(value: Aes128KeyFromX25519SharedSecret) -> Self {
+        CASAesKeyFromX25519SharedSecret {
+            aes_key: value.aes_key.to_vec(),
+            aes_nonce: value.aes_nonce.to_vec()
+        }
+    }
+}
+
+impl From<Aes256KeyFromX25519SharedSecret> for CASAesKeyFromX25519SharedSecret {
+    fn from(value: Aes256KeyFromX25519SharedSecret) -> Self {
         CASAesKeyFromX25519SharedSecret {
-            aes_key: value.aes_key,
-            aes_nonce: value.aes_nonce
+            aes_key: value.aes_key.to_vec(),
+            aes_nonce: value.aes_nonce.to_vec()
         }
     }
 }

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