dll-syringe 0.6.0

A windows dll injection library written in rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use std::{cell::RefCell, io, marker::PhantomData, mem, ptr::NonNull, rc::Rc};

use crate::{
    process_memory::{Allocation, DynamicMultiBufferAllocator, ProcessMemorySlice, RawAllocator},
    ProcessRef,
};

#[derive(Debug, Clone)]
pub struct RemoteBoxAllocator<'a>(Rc<RefCell<DynamicMultiBufferAllocator<'a>>>);

impl<'a> RemoteBoxAllocator<'a> {
    pub fn new(process: ProcessRef<'a>) -> Self {
        Self(Rc::new(RefCell::new(DynamicMultiBufferAllocator::new(
            process,
        ))))
    }

    pub fn process(&self) -> ProcessRef<'a> {
        self.0.borrow().process()
    }

    pub unsafe fn alloc_raw<T: ?Sized>(
        &mut self,
        size: usize,
    ) -> Result<RemoteBox<'a, T>, io::Error> {
        let allocation = self.0.borrow_mut().alloc(size)?;
        Ok(RemoteBox::new(self.0.clone(), allocation))
    }
    pub fn alloc_uninit<T: Sized>(&mut self) -> Result<RemoteBox<'a, T>, io::Error> {
        unsafe { self.alloc_raw(mem::size_of::<T>()) }
    }
    pub fn alloc_uninit_for<T: ?Sized>(
        &mut self,
        value: &T,
    ) -> Result<RemoteBox<'a, T>, io::Error> {
        unsafe { self.alloc_raw(mem::size_of_val(value)) }
    }
    pub fn alloc_and_copy<T: ?Sized>(&mut self, value: &T) -> Result<RemoteBox<'a, T>, io::Error> {
        let b = self.alloc_uninit_for(value)?;
        b.write(value)?;
        Ok(b)
    }

    #[allow(dead_code)]
    fn free(&mut self, allocation: &Allocation) {
        self.0.borrow_mut().free(allocation);
    }
}

#[derive(Debug)]
pub struct RemoteBox<'a, T: ?Sized> {
    allocation: Allocation,
    allocator: Rc<RefCell<DynamicMultiBufferAllocator<'a>>>,
    phantom: PhantomData<T>,
}

impl<'a, T: ?Sized> RemoteBox<'a, T> {
    fn new(
        allocator: Rc<RefCell<DynamicMultiBufferAllocator<'a>>>,
        allocation: Allocation,
    ) -> Self {
        Self {
            allocation,
            allocator,
            phantom: PhantomData,
        }
    }

    pub fn process(&self) -> ProcessRef<'a> {
        self.allocator.borrow().process()
    }

    pub fn memory(&self) -> ProcessMemorySlice<'a> {
        unsafe {
            ProcessMemorySlice::from_raw_parts(
                self.allocation.as_raw_ptr(),
                self.allocation.len,
                self.process(),
            )
        }
    }

    pub fn write(&self, value: &T) -> Result<(), io::Error> {
        self.memory().write_struct(0, value)
    }

    pub fn as_raw_ptr(&mut self) -> *mut u8 {
        self.allocation.as_raw_ptr()
    }
}

impl<'a, T: Sized> RemoteBox<'a, T> {
    pub fn read(&self) -> Result<T, io::Error> {
        unsafe { self.memory().read_struct::<T>(0) }
    }

    #[allow(dead_code)]
    pub fn as_ptr(&mut self) -> NonNull<T> {
        self.allocation.as_ptr().cast()
    }
}

impl<T: ?Sized> Drop for RemoteBox<'_, T> {
    fn drop(&mut self) {
        self.allocator.borrow_mut().free(&self.allocation);
    }
}