dll-syringe 0.2.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
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
145
146
147
148
149
150
151
152
153

use std::io;

use quick_error::quick_error;

quick_error! {
    #[derive(Debug)]
    /// Error enum representing either a win32 api error or a nul error from an invalid interior nul.
    pub enum Win32OrNulError {
        /// Variant representing an illegal interior nul value.
        Nul(source: widestring::NulError<u16>) {
            from()
            display("Invalid nul value in argument: {}", source)
            source(source)
        }
        /// Variant representing an windows api error.
        Win32(source: rust_win32error::Win32Error) {
            from()
            display("Windows API call failed: {}", source)
            source(source)
        }
    }
}

quick_error! {
    /// Error enum for errors during a call to [`ProcessModule::get_procedure`].
    ///
    /// [`ProcessModule::get_procedure`]: ProcessModule::get_procedure
    #[derive(Debug)]
    pub enum ProcedureLoadError {
        /// Variant representing an illegal interior nul value.
        Nul(source: std::ffi::NulError) {
            from()
            display("Invalid nul value in argument: {}", source)
            source(source)
        }
        /// Variant representing an windows api error.
        Win32(source: rust_win32error::Win32Error) {
            from()
            display("Windows API call failed: {}", source)
            source(source)
        }
        /// Variant representing an unsupported target process.
        UnsupportedTarget {
            display("The requested operation is not supported for the target process.")
        }
    }
}

quick_error! {
    /// Error enum for errors during a call to [`ProcessModule::from_path`] and related methods.
    ///
    /// [`ProcessModule::from_path`]: ProcessModule::from_path
    #[derive(Debug)]
    pub enum ModuleFromPathError {
        /// Variant representing an illegal interior nul value.
        Nul(source: widestring::NulError<u16>) {
            from()
            display("Invalid nul value in argument: {}", source)
            source(source)
        }
        /// Variant representing an windows api error.
        Win32(source: rust_win32error::Win32Error) {
            from()
            display("Windows API call failed: {}", source)
            source(source)
        }
        /// Variant representing a general io error.
        Io(source: io::Error) {
            from()
            display("Io error: {}", source)
            source(source)
        }
    }
}

impl From<Win32OrNulError> for ModuleFromPathError {
    fn from(err: Win32OrNulError) -> Self {
        match err {
            Win32OrNulError::Nul(e) => ModuleFromPathError::Nul(e),
            Win32OrNulError::Win32(e) => ModuleFromPathError::Win32(e),
        }
    }
}

quick_error! {
    /// Error enum for errors during injection and ejection.
    #[derive(Debug)]
    pub enum InjectError {
        /// Variant representing an illegal interior nul value.
        Nul(source: widestring::NulError<u16>) {
            from()
            display("Invalid nul value in argument: {}", source)
            source(source)
        }
        /// Variant representing an windows api error.
        Win32(source: rust_win32error::Win32Error) {
            from()
            display("Windows API call failed: {}", source)
            source(source)
        }
        /// Variant representing an unsupported target process.
        UnsupportedTarget {
            display("The requested operation is not supported for the target process.")
        }
        /// Variant representing a failed operation inside the target process.
        RemoteOperationFailed {
            display("An operation failed inside the remote process.")
        }
        /// Variant representing a general io error.
        Io(source: io::Error) {
            from()
            display("Io error: {}", source)
            source(source)
        }
        #[cfg(target_arch = "x86_64")]
        #[cfg(feature = "into_x86_from_x64")]
        /// Variant representing an error while loading an pe file.
        Goblin(source: goblin::error::Error) {
            display("Failed to load pe file: {}", source)
            source(source)
        }
    }
}

// This cannot be done with from() like for the other error types as goblin is only present
// on x64 with the into_x86_from_x64 feature and quick_error includes the From impl
// unconditionally
#[cfg(target_arch = "x86_64")]
#[cfg(feature = "into_x86_from_x64")]
impl From<goblin::error::Error> for InjectError {
    fn from(source: goblin::error::Error) -> Self {
        InjectError::Goblin(source)
    }
}

impl From<Win32OrNulError> for InjectError {
    fn from(err: Win32OrNulError) -> Self {
        match err {
            Win32OrNulError::Nul(e) => InjectError::Nul(e),
            Win32OrNulError::Win32(e) => InjectError::Win32(e),
        }
    }
}

impl From<ModuleFromPathError> for InjectError {
    fn from(err: ModuleFromPathError) -> Self {
        match err {
            ModuleFromPathError::Nul(e) => InjectError::Nul(e),
            ModuleFromPathError::Win32(e) => InjectError::Win32(e),
            ModuleFromPathError::Io(e) => InjectError::Io(e),
        }
    }
}