cas-typescript-sdk 1.0.47 → 1.0.49

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);
-    });
-});

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

@@ -1,82 +0,0 @@
-import { assert } from "chai";
-import { AESWrapper } from "../src-ts/symmetric/aes-wrapper";
-import { X25519Wrapper } from '../src-ts/key_exchange/x25519';
-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.generateAESNonce();
-    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.generateAESNonce();
-    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);
-  });
-
-  it("ase 256 X25519 Diffie-Hellman encrypt and decrypt", () => {
-    const x25519 = new X25519Wrapper();
-    const alice= x25519.generateSecretAndPublicKey();
-    const bob = x25519.generateSecretAndPublicKey();
-
-    const aliceSharedSecret = x25519.generateSharedSecret(alice.secretKey, bob.publicKey);
-    const bobSharedSecret = x25519.generateSharedSecret(bob.secretKey, alice.publicKey);
-
-    const aesWrapper: AESWrapper = new AESWrapper();
-    const aliceAesKey = aesWrapper.aes256KeyNonceX25519DiffieHellman(aliceSharedSecret);
-    const bobAesKey = aesWrapper.aes256KeyNonceX25519DiffieHellman(bobSharedSecret);
-
-    const nonce = aesWrapper.generateAESNonce();
-
-    const tohashed: string = "This is my array to encrypt";
-    const encoder = new TextEncoder();
-    const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-
-    const aliceCiphertext = aesWrapper.aes256Encrypt(aliceAesKey, nonce, tohashBytes);
-    const bobPlaintext = aesWrapper.aes256Decrypt(bobAesKey, nonce, aliceCiphertext);
-
-    var result = areEqual(bobPlaintext, tohashBytes);
-    assert.isTrue(result);
-  });
-
-  it("ase 128 X25519 Diffie-Hellman encrypt and decrypt", () => {
-    const x25519 = new X25519Wrapper();
-    const alice= x25519.generateSecretAndPublicKey();
-    const bob = x25519.generateSecretAndPublicKey();
-
-    const aliceSharedSecret = x25519.generateSharedSecret(alice.secretKey, bob.publicKey);
-    const bobSharedSecret = x25519.generateSharedSecret(bob.secretKey, alice.publicKey);
-
-    const aesWrapper: AESWrapper = new AESWrapper();
-    const aliceAesKey = aesWrapper.aes128KeyNonceX25519DiffieHellman(aliceSharedSecret);
-    const bobAesKey = aesWrapper.aes128KeyNonceX25519DiffieHellman(bobSharedSecret);
-
-    const tohashed: string = "This is my array to encrypt";
-    const encoder = new TextEncoder();
-    const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-
-    const nonce = aesWrapper.generateAESNonce();
-
-    const aliceCiphertext = aesWrapper.aes128Encrypt(aliceAesKey, nonce, tohashBytes);
-    const bobPlaintext = aesWrapper.aes128Decrypt(bobAesKey, nonce, aliceCiphertext);
-
-    var result = areEqual(bobPlaintext, tohashBytes);
-    assert.isTrue(result);
-  });
-});

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-    "$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/**/*"
-    ]
-  }