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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
#-*- coding:utf-8 -*-
import warnings
class Machine(object):
"""Abstract machine architecture to restrict architecture dependent code"""
__dis_engine = None # Disassembly engine
__mn = None # Machine instance
__lifter_model_call = None # IR analyser
__jitter = None # Jit engine
__gdbserver = None # GdbServer handler
__available = ["arml", "armb", "armtl", "armtb", "sh4", "x86_16", "x86_32",
"x86_64", "msp430", "mips32b", "mips32l",
"aarch64l", "aarch64b", "ppc32b", "mepl", "mepb"]
def __init__(self, machine_name):
dis_engine = None
mn = None
lifter_model_call = None
ir = None
jitter = None
gdbserver = None
jit = None
log_jit = None
log_arch = None
# Import on runtime for performance issue
if machine_name == "arml":
from miasm.arch.arm.disasm import dis_arml as dis_engine
from miasm.arch.arm import arch
try:
from miasm.arch.arm import jit
jitter = jit.jitter_arml
except ImportError:
pass
mn = arch.mn_arm
from miasm.arch.arm.lifter_model_call import LifterModelCallArml as lifter_model_call
from miasm.arch.arm.sem import Lifter_Arml as lifter
elif machine_name == "armb":
from miasm.arch.arm.disasm import dis_armb as dis_engine
from miasm.arch.arm import arch
try:
from miasm.arch.arm import jit
jitter = jit.jitter_armb
except ImportError:
pass
mn = arch.mn_arm
from miasm.arch.arm.lifter_model_call import LifterModelCallArmb as lifter_model_call
from miasm.arch.arm.sem import Lifter_Armb as lifter
elif machine_name == "aarch64l":
from miasm.arch.aarch64.disasm import dis_aarch64l as dis_engine
from miasm.arch.aarch64 import arch
try:
from miasm.arch.aarch64 import jit
jitter = jit.jitter_aarch64l
except ImportError:
pass
mn = arch.mn_aarch64
from miasm.arch.aarch64.lifter_model_call import LifterModelCallAarch64l as lifter_model_call
from miasm.arch.aarch64.sem import Lifter_Aarch64l as lifter
elif machine_name == "aarch64b":
from miasm.arch.aarch64.disasm import dis_aarch64b as dis_engine
from miasm.arch.aarch64 import arch
try:
from miasm.arch.aarch64 import jit
jitter = jit.jitter_aarch64b
except ImportError:
pass
mn = arch.mn_aarch64
from miasm.arch.aarch64.lifter_model_call import LifterModelCallAarch64b as lifter_model_call
from miasm.arch.aarch64.sem import Lifter_Aarch64b as lifter
elif machine_name == "armtl":
from miasm.arch.arm.disasm import dis_armtl as dis_engine
from miasm.arch.arm import arch
mn = arch.mn_armt
from miasm.arch.arm.lifter_model_call import LifterModelCallArmtl as lifter_model_call
from miasm.arch.arm.sem import Lifter_Armtl as lifter
try:
from miasm.arch.arm import jit
jitter = jit.jitter_armtl
except ImportError:
pass
elif machine_name == "armtb":
from miasm.arch.arm.disasm import dis_armtb as dis_engine
from miasm.arch.arm import arch
mn = arch.mn_armt
from miasm.arch.arm.lifter_model_call import LifterModelCallArmtb as lifter_model_call
from miasm.arch.arm.sem import Lifter_Armtb as lifter
elif machine_name == "sh4":
from miasm.arch.sh4 import arch
mn = arch.mn_sh4
elif machine_name == "x86_16":
from miasm.arch.x86.disasm import dis_x86_16 as dis_engine
from miasm.arch.x86 import arch
try:
from miasm.arch.x86 import jit
jitter = jit.jitter_x86_16
except ImportError:
pass
mn = arch.mn_x86
from miasm.arch.x86.lifter_model_call import LifterModelCall_x86_16 as lifter_model_call
from miasm.arch.x86.sem import Lifter_X86_16 as lifter
elif machine_name == "x86_32":
from miasm.arch.x86.disasm import dis_x86_32 as dis_engine
from miasm.arch.x86 import arch
try:
from miasm.arch.x86 import jit
jitter = jit.jitter_x86_32
except ImportError:
pass
mn = arch.mn_x86
from miasm.arch.x86.lifter_model_call import LifterModelCall_x86_32 as lifter_model_call
from miasm.arch.x86.sem import Lifter_X86_32 as lifter
try:
from miasm.analysis.gdbserver import GdbServer_x86_32 as gdbserver
except ImportError:
pass
elif machine_name == "x86_64":
from miasm.arch.x86.disasm import dis_x86_64 as dis_engine
from miasm.arch.x86 import arch
try:
from miasm.arch.x86 import jit
jitter = jit.jitter_x86_64
except ImportError:
pass
mn = arch.mn_x86
from miasm.arch.x86.lifter_model_call import LifterModelCall_x86_64 as lifter_model_call
from miasm.arch.x86.sem import Lifter_X86_64 as lifter
elif machine_name == "msp430":
from miasm.arch.msp430.disasm import dis_msp430 as dis_engine
from miasm.arch.msp430 import arch
try:
from miasm.arch.msp430 import jit
jitter = jit.jitter_msp430
except ImportError:
pass
mn = arch.mn_msp430
from miasm.arch.msp430.lifter_model_call import LifterModelCallMsp430 as lifter_model_call
from miasm.arch.msp430.sem import Lifter_MSP430 as lifter
try:
from miasm.analysis.gdbserver import GdbServer_msp430 as gdbserver
except ImportError:
pass
elif machine_name == "mips32b":
from miasm.arch.mips32.disasm import dis_mips32b as dis_engine
from miasm.arch.mips32 import arch
try:
from miasm.arch.mips32 import jit
jitter = jit.jitter_mips32b
except ImportError:
pass
mn = arch.mn_mips32
from miasm.arch.mips32.lifter_model_call import LifterModelCallMips32b as lifter_model_call
from miasm.arch.mips32.sem import Lifter_Mips32b as lifter
elif machine_name == "mips32l":
from miasm.arch.mips32.disasm import dis_mips32l as dis_engine
from miasm.arch.mips32 import arch
try:
from miasm.arch.mips32 import jit
jitter = jit.jitter_mips32l
except ImportError:
pass
mn = arch.mn_mips32
from miasm.arch.mips32.lifter_model_call import LifterModelCallMips32l as lifter_model_call
from miasm.arch.mips32.sem import Lifter_Mips32l as lifter
elif machine_name == "ppc32b":
from miasm.arch.ppc.disasm import dis_ppc32b as dis_engine
from miasm.arch.ppc import arch
try:
from miasm.arch.ppc import jit
jitter = jit.jitter_ppc32b
except ImportError:
pass
mn = arch.mn_ppc
from miasm.arch.ppc.lifter_model_call import LifterModelCallPpc32b as lifter_model_call
from miasm.arch.ppc.sem import Lifter_PPC32b as lifter
elif machine_name == "mepb":
from miasm.arch.mep.disasm import dis_mepb as dis_engine
from miasm.arch.mep import arch
try:
from miasm.arch.mep import jit
jitter = jit.jitter_mepb
except ImportError:
pass
mn = arch.mn_mep
from miasm.arch.mep.lifter_model_call import LifterModelCallMepb as lifter_model_call
from miasm.arch.mep.sem import Lifter_MEPb as lifter
elif machine_name == "mepl":
from miasm.arch.mep.disasm import dis_mepl as dis_engine
from miasm.arch.mep import arch
try:
from miasm.arch.mep import jit
jitter = jit.jitter_mepl
except ImportError:
pass
mn = arch.mn_mep
from miasm.arch.mep.lifter_model_call import LifterModelCallMepl as lifter_model_call
from miasm.arch.mep.sem import Lifter_MEPl as lifter
else:
raise ValueError('Unknown machine: %s' % machine_name)
# Loggers
if jit is not None:
log_jit = jit.log
log_arch = arch.log
self.__dis_engine = dis_engine
self.__mn = mn
self.__lifter_model_call = lifter_model_call
self.__jitter = jitter
self.__gdbserver = gdbserver
self.__log_jit = log_jit
self.__log_arch = log_arch
self.__base_expr = arch.base_expr
self.__lifter = lifter
self.__name = machine_name
@property
def dis_engine(self):
return self.__dis_engine
@property
def mn(self):
return self.__mn
@property
def lifter(self):
return self.__lifter
@property
def lifter_model_call(self):
return self.__lifter_model_call
@property
def ir(self):
return self.__ir
@property
def jitter(self):
return self.__jitter
@property
def gdbserver(self):
return self.__gdbserver
@property
def log_jit(self):
return self.__log_jit
@property
def log_arch(self):
return self.__log_arch
@property
def base_expr(self):
return self.__base_expr
@property
def name(self):
return self.__name
@classmethod
def available_machine(cls):
"Return a list of supported machines"
return cls.__available
@property
def ira(self):
warnings.warn('DEPRECATION WARNING: use ".lifter_model_call" instead of ".ira"')
return self.lifter_model_call
@property
def ir(self):
warnings.warn('DEPRECATION WARNING: use ".lifter" instead of ".ir"')
return self.lifter
|