cas-typescript-sdk 1.0.15 → 1.0.17

package/test-ts/insecure-channel.test.spec.ts

@@ -1,51 +1,51 @@
-import {AESWrapper} from "../src-ts/symmetric/index";
-import {X25519Wrapper} from "../src-ts/key_exchange/index";
-import {X25519SecretPublicKeyResult} from "../index";
-import { areEqual } from "./helpers/array";
-import { assert } from "chai";
-
-describe("Insecure Channel Tests", () => {
-    it("AES256-GBC Diffie Hellman X25519", () => {
-      const aesWrapper = new AESWrapper();
-      const x25519Wrapper = new X25519Wrapper();
-      const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      
-      const alice_shared_secret = x25519Wrapper.diffieHellman(alice_keys.secretKey, bob_keys.publicKey);
-      const bob_shared_secret = x25519Wrapper.diffieHellman(bob_keys.secretKey, alice_keys.publicKey);
-
-      const alice_aes_key = aesWrapper.aes256KeyFromX25519SharedSecret(alice_shared_secret);
-      const bob_aes_key = aesWrapper.aes256KeyFromX25519SharedSecret(bob_shared_secret);
-
-      const tohashed: string = "This is my encrypt text";
-      const encoder = new TextEncoder();
-      const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
-
-      const encrypted = aesWrapper.aes256Encrypt(alice_aes_key?.aesKey, alice_aes_key?.aesNonce, toEncrypt);
-      const decrypted = aesWrapper.aes256Decrypt(bob_aes_key?.aesKey, bob_aes_key?.aesNonce, encrypted);
-      let result = areEqual(decrypted, toEncrypt);
-      assert.isTrue(result);
-    });
-
-    it("AES128-GBC Diffie Hellman X25519", () => {
-      const aesWrapper = new AESWrapper();
-      const x25519Wrapper = new X25519Wrapper();
-      const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      
-      const alice_shared_secret = x25519Wrapper.diffieHellman(alice_keys.secretKey, bob_keys.publicKey);
-      const bob_shared_secret = x25519Wrapper.diffieHellman(bob_keys.secretKey, alice_keys.publicKey);
-
-      const alice_aes_key = aesWrapper.aes128KeyFromX25519SharedSecret(alice_shared_secret);
-      const bob_aes_key = aesWrapper.aes128KeyFromX25519SharedSecret(bob_shared_secret);
-
-      const tohashed: string = "This is my encrypt text";
-      const encoder = new TextEncoder();
-      const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
-
-      const encrypted = aesWrapper.aes128Encrypt(alice_aes_key?.aesKey, alice_aes_key?.aesNonce, toEncrypt);
-      const decrypted = aesWrapper.aes128Decrypt(bob_aes_key?.aesKey, bob_aes_key?.aesNonce, encrypted);
-      let result = areEqual(decrypted, toEncrypt);
-      assert.isTrue(result);
-    });
+import {AESWrapper} from "../src-ts/symmetric/index";
+import {X25519Wrapper} from "../src-ts/key_exchange/index";
+import {X25519SecretPublicKeyResult} from "../index";
+import { areEqual } from "./helpers/array";
+import { assert } from "chai";
+
+describe("Insecure Channel Tests", () => {
+    it("AES256-GBC Diffie Hellman X25519", () => {
+      const aesWrapper = new AESWrapper();
+      const x25519Wrapper = new X25519Wrapper();
+      const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
+      const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
+      
+      const alice_shared_secret = x25519Wrapper.diffieHellman(alice_keys.secretKey, bob_keys.publicKey);
+      const bob_shared_secret = x25519Wrapper.diffieHellman(bob_keys.secretKey, alice_keys.publicKey);
+
+      const alice_aes_key = aesWrapper.aes256KeyFromX25519SharedSecret(alice_shared_secret);
+      const bob_aes_key = aesWrapper.aes256KeyFromX25519SharedSecret(bob_shared_secret);
+
+      const tohashed: string = "This is my encrypt text";
+      const encoder = new TextEncoder();
+      const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
+
+      const encrypted = aesWrapper.aes256Encrypt(alice_aes_key?.aesKey, alice_aes_key?.aesNonce, toEncrypt);
+      const decrypted = aesWrapper.aes256Decrypt(bob_aes_key?.aesKey, bob_aes_key?.aesNonce, encrypted);
+      let result = areEqual(decrypted, toEncrypt);
+      assert.isTrue(result);
+    });
+
+    it("AES128-GBC Diffie Hellman X25519", () => {
+      const aesWrapper = new AESWrapper();
+      const x25519Wrapper = new X25519Wrapper();
+      const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
+      const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
+      
+      const alice_shared_secret = x25519Wrapper.diffieHellman(alice_keys.secretKey, bob_keys.publicKey);
+      const bob_shared_secret = x25519Wrapper.diffieHellman(bob_keys.secretKey, alice_keys.publicKey);
+
+      const alice_aes_key = aesWrapper.aes128KeyFromX25519SharedSecret(alice_shared_secret);
+      const bob_aes_key = aesWrapper.aes128KeyFromX25519SharedSecret(bob_shared_secret);
+
+      const tohashed: string = "This is my encrypt text";
+      const encoder = new TextEncoder();
+      const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
+
+      const encrypted = aesWrapper.aes128Encrypt(alice_aes_key?.aesKey, alice_aes_key?.aesNonce, toEncrypt);
+      const decrypted = aesWrapper.aes128Decrypt(bob_aes_key?.aesKey, bob_aes_key?.aesNonce, encrypted);
+      let result = areEqual(decrypted, toEncrypt);
+      assert.isTrue(result);
+    });
 });

package/test-ts/key-exchange-test.spec.ts

@@ -1,23 +1,23 @@
-import { assert } from "chai";
-import { X25519Wrapper } from "../src-ts/index";
-import { areEqual } from "./helpers/array";
-
-describe("X25519 Key Exchange", () => {
-    it("Pass", () => {
-    const wrapper = new X25519Wrapper();
-    const alice = wrapper.generateSecretAndPublicKey();
-    const bob = wrapper.generateSecretAndPublicKey();
-
-    const alice_shared_secret = wrapper.diffieHellman(
-      alice.secretKey,
-      bob.publicKey,
-    );
-    const bob_shared_secret = wrapper.diffieHellman(
-      bob.secretKey,
-      alice.publicKey,
-    );
-
-    var result = areEqual(alice_shared_secret, bob_shared_secret);
-    assert.isTrue(result);
-  });
-});
+import { assert } from "chai";
+import { X25519Wrapper } from "../src-ts/index";
+import { areEqual } from "./helpers/array";
+
+describe("X25519 Key Exchange", () => {
+    it("Pass", () => {
+    const wrapper = new X25519Wrapper();
+    const alice = wrapper.generateSecretAndPublicKey();
+    const bob = wrapper.generateSecretAndPublicKey();
+
+    const alice_shared_secret = wrapper.diffieHellman(
+      alice.secretKey,
+      bob.publicKey,
+    );
+    const bob_shared_secret = wrapper.diffieHellman(
+      bob.secretKey,
+      alice.publicKey,
+    );
+
+    var result = areEqual(alice_shared_secret, bob_shared_secret);
+    assert.isTrue(result);
+  });
+});

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/build-node.sh

@@ -1,2 +0,0 @@
-#!usr/bin/env bash
-rm -rf lib && tsc

package/src-ts/global.d.ts

@@ -1,2 +0,0 @@
-declare var pathToWindowsDll: string;
-declare var pathToLinuxSO: string;