lots of WIP stuff

pull/11/head
Zach Riggle 11 years ago
parent 3e57bc3445
commit 994afa9aef

60
.gitignore vendored

@ -0,0 +1,60 @@
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
# C extensions
*.so
# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
*.egg-info/
.installed.cfg
*.egg
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*,cover
# Translations
*.mo
*.pot
# Django stuff:
*.log
# Sphinx documentation
docs/_build/
# PyBuilder
target/
npm-debug.log
.gdb_history

@ -20,11 +20,11 @@ Pretty easy.
Does most things that PEDA does. Doesn't do things that PEDA does that [pwntools](https://github.com/Gallopsled/pwntools) or [binjitsu](https://binjit.su) (my fork of pwntools) do better.
Also has a basic windbg compat layer for e.g. `dd`, `eb`, `da`, `dps`. Note that `gdb` doesn't circumvent page permissions like windbg does, so e.g. `eb eip 90`, much to [my](https://twitter.com/ebeip90) chargrin.
Also has a basic windbg compat layer for e.g. `dd`, `eb`, `da`, `dps`. Now you can even [`eb eip 90`](https://twitter.com/ebeip90)!
## Screenshots
Here's a screenshot of `pwndbg` working on an aarch64 binary running under `qemu-user`.
Here's a screenshot of `pwndbg` working on an aarch64 binary running under `qemu-user`.
![a](caps/a.png?raw=1)

@ -1,5 +1,6 @@
import gdb
import pwndbg.arch
import pwndbg.arguments
import pwndbg.vmmap
import pwndbg.dt
import pwndbg.memory
@ -10,7 +11,6 @@ import pwndbg.regs
import pwndbg.stack
import pwndbg.stdio
import pwndbg.color
import pwndbg.function
import pwndbg.typeinfo
import pwndbg.commands
import pwndbg.commands.hexdump
@ -95,11 +95,5 @@ for line in pre_commands.splitlines():
if line:
gdb.execute(line)
@pwndbg.memoize.reset_on_stop
def prompt_hook(*a):
pwndbg.commands.context.context()
gdb.prompt_hook = prompt_hook
msg = "Loaded %i commands. Type pwndbg for a list." % len(pwndbg.commands.Command.commands)
msg = "Loaded %i commands. Type pwndbg for a list." % len(pwndbg.commands._Command.commands)
print(pwndbg.color.red(msg))

@ -13,11 +13,15 @@ ptrsize = pwndbg.typeinfo.ptrsize
fmt = '=i'
disasm = lambda: None
def fix_arch(arch):
arches = ['x86-64', 'i386', 'mips', 'powerpc', 'sparc', 'arm', 'aarch64', arch]
return next(a for a in arches if a in arch)
@pwndbg.events.stop
def update():
m = sys.modules[__name__]
m.current = gdb.selected_frame().architecture().name()
m.current = fix_arch(gdb.selected_frame().architecture().name())
m.ptrsize = pwndbg.typeinfo.ptrsize
m.ptrmask = (1 << 8*pwndbg.typeinfo.ptrsize)-1

@ -6,10 +6,12 @@ may be passed in a combination of registers and stack values.
"""
import gdb
import pwndbg.arch
import pwndbg.disasm
import pwndbg.memory
import pwndbg.regs
import pwndbg.typeinfo
import pwndbg.functions
import pwndbg.symbol
def arguments():
"""
@ -18,6 +20,7 @@ def arguments():
Otherwise, returns None.
"""
pwndbg.disasm.calls
def argument(n):
"""
@ -25,12 +28,15 @@ def argument(n):
instruction.
"""
arch = pwndbg.arch.current
regs = []
if 'x86-64' in arch:
regs = ['rdi','rsi','rdx','rcx','r8','r9']
elif 'arm' == arch:
regs = ['r0','r1','r2','r3']
regs = {
'x86-64': ['rdi','rsi','rdx','rcx','r8','r9'],
'arm': ['r%i' % i for i in range(0, 4)],
'aarch64': ['x%i' % i for i in range(0, 4)],
'powerpc': ['r%i' % i for i in range(3, 10+1)],
'mips': ['r%i' % i for i in range(4, 7+1)],
'sparc': ['i%i' % i for i in range(0,8)],
}[arch]
if n < len(regs):
return getattr(pwndbg.regs, regs[n])
@ -40,3 +46,4 @@ def argument(n):
sp = pwndbg.regs.sp + (n * pwndbg.arch.ptrsize)
return int(pwndbg.memory.poi(pwndbg.typeinfo.ppvoid, sp))

@ -26,6 +26,7 @@ def blue(x): return BLUE + x + NORMAL
def gray(x): return GRAY + x + NORMAL
def green(x): return GREEN + x + NORMAL
def yellow(x): return YELLOW + x + NORMAL
def underline(x): return UNDERLINE + x + NORMAL
def get(address, text = None):
"""

@ -10,7 +10,6 @@ import pwndbg.chain
import pwndbg.enhance
import pwndbg.symbol
import pwndbg.ui
import pwndbg.proc
__all__ = [
'asm',
@ -33,16 +32,18 @@ __all__ = [
debug = True
class Command(gdb.Command):
class _Command(gdb.Command):
"""Generic command wrapper"""
count = 0
commands = []
def __init__(self, function):
super(Command, self).__init__(function.__name__, gdb.COMMAND_USER, gdb.COMPLETE_EXPRESSION)
super(_Command, self).__init__(function.__name__, gdb.COMMAND_USER, gdb.COMPLETE_EXPRESSION)
self.function = function
Command.commands.append(self)
self.commands.append(self)
functools.update_wrapper(self, function)
self.__doc__ = function.__doc__
def split_args(self, argument):
return gdb.string_to_argv(argument)
@ -60,9 +61,9 @@ class Command(gdb.Command):
return self.function(*args, **kwargs)
class ParsedCommand(Command):
class _ParsedCommand(_Command):
def split_args(self, argument):
argv = super(ParsedCommand,self).split_args(argument)
argv = super(_ParsedCommand,self).split_args(argument)
return list(filter(lambda x: x is not None, map(fix, argv)))
def fix(arg, sloppy=False):
@ -74,7 +75,8 @@ def fix(arg, sloppy=False):
try:
arg = pwndbg.regs.fix(arg)
return gdb.parse_and_eval(arg)
except Exception:
except Exception as e:
print(e)
pass
if sloppy:
@ -82,13 +84,23 @@ def fix(arg, sloppy=False):
return None
OnlyWhenRunning = pwndbg.proc.OnlyWhenRunning
@Command
def pwndbg():
"""
Prints out a list of all pwndbg commands.
"""
names = [C.function.__name__ for C in Command.commands]
for name in sorted(names):
print(name)
def OnlyWhenRunning(function):
@functools.wraps(function)
def _OnlyWhenRunning(*a, **kw):
if pwndbg.proc.alive:
return function(*a, **kw)
else:
print("Only available when running")
return _OnlyWhenRunning
def Command(func):
class C(_Command):
__doc__ = func.__doc__
__name__ = func.__name__
return C(func)
def ParsedCommand(func):
class C(_ParsedCommand):
__doc__ = func.__doc__
__name__ = func.__name__
return C(func)

@ -12,7 +12,7 @@ import pwndbg.symbol
import pwndbg.ui
import pwndbg.vmmap
@pwndbg.events.stop
@pwndbg.commands.ParsedCommand
@pwndbg.commands.OnlyWhenRunning
def context(*args):
@ -31,25 +31,51 @@ def context(*args):
if 'c' in args: result.extend(context_code())
if 's' in args: result.extend(context_stack())
if 'b' in args: result.extend(context_backtrace())
if 'b' in args: result.extend(context_signal())
result.extend(context_signal())
print('\n'.join(map(str, result)))
def context_regs():
result = []
result.append(pwndbg.color.blue(pwndbg.ui.banner("registers")))
for reg in pwndbg.regs.gpr + (pwndbg.regs.frame, pwndbg.regs.stack, '$pc'):
result.extend(get_regs())
return result
@pwndbg.commands.Command
@pwndbg.commands.OnlyWhenRunning
def regs(*regs):
print('\n'.join(get_regs(*regs)))
def get_regs(*regs):
result = []
if not regs:
regs = pwndbg.regs.gpr + (pwndbg.regs.frame, pwndbg.regs.current.stack, pwndbg.regs.current.pc)
changed = pwndbg.regs.changed
for reg in regs:
if reg is None:
continue
if reg not in pwndbg.regs:
print("Unknown register: %r" % reg)
continue
value = pwndbg.regs[reg]
# Make the register stand out
regname = pwndbg.color.bold(reg.ljust(4).upper())
result.append("%s %s" % (regname, pwndbg.chain.format(value)))
# Show a dot next to the register if it changed
m = ' ' if reg not in changed else '*'
result.append("%s%s %s" % (m, regname, pwndbg.chain.format(value)))
return result
def context_code():
banner = [pwndbg.color.blue(pwndbg.ui.banner("code"))]
result = pwndbg.commands.nearpc.nearpc(to_string=True)
@ -114,7 +140,7 @@ def context_backtrace(frame_count=10, with_banner=True):
i += 1
return result
last_signal = None
last_signal = []
def save_signal(signal):
global last_signal

@ -1,16 +1,14 @@
import errno as _errno
import struct
import pwndbg.commands
import pwndbg.regs
import pwndbg as _pwndbg
_errno.errorcode[0] = 'OK'
@pwndbg.commands.ParsedCommand
@_pwndbg.commands.ParsedCommand
def errno(err=None):
if err is None:
err = pwndbg.regs.retval
err = pwndbg.regs[err]
err = _pwndbg.regs.retval
err = _pwndbg.regs[err]
err = abs(int(err))
@ -21,3 +19,19 @@ def errno(err=None):
msg = _errno.errorcode.get(int(err), "Unknown error code")
print("Errno %i: %s" % (err, msg))
@_pwndbg.commands.Command
def pwndbg():
"""
Prints out a list of all pwndbg commands.
"""
sorted_commands = list(_pwndbg.commands._Command.commands)
sorted_commands.sort(key=lambda x: x.__name__)
for c in sorted_commands:
name = c.__name__
docs = c.__doc__
if docs: docs = docs.strip()
if docs: docs = docs.splitlines()[0]
print("%-20s %s" % (name, docs))

@ -16,8 +16,8 @@ import pwndbg.typeinfo
@pwndbg.commands.OnlyWhenRunning
def telescope(address=None, count=8, to_string=False):
"""
Starting at the specified address, recursively dereference
N pointers (default 8).
Recursively dereferences pointers starting at the specified address
($sp by default)
"""
if None not in (address, count) and int(address) < int(count):
count -= address
@ -74,7 +74,6 @@ def telescope(address=None, count=8, to_string=False):
@pwndbg.commands.OnlyWhenRunning
def stack(*a):
"""
Starting at the specified address, recursively dereference
N pointers (default 8).
Recursively dereferences pointers on the stack
"""
telescope(*a)

@ -183,11 +183,11 @@ def dqs(*a):
@pwndbg.commands.ParsedCommand
@pwndbg.commands.OnlyWhenRunning
def da(address):
def da(address, max=256):
"""
Dump a string at the specified address.
"""
print("%x" % address, pwndbg.strings.get(address))
print("%x" % address, repr(pwndbg.strings.get(address, max)))
@pwndbg.commands.ParsedCommand
@pwndbg.commands.OnlyWhenRunning

@ -13,8 +13,44 @@ import pwndbg.disasm_powerpc
import pwndbg.ida
import pwndbg.memory
import pwndbg.symbol
Instruction = collections.namedtuple('Instruction', ['address', 'length', 'asm'])
import pwndbg.memoize
import pwndbg.jump
from capstone import *
Instruction = collections.namedtuple('Instruction', ['address', 'length', 'asm', 'target'])
disassembler = None
last_arch = None
CapstoneArch = {
'arm': Cs(CS_ARCH_ARM, CS_MODE_ARM),
'aarch64': Cs(CS_ARCH_ARM64, CS_MODE_ARM),
'i386': Cs(CS_ARCH_X86, CS_MODE_32),
'x86-64': Cs(CS_ARCH_X86, CS_MODE_64),
'powerpc': Cs(CS_ARCH_PPC, CS_MODE_32),
'mips': Cs(CS_ARCH_MIPS, CS_MODE_32),
'sparc': Cs(CS_ARCH_SPARC, 0),
}
InstructionMaxSize = {
'arm': 4,
'aarch64': 4,
'i386': 16,
'x86-64': 16
}
def get_disassembler(pc):
arch = pwndbg.arch.current
d = CapstoneArch[arch]
if arch in ('i386', 'x86-64', 'powerpc', 'mips'):
d.mode = {4:CS_MODE_32, 8:CS_MODE_64}[pwndbg.arch.ptrsize]
if arch in ('arm', 'aarch64'):
d.mode = {0:CS_MODE_ARM,1:CS_MODE_THUMB}[pc & 1]
return d
def get_one_instruction(pc):
pass
def get(address, instructions=1):
address = int(address)
@ -30,11 +66,10 @@ def get(address, instructions=1):
addr = int(insn['addr'])
length = insn['length']
asm = insn['asm']
target = 0
split = asm.split()
if len(split) == 2:
target = 0
try:
target = split[1]
name = pwndbg.symbol.get(int(target, 0))
@ -43,9 +78,7 @@ def get(address, instructions=1):
except ValueError:
pass
retval.append(Instruction(addr,length,asm))
retval.append(Instruction(addr,length,asm,target))
return retval
def near(address, instructions=1):
@ -94,7 +127,6 @@ calls = set([
returns = set([
'ret','retn','return',
'bx', # sometimes
'jr'
])
@ -102,7 +134,6 @@ branches = calls | returns | set([
# Unconditional x86 branches
'call', 'callq',
'jmp',
'ret',
# Conditional x86 branches
'ja', 'jna',
'jae', 'jnae',
@ -124,7 +155,7 @@ branches = calls | returns | set([
'beq', 'beq.w', 'bne', 'bmi', 'bpl', 'blt',
'ble', 'bgt', 'bge', 'bxne',
# MIPS branches
'j', 'jal', 'jr',
'j', 'jal',
# SPARC
'ba', 'bne', 'be', 'bg', 'ble', 'bge', 'bl', 'bgu', 'bleu',
'jmpl'

@ -10,6 +10,7 @@ import sys
import traceback
import gdb
import pwndbg.stdio
debug = False
pause = 0
@ -71,11 +72,12 @@ def connect(func, event_handler, name=''):
def caller(*a):
if debug: sys.stdout.write('%r %s.%s %r\n' % (name, func.__module__, func.__name__, a))
if pause: return
try:
func()
except Exception as e:
print(traceback.format_exc())
raise e
with pwndbg.stdio.stdio:
try:
func()
except Exception as e:
print(traceback.format_exc())
raise e
registered[event_handler].append(caller)
event_handler.connect(caller)

@ -23,8 +23,12 @@ def get(path):
if pwndbg.remote.is_remote():
local_path = tempfile.mktemp()
error = gdb.execute('remote get %s %s' % (path, local_path),
error = None
try:
error = gdb.execute('remote get %s %s' % (path, local_path),
to_string=True)
except gdb.error as e:
error = e
if error:
raise OSError("Could not download remote file %r:\n" \

File diff suppressed because it is too large Load Diff

@ -0,0 +1,18 @@
import pwndbg.arch
import pwndbg.jump.mips
import pwndbg.jump.arm
import pwndbg.jump.ppc
import pwndbg.jump.x86
import pwndbg.jump.sparc
def get_target(pc):
return {
'i386': pwndbg.jump.x86.resolver,
'x86-64': pwndbg.jump.x86.resolver
}.get(pwndbg.arch.current, lambda *a: None)(pc)
class Foo(object):
@property
def foobar(self):
return self._foobar

@ -0,0 +1,82 @@
import pwndbg.arch
import pwndbg.memory
import pwndbg.regs
from capstone import *
from capstone.x86 import *
md = Cs(CS_ARCH_X86, CS_MODE_32)
md.detail = True
class TargetResolver(object):
groups = {v:k for k,v in globals().items() if k.startswith('X86_GRP_')}
ops = {v:k for k,v in globals().items() if k.startswith('X86_OP_')}
regs = {v:k for k,v in globals().items() if k.startswith('X86_REG_')}
def __init__(self):
self.classes = {
X86_GRP_CALL: self.call_or_jump,
X86_GRP_JUMP: self.call_or_jump,
X86_GRP_RET: self.ret
}
def resolve(self, address):
code = bytes(pwndbg.memory.read(address, 16))
md.mode = CS_MODE_32 if pwndbg.arch.ptrsize == 4 else CS_MODE_64
instruction = next(md.disasm(code, address, 1))
for group in instruction.groups:
function = self.classes.get(group, None)
print(self.groups[group])
if function:
return function(instruction)
def get_operand_target(self, op):
# EB/E8/E9 or similar "call $+offset"
# Capstone handles the instruction + instruction size.
if op.type == X86_OP_IMM:
return op.value.imm
# jmp/call REG
if op.type == X86_OP_REG:
regname = instruction.reg_name(op.value.reg)
return pwndbg.regs[regname]
# base + disp + scale * offset
assert op.type == X86_OP_MEM, "Invalid operand type %i" % op.type
target = 0
if op.mem.base != 0:
regname = instruction.reg_name(op.value.reg)
target += pwndbg.regs[regname]
if op.mem.disp != 0:
target += op.value.mem.disp
if op.mem.index != 0:
scale = op.mem.scale
index = pwndbg.regs[instruction.reg_name(op.mem.index)]
target += (scale * index)
return target
def call_or_jump(self, instruction):
ops = instruction.operands
assert len(ops) == 1, "Too many operands (%i)" % len(ops)
return self.get_operand_target(ops[0])
def ret(self, instruction):
target = pwndbg.regs.sp
for op in instruction.operands:
assert op.type == X86_OP_IMM, "Unknown RET operand type"
target += op.value.imm
return pwndbg.memory.pvoid(target)
resolver = TargetResolver()

@ -40,6 +40,7 @@ def byte(addr): return readtype(pwndbg.typeinfo.uchar, addr)
def uchar(addr): return readtype(pwndbg.typeinfo.uchar, addr)
def ushort(addr): return readtype(pwndbg.typeinfo.ushort, addr)
def uint(addr): return readtype(pwndbg.typeinfo.uint, addr)
def pvoid(addr): return readtype(pwndbg.typeinfo.pvoid, addr)
def u8(addr): return readtype(pwndbg.typeinfo.uint8_t, addr)
def u16(addr): return readtype(pwndbg.typeinfo.uint16_t, addr)

@ -10,6 +10,7 @@ from types import ModuleType
import gdb
import pwndbg.arch
import pwndbg.events
import pwndbg.memoize
@ -25,13 +26,23 @@ class RegisterSet(object):
self.args = args
self.retval = retval
self.common = set(i for i in gpr + (frame, stack, pc) if i)
self.all = set(i for i in misc or tuple()) | set(flags or tuple()) | self.common
self.common -= {None}
self.all -= {None}
def __iter__(self):
for r in self.all:
yield r
arm = RegisterSet( 'pc',
'sp',
None,
('lr',),
('cpsr',),
('r0','r1','r2','r3','r4','r5','r6','r7','r8','r9','r10','r11','r12'),
None,
tuple(),
('r0','r1','r2','r3'),
'r0')
@ -41,7 +52,7 @@ aarch64 = RegisterSet('pc',
('lr',),
('cpsr',),
('x0','x1','x2','x3','x4','x5','x6','x7','x8','x9','x10','x11','x12'),
None,
tuple(),
('x0','x1','x2','x3'),
'x0')
@ -49,7 +60,7 @@ aarch64 = RegisterSet('pc',
amd64 = RegisterSet('rip',
'rsp',
'rbp',
None,
tuple(),
('eflags',),
('rax','rbx','rcx','rdx','rdi','rsi',
'r8', 'r9', 'r10','r11','r12',
@ -61,7 +72,7 @@ amd64 = RegisterSet('rip',
i386 = RegisterSet('eip',
'esp',
'ebp',
None,
tuple(),
('eflags',),
('eax','ebx','ecx','edx','edi','esi'),
('cs','ss','ds','es','fs','gs'),
@ -131,7 +142,7 @@ sparc = RegisterSet('pc',
('o7',),
('psr',),
sparc_gp,
None,
tuple(),
('i0','i1','i2','i3','i4','i5'),
'o0')
@ -153,25 +164,29 @@ mips = RegisterSet( 'pc',
'sp',
'fp',
('ra',),
None,
tuple('r%i' % i for i in range(1,26)),
None,
tuple(),
('v0','v1','a0','a1','a2','a3') \
+ tuple('t%i' % i for i in range(10)) \
+ tuple('s%i' % i for i in range(9)),
tuple(),
('a0','a1','a2','a3'),
'v0')
arch_to_regs = {
'i386': i386,
'i386:x86-64': amd64,
'x86-64': amd64,
'mips': mips,
'sparc': sparc,
'arm': arm,
'aarch64': aarch64,
'powerpc:403': powerpc,
'powerpc:common64': powerpc,
'powerpc': powerpc,
'powerpc': powerpc,
}
class module(ModuleType):
last = {}
def __getattr__(self, attr):
try:
value = int(gdb.parse_and_eval('$' + attr.lstrip('$')))
@ -180,13 +195,29 @@ class module(ModuleType):
return None
def __getitem__(self, item):
item = getattr(self, item)
if isinstance(item, int):
return arch_to_regs[pwndbg.arch.current][item]
assert isinstance(item, str), "Unknown type %r" % item
# e.g. if we're looking for register "$rax", turn it into "rax"
item = item.lstrip('$')
item = getattr(self, item.lower())
if isinstance(item, (int,long)):
return int(item) & pwndbg.arch.ptrmask
return item
def __iter__(self):
regs = set(arch_to_regs[pwndbg.arch.current]) | set(['pc','sp'])
for item in regs:
yield item
@property
def current(self):
return arch_to_regs[pwndbg.arch.current]
@property
def gpr(self):
return arch_to_regs[pwndbg.arch.current].gpr
@ -225,7 +256,6 @@ class module(ModuleType):
expression = re.sub(r'\$?\b%s\b' % regname, r'$'+regname, expression)
return expression
def items(self):
for regname in self.all:
yield regname, self[regname]
@ -244,8 +274,20 @@ class module(ModuleType):
arch_to_regs = arch_to_regs
@property
def changed(self):
delta = []
for reg, value in self.last.items():
if self[reg] != value:
delta.append(reg)
return delta
# To prevent garbage collection
tether = sys.modules[__name__]
sys.modules[__name__] = module(__name__, '')
@pwndbg.events.cont
def update_last():
M = sys.modules[__name__]
M.last = {k:M[k] for k in M}

@ -8,8 +8,6 @@ import sys
import gdb
import pwndbg.compat
debug = False
def get(fd, mode):
file = io.open(1, mode=mode, buffering=0, closefd=False)
@ -19,7 +17,20 @@ def get(fd, mode):
return io.TextIOWrapper(file, **kw)
if debug:
sys.stdin = get(0, 'rb')
sys.stdout = get(1, 'wb')
sys.stderr = get(2, 'wb')
stdin = get(0, 'rb')
stdout = get(1, 'wb')
stderr = get(2, 'wb')
class Stdio(object):
queue = []
def __enter__(self, *a, **kw):
self.queue.append((sys.stdin, sys.stdout, sys.stderr))
sys.stdin = get(0, 'rb')
sys.stdout = get(1, 'wb')
sys.stderr = get(2, 'wb')
def __exit__(self, *a, **kw):
sys.stdin, sys.stdout, sys.stderr = self.queue.pop()
stdio = Stdio()

@ -139,7 +139,7 @@ def proc_pid_maps():
except (OSError, gdb.error):
continue
else:
return []
return tuple()
if pwndbg.compat.python3:
data = data.decode()
@ -202,6 +202,7 @@ def info_sharedlibrary():
(*): Shared library is missing debugging information.
"""
pages = []
for line in gdb.execute('info sharedlibrary', to_string=True).splitlines():
if not line.startswith('0x'):
continue
@ -212,7 +213,7 @@ def info_sharedlibrary():
pages.extend(pwndbg.elf.map(text, obj))
return sorted(pages)
return tuple(sorted(pages))
@pwndbg.memoize.reset_on_objfile
def info_files():
@ -288,7 +289,7 @@ def info_auxv(skip_exe=False):
auxv = pwndbg.auxv.get()
if not auxv:
return []
return tuple()
pages = []
exe_name = auxv.AT_EXECFN or 'main.exe'
@ -302,7 +303,7 @@ def info_auxv(skip_exe=False):
if vdso:
pages.append(find_boundaries(vdso, '[vdso]'))
return sorted(pages)
return tuple(sorted(pages))
def find_boundaries(addr, name=''):
@ -327,12 +328,9 @@ def check_aslr():
try: data = pwndbg.file.get('/proc/sys/kernel/randomize_va_space')
except OSError: pass
output = gdb.execute('show disable-randomization', to_string=True)
if "is off." in output:
vmmap.aslr = True
return vmmap.aslr

Loading…
Cancel
Save