cas-typescript-sdk 1.0.13 → 1.0.14

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/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,11 +1,13 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "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",
+    "node:test": "mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
+    "rust:test": "cargo test",
     "build": "napi build --release && tsc",
     "prepare": "npm run build"
   },

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