cas-typescript-sdk 1.0.13 → 1.0.15

package/README.md

@@ -1,4 +1,4 @@
-# eas-typescript-sdk
+# cas-typescript-sdk
 
 Ever wanted all of your most useful cryptograpihc operations in one module and not have to surf documentation for various packages? 
 CAS is here to provide a unified development experience as an abstract layer to the RustCrypto and Dalek-Cryptography suite of algorithms.

package/build-node.sh

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

package/index.d.ts

@@ -22,6 +22,8 @@ export function aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plain
 export function aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
 export function aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
 export function aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
+export function aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): AesKeyFromX25519SharedSecret
+export function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): AesKeyFromX25519SharedSecret
 export function generateRsaKeys(keySize: number): RsaKeyPairResult
 export function encryptPlaintextRsa(publicKey: string, plaintext: Array<number>): Array<number>
 export function decryptCiphertextRsa(privateKey: string, ciphertext: Array<number>): Array<number>
@@ -33,6 +35,11 @@ export class X25519SecretPublicKeyResult {
   secretKey: Array<number>
   constructor(publicKey: Array<number>, secretKey: Array<number>)
 }
+export class AesKeyFromX25519SharedSecret {
+  aesKey: Array<number>
+  aesNonce: Array<number>
+  constructor(aesKey: Array<number>, aesNonce: Array<number>)
+}
 export type RSAKeyPairResult = RsaKeyPairResult
 export class RsaKeyPairResult {
   privateKey: string

package/lib/hybrid/hybrid-encryption-wrapper.d.ts

@@ -0,0 +1,9 @@
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+export declare class HybridEncryptionWrapper {
+    private aesWrapper;
+    private rsaWrapper;
+    constructor();
+    encrypt(dataToEncrypt: Array<number>, initalizer: AESRSAHybridInitializer): AesRsaHybridEncryptResult;
+    decrypt(privateKey: string, encryptResult: AesRsaHybridEncryptResult): Array<number>;
+}

package/lib/hybrid/hybrid-encryption-wrapper.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridEncryptionWrapper = void 0;
+const asymmetric_1 = require("../asymmetric");
+const symmetric_1 = require("../symmetric");
+const aes_rsa_hybird_encrypt_result_1 = require("./types/aes-rsa-hybird-encrypt-result");
+class HybridEncryptionWrapper {
+    aesWrapper;
+    rsaWrapper;
+    constructor() {
+        this.aesWrapper = new symmetric_1.AESWrapper();
+        this.rsaWrapper = new asymmetric_1.RSAWrapper();
+    }
+    encrypt(dataToEncrypt, initalizer) {
+        let encryptedData = (initalizer.aesType === 128)
+            ? this.aesWrapper.aes128Encrypt(initalizer.aesKey, initalizer.aesNonce, dataToEncrypt)
+            : this.aesWrapper.aes256Encrypt(initalizer.aesKey, initalizer.aesNonce, dataToEncrypt);
+        let encryptedAesKey = this.rsaWrapper.encrypt(initalizer.rsaKeyPair.publicKey, initalizer.aesKey);
+        let result = new aes_rsa_hybird_encrypt_result_1.AesRsaHybridEncryptResult(encryptedData, encryptedAesKey, initalizer.aesType, initalizer.aesNonce);
+        return result;
+    }
+    decrypt(privateKey, encryptResult) {
+        let plaintextAesKey = this.rsaWrapper.decrypt(privateKey, encryptResult.encryptedAesKey);
+        let plaintext = (encryptResult.aesType === 128)
+            ? this.aesWrapper.aes128Decrypt(plaintextAesKey, encryptResult.aesNonce, encryptResult.ciphertext)
+            : this.aesWrapper.aes256Decrypt(plaintextAesKey, encryptResult.aesNonce, encryptResult.ciphertext);
+        return plaintext;
+    }
+}
+exports.HybridEncryptionWrapper = HybridEncryptionWrapper;

package/lib/hybrid/index.d.ts

@@ -0,0 +1,4 @@
+import { HybridEncryptionWrapper } from "./hybrid-encryption-wrapper";
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, HybridEncryptionWrapper, };

package/lib/hybrid/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridEncryptionWrapper = exports.AESRSAHybridInitializer = exports.AesRsaHybridEncryptResult = void 0;
+const hybrid_encryption_wrapper_1 = require("./hybrid-encryption-wrapper");
+Object.defineProperty(exports, "HybridEncryptionWrapper", { enumerable: true, get: function () { return hybrid_encryption_wrapper_1.HybridEncryptionWrapper; } });
+const aes_rsa_hybird_encrypt_result_1 = require("./types/aes-rsa-hybird-encrypt-result");
+Object.defineProperty(exports, "AesRsaHybridEncryptResult", { enumerable: true, get: function () { return aes_rsa_hybird_encrypt_result_1.AesRsaHybridEncryptResult; } });
+const aes_rsa_hybrid_initializer_1 = require("./types/aes-rsa-hybrid-initializer");
+Object.defineProperty(exports, "AESRSAHybridInitializer", { enumerable: true, get: function () { return aes_rsa_hybrid_initializer_1.AESRSAHybridInitializer; } });

package/lib/hybrid/types/aes-rsa-hybird-encrypt-result.d.ts

@@ -0,0 +1,7 @@
+export declare class AesRsaHybridEncryptResult {
+    ciphertext: Array<number>;
+    encryptedAesKey: Array<number>;
+    aesType: number;
+    aesNonce: Array<number>;
+    constructor(cipherText: Array<number>, encryptAesKey: Array<number>, aesType: number, aesNonce: Array<number>);
+}

package/lib/hybrid/types/aes-rsa-hybird-encrypt-result.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AesRsaHybridEncryptResult = void 0;
+class AesRsaHybridEncryptResult {
+    ciphertext;
+    encryptedAesKey;
+    aesType;
+    aesNonce;
+    constructor(cipherText, encryptAesKey, aesType, aesNonce) {
+        this.ciphertext = cipherText;
+        this.encryptedAesKey = encryptAesKey;
+        this.aesType = aesType;
+        this.aesNonce = aesNonce;
+    }
+}
+exports.AesRsaHybridEncryptResult = AesRsaHybridEncryptResult;

package/lib/hybrid/types/aes-rsa-hybrid-initializer.d.ts

@@ -0,0 +1,8 @@
+import { RsaKeyPairResult } from "../../..";
+export declare class AESRSAHybridInitializer {
+    aesType: number;
+    aesKey: Array<number>;
+    aesNonce: Array<number>;
+    rsaKeyPair: RsaKeyPairResult;
+    constructor(aesType: number, rsaSize: number);
+}

package/lib/hybrid/types/aes-rsa-hybrid-initializer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AESRSAHybridInitializer = void 0;
+const asymmetric_1 = require("../../asymmetric");
+const symmetric_1 = require("../../symmetric");
+class AESRSAHybridInitializer {
+    aesType;
+    aesKey;
+    aesNonce;
+    rsaKeyPair;
+    constructor(aesType, rsaSize) {
+        if (aesType !== 128 && aesType !== 256) {
+            throw new Error("Need an appropriate AES size to generate a hybrid initalizer");
+        }
+        this.aesType = aesType;
+        let aesWrapper = new symmetric_1.AESWrapper();
+        this.aesKey = (aesType === 128) ? aesWrapper.aes128Key() : aesWrapper.aes256Key();
+        this.aesNonce = aesWrapper.aesNonce();
+        if (rsaSize !== 1028 && rsaSize !== 2048 && rsaSize !== 4096) {
+            throw new Error("You must provide an appropriate RSA Key pair size to generate a hybrid initalizer");
+        }
+        this.rsaKeyPair = new asymmetric_1.RSAWrapper().generateKeys(rsaSize);
+    }
+}
+exports.AESRSAHybridInitializer = AESRSAHybridInitializer;

package/lib/index.d.ts

@@ -2,5 +2,6 @@ import { Argon2Wrapper, BCryptWrapper, PasswordHasherFactory, PasswordHasherType
 import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
 import { X25519Wrapper } from "./key_exchange/index";
 import { AESWrapper } from "./symmetric/index";
-import { RSAWrapper, RsaKeyPairResult } from "./asymmetric";
-export { Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, PasswordHasherFactory, PasswordHasherType, ScryptWrapper, SHAWrapper, X25519Wrapper, AESWrapper, RSAWrapper, RsaKeyPairResult };
+import { RsaKeyPairResult, RSAWrapper } from "./asymmetric/index";
+import { AesRsaHybridEncryptResult, AESRSAHybridInitializer, HybridEncryptionWrapper } from "./hybrid/index";
+export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, AESWrapper, Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, HybridEncryptionWrapper, PasswordHasherFactory, PasswordHasherType, RsaKeyPairResult, RSAWrapper, ScryptWrapper, SHAWrapper, X25519Wrapper, };

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RsaKeyPairResult = exports.RSAWrapper = exports.AESWrapper = exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = void 0;
+exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.RSAWrapper = exports.RsaKeyPairResult = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HybridEncryptionWrapper = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = exports.AESWrapper = exports.AESRSAHybridInitializer = exports.AesRsaHybridEncryptResult = void 0;
 const index_1 = require("./password-hashers/index");
 Object.defineProperty(exports, "Argon2Wrapper", { enumerable: true, get: function () { return index_1.Argon2Wrapper; } });
 Object.defineProperty(exports, "BCryptWrapper", { enumerable: true, get: function () { return index_1.BCryptWrapper; } });
@@ -15,6 +15,10 @@ const index_3 = require("./key_exchange/index");
 Object.defineProperty(exports, "X25519Wrapper", { enumerable: true, get: function () { return index_3.X25519Wrapper; } });
 const index_4 = require("./symmetric/index");
 Object.defineProperty(exports, "AESWrapper", { enumerable: true, get: function () { return index_4.AESWrapper; } });
-const asymmetric_1 = require("./asymmetric");
-Object.defineProperty(exports, "RSAWrapper", { enumerable: true, get: function () { return asymmetric_1.RSAWrapper; } });
-Object.defineProperty(exports, "RsaKeyPairResult", { enumerable: true, get: function () { return asymmetric_1.RsaKeyPairResult; } });
+const index_5 = require("./asymmetric/index");
+Object.defineProperty(exports, "RsaKeyPairResult", { enumerable: true, get: function () { return index_5.RsaKeyPairResult; } });
+Object.defineProperty(exports, "RSAWrapper", { enumerable: true, get: function () { return index_5.RSAWrapper; } });
+const index_6 = require("./hybrid/index");
+Object.defineProperty(exports, "AesRsaHybridEncryptResult", { enumerable: true, get: function () { return index_6.AesRsaHybridEncryptResult; } });
+Object.defineProperty(exports, "AESRSAHybridInitializer", { enumerable: true, get: function () { return index_6.AESRSAHybridInitializer; } });
+Object.defineProperty(exports, "HybridEncryptionWrapper", { enumerable: true, get: function () { return index_6.HybridEncryptionWrapper; } });

package/lib/symmetric/aes-wrapper.d.ts

@@ -1,3 +1,4 @@
+import { AesKeyFromX25519SharedSecret } from "../../index";
 export declare class AESWrapper {
     aes128Key(): Array<number>;
     aes256Key(): Array<number>;
@@ -6,4 +7,6 @@ export declare class AESWrapper {
     aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
     aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
     aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
+    aes256KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes128KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
 }

package/lib/symmetric/aes-wrapper.js

@@ -24,5 +24,11 @@ class AESWrapper {
     aes256Decrypt(aesKey, nonce, ciphertext) {
         return (0, index_1.aes256Decrypt)(aesKey, nonce, ciphertext);
     }
+    aes256KeyFromX25519SharedSecret(shared_secret) {
+        return (0, index_1.aes256KeyFromX25519SharedSecret)(shared_secret);
+    }
+    aes128KeyFromX25519SharedSecret(shared_secret) {
+        return (0, index_1.aes128KeyFromX25519SharedSecret)(shared_secret);
+    }
 }
 exports.AESWrapper = AESWrapper;

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
     "test": "cargo test && npm run build && mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
-    "build": "napi build --release && tsc",
+    "node:test": "mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
+    "rust:test": "cargo test",
+    "build": "npm run build:rust && npm run build:node",
+    "build:rust": "napi build --release",
+    "build:node": "bash build-node.sh",
     "prepare": "npm run build"
   },
   "repository": {

package/src/symmetric/aes.rs

@@ -1,3 +1,4 @@
+use aes_gcm::Key;
 use napi_derive::napi;
 use rand::rngs::OsRng;
 use rand::{RngCore, SeedableRng};
@@ -8,7 +9,7 @@ use aes_gcm::{
     Aes256Gcm, Aes128Gcm, KeyInit, Nonce
 };
 
-use super::cas_symmetric_encryption::CASAESEncryption;
+use super::cas_symmetric_encryption::{AesKeyFromX25519SharedSecret, CASAESEncryption};
 pub struct CASAES128;
 pub struct CASAES256;
 
@@ -32,6 +33,17 @@ impl CASAESEncryption for CASAES256 {
         let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).unwrap();
         plaintext
     }
+
+    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
+        let aes_key = Key::<Aes256Gcm>::from_slice(&shared_secret);
+        let mut aes_nonce: [u8; 12] = Default::default();
+        aes_nonce.copy_from_slice(&shared_secret[..12]);
+        let result = AesKeyFromX25519SharedSecret {
+            aes_key: aes_key.to_vec(),
+            aes_nonce: aes_nonce.to_vec()
+        };
+        result
+    }
 }
 
 impl CASAESEncryption for CASAES128 {
@@ -54,6 +66,19 @@ impl CASAESEncryption for CASAES128 {
         let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).unwrap();
         plaintext
     }
+
+    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
+        let mut aes_key: [u8; 16] = Default::default();
+        aes_key.copy_from_slice(&shared_secret[..16]);
+        let aes_key_slice = Key::<Aes128Gcm>::from_slice(&aes_key);
+        let mut aes_nonce: [u8; 12] = Default::default();
+        aes_nonce.copy_from_slice(&shared_secret[..12]);
+        let result = AesKeyFromX25519SharedSecret {
+            aes_key: aes_key_slice.to_vec(),
+            aes_nonce: aes_nonce.to_vec()
+        };
+        result
+    }
 }
 
 #[napi]
@@ -95,6 +120,16 @@ pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) ->
     return CASAES256::decrypt_ciphertext(aes_key, nonce, ciphertext);
 }
 
+#[napi]
+pub fn aes_256_key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
+    return CASAES256::key_from_x25519_shared_secret(shared_secret);
+}
+
+#[napi]
+pub fn aes_128_key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
+    return CASAES128::key_from_x25519_shared_secret(shared_secret);
+}
+
 #[test]
 fn aes128_encrypt_decrypt_test() {
     let aes_key = aes128_key();

package/src/symmetric/cas_symmetric_encryption.rs

@@ -1,5 +1,14 @@
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct AesKeyFromX25519SharedSecret {
+    pub aes_key: Vec<u8>,
+    pub aes_nonce: Vec<u8>
+}
+
 pub trait CASAESEncryption {
     fn generate_key() -> Vec<u8>;
     fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8>;
     fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8>;
+    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret;
 }

package/src-ts/hybrid/hybrid-encryption-wrapper.ts

@@ -0,0 +1,64 @@
+import { RSAWrapper } from "../asymmetric";
+import { AESWrapper } from "../symmetric";
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+
+export class HybridEncryptionWrapper {
+  private aesWrapper: AESWrapper;
+  private rsaWrapper: RSAWrapper;
+
+  constructor() {
+    this.aesWrapper = new AESWrapper();
+    this.rsaWrapper = new RSAWrapper();
+  }
+
+  public encrypt(
+    dataToEncrypt: Array<number>,
+    initalizer: AESRSAHybridInitializer,
+  ): AesRsaHybridEncryptResult {
+    let encryptedData: Array<number> = (initalizer.aesType === 128)
+      ? this.aesWrapper.aes128Encrypt(
+        initalizer.aesKey,
+        initalizer.aesNonce,
+        dataToEncrypt,
+      )
+      : this.aesWrapper.aes256Encrypt(
+        initalizer.aesKey,
+        initalizer.aesNonce,
+        dataToEncrypt,
+      );
+    let encryptedAesKey: Array<number> = this.rsaWrapper.encrypt(
+      initalizer.rsaKeyPair.publicKey,
+      initalizer.aesKey,
+    );
+    let result: AesRsaHybridEncryptResult = new AesRsaHybridEncryptResult(
+      encryptedData,
+      encryptedAesKey,
+      initalizer.aesType,
+      initalizer.aesNonce,
+    );
+    return result;
+  }
+
+  public decrypt(
+    privateKey: string,
+    encryptResult: AesRsaHybridEncryptResult,
+  ): Array<number> {
+    let plaintextAesKey = this.rsaWrapper.decrypt(
+      privateKey,
+      encryptResult.encryptedAesKey,
+    );
+    let plaintext = (encryptResult.aesType === 128)
+      ? this.aesWrapper.aes128Decrypt(
+        plaintextAesKey,
+        encryptResult.aesNonce,
+        encryptResult.ciphertext,
+      )
+      : this.aesWrapper.aes256Decrypt(
+        plaintextAesKey,
+        encryptResult.aesNonce,
+        encryptResult.ciphertext,
+      );
+      return plaintext;
+  }
+}

package/src-ts/hybrid/index.ts

@@ -0,0 +1,9 @@
+import { HybridEncryptionWrapper } from "./hybrid-encryption-wrapper";
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+
+export {
+  AesRsaHybridEncryptResult,
+  AESRSAHybridInitializer,
+  HybridEncryptionWrapper,
+};

package/src-ts/hybrid/types/aes-rsa-hybird-encrypt-result.ts

@@ -0,0 +1,13 @@
+export class AesRsaHybridEncryptResult {
+    ciphertext: Array<number>;
+    encryptedAesKey: Array<number>;
+    aesType: number;
+    aesNonce: Array<number>;
+
+    constructor(cipherText: Array<number>, encryptAesKey: Array<number>, aesType: number, aesNonce: Array<number>) {
+        this.ciphertext = cipherText;
+        this.encryptedAesKey = encryptAesKey;
+        this.aesType = aesType;
+        this.aesNonce = aesNonce;
+    }
+}

package/src-ts/hybrid/types/aes-rsa-hybrid-initializer.ts

@@ -0,0 +1,24 @@
+import { RsaKeyPairResult } from "../../..";
+import { RSAWrapper } from "../../asymmetric";
+import { AESWrapper } from "../../symmetric";
+
+export class AESRSAHybridInitializer {
+    public aesType: number;
+    public aesKey: Array<number>;
+    public aesNonce: Array<number>;
+    public rsaKeyPair: RsaKeyPairResult;
+
+    constructor(aesType: number, rsaSize: number) {
+        if (aesType !== 128 && aesType !== 256) {
+            throw new Error("Need an appropriate AES size to generate a hybrid initalizer");
+        }
+        this.aesType = aesType;
+        let aesWrapper = new AESWrapper();
+        this.aesKey = (aesType === 128) ? aesWrapper.aes128Key() : aesWrapper.aes256Key();
+        this.aesNonce = aesWrapper.aesNonce();
+        if (rsaSize !== 1028 && rsaSize !== 2048 && rsaSize !== 4096) {
+            throw new Error("You must provide an appropriate RSA Key pair size to generate a hybrid initalizer");
+        }
+        this.rsaKeyPair = new RSAWrapper().generateKeys(rsaSize); 
+    }
+}

package/src-ts/index.ts

@@ -8,19 +8,27 @@ import {
 import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
 import { X25519Wrapper } from "./key_exchange/index";
 import { AESWrapper } from "./symmetric/index";
-import { RSAWrapper, RsaKeyPairResult } from "./asymmetric";
+import { RsaKeyPairResult, RSAWrapper } from "./asymmetric/index";
+import {
+  AesRsaHybridEncryptResult,
+  AESRSAHybridInitializer,
+  HybridEncryptionWrapper,
+} from "./hybrid/index";
 
 export {
+  AesRsaHybridEncryptResult,
+  AESRSAHybridInitializer,
+  AESWrapper,
   Argon2Wrapper,
   BCryptWrapper,
   HasherFactory,
   HasherType,
+  HybridEncryptionWrapper,
   PasswordHasherFactory,
   PasswordHasherType,
+  RsaKeyPairResult,
+  RSAWrapper,
   ScryptWrapper,
   SHAWrapper,
   X25519Wrapper,
-  AESWrapper,
-  RSAWrapper,
-  RsaKeyPairResult
 };

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

@@ -1,10 +1,13 @@
 import {
+  AesKeyFromX25519SharedSecret,
   aes128Decrypt,
   aes128Encrypt,
   aes128Key,
+  aes128KeyFromX25519SharedSecret,
   aes256Decrypt,
   aes256Encrypt,
   aes256Key,
+  aes256KeyFromX25519SharedSecret,
   aesNonce,
 } from "../../index";
 
@@ -36,4 +39,12 @@ export class AESWrapper {
     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/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

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

package/lib/hashers/IHasherBase.d.ts

@@ -1,6 +0,0 @@
-export interface IHasherBase {
-    hash_512(dataToHash: number[]): number[];
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean;
-    hash_256(dataToHash: number[]): number[];
-    verify_256(dataToHash: number[], dataToVerify: number[]): boolean;
-}

package/lib/hashers/IHasherBase.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/hashers/SHAWrapper.d.ts

@@ -1,7 +0,0 @@
-import { IHasherBase } from "./IHasherBase";
-export declare class SHAWrapper implements IHasherBase {
-    hash_512(dataToHash: number[]): number[];
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean;
-    hash_256(dataToHash: number[]): number[];
-    verify_256(dataToHash: number[], dataToVerify: number[]): boolean;
-}

package/lib/hashers/SHAWrapper.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHAWrapper = void 0;
-const index_1 = require("../../index");
-class SHAWrapper {
-    hash_512(dataToHash) {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        return (0, index_1.sha512)(dataToHash);
-    }
-    verify_512(dataToHash, dataToVerify) {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        if (!dataToVerify || dataToVerify.length === 0) {
-            throw new Error("You must provide an allocated array of data to verify");
-        }
-        return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
-    }
-    hash_256(dataToHash) {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        return (0, index_1.sha256)(dataToHash);
-    }
-    verify_256(dataToHash, dataToVerify) {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        if (!dataToVerify || dataToVerify.length === 0) {
-            throw new Error("You must provide an allocated array of data to verify");
-        }
-        return (0, index_1.sha256Verify)(dataToHash, dataToVerify);
-    }
-}
-exports.SHAWrapper = SHAWrapper;

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

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

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

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