commands ¤

Modules:

• ai –

  This command sends information on the current debugging context to OpenAI's

• argv –
• aslr –
• asm –
• attachp –
• auxv –
• binder –
• binja –
• binja_functions –
• branch –
• canary –
• checksec –
• comments –
• config –

  Dumps all pwndbg-specific configuration points.

• context –
• cpsr –
• cyclic –
• cymbol –

  Add, load, show, edit, or delete symbols for custom structures.

• dev –
• distance –
• dt –
• dumpargs –
• elf –
• flags –
• gdt –
• ghidra –
• godbg –
• got –
• got_tracking –
• hex2ptr –
• hexdump –
• hijack_fd –
• ida –
• ignore –

  Ignoring a breakpoint

• integration –
• ipython_interactive –

  Command to start an interactive IPython prompt.

• jemalloc –
• kbase –
• kchecksec –
• kcmdline –
• kconfig –
• killthreads –
• klookup –
• knft –
• kversion –
• leakfind –

  Find a chain of leaks given some starting address.

• libcinfo –
• linkmap –
• memoize –
• misc –
• mmap –
• mprotect –
• nearpc –
• next –

  Stepping until an event occurs

• onegadget –
• p2p –
• patch –
• pcplist –
• peda –
• pie –
• plist –
• probeleak –
• procinfo –
• profiler –

  Utilities for profiling pwndbg.

• ptmalloc2 –
• ptmalloc2_tracking –
• radare2 –
• reload –
• retaddr –
• rizin –
• rop –
• ropper –
• search –
• segments –
• shell –

  Wrapper for shell commands.

• sigreturn –
• slab –

  Commands for dealing with Linux kernel slab allocator. Currently, only SLUB is supported.

• spray –
• start –

  Launches the target process after setting a breakpoint at a convenient

• strings –
• telescope –

  Prints out pointer chains starting at some address in memory.

• tips –
• tls –

  Command to print the information of the current Thread Local Storage (TLS).

• valist –
• version –

  Implements version and bugreport commands.

• vmmap –

  Command to print the virtual memory map a la /proc/self/maps.

• windbg –

  Compatibility functionality for Windbg users.

• xinfo –
• xor –

Classes:

• CommandCategory –
• Command –

  Generic command wrapper

• ArgparsedCommand –

  Adds documentation and offloads parsing for a Command via argparse

Functions:

• fix –

  Fix a single command-line argument coming from the CLI.

• fix_reraise –
• fix_reraise_arg –

  fix_reraise wrapper for evaluating command arguments

• fix_int –
• fix_int_reraise –
• fix_int_reraise_arg –

  fix_int_reraise wrapper for evaluating command arguments

• func_name –
• OnlyWhenLocal –
• OnlyWithFile –
• OnlyWhenQemuKernel –
• OnlyWhenUserspace –
• OnlyWithKernelDebugSyms –
• OnlyWhenPagingEnabled –
• OnlyWhenRunning –
• OnlyWithTcache –
• OnlyWhenHeapIsInitialized –
• OnlyWithResolvedHeapSyms –
• sloppy_gdb_parse –

  This function should be used as argparse.ArgumentParser .add_argument method's type helper.

• AddressExpr –

  Parses an address expression. Returns an int.

• HexOrAddressExpr –

  Parses string as hexadecimal int or an address expression. Returns an int.

• load_commands –

Attributes:

• log –
• T –
• P –
• commands (list[Command]) –
• command_names (set[str]) –
• GDB_BUILTIN_COMMANDS –
• pwndbg_is_reloading –

log = getLogger(__name__)

T = TypeVar('T')

P = ParamSpec('P')

commands: list[Command] = []

command_names: set[str] = set()

GDB_BUILTIN_COMMANDS = commands()

pwndbg_is_reloading = False

START = 'Start'

NEXT = 'Step/Next/Continue'

CONTEXT = 'Context'

PTMALLOC2 = 'GLibc ptmalloc2 Heap'

JEMALLOC = 'jemalloc Heap'

BREAKPOINT = 'Breakpoint'

MEMORY = 'Memory'

STACK = 'Stack'

REGISTER = 'Register'

PROCESS = 'Process'

LINUX = 'Linux/libc/ELF'

DISASS = 'Disassemble'

MISC = 'Misc'

KERNEL = 'Kernel'

INTEGRATIONS = 'Integrations'

WINDBG = 'WinDbg'

PWNDBG = 'pwndbg'

SHELL = 'Shell'

DEV = 'Developer'

Command(
    function: Callable[..., str | None],
    prefix: bool = False,
    command_name: str | None = None,
    shell: bool = False,
    is_alias: bool = False,
    aliases: list[str] = [],
    category: CommandCategory = MISC,
    doc: str | None = None,
)

builtin_override_whitelist: set[str] = {
    "up",
    "down",
    "search",
    "pwd",
    "start",
    "starti",
    "ignore",
}

history: dict[int, str] = {}

is_alias = is_alias

aliases = aliases

category = category

shell = shell

doc = doc

handle = add_command(command_name, _handler, doc)

function = function

__name__ = command_name

repeat = False

split_args(argument: str) -> tuple[list[str], dict[Any, Any]]

invoke(argument: str, from_tty: bool) -> None

check_repeated(argument: str, from_tty: bool) -> bool

__call__(*args: Any, **kwargs: Any) -> str | None

ArgparsedCommand(
    parser_or_desc: str | ArgumentParser,
    category: CommandCategory,
    command_name: str | None = None,
    aliases: list[str] = [],
    only_debuggers: set[DebuggerType] = None,
    exclude_debuggers: set[DebuggerType] = None,
)

parser = ArgumentParser(description=parser_or_desc)

aliases = aliases

category = category

only_debuggers = only_debuggers

exclude_debuggers = exclude_debuggers

__call__(function: Callable[..., Any]) -> _ArgparsedCommand

fix(
    arg: str | Value,
    sloppy: bool = False,
    quiet: bool = True,
    reraise: bool = False,
) -> str | Value | None

fix_reraise(*a, **kw) -> str | Value | None

fix_reraise_arg(arg) -> Value

fix_int(*a, **kw) -> int

fix_int_reraise(*a, **kw) -> int

fix_int_reraise_arg(arg) -> int

func_name(function: Callable[P, T]) -> str

OnlyWhenLocal(function: Callable[P, T]) -> Callable[P, T | None]

OnlyWithFile(function: Callable[P, T]) -> Callable[P, T | None]

OnlyWhenQemuKernel(function: Callable[P, T]) -> Callable[P, T | None]

OnlyWhenUserspace(function: Callable[P, T]) -> Callable[P, T | None]

OnlyWithKernelDebugSyms(function: Callable[P, T]) -> Callable[P, T | None]

OnlyWhenPagingEnabled(function: Callable[P, T]) -> Callable[P, T | None]

OnlyWhenRunning(function: Callable[P, T]) -> Callable[P, T | None]

OnlyWithTcache(function: Callable[P, T]) -> Callable[P, T | None]

OnlyWhenHeapIsInitialized(
    function: Callable[P, T],
) -> Callable[P, T | None]

OnlyWithResolvedHeapSyms(function: Callable[P, T]) -> Callable[P, T | None]

sloppy_gdb_parse(s: str) -> int | str

AddressExpr(s: str) -> int

HexOrAddressExpr(s: str) -> int

load_commands() -> None