moving aes logic into cas-lib

Author: WingZer0o

index.d.ts

@@ -28,8 +28,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 aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
+export function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
 export function generateRsaKeys(keySize: number): CasrsaKeyPairResult
 export function encryptPlaintextRsa(publicKey: string, plaintext: Array<number>): Array<number>
 export function decryptCiphertextRsa(privateKey: string, ciphertext: Array<number>): Array<number>
@@ -53,7 +53,8 @@ export class CaSx25519SecretPublicKeyResult {
   secretKey: Array<number>
   constructor(publicKey: Array<number>, secretKey: Array<number>)
 }
-export class AesKeyFromX25519SharedSecret {
+export type CASAesKeyFromX25519SharedSecret = CasAesKeyFromX25519SharedSecret
+export class CasAesKeyFromX25519SharedSecret {
   aesKey: Array<number>
   aesNonce: Array<number>
   constructor(aesKey: Array<number>, aesNonce: Array<number>)

index.node

@@ -1,5 +1,5 @@
 import {
-  AesKeyFromX25519SharedSecret,
+  CASAesKeyFromX25519SharedSecret,
   aes128Decrypt,
   aes128Encrypt,
   aes128Key,
@@ -87,7 +87,7 @@ export class AESWrapper {
      * @param shared_secret 
      * @returns 
      */
-    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret {
          return aes256KeyFromX25519SharedSecret(shared_secret);
     }
 
@@ -96,7 +96,7 @@ export class AESWrapper {
      * @param shared_secret 
      * @returns 
      */
-    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret {
         return aes128KeyFromX25519SharedSecret(shared_secret);
    }
 }

src-ts/symmetric/aes-wrapper.ts

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

src-ts/symmetric/index.ts

@@ -10,12 +10,12 @@ mod hashers {
 
 mod key_exchange {
     pub mod x25519;
-    pub mod types;
+    mod types;
 }
 
 mod symmetric {
     pub mod aes;
-    pub mod cas_symmetric_encryption;
+    mod types;
 }
 
 mod asymmetric {
@@ -27,7 +27,7 @@ mod digital_signature {
     pub mod sha_256_rsa;
     pub mod sha_512_ed25519;
     pub mod sha_256_ed25519;
-    pub mod types;
+    mod types;
 }
 
 mod sponges {

src/lib.rs

@@ -1,85 +1,10 @@
 use aes_gcm::Key;
+use cas_lib::symmetric::{aes::{CASAES128, CASAES256}, cas_symmetric_encryption::CASAESEncryption};
 use napi_derive::napi;
-use rand::rngs::OsRng;
 use rand::{RngCore, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 
-use aes_gcm::{
-    aead::{generic_array::GenericArray, Aead},
-    Aes128Gcm, Aes256Gcm, KeyInit, Nonce,
-};
-
-use super::cas_symmetric_encryption::{AesKeyFromX25519SharedSecret, CASAESEncryption};
-pub struct CASAES128;
-pub struct CASAES256;
-
-impl CASAESEncryption for CASAES256 {
-    fn generate_key() -> Vec<u8> {
-        return Aes256Gcm::generate_key(&mut OsRng).to_vec();
-    }
-
-    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes256Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let ciphertext = cipher.encrypt(nonce, plaintext.as_ref()).unwrap();
-        ciphertext
-    }
-
-    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes256Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        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 {
-    fn generate_key() -> Vec<u8> {
-        return Aes128Gcm::generate_key(&mut OsRng).to_vec();
-    }
-
-    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes128Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let ciphertext = cipher.encrypt(nonce, plaintext.as_ref()).unwrap();
-        ciphertext
-    }
-
-    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let cipher = Aes128Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        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
-    }
-}
+use super::types::CASAesKeyFromX25519SharedSecret;
 
 #[napi]
 pub fn aes_nonce() -> Vec<u8> {
@@ -92,46 +17,46 @@ pub fn aes_nonce() -> Vec<u8> {
 
 #[napi]
 pub fn aes128_key() -> Vec<u8> {
-    return CASAES128::generate_key();
+    return <CASAES128 as CASAESEncryption>::generate_key();
 }
 
 #[napi]
 pub fn aes256_key() -> Vec<u8> {
-    return CASAES256::generate_key();
+    return <CASAES256 as CASAESEncryption>::generate_key();
 }
 
 #[napi]
 pub fn aes128_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return CASAES128::encrypt_plaintext(aes_key, nonce, plaintext);
+    return <CASAES128 as CASAESEncryption>::encrypt_plaintext(aes_key, nonce, plaintext);
 }
 
 #[napi]
 pub fn aes128_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return CASAES128::decrypt_ciphertext(aes_key, nonce, ciphertext);
+    return <CASAES128 as CASAESEncryption>::decrypt_ciphertext(aes_key, nonce, ciphertext);
 }
 
 #[napi]
 pub fn aes256_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return CASAES256::encrypt_plaintext(aes_key, nonce, plaintext);
+    return <CASAES256 as CASAESEncryption>::encrypt_plaintext(aes_key, nonce, plaintext);
 }
 
 #[napi]
 pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return CASAES256::decrypt_ciphertext(aes_key, nonce, ciphertext);
+    return <CASAES256 as CASAESEncryption>::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);
+) -> CASAesKeyFromX25519SharedSecret {
+    return <CASAES256 as CASAESEncryption>::key_from_x25519_shared_secret(shared_secret).into();
 }
 
 #[napi]
 pub fn aes_128_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
-) -> AesKeyFromX25519SharedSecret {
-    return CASAES128::key_from_x25519_shared_secret(shared_secret);
+) -> CASAesKeyFromX25519SharedSecret {
+    return <CASAES128 as CASAESEncryption>::key_from_x25519_shared_secret(shared_secret).into();
 }
 
 #[test]

src/symmetric/aes.rs

@@ -0,0 +1,17 @@
+use cas_lib::symmetric::cas_symmetric_encryption::AesKeyFromX25519SharedSecret;
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct CASAesKeyFromX25519SharedSecret {
+    pub aes_key: Vec<u8>,
+    pub aes_nonce: Vec<u8>,
+}
+
+impl From<AesKeyFromX25519SharedSecret> for CASAesKeyFromX25519SharedSecret {
+    fn from(value: AesKeyFromX25519SharedSecret) -> Self {
+        CASAesKeyFromX25519SharedSecret {
+            aes_key: value.aes_key,
+            aes_nonce: value.aes_nonce
+        }
+    }
+}