libmwemu 0.25.1

x86 32/64bits and system internals emulator, for securely emulating malware and other stuff.
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

use crate::{eflags::Eflags, emu::Emu, flags::Flags, threading::context::ArchThreadState};

impl Emu {
    pub fn pre_op_flags(&self) -> &Flags {
        match &self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { pre_op_flags, .. } => pre_op_flags,
            _ => panic!("pre_op_flags called on aarch64 emu"),
        }
    }

    pub fn pre_op_flags_mut(&mut self) -> &mut Flags {
        match &mut self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { pre_op_flags, .. } => pre_op_flags,
            _ => panic!("pre_op_flags_mut called on aarch64 emu"),
        }
    }

    pub fn post_op_flags(&self) -> &Flags {
        match &self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { post_op_flags, .. } => post_op_flags,
            _ => panic!("post_op_flags called on aarch64 emu"),
        }
    }

    pub fn post_op_flags_mut(&mut self) -> &mut Flags {
        match &mut self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { post_op_flags, .. } => post_op_flags,
            _ => panic!("post_op_flags_mut called on aarch64 emu"),
        }
    }

    pub fn eflags(&self) -> &Eflags {
        match &self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { eflags, .. } => eflags,
            _ => panic!("eflags called on aarch64 emu"),
        }
    }

    pub fn eflags_mut(&mut self) -> &mut Eflags {
        match &mut self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { eflags, .. } => eflags,
            _ => panic!("eflags_mut called on aarch64 emu"),
        }
    }

    pub fn set_pre_op_flags(&mut self, new_flags: Flags) {
        match &mut self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { pre_op_flags, .. } => *pre_op_flags = new_flags,
            _ => panic!("set_pre_op_flags called on aarch64 emu"),
        }
    }

    pub fn set_post_op_flags(&mut self, new_flags: Flags) {
        match &mut self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { post_op_flags, .. } => *post_op_flags = new_flags,
            _ => panic!("set_post_op_flags called on aarch64 emu"),
        }
    }

    #[inline(always)]
    pub fn flags(&mut self) -> &Flags {
        match &mut self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { flags, .. } => {
                flags.materialize_lazy();
                flags
            }
            _ => panic!("flags() called on aarch64 emu"),
        }
    }

    #[inline(always)]
    pub fn flags_ref(&self) -> &Flags {
        match &self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { flags, .. } => flags,
            _ => panic!("flags() called on aarch64 emu"),
        }
    }

    #[inline(always)]
    pub fn flags_snapshot(&self) -> Flags {
        let mut flags = *self.flags_ref();
        flags.materialize_lazy();
        flags
    }

    #[inline(always)]
    pub fn flags_mut(&mut self) -> &mut Flags {
        match &mut self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { flags, .. } => {
                flags.materialize_lazy();
                flags
            }
            _ => panic!("flags_mut() called on aarch64 emu"),
        }
    }

    #[inline(always)]
    pub fn flags_overwrite_mut(&mut self) -> &mut Flags {
        match &mut self.threads[self.current_thread_id].arch {
            ArchThreadState::X86 { flags, .. } => flags,
            _ => panic!("flags_overwrite_mut() called on aarch64 emu"),
        }
    }

    #[inline(always)]
    pub fn flag_cf(&self) -> bool {
        self.flags_ref().cf()
    }

    #[inline(always)]
    pub fn flag_zf(&self) -> bool {
        self.flags_ref().zf()
    }

    #[inline(always)]
    pub fn flag_sf(&self) -> bool {
        self.flags_ref().sf()
    }

    #[inline(always)]
    pub fn flag_of(&self) -> bool {
        self.flags_ref().of()
    }

    #[inline(always)]
    pub fn flag_df(&self) -> bool {
        self.flags_ref().f_df
    }

    #[inline(always)]
    pub fn flag_pf(&self) -> bool {
        self.flags_ref().pf()
    }

    #[inline(always)]
    pub fn flag_af(&self) -> bool {
        self.flags_ref().af()
    }
}