Skip to content

Commit fc67346

Browse files
BasstormBasstorm
committed
Totally rewrite PDB parser
1 parent d505032 commit fc67346

25 files changed

+2769
-5546
lines changed

‎librz/analysis/type_pdb.c

+249-231
Large diffs are not rendered by default.

‎librz/bin/meson.build

+3-3
Original file line numberDiff line numberDiff line change
@@ -147,12 +147,10 @@ rz_bin_sources = [
147147
'mangling/swift.c',
148148

149149
'pdb/dbi.c',
150-
'pdb/fpo.c',
151150
'pdb/gdata.c',
152151
'pdb/omap.c',
153152
'pdb/pdb.c',
154153
'pdb/pdb_downloader.c',
155-
'pdb/stream_file.c',
156154
'pdb/stream_pe.c',
157155
'pdb/tpi.c'
158156
]
@@ -172,6 +170,7 @@ rz_bin = library('rz_bin', rz_bin_sources,
172170
rz_syscall_dep,
173171
rz_cons_dep,
174172
rz_io_dep,
173+
rz_type_dep,
175174
],
176175
install: true,
177176
implicit_include_directories: false,
@@ -192,7 +191,8 @@ pkgconfig_mod.generate(rz_bin,
192191
'rz_util',
193192
'rz_io',
194193
'rz_socket',
195-
'rz_syscall'
194+
'rz_syscall',
195+
'rz_type'
196196
],
197197
description: 'rizin foundation libraries'
198198
)

‎librz/bin/pdb/dbi.c

+106-147
Original file line numberDiff line numberDiff line change
@@ -1,164 +1,123 @@
11
// SPDX-FileCopyrightText: 2014-2020 inisider <[email protected]>
2+
// SPDX-FileCopyrightText: 2021 Basstorm <[email protected]>
23
// SPDX-License-Identifier: LGPL-3.0-only
34

4-
#include "types.h"
5-
#include "dbi.h"
6-
#include "stream_file.h"
7-
#include "tpi.h"
5+
#include "pdb.h"
86

9-
#define PDB_ALIGN 4
10-
11-
static void free_dbi_stream(void *stream) {
12-
SDbiStream *t = (SDbiStream *)stream;
13-
SDBIExHeader *dbi_ex_header = 0;
14-
15-
RzListIter *it = rz_list_iterator(t->dbiexhdrs);
16-
while (rz_list_iter_next(it)) {
17-
dbi_ex_header = (SDBIExHeader *)rz_list_iter_get(it);
18-
free(dbi_ex_header->modName.name);
19-
free(dbi_ex_header->objName.name);
20-
free(dbi_ex_header);
7+
RZ_IPI void rz_bin_pdb_free_dbi_stream(DbiStream *stream) {
8+
DbiStreamExHdr *ex_hdr;
9+
RzListIter *it;
10+
rz_list_foreach (stream->ex_hdrs, it, ex_hdr) {
11+
RZ_FREE(ex_hdr->ModuleName);
12+
RZ_FREE(ex_hdr->ObjFileName);
13+
RZ_FREE(ex_hdr);
2114
}
22-
rz_list_free(t->dbiexhdrs);
23-
}
24-
25-
static void parse_dbi_header(SDBIHeader *dbi_header, RZ_STREAM_FILE *stream_file) {
26-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->magic);
27-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->version);
28-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->age);
29-
stream_file_read(stream_file, sizeof(ut16), (char *)&dbi_header->gssymStream);
30-
stream_file_read(stream_file, sizeof(ut16), (char *)&dbi_header->vers);
31-
stream_file_read(stream_file, sizeof(st16), (char *)&dbi_header->pssymStream);
32-
stream_file_read(stream_file, sizeof(ut16), (char *)&dbi_header->pdbver);
33-
stream_file_read(stream_file, sizeof(st16), (char *)&dbi_header->symrecStream);
34-
stream_file_read(stream_file, sizeof(ut16), (char *)&dbi_header->pdbver2);
35-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->module_size);
36-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->seccon_size);
37-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->secmap_size);
38-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->filinf_size);
39-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->tsmap_size);
40-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->mfc_index);
41-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->dbghdr_size);
42-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->ecinfo_size);
43-
stream_file_read(stream_file, sizeof(ut16), (char *)&dbi_header->flags);
44-
stream_file_read(stream_file, 2, (char *)&dbi_header->machine);
45-
stream_file_read(stream_file, sizeof(ut32), (char *)&dbi_header->resvd);
15+
rz_list_free(stream->ex_hdrs);
4616
}
4717

48-
static int parse_ssymbol_range(char *data, int max_len, SSymbolRange *symbol_range) {
49-
int read_bytes = 0;
50-
51-
READ2(read_bytes, max_len, symbol_range->section, data, st16);
52-
READ2(read_bytes, max_len, symbol_range->padding1, data, st16);
53-
READ4(read_bytes, max_len, symbol_range->offset, data, st32);
54-
READ4(read_bytes, max_len, symbol_range->size, data, st32);
55-
READ4(read_bytes, max_len, symbol_range->flags, data, ut32);
56-
READ4(read_bytes, max_len, symbol_range->module, data, st32);
57-
58-
// TODO: why not need to read this padding?
59-
// READ2(read_bytes, max_len, symbol_range->padding2, data, short);
60-
READ4(read_bytes, max_len, symbol_range->data_crc, data, ut32);
61-
READ4(read_bytes, max_len, symbol_range->reloc_crc, data, ut32);
62-
63-
return read_bytes;
18+
static void parse_dbi_stream_header(DbiStream *s, RzBuffer *buf) {
19+
s->hdr.version_signature = rz_buf_read_le32(buf);
20+
s->hdr.version_header = rz_buf_read_le32(buf);
21+
s->hdr.age = rz_buf_read_le32(buf);
22+
s->hdr.global_stream_index = rz_buf_read_le16(buf);
23+
s->hdr.build_number = rz_buf_read_le16(buf);
24+
s->hdr.public_stream_index = rz_buf_read_le16(buf);
25+
s->hdr.pdb_dll_version = rz_buf_read_le16(buf);
26+
s->hdr.sym_record_stream = rz_buf_read_le16(buf);
27+
s->hdr.pdb_dll_rbld = rz_buf_read_le16(buf);
28+
s->hdr.mod_info_size = rz_buf_read_le32(buf);
29+
s->hdr.section_contribution_size = rz_buf_read_le32(buf);
30+
s->hdr.section_map_size = rz_buf_read_le32(buf);
31+
s->hdr.source_info_size = rz_buf_read_le32(buf);
32+
s->hdr.type_server_map_size = rz_buf_read_le32(buf);
33+
s->hdr.mfc_type_server_index = rz_buf_read_le32(buf);
34+
s->hdr.optional_dbg_header_size = rz_buf_read_le32(buf);
35+
s->hdr.ec_substream_size = rz_buf_read_le32(buf);
36+
s->hdr.flags = rz_buf_read_le16(buf);
37+
s->hdr.machine = rz_buf_read_le16(buf);
38+
s->hdr.padding = rz_buf_read_le32(buf);
6439
}
6540

66-
static int parse_dbi_ex_header(char *data, int max_len, SDBIExHeader *dbi_ex_header) {
67-
ut32 read_bytes = 0, before_read_bytes = 0;
68-
69-
READ4(read_bytes, max_len, dbi_ex_header->opened, data, ut32);
70-
71-
before_read_bytes = read_bytes;
72-
read_bytes += parse_ssymbol_range(data, max_len, &dbi_ex_header->range);
73-
data += (read_bytes - before_read_bytes);
74-
75-
READ2(read_bytes, max_len, dbi_ex_header->flags, data, ut16);
76-
READ2(read_bytes, max_len, dbi_ex_header->stream, data, st16);
77-
READ4(read_bytes, max_len, dbi_ex_header->symSize, data, ut32);
78-
READ4(read_bytes, max_len, dbi_ex_header->oldLineSize, data, ut32);
79-
READ4(read_bytes, max_len, dbi_ex_header->lineSize, data, ut32);
80-
READ2(read_bytes, max_len, dbi_ex_header->nSrcFiles, data, st16);
81-
READ2(read_bytes, max_len, dbi_ex_header->padding1, data, st16);
82-
READ4(read_bytes, max_len, dbi_ex_header->offsets, data, ut32);
83-
READ4(read_bytes, max_len, dbi_ex_header->niSource, data, ut32);
84-
READ4(read_bytes, max_len, dbi_ex_header->niCompiler, data, ut32);
85-
86-
before_read_bytes = read_bytes;
87-
parse_scstring(&dbi_ex_header->modName, (unsigned char *)data, &read_bytes, max_len);
88-
data += (read_bytes - before_read_bytes);
89-
90-
parse_scstring(&dbi_ex_header->objName, (unsigned char *)data, &read_bytes, max_len);
91-
92-
return read_bytes;
41+
static ut32 parse_dbi_stream_section_entry(DbiStreamExHdr *hdr, RzBuffer *buf) {
42+
hdr->SectionContr.Section = rz_buf_read_le16(buf);
43+
*(ut16 *)hdr->SectionContr.Padding1 = rz_buf_read_le16(buf);
44+
hdr->SectionContr.Offset = rz_buf_read_le32(buf);
45+
hdr->SectionContr.Size = rz_buf_read_le32(buf);
46+
hdr->SectionContr.Characteristics = rz_buf_read_le32(buf);
47+
hdr->SectionContr.ModuleIndex = rz_buf_read_le16(buf);
48+
*(ut16 *)hdr->SectionContr.Padding2 = rz_buf_read_le16(buf);
49+
hdr->SectionContr.DataCrc = rz_buf_read_le32(buf);
50+
hdr->SectionContr.RelocCrc = rz_buf_read_le32(buf);
51+
return sizeof(hdr->SectionContr);
9352
}
9453

95-
static void parse_dbg_header(SDbiDbgHeader *dbg_header, RZ_STREAM_FILE *stream_file) {
96-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_fpo);
97-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_exception);
98-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_fixup);
99-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_omap_to_src);
100-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_omap_from_src);
101-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_section_hdr);
102-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_token_rid_map);
103-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_xdata);
104-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_pdata);
105-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_new_fpo);
106-
stream_file_read(stream_file, sizeof(short), (char *)&dbg_header->sn_section_hdr_orig);
107-
}
108-
109-
void init_dbi_stream(SDbiStream *dbi_stream) {
110-
dbi_stream->free_ = free_dbi_stream;
111-
}
112-
113-
void parse_dbi_stream(void *parsed_pdb_stream, RZ_STREAM_FILE *stream_file) {
114-
SDbiStream *dbi_stream = (SDbiStream *)parsed_pdb_stream;
115-
SDBIExHeader *dbi_ex_header = 0;
116-
int pos = 0;
117-
char *dbiexhdr_data = 0, *p_tmp = 0;
118-
int size = 0, sz = 0;
119-
int i = 0;
120-
121-
parse_dbi_header(&dbi_stream->dbi_header, stream_file);
122-
pos += sizeof(SDBIHeader) - 2; // 2 because enum in C equal to 4, but
123-
// to read just 2;
124-
stream_file_seek(stream_file, pos, 0);
125-
126-
size = dbi_stream->dbi_header.module_size;
127-
dbiexhdr_data = (char *)malloc(size);
128-
if (!dbiexhdr_data) {
129-
return;
54+
static bool parse_dbi_stream_ex_header(DbiStream *s, RzBuffer *buf) {
55+
s->ex_hdrs = rz_list_new();
56+
if (!s->ex_hdrs) {
57+
// free s-dbi
58+
return false;
13059
}
131-
stream_file_read(stream_file, size, dbiexhdr_data);
132-
133-
dbi_stream->dbiexhdrs = rz_list_new();
134-
p_tmp = dbiexhdr_data;
135-
while (i < size) {
136-
dbi_ex_header = (SDBIExHeader *)malloc(sizeof(SDBIExHeader));
137-
if (!dbi_ex_header) {
138-
break;
139-
}
140-
// TODO: rewrite for signature where can to do chech CAN_READ true?
141-
sz = parse_dbi_ex_header(p_tmp, size, dbi_ex_header);
142-
if ((sz % PDB_ALIGN)) {
143-
sz = sz + (PDB_ALIGN - (sz % PDB_ALIGN));
60+
ut32 ex_size = s->hdr.mod_info_size;
61+
ut32 read_len = 0;
62+
while (read_len < ex_size) {
63+
DbiStreamExHdr *hdr = RZ_NEW0(DbiStreamExHdr);
64+
if (!hdr) {
65+
return false;
14466
}
145-
i += sz;
146-
p_tmp += sz;
147-
rz_list_append(dbi_stream->dbiexhdrs, dbi_ex_header);
67+
hdr->unknown = rz_buf_read_le32(buf);
68+
read_len += sizeof(ut32);
69+
read_len += parse_dbi_stream_section_entry(hdr, buf);
70+
hdr->Flags = rz_buf_read_le16(buf);
71+
hdr->ModuleName = rz_buf_read_le16(buf);
72+
read_len += sizeof(ut16) * 2;
73+
hdr->SymByteSize = rz_buf_read_le32(buf);
74+
hdr->C11ByteSize = rz_buf_read_le32(buf);
75+
hdr->C13ByteSize = rz_buf_read_le32(buf);
76+
read_len += sizeof(ut32) * 3;
77+
hdr->SourceFileCount = rz_buf_read_le16(buf);
78+
*(ut16 *)hdr->Padding = rz_buf_read_le16(buf);
79+
read_len += sizeof(ut16) * 2;
80+
hdr->Unused2 = rz_buf_read_le32(buf);
81+
hdr->SourceFileNameIndex = rz_buf_read_le32(buf);
82+
hdr->PdbFilePathNameIndex = rz_buf_read_le32(buf);
83+
read_len += sizeof(ut32) * 3;
84+
hdr->ModuleName = rz_buf_get_string(buf, rz_buf_tell(buf));
85+
ut32 str_length = strlen(hdr->ModuleName);
86+
rz_buf_seek(buf, rz_buf_tell(buf) + str_length, RZ_BUF_SET);
87+
read_len += str_length;
88+
hdr->ObjFileName = rz_buf_get_string(buf, rz_buf_tell(buf));
89+
str_length = strlen(hdr->ObjFileName);
90+
rz_buf_seek(buf, rz_buf_tell(buf) + str_length, RZ_BUF_SET);
91+
read_len += str_length;
92+
rz_list_append(s->ex_hdrs, hdr);
14893
}
94+
}
14995

150-
free(dbiexhdr_data);
151-
152-
// "Section Contribution"
153-
stream_file_seek(stream_file, dbi_stream->dbi_header.seccon_size, 1);
154-
// "Section Map"
155-
stream_file_seek(stream_file, dbi_stream->dbi_header.secmap_size, 1);
156-
// "File Info"
157-
stream_file_seek(stream_file, dbi_stream->dbi_header.filinf_size, 1);
158-
// "TSM"
159-
stream_file_seek(stream_file, dbi_stream->dbi_header.tsmap_size, 1);
160-
// "EC"
161-
stream_file_seek(stream_file, dbi_stream->dbi_header.ecinfo_size, 1);
96+
static void parse_dbi_dbg_header(DbiStream *s, RzBuffer *buf) {
97+
s->dbg_hdr.sn_fpo = rz_buf_read_le16(buf);
98+
s->dbg_hdr.sn_exception = rz_buf_read_le16(buf);
99+
s->dbg_hdr.sn_fixup = rz_buf_read_le16(buf);
100+
s->dbg_hdr.sn_omap_to_src = rz_buf_read_le16(buf);
101+
s->dbg_hdr.sn_omap_from_src = rz_buf_read_le16(buf);
102+
s->dbg_hdr.sn_section_hdr = rz_buf_read_le16(buf);
103+
s->dbg_hdr.sn_token_rid_map = rz_buf_read_le16(buf);
104+
s->dbg_hdr.sn_xdata = rz_buf_read_le16(buf);
105+
s->dbg_hdr.sn_pdata = rz_buf_read_le16(buf);
106+
s->dbg_hdr.sn_new_fpo = rz_buf_read_le16(buf);
107+
s->dbg_hdr.sn_section_hdr_orig = rz_buf_read_le16(buf);
108+
}
162109

163-
parse_dbg_header(&dbi_stream->dbg_header, stream_file);
110+
RZ_IPI bool parse_dbi_stream(RzPdb *pdb, MsfStream *stream) {
111+
if (!pdb || !stream) {
112+
return false;
113+
}
114+
pdb->s_dbi = RZ_NEW0(DbiStream);
115+
DbiStream *s = pdb->s_dbi;
116+
RzBuffer *buf = stream->stream_data;
117+
// parse header
118+
parse_dbi_stream_header(s, buf);
119+
parse_dbi_stream_ex_header(s, buf);
120+
// skip these streams
121+
ut64 seek = s->hdr.section_map_size + s->hdr.source_info_size + s->hdr.type_server_map_size + s->hdr.ec_substream_size;
122+
rz_buf_seek(buf, rz_buf_tell(buf) + seek, RZ_BUF_SET);
164123
}

‎librz/bin/pdb/dbi.h

+79-2
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,87 @@
11
// SPDX-FileCopyrightText: 2014 inisider <[email protected]>
2+
// SPDX-FileCopyrightText: 2021 Basstorm <[email protected]>
23
// SPDX-License-Identifier: LGPL-3.0-only
34

45
#ifndef DBI_H
56
#define DBI_H
67

7-
void init_dbi_stream(SDbiStream *dbi_stream);
8-
void parse_dbi_stream(void *parsed_pdb_stream, RZ_STREAM_FILE *stream_file);
8+
enum dbi_stream_version {
9+
DSV_VC41 = 930803,
10+
DSV_V50 = 19960307,
11+
DSV_V60 = 19970606,
12+
DSV_V70 = 19990903,
13+
DSV_V110 = 20091201
14+
};
15+
16+
typedef struct dbi_stream_header_t {
17+
st32 version_signature;
18+
ut32 version_header;
19+
ut32 age;
20+
ut16 global_stream_index;
21+
ut16 build_number;
22+
ut16 public_stream_index;
23+
ut16 pdb_dll_version;
24+
ut16 sym_record_stream;
25+
ut16 pdb_dll_rbld;
26+
ut32 mod_info_size;
27+
ut32 section_contribution_size;
28+
ut32 section_map_size;
29+
ut32 source_info_size;
30+
ut32 type_server_map_size;
31+
ut32 mfc_type_server_index;
32+
ut32 optional_dbg_header_size;
33+
ut32 ec_substream_size;
34+
ut16 flags;
35+
ut16 machine;
36+
ut32 padding;
37+
} DbiStreamHdr;
38+
39+
typedef struct dbi_stream_ex_header_t {
40+
ut32 unknown;
41+
struct SectionContribEntry {
42+
ut16 Section;
43+
char Padding1[2];
44+
st32 Offset;
45+
st32 Size;
46+
ut32 Characteristics;
47+
ut16 ModuleIndex;
48+
char Padding2[2];
49+
ut32 DataCrc;
50+
ut32 RelocCrc;
51+
} SectionContr;
52+
ut16 Flags;
53+
ut16 ModuleSymStream;
54+
ut32 SymByteSize;
55+
ut32 C11ByteSize;
56+
ut32 C13ByteSize;
57+
ut16 SourceFileCount;
58+
char Padding[2];
59+
ut32 Unused2;
60+
ut32 SourceFileNameIndex;
61+
ut32 PdbFilePathNameIndex;
62+
char *ModuleName;
63+
char *ObjFileName;
64+
} DbiStreamExHdr;
65+
66+
typedef struct {
67+
st16 sn_fpo;
68+
st16 sn_exception;
69+
st16 sn_fixup;
70+
st16 sn_omap_to_src;
71+
st16 sn_omap_from_src;
72+
st16 sn_section_hdr;
73+
st16 sn_token_rid_map;
74+
st16 sn_xdata;
75+
st16 sn_pdata;
76+
st16 sn_new_fpo;
77+
st16 sn_section_hdr_orig;
78+
} DbiStreamDbgHeader;
79+
80+
typedef struct dbi_stream_t {
81+
DbiStreamHdr hdr;
82+
RzList /* DbiStreamExHdr */ *ex_hdrs;
83+
DbiStreamDbgHeader dbg_hdr;
84+
85+
} DbiStream;
986

1087
#endif // DBI_H

0 commit comments

Comments
 (0)