| 1 |
from os import strerror |
| 2 |
from errno import errorcode |
| 3 |
|
| 4 |
from ptrace.cpu_info import CPU_X86_64, CPU_POWERPC, CPU_I386, CPU_ARM32, CPU_AARCH64, CPU_RISCV |
| 5 |
from ptrace.ctypes_tools import ulong2long, formatAddress, formatWordHex |
| 6 |
from ptrace.func_call import FunctionCall |
| 7 |
from ptrace.syscall import SYSCALL_NAMES, SYSCALL_PROTOTYPES, SyscallArgument |
| 8 |
from ptrace.syscall.socketcall import setupSocketCall |
| 9 |
from ptrace.os_tools import RUNNING_LINUX, RUNNING_BSD |
| 10 |
from ptrace.cpu_info import CPU_WORD_SIZE |
| 11 |
from ptrace.binding.cpu import CPU_INSTR_POINTER |
| 12 |
|
| 13 |
if CPU_POWERPC: |
| 14 |
SYSCALL_REGISTER = "gpr0" |
| 15 |
elif CPU_ARM32: |
| 16 |
SYSCALL_REGISTER = "r7" |
| 17 |
elif CPU_AARCH64: |
| 18 |
SYSCALL_REGISTER = "r8" |
| 19 |
elif CPU_RISCV: |
| 20 |
SYSCALL_REGISTER = "a7" |
| 21 |
elif RUNNING_LINUX: |
| 22 |
if CPU_X86_64: |
| 23 |
SYSCALL_REGISTER = "orig_rax" |
| 24 |
else: |
| 25 |
SYSCALL_REGISTER = "orig_eax" |
| 26 |
else: |
| 27 |
if CPU_X86_64: |
| 28 |
SYSCALL_REGISTER = "rax" |
| 29 |
else: |
| 30 |
SYSCALL_REGISTER = "eax" |
| 31 |
|
| 32 |
if CPU_ARM32: |
| 33 |
RETURN_VALUE_REGISTER = "r0" |
| 34 |
elif CPU_AARCH64: |
| 35 |
RETURN_VALUE_REGISTER = "r0" |
| 36 |
elif CPU_I386: |
| 37 |
RETURN_VALUE_REGISTER = "eax" |
| 38 |
elif CPU_X86_64: |
| 39 |
RETURN_VALUE_REGISTER = "rax" |
| 40 |
elif CPU_POWERPC: |
| 41 |
RETURN_VALUE_REGISTER = "result" |
| 42 |
elif CPU_RISCV: |
| 43 |
RETURN_VALUE_REGISTER = "a0" |
| 44 |
else: |
| 45 |
raise NotImplementedError("Unsupported CPU architecture") |
| 46 |
|
| 47 |
PREFORMAT_ARGUMENTS = { |
| 48 |
"select": (1, 2, 3), |
| 49 |
"execve": (0, 1, 2), |
| 50 |
"clone": (0, 1), |
| 51 |
} |
| 52 |
|
| 53 |
|
| 54 |
class PtraceSyscall(FunctionCall): |
| 55 |
|
| 56 |
def __init__(self, process, options, regs=None): |
| 57 |
FunctionCall.__init__(self, "syscall", options, SyscallArgument) |
| 58 |
self.process = process |
| 59 |
self.restype = "long" |
| 60 |
self.result = None |
| 61 |
self.result_text = None |
| 62 |
self.instr_pointer = None |
| 63 |
if not regs: |
| 64 |
regs = self.process.getregs() |
| 65 |
self.readSyscall(regs) |
| 66 |
|
| 67 |
def enter(self, regs=None): |
| 68 |
if not regs: |
| 69 |
regs = self.process.getregs() |
| 70 |
argument_values = self.readArgumentValues(regs) |
| 71 |
self.readArguments(argument_values) |
| 72 |
|
| 73 |
if self.name == "socketcall" and self.options.replace_socketcall: |
| 74 |
setupSocketCall(self, self.process, self[0], self[1].value) |
| 75 |
|
| 76 |
# Some arguments are lost after the syscall, so format them now |
| 77 |
if self.name in PREFORMAT_ARGUMENTS: |
| 78 |
for index in PREFORMAT_ARGUMENTS[self.name]: |
| 79 |
argument = self.arguments[index] |
| 80 |
argument.format() |
| 81 |
|
| 82 |
if self.options.instr_pointer: |
| 83 |
self.instr_pointer = getattr(regs, CPU_INSTR_POINTER) |
| 84 |
|
| 85 |
def readSyscall(self, regs): |
| 86 |
# Read syscall number |
| 87 |
self.syscall = getattr(regs, SYSCALL_REGISTER) |
| 88 |
# Get syscall variables |
| 89 |
self.name = SYSCALL_NAMES.get( |
| 90 |
self.syscall, "syscall<%s>" % self.syscall) |
| 91 |
|
| 92 |
def readArgumentValues(self, regs): |
| 93 |
if CPU_X86_64: |
| 94 |
return (regs.rdi, regs.rsi, regs.rdx, regs.r10, regs.r8, regs.r9) |
| 95 |
if CPU_ARM32: |
| 96 |
return (regs.r0, regs.r1, regs.r2, regs.r3, regs.r4, regs.r5, regs.r6) |
| 97 |
if CPU_AARCH64: |
| 98 |
return (regs.r0, regs.r1, regs.r2, regs.r3, regs.r4, regs.r5, regs.r6, regs.r7) |
| 99 |
if CPU_RISCV: |
| 100 |
return (regs.a0, regs.a1, regs.a2, regs.a3, regs.a4, regs.a5, regs.a6) |
| 101 |
if RUNNING_BSD: |
| 102 |
sp = self.process.getStackPointer() |
| 103 |
return [self.process.readWord(sp + index * CPU_WORD_SIZE) |
| 104 |
for index in range(1, 6 + 1)] |
| 105 |
if CPU_I386: |
| 106 |
return (regs.ebx, regs.ecx, regs.edx, regs.esi, regs.edi, regs.ebp) |
| 107 |
if CPU_POWERPC: |
| 108 |
return (regs.gpr3, regs.gpr4, regs.gpr5, regs.gpr6, regs.gpr7, regs.gpr8) |
| 109 |
raise NotImplementedError() |
| 110 |
|
| 111 |
def readArguments(self, argument_values): |
| 112 |
if self.name in SYSCALL_PROTOTYPES: |
| 113 |
self.restype, formats = SYSCALL_PROTOTYPES[self.name] |
| 114 |
for value, format in zip(argument_values, formats): |
| 115 |
argtype, argname = format |
| 116 |
self.addArgument(value=value, name=argname, type=argtype) |
| 117 |
else: |
| 118 |
for value in argument_values: |
| 119 |
self.addArgument(value=value) |
| 120 |
|
| 121 |
def exit(self): |
| 122 |
if self.name in PREFORMAT_ARGUMENTS: |
| 123 |
preformat = set(PREFORMAT_ARGUMENTS[self.name]) |
| 124 |
else: |
| 125 |
preformat = set() |
| 126 |
|
| 127 |
# Data pointed by arguments may have changed during the syscall |
| 128 |
# e.g. uname() syscall |
| 129 |
for index, argument in enumerate(self.arguments): |
| 130 |
if index in preformat: |
| 131 |
# Don't lose preformatted arguments |
| 132 |
continue |
| 133 |
if argument.type and not argument.type.endswith("*"): |
| 134 |
continue |
| 135 |
argument.text = None |
| 136 |
|
| 137 |
self.result = self.process.getreg(RETURN_VALUE_REGISTER) |
| 138 |
|
| 139 |
if self.restype.endswith("*"): |
| 140 |
text = formatAddress(self.result) |
| 141 |
else: |
| 142 |
uresult = self.result |
| 143 |
self.result = ulong2long(self.result) |
| 144 |
if self.result < 0 and (-self.result) in errorcode: |
| 145 |
errcode = -self.result |
| 146 |
text = "%s %s (%s)" % ( |
| 147 |
self.result, errorcode[errcode], strerror(errcode)) |
| 148 |
elif not (0 <= self.result <= 9): |
| 149 |
text = "%s (%s)" % (self.result, formatWordHex(uresult)) |
| 150 |
else: |
| 151 |
text = str(self.result) |
| 152 |
self.result_text = text |
| 153 |
return text |
| 154 |
|
| 155 |
def __str__(self): |
| 156 |
return "<Syscall name=%r>" % self.name |