chiter 0.4.3

Memory editing library aimed at game hacking.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121

/// A macro to convert a pointer into a function
///
/// # Example:
/// ```c
/// // This code is in C.
/// int add_one(int thing) {
///     return thing + 1;
/// }
/// ```
/// ```rust
/// // This code is in Rust. 0xDEADBEEF is the address where add_one starts.
/// let add_one = unsafe { make_fn!(0xDEADBEEF, i32, i32) };
///
/// assert_eq!(add_one(400), 401);
/// ```
#[macro_export]
macro_rules! make_fn {
    ($address:expr, $returntype:ty) => {
        std::mem::transmute::<*const usize, fn() -> $returntype>($address as *const usize)
    };
    ($address:expr, $returntype:ty, $($argument:ty),*) => {
        std::mem::transmute::<*const usize, fn($($argument,)*) -> $returntype>($address as *const usize)
    }
}

///A macro to interop with c++ virtual funcs
/// 
/// Supplied by balen (https://www.unknowncheats.me/forum/members/1860455.html)
/// 
/// # Example:
/// ```rust
///  create_function_definitions! {
///  ("thiscall" trace_ray[5] -> bool;(ray, &mut Ray);(mask, u32);(filter, &mut TraceFilter);(trace, &mut Trace))
/// }
///  
/// pub fn new() -> Self {
/// let address = create_interface("engine.dll", "EngineTraceClient004");
///
///  Self {
/// this_ptr: ThisPtr::new(address),
///        }
/// }
/// ```
#[macro_export]
macro_rules! create_function_definitions {
        ($(($calling_convention:tt $visible:vis $function_name:ident[$index:literal] -> $return_type:ty;$(($param_name:ident,$param_type:ty));*)),*) =>{
        $(
            $visible fn $function_name(&self, $($param_name: $param_type),*) -> $return_type{
        unsafe {
        use ::winapi::shared::minwindef::LPVOID;
        use ::std::mem::transmute;
        use crate::util::get_vfunc_address;
        if $calling_convention == "thiscall" {
            return transmute::<LPVOID, extern $calling_convention fn(LPVOID, $($param_type),*) -> $return_type>(get_vfunc_address(self.this_ptr.get(), $index))(self.this_ptr.get(), $($param_name),*);
        }

        transmute::<LPVOID, extern $calling_convention fn($($param_type),*) -> $return_type>(get_vfunc_address(self.this_ptr.get(), $index))($($param_name),*)
    }
    }
        )*

    };

    }

/// A macro to convert multiple pointers into functions
///
/// take note: untested
///
/// # Example:
/// ```c
/// // This code is in C.
/// int add_one(int thing) {
///     return thing + 1;
/// }
///
/// int get_random_number() {
///     return 4;
/// }
/// ```
/// ```rust
/// // This code is in Rust.
/// // 0xDEADBEEF is the address where add_one starts,
/// // and 0x0DEADBEEF + 70 is the address where get_random_number starts.
///
/// let add_one;
/// let get_random_number;
///
/// unsafe {
///     make_functions! {
///         0xDEADBEEF; fn add_one(i32) -> i32;
///         0xDEADBEEF + 70; fn get_random_number() -> i32
///     }
/// }
///
/// assert_eq!(add_one(400), 401);
/// assert_eq!(get_random_number(), 4);
/// ```
// TO-DO: fix "unexpected end of macro invocation" when ending with a ;
#[macro_export]
macro_rules! make_functions {
    ( $( $address:expr; fn $fn_name:ident( $($argument:ty),* ) -> $returntype:ty);* ;) => {
        $(
            $fn_name = std::mem::transmute::<*const usize, fn( $($argument),* ) -> $returntype>($address as *const usize);
        );*
        }
    }

/// A macro to write rust-usable pointers in a somewhat nicer way
///
/// # Example:
///
/// ```rust
/// ptr!(0xDEADBEEF, u8) = 255
/// ```
#[macro_export]
macro_rules! ptr {
    ($address:expr, $type:ty) => {
        *($address as *mut $type)
    };
}