[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/src/guest_handle/host_comm.rs

@@ -34,6 +34,29 @@ use crate::error::{HyperlightGuestError, Result};
 use crate::exit::out32;
 
 impl GuestHandle {
+    /// Get user memory region as bytes.
+    pub fn read_n_bytes_from_user_memory(&self, num: u64) -> Result<Vec<u8>> {
+        let peb_ptr = self.peb().unwrap();
+        let user_memory_region_ptr = unsafe { (*peb_ptr).user_memory.ptr as *mut u8 };
+        let user_memory_region_size = unsafe { (*peb_ptr).user_memory.size };
+
+        if num > user_memory_region_size {
+            return Err(HyperlightGuestError::new(
+                ErrorCode::GuestError,
+                format!(
+                    "Requested {} bytes from user memory, but only {} bytes are available",
+                    num, user_memory_region_size
+                ),
+            ));
+        } else {
+            let user_memory_region_slice =
+                unsafe { core::slice::from_raw_parts(user_memory_region_ptr, num as usize) };
+            let user_memory_region_bytes = user_memory_region_slice.to_vec();
+
+            Ok(user_memory_region_bytes)
+        }
+    }
+
     /// Get a return value from a host function call.
     /// This usually requires a host function to be called first using
     /// `call_host_function_internal`.

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

@@ -415,11 +415,42 @@ 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.clone(), None);
+            assert!(uninitialized_sandbox.is_err()); // should fail because we don't have enough memory to accommodate the extra blob
+        }
+
+        {
+            let mut cfg = SandboxConfiguration::default();
+            cfg.set_guest_memory_size(0x500_000);
+
+            let uninitialized_sandbox = UninitializedSandbox::new(guest_env, Some(cfg)).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(),