[test,guest/guest_bin/simpleguest] added test w/ utilizing extra blob data

+ modified guest and guest_bin libs for it too

Signed-off-by: danbugs <[email protected]>

Author: danbugs

src/hyperlight_guest_bin/src/host_comm.rs

@@ -65,6 +65,11 @@ pub fn get_host_function_details() -> HostFunctionDetails {
     handle.get_host_function_details()
 }
 
+pub fn read_n_bytes_from_user_memory(num: u64) -> Result<Vec<u8>> {
+    let handle = unsafe { GUEST_HANDLE };
+    handle.read_n_bytes_from_user_memory(num)
+}
+
 /// Print a message using the host's print function.
 ///
 /// This function requires memory to be setup to be used. In particular, the

src/hyperlight_host/src/sandbox/uninitialized.rs

@@ -441,11 +441,28 @@ mod tests {
     use hyperlight_testing::simple_guest_as_string;
 
     use crate::sandbox::SandboxConfiguration;
-    use crate::sandbox::uninitialized::GuestBinary;
+    use crate::sandbox::uninitialized::{GuestBinary, GuestEnvironment};
     use crate::sandbox_state::sandbox::EvolvableSandbox;
     use crate::sandbox_state::transition::Noop;
     use crate::{MultiUseSandbox, Result, UninitializedSandbox, new_error};
 
+    #[test]
+    fn test_load_extra_blob() {
+        let binary_path = simple_guest_as_string().unwrap();
+        let buffer = [0xde, 0xad, 0xbe, 0xef];
+        let guest_env =
+            GuestEnvironment::new(GuestBinary::FilePath(binary_path.clone()), Some(&buffer));
+
+        let uninitialized_sandbox = UninitializedSandbox::new(guest_env, None).unwrap();
+        let mut sandbox: MultiUseSandbox = uninitialized_sandbox.evolve(Noop::default()).unwrap();
+
+        let res = sandbox
+            .call_guest_function_by_name::<Vec<u8>>("ReadFromUserMemory", (4u64, buffer.to_vec()))
+            .expect("Failed to call ReadFromUserMemory");
+
+        assert_eq!(res, buffer.to_vec());
+    }
+
     #[test]
     fn test_new_sandbox() {
         // Guest Binary exists at path

src/tests/rust_guests/simpleguest/src/main.rs

@@ -46,7 +46,7 @@ use hyperlight_guest::exit::{abort_with_code, abort_with_code_and_message};
 use hyperlight_guest_bin::guest_function::definition::GuestFunctionDefinition;
 use hyperlight_guest_bin::guest_function::register::register_function;
 use hyperlight_guest_bin::host_comm::{
-    call_host_function, call_host_function_without_returning_result,
+    call_host_function, call_host_function_without_returning_result, read_n_bytes_from_user_memory,
 };
 use hyperlight_guest_bin::memory::malloc;
 use hyperlight_guest_bin::{MIN_STACK_ADDRESS, guest_logger};
@@ -750,8 +750,42 @@ fn large_parameters(function_call: &FunctionCall) -> Result<Vec<u8>> {
     }
 }
 
+fn read_from_user_memory(function_call: &FunctionCall) -> Result<Vec<u8>> {
+    if let (ParameterValue::ULong(num), ParameterValue::VecBytes(expected)) = (
+        function_call.parameters.clone().unwrap()[0].clone(),
+        function_call.parameters.clone().unwrap()[1].clone(),
+    ) {
+        let bytes = read_n_bytes_from_user_memory(num).expect("Failed to read from user memory");
+
+        // verify that the user memory contains the expected data
+        if bytes != expected {
+            error!("User memory does not contain the expected data");
+            return Err(HyperlightGuestError::new(
+                ErrorCode::GuestError,
+                "User memory does not contain the expected data".to_string(),
+            ));
+        }
+
+        Ok(get_flatbuffer_result(&*bytes))
+    } else {
+        Err(HyperlightGuestError::new(
+            ErrorCode::GuestFunctionParameterTypeMismatch,
+            "Invalid parameters passed to read_from_user_memory".to_string(),
+        ))
+    }
+}
+
 #[no_mangle]
 pub extern "C" fn hyperlight_main() {
+    let read_from_user_memory_def = GuestFunctionDefinition::new(
+        "ReadFromUserMemory".to_string(),
+        Vec::from(&[ParameterType::ULong, ParameterType::VecBytes]),
+        ReturnType::VecBytes,
+        read_from_user_memory as usize,
+    );
+
+    register_function(read_from_user_memory_def);
+
     let set_static_def = GuestFunctionDefinition::new(
         "SetStatic".to_string(),
         Vec::new(),