Support Randomization of Stack Padding Bytes

litebox_runner_linux_on_windows_userland/src/lib.rs

@@ -116,13 +116,17 @@ pub fn run(cli_args: CliArgs) -> Result<()> {
         envp
     };
 
+    let mut stack_padding = [0u8; 16];
+    platform.fill_bytes_crng(&mut stack_padding);
+
     let program = shim
         .load_program(
             initial_file_system,
             platform.init_task(),
             prog_path,
             argv,
             envp,
+            Some(&stack_padding),
         )
         .unwrap();
     unsafe {

litebox_runner_linux_userland/src/lib.rs

@@ -4,6 +4,7 @@
 use anyhow::{Context as _, Result, anyhow};
 use clap::Parser;
 use litebox::fs::Mode;
+use litebox::platform::CrngProvider;
 use litebox_platform_linux_userland::LinuxUserland as Platform;
 use memmap2::Mmap;
 use std::os::linux::fs::MetadataExt as _;
@@ -376,7 +377,17 @@ pub fn run(cli_args: CliArgs) -> Result<()> {
     #[cfg(target_arch = "x86_64")]
     litebox_platform_linux_userland::LinuxUserland::enable_seccomp_filter();
 
-    let program = shim.load_program(initial_file_system, task_params, prog_path, argv, envp)?;
+    let mut stack_padding = [0u8; 16];
+    platform.fill_bytes_crng(&mut stack_padding);
+
+    let program = shim.load_program(
+        initial_file_system,
+        task_params,
+        prog_path,
+        argv,
+        envp,
+        Some(&stack_padding),
+    )?;
 
     #[cfg(feature = "lock_tracing")]
     litebox::sync::start_recording();

litebox_runner_linux_userland/tests/loader.rs

@@ -104,7 +104,14 @@ impl TestLauncher {
         let fs = std::sync::Arc::new(self.fs);
         let shim = self.shim_builder.build();
         let program = shim
-            .load_program(fs, self.platform.init_task(), executable_path, argv, envp)
+            .load_program(
+                fs,
+                self.platform.init_task(),
+                executable_path,
+                argv,
+                envp,
+                None,
+            )
             .unwrap();
         unsafe {
             litebox_platform_linux_userland::run_thread(

litebox_runner_snp/src/main.rs

@@ -253,8 +253,14 @@ pub extern "C" fn sandbox_process_init(
     let fs = alloc::sync::Arc::new(litebox::fs::resolver::Resolver::new(litebox, composer));
 
     // Loading a program may trigger page faults, so we need to set SHIM before this.
-    let program = match shim.load_program(fs, platform.init_task(boot_params), &program, argv, envp)
-    {
+    let program = match shim.load_program(
+        fs,
+        platform.init_task(boot_params),
+        &program,
+        argv,
+        envp,
+        None,
+    ) {
         Ok(program) => program,
         Err(err) => {
             litebox_util_log::error!(err:% = err; "failed to load program");

litebox_shim_linux/src/lib.rs

@@ -386,6 +386,7 @@ impl<Platform: ShimPlatform> LinuxShim<Platform> {
         path: &str,
         argv: Vec<alloc::ffi::CString>,
         envp: Vec<alloc::ffi::CString>,
+        padding: Option<&[u8; 16]>,
     ) -> Result<LoadedProgram<Platform>, loader::elf::ElfLoaderError> {
         let litebox_common_linux::TaskParams {
             pid,
@@ -434,6 +435,7 @@ impl<Platform: ShimPlatform> LinuxShim<Platform> {
             loader::elf::ElfLoader::new(&entrypoints.task, &path)?,
             argv,
             envp,
+            padding,
         )?;
         let process = LinuxShimProcess(entrypoints.task.process().clone());
         Ok(LoadedProgram {

litebox_shim_linux/src/loader/elf.rs

@@ -278,6 +278,7 @@ impl<'a, Platform: ShimPlatform> ElfLoader<'a, Platform> {
         &mut self,
         argv: Vec<CString>,
         envp: Vec<CString>,
+        padding: Option<&[u8; 16]>,
         mut aux: AuxVec,
     ) -> Result<ElfLoadInfo, ElfLoaderError> {
         let global = &self.main.file.task.global;
@@ -319,7 +320,7 @@ impl<'a, Platform: ShimPlatform> ElfLoader<'a, Platform> {
         )
         .ok_or(ElfLoaderError::InvalidStackAddr)?;
         stack
-            .init(argv, envp, aux)
+            .init(argv, envp, padding, aux)
             .ok_or(ElfLoaderError::InvalidStackAddr)?;
 
         Ok(ElfLoadInfo {
@@ -511,6 +512,7 @@ mod tests {
             .load(
                 vec![CString::new("/pie").unwrap()],
                 Vec::new(),
+                None,
                 task.init_auxv(),
             )
             .expect("loader should initialize the process stack");

litebox_shim_linux/src/loader/stack.rs

@@ -164,6 +164,7 @@ impl<Platform: ShimPlatform> UserStack<Platform> {
         &mut self,
         argv: Vec<CString>,
         env: Vec<CString>,
+        padding: Option<&[u8; 16]>,
         mut aux: BTreeMap<AuxKey, usize>,
     ) -> Option<()> {
         // end markers
@@ -174,11 +175,11 @@ impl<Platform: ShimPlatform> UserStack<Platform> {
         let envp = self.push_cstrings(&env)?;
         let argvp = self.push_cstrings(&argv)?;
 
-        // TODO: generate a random value
-        self.push_bytes(&[
+        self.push_bytes(padding.unwrap_or(&[
             0xDE, 0xAD, 0xBE, 0xEF, 0xDE, 0xAD, 0xBE, 0xEF, 0xDE, 0xAD, 0xBE, 0xEF, 0xDE, 0xAD,
             0xBE, 0xEF,
-        ])?;
+        ]))?;
+
         aux.insert(AuxKey::AT_RANDOM, self.stack_top.as_usize() + self.pos);
 
         let align_down = |pos: usize, alignment: usize| -> usize {

litebox_shim_linux/src/syscalls/process.rs

@@ -1522,7 +1522,7 @@ impl<Platform: ShimPlatform> Task<Platform> {
             .set_arch_specific_register(&ArchSpecificRegister::FsBase, 0)
             .expect("failed to clear guest TLS on execve");
 
-        self.load_program(loader, argv_vec, envp_vec)
+        self.load_program(loader, argv_vec, envp_vec, None)
             .expect("TODO: terminate the process cleanly");
 
         self.init_thread_context(ctx);
@@ -1536,8 +1536,9 @@ impl<Platform: ShimPlatform> Task<Platform> {
         mut loader: crate::loader::elf::ElfLoader<'_, Platform>,
         argv: Vec<alloc::ffi::CString>,
         envp: Vec<alloc::ffi::CString>,
+        padding: Option<&[u8; 16]>,
     ) -> Result<(), crate::loader::elf::ElfLoaderError> {
-        let load_info = loader.load(argv, envp, self.init_auxv())?;
+        let load_info = loader.load(argv, envp, padding, self.init_auxv())?;
 
         self.set_task_comm(loader.comm());