dnrops
/
pwndbg
mirror of https://github.com/pwndbg/pwndbg
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Convert all vmmap references to pwndbg.gdblib.vmmap

This commit is contained in:
Gulshan Singh 2022-10-13 14:33:00 -07:00
parent 8b6deac4fd
commit e456b317d7
34 changed files with 102 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/source/api/vmmap.rst
View File

@ -1,5 +1,5 @@
:mod:`pwndbg.vmmap` --- pwndbg.vmmap :mod:`pwndbg.gdblib.vmmap` --- pwndbg.gdblib.vmmap
============================================= =============================================
.. automodule:: pwndbg.vmmap .. automodule:: pwndbg.gdblib.vmmap
:members: :members:

1
pwndbg/__init__.py
View File

@ -20,7 +20,6 @@ import pwndbg.exception
import pwndbg.heap import pwndbg.heap
import pwndbg.lib.version import pwndbg.lib.version
import pwndbg.ui import pwndbg.ui
import pwndbg.vmmap
__version__ = pwndbg.lib.version.__version__ __version__ = pwndbg.lib.version.__version__
version = __version__ version = __version__

4
pwndbg/chain.py
View File

@ -8,7 +8,7 @@ import pwndbg.gdblib.abi
import pwndbg.gdblib.memory import pwndbg.gdblib.memory
import pwndbg.gdblib.symbol import pwndbg.gdblib.symbol
import pwndbg.gdblib.typeinfo import pwndbg.gdblib.typeinfo
import pwndbg.vmmap import pwndbg.gdblib.vmmap
LIMIT = pwndbg.gdblib.config.add_param( LIMIT = pwndbg.gdblib.config.add_param(
"dereference-limit", 5, "max number of pointers to dereference in a chain" "dereference-limit", 5, "max number of pointers to dereference in a chain"
@ -56,7 +56,7 @@ def get(
# Avoid redundant dereferences in bare metal mode by checking # Avoid redundant dereferences in bare metal mode by checking
# if address is in any of vmmap pages # if address is in any of vmmap pages
if not pwndbg.gdblib.abi.linux and not pwndbg.vmmap.find(address): if not pwndbg.gdblib.abi.linux and not pwndbg.gdblib.vmmap.find(address):
break break
next_address = int(pwndbg.gdblib.memory.poi(pwndbg.gdblib.typeinfo.ppvoid, address)) next_address = int(pwndbg.gdblib.memory.poi(pwndbg.gdblib.typeinfo.ppvoid, address))

4
pwndbg/color/memory.py
View File

@ -1,6 +1,6 @@
import pwndbg.color.theme as theme import pwndbg.color.theme as theme
import pwndbg.gdblib.config as config import pwndbg.gdblib.config as config
import pwndbg.vmmap import pwndbg.gdblib.vmmap
from pwndbg.color import generateColorFunction from pwndbg.color import generateColorFunction
from pwndbg.color import normal from pwndbg.color import normal
@ -51,7 +51,7 @@ def get(address, text=None):
""" """
address = int(address) address = int(address)
page = pwndbg.vmmap.find(int(address)) page = pwndbg.gdblib.vmmap.find(int(address))
if page is None: if page is None:
color = normal color = normal

4
pwndbg/commands/aslr.py
View File

@ -4,7 +4,7 @@ import gdb
import pwndbg.commands import pwndbg.commands
import pwndbg.gdblib.proc import pwndbg.gdblib.proc
import pwndbg.vmmap import pwndbg.gdblib.vmmap
from pwndbg.color import message from pwndbg.color import message
options = {"on": "off", "off": "on"} options = {"on": "off", "off": "on"}
@ -33,7 +33,7 @@ def aslr(state=None):
if pwndbg.gdblib.proc.alive: if pwndbg.gdblib.proc.alive:
print("Change will take effect when the process restarts") print("Change will take effect when the process restarts")
aslr, method = pwndbg.vmmap.check_aslr() aslr, method = pwndbg.gdblib.vmmap.check_aslr()
if aslr is True: if aslr is True:
status = message.on("ON") status = message.on("ON")

2
pwndbg/commands/context.py
View File

@ -23,10 +23,10 @@ import pwndbg.gdblib.config
import pwndbg.gdblib.events import pwndbg.gdblib.events
import pwndbg.gdblib.regs import pwndbg.gdblib.regs
import pwndbg.gdblib.symbol import pwndbg.gdblib.symbol
import pwndbg.gdblib.vmmap
import pwndbg.ghidra import pwndbg.ghidra
import pwndbg.ida import pwndbg.ida
import pwndbg.ui import pwndbg.ui
import pwndbg.vmmap
from pwndbg.color import message from pwndbg.color import message
from pwndbg.color import theme from pwndbg.color import theme

2
pwndbg/commands/dt.py
View File

@ -3,7 +3,7 @@ import argparse
import pwndbg.color import pwndbg.color
import pwndbg.commands import pwndbg.commands
import pwndbg.gdblib.dt import pwndbg.gdblib.dt
import pwndbg.vmmap import pwndbg.gdblib.vmmap
parser = argparse.ArgumentParser() parser = argparse.ArgumentParser()
parser.description = """ parser.description = """

4
pwndbg/commands/heap.py
View File

@ -143,7 +143,7 @@ def heap(addr=None, verbose=False, simple=False):
cursor = heap_region.start cursor = heap_region.start
else: else:
cursor = heap_region.start + allocator.heap_info.sizeof cursor = heap_region.start + allocator.heap_info.sizeof
if pwndbg.vmmap.find(allocator.get_heap(heap_region.start)["ar_ptr"]) == heap_region: if pwndbg.gdblib.vmmap.find(allocator.get_heap(heap_region.start)["ar_ptr"]) == heap_region:
# Round up to a 2-machine-word alignment after an arena to # Round up to a 2-machine-word alignment after an arena to
# compensate for the presence of the have_fastchunks variable # compensate for the presence of the have_fastchunks variable
# in GLIBC versions >= 2.27. # in GLIBC versions >= 2.27.
@ -642,7 +642,7 @@ def vis_heap_chunks(addr=None, count=None, naive=None, display_all=None):
cursor = heap_region.start cursor = heap_region.start
else: else:
cursor = heap_region.start + allocator.heap_info.sizeof cursor = heap_region.start + allocator.heap_info.sizeof
if pwndbg.vmmap.find(allocator.get_heap(heap_region.start)["ar_ptr"]) == heap_region: if pwndbg.gdblib.vmmap.find(allocator.get_heap(heap_region.start)["ar_ptr"]) == heap_region:
# Round up to a 2-machine-word alignment after an arena to # Round up to a 2-machine-word alignment after an arena to
# compensate for the presence of the have_fastchunks variable # compensate for the presence of the have_fastchunks variable
# in GLIBC versions >= 2.27. # in GLIBC versions >= 2.27.

2
pwndbg/commands/hexdump.py
View File

@ -28,7 +28,7 @@ def address_or_module_name(s):
gdbval_or_str = pwndbg.commands.sloppy_gdb_parse(s) gdbval_or_str = pwndbg.commands.sloppy_gdb_parse(s)
if isinstance(gdbval_or_str, str): if isinstance(gdbval_or_str, str):
module_name = gdbval_or_str module_name = gdbval_or_str
pages = list(filter(lambda page: module_name in page.objfile, pwndbg.vmmap.get())) pages = list(filter(lambda page: module_name in page.objfile, pwndbg.gdblib.vmmap.get()))
if pages: if pages:
return pages[0].vaddr return pages[0].vaddr
else: else:

8
pwndbg/commands/leakfind.py
View File

@ -11,7 +11,7 @@ import pwndbg.color.chain as C
import pwndbg.color.memory as M import pwndbg.color.memory as M
import pwndbg.color.message as message import pwndbg.color.message as message
import pwndbg.commands import pwndbg.commands
import pwndbg.vmmap import pwndbg.gdblib.vmmap
from pwndbg.chain import config_arrow_right from pwndbg.chain import config_arrow_right
@ -19,7 +19,7 @@ from pwndbg.chain import config_arrow_right
# addr is a pointer. It is taken to be a child pointer. # addr is a pointer. It is taken to be a child pointer.
# visited_map is a map of children -> (parent,parent_start) # visited_map is a map of children -> (parent,parent_start)
def get_rec_addr_string(addr, visited_map): def get_rec_addr_string(addr, visited_map):
page = pwndbg.vmmap.find(addr) page = pwndbg.gdblib.vmmap.find(addr)
arrow_right = C.arrow(" %s " % config_arrow_right) arrow_right = C.arrow(" %s " % config_arrow_right)
if page is not None: if page is not None:
@ -103,7 +103,7 @@ def leakfind(
): ):
if address is None: if address is None:
raise argparse.ArgumentTypeError("No starting address provided.") raise argparse.ArgumentTypeError("No starting address provided.")
foundPages = pwndbg.vmmap.find(address) foundPages = pwndbg.gdblib.vmmap.find(address)
if not foundPages: if not foundPages:
raise argparse.ArgumentTypeError("Starting address is not mapped.") raise argparse.ArgumentTypeError("Starting address is not mapped.")
@ -165,7 +165,7 @@ def leakfind(
arrow_right = C.arrow(" %s " % config_arrow_right) arrow_right = C.arrow(" %s " % config_arrow_right)
for child in visited_map: for child in visited_map:
child_page = pwndbg.vmmap.find(child) child_page = pwndbg.gdblib.vmmap.find(child)
if child_page is not None: if child_page is not None:
if page_name is not None and page_name not in child_page.objfile: if page_name is not None and page_name not in child_page.objfile:
continue continue

2
pwndbg/commands/misc.py
View File

@ -40,7 +40,7 @@ def errno_(err):
errno_loc_gotplt = pwndbg.gdblib.symbol.address("__errno_location@got.plt") errno_loc_gotplt = pwndbg.gdblib.symbol.address("__errno_location@got.plt")
# If the got.plt entry is not there (is None), it means the symbol is not used by the binary # If the got.plt entry is not there (is None), it means the symbol is not used by the binary
if errno_loc_gotplt is None or pwndbg.vmmap.find( if errno_loc_gotplt is None or pwndbg.gdblib.vmmap.find(
pwndbg.gdblib.memory.pvoid(errno_loc_gotplt) pwndbg.gdblib.memory.pvoid(errno_loc_gotplt)
): ):
err = int(gdb.parse_and_eval("*((int *(*) (void)) __errno_location) ()")) err = int(gdb.parse_and_eval("*((int *(*) (void)) __errno_location) ()"))

4
pwndbg/commands/nearpc.py
View File

@ -15,10 +15,10 @@ import pwndbg.gdblib.config
import pwndbg.gdblib.regs import pwndbg.gdblib.regs
import pwndbg.gdblib.strings import pwndbg.gdblib.strings
import pwndbg.gdblib.symbol import pwndbg.gdblib.symbol
import pwndbg.gdblib.vmmap
import pwndbg.ida import pwndbg.ida
import pwndbg.lib.functions import pwndbg.lib.functions
import pwndbg.ui import pwndbg.ui
import pwndbg.vmmap
from pwndbg.color import message from pwndbg.color import message
@ -120,7 +120,7 @@ def nearpc(pc=None, lines=None, to_string=False, emulate=False):
# In case $pc is in a new map we don't know about, # In case $pc is in a new map we don't know about,
# this will trigger an exploratory search. # this will trigger an exploratory search.
pwndbg.vmmap.find(pc) pwndbg.gdblib.vmmap.find(pc)
# Gather all addresses and symbols for each instruction # Gather all addresses and symbols for each instruction
symbols = [pwndbg.gdblib.symbol.get(i.address) for i in instructions] symbols = [pwndbg.gdblib.symbol.get(i.address) for i in instructions]

4
pwndbg/commands/p2p.py
View File

@ -20,7 +20,7 @@ class AddrRange:
def get_addrrange_any_named(): def get_addrrange_any_named():
return [AddrRange(page.start, page.end) for page in pwndbg.vmmap.get()] return [AddrRange(page.start, page.end) for page in pwndbg.gdblib.vmmap.get()]
def guess_numbers_base(num: str): def guess_numbers_base(num: str):
@ -63,7 +63,7 @@ def address_range(section):
if ":" in section: if ":" in section:
return [address_range_explicit(section)] return [address_range_explicit(section)]
pages = list(filter(lambda page: section in page.objfile, pwndbg.vmmap.get())) pages = list(filter(lambda page: section in page.objfile, pwndbg.gdblib.vmmap.get()))
if pages: if pages:
return [AddrRange(page.start, page.end) for page in pages] return [AddrRange(page.start, page.end) for page in pages]

4
pwndbg/commands/pie.py
View File

@ -6,7 +6,7 @@ import gdb
import pwndbg.auxv import pwndbg.auxv
import pwndbg.color.message as message import pwndbg.color.message as message
import pwndbg.commands import pwndbg.commands
import pwndbg.vmmap import pwndbg.gdblib.vmmap
def get_exe_name(): def get_exe_name():
@ -42,7 +42,7 @@ def get_exe_name():
def translate_addr(offset, module): def translate_addr(offset, module):
mod_filter = lambda page: module in page.objfile mod_filter = lambda page: module in page.objfile
pages = list(filter(mod_filter, pwndbg.vmmap.get())) pages = list(filter(mod_filter, pwndbg.gdblib.vmmap.get()))
if not pages: if not pages:
print( print(

6
pwndbg/commands/probeleak.py
View File

@ -9,17 +9,17 @@ import pwndbg.color.message as message
import pwndbg.commands import pwndbg.commands
import pwndbg.gdblib.arch import pwndbg.gdblib.arch
import pwndbg.gdblib.elf import pwndbg.gdblib.elf
import pwndbg.vmmap import pwndbg.gdblib.vmmap
def find_module(addr, max_distance): def find_module(addr, max_distance):
mod_filter = lambda page: page.start <= addr < page.end mod_filter = lambda page: page.start <= addr < page.end
pages = list(filter(mod_filter, pwndbg.vmmap.get())) pages = list(filter(mod_filter, pwndbg.gdblib.vmmap.get()))
if not pages: if not pages:
if max_distance != 0: if max_distance != 0:
mod_filter = lambda page: page.start - max_distance <= addr < page.end + max_distance mod_filter = lambda page: page.start - max_distance <= addr < page.end + max_distance
pages = list(filter(mod_filter, pwndbg.vmmap.get())) pages = list(filter(mod_filter, pwndbg.gdblib.vmmap.get()))
if not pages: if not pages:
return None return None

2
pwndbg/commands/rop.py
View File

@ -6,7 +6,7 @@ import tempfile
import gdb import gdb
import pwndbg.commands import pwndbg.commands
import pwndbg.vmmap import pwndbg.gdblib.vmmap
parser = argparse.ArgumentParser( parser = argparse.ArgumentParser(
description="Dump ROP gadgets with Jon Salwan's ROPgadget tool.", description="Dump ROP gadgets with Jon Salwan's ROPgadget tool.",

2
pwndbg/commands/ropper.py
View File

@ -5,7 +5,7 @@ import tempfile
import gdb import gdb
import pwndbg.commands import pwndbg.commands
import pwndbg.vmmap import pwndbg.gdblib.vmmap
parser = argparse.ArgumentParser( parser = argparse.ArgumentParser(
description="ROP gadget search with ropper.", description="ROP gadget search with ropper.",

6
pwndbg/commands/search.py
View File

@ -10,8 +10,8 @@ import pwndbg.commands
import pwndbg.enhance import pwndbg.enhance
import pwndbg.gdblib.arch import pwndbg.gdblib.arch
import pwndbg.gdblib.config import pwndbg.gdblib.config
import pwndbg.gdblib.vmmap
import pwndbg.search import pwndbg.search
import pwndbg.vmmap
from pwndbg.color import message from pwndbg.color import message
saved = set() # type:Set[int] saved = set() # type:Set[int]
@ -26,7 +26,7 @@ def print_search_hit(address):
if not address: if not address:
return return
vmmap = pwndbg.vmmap.find(address) vmmap = pwndbg.gdblib.vmmap.find(address)
if vmmap: if vmmap:
region = os.path.basename(vmmap.objfile) region = os.path.basename(vmmap.objfile)
else: else:
@ -179,7 +179,7 @@ def search(type, hex, executable, writable, value, mapping_name, save, next, tru
value += b"\x00" value += b"\x00"
# Find the mappings that we're looking for # Find the mappings that we're looking for
mappings = pwndbg.vmmap.get() mappings = pwndbg.gdblib.vmmap.get()
if mapping_name: if mapping_name:
mappings = [m for m in mappings if mapping_name in m.objfile] mappings = [m for m in mappings if mapping_name in m.objfile]

4
pwndbg/commands/stack.py
View File

@ -4,14 +4,14 @@ import pwndbg.chain
import pwndbg.commands import pwndbg.commands
import pwndbg.gdblib.arch import pwndbg.gdblib.arch
import pwndbg.gdblib.regs import pwndbg.gdblib.regs
import pwndbg.vmmap import pwndbg.gdblib.vmmap
@pwndbg.commands.ArgparsedCommand("Print out the stack addresses that contain return addresses.") @pwndbg.commands.ArgparsedCommand("Print out the stack addresses that contain return addresses.")
@pwndbg.commands.OnlyWhenRunning @pwndbg.commands.OnlyWhenRunning
def retaddr(): def retaddr():
sp = pwndbg.gdblib.regs.sp sp = pwndbg.gdblib.regs.sp
stack = pwndbg.vmmap.find(sp) stack = pwndbg.gdblib.vmmap.find(sp)
# Enumerate all return addresses # Enumerate all return addresses
frame = gdb.newest_frame() frame = gdb.newest_frame()

10
pwndbg/commands/vmmap.py
View File

@ -10,7 +10,7 @@ from elftools.elf.elffile import ELFFile
import pwndbg.color.memory as M import pwndbg.color.memory as M
import pwndbg.commands import pwndbg.commands
import pwndbg.gdblib.elf import pwndbg.gdblib.elf
import pwndbg.vmmap import pwndbg.gdblib.vmmap
integer_types = (int, gdb.Value) integer_types = (int, gdb.Value)
@ -62,7 +62,7 @@ parser.add_argument("-x", "--executable", action="store_true", help="Display exe
@pwndbg.commands.ArgparsedCommand(parser, aliases=["lm", "address", "vprot"]) @pwndbg.commands.ArgparsedCommand(parser, aliases=["lm", "address", "vprot"])
@pwndbg.commands.OnlyWhenRunning @pwndbg.commands.OnlyWhenRunning
def vmmap(gdbval_or_str=None, writable=False, executable=False): def vmmap(gdbval_or_str=None, writable=False, executable=False):
pages = pwndbg.vmmap.get() pages = pwndbg.gdblib.vmmap.get()
if gdbval_or_str: if gdbval_or_str:
pages = list(filter(pages_filter(gdbval_or_str), pages)) pages = list(filter(pages_filter(gdbval_or_str), pages))
@ -117,14 +117,14 @@ def vmmap_add(start, size, flags, offset):
perm |= flag_val perm |= flag_val
page = pwndbg.lib.memory.Page(start, size, perm, offset) page = pwndbg.lib.memory.Page(start, size, perm, offset)
pwndbg.vmmap.add_custom_page(page) pwndbg.gdblib.vmmap.add_custom_page(page)
print("%r added" % page) print("%r added" % page)
@pwndbg.commands.ArgparsedCommand("Clear the vmmap cache.") # TODO is this accurate? @pwndbg.commands.ArgparsedCommand("Clear the vmmap cache.") # TODO is this accurate?
def vmmap_clear(): def vmmap_clear():
pwndbg.vmmap.clear_custom_page() pwndbg.gdblib.vmmap.clear_custom_page()
parser = argparse.ArgumentParser() parser = argparse.ArgumentParser()
@ -173,5 +173,5 @@ def vmmap_load(filename):
pages.append(page) pages.append(page)
for page in pages: for page in pages:
pwndbg.vmmap.add_custom_page(page) pwndbg.gdblib.vmmap.add_custom_page(page)
print("%r added" % page) print("%r added" % page)

8
pwndbg/commands/xinfo.py
View File

@ -7,7 +7,7 @@ import pwndbg.gdblib.config
import pwndbg.gdblib.memory import pwndbg.gdblib.memory
import pwndbg.gdblib.regs import pwndbg.gdblib.regs
import pwndbg.gdblib.stack import pwndbg.gdblib.stack
import pwndbg.vmmap import pwndbg.gdblib.vmmap
import pwndbg.wrappers import pwndbg.wrappers
parser = argparse.ArgumentParser( parser = argparse.ArgumentParser(
@ -35,7 +35,7 @@ def xinfo_stack(page, addr):
sp = pwndbg.gdblib.regs.sp sp = pwndbg.gdblib.regs.sp
frame = pwndbg.gdblib.regs[pwndbg.gdblib.regs.frame] frame = pwndbg.gdblib.regs[pwndbg.gdblib.regs.frame]
frame_mapping = pwndbg.vmmap.find(frame) frame_mapping = pwndbg.gdblib.vmmap.find(frame)
print_line("Stack Top", addr, page.vaddr, addr - page.vaddr, "+") print_line("Stack Top", addr, page.vaddr, addr - page.vaddr, "+")
print_line("Stack End", addr, page.end, page.end - addr, "-") print_line("Stack End", addr, page.end, page.end - addr, "-")
@ -63,7 +63,7 @@ def xinfo_mmap_file(page, addr):
# to beginning of file in memory and on disk # to beginning of file in memory and on disk
file_name = page.objfile file_name = page.objfile
objpages = filter(lambda p: p.objfile == file_name, pwndbg.vmmap.get()) objpages = filter(lambda p: p.objfile == file_name, pwndbg.gdblib.vmmap.get())
first = sorted(objpages, key=lambda p: p.vaddr)[0] first = sorted(objpages, key=lambda p: p.vaddr)[0]
# print offset from ELF base load address # print offset from ELF base load address
@ -112,7 +112,7 @@ def xinfo(address=None):
addr = int(address) addr = int(address)
addr &= pwndbg.gdblib.arch.ptrmask addr &= pwndbg.gdblib.arch.ptrmask
page = pwndbg.vmmap.find(addr) page = pwndbg.gdblib.vmmap.find(addr)
if page is None: if page is None:
print("\n Virtual address {:#x} is not mapped.".format(addr)) print("\n Virtual address {:#x} is not mapped.".format(addr))

2
pwndbg/enhance.py
View File

@ -60,7 +60,7 @@ def enhance(value, code=True, safe_linking=False):
value = int(value) value = int(value)
name = pwndbg.gdblib.symbol.get(value) or None name = pwndbg.gdblib.symbol.get(value) or None
page = pwndbg.vmmap.find(value) page = pwndbg.gdblib.vmmap.find(value)
# If it's not in a page we know about, try to dereference # If it's not in a page we know about, try to dereference
# it anyway just to test. # it anyway just to test.

1
pwndbg/gdblib/__init__.py
View File

@ -27,3 +27,4 @@ def load_gdblib():
import pwndbg.gdblib.regs import pwndbg.gdblib.regs
import pwndbg.gdblib.symbol import pwndbg.gdblib.symbol
import pwndbg.gdblib.typeinfo import pwndbg.gdblib.typeinfo
import pwndbg.gdblib.vmmap

4
pwndbg/gdblib/elf.py
View File

@ -240,7 +240,7 @@ def get_ehdr(pointer):
if pwndbg.gdblib.qemu.is_qemu(): if pwndbg.gdblib.qemu.is_qemu():
return None, None return None, None
vmmap = pwndbg.vmmap.find(pointer) vmmap = pwndbg.gdblib.vmmap.find(pointer)
base = None base = None
# If there is no vmmap for the requested address, we can't do much # If there is no vmmap for the requested address, we can't do much
@ -255,7 +255,7 @@ def get_ehdr(pointer):
# The page did not have ELF magic; it may be that .text and binary start are split # The page did not have ELF magic; it may be that .text and binary start are split
# into two pages, so let's get the first page from the pointer's page objfile # into two pages, so let's get the first page from the pointer's page objfile
else: else:
for v in pwndbg.vmmap.get(): for v in pwndbg.gdblib.vmmap.get():
if v.objfile == vmmap.objfile: if v.objfile == vmmap.objfile:
vmmap = v vmmap = v
break break

2
pwndbg/gdblib/next.py
View File

@ -140,7 +140,7 @@ def break_on_program_code():
""" """
exe = pwndbg.gdblib.proc.exe exe = pwndbg.gdblib.proc.exe
binary_exec_page_ranges = tuple( binary_exec_page_ranges = tuple(
(p.start, p.end) for p in pwndbg.vmmap.get() if p.objfile == exe and p.execute (p.start, p.end) for p in pwndbg.gdblib.vmmap.get() if p.objfile == exe and p.execute
) )
pc = pwndbg.gdblib.regs.pc pc = pwndbg.gdblib.regs.pc

10
pwndbg/gdblib/symbol.py
View File

@ -23,9 +23,9 @@ import pwndbg.gdblib.memory
import pwndbg.gdblib.qemu import pwndbg.gdblib.qemu
import pwndbg.gdblib.remote import pwndbg.gdblib.remote
import pwndbg.gdblib.stack import pwndbg.gdblib.stack
import pwndbg.gdblib.vmmap
import pwndbg.ida import pwndbg.ida
import pwndbg.lib.memoize import pwndbg.lib.memoize
import pwndbg.vmmap
def _get_debug_file_directory(): def _get_debug_file_directory():
@ -87,7 +87,7 @@ def _autofetch():
if remote_files_dir not in _get_debug_file_directory().split(":"): if remote_files_dir not in _get_debug_file_directory().split(":"):
_add_debug_file_directory(remote_files_dir) _add_debug_file_directory(remote_files_dir)
for mapping in pwndbg.vmmap.get(): for mapping in pwndbg.gdblib.vmmap.get():
objfile = mapping.objfile objfile = mapping.objfile
# Don't attempt to download things like '[stack]' and '[heap]' # Don't attempt to download things like '[stack]' and '[heap]'
@ -118,7 +118,7 @@ def _autofetch():
_remote_files[objfile] = local_path _remote_files[objfile] = local_path
base = None base = None
for mapping in pwndbg.vmmap.get(): for mapping in pwndbg.gdblib.vmmap.get():
if mapping.objfile != objfile: if mapping.objfile != objfile:
continue continue
@ -167,7 +167,7 @@ def get(address: int, gdb_only=False) -> str:
address = int(address) address = int(address)
exe = pwndbg.gdblib.elf.exe() exe = pwndbg.gdblib.elf.exe()
if exe: if exe:
exe_map = pwndbg.vmmap.find(exe.address) exe_map = pwndbg.gdblib.vmmap.find(exe.address)
if exe_map and address in exe_map: if exe_map and address in exe_map:
res = pwndbg.ida.Name(address) or pwndbg.ida.GetFuncOffset(address) res = pwndbg.ida.Name(address) or pwndbg.ida.GetFuncOffset(address)
return res or "" return res or ""
@ -265,7 +265,7 @@ def _add_main_exe_to_symbols():
addr = int(addr) addr = int(addr)
mmap = pwndbg.vmmap.find(addr) mmap = pwndbg.gdblib.vmmap.find(addr)
if not mmap: if not mmap:
return return

5
pwndbg/gdblib/tls.py
View File

@ -11,7 +11,7 @@ import pwndbg.gdblib.arch
import pwndbg.gdblib.memory import pwndbg.gdblib.memory
import pwndbg.gdblib.regs import pwndbg.gdblib.regs
import pwndbg.gdblib.symbol import pwndbg.gdblib.symbol
import pwndbg.vmmap import pwndbg.gdblib.vmmap
class module(ModuleType): class module(ModuleType):
@ -97,7 +97,8 @@ class module(ModuleType):
# For arm (32-bit), we doesn't have other choice # For arm (32-bit), we doesn't have other choice
# Note: aarch64 seems doesn't have this issue # Note: aarch64 seems doesn't have this issue
is_valid_tls_base = ( is_valid_tls_base = (
pwndbg.vmmap.find(tls_base) is not None and tls_base % pwndbg.gdblib.arch.ptrsize == 0 pwndbg.gdblib.vmmap.find(tls_base) is not None
and tls_base % pwndbg.gdblib.arch.ptrsize == 0
) )
return tls_base if is_valid_tls_base else self.get_tls_base_via_errno_location() return tls_base if is_valid_tls_base else self.get_tls_base_via_errno_location()

50
pwndbg/heap/ptmalloc.py
View File

@ -10,9 +10,9 @@ import pwndbg.gdblib.events
import pwndbg.gdblib.symbol import pwndbg.gdblib.symbol
import pwndbg.gdblib.tls import pwndbg.gdblib.tls
import pwndbg.gdblib.typeinfo import pwndbg.gdblib.typeinfo
import pwndbg.gdblib.vmmap
import pwndbg.glibc import pwndbg.glibc
import pwndbg.search import pwndbg.search
import pwndbg.vmmap
from pwndbg.color import message from pwndbg.color import message
from pwndbg.constants import ptmalloc from pwndbg.constants import ptmalloc
from pwndbg.heap import heap_chain_limit from pwndbg.heap import heap_chain_limit
@ -264,7 +264,7 @@ class HeapInfo:
def __str__(self): def __str__(self):
fmt = "[%%%ds]" % (pwndbg.gdblib.arch.ptrsize * 2) fmt = "[%%%ds]" % (pwndbg.gdblib.arch.ptrsize * 2)
return message.hint(fmt % (hex(self.first_chunk))) + M.heap( return message.hint(fmt % (hex(self.first_chunk))) + M.heap(
str(pwndbg.vmmap.find(self.addr)) str(pwndbg.gdblib.vmmap.find(self.addr))
) )
@ -529,7 +529,7 @@ class Heap(pwndbg.heap.heap.BaseHeap):
def get_region(self, addr): def get_region(self, addr):
"""Find the memory map containing 'addr'.""" """Find the memory map containing 'addr'."""
return pwndbg.vmmap.find(addr) return pwndbg.gdblib.vmmap.find(addr)
def fastbin_index(self, size): def fastbin_index(self, size):
if pwndbg.gdblib.arch.ptrsize == 8: if pwndbg.gdblib.arch.ptrsize == 8:
@ -890,7 +890,7 @@ class DebugSymsHeap(Heap):
return ( return (
None None
if pwndbg.vmmap.find(arena_addr) is None if pwndbg.gdblib.vmmap.find(arena_addr) is None
else pwndbg.gdblib.memory.poi(self.malloc_state, arena_addr) else pwndbg.gdblib.memory.poi(self.malloc_state, arena_addr)
) )
@ -956,11 +956,11 @@ class HeuristicHeap(Heap):
def possible_page_of_symbols(self): def possible_page_of_symbols(self):
if self._possible_page_of_symbols is None: if self._possible_page_of_symbols is None:
if pwndbg.glibc.get_got_plt_address() > 0: if pwndbg.glibc.get_got_plt_address() > 0:
self._possible_page_of_symbols = pwndbg.vmmap.find( self._possible_page_of_symbols = pwndbg.gdblib.vmmap.find(
pwndbg.glibc.get_got_plt_address() pwndbg.glibc.get_got_plt_address()
) )
elif pwndbg.gdblib.symbol.address("_IO_list_all"): elif pwndbg.gdblib.symbol.address("_IO_list_all"):
self._possible_page_of_symbols = pwndbg.vmmap.find( self._possible_page_of_symbols = pwndbg.gdblib.vmmap.find(
pwndbg.gdblib.symbol.address("_IO_list_all") pwndbg.gdblib.symbol.address("_IO_list_all")
) )
return self._possible_page_of_symbols return self._possible_page_of_symbols
@ -975,7 +975,7 @@ class HeuristicHeap(Heap):
return False return False
_IO_list_all_addr = pwndbg.gdblib.symbol.address("_IO_list_all") _IO_list_all_addr = pwndbg.gdblib.symbol.address("_IO_list_all")
if _IO_list_all_addr: if _IO_list_all_addr:
return addr in pwndbg.vmmap.find(_IO_list_all_addr) and addr > _IO_list_all_addr return addr in pwndbg.gdblib.vmmap.find(_IO_list_all_addr) and addr > _IO_list_all_addr
# We trust that symbol is from GLIBC :) # We trust that symbol is from GLIBC :)
return True return True
@ -1059,7 +1059,7 @@ class HeuristicHeap(Heap):
self._main_arena_addr = offset + instr.address + 4 self._main_arena_addr = offset + instr.address + 4
# Try to search main_arena in .data of libc if we can't find it via above trick # Try to search main_arena in .data of libc if we can't find it via above trick
if not self._main_arena_addr or pwndbg.vmmap.find(self._main_arena_addr) is None: if not self._main_arena_addr or pwndbg.gdblib.vmmap.find(self._main_arena_addr) is None:
start = pwndbg.gdblib.symbol.address("_IO_2_1_stdin_") start = pwndbg.gdblib.symbol.address("_IO_2_1_stdin_")
end = pwndbg.gdblib.symbol.address("_IO_list_all") end = pwndbg.gdblib.symbol.address("_IO_list_all")
# If we didn't have these symbols, we try to find them in the possible page # If we didn't have these symbols, we try to find them in the possible page
@ -1100,7 +1100,7 @@ class HeuristicHeap(Heap):
if found: if found:
break break
if self._main_arena_addr and pwndbg.vmmap.find(self._main_arena_addr): if self._main_arena_addr and pwndbg.gdblib.vmmap.find(self._main_arena_addr):
self._main_arena = self.malloc_state(self._main_arena_addr) self._main_arena = self.malloc_state(self._main_arena_addr)
return self._main_arena return self._main_arena
@ -1133,13 +1133,14 @@ class HeuristicHeap(Heap):
is_valid_address = 0 < thread_arena_via_symbol - tls_base < 0x250 is_valid_address = 0 < thread_arena_via_symbol - tls_base < 0x250
is_valid_address = ( is_valid_address = (
is_valid_address and thread_arena_via_symbol in pwndbg.vmmap.find(tls_base) is_valid_address
and thread_arena_via_symbol in pwndbg.gdblib.vmmap.find(tls_base)
) )
if is_valid_address: if is_valid_address:
thread_arena_struct_addr = pwndbg.gdblib.memory.u(thread_arena_via_symbol) thread_arena_struct_addr = pwndbg.gdblib.memory.u(thread_arena_via_symbol)
# Check &thread_arena is a valid address or not to avoid false positive. # Check &thread_arena is a valid address or not to avoid false positive.
if pwndbg.vmmap.find(thread_arena_struct_addr): if pwndbg.gdblib.vmmap.find(thread_arena_struct_addr):
return thread_arena_struct_addr return thread_arena_struct_addr
if not self._thread_arena_offset and pwndbg.gdblib.symbol.address("__libc_calloc"): if not self._thread_arena_offset and pwndbg.gdblib.symbol.address("__libc_calloc"):
@ -1264,7 +1265,7 @@ class HeuristicHeap(Heap):
tls_base = pwndbg.gdblib.tls.address tls_base = pwndbg.gdblib.tls.address
if tls_base: if tls_base:
thread_arena_struct_addr = tls_base + self._thread_arena_offset thread_arena_struct_addr = tls_base + self._thread_arena_offset
if pwndbg.vmmap.find(thread_arena_struct_addr): if pwndbg.gdblib.vmmap.find(thread_arena_struct_addr):
return pwndbg.gdblib.memory.pvoid(thread_arena_struct_addr) return pwndbg.gdblib.memory.pvoid(thread_arena_struct_addr)
raise SymbolUnresolvableError("thread_arena") raise SymbolUnresolvableError("thread_arena")
@ -1296,7 +1297,8 @@ class HeuristicHeap(Heap):
is_valid_address = 0 < thread_cache_via_symbol - tls_base < 0x250 is_valid_address = 0 < thread_cache_via_symbol - tls_base < 0x250
is_valid_address = ( is_valid_address = (
is_valid_address and thread_cache_via_symbol in pwndbg.vmmap.find(tls_base) is_valid_address
and thread_cache_via_symbol in pwndbg.gdblib.vmmap.find(tls_base)
) )
if is_valid_address: if is_valid_address:
@ -1471,7 +1473,7 @@ class HeuristicHeap(Heap):
tls_base + self._thread_cache_offset tls_base + self._thread_cache_offset
) )
if ( if (
pwndbg.vmmap.find(thread_cache_struct_addr) pwndbg.gdblib.vmmap.find(thread_cache_struct_addr)
and thread_cache_struct_addr in self.get_heap_boundaries() and thread_cache_struct_addr in self.get_heap_boundaries()
): ):
self._thread_cache = self.tcache_perthread_struct(thread_cache_struct_addr) self._thread_cache = self.tcache_perthread_struct(thread_cache_struct_addr)
@ -1487,7 +1489,10 @@ class HeuristicHeap(Heap):
cursor = heap_region.start cursor = heap_region.start
else: else:
cursor = heap_region.start + self.heap_info.sizeof cursor = heap_region.start + self.heap_info.sizeof
if pwndbg.vmmap.find(self.get_heap(heap_region.start)["ar_ptr"]) == heap_region: if (
pwndbg.gdblib.vmmap.find(self.get_heap(heap_region.start)["ar_ptr"])
== heap_region
):
# Round up to a 2-machine-word alignment after an arena to # Round up to a 2-machine-word alignment after an arena to
# compensate for the presence of the have_fastchunks variable # compensate for the presence of the have_fastchunks variable
# in GLIBC versions >= 2.27. # in GLIBC versions >= 2.27.
@ -1618,7 +1623,7 @@ class HeuristicHeap(Heap):
# can't find the reference about mp_ in __libc_free, try to find it with heap boundaries of main_arena # can't find the reference about mp_ in __libc_free, try to find it with heap boundaries of main_arena
if ( if (
not self._mp_addr not self._mp_addr
or pwndbg.vmmap.find(self._mp_addr) is None or pwndbg.gdblib.vmmap.find(self._mp_addr) is None
and self.possible_page_of_symbols and self.possible_page_of_symbols
): ):
libc_page = self.possible_page_of_symbols libc_page = self.possible_page_of_symbols
@ -1633,7 +1638,7 @@ class HeuristicHeap(Heap):
region = self.get_region(arena["top"]) region = self.get_region(arena["top"])
else: else:
# If we can't find main_arena via heuristics, try to find it via vmmap # If we can't find main_arena via heuristics, try to find it via vmmap
region = next(p for p in pwndbg.vmmap.get() if "heap]" in p.objfile) region = next(p for p in pwndbg.gdblib.vmmap.get() if "heap]" in p.objfile)
possible_sbrk_base = region.start possible_sbrk_base = region.start
sbrk_offset = self.malloc_par(0).get_field_address("sbrk_base") sbrk_offset = self.malloc_par(0).get_field_address("sbrk_base")
@ -1648,7 +1653,7 @@ class HeuristicHeap(Heap):
except StopIteration: except StopIteration:
pass pass
if self._mp_addr and pwndbg.vmmap.find(self._mp_addr) is not None: if self._mp_addr and pwndbg.gdblib.vmmap.find(self._mp_addr) is not None:
self._mp = self.malloc_par(self._mp_addr) self._mp = self.malloc_par(self._mp_addr)
return self._mp return self._mp
@ -1781,7 +1786,7 @@ class HeuristicHeap(Heap):
elif instr.mnemonic == "ldr" and "[pc" in instr.op_str: elif instr.mnemonic == "ldr" and "[pc" in instr.op_str:
ldr_instr = instr ldr_instr = instr
if self._global_max_fast_addr and pwndbg.vmmap.find(self._global_max_fast_addr): if self._global_max_fast_addr and pwndbg.gdblib.vmmap.find(self._global_max_fast_addr):
self._global_max_fast = pwndbg.gdblib.memory.u(self._global_max_fast_addr) self._global_max_fast = pwndbg.gdblib.memory.u(self._global_max_fast_addr)
return self._global_max_fast return self._global_max_fast
@ -1857,7 +1862,7 @@ class HeuristicHeap(Heap):
region = self.get_region(addr) if addr else self.get_region(self.get_arena()["top"]) region = self.get_region(addr) if addr else self.get_region(self.get_arena()["top"])
else: else:
# If we can't find an arena via heuristics, try to find it via vmmap # If we can't find an arena via heuristics, try to find it via vmmap
region = next(p for p in pwndbg.vmmap.get() if "heap]" in p.objfile) region = next(p for p in pwndbg.gdblib.vmmap.get() if "heap]" in p.objfile)
# Occasionally, the [heap] vm region and the actual start of the heap are # Occasionally, the [heap] vm region and the actual start of the heap are
# different, e.g. [heap] starts at 0x61f000 but mp_.sbrk_base is 0x620000. # different, e.g. [heap] starts at 0x61f000 but mp_.sbrk_base is 0x620000.
@ -1877,4 +1882,7 @@ class HeuristicHeap(Heap):
def is_initialized(self): def is_initialized(self):
# TODO/FIXME: If main_arena['top'] is been modified to 0, this will not work. # TODO/FIXME: If main_arena['top'] is been modified to 0, this will not work.
# try to use vmmap or main_arena.top to find the heap # try to use vmmap or main_arena.top to find the heap
return any("heap]" in x.objfile for x in pwndbg.vmmap.get()) or self.main_arena["top"] != 0 return (
any("heap]" in x.objfile for x in pwndbg.gdblib.vmmap.get())
or self.main_arena["top"] != 0
)

4
pwndbg/search.py
View File

@ -7,7 +7,7 @@ import gdb
import pwndbg.gdblib.arch import pwndbg.gdblib.arch
import pwndbg.gdblib.memory import pwndbg.gdblib.memory
import pwndbg.gdblib.typeinfo import pwndbg.gdblib.typeinfo
import pwndbg.vmmap import pwndbg.gdblib.vmmap
def search(searchfor, mappings=None, start=None, end=None, executable=False, writable=False): def search(searchfor, mappings=None, start=None, end=None, executable=False, writable=False):
@ -27,7 +27,7 @@ def search(searchfor, mappings=None, start=None, end=None, executable=False, wri
""" """
i = gdb.selected_inferior() i = gdb.selected_inferior()
maps = mappings or pwndbg.vmmap.get() maps = mappings or pwndbg.gdblib.vmmap.get()
if end and start: if end and start:
assert start < end, "Last address to search must be greater then first address" assert start < end, "Last address to search must be greater then first address"

18
tests/heap/test_heap_bins.py
View File

@ -2,8 +2,8 @@ import gdb
import pwndbg.gdblib.memory import pwndbg.gdblib.memory
import pwndbg.gdblib.symbol import pwndbg.gdblib.symbol
import pwndbg.gdblib.vmmap
import pwndbg.heap import pwndbg.heap
import pwndbg.vmmap
import tests import tests
BINARY = tests.binaries.get("heap_bins.out") BINARY = tests.binaries.get("heap_bins.out")
@ -76,7 +76,7 @@ def test_heap_bins(start_binary):
result[tcache_size][1] == tcache_count and len(result[tcache_size][0]) == tcache_count + 1 result[tcache_size][1] == tcache_count and len(result[tcache_size][0]) == tcache_count + 1
) )
for addr in result[tcache_size][0][:-1]: for addr in result[tcache_size][0][:-1]:
assert pwndbg.vmmap.find(addr) assert pwndbg.gdblib.vmmap.find(addr)
# check fastbin # check fastbin
gdb.execute("continue") gdb.execute("continue")
@ -85,7 +85,7 @@ def test_heap_bins(start_binary):
assert result["type"] == "fastbins" assert result["type"] == "fastbins"
assert (fastbin_size in result) and (len(result[fastbin_size]) == fastbin_count + 1) assert (fastbin_size in result) and (len(result[fastbin_size]) == fastbin_count + 1)
for addr in result[fastbin_size][:-1]: for addr in result[fastbin_size][:-1]:
assert pwndbg.vmmap.find(addr) assert pwndbg.gdblib.vmmap.find(addr)
# check unsortedbin # check unsortedbin
gdb.execute("continue") gdb.execute("continue")
@ -97,9 +97,9 @@ def test_heap_bins(start_binary):
) )
assert not result["all"][2] assert not result["all"][2]
for addr in result["all"][0][:-1]: for addr in result["all"][0][:-1]:
assert pwndbg.vmmap.find(addr) assert pwndbg.gdblib.vmmap.find(addr)
for addr in result["all"][1][:-1]: for addr in result["all"][1][:-1]:
assert pwndbg.vmmap.find(addr) assert pwndbg.gdblib.vmmap.find(addr)
# check smallbins # check smallbins
gdb.execute("continue") gdb.execute("continue")
@ -112,9 +112,9 @@ def test_heap_bins(start_binary):
) )
assert not result[smallbin_size][2] assert not result[smallbin_size][2]
for addr in result[smallbin_size][0][:-1]: for addr in result[smallbin_size][0][:-1]:
assert pwndbg.vmmap.find(addr) assert pwndbg.gdblib.vmmap.find(addr)
for addr in result[smallbin_size][1][:-1]: for addr in result[smallbin_size][1][:-1]:
assert pwndbg.vmmap.find(addr) assert pwndbg.gdblib.vmmap.find(addr)
# check largebins # check largebins
gdb.execute("continue") gdb.execute("continue")
@ -127,9 +127,9 @@ def test_heap_bins(start_binary):
) )
assert not result[largebin_size][2] assert not result[largebin_size][2]
for addr in result[largebin_size][0][:-1]: for addr in result[largebin_size][0][:-1]:
assert pwndbg.vmmap.find(addr) assert pwndbg.gdblib.vmmap.find(addr)
for addr in result[largebin_size][1][:-1]: for addr in result[largebin_size][1][:-1]:
assert pwndbg.vmmap.find(addr) assert pwndbg.gdblib.vmmap.find(addr)
# check corrupted # check corrupted
gdb.execute("continue") gdb.execute("continue")

2
tests/heap/test_vis_heap_chunks.py
View File

@ -13,7 +13,7 @@ def test_vis_heap_chunk_command(start_binary):
# TODO/FIXME: Shall we have a standard method to do this kind of filtering? # TODO/FIXME: Shall we have a standard method to do this kind of filtering?
# Note that we have `pages_filter` in pwndbg/pwndbg/commands/vmmap.py heh # Note that we have `pages_filter` in pwndbg/pwndbg/commands/vmmap.py heh
heap_page = next(page for page in pwndbg.vmmap.get() if page.objfile == "[heap]") heap_page = next(page for page in pwndbg.gdblib.vmmap.get() if page.objfile == "[heap]")
first_chunk_size = pwndbg.gdblib.memory.u64(heap_page.start + pwndbg.gdblib.arch.ptrsize) first_chunk_size = pwndbg.gdblib.memory.u64(heap_page.start + pwndbg.gdblib.arch.ptrsize)

6
tests/test_commands_next.py
View File

@ -24,16 +24,16 @@ def test_command_nextproginstr(start_binary):
# Sanity check # Sanity check
exec_bin_pages = [ exec_bin_pages = [
p for p in pwndbg.vmmap.get() if p.objfile == pwndbg.gdblib.proc.exe and p.execute p for p in pwndbg.gdblib.vmmap.get() if p.objfile == pwndbg.gdblib.proc.exe and p.execute
] ]
assert any(pwndbg.gdblib.regs.pc in p for p in exec_bin_pages) assert any(pwndbg.gdblib.regs.pc in p for p in exec_bin_pages)
main_page = pwndbg.vmmap.find(pwndbg.gdblib.regs.pc) main_page = pwndbg.gdblib.vmmap.find(pwndbg.gdblib.regs.pc)
gdb.execute("break puts") gdb.execute("break puts")
gdb.execute("continue") gdb.execute("continue")
# Sanity check that we are in libc # Sanity check that we are in libc
assert "libc" in pwndbg.vmmap.find(pwndbg.gdblib.regs.rip).objfile assert "libc" in pwndbg.gdblib.vmmap.find(pwndbg.gdblib.regs.rip).objfile
# Execute nextproginstr and see if we came back to the same vmmap page # Execute nextproginstr and see if we came back to the same vmmap page
gdb.execute("nextproginstr") gdb.execute("nextproginstr")

2
tests/test_hexdump.py
View File

@ -4,7 +4,7 @@ from pwnlib.util.cyclic import cyclic
import pwndbg.gdblib.config import pwndbg.gdblib.config
import pwndbg.gdblib.memory import pwndbg.gdblib.memory
import pwndbg.gdblib.regs import pwndbg.gdblib.regs
import pwndbg.vmmap import pwndbg.gdblib.vmmap
import tests import tests
BINARY = tests.binaries.get("reference-binary.out") BINARY = tests.binaries.get("reference-binary.out")

2
tests/test_windbg.py
View File

@ -287,7 +287,7 @@ def test_windbg_eX_commands(start_binary):
######################################### #########################################
# e.g. when we make a write to the last stack address # e.g. when we make a write to the last stack address
stack_ea = pwndbg.gdblib.regs[pwndbg.gdblib.regs.stack] stack_ea = pwndbg.gdblib.regs[pwndbg.gdblib.regs.stack]
stack_page = pwndbg.vmmap.find(stack_ea) stack_page = pwndbg.gdblib.vmmap.find(stack_ea)
# Last possible address on stack where we can perform an 8-byte write # Last possible address on stack where we can perform an 8-byte write
stack_last_qword_ea = stack_page.end - 8 stack_last_qword_ea = stack_page.end - 8