int main(int argc, char** argv)
{
ElfFile* f = elf_open(argv[1]);
stabinfo_t *s = stab_load(f);
if (!s)
{
printf("No debug info");
return 0;
}
char* addr;
while (scanf("%x", (unsigned int*)&addr) == 1)
{
stab_line_t *r = stab_find(s, (char*)addr);
if (s->fns[r->fn].begin <= addr && addr < s->fns[r->fn].end)
{
printf("0x%08x:%s:%s:%x:%d\n",
(unsigned int)addr, s->srcs[s->fns[r->fn].src].name,
s->fns[r->fn].name, addr - s->fns[r->fn].begin, r->line);
}
else
{
printf("0x%08x::::\n", (unsigned int)addr);
}
}
stab_delete(s);
elf_close(f);
}
void kernel_binary_analyze_inner_elf(char *file_name)
{
struct elf_file_t *elf;
char *section_name;
char file_name_dest[MAX_STRING_SIZE];
void *section_buf;
int i;
elf = elf_open(file_name);
if (!elf)
return;
for (i = 0; i < elf_section_count(elf); i++)
{
uint32_t addr, offset, size, flags;
/* Get section info */
elf_section_info(elf, i, §ion_name, &addr, &offset, &size, &flags);
if (!*section_name)
continue;
/* Read section */
section_buf = elf_section_read(elf, i);
snprintf(file_name_dest, MAX_STRING_SIZE, "%s.%d%s", file_name, i, section_name);
write_buffer(file_name_dest, section_buf, size);
elf_section_free(section_buf);
/* Info */
printf("\t %s: inner section '%s' dumped\n", file_name_dest, section_name);
}
}
int lua_elf_t_new (lua_State * L)
{
char * filename;
struct lua_elf_t ** new_elf;
filename = (char *) luaL_checkstring(L, 1);
lua_pop(L, 1);
new_elf = lua_newuserdata(L, sizeof(struct lua_elf_t **));
luaL_getmetatable(L, "rop_tools.elf_t");
lua_setmetatable(L, -2);
*new_elf = (struct lua_elf_t *) malloc(sizeof(struct lua_elf_t));
(*new_elf)->ref_count = 1;
(*new_elf)->elf = elf_open(filename);
if ((*new_elf)->elf == NULL)
luaL_error(L, "error opening elf file %s", filename);
return 1;
}
int
elf_dump(const char *path, uint32_t *entry,
unsigned char *mem, size_t memsz) {
struct elf_file file;
int retval = 0;
retval = elf_open(&file, path);
if (retval != 0) {
error(0, 0, "couldn't get started on the ELF file.");
return retval;
}
*entry = file.ehdr.e_entry;
retval = copy_all_segments(&file, mem, memsz);
if (retval != 0) {
error(0, 0, "couldn't read prog segments.");
return retval;
}
return elf_close(&file);
}
void kernel_binary_analyze(char *file_name)
{
struct elf_file_t *elf;
struct elf_symbol_t *sym;
int i;
char file_name_prefix[MAX_STRING_SIZE];
char subdir[MAX_STRING_SIZE];
int len;
char file_name_dest[MAX_STRING_SIZE];
void *section_buf;
uint32_t section_size;
char *section_name;
/* Get file name prefix */
strcpy(file_name_prefix, file_name);
len = strlen(file_name);
if (len > 4 && !strcmp(file_name + len - 4, ".bin"))
file_name_prefix[len - 4] = '\0';
/* Create subdirectory */
snprintf(subdir, sizeof subdir, "%s_files", file_name_prefix);
mkdir(subdir, 0755);
/* Analyze ELF file */
elf_debug_file = fopen("/dev/null", "wt");
elf = elf_open(file_name);
if (!elf)
fatal("%s: cannot open ELF file", file_name);
/* List ELF sections */
printf("ELF sections:\n");
for (i = 0; i < elf_section_count(elf); i++)
{
uint32_t addr, offset, size, flags;
elf_section_info(elf, i, §ion_name, &addr, &offset, &size, &flags);
if (!size)
continue;
/* Dump to file */
section_buf = elf_section_read(elf, i);
sprintf(file_name_dest, "%s/%s.%s", subdir, file_name_prefix,
*section_name == '.' ? section_name + 1 : section_name);
write_buffer(file_name_dest, section_buf, size);
elf_section_free(section_buf);
/* Info */
printf(" section '%s': addr=0x%x, offset=0x%x, size=%d, flags=0x%x\n",
section_name, addr, offset, size, flags);
}
/* Get symbols */
for (i = 0; i < elf->symtab_count; i++)
{
char kernel_func_name[MAX_STRING_SIZE];
int kernel_func_len;
int sym_len;
sym = &elf->symtab[i];
if (strncmp(sym->name, "__OpenCL_", 9))
continue;
sym_len = strlen(sym->name);
if (!sym->size)
continue;
/* Read section */
elf_section_info(elf, sym->section, §ion_name, NULL, NULL, §ion_size, NULL);
section_buf = elf_section_read(elf, sym->section);
assert(sym->value + sym->size <= section_size);
/* Dump to files */
if (str_suffix(sym->name, "_metadata"))
{
kernel_func_len = sym_len - 18;
strncpy(kernel_func_name, sym->name + 9, kernel_func_len);
kernel_func_name[kernel_func_len] = '\0';
sprintf(file_name_dest, "%s/%s.%s.metadata", subdir, file_name_prefix, kernel_func_name);
write_buffer(file_name_dest, section_buf + sym->value, sym->size);
printf("\t%s: meta data dumped\n", file_name_dest);
}
else if (str_suffix(sym->name, "_kernel"))
{
kernel_func_len = sym_len - 16;
strncpy(kernel_func_name, sym->name + 9, kernel_func_len);
kernel_func_name[kernel_func_len] = '\0';
sprintf(file_name_dest, "%s/%s.%s.kernel", subdir, file_name_prefix, kernel_func_name);
write_buffer(file_name_dest, section_buf + sym->value, sym->size);
printf("\t%s: inner ELF file dumped\n", file_name_dest);
kernel_binary_analyze_inner_elf(file_name_dest);
}
/* Free section */
elf_section_free(section_buf);
}
/* Close file */
elf_close(elf);
}
int elf_enumerate_symbols (Context * ctx, const char * file_name, EnumerateSymbols ** enum_syms, EnumerateBatchSymbolsCallBack * call_back, void * args) {
Trap trap;
ELF_File * file;
unsigned sec_idx;
int has_more = 0;
if (!set_trap(&trap)) {
loc_free (*enum_syms);
*enum_syms = NULL;
return -1;
}
if (ctx == NULL && file_name == NULL) {
assert (*enum_syms != NULL);
file = elf_open ((*enum_syms)->file_name);
if (file == NULL) exception (errno);
/*
* Check that the file is identical to the initial file and the context
* still exists.
*/
if (file->ino != (*enum_syms)->ino || file->dev != (*enum_syms)->dev || file->mtime != (*enum_syms)->mtime) {
str_exception(ERR_OTHER, "The elf symbol file has changed");
}
else {
ctx = id2ctx((*enum_syms)->ctxId);
if (ctx == NULL) exception (ERR_INV_CONTEXT);
else if (ctx->exited) exception (ERR_ALREADY_EXITED);
}
sec_idx = (*enum_syms)->sec_idx;
}
else {
unsigned symtab_idx = 0;
unsigned dynsym_idx = 0;
unsigned ix;
assert (file_name != NULL && enum_syms != NULL && *enum_syms == NULL);
file = elf_open (file_name);
if (file == NULL) exception (errno);
if (file->sections == NULL) str_exception(ERR_OTHER, "The file does not have sections");
/* Look for the symbol table sections */
for (ix = 0; ix < file->section_cnt && (symtab_idx == 0 || dynsym_idx == 0); ix++) {
ELF_Section * sec = file->sections + ix;
if (sec->type == SHT_SYMTAB) symtab_idx = ix;
else if (sec->type == SHT_DYNSYM) dynsym_idx = ix;
}
if (symtab_idx == 0 && dynsym_idx == 0) str_exception(ERR_OTHER, "The file does not have a symbol table");
/* Set priority to the symbol table */
if (symtab_idx != 0) sec_idx = symtab_idx;
else sec_idx = dynsym_idx;
*enum_syms = (EnumerateSymbols *)loc_alloc_zero (sizeof (EnumerateSymbols));
strlcpy ((*enum_syms)->file_name, file_name, sizeof ((*enum_syms)->file_name));
if (strlen (file_name) != strlen ((*enum_syms)->file_name)) str_exception (ERR_OTHER, "File pathname too long");
strlcpy ((*enum_syms)->ctxId, ctx->id, sizeof ((*enum_syms)->ctxId));
(*enum_syms)->dev = file->dev;
(*enum_syms)->ino = file->ino;
(*enum_syms)->mtime = file->mtime;
(*enum_syms)->sec_idx = sec_idx;
}
has_more = enumerate_symbol_table(ctx, file->sections + sec_idx, *enum_syms, call_back, args);
clear_trap(&trap);
if (has_more == 0) {
loc_free (*enum_syms);
*enum_syms = NULL;
}
return has_more;
}
