add tests for encrypt

Author: Dario Maiocchi

Cargo.lock

@@ -14,3 +14,4 @@ serde.workspace = true
 rand.workspace = true
 aws-lc-rs = "1.13.1"
 hex.workspace = true
+tokio = {workspace=true, features=["full"]}

crates/mod-crypto/Cargo.toml

@@ -5,15 +5,15 @@ use aws_lc_rs::cipher::{
 };
 
 use data_encoding::{
-    BASE32, BASE32HEX, BASE32HEX_NOPAD, BASE32_NOPAD, BASE64, BASE64URL, BASE64URL_NOPAD,
-    BASE64_NOPAD, HEXLOWER,
+    BASE32, BASE32_NOPAD, BASE32HEX, BASE32HEX_NOPAD, BASE64, BASE64_NOPAD, BASE64URL,
+    BASE64URL_NOPAD, HEXLOWER,
 };
 
-use mlua::prelude::LuaUserData;
-use mlua::{Lua, MetaMethod, UserDataFields, UserDataMethods, Value, Error as LuaError};
 use config::{any_err, from_lua_value, get_or_create_sub_module};
 use data_loader::KeySource;
 use hex::decode;
+use mlua::prelude::LuaUserData;
+use mlua::{Error as LuaError, Lua, MetaMethod, UserDataFields, UserDataMethods, Value};
 use std::str;
 
 use serde::Deserialize;
@@ -70,7 +70,6 @@ impl AesKey {
     }
 }
 
-
 struct EncryptResult(Vec<u8>);
 
 impl LuaUserData for EncryptResult {
@@ -103,9 +102,7 @@ impl LuaUserData for EncryptResult {
     }
 }
 
-
-
-fn aes_encrypt_block(plaintext: &str, params: AesParams) ->  anyhow::Result<EncryptResult> {
+fn aes_encrypt_block(plaintext: &str, params: AesParams) -> anyhow::Result<EncryptResult> {
     let mut buf_ciphertext = plaintext.as_bytes().to_vec();
     let enc_key: PaddedBlockEncryptingKey;
 
@@ -330,7 +327,8 @@ mod tests {
                 "Ciphertext should contain IV + data"
             );
 
-            let decrypted_text = aes_decrypt_block(ciphertext_with_iv.0.as_slice(), params.clone())?;
+            let decrypted_text =
+                aes_decrypt_block(ciphertext_with_iv.0.as_slice(), params.clone())?;
             let decrypted_string = String::from_utf8(decrypted_text)?;
 
             assert_eq!(decrypted_string, plaintext);
@@ -356,12 +354,139 @@ mod tests {
                 "Ciphertext should contain IV + data"
             );
 
-            let decrypted_text = aes_decrypt_block(ciphertext_with_iv.0.as_slice(), params.clone())?;
+            let decrypted_text =
+                aes_decrypt_block(ciphertext_with_iv.0.as_slice(), params.clone())?;
             let decrypted_string = String::from_utf8(decrypted_text)?;
 
             assert_eq!(decrypted_string, plaintext);
 
+            Ok(())
+        }
+    }
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::Result;
+    use hex;
+    use mlua::Lua;
+
+    mod encrypt_result_lua_tests {
+        use super::*;
+
+        #[tokio::test]
+        async fn test_encrypt_result_hex_field() -> Result<()> {
+            let lua = Lua::new();
+            super::register(&lua)?;
+
+            let plaintext = "testdata";
+            let key_hex = "2b7e151628aed2a6abf7158809cf4f3c"; // AES-128 key
+            let key_bytes = hex::decode(key_hex)?;
+
+            let params = AesParams {
+                key: AesKey::Aes128(key_bytes.try_into().unwrap()),
+                algorithm: AesAlgo::Ecb(),
+            };
+
+            let encrypted_data_result = aes_encrypt_block(plaintext, params)?; // This is EncryptResult
+            let expected_cipher_bytes = encrypted_data_result.0.clone(); // Get the actual encrypted bytes
+
+            let lua_encrypt_result = lua.create_userdata(encrypted_data_result)?;
+            lua.globals().set("encrypted_obj", lua_encrypt_result)?;
+
+            let lua_script = r#"
+                return encrypted_obj.hex
+            "#;
+            let hex_output: String = lua.load(lua_script).eval()?;
+            assert_eq!(hex_output, HEXLOWER.encode(&expected_cipher_bytes)); // Compare with hex of actual encrypted bytes
+
+            Ok(())
+        }
+
+        #[tokio::test]
+        async fn test_encrypt_result_base64_field() -> Result<()> {
+            let lua = Lua::new();
+            super::register(&lua)?;
+
+            let plaintext = "another test string for base64";
+            let key_hex = "603deb1015ca71be2b73aef0857d7781a5b6b8e5b62c65e9f1f63b7ee7ec6f2f"; // AES-256 key
+            let key_bytes = hex::decode(key_hex)?;
+
+            let params = AesParams {
+                key: AesKey::Aes256(key_bytes.try_into().unwrap()),
+                algorithm: AesAlgo::Ecb(),
+            };
+
+            let encrypted_data_result = aes_encrypt_block(plaintext, params)?; // This is EncryptResult
+            let expected_cipher_bytes = encrypted_data_result.0.clone(); // Get the actual encrypted bytes
+
+            let lua_encrypt_result = lua.create_userdata(encrypted_data_result)?;
+            lua.globals().set("encrypted_obj", lua_encrypt_result)?;
+
+            let lua_script = r#"
+                return encrypted_obj.base64
+            "#;
+            let base64_output: String = lua.load(lua_script).eval()?;
+            assert_eq!(base64_output, BASE64.encode(&expected_cipher_bytes)); // Compare with base64 of actual encrypted bytes
+
+            Ok(())
+        }
+
+        #[tokio::test]
+        async fn test_encrypt_result_bytes_field() -> Result<()> {
+            let lua = Lua::new();
+            super::register(&lua)?;
+
+            let plaintext = "raw bytes test";
+            let key_hex = "2b7e151628aed2a6abf7158809cf4f3c";
+            let key_bytes = hex::decode(key_hex)?;
+
+            let params = AesParams {
+                key: AesKey::Aes128(key_bytes.try_into().unwrap()),
+                algorithm: AesAlgo::Ecb(),
+            };
+
+            let encrypted_data = aes_encrypt_block(plaintext, params)?;
+            let expected_bytes = encrypted_data.0.clone(); // Clone the internal bytes before moving `encrypted_data`
+            let lua_encrypt_result = lua.create_userdata(encrypted_data)?;
+            lua.globals().set("encrypted_obj", lua_encrypt_result)?;
+
+            let lua_script = r#"
+                return encrypted_obj.bytes
+            "#;
+            let bytes_output: mlua::String = lua.load(lua_script).eval()?;
+            assert_eq!(bytes_output.as_bytes(), expected_bytes.as_slice());
+
+            Ok(())
+        }
+
+        #[tokio::test]
+        async fn test_encrypt_result_tostring_method() -> Result<()> {
+            let lua = Lua::new();
+            super::register(&lua)?;
+
+            let plaintext = "tostring method test";
+            let key_hex = "603deb1015ca71be2b73aef0857d7781a5b6b8e5b62c65e9f1f63b7ee7ec6f2f";
+            let key_bytes = hex::decode(key_hex)?;
+
+            let params = AesParams {
+                key: AesKey::Aes256(key_bytes.try_into().unwrap()),
+                algorithm: AesAlgo::Ecb(),
+            };
+
+            let encrypted_data = aes_encrypt_block(plaintext, params)?;
+            let expected_hex = HEXLOWER.encode(&encrypted_data.0); // Get expected hex before moving
+            let lua_encrypt_result = lua.create_userdata(encrypted_data)?;
+            lua.globals().set("encrypted_obj", lua_encrypt_result)?;
+
+            let lua_script = r#"
+                return tostring(encrypted_obj)
+            "#;
+            let tostring_output: String = lua.load(lua_script).eval()?;
+            assert_eq!(tostring_output, expected_hex);
+
             Ok(())
         }
     }
 }
+    }
+