Support reading from 32-bit processes on 64-bit hosts and vice versa

src/data_member.rs

@@ -31,6 +31,7 @@ use crate::{CopyAddress, Memory, ProcessHandle, PutAddress};
 pub struct DataMember<T> {
     offsets: Vec<usize>,
     process: ProcessHandle,
+    arch: usize,
     _phantom: std::marker::PhantomData<*mut T>,
 }
 
@@ -53,6 +54,7 @@ impl<T: Sized + Copy> DataMember<T> {
         Self {
             offsets: Vec::new(),
             process: handle,
+            arch: std::mem::size_of::<usize>() * 8,
             _phantom: std::marker::PhantomData,
         }
     }
@@ -69,9 +71,21 @@ impl<T: Sized + Copy> DataMember<T> {
         Self {
             offsets,
             process: handle,
+            arch: std::mem::size_of::<usize>() * 8,
             _phantom: std::marker::PhantomData,
         }
     }
+
+    /// Sets the architecture of the DataMember.
+    ///
+    /// This can be used for reading memory offsets of programs that are of
+    /// different architectures to the host program.
+    /// This defaults to the architecture of the host program.
+    pub fn set_arch(mut self, arch: usize) -> Self {
+        assert!(arch == 32 || arch == 64);
+        self.arch = arch;
+        self
+    }
 }
 
 impl<T: Sized + Copy> Memory<T> for DataMember<T> {
@@ -80,11 +94,11 @@ impl<T: Sized + Copy> Memory<T> for DataMember<T> {
     }
 
     fn get_offset(&self) -> std::io::Result<usize> {
-        self.process.get_offset(&self.offsets)
+        self.process.get_offset(&self.offsets, &self.arch)
     }
 
     fn read(&self) -> std::io::Result<T> {
-        let offset = self.process.get_offset(&self.offsets)?;
+        let offset = self.process.get_offset(&self.offsets, &self.arch)?;
         // This can't be [0_u8;size_of::<T>()] because no const generics.
         // It will be freed at the end of the function because no references are held to it.
         let mut buffer = vec![0_u8; std::mem::size_of::<T>()];
@@ -94,7 +108,7 @@ impl<T: Sized + Copy> Memory<T> for DataMember<T> {
 
     fn write(&self, value: &T) -> std::io::Result<()> {
         use std::slice;
-        let offset = self.process.get_offset(&self.offsets)?;
+        let offset = self.process.get_offset(&self.offsets, &self.arch)?;
         let buffer: &[u8] =
             unsafe { slice::from_raw_parts(value as *const _ as _, std::mem::size_of::<T>()) };
         self.process.put_address(offset, &buffer)

src/lib.rs

@@ -53,6 +53,8 @@
 #![deny(unused)]
 #![deny(clippy::pedantic)]
 
+use std::convert::TryInto;
+
 mod data_member;
 mod local_member;
 
@@ -73,21 +75,22 @@ mod platform;
 /// type into a buffer.
 pub trait CopyAddress {
     /// Copy an address into user-defined buffer.
-    fn copy_address(&self, addr: usize, buf: &mut [u8]) -> std::io::Result<()>;
+    fn copy_address(&self, addr: usize, buf: &mut Vec<u8>) -> std::io::Result<()>;
 
     /// Get the actual memory location from a set of offsets.
     ///
     /// If [`copy_address`] is already defined, then we can provide a standard implementation that
     /// will work across all operating systems.
-    fn get_offset(&self, offsets: &[usize]) -> std::io::Result<usize> {
+    fn get_offset(&self, offsets: &[usize], arch: &usize) -> std::io::Result<usize> {
         // Look ma! No unsafes!
         let mut offset: usize = 0;
         let noffsets: usize = offsets.len();
         for next_offset in offsets.iter().take(noffsets - 1) {
             offset += next_offset;
-            let mut copy: [u8; std::mem::size_of::<usize>()] = [0; std::mem::size_of::<usize>()];
+            let mut copy: Vec<u8> = vec![0; arch / 8];
             self.copy_address(offset, &mut copy)?;
-            offset = usize::from_ne_bytes(copy);
+            copy.resize(std::mem::size_of::<usize>(), 0);
+            offset = usize::from_ne_bytes(copy.as_slice().try_into().unwrap());
         }
 
         offset += offsets[noffsets - 1];

src/linux.rs

@@ -30,7 +30,7 @@ impl TryIntoProcessHandle for Child {
 }
 
 impl CopyAddress for ProcessHandle {
-    fn copy_address(&self, addr: usize, buf: &mut [u8]) -> std::io::Result<()> {
+    fn copy_address(&self, addr: usize, buf: &mut Vec<u8>) -> std::io::Result<()> {
         let local_iov = iovec {
             iov_base: buf.as_mut_ptr() as *mut c_void,
             iov_len: buf.len(),

src/macos.rs

@@ -61,14 +61,14 @@ impl PutAddress for ProcessHandle {
 /// We use `vm_read_overwrite` instead of `vm_read` because it can handle non-aligned reads and
 /// won't read an entire page.
 impl CopyAddress for ProcessHandle {
-    fn copy_address(&self, addr: usize, buf: &mut [u8]) -> std::io::Result<()> {
+    fn copy_address(&self, addr: usize, buf: &mut Vec<u8>) -> std::io::Result<()> {
         let mut read_len: u64 = 0;
         let result = unsafe {
             mach::vm::mach_vm_read_overwrite(
                 *self,
                 addr as _,
                 buf.len() as _,
-                buf.as_ptr() as _,
+                buf.as_mut_ptr() as _,
                 &mut read_len,
             )
         };

src/windows.rs

@@ -54,7 +54,7 @@ impl TryIntoProcessHandle for Child {
 
 /// Use `ReadProcessMemory` to read memory from another process on Windows.
 impl CopyAddress for ProcessHandle {
-    fn copy_address(&self, addr: usize, buf: &mut [u8]) -> std::io::Result<()> {
+    fn copy_address(&self, addr: usize, buf: &mut Vec<u8>) -> std::io::Result<()> {
         if buf.is_empty() {
             return Ok(());
         }
@@ -64,7 +64,7 @@ impl CopyAddress for ProcessHandle {
                 *self,
                 addr as minwindef::LPVOID,
                 buf.as_mut_ptr() as minwindef::LPVOID,
-                mem::size_of_val(buf) as winapi::shared::basetsd::SIZE_T,
+                buf.len() as winapi::shared::basetsd::SIZE_T,
                 ptr::null_mut(),
             )
         } == winapi::shared::minwindef::FALSE