thread pool for scrypt

Author: WingZer0o

index.d.ts

@@ -13,6 +13,8 @@ export function bcryptVerify(hashedPassword: string, passwordToVerify: string):
 export function bcryptVerifyThreadpool(passwordToHash: string, passwordToVerify: string): boolean
 export function scryptHash(passwordToHash: string): string
 export function scryptVerify(hashedPassword: string, passwordToVerify: string): boolean
+export function scryptHashThreadpool(passwordToHash: string): string
+export function scryptVerifyThreadpool(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>

index.node

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

package.json

@@ -1,14 +1,22 @@
-import { scryptHash, scryptVerify } from "../../index";
+import { scryptHash, scryptHashThreadpool, scryptVerify, scryptVerifyThreadpool } from "../../index";
 import { IPasswordHasherBase } from "./password-hasher-base";
 
 export class ScryptWrapper implements IPasswordHasherBase {
 
   verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean {
-    throw new Error("Method not implemented.");
+    if (!hashedPassword || !passwordToCheck) {
+      throw new Error(
+        "You must provide a hashed password and a plaintext password to verify with Scrypt",
+      );
+    }
+    return scryptVerifyThreadpool(hashedPassword, passwordToCheck);
   }
-  
+
   hashPasswordThreadPool(password: string): string {
-    throw new Error("Method not implemented.");
+    if (!password) {
+      throw new Error("You must provide a password to hash with Scrypt");
+    }
+    return scryptHashThreadpool(password);
   }
 
   public hashPassword(password: string): string {

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

@@ -1,3 +1,5 @@
+use std::sync::mpsc;
+
 use napi_derive::napi;
 
 use scrypt::{
@@ -36,6 +38,43 @@ pub fn scrypt_verify(hashed_password: String, password_to_verify: String) -> boo
     return <CASScrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
 }
 
+#[napi]
+pub fn scrypt_hash_threadpool(password_to_hash: String) -> String {
+    let (sender, receiver) = mpsc::channel();
+    rayon::spawn(move || {
+        let thread_result = <CASScrypt as CASPasswordHasher>::hash_password(password_to_hash);
+        sender.send(thread_result);
+    });
+    let result = receiver.recv().unwrap();
+    result
+}
+
+#[napi]
+pub fn scrypt_verify_threadpool(hashed_password: String, password_to_verify: String) -> bool {
+    let (sender, receiver) = mpsc::channel();
+    rayon::spawn(move || {
+        let thread_result = <CASScrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+        sender.send(thread_result);
+    });
+    let result = receiver.recv().unwrap();
+    result
+}
+
+#[test]
+pub fn scrypt_hash_threadpool_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash_threadpool(password.clone());
+    assert_ne!(password, hashed_password);
+}
+
+#[test]
+pub fn scrypt_verify_threadpool_test() {
+    let password = "BadPassword".to_string();
+    let hashed_password = scrypt_hash_threadpool(password.clone());
+    let verified = scrypt_verify_threadpool(hashed_password, password);
+    assert_eq!(true, verified);
+}
+
 #[test]
 pub fn scrypt_hash_test() {
     let password = "BadPassword".to_string();

src/password_hashers/scrypt.rs

@@ -51,6 +51,25 @@ describe("Bcrypt Tests", () => {
 });
 
 describe("Scrypt Tests", () => {
+  it("hash with threadpool", () => {
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Scrypt,
+    );
+    const password: string = "ScryptRocks";
+    const hashed: string = hasher.hashPasswordThreadPool(password);
+    assert.notEqual(password, hashed);
+  });
+
+  it("verify pass with threadpool", () => {
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Scrypt,
+    );
+    const password: string = "ScryptRocks1231231";
+    const hashed: string = hasher.hashPasswordThreadPool(password);
+    const verified: boolean = hasher.verifyThreadPool(hashed, password);
+    assert.isTrue(verified);
+  });
+
   it("hash with factory", () => {
     const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
       PasswordHasherType.Scrypt,