min_hook_rs 2.2.0

A Rust implementation of MinHook library for Windows x64 function hooking with simplified but reliable instruction decoding
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

//! Error handling for MinHook-rs
//!
//! This module provides error types that correspond to the original C library's error codes.

use std::fmt;

/// Result type for MinHook operations
pub type Result<T> = std::result::Result<T, HookError>;

/// Error codes returned by MinHook operations
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(i32)]
pub enum HookError {
    /// Unknown error (should not be returned)
    Unknown = -1,

    /// MinHook is already initialized
    AlreadyInitialized = 1,

    /// MinHook is not initialized yet, or already uninitialized
    NotInitialized = 2,

    /// The hook for the specified target function is already created
    AlreadyCreated = 3,

    /// The hook for the specified target function is not created yet
    NotCreated = 4,

    /// The hook for the specified target function is already enabled
    Enabled = 5,

    /// The hook for the specified target function is not enabled yet, or already disabled
    Disabled = 6,

    /// The specified pointer is invalid (points to non-allocated and/or non-executable region)
    NotExecutable = 7,

    /// The specified target function cannot be hooked
    UnsupportedFunction = 8,

    /// Failed to allocate memory
    MemoryAlloc = 9,

    /// Failed to change the memory protection
    MemoryProtect = 10,

    /// The specified module is not loaded
    ModuleNotFound = 11,

    /// The specified function is not found
    FunctionNotFound = 12,
}

impl HookError {
    /// Convert error to string representation
    pub fn as_str(self) -> &'static str {
        match self {
            HookError::Unknown => "Unknown error",
            HookError::AlreadyInitialized => "Already initialized",
            HookError::NotInitialized => "Not initialized",
            HookError::AlreadyCreated => "Already created",
            HookError::NotCreated => "Not created",
            HookError::Enabled => "Already enabled",
            HookError::Disabled => "Already disabled",
            HookError::NotExecutable => "Not executable",
            HookError::UnsupportedFunction => "Unsupported function",
            HookError::MemoryAlloc => "Memory allocation failed",
            HookError::MemoryProtect => "Memory protection failed",
            HookError::ModuleNotFound => "Module not found",
            HookError::FunctionNotFound => "Function not found",
        }
    }

    /// Convert from C-style error code
    pub fn from_code(code: i32) -> Self {
        match code {
            -1 => HookError::Unknown,
            1 => HookError::AlreadyInitialized,
            2 => HookError::NotInitialized,
            3 => HookError::AlreadyCreated,
            4 => HookError::NotCreated,
            5 => HookError::Enabled,
            6 => HookError::Disabled,
            7 => HookError::NotExecutable,
            8 => HookError::UnsupportedFunction,
            9 => HookError::MemoryAlloc,
            10 => HookError::MemoryProtect,
            11 => HookError::ModuleNotFound,
            12 => HookError::FunctionNotFound,
            _ => HookError::Unknown,
        }
    }
}

impl fmt::Display for HookError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::error::Error for HookError {}

/// Success status (equivalent to MH_OK)
pub const OK: i32 = 0;

/// Helper function to create Ok result
pub fn ok<T>(value: T) -> Result<T> {
    Ok(value)
}

/// Helper function to create error result
pub fn err<T>(error: HookError) -> Result<T> {
    Err(error)
}