nccgroup/libtalloclibtalloc è uno script Python per l'uso con GDB che può essere utilizzato per analizzare l'"allocatore banale" (talloc)
libtalloc è uno script python per l'uso con GDB che può essere utilizzato per analizzare l'"allocatore banale" (talloc). Un'introduzione su talloc si può trovare qui:
https://talloc.samba.org/talloc/doc/html/index.html
libtalloc è stato ispirato da altri script python per GDB per l'analisi di heap come unmask_jemalloc e libheap. Alcune funzionalità di base sono identiche a questi progetti.
https://github.com/cloudburst/libheap
https://github.com/argp/unmask_jemalloc
Tieni presente che non sono un guru di python e la qualità del codice lo rispecchia. Se vedi qualcosa che ti disgusta, sentiti libero di inviare una patch o darmi qualche suggerimento. Tutti i feedback sono benvenuti.
libtalloc è stato testato su diverse release 2.x di talloc e supporta il rilevamento dinamico della versione per cercare di superare le varie differenze strutturali tra le versioni. È stato testato su 32-bit e 64-bit, ma non in modo esaustivo, quindi non sorprenderti se ogni tanto si rompe.
È stato testato in una certa misura su x86 e x64:
Se lo provi su un'altra versione, per favore fammi sapere se ha funzionato o cosa si è rotto e cercherò di aggiornarlo e/o la documentazione di conseguenza.
Lo script richiede semplicemente una versione relativamente moderna di GDB con supporto python.
Alcune distro LTS, come Ubuntu 12.04, usano ancora GDB con python 2.7, mentre versioni più recenti come 14.04 usano python 3.0. Ho cercato di far funzionare questo script con entrambi, quindi dovresti solo dover:
(gdb) source libtalloc.py
La maggior parte delle funzionalità è modellata sull'approccio di unmask_jemalloc, dove viene fornito un comando GDB separato piuttosto che un complesso insieme di opzioni.
Sono disponibili diversi metodi progettati specificamente per imitare le funzioni C della libreria talloc, per aiutare le persone che cercano di estendere libtalloc se sono già familiari con la libreria.
Per vedere un elenco completo dei comandi puoi eseguire il comando tchelp:
(gdb) tchelp
[libtalloc] talloc commands for gdb
[libtalloc] tcchunk -v -x <addr> : show chunk contents (-v for verbose, -x for data dump)
[libtalloc] tcvalidate -a <addr> : validate chunk (-a for whole heap)
[libtalloc] tcsearch <addr> : search heap for hex value or address
[libtalloc] tcwalk <func> : walk whole heap calling func on every chunk
[libtalloc] tcreport <addr> : give talloc_report_full() info on memory context
[libtalloc] tcdump -s <addr> : dump chunks linked to memory context (-s for sorted by addr)
[libtalloc] tcparents <addr> : show all parents of chunk
[libtalloc] tcchildren <addr> : show all children of chunk
[libtalloc] tcinfo : show information known about heap
[libtalloc] tcprobe : try to collect information about talloc version
[libtalloc] tchelp : this help message
Uno dei comandi più importanti è tcprobe. Deve essere eseguito per capire quale versione di talloc è effettivamente installata. I layout delle strutture per le diverse versioni possono variare notevolmente, quindi per far funzionare la maggior parte delle funzioni la versione deve essere nota.
Se il comando funziona, dovrebbe comunicarti la versione rilevata:
(gdb) tcprobe
Version: 2.1.1
File: /usr/lib/libtalloc.so.2.1.1
Il comando tcinfo è pensato per mostrare quante più informazioni raccolte sull'heap possibile, come le informazioni di tcprobe, la struttura null_context se è stata trovata, e altro. Al momento mostra solo la versione e se null_context è impostato. null_context è richiesto per la maggior parte delle funzioni che attraversano la gerarchia reale, e per trovarlo la maggior parte delle altre funzionalità, come tchunk, ecc., proveranno a trovarlo automaticamente.
Dopo che tcprobe è stato eseguito ma prima che tchunk venga effettivamente usato:
(gdb) tcinfo [libtalloc] null_context not yet found yet [libtalloc] Version: 2.0.7 [libtalloc] File: /usr/lib/i386-linux-gnu/libtalloc.so.2.0.7
Poi dopo aver analizzato un chunk, in questo modo:
(gdb) tcchunk 0xb94a52b0 WARNING: 0xb94a52b0 not a talloc_chunk. Assuming ptr to chunk data 0xb94a5280 sz:0x0000003c, flags:...., name:struct tevent_context
Puoi confermare che è stato trovato dopo il fatto usando tcinfo.
(gdb) tcinfo [libtalloc] null_context: 0xb94a5028 [libtalloc] Version: 2.0.7 [libtalloc] File: /usr/lib/i386-linux-gnu/libtalloc.so.2.0.7
Ora che null_context è impostato potresti eseguire altri comandi che normalmente si lamenterebbero che non è impostato, come il comando tcsearch.
tcchunk può fornirti un riepilogo del chunk, un output più dettagliato di ogni campo, o informazioni estremamente dettagliate su ogni chunk circostante.
NOTA: Una cosa importante da notare su tcchunk è che internamente usa il metodo tc_chunk(), che tenta di correggere errori commessi passando l'indirizzo del chunk. In particolare, se passi l'indirizzo dei dati del chunk stesso, se non trova la magic di talloc attesa, cercherà un header di chunk legittimo leggermente prima in memoria. Questo può confonderti in scenari corrotti, quindi assicurati sempre di passare l'indirizzo esplicito a meno che tu non stia facendo un'analisi sommaria.
Output di riepilogo:
(gdb) tcchunk 0x80a13c88
0x80a13c88 sz:0x00000020, flags:..p., name:struct netr_ServerPasswordSet
La seguente è una legenda per i chunk nell'output di riepilogo:
p - Membro di un pool (flag POOLMEM)
P - Il chunk è un pool (flag POOL)
F - Il chunk è libero (flag FREE)
L - Il chunk è in loop (flag LOOP)
Output dettagliato:
(gdb) tcchunk -v 0x80a13c88
struct talloc_chunk @ 0x80a13c88 {
next = 0x0
prev = 0x80a140c8
parent = 0x0
child = 0x80a14088
refs = 0x0
destructor = 0x0
name = 0x807d9f2f (struct netr_ServerPasswordSet)
size = 0x20
flags = 0xe8150c78 (POOLMEM)
limit = 0x0
pool = 0x80a13248
I chunk di talloc contengono alcuni valori magici che possono essere usati per validare se sono sani. Il comando tcvalidate analizzerà un chunk per assicurarsi che la magic del chunk sia come previsto. Inoltre, analizza tutti gli altri membri puntatore per assicurarsi che ricadano effettivamente in intervalli di memoria (come noto a gdb), se la dimensione è valida, ecc.
(gdb) tcvalidate 0x80a13c88
Chunk header is valid
Useremo un metodo integrato per modificare un valore per mostrare come potrebbe fallire:
(gdb) python set_destructor(tc_chunk(0x80a13c88), 0x41414141)
(gdb) tcchunk -v 0x80a13c88
struct talloc_chunk @ 0x80a13c88 {
next = 0x0
prev = 0x80a140c8
parent = 0x0
child = 0x80a14088
refs = 0x0
destructor = 0x41414141
name = 0x807d9f2f (struct netr_ServerPasswordSet)
size = 0x20
flags = 0xe8150c78 (POOLMEM)
limit = 0x0
pool = 0x80a13248
(gdb) tcvalidate 0x80a13c88
Chunk header is invalid:
0x80a13c88: Chunk has bad destructor pointer 0x41414141
tcparents può essere usato per visualizzare tutti i genitori del chunk fornito:
(gdb) tcparents 0x80a13c88
0x809f8300: null_context
0x80a08660: TALLOC_CTX *
0x809f8370: talloc_new: ../lib/util/talloc_stack.c:147
0x809fb680: talloc_new: ../lib/util/talloc_stack.c:147
0x80a13258: UNNAMED
0x80a13c58: talloc_new: ../lib/util/talloc_stack.c:147
0x80a13c88: struct netr_ServerPasswordSet
tchildren può essere usato per visualizzare tutti i figli (e nipoti, ecc.) del chunk fornito:
(gdb) tcchildren 0x80a13c88
0x80a14088: struct netr_Authenticator
0x80a14048: librpc/gen_ndr/ndr_netlogon.c:10964
0x80a14008: librpc/gen_ndr/ndr_netlogon.c:10958
0x80a13fc8: librpc/gen_ndr/ndr_netlogon.c:10951
0x80a13f88: lib/charcnv.c:506
0x80a13ec8: lib/charcnv.c:506
0x80a13d48: librpc/gen_ndr/ndr_netlogon.c:10913
0x80a13e08:
0x80a13cd8: struct ndr_pull
0x80a13f48: struct ndr_token_list
0x80a13f08: struct ndr_token_list
0x80a13e88: struct ndr_token_list
0x80a13e48: struct ndr_token_list
0x80a13dc8: struct ndr_token_list
0x80a13d88: struct ndr_token_list
talloc ha il concetto di pool chunk. Sono fondamentalmente normali chunk talloc ma che vengono usati per allocare nuovi chunk invece di ripiegare sull'implementazione malloc() sottostante del sistema. Un pool chunk ha header leggermente diversi a seconda della versione usata, a volte usando padding, e a volte usando un header prefisso/suffisso.
tcpool può essere usato per analizzare l'header di un pool chunk, simile a tcchunk:
# First we find a pool to analyze
(gdb) tcchunk -v 0x80a13c88
struct talloc_chunk @ 0x80a13c88 {
next = 0x0
prev = 0x80a140c8
parent = 0x0
child = 0x80a14088
refs = 0x0
destructor = 0x0
name = 0x807d9f2f (struct netr_ServerPasswordSet)
size = 0x20
flags = 0xe8150c78 (POOLMEM)
limit = 0x0
pool = 0x80a13248
(gdb) tcpool -v 0x80a13248
struct talloc_pool_hdr @ 0x80a13248 {
end = 0x80a14108
object_count = 0x19
poolsize = 0x2000
struct talloc_chunk @ 0x80a13258 {
next = 0x0
prev = 0x0
parent = 0x809fb680
child = 0x80a13c58
refs = 0x0
destructor = 0x80429aa0
name = 0x0 (UNNAMED)
size = 0x0
flags = 0xe8150c74 (POOL)
limit = 0x0
pool = 0x0
Nel caso sopra il pool aveva un talloc_pool_hdr prefissato, che viene mostrato. L'opzione -l può essere passata a tcpool per elencare tutti i chunk allocati all'interno di un pool:
(gdb) tcpool -l 0x80a13248
Pool summary -- objects: 0x19, total size: 0x2000, space left: 0x1180, next free: 0x80a14108
0x80a13258 sz:0x00000000, flags:.P.., name:UNNAMED
0x80a13288 sz:0x000007a3, flags:..p., name:char
0x80a13a68 sz:0x0000005c, flags:..p., name:struct smb_request
0x80a13af8 sz:0x00000008, flags:..p., name:struct pipe_write_andx_state
0x80a13b38 sz:0x00000038, flags:..p., name:struct tevent_req
0x80a13ba8 sz:0x00000028, flags:..p., name:struct tevent_immediate
0x80a13c08 sz:0x00000014, flags:..p., name:struct np_write_state
0x80a13c58 sz:0x00000000, flags:..p., name:talloc_new: ../lib/util/talloc_stack.c:147
0x80a13c88 sz:0x00000020, flags:..p., name:struct netr_ServerPasswordSet
0x80a13cd8 sz:0x00000038, flags:..p., name:struct ndr_pull
0x80a13d48 sz:0x00000001, flags:..p., name:librpc/gen_ndr/ndr_netlogon.c:10913
0x80a13d88 sz:0x00000010, flags:..p., name:struct ndr_token_list
0x80a13dc8 sz:0x00000010, flags:..p., name:struct ndr_token_list
0x80a13e08 sz:0x00000001, flags:..p., name:
0x80a13e48 sz:0x00000010, flags:..p., name:struct ndr_token_list
0x80a13e88 sz:0x00000010, flags:..p., name:struct ndr_token_list
0x80a13ec8 sz:0x00000008, flags:..p., name:lib/charcnv.c:506
0x80a13f08 sz:0x00000010, flags:..p., name:struct ndr_token_list
0x80a13f48 sz:0x00000010, flags:..p., name:struct ndr_token_list
0x80a13f88 sz:0x00000008, flags:..p., name:lib/charcnv.c:506
0x80a13fc8 sz:0x0000000c, flags:..p., name:librpc/gen_ndr/ndr_netlogon.c:10951
0x80a14008 sz:0x00000010, flags:..p., name:librpc/gen_ndr/ndr_netlogon.c:10958
0x80a14048 sz:0x0000000c, flags:..p., name:librpc/gen_ndr/ndr_netlogon.c:10964
0x80a14088 sz:0x0000000c, flags:..p., name:struct netr_Authenticator
0x80a140c8 sz:0x0000000b, flags:..p., name:/etc/samba
Nota il flag P nell'output sopra, il chunk in cima è il pool chunk che contiene tutti i chunk sottostanti.
tcdump può essere usato per scaricare tutti i chunk dell'intero albero. Di default sono mostrati in ordine gerarchico, ma l'opzione -s può essere usata per ordinare l'output per indirizzo.
(gdb) tcdump -a 0x809f8300
0x809f8300 sz:0x00000000, flags:...., name:null_context
0x80a0b3f8 sz:0x0000000c, flags:...., name:struct handle_list
0x809ff178 sz:0x00000014, flags:...., name:struct security_token
0x80a089e8 sz:0x00000198, flags:...., name:lib/util_nttoken.c:50
0x80a07268 sz:0x00000188, flags:...., name:connection_struct
0x80a08bc8 sz:0x00000020, flags:...., name:struct fd_handle
0x80a00c30 sz:0x000000f0, flags:...., name:struct files_struct
0x80a083b8 sz:0x00000008, flags:...., name:struct fake_file_handle
0x80a08c20 sz:0x0000009c, flags:...., name:struct pipes_struct
0x80a07900 sz:0x00000760, flags:...., name:uint8_t
0x80a07428 sz:0x000000c0, flags:...., name:struct auth_serversupplied_info
0x80a06390 sz:0x00000001, flags:...., name:
0x80a06350 sz:0x00000007, flags:...., name:nobody
0x80a06158 sz:0x000000cc, flags:...., name:struct netr_SamInfo3
0x80a062d8 sz:0x00000044, flags:...., name:struct dom_sid
[SNIP]
tcreport è un comando simile a tcdump ma abbellisce un po' l'output ed è pensato per imitare la funzione di debug talloc_report_full() fornita dalla stessa libreria talloc.
(gdb) tcreport 0x80a0b3f8 -a
Full talloc report on 'null_context' (total 558651 bytes in 446 blocks)
struct handle_list contains 12 bytes in 1 blocks (ref 67) 0x80a0b3f8
struct security_token contains 428 bytes in 2 blocks (ref 66) 0x809ff178
lib/util_nttoken.c:50 contains 408 bytes in 1 blocks (ref 0) 0x80a089e8
connection_struct contains 531071 bytes in 36 blocks (ref 65) 0x80a07268
struct fd_handle contains 32 bytes in 1 blocks (ref 4) 0x80a08bc8
struct files_struct contains 529681 bytes in 22 blocks (ref 3) 0x80a00c30
struct fake_file_handle contains 529308 bytes in 19 blocks (ref 1) 0x80a083b8
struct pipes_struct contains 529300 bytes in 18 blocks (ref 0) 0x80a08c20
uint8_t contains 1888 bytes in 1 blocks (ref 2) 0x80a07900
struct auth_serversupplied_info contains 934 bytes in 10 blocks (ref 1) 0x80a07428
contains 1 bytes in 1 blocks (ref 4) 0x80a06390
nobody contains 7 bytes in 1 blocks (ref 3) 0x80a06350
struct netr_SamInfo3 contains 290 bytes in 4 blocks (ref 2) 0x80a06158
[SNIP]
Ci sono due comandi per la ricerca: tcsearch e tcfindaddr.
tcsearch può essere usato per trovare chunk che contengono il valore esadecimale fornito. Funziona attraversando l'intera gerarchia dell'albero a partire da null_context (se noto), o da un chunk iniziale fornito.
(gdb) python set_destructor(tc_chunk(0x80a13c88), 0x41414141)
(gdb) tcsearch 0x41414141 0x809f8300
[libtalloc] 0x41414141 found in chunk at 0x80a1d218
[libtalloc] 0x41414141 found in chunk at 0x80a13c88
(gdb) tcchunk -v 0x80a1d218
struct talloc_chunk @ 0x80a1d218 {
next = 0x80a00158
prev = 0x809fb0c8
parent = 0x0
child = 0x0
refs = 0x0
destructor = 0x0
name = 0x8071fcbd (uint8_t)
size = 0x80050
flags = 0xe8150c70 ()
limit = 0x0
pool = 0x0
(gdb) tcchunk -x 0x80a1d218
0x80a1d218 sz:0x00080050, flags:...., name:uint8_t
Chunk data (524368 bytes):
0x80a1d248: 0x41414141 0x00000000 0x00000000 0x00000000
0x80a1d258: 0x00000001 0x00000000 0x00000001 0x00020000
0x80a1d268: 0x00000001 0x00000000 0x00000001 0xaaaa0000
[SNIP]
(gdb) tcchunk -v 0x80a13c88
struct talloc_chunk @ 0x80a13c88 {
next = 0x0
prev = 0x80a140c8
parent = 0x0
child = 0x80a14088
refs = 0x0
destructor = 0x41414141
name = 0x807d9f2f (struct netr_ServerPasswordSet)
size = 0x20
flags = 0xe8150c78 (POOLMEM)
limit = 0x0
pool = 0x80a13248
tcfindaddr può essere usato per determinare se un indirizzo ricade all'interno dei limiti di un chunk nell'albero talloc. Diciamo che sai che 0x80a1d3280 contiene alcuni dati che controlli, quindi vuoi vedere se ricade in un chunk. Nota che il secondo indirizzo è null_context, ma può essere qualsiasi chunk che ci permetta di trovare la cima dell'heap.
(gdb) tcfindaddr 0x80a1d328 0x809f8300
[libtalloc] address 0x80a1d328 falls within chunk @ 0x80a1d218 (size 0x80050)
Parte della ricerca nell'albero viene fatta usando una funzione ricorsiva che ho esposto tramite il comando tcwalk. È una funzione di supporto che ti permette di specificare un metodo python che verrà chiamato su ogni chunk scoperto nell'albero.
Nell'esempio seguente chiameremo il metodo di validazione dell'heap su ogni chunk nell'heap per vedere se qualcosa è corrotto.
(gdb) tcwalk validate_chunk
0x80a13c88: Chunk has bad destructor pointer 0x41414141
Nota che se null_context non è stato impostato devi passare un indirizzo di chunk come secondo argomento.
Scritto da Aaron Adams
Email: aaron (dot) adams (at) nccgroup (dot) trust
Twitter: @fidgetingbits