faithe 0.8.0

Windows memory hacking 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
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::{pattern::Pattern, FaitheError};
use iced_x86::{Decoder, DecoderOptions, Mnemonic, OpKind};
use std::cell::UnsafeCell;

mod global;
mod interface;
mod sizeof;
mod strings;
mod vmt;

cfg_if::cfg_if! {
    if #[cfg(not(feature = "no-std"))] {
        mod function;
        pub use function::*;
    }
}

/// Macro for interal use. Provides functionality to hide panic messages if needed.
#[doc(hidden)]
#[macro_export]
macro_rules! __expect {
    ($var:expr, $msg:expr) => {
        if cfg!(feature = "no-msgs") {
            $var.unwrap()
        } else {
            $var.expect($msg)
        }
    };
}

enum InnerOffset {
    Explicit(usize),
    Pattern(&'static str),
    #[cfg(not(feature = "no-std"))]
    Smart(&'static str),
    Resolved(usize),
}

#[doc(hidden)]
pub struct RuntimeOffset(UnsafeCell<InnerOffset>);
impl RuntimeOffset {
    #[inline(always)]
    pub fn address(&self) -> usize {
        unsafe {
            match *(self.0.get()) {
                InnerOffset::Resolved(address) => address,
                _ => unreachable!(),
            }
        }
    }

    #[inline(always)]
    pub fn is_resolved(&self) -> bool {
        unsafe { matches!(*(self.0.get()), InnerOffset::Resolved(_)) }
    }

    #[inline]
    pub fn try_resolve(&self, module: &'static str, add: usize) -> crate::Result<()> {
        unsafe {
            match *(self.0.get()) {
                InnerOffset::Explicit(offset) => {
                    let base = crate::internal::get_module_address(module)? as usize;
                    *self.0.get() = InnerOffset::Resolved(base + offset + add);
                    Ok(())
                }
                InnerOffset::Pattern(pat) => {
                    let addr = crate::internal::find_pattern(module, Pattern::from_ida_style(pat))?
                        .ok_or(FaitheError::PatternNotFound)?
                        .as_ptr() as usize
                        + add;
                    *self.0.get() = InnerOffset::Resolved(addr);
                    Ok(())
                }
                #[cfg(not(feature = "no-std"))]
                InnerOffset::Smart(pat) => {
                    let addr = crate::internal::find_pattern(module, Pattern::from_ida_style(pat))?
                        .ok_or(FaitheError::PatternNotFound)?
                        .as_ptr() as usize
                        + add;
                    let asm = crate::__expect!(
                        Decoder::new(
                            if cfg!(target_pointer_width = "64") {
                                64
                            } else {
                                32
                            },
                            core::slice::from_raw_parts(addr as _, 15),
                            DecoderOptions::NONE,
                        )
                        .iter()
                        .next(),
                        "Failed to disassemble instruction at address"
                    );
                    let end = match asm.mnemonic() {
                        Mnemonic::Lea | Mnemonic::Mov if asm.op1_kind() == OpKind::Memory => {
                            addr.wrapping_add(asm.memory_displacement64() as usize)
                        }
                        _ => unimplemented!(),
                    };
                    *self.0.get() = InnerOffset::Resolved(end);
                    Ok(())
                }
                InnerOffset::Resolved(_) => Err(FaitheError::AlreadyResolved),
            }
        }
    }

    pub const fn explicit(offset: usize) -> Self {
        Self(UnsafeCell::new(InnerOffset::Explicit(offset)))
    }

    pub const fn pattern(pat: &'static str) -> Self {
        Self(UnsafeCell::new(InnerOffset::Pattern(pat)))
    }

    pub const fn smart(pat: &'static str) -> Self {
        Self(UnsafeCell::new(InnerOffset::Smart(pat)))
    }
}

#[doc(hidden)]
#[macro_export]
macro_rules! __define_offset {
    (# $var:tt) => {
        $crate::RuntimeOffset::explicit($var)
    };
    (@ $var:tt) => {
        $crate::RuntimeOffset::pattern($var)
    };
    (% $var:tt) => {
        $crate::RuntimeOffset::smart($var)
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __define_offset2 {
    () => {
        0
    };
    ($val:tt) => {
        $val
    };
}