cas-typescript-sdk 1.0.14 → 1.0.16

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

@@ -1,50 +1,50 @@
-import {
-  AesKeyFromX25519SharedSecret,
-  aes128Decrypt,
-  aes128Encrypt,
-  aes128Key,
-  aes128KeyFromX25519SharedSecret,
-  aes256Decrypt,
-  aes256Encrypt,
-  aes256Key,
-  aes256KeyFromX25519SharedSecret,
-  aesNonce,
-} from "../../index";
-
-export class AESWrapper {
-    public aes128Key(): Array<number> {
-        return aes128Key();
-    }
-
-    public aes256Key(): Array<number> {
-        return aes256Key();
-    }
-
-    public aesNonce(): Array<number> {
-        return aesNonce();
-    }
-
-    public aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
-        return aes128Encrypt(aesKey, nonce, plaintext);
-    }
-
-    public aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
-        return aes128Decrypt(aesKey, nonce, ciphertext);
-    }
-
-    public aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
-        return aes256Encrypt(aesKey, nonce, plaintext);
-    }
-
-    public aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
-        return aes256Decrypt(aesKey, nonce, ciphertext);
-    }
-
-    public aes256KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
-         return aes256KeyFromX25519SharedSecret(shared_secret);
-    }
-
-    public aes128KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
-        return aes128KeyFromX25519SharedSecret(shared_secret);
-   }
-}
+import {
+  AesKeyFromX25519SharedSecret,
+  aes128Decrypt,
+  aes128Encrypt,
+  aes128Key,
+  aes128KeyFromX25519SharedSecret,
+  aes256Decrypt,
+  aes256Encrypt,
+  aes256Key,
+  aes256KeyFromX25519SharedSecret,
+  aesNonce,
+} from "../../index";
+
+export class AESWrapper {
+    public aes128Key(): Array<number> {
+        return aes128Key();
+    }
+
+    public aes256Key(): Array<number> {
+        return aes256Key();
+    }
+
+    public aesNonce(): Array<number> {
+        return aesNonce();
+    }
+
+    public aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
+        return aes128Encrypt(aesKey, nonce, plaintext);
+    }
+
+    public aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
+        return aes128Decrypt(aesKey, nonce, ciphertext);
+    }
+
+    public aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
+        return aes256Encrypt(aesKey, nonce, plaintext);
+    }
+
+    public aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
+        return aes256Decrypt(aesKey, nonce, ciphertext);
+    }
+
+    public aes256KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+         return aes256KeyFromX25519SharedSecret(shared_secret);
+    }
+
+    public aes128KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+        return aes128KeyFromX25519SharedSecret(shared_secret);
+   }
+}

package/src-ts/symmetric/index.ts

@@ -1,3 +1,3 @@
-import { AESWrapper } from "./aes-wrapper";
-
-export { AESWrapper };
+import { AESWrapper } from "./aes-wrapper";
+
+export { AESWrapper };

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

@@ -1,28 +1,28 @@
-import { assert } from "chai";
-import { RSAWrapper, RsaKeyPairResult } from "..";
-import { areEqual } from "./helpers/array";
-
-describe("Asymmetric Tests", () => {
-    it("RSA 4096 encrypt and decrypt equals", () => {
-      const rsaWrapper: RSAWrapper = new RSAWrapper();
-      const keys: RsaKeyPairResult = rsaWrapper.generateKeys(4096);
-      const tohashed: string = "This is my array to encrypt";
-      const encoder = new TextEncoder();
-      const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const ciphertext = rsaWrapper.encrypt(keys.publicKey, tohashBytes);
-      const plaintext = rsaWrapper.decrypt(keys.privateKey, ciphertext);
-      let result = areEqual(tohashBytes, plaintext);
-      assert.isTrue(result);
-    });
-
-    it("RSA 2048 Sign and Verify", () => {
-      const rsaWrapper = new RSAWrapper();
-      const keys: RsaKeyPairResult = 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);
-    });
+import { assert } from "chai";
+import { RSAWrapper, RsaKeyPairResult } from "..";
+import { areEqual } from "./helpers/array";
+
+describe("Asymmetric Tests", () => {
+    it("RSA 4096 encrypt and decrypt equals", () => {
+      const rsaWrapper: RSAWrapper = new RSAWrapper();
+      const keys: RsaKeyPairResult = rsaWrapper.generateKeys(4096);
+      const tohashed: string = "This is my array to encrypt";
+      const encoder = new TextEncoder();
+      const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+      const ciphertext = rsaWrapper.encrypt(keys.publicKey, tohashBytes);
+      const plaintext = rsaWrapper.decrypt(keys.privateKey, ciphertext);
+      let result = areEqual(tohashBytes, plaintext);
+      assert.isTrue(result);
+    });
+
+    it("RSA 2048 Sign and Verify", () => {
+      const rsaWrapper = new RSAWrapper();
+      const keys: RsaKeyPairResult = 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

@@ -0,0 +1,49 @@
+import { assert } from "chai";
+import { DigitalSignatureFactory, DigitalSignatureType } from "../src-ts/digital-signature/digital-signature-factory";
+import { CASRSADigitalSignatureResult } from "../index";
+
+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);
+    });
+});

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

@@ -1,71 +1,71 @@
-import { assert } from "chai";
-import { 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.hash_512(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.hash_512(tohashBytes);
-    const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const verified = wrapper.verify_512(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.hash_512(tohashBytes);
-    const toVerify = "This Is Not The Same";
-    const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
-    const verified = wrapper.verify_512(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.hash_256(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.hash_256(tohashBytes);
-      const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const verified = wrapper.verify_256(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.hash_256(tohashBytes);
-      const toVerify = "This Is Not The Same";
-      const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
-      const verified = wrapper.verify_256(hashed, toVerifyBytes);
-      assert.equal(false, verified);
-    });
+import { assert } from "chai";
+import { 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.hash_512(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.hash_512(tohashBytes);
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
+    const verified = wrapper.verify_512(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.hash_512(tohashBytes);
+    const toVerify = "This Is Not The Same";
+    const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
+    const verified = wrapper.verify_512(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.hash_256(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.hash_256(tohashBytes);
+      const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
+      const verified = wrapper.verify_256(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.hash_256(tohashBytes);
+      const toVerify = "This Is Not The Same";
+      const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
+      const verified = wrapper.verify_256(hashed, toVerifyBytes);
+      assert.equal(false, verified);
+    });
   });

package/test-ts/helpers/array.ts

@@ -1,10 +1,10 @@
-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;
+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/hybrid.test.spec.ts

@@ -0,0 +1,33 @@
+import { assert } from "chai";
+import {
+  AESRSAHybridInitializer,
+  AesRsaHybridEncryptResult,
+  HybridEncryptionWrapper,
+} from "../src-ts/hybrid/index";
+import { areEqual } from "./helpers/array";
+
+describe("Hybrid Encryption Tests", () => {
+  it("RSA 4096 AES 128 encrypt and decrypt equals", () => {
+    const hybridWrapper = new HybridEncryptionWrapper();
+    let initalizer = new AESRSAHybridInitializer(128, 4096);
+    const tohashed: string = "This is my encrypt text for rsa hybrid";
+    const encoder = new TextEncoder();
+    const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
+    let result: AesRsaHybridEncryptResult = hybridWrapper.encrypt(toEncrypt, initalizer);
+    let plaintext: Array<number> = hybridWrapper.decrypt(initalizer.rsaKeyPair.privateKey, result);
+    let result2 = areEqual(toEncrypt, plaintext);
+    assert.isTrue(result2);
+  });
+
+  it("RSA 2048 AES 256 encrypt and decrypt equals", () => {
+    const hybridWrapper = new HybridEncryptionWrapper();
+    let initalizer = new AESRSAHybridInitializer(256, 2048);
+    const tohashed: string = "This is my encrypt text for rsa hybrid";
+    const encoder = new TextEncoder();
+    const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
+    let result: AesRsaHybridEncryptResult = hybridWrapper.encrypt(toEncrypt, initalizer);
+    let plaintext: Array<number> = hybridWrapper.decrypt(initalizer.rsaKeyPair.privateKey, result);
+    let result2 = areEqual(toEncrypt, plaintext);
+    assert.isTrue(result2);
+  });
+});

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