Debian Codegraph @

ptrace/debugger/ptrace_signal.py

raw
1 from logging import error
2 from ptrace.disasm import HAS_DISASSEMBLER
3 from signal import SIGFPE, SIGSEGV, SIGABRT
4 try:
5 from signal import SIGCHLD
6 except ImportError:
7 SIGCHLD = None
8 try:
9 from signal import SIGBUS
10 except ImportError:
11 SIGBUS = None
12 from ptrace.os_tools import RUNNING_LINUX
13 from ptrace.cpu_info import CPU_64BITS
14 from ptrace.debugger import ProcessEvent
15 from ptrace.error import PtraceError
16 from ptrace import signalName
17 from ptrace.debugger.signal_reason import (
18 DivisionByZero, Abort, StackOverflow,
19 InvalidMemoryAccess, InvalidRead, InvalidWrite,
20 InstructionError, ChildExit)
21 from ptrace.debugger.parse_expr import parseExpression
22 import re
23
24 # Match a pointer dereference (e.g. "DWORD [EDX+0x8]")
25 DEREF_REGEX = r'(?P<deref_size>(BYTE|WORD|DWORD|DQWORD) )?\[(?P<deref>[^]]+)\]'
26
27 NAMED_WORD_SIZE = {
28 'BYTE': 1,
29 'WORD': 2,
30 'DWORD': 4,
31 'DQWORD': 8,
32 }
33
34 # Match any Intel instruction (e.g. "ADD")
35 INSTR_REGEX = '(?:[A-Z]{3,10})'
36
37
38 def findDerefSize(match):
39 name = match.group("deref_size")
40 try:
41 return NAMED_WORD_SIZE[name]
42 except KeyError:
43 return None
44
45
46 def evalFaultAddress(process, match):
47 expr = match.group('deref')
48 if not expr:
49 return None
50 try:
51 return parseExpression(process, expr)
52 except ValueError as err:
53 error("err: %s" % err)
54 return None
55
56
57 class ProcessSignal(ProcessEvent):
58
59 def __init__(self, signum, process):
60 # Initialize attributes
61 self.name = signalName(signum)
62 ProcessEvent.__init__(self, process, "Signal %s" % self.name)
63 self.signum = signum
64 self.reason = None
65
66 def _analyze(self):
67 if self.signum in (SIGSEGV, SIGBUS):
68 self.memoryFault()
69 elif self.signum == SIGFPE:
70 self.mathError()
71 elif self.signum == SIGCHLD:
72 self.childExit()
73 elif self.signum == SIGABRT:
74 self.reason = Abort()
75 return self.reason
76
77 def getInstruction(self):
78 if not HAS_DISASSEMBLER:
79 return None
80 try:
81 return self.process.disassembleOne()
82 except PtraceError:
83 return None
84
85 def memoryFaultInstr(self, instr, fault_address):
86 asm = instr.text
87
88 # Invalid write (e.g. "MOV [...], value")
89 match = re.search(r"^(?:MOV|TEST)[A-Z]* %s," % DEREF_REGEX, asm)
90 if match:
91 if fault_address is None:
92 fault_address = evalFaultAddress(self.process, match)
93 self.reason = InvalidWrite(fault_address, size=findDerefSize(match),
94 instr=instr, process=self.process)
95 return
96
97 # Invalid read (e.g. "CMP BYTE [EAX+EDX-0x1], 0x0")
98 match = re.search(r"^%s %s," % (INSTR_REGEX, DEREF_REGEX), asm)
99 if match:
100 if fault_address is None:
101 fault_address = evalFaultAddress(self.process, match)
102 self.reason = InvalidRead(fault_address, size=findDerefSize(match),
103 instr=instr, process=self.process)
104 return
105
106 # Invalid read (e.g. "MOV reg, [...]")
107 match = re.match(r"%s [^,]+, %s" % (INSTR_REGEX, DEREF_REGEX), asm)
108 if match:
109 if fault_address is None:
110 fault_address = evalFaultAddress(self.process, match)
111 self.reason = InvalidRead(fault_address, size=findDerefSize(match),
112 instr=instr, process=self.process)
113 return
114
115 # MOVS* and SCAS* instructions (e.g. "MOVSB" or "REP SCASD")
116 match = re.search(
117 r"^(?:REP(?:NZ)? )?(?P<operator>MOVS|SCAS)(?P<suffix>[BWD])?", asm)
118 if match:
119 self.reason = self.movsInstr(fault_address, instr, match)
120 return
121
122 def movsInstr(self, fault_address, instr, match):
123 operator = match.group("operator")
124 suffix = match.group("suffix")
125 size = {'B': 1, 'W': 2, 'D': 4}.get(suffix)
126 error_cls = InvalidMemoryAccess
127 try:
128 process = self.process
129 if CPU_64BITS:
130 source_reg = 'rsi'
131 dest_reg = 'rdi'
132 else:
133 source_reg = 'esi'
134 dest_reg = 'edi'
135 source_addr = process.getreg(source_reg)
136 registers = {source_reg: source_addr}
137 write = (operator == 'MOVS')
138 if write:
139 dest_addr = process.getreg(dest_reg)
140 registers[dest_reg] = dest_addr
141
142 if fault_address is not None:
143 if fault_address == source_addr:
144 error_cls = InvalidRead
145 if write and fault_address == dest_addr:
146 error_cls = InvalidWrite
147 else:
148 if write:
149 fault_address = (source_addr, dest_addr)
150 else:
151 fault_address = (source_addr,)
152 except PtraceError:
153 registers = {}
154 return error_cls(fault_address, size=size, instr=instr,
155 registers=registers, process=self.process)
156
157 def getSignalInfo(self):
158 if RUNNING_LINUX:
159 return self.process.getsiginfo()
160 else:
161 return None
162
163 def memoryFault(self):
164 # Get fault
165 siginfo = self.getSignalInfo()
166 if siginfo:
167 fault_address = siginfo._sigfault._addr
168 if not fault_address:
169 fault_address = 0
170 else:
171 fault_address = None
172
173 # Get current instruction
174 instr = self.getInstruction()
175
176 # Call to invalid address?
177 if fault_address is not None:
178 try:
179 ip = self.process.getInstrPointer()
180 if ip == fault_address:
181 self.reason = InstructionError(ip, process=self.process)
182 return
183 except PtraceError:
184 pass
185
186 # Stack overflow?
187 stack = self.process.findStack()
188 if stack:
189 sp = self.process.getStackPointer()
190 if not (stack.start <= sp <= stack.end):
191 self.reason = StackOverflow(
192 sp, stack, instr=instr, process=self.process)
193 return
194
195 # Guess error type using the assembler instruction
196 if instr:
197 self.memoryFaultInstr(instr, fault_address)
198 if self.reason:
199 return
200
201 # Last chance: use generic invalid memory access error
202 self.reason = InvalidMemoryAccess(
203 fault_address, instr=instr, process=self.process)
204
205 def mathError(self):
206 instr = self.getInstruction()
207 if not instr:
208 return
209 match = re.match(r"I?DIV (.*)", instr.text)
210 if not match:
211 return
212 self.reason = DivisionByZero(instr=instr, process=self.process)
213
214 def childExit(self):
215 siginfo = self.getSignalInfo()
216 if siginfo:
217 child = siginfo._sigchld
218 self.reason = ChildExit(child.pid, child.status, child.uid)
219 else:
220 self.reason = ChildExit()
221
222 def display(self, log=None):
223 self._analyze()
224 if not log:
225 log = error
226 log("-" * 60)
227 log("PID: %s" % self.process.pid)
228 log("Signal: %s" % self.name)
229 if self.reason:
230 self.reason.display(log)
231 log("-" * 60)