mnemosyne 0.3.1

a process hooking library
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

use crate::module;

pub struct VTable {
    method_index: u64,
    original_pointer: u64,
    original_method: u64,

    pub is_hooked: bool,
}

impl VTable {
    pub fn new(original: u64, index: u64) -> Self {
        Self {
            method_index: index,
            original_pointer: original,
            original_method: 0,

            is_hooked: false,
        }
    }

    pub fn set_hook(&mut self, hook: u64) -> Result<(), String> {
        let vmt = module::read::<*mut u64>(self.original_pointer).unwrap();

        self.original_method = unsafe {
            let result = module::read::<u64>(vmt.add(self.method_index as usize) as u64);
            if result.is_none() {
                return Err("invalid method index".into());
            }

            result.unwrap()
        };

        let result = unsafe { module::write(vmt.add(self.method_index as usize) as u64, &hook) };
        if result.is_ok() {
            self.is_hooked = true;
        }

        result
    }

    pub fn unhook(&mut self) -> Result<(), String> {
        let vmt = module::read::<*mut u64>(self.original_pointer).unwrap();
        let result = unsafe {
            module::write(
                vmt.add(self.method_index as usize) as u64,
                &(self.original_method),
            )
        };

        if result.is_ok() {
            self.is_hooked = false;
        }

        result
    }

    pub fn call_original<R, Args>(&mut self, args: Args) -> R {
        unsafe { std::mem::transmute::<_, extern "C" fn(Args) -> R>(self.original_method)(args) }
    }
}