cas-typescript-sdk 1.0.8 → 1.0.9

package/Cargo.toml

@@ -14,6 +14,7 @@ napi = "2"
 napi-derive = "2"
 rand = "0.8.5"
 scrypt = "0.11.0"
+sha3 = "0.10.8"
 
 [build-dependencies]
 napi-build = "1"

package/README.md

@@ -7,5 +7,12 @@ The official NPM page can be found [here](https://www.npmjs.com/package/cas-type
 
 This Node.js NPM module is dependent on our Rust layer [here](./src) that contains methods to run industry standard cryptographic operations sequentially, on threads, and the thread pool.
 
+## Consuming Library Documentation
+We utilize some smart people's existing work and we believe their documentation should be reviewed when possible.
+- [Spin Research](https://github.com/SpinResearch)
+- [Dalek-Cryptography](https://github.com/dalek-cryptography)
+- [Rust Crypto](https://github.com/RustCrypto)
+- [Rayon](https://github.com/rayon-rs/rayon)
+
 ## Disclaimer
-Many of the cryptographic crates that are utilized in our core FFI [layer](https://github.com/Crytographic-API-Services/cas-core-lib) have never had a security audit performed. Utilize this SDK at your own risk.
+Many of the cryptographic crates that are utilized in our core FFI [layer](./src) have never had a security audit performed. Utilize this SDK at your own risk.

package/index.d.ts

@@ -9,3 +9,7 @@ export function bcryptHash(passwordToHash: string): string
 export function bcryptVerify(hashedPassword: string, passwordToVerify: string): boolean
 export function scryptHash(passwordToHash: string): string
 export function scryptVerify(hashedPassword: string, passwordToVerify: string): boolean
+export function sha512(dataToHash: Array<number>): Array<number>
+export function sha512Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
+export function sha256(dataToHash: Array<number>): Array<number>
+export function sha256Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean

package/lib/hashers/IHasherBase.d.ts

@@ -0,0 +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;
+}

package/lib/hashers/IHasherBase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/hashers/SHAWrapper.d.ts

@@ -0,0 +1,7 @@
+import { IHasherBase } from "./IHasherBase";
+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;
+}

package/lib/hashers/SHAWrapper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHAWrapper = void 0;
+const index_1 = require("../../index");
+class SHAWrapper {
+    hash_512(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) {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        if (!dataToVerify || dataToVerify.length === 0) {
+            throw new Error("You must provide an allocated array of data to verify");
+        }
+        return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
+    }
+    hash_256(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) {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        if (!dataToVerify || dataToVerify.length === 0) {
+            throw new Error("You must provide an allocated array of data to verify");
+        }
+        return (0, index_1.sha256Verify)(dataToHash, dataToVerify);
+    }
+}
+exports.SHAWrapper = SHAWrapper;

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

@@ -0,0 +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;
+}

package/lib/hashers/hasher-base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import { HasherType } from "./hasher-type";
+export declare class HasherFactory {
+    getHasher(type: HasherType): any;
+}

package/lib/hashers/hasher-factory.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasherFactory = void 0;
+const sha_wrapper_1 = require("./sha-wrapper");
+class HasherFactory {
+    getHasher(type) {
+        let result = new sha_wrapper_1.SHAWrapper();
+        switch (type) {
+        }
+        return result;
+    }
+}
+exports.HasherFactory = HasherFactory;

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

@@ -0,0 +1,3 @@
+export declare enum HasherType {
+    SHA = 1
+}

package/lib/hashers/hasher-type.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasherType = void 0;
+var HasherType;
+(function (HasherType) {
+    HasherType[HasherType["SHA"] = 1] = "SHA";
+})(HasherType || (exports.HasherType = HasherType = {}));

package/lib/hashers/index.d.ts

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

package/lib/hashers/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });

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

@@ -0,0 +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;
+}

package/lib/hashers/sha-wrapper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHAWrapper = void 0;
+const index_1 = require("../../index");
+class SHAWrapper {
+    hash_512(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) {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        if (!dataToVerify || dataToVerify.length === 0) {
+            throw new Error("You must provide an allocated array of data to verify");
+        }
+        return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
+    }
+    hash_256(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) {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        if (!dataToVerify || dataToVerify.length === 0) {
+            throw new Error("You must provide an allocated array of data to verify");
+        }
+        return (0, index_1.sha256Verify)(dataToHash, dataToVerify);
+    }
+}
+exports.SHAWrapper = SHAWrapper;

package/lib/index.d.ts

@@ -1,2 +1,3 @@
-import * as PasswordHashers from "./password-hashers/index";
-export { PasswordHashers };
+import { Argon2Wrapper, BCryptWrapper, PasswordHasherFactory, PasswordHasherType, ScryptWrapper } from "./password-hashers/index";
+import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
+export { Argon2Wrapper, BCryptWrapper, ScryptWrapper, PasswordHasherFactory, PasswordHasherType, HasherFactory, HasherType, SHAWrapper, };

package/lib/index.js

@@ -1,28 +1,13 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PasswordHashers = void 0;
-const PasswordHashers = __importStar(require("./password-hashers/index"));
-exports.PasswordHashers = PasswordHashers;
+exports.SHAWrapper = exports.HasherType = exports.HasherFactory = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.ScryptWrapper = exports.BCryptWrapper = exports.Argon2Wrapper = void 0;
+const index_1 = require("./password-hashers/index");
+Object.defineProperty(exports, "Argon2Wrapper", { enumerable: true, get: function () { return index_1.Argon2Wrapper; } });
+Object.defineProperty(exports, "BCryptWrapper", { enumerable: true, get: function () { return index_1.BCryptWrapper; } });
+Object.defineProperty(exports, "PasswordHasherFactory", { enumerable: true, get: function () { return index_1.PasswordHasherFactory; } });
+Object.defineProperty(exports, "PasswordHasherType", { enumerable: true, get: function () { return index_1.PasswordHasherType; } });
+Object.defineProperty(exports, "ScryptWrapper", { enumerable: true, get: function () { return index_1.ScryptWrapper; } });
+const index_2 = require("./hashers/index");
+Object.defineProperty(exports, "HasherFactory", { enumerable: true, get: function () { return index_2.HasherFactory; } });
+Object.defineProperty(exports, "HasherType", { enumerable: true, get: function () { return index_2.HasherType; } });
+Object.defineProperty(exports, "SHAWrapper", { enumerable: true, get: function () { return index_2.SHAWrapper; } });

package/lib/password-hashers/index.d.ts

@@ -3,4 +3,4 @@ import { BCryptWrapper } from "./bcrypt-wrapper";
 import { ScryptWrapper } from "./scrypt-wrapper";
 import { PasswordHasherType } from "./password-hasher-type";
 import { PasswordHasherFactory } from "./password-hasher-factory";
-export { PasswordHasherFactory, PasswordHasherType, BCryptWrapper, Argon2Wrapper, ScryptWrapper };
+export { Argon2Wrapper, BCryptWrapper, PasswordHasherFactory, PasswordHasherType, ScryptWrapper, };

package/lib/password-hashers/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScryptWrapper = exports.Argon2Wrapper = exports.BCryptWrapper = exports.PasswordHasherType = exports.PasswordHasherFactory = void 0;
+exports.ScryptWrapper = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = void 0;
 const argon2_wrapper_1 = require("./argon2-wrapper");
 Object.defineProperty(exports, "Argon2Wrapper", { enumerable: true, get: function () { return argon2_wrapper_1.Argon2Wrapper; } });
 const bcrypt_wrapper_1 = require("./bcrypt-wrapper");

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
-    "test": "mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
+    "test": "cargo test && npm run build && mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
     "build": "napi build --release && tsc",
     "prepare": "npm run build"
   },

package/src/hashers/cas_hasher.rs

@@ -0,0 +1,8 @@
+use napi::bindgen_prelude::Array;
+
+pub trait CASHasher {
+    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8>;
+    fn verify_512(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool;
+    fn hash_256(data_to_hash: Vec<u8>) -> Vec<u8>;
+    fn verify_256(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool;
+}

package/src/hashers/sha.rs

@@ -0,0 +1,103 @@
+use napi::bindgen_prelude::Array;
+use napi_derive::napi;
+
+use super::cas_hasher::CASHasher;
+use sha3::{Digest, Sha3_256, Sha3_512};
+pub struct CASSHA;
+
+impl CASHasher for CASSHA {
+    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8> {
+        let mut hasher = Sha3_512::new();
+        hasher.update(data_to_hash);
+        let result = hasher.finalize();
+        return result.to_vec();
+    }
+
+    fn verify_512(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+        let mut hasher = Sha3_512::new();
+        hasher.update(data_to_verify);
+        let result = hasher.finalize();
+        return hash_to_verify.eq(&result.to_vec());
+    }
+
+    fn hash_256(data_to_hash: Vec<u8>) -> Vec<u8> {
+        let mut hasher = Sha3_256::new();
+        hasher.update(data_to_hash);
+        let result = hasher.finalize();
+        return result.to_vec();
+    }
+
+    fn verify_256(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+        let mut hasher = Sha3_256::new();
+        hasher.update(data_to_verify);
+        let result = hasher.finalize();
+        return hash_to_verify.eq(&result.to_vec());
+    }
+}
+
+#[napi]
+pub fn sha_512(data_to_hash: Vec<u8>) -> Vec<u8> {
+    return <CASSHA as CASHasher>::hash_512(data_to_hash);
+}
+
+#[napi]
+pub fn sha_512_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+    return <CASSHA as CASHasher>::verify_512(data_to_hash, data_to_verify);
+}
+
+
+#[napi]
+pub fn sha_256(data_to_hash: Vec<u8>) -> Vec<u8> {
+    return <CASSHA as CASHasher>::hash_256(data_to_hash);
+}
+
+#[napi]
+pub fn sha_256_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+    return <CASSHA as CASHasher>::verify_256(data_to_hash, data_to_verify);
+}
+
+#[test]
+pub fn sha_512_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let hashed_data = sha_512(data_to_hash.clone());
+    assert_ne!(true, hashed_data.eq(&data_to_hash));
+}
+
+#[test]
+pub fn sha_512_verify_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let hashed_data = sha_512(data_to_hash.clone());
+    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
+    assert_ne!(true, sha_512_verify(data_to_hash, data_to_verify));
+}
+
+#[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 data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
+    assert_ne!(true, sha_512_verify(data_to_hash, data_to_verify));
+}
+
+#[test]
+pub fn sha_256_test() {
+    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
+    let hashed_data = sha_256(data_to_hash.clone());
+    assert_ne!(true, hashed_data.eq(&data_to_hash));
+}
+
+#[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 data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
+    assert_ne!(true, sha_256_verify(data_to_hash, data_to_verify));
+}
+
+#[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 data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
+    assert_ne!(true, sha_256_verify(data_to_hash, data_to_verify));
+}

package/src/lib.rs

@@ -3,4 +3,9 @@ mod password_hashers {
     pub mod bcrypt;
     pub mod scrypt;
     pub mod cas_password_hasher;
+}
+
+mod hashers {
+    pub mod sha;
+    pub mod cas_hasher;
 }

package/src/password_hashers/argon2.rs

@@ -1,3 +1,5 @@
+use std::net::ToSocketAddrs;
+
 use napi_derive::napi;
 
 use argon2::{
@@ -34,4 +36,29 @@ pub fn argon2_hash(password: String) -> String {
 #[napi]
 pub fn argon2_verify(hashed_password: String, password_to_verify: String) -> bool {
     return <CASArgon as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+}
+
+
+#[test]
+pub fn argon2_hash_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = argon2_hash(password.clone());
+    assert_ne!(password, hashed);
+}
+
+#[test]
+pub fn argon2_verify_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = argon2_hash(password.clone());
+    let verified = argon2_verify(hashed, password);
+    assert_eq!(true, verified);
+}
+
+#[test]
+pub fn argon2_verify_fail_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = argon2_hash(password.clone());
+    let verified = "Nope".to_string();
+    let verified = argon2_verify(hashed, verified);
+    assert_eq!(false, verified);
 }

package/src/password_hashers/bcrypt.rs

@@ -24,4 +24,28 @@ pub fn bcrypt_hash(password_to_hash: String) -> String {
 #[napi]
 pub fn bcrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
     return <CASBCrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+}
+
+#[test]
+pub fn bcrypt_hash_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = bcrypt_hash(password.clone());
+    assert_ne!(password, hashed);
+}
+
+#[test]
+pub fn bcrypt_verify_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = bcrypt_hash(password.clone());
+    let verified = bcrypt_verify(hashed, password);
+    assert_eq!(true, verified);
+}
+
+#[test]
+pub fn bcrypt_verify_fail_test() {
+    let password = "ThisIsNotMyPasswolrd".to_string();
+    let hashed = bcrypt_hash(password.clone());
+    let verified = "nope".to_string();
+    let verified = bcrypt_verify(hashed, verified);
+    assert_eq!(false, verified);
 }

package/src/password_hashers/scrypt.rs

@@ -29,4 +29,28 @@ pub fn scrypt_hash(password_to_hash: String) -> String {
 #[napi]
 pub fn scrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
     return <CASScrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+}
+
+#[test]
+pub fn scrypt_hash_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash(password.clone());
+    assert_ne!(password, hashed_password);
+}
+
+#[test]
+pub fn scrypt_verify_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash(password.clone());
+    let verified = scrypt_verify(hashed_password, password);
+    assert_eq!(true, verified);
+}
+
+#[test]
+pub fn scrypt_verify_fail_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash(password.clone());
+    let verified = "Nope".to_string();
+    let verified = scrypt_verify(hashed_password, verified);
+    assert_eq!(false, verified);
 }

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,12 @@
+import { HasherType } from "./hasher-type";
+import { SHAWrapper } from "./sha-wrapper";
+
+export class HasherFactory {
+    getHasher(type: HasherType): any {
+        let result: SHAWrapper = new SHAWrapper();
+        switch(type) {
+
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,3 @@
+export enum HasherType {
+    SHA = 1
+}

package/src-ts/hashers/index.ts

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

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

@@ -0,0 +1,38 @@
+import { sha256, sha256Verify, sha512, sha512Verify } from "../../index";
+import { IHasherBase } from "./hasher-base";
+
+export class SHAWrapper implements IHasherBase {
+    hash_512(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 {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        if (!dataToVerify || dataToVerify.length === 0) {
+            throw new Error("You must provide an allocated array of data to verify");
+        }
+        return sha512Verify(dataToHash, dataToVerify);
+    }
+
+    hash_256(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 {
+        if (!dataToHash || dataToHash.length === 0) {
+            throw new Error("You must provide an allocated array of data");
+        }
+        if (!dataToVerify || dataToVerify.length === 0) {
+            throw new Error("You must provide an allocated array of data to verify");
+        }
+        return sha256Verify(dataToHash, dataToVerify);
+    }
+}

package/src-ts/index.ts

@@ -1,5 +1,19 @@
-import * as PasswordHashers from "./password-hashers/index";
+import {
+  Argon2Wrapper,
+  BCryptWrapper,
+  PasswordHasherFactory,
+  PasswordHasherType,
+  ScryptWrapper,
+} from "./password-hashers/index";
+import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
 
 export {
-    PasswordHashers
-}
+  Argon2Wrapper,
+  BCryptWrapper,
+  ScryptWrapper,
+  PasswordHasherFactory,
+  PasswordHasherType,
+  HasherFactory,
+  HasherType,
+  SHAWrapper,
+};

package/src-ts/password-hashers/index.ts

@@ -1,8 +1,14 @@
-import { Argon2Wrapper } from "./argon2-wrapper"
-import { BCryptWrapper } from "./bcrypt-wrapper"
-import { ScryptWrapper } from "./scrypt-wrapper"
+import { Argon2Wrapper } from "./argon2-wrapper";
+import { BCryptWrapper } from "./bcrypt-wrapper";
+import { ScryptWrapper } from "./scrypt-wrapper";
 
-import { PasswordHasherType } from "./password-hasher-type"
-import { PasswordHasherFactory } from "./password-hasher-factory"
+import { PasswordHasherType } from "./password-hasher-type";
+import { PasswordHasherFactory } from "./password-hasher-factory";
 
-export {PasswordHasherFactory, PasswordHasherType, BCryptWrapper, Argon2Wrapper, ScryptWrapper}
+export {
+  Argon2Wrapper,
+  BCryptWrapper,
+  PasswordHasherFactory,
+  PasswordHasherType,
+  ScryptWrapper,
+};

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

@@ -0,0 +1,71 @@
+import { assert } from "chai";
+import { SHAWrapper } from "../src-ts/hashers/index";
+
+describe("SHA512 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.hash_512(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.hash_512(tohashBytes);
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
+    const verified = wrapper.verify_512(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.hash_512(tohashBytes);
+    const toVerify = "This Is Not The Same";
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
+    const verified = wrapper.verify_512(hashed, toVerifyBytes);
+    assert.equal(false, verified);
+  });
+});
+
+
+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.hash_256(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.hash_256(tohashBytes);
+      const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
+      const verified = wrapper.verify_256(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.hash_256(tohashBytes);
+      const toVerify = "This Is Not The Same";
+      const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
+      const verified = wrapper.verify_256(hashed, toVerifyBytes);
+      assert.equal(false, verified);
+    });
+  });