cas-typescript-sdk 1.0.47 → 1.0.48

package/src-ts/sponges/ascon-wrapper.ts

@@ -1,72 +0,0 @@
-import {
-  ascon128Decrypt,
-  ascon128Encrypt,
-  ascon128KeyGenerate,
-  ascon128NonceGenerate,
-} from "../../index";
-
-export class AsconWrapper {
-  /**
-   * Generates an Ascon 128 key
-   * @returns Array<number>
-   */
-  ascon128Key(): Array<number> {
-    return ascon128KeyGenerate();
-  }
-
-  /**
-   * Generates and Ascon 128 nonce.
-   * @returns Array<number>
-   */
-  ascon128Nonce(): Array<number> {
-    return ascon128NonceGenerate();
-  }
-
-  /**
-   * Encrypts with Ascon 128 using the key and nonce generated from ascon128Key() and ascon128Nonce() respectively.
-   * @param key 
-   * @param nonce 
-   * @param plaintext 
-   * @returns 
-   */
-  ascon128Encrypt(
-    key: Array<number>,
-    nonce: Array<number>,
-    plaintext: Array<number>,
-  ): Array<number> {
-    if (!key || key.length === 0) {
-      throw new Error("Key is required");
-    }
-    if (!nonce || nonce.length === 0) {
-      throw new Error("Nonce is required");
-    }
-    if (!plaintext || plaintext.length === 0) {
-      throw new Error("Plaintext is required");
-    }
-    return ascon128Encrypt(key, nonce, plaintext);
-  }
-
-   /**
-   * Decrypts with Ascon 128 using the key and nonce generated from ascon128Key() and ascon128Nonce() respectively.
-   * @param key 
-   * @param nonce 
-   * @param ciphertext 
-   * @returns Array<number>
-   */
-  ascon128Decrypt(
-    key: Array<number>,
-    nonce: Array<number>,
-    ciphertext: Array<number>,
-  ): Array<number> {
-    if (!key || key.length === 0) {
-      throw new Error("Key is required");
-    }
-    if (!nonce || nonce.length === 0) {
-      throw new Error("Nonce is required");
-    }
-    if (!ciphertext || ciphertext.length === 0) {
-      throw new Error("Ciphertext is required");
-    }
-    return ascon128Decrypt(key, nonce, ciphertext);
-  }
-}

package/src-ts/symmetric/aes-wrapper.ts

@@ -1,101 +0,0 @@
-import {
-  aes128Decrypt,
-  aes128Encrypt,
-  aes128Key,
-  aes128KeyFromX25519SharedSecret,
-  aes256Decrypt,
-  aes256Encrypt,
-  aes256Key,
-  aes256KeyFromX25519SharedSecret,
-  aesNonce,
-} from "../../index";
-
-
-export class AESWrapper {
-
-    /**
-     * @description Generates a 128 bit AES key
-     * @returns returns a 128 bit AES key
-     */
-    public aes128Key(): Array<number> {
-        return aes128Key();
-    }
-
-    /**
-     * @description Generates a 256 bit AES key
-     * @returns returns a 256 bit AES key
-     */
-    public aes256Key(): Array<number> {
-        return aes256Key();
-    }
-
-    /**
-     * Generates an 96 bit AES nonce
-     * @returns Array<number>
-     */
-    public generateAESNonce(): Array<number> {
-        return aesNonce();
-    }
-
-    /**
-     * Encrypts with AES 128.
-     * @param aesKey 
-     * @param nonce 
-     * @param plaintext 
-     * @returns Array<number>
-     */
-    public aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
-        return aes128Encrypt(aesKey, nonce, plaintext);
-    }
-
-    /**
-     * Decrypts with AES 128
-     * @param aesKey 
-     * @param nonce 
-     * @param ciphertext 
-     * @returns Array<number>
-     */
-    public aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
-        return aes128Decrypt(aesKey, nonce, ciphertext);
-    }
-
-    /**
-     * Encrypts with AES-256
-     * @param aesKey 
-     * @param nonce 
-     * @param plaintext 
-     * @returns 
-     */
-    public aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
-        return aes256Encrypt(aesKey, nonce, plaintext);
-    }
-
-    /**
-     * Decrypts with AES 256
-     * @param aesKey 
-     * @param nonce 
-     * @param ciphertext 
-     * @returns 
-     */
-    public aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
-        return aes256Decrypt(aesKey, nonce, ciphertext);
-    }
-
-    /**
-     * Derives an AES-256 key from a X25519 Diffie Hellman shared secret.
-     * @param shared_secret 
-     * @returns 
-     */
-    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): number[] {
-         return aes256KeyFromX25519SharedSecret(shared_secret);
-    }
-
-    /**
-     * Derives an AES-128 key from a X25519 Diffie Hellman shared secret.
-     * @param shared_secret 
-     * @returns 
-     */
-    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): number[] {
-        return aes128KeyFromX25519SharedSecret(shared_secret);
-   }
-}

package/test-ts/asymmetric.test.spec.ts

@@ -1,15 +0,0 @@
-import { assert } from "chai";
-import { CASRSAKeyPairResult, RSAWrapper } from "..";
-
-describe("Asymmetric Tests", () => {
-    it("RSA 2048 Sign and Verify", () => {
-      const rsaWrapper = new RSAWrapper();
-      const keys: CASRSAKeyPairResult = rsaWrapper.generateKeys(2048);
-      const tohashed: string = "This is my encrypt";
-      const encoder = new TextEncoder();
-      const toSignBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const signature: Array<number> = rsaWrapper.sign(keys.privateKey, toSignBytes);
-      const verified = rsaWrapper.verify(keys.publicKey, toSignBytes, signature);
-      assert.isTrue(verified);
-    });
-});

package/test-ts/digital-signature.test.spec.ts

@@ -1,70 +0,0 @@
-import { assert } from "chai";
-import { DigitalSignatureFactory, DigitalSignatureType } from "../src-ts/digital-signature/digital-signature-factory";
-import { CASRSADigitalSignatureResult } from "../index";
-import { Ed25519Wrapper } from "../src-ts/signature/ed25519-wrapper";
-
-describe("Digital Signature", () => {
-    it("SHA 512 RSA pass", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
-        const tohashed: string = "This is my array to encrypt";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
-        const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
-        assert.equal(verify, true);
-    });
-
-    it("SHA 512 RSA fails", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
-        const tohashed: string = "This is my array to encrypt";
-        const notOriginal: string = "This is not a fun time";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
-        const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
-        assert.equal(verify, false);
-    });
-
-    it("SHA 256 RSA pass", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
-        const tohashed: string = "This is my array to encrypt";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
-        const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
-        assert.equal(verify, true);
-    });
-
-    it("SHA 256 RSA fails", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
-        const tohashed: string = "This is my array to encrypt";
-        const notOriginal: string = "This is not a fun time";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
-        const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
-        assert.equal(verify, false);
-    });
-
-
-    it("ED25519 Sign and Verify", () => {
-        const ed25519 = new Ed25519Wrapper();
-        const keyPair = ed25519.getKeyPair();
-        const message = Array.from(new TextEncoder().encode("This is a test message"));
-        const signature = ed25519.signMessage(keyPair.privateKey, message);
-        const isValid = ed25519.verifyMessage(keyPair.publicKey, message, signature);
-        assert.equal(isValid, true);
-    });
-
-    it("ED25519 Verify Fails with Wrong Message", () => {
-        const ed25519 = new Ed25519Wrapper();
-        const keyPair = ed25519.getKeyPair();
-        const message = Array.from(new TextEncoder().encode("This is a test message"));
-        const wrongMessage = Array.from(new TextEncoder().encode("This is a different message"));
-        const signature = ed25519.signMessage(keyPair.privateKey, message);
-        const isValid = ed25519.verifyMessage(keyPair.publicKey, wrongMessage, signature);
-        assert.equal(isValid, false);
-    });
-});

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

@@ -1,139 +0,0 @@
-import { assert } from "chai";
-import { Blake2Wrapper, 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.hash512(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.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 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.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);
-  });
-});
-
-
-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);
-  });
-
-  describe("Blake2 256", () => {
-    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.hash256(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.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 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);
-      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);
-    });
-  });
-});

package/test-ts/helpers/array.ts

@@ -1,10 +0,0 @@
-export const areEqual = (a: any, b: any) => {
-    if (a === b) return true;
-    if (a == null || b == null) return false;
-    if (a.length !== b.length) return false;
-
-    for (var i = 0; i < a.length; ++i) {
-        if (a[i] !== b[i]) return false;
-    }
-    return true;
-};

package/test-ts/hmac.test.spec.ts

@@ -1,16 +0,0 @@
-import { assert } from "chai";
-import { HmacWrapper } from "../src-ts/message/index";
-
-describe("HMAC Tests", () => {
-  it("Sign and Verify", () => {
-    const wrapper = new HmacWrapper();
-    const key: string = "This is my array to hash";
-    const encoder = new TextEncoder();
-    const keyBytes: Array<number> = Array.from(encoder.encode(key));
-    const message: string = "This is my message";
-    const messageBytes = Array.from(encoder.encode(message));
-    const signature = wrapper.hmacSignBytes(keyBytes, messageBytes);
-    const result = wrapper.hmacVerifyBytes(keyBytes, messageBytes, signature);
-    assert.equal(true, result);
-  });
-});

package/test-ts/hybrid.test.spec.ts

@@ -1,23 +0,0 @@
-import { HpkeWrapper } from "../src-ts/hybrid/hpke";
-import { assert } from "chai";
-
-describe("Hybrid Encryption", () => {
-    it("HPKE Encrypt and Decrypt", () => {
-        const hpkeWrapper = new HpkeWrapper();
-        const keyPair = hpkeWrapper.generateKeyPair();
-        const encoder = new TextEncoder();
-        const message = "This is a secret message";
-        const messageBytes: Array<number> = Array.from(encoder.encode(message));
-        const encrypted = hpkeWrapper.encrypt(messageBytes, keyPair.publicKey, keyPair.infoStr);
-        const decrypted = hpkeWrapper.decrypt(
-            encrypted.ciphertext,
-            keyPair.secretKey,
-            encrypted.encapsulatedKey,
-            encrypted.tag,
-            keyPair.infoStr
-        );
-        const decoder = new TextDecoder();
-        const decryptedMessage = decoder.decode(new Uint8Array(decrypted));
-        assert.equal(decryptedMessage, message);
-    });
-});

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

@@ -1,55 +0,0 @@
-import {AESWrapper} from "../src-ts/symmetric/index";
-import {X25519Wrapper} from "../src-ts/key_exchange/index";
-import {CASx25519SecretPublicKeyResult} 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: CASx25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      const bob_keys: CASx25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      
-      const alice_shared_secret = x25519Wrapper.generateSharedSecret(alice_keys.secretKey, bob_keys.publicKey);
-      const bob_shared_secret = x25519Wrapper.generateSharedSecret(bob_keys.secretKey, alice_keys.publicKey);
-
-      const alice_aes_key = aesWrapper.aes256KeyNonceX25519DiffieHellman(alice_shared_secret);
-      const bob_aes_key = aesWrapper.aes256KeyNonceX25519DiffieHellman(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 nonce = aesWrapper.generateAESNonce();
-
-      const encrypted = aesWrapper.aes256Encrypt(alice_aes_key, nonce, toEncrypt);
-      const decrypted = aesWrapper.aes256Decrypt(bob_aes_key, nonce, 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: CASx25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      const bob_keys: CASx25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
-      
-      const alice_shared_secret = x25519Wrapper.generateSharedSecret(alice_keys.secretKey, bob_keys.publicKey);
-      const bob_shared_secret = x25519Wrapper.generateSharedSecret(bob_keys.secretKey, alice_keys.publicKey);
-
-      const alice_aes_key = aesWrapper.aes128KeyNonceX25519DiffieHellman(alice_shared_secret);
-      const bob_aes_key = aesWrapper.aes128KeyNonceX25519DiffieHellman(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 nonce = aesWrapper.generateAESNonce();
-
-      const encrypted = aesWrapper.aes128Encrypt(alice_aes_key, nonce, toEncrypt);
-      const decrypted = aesWrapper.aes128Decrypt(bob_aes_key, nonce, encrypted);
-      let result = areEqual(decrypted, toEncrypt);
-      assert.isTrue(result);
-    });
-});

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

@@ -1,23 +0,0 @@
-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.generateSharedSecret(
-      alice.secretKey,
-      bob.publicKey,
-    );
-    const bob_shared_secret = wrapper.generateSharedSecret(
-      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,104 +0,0 @@
-import { assert, expect } from "chai";
-import { Argon2Wrapper, 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.verify(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.verify(
-      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.verify(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.verify(
-      hashed,
-      "make this fail, its not the same",
-    );
-    assert.isNotTrue(verified);
-  });
-});
-
-describe("Argon2 Tests", () => { 
-  it("hash with factory", () => {
-    const hasher: Argon2Wrapper = 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: Argon2Wrapper = PasswordHasherFactory.getHasher(
-      PasswordHasherType.Argon2,
-    );
-    const password: string = "ScryptRocks1231231";
-    const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verify(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.verify(
-      hashed,
-      "make this fail, its not the same",
-    );
-    assert.isNotTrue(verified);
-  });
-});

package/test-ts/sponges.test.spec.ts

@@ -1,28 +0,0 @@
-import { AsconWrapper } from "../src-ts/sponges/ascon-wrapper";
-import { assert } from "chai";
-import { areEqual } from "./helpers/array";
-
-describe("Sponges Tests", () => {
-    it("Ascon 128 Encrypt", () => {
-        const wrapper: AsconWrapper = new AsconWrapper();
-        const key: Array<number> = wrapper.ascon128Key();
-        const nonce: Array<number> = wrapper.ascon128Nonce();
-        const tohashed: string = "This is my array to encrypt";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const ciphertext = wrapper.ascon128Encrypt(key, nonce, tohashBytes);
-        assert.isNotTrue(areEqual(tohashBytes, ciphertext));
-    });
-
-    it ("Ascon 128 Decrypt", () => {
-        const wrapper: AsconWrapper = new AsconWrapper();
-        const key: Array<number> = wrapper.ascon128Key();
-        const nonce: Array<number> = wrapper.ascon128Nonce();
-        const tohashed: string = "This is my array to encrypt";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const ciphertext = wrapper.ascon128Encrypt(key, nonce, tohashBytes);
-        const plaintext = wrapper.ascon128Decrypt(key, nonce, ciphertext);
-        assert.equal(areEqual(plaintext, tohashBytes), true);
-    });
-});