python - Volcado de memoria formateado como xxd desde gdb

debugging pretty-print

Question

Estoy intentando inspeccionar un buffer que contiene un mensaje con formato binario, pero también contiene datos de cadena. Como ejemplo, estoy usando este código C:

int main (void) {
    char buf[100] = "/x01/x02/x03/x04String Data/xAA/xBB/xCC";

    return 0;
}

Me gustaría obtener un volcado hexadecimal de lo que está en buf , de un formato similar a xxd (no me importa si es una coincidencia exacta, lo que realmente estoy buscando es un volcado hexadecimal al lado del otro con caracteres imprimibles) .

Dentro de GDB puedo usar algo como:

(gdb) x /100bx buf
0x7fffffffdf00: 0x01    0x02    0x03    0x04    0x53    0x74    0x72    0x69
0x7fffffffdf08: 0x6e    0x67    0x20    0x44    0x61    0x74    0x61    0xaa
0x7fffffffdf10: 0xbb    0xcc    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf18: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf20: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf28: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf30: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf38: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf40: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf48: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf50: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x7fffffffdf58: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00

lo cual está bien, pero es difícil elegir cadenas de esa manera ... o puedo usar

(gdb) x /100bs buf
0x7fffffffdf00:  "/001/002/003/004String Data/252/273/314"
0x7fffffffdf13:  ""
0x7fffffffdf14:  ""
0x7fffffffdf15:  ""
0x7fffffffdf16:  ""
0x7fffffffdf17:  ""
...

lo que hace que sea difícil leer la parte binaria ... los mensajes reales con los que estoy lidiando tienen un montón de ascii nul también, así que realmente parece un desastre.

Lo mejor que se me ocurre es hacer esto:

(gdb) dump binary memory dump.bin buf buf+100

y entonces

$ xxd dump.bin
0000000: 0102 0304 5374 7269 6e67 2044 6174 61aa  ....String Data.
0000010: bbcc 0000 0000 0000 0000 0000 0000 0000  ................
0000020: 0000 0000 0000 0000 0000 0000 0000 0000  ................
0000030: 0000 0000 0000 0000 0000 0000 0000 0000  ................
0000040: 0000 0000 0000 0000 0000 0000 0000 0000  ................
0000050: 0000 0000 0000 0000 0000 0000 0000 0000  ................
0000060: 0000 0000                                ....

pero eso es un dolor hacer eso cada vez. Pensé que alguien por ahí quería esto antes, así que me pregunto si alguien ha encontrado la manera de hacerlo dentro de gdb. Además, pierde las direcciones de la memoria original de esta manera.

Estoy usando GDB 7.4 con soporte de python integrado, por lo que estoy abierto a la idea de usar una impresora bonita o similar, pero no sé cómo configurarlo.

Answer 1

Desafortunadamente, las versiones de @ FatalError y @ gunthor no me funcionaron, así que escribí otra más. Así es como esto luce:

(gdb) xxd hello_string 0xc
00000001_00000f87:                  48 656c 6c6f 0957 6f72         Hello.Wor
00000001_00000f90: 6c64 0a                                  ld.

Las versiones más recientes de xxd admiten el indicador -o que permite especificar un desplazamiento para agregar al visualizado (que siempre comenzará en 0000000 ).

En caso de que xxd -o no esté disponible, aquí hay un sustituto que se alinea correctamente y muestra la dirección de la ubicación que es xxd ''d.

El comando xxd :

define xxd
    dump binary memory /tmp/dump.bin $arg0 $arg0+$arg1
    eval "shell xxd-o %p /tmp/dump.bin", $arg0
end

La secuencia de comandos de perl posiblemente feo xxd-o ( xxd con desplazamiento):

#!/usr/bin/env perl
use IPC::Open2; 
$SIG{''__WARN__''} = sub{ die "$0: $!/n" };

my $offset = shift // "0";
$offset = oct($offset) if $offset =~ /^0/;
my $base = $offset >= 2**32 ? 16 : 8;

my $zeroes = $offset % 16;
my $padding = 1 + int($zeroes / 2) + 2*$zeroes;
my $bytestr = "/0" x $zeroes;
{ local $/; $bytestr .= <> }

open2(/*XXD_OUT, /*XXD_IN, "xxd") or die "xxd is not available!";
print XXD_IN $bytestr; close XXD_IN;

if ($zeroes) {
    $_ = <XXD_OUT>;
    s/^(.{50}).{$zeroes}/$1 . ('' '' x $zeroes)/ge;
    s/^([[:xdigit:]]+:).{$padding}/$1 . ('' '' x $padding)/ge;
    my $newoff = sprintf("%0${base}x",hex($1)+$offset) =~ s/^(.{8})(.{8})$/$1_$2/r;
    s/^([[:xdigit:]]+):/$newoff:/g;
    print
}
while (<XXD_OUT>) {
    s/^([[:xdigit:]]+)(?=:)/sprintf("%0${base}x", hex($1)+$offset-$offset%16) =~ s[^(.{8})(.{8})$][$1_$2]r/ge;
    print
}

Mejoras bienvenidas! :-)

Answer 2

Entonces, terminé jugando con la interfaz de python y se me ocurrió esto:

import gdb
from curses.ascii import isgraph

def groups_of(iterable, size, first=0):
    first = first if first != 0 else size
    chunk, iterable = iterable[:first], iterable[first:]
    while chunk:
        yield chunk
        chunk, iterable = iterable[:size], iterable[size:]

class HexDump(gdb.Command):
    def __init__(self):
        super (HexDump, self).__init__ (''hex-dump'', gdb.COMMAND_DATA)

    def invoke(self, arg, from_tty):
        argv = gdb.string_to_argv(arg)
        if len(argv) != 2:
            raise gdb.GdbError(''hex-dump takes exactly 2 arguments.'')
        addr = gdb.parse_and_eval(argv[0]).cast(
            gdb.lookup_type(''void'').pointer())
        try:
            bytes = int(gdb.parse_and_eval(argv[1]))
        except ValueError:
            raise gdb.GdbError(''Byte count numst be an integer value.'')

        inferior = gdb.selected_inferior()

        align = gdb.parameter(''hex-dump-align'')
        width = gdb.parameter(''hex-dump-width'')
        if width == 0:
            width = 16

        mem = inferior.read_memory(addr, bytes)
        pr_addr = int(str(addr), 16)
        pr_offset = width

        if align:
            pr_offset = width - (pr_addr % width)
            pr_addr -= pr_addr % width

        for group in groups_of(mem, width, pr_offset):
            print ''0x%x: '' % (pr_addr,) + ''   ''*(width - pr_offset),
            print '' ''.join([''%02X'' % (ord(g),) for g in group]) + /
                ''   '' * (width - len(group) if pr_offset == width else 0) + '' '',
            print '' ''*(width - pr_offset) +  ''''.join(
                [g if isgraph(g) or g == '' '' else ''.'' for g in group])
            pr_addr += width
            pr_offset = width

class HexDumpAlign(gdb.Parameter):
    def __init__(self):
        super (HexDumpAlign, self).__init__(''hex-dump-align'',
                                            gdb.COMMAND_DATA,
                                            gdb.PARAM_BOOLEAN)

    set_doc = ''Determines if hex-dump always starts at an "aligned" address (see hex-dump-width''
    show_doc = ''Hex dump alignment is currently''

class HexDumpWidth(gdb.Parameter):
    def __init__(self):
        super (HexDumpWidth, self).__init__(''hex-dump-width'',
                                            gdb.COMMAND_DATA,
                                            gdb.PARAM_INTEGER)

    set_doc = ''Set the number of bytes per line of hex-dump''

    show_doc = ''The number of bytes per line in hex-dump is''

HexDump()
HexDumpAlign()
HexDumpWidth()

Me doy cuenta de que puede que no sea la solución más bella y elegante, pero hace el trabajo y funciona como un primer borrador. Podría incluirse en ~/.gdbinit como:

python
sys.path.insert(0, ''/path/to/module/dir'')
import hexdump
end

Entonces podría ser utilizado con el programa anterior como así:

(gdb) hex-dump buf 100
0x7fffffffdf00:  01 02 03 04 53 74 72 69 6E 67 20 44 61 74 61 AA  ....String Data.
0x7fffffffdf10:  BB CC 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf20:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf30:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf40:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf50:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf60:  00 00 00 00                                      ....

Y algunos otros toques para una buena medida:

(gdb) set hex-dump-align on
Determines if hex-dump always starts at an "aligned" address (see hex-dump-width
(gdb) hex-dump &buf[5] 95
0x7fffffffdf00:                 74 72 69 6E 67 20 44 61 74 61 AA       tring Data.
0x7fffffffdf10:  BB CC 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf20:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf30:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf40:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf50:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x7fffffffdf60:  00 00 00 00                                      ....

(gdb) set hex-dump-width 8
Set the number of bytes per line of hex-dump
(gdb) hex-dump &buf[5] 95
0x7fffffffdf00:                 74 72 69       tri
0x7fffffffdf08:  6E 67 20 44 61 74 61 AA  ng Data.
0x7fffffffdf10:  BB CC 00 00 00 00 00 00  ........
0x7fffffffdf18:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf20:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf28:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf30:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf38:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf40:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf48:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf50:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf58:  00 00 00 00 00 00 00 00  ........
0x7fffffffdf60:  00 00 00 00              ....

No hay promesas de que no haya errores :). Podría ponerlo en github o algo si la gente está interesada.

Solo lo he probado con GDB 7.4.

Answer 3

una versión adaptada de la solución de User FatalError

• funciona con python 3
• agregado un encabezado hex-col-header
• parámetro de longitud opcional
• renombrado a hd

ejemplos

hd 0xbfffe4f1

hd 0xbfffe4f1 500

import gdb
from curses.ascii import isgraph

def groups_of(iterable, size, first=0):
    first = first if first != 0 else size
    chunk, iterable = iterable[:first], iterable[first:]
    while chunk:
        yield chunk
        chunk, iterable = iterable[:size], iterable[size:]

class HexDump(gdb.Command):
    def __init__(self):
        super (HexDump, self).__init__ (''hd'', gdb.COMMAND_DATA)

    def invoke(self, arg, from_tty):
        argv = gdb.string_to_argv(arg)

        addr = gdb.parse_and_eval(argv[0]).cast(
            gdb.lookup_type(''void'').pointer())
        if len(argv) == 2:
             try:
                 bytes = int(gdb.parse_and_eval(argv[1]))
             except ValueError:
                 raise gdb.GdbError(''Byte count numst be an integer value.'')
        else:
             bytes = 500

        inferior = gdb.selected_inferior()

        align = gdb.parameter(''hex-dump-align'')
        width = gdb.parameter(''hex-dump-width'')
        if width == 0:
            width = 16

        mem = inferior.read_memory(addr, bytes)
        pr_addr = int(str(addr), 16)
        pr_offset = width

        if align:
            pr_offset = width - (pr_addr % width)
            pr_addr -= pr_addr % width
        start=(pr_addr) & 0xff;


        print (''            '' , end="")
        print (''  ''.join([''%01X'' % (i&0x0f,) for i in range(start,start+width)]) , end="")
        print (''  '' , end="")       
        print ('' ''.join([''%01X'' % (i&0x0f,) for i in range(start,start+width)]) )

        for group in groups_of(mem, width, pr_offset):
            print (''0x%x: '' % (pr_addr,) + ''   ''*(width - pr_offset), end="")
            print ('' ''.join([''%02X'' % (ord(g),) for g in group]) + /
                ''   '' * (width - len(group) if pr_offset == width else 0) + '' '', end="")    
            print ('' ''*(width - pr_offset) +  '' ''.join(
                [chr( int.from_bytes(g, byteorder=''big'')) if isgraph( int.from_bytes(g, byteorder=''big'')   ) or g == '' '' else ''.'' for g in group]))
            pr_addr += width
            pr_offset = width

class HexDumpAlign(gdb.Parameter):
    def __init__(self):
        super (HexDumpAlign, self).__init__(''hex-dump-align'',
                                            gdb.COMMAND_DATA,
                                            gdb.PARAM_BOOLEAN)

    set_doc = ''Determines if hex-dump always starts at an "aligned" address (see hex-dump-width''
    show_doc = ''Hex dump alignment is currently''

class HexDumpWidth(gdb.Parameter):
    def __init__(self):
        super (HexDumpWidth, self).__init__(''hex-dump-width'',
                                            gdb.COMMAND_DATA,
                                            gdb.PARAM_INTEGER)

    set_doc = ''Set the number of bytes per line of hex-dump''

    show_doc = ''The number of bytes per line in hex-dump is''

HexDump()
HexDumpAlign()
HexDumpWidth()

Answer 4

(gdb) define xxd
>dump binary memory dump.bin $arg0 $arg0+$arg1
>shell xxd dump.bin
>end
(gdb) xxd &j 10 
0000000: 0000 0000 0000 0000 0000 0000 4d8c a7f7  ............M...
0000010: ff7f 0000 0000 0000 0000 0000 c8d7 ffff  ................
0000020: ff7f 0000 0000 0000

Parece bastante fácil ;-)

Es probable que pueda escribir un script de Python (las versiones modernas de GDB tienen incorporado el intérprete de Python) para hacer lo mismo y deshacerse de la necesidad de "pagar".