cas-typescript-sdk 1.0.14 → 1.0.16

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

@@ -1,103 +1,103 @@
-import { assert, expect } from "chai";
-import { BCryptWrapper } from "../src-ts/password-hashers/index";
-import { ScryptWrapper } from "../src-ts/password-hashers/index";
-import {
-  PasswordHasherFactory,
-  PasswordHasherType,
-} from "../src-ts/password-hashers/";
-
-describe("Bcrypt Tests", () => {
-  it("hash", () => {
-    const hasher: BCryptWrapper = new BCryptWrapper();
-    const password: string = "ThisOneBadPassword!@";
-    const hashedPassword: string = hasher.hashPassword(password);
-    assert.notEqual(hashedPassword, password);
-  });
-
-  it("verify pass", () => {
-    const hasher: BCryptWrapper = new BCryptWrapper();
-    const password: string = "NotThisPassword!@";
-    const hashedPassword: string = hasher.hashPassword(password);
-    const isValid: boolean = hasher.verifyPassword(hashedPassword, password);
-    expect(isValid).to.equal(true);
-  });
-
-  it("verify fail", () => {
-    const hasher: BCryptWrapper = new BCryptWrapper();
-    const password: string = "NotThisPassword!@";
-    const hashedPassword: string = hasher.hashPassword(password);
-    const isValid: boolean = hasher.verifyPassword(
-      hashedPassword,
-      "ThesePasswordsDoNotMatch",
-    );
-    expect(isValid).to.equal(false);
-  });
-});
-
-describe("Scrypt Tests", () => {
-  it("hash with factory", () => {
-    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Scrypt,
-    );
-    const password: string = "ScryptRocks";
-    const hashed: string = hasher.hashPassword(password);
-    assert.notEqual(password, hashed);
-  });
-
-  it("verify pass with factory", () => {
-    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Scrypt,
-    );
-    const password: string = "ScryptRocks1231231";
-    const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(hashed, password);
-    assert.isTrue(verified);
-  });
-
-  it("verify fail with factory", () => {
-    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Scrypt,
-    );
-    const password: string = "ScryptRocksSomeGarbageText";
-    const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(
-      hashed,
-      "make this fail, its not the same",
-    );
-    assert.isNotTrue(verified);
-  });
-});
-
-describe("Argon2 Tests", () => {
-  it("hash with factory", () => {
-    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Argon2,
-    );
-    const password: string = "ScryptRocks";
-    const hashed: string = hasher.hashPassword(password);
-    assert.notEqual(password, hashed);
-  });
-
-  it("verify pass with factory", () => {
-    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Argon2,
-    );
-    const password: string = "ScryptRocks1231231";
-    const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(hashed, password);
-    assert.isTrue(verified);
-  });
-
-  it("verify fail with factory", () => {
-    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Argon2,
-    );
-    const password: string = "ScryptRocksSomeGarbageText";
-    const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(
-      hashed,
-      "make this fail, its not the same",
-    );
-    assert.isNotTrue(verified);
-  });
+import { assert, expect } from "chai";
+import { BCryptWrapper } from "../src-ts/password-hashers/index";
+import { ScryptWrapper } from "../src-ts/password-hashers/index";
+import {
+  PasswordHasherFactory,
+  PasswordHasherType,
+} from "../src-ts/password-hashers/";
+
+describe("Bcrypt Tests", () => {
+  it("hash", () => {
+    const hasher: BCryptWrapper = new BCryptWrapper();
+    const password: string = "ThisOneBadPassword!@";
+    const hashedPassword: string = hasher.hashPassword(password);
+    assert.notEqual(hashedPassword, password);
+  });
+
+  it("verify pass", () => {
+    const hasher: BCryptWrapper = new BCryptWrapper();
+    const password: string = "NotThisPassword!@";
+    const hashedPassword: string = hasher.hashPassword(password);
+    const isValid: boolean = hasher.verifyPassword(hashedPassword, password);
+    expect(isValid).to.equal(true);
+  });
+
+  it("verify fail", () => {
+    const hasher: BCryptWrapper = new BCryptWrapper();
+    const password: string = "NotThisPassword!@";
+    const hashedPassword: string = hasher.hashPassword(password);
+    const isValid: boolean = hasher.verifyPassword(
+      hashedPassword,
+      "ThesePasswordsDoNotMatch",
+    );
+    expect(isValid).to.equal(false);
+  });
+});
+
+describe("Scrypt Tests", () => {
+  it("hash with factory", () => {
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Scrypt,
+    );
+    const password: string = "ScryptRocks";
+    const hashed: string = hasher.hashPassword(password);
+    assert.notEqual(password, hashed);
+  });
+
+  it("verify pass with factory", () => {
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Scrypt,
+    );
+    const password: string = "ScryptRocks1231231";
+    const hashed: string = hasher.hashPassword(password);
+    const verified: boolean = hasher.verifyPassword(hashed, password);
+    assert.isTrue(verified);
+  });
+
+  it("verify fail with factory", () => {
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Scrypt,
+    );
+    const password: string = "ScryptRocksSomeGarbageText";
+    const hashed: string = hasher.hashPassword(password);
+    const verified: boolean = hasher.verifyPassword(
+      hashed,
+      "make this fail, its not the same",
+    );
+    assert.isNotTrue(verified);
+  });
+});
+
+describe("Argon2 Tests", () => {
+  it("hash with factory", () => {
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Argon2,
+    );
+    const password: string = "ScryptRocks";
+    const hashed: string = hasher.hashPassword(password);
+    assert.notEqual(password, hashed);
+  });
+
+  it("verify pass with factory", () => {
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Argon2,
+    );
+    const password: string = "ScryptRocks1231231";
+    const hashed: string = hasher.hashPassword(password);
+    const verified: boolean = hasher.verifyPassword(hashed, password);
+    assert.isTrue(verified);
+  });
+
+  it("verify fail with factory", () => {
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Argon2,
+    );
+    const password: string = "ScryptRocksSomeGarbageText";
+    const hashed: string = hasher.hashPassword(password);
+    const verified: boolean = hasher.verifyPassword(
+      hashed,
+      "make this fail, its not the same",
+    );
+    assert.isNotTrue(verified);
+  });
 });

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

@@ -1,31 +1,31 @@
-import { assert } from "chai";
-import { AESWrapper } from "../src-ts/symmetric/aes-wrapper";
-import { areEqual } from "./helpers/array";
-
-describe("Symmetric Tests", () => {
-  it("aes 128 encrypt and decrypt equals", () => {
-    const aesWrapper: AESWrapper = new AESWrapper();
-    const aesKey = aesWrapper.aes128Key();
-    const aesNonce = aesWrapper.aesNonce();
-    const tohashed: string = "This is my array to encrypt";
-    const encoder = new TextEncoder();
-    const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const ciphertext = aesWrapper.aes128Encrypt(aesKey, aesNonce, tohashBytes);
-    const plaintxt = aesWrapper.aes128Decrypt(aesKey, aesNonce, ciphertext);
-    var result = areEqual(plaintxt, tohashBytes);
-    assert.isTrue(result);
-  });
-
-  it("aes 256 encrypt and decrypt equals", () => {
-    const aesWrapper: AESWrapper = new AESWrapper();
-    const aesKey = aesWrapper.aes256Key();
-    const aesNonce = aesWrapper.aesNonce();
-    const tohashed: string = "This is my array to encrypt";
-    const encoder = new TextEncoder();
-    const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const ciphertext = aesWrapper.aes256Encrypt(aesKey, aesNonce, tohashBytes);
-    const plaintxt = aesWrapper.aes256Decrypt(aesKey, aesNonce, ciphertext);
-    var result = areEqual(plaintxt, tohashBytes);
-    assert.isTrue(result);
-  });
-});
+import { assert } from "chai";
+import { AESWrapper } from "../src-ts/symmetric/aes-wrapper";
+import { areEqual } from "./helpers/array";
+
+describe("Symmetric Tests", () => {
+  it("aes 128 encrypt and decrypt equals", () => {
+    const aesWrapper: AESWrapper = new AESWrapper();
+    const aesKey = aesWrapper.aes128Key();
+    const aesNonce = aesWrapper.aesNonce();
+    const tohashed: string = "This is my array to encrypt";
+    const encoder = new TextEncoder();
+    const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+    const ciphertext = aesWrapper.aes128Encrypt(aesKey, aesNonce, tohashBytes);
+    const plaintxt = aesWrapper.aes128Decrypt(aesKey, aesNonce, ciphertext);
+    var result = areEqual(plaintxt, tohashBytes);
+    assert.isTrue(result);
+  });
+
+  it("aes 256 encrypt and decrypt equals", () => {
+    const aesWrapper: AESWrapper = new AESWrapper();
+    const aesKey = aesWrapper.aes256Key();
+    const aesNonce = aesWrapper.aesNonce();
+    const tohashed: string = "This is my array to encrypt";
+    const encoder = new TextEncoder();
+    const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+    const ciphertext = aesWrapper.aes256Encrypt(aesKey, aesNonce, tohashBytes);
+    const plaintxt = aesWrapper.aes256Decrypt(aesKey, aesNonce, ciphertext);
+    var result = areEqual(plaintxt, tohashBytes);
+    assert.isTrue(result);
+  });
+});

package/tsconfig.json

@@ -1,22 +1,22 @@
-{
-    "$schema": "https://json.schemastore.org/tsconfig",
-    "display": "Node 18",
-  
-    "compilerOptions": {
-      "lib": ["es2022"],
-      "module": "commonjs",
-      "target": "es2022",
-  
-      "strict": true,
-      "esModuleInterop": true,
-      "skipLibCheck": true,
-      "forceConsistentCasingInFileNames": true,
-  
-      "outDir": "lib",
-      "declaration": true
-    },
-  
-    "include": [
-      "src-ts/**/*"
-    ]
+{
+    "$schema": "https://json.schemastore.org/tsconfig",
+    "display": "Node 18",
+  
+    "compilerOptions": {
+      "lib": ["es2022"],
+      "module": "commonjs",
+      "target": "es2022",
+  
+      "strict": true,
+      "esModuleInterop": true,
+      "skipLibCheck": true,
+      "forceConsistentCasingInFileNames": true,
+  
+      "outDir": "lib",
+      "declaration": true
+    },
+  
+    "include": [
+      "src-ts/**/*"
+    ]
   }

package/lib/hashers/IHasherBase.d.ts

@@ -1,6 +0,0 @@
-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/SHAWrapper.d.ts

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

@@ -1,37 +0,0 @@
-"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/password-hashers/types/argon2-hash-thread-result.d.ts

@@ -1,3 +0,0 @@
-import koffi from "koffi";
-declare const Argon2HashThreadResult: koffi.IKoffiCType;
-export default Argon2HashThreadResult;

package/lib/password-hashers/types/argon2-hash-thread-result.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const koffi_1 = __importDefault(require("koffi"));
-const Argon2HashThreadResult = koffi_1.default.struct("Argon2HashThreadResult", {
-    passwords: 'char *',
-    length: 'int'
-});
-exports.default = Argon2HashThreadResult;