R_API void r_anal_state_insert_bb(RAnalState* state, RAnalBlock *bb) { if (!state || !bb) { return; } if (!r_anal_state_search_bb (state, bb->addr) && state->current_fcn) { r_list_append (state->current_fcn->bbs, bb); state->bytes_consumed += state->current_bb->op_sz; const char *key = sdb_fmt (0, "0x%08"PFMT64x, bb->addr); if (!ht_insert (state->ht, key, bb)) { eprintf ("Inserted bb 0x%04"PFMT64x" failure\n", bb->addr); } } }
static RList* entries(RBinFile *arch) { RList *ret; RBinAddr *ptr = NULL; if (!(ret = r_list_new ())) return NULL; ret->free = free; if (!(ptr = R_NEW0 (RBinAddr))) return ret; ptr->paddr = ptr->vaddr = 0; r_list_append (ret, ptr); return ret; }
static int xrefs_list_cb_any(RAnal *anal, const char *k, const char *v) { //ut64 dst, src = r_num_get (NULL, v); if (!strncmp (_kpfx, k, strlen (_kpfx))) { RAnalRef *ref = r_anal_ref_new (); if (ref) { ref->addr = r_num_get (NULL, k + strlen (_kpfx) + 1); ref->at = r_num_get (NULL, v); // XXX ref->type = _type; r_list_append (_list, ref); } } return true; }
static int callback_list(void *u, const char *k, const char *v) { RList *list = (RList*)u; if (!strchr (k, '.')) { RSyscallItem *si = r_syscall_item_new_from_string (k, v); if (!si) { return 1; } if (!strchr (si->name, '.')) { r_list_append (list, si); } } return 1; // continue loop }
static RList *entries(RBinFile *bf) { RList /*<RBinAddr>*/ *ret = r_list_newf (free); if (!ret) { return NULL; } RBinAddr *ptr = R_NEW0 (RBinAddr); if (ptr) { ptr->paddr = N64_ROM_START; ptr->vaddr = baddr (bf); r_list_append (ret, ptr); } return ret; }
static RList* entries(RBinArch *arch) { RList* ret = r_list_new ();; RBinAddr *ptr = NULL; if (!ret) return NULL; ret->free = free; if (!memcmp (arch->buf+0x30, "\x00\x00\x00\x00\x20\x73\x74\x64\x6f\x75\x74\x20\x21\x55\x0c\xcd", 16)) { if ((ptr = R_NEW (RBinAddr))) { ptr->rva = ptr->offset = 0x9a; r_list_append (ret, ptr); } } return ret; }
static RList* sections(RBinFile *arch){ ut8 bank; int i; RList *ret = r_list_new(); r_buf_read_at (arch->buf, 0x148, &bank, 1); bank=gb_get_rombanks(bank); RBinSection *rombank[bank]; if (!ret ) return NULL; if (!arch || !arch->buf) { free (ret); return NULL; } ret->free = free; rombank[0] = R_NEW0 (RBinSection); strncpy (rombank[0]->name, "rombank00", R_BIN_SIZEOF_STRINGS); rombank[0]->offset = 0; rombank[0]->size = 0x4000; rombank[0]->vsize = 0x4000; rombank[0]->rva = 0; rombank[0]->srwx = r_str_rwx ("rx"); r_list_append (ret, rombank[0]); for (i=1;i<bank;i++) { rombank[i] = R_NEW0 (RBinSection); sprintf (rombank[i]->name,"rombank%02x",i); rombank[i]->offset = i*0x4000; rombank[i]->rva = i*0x10000-0xc000; //spaaaaaaaaaaaaaaaace!!! rombank[i]->size = rombank[i]->vsize = 0x4000; rombank[i]->srwx=r_str_rwx ("rx"); r_list_append (ret,rombank[i]); } return ret; }
static RList* sections(RBinFile *arch) { RList *ret = NULL; RBinSection *ptr = NULL; RRarBinObj *bin_obj = arch && arch->o ? arch->o->bin_obj : NULL; const ut8 *buf = bin_obj ? r_buf_buffer (bin_obj->buf) : NULL; ut64 sz = 0; if (bin_obj) sz = r_buf_size (bin_obj->buf); if (!(ret = r_list_new ())) return NULL; ret->free = free; // TODO: return NULL here? if (!buf || sz < 0x30 || memcmp (buf+0x30, RAR_CONST, 16)) return ret; // add text segment if (!(ptr = R_NEW0 (RBinSection))) return ret; strncpy (ptr->name, "header", R_BIN_SIZEOF_STRINGS); ptr->size = ptr->vsize = 0x9a; ptr->paddr = 0; ptr->vaddr = ptr->paddr; ptr->srwx = R_BIN_SCN_READABLE | R_BIN_SCN_MAP; // r-- ptr->add = true; r_list_append (ret, ptr); /* rarvm code */ if (!(ptr = R_NEW0 (RBinSection))) return ret; strncpy (ptr->name, "rarvm", R_BIN_SIZEOF_STRINGS); ptr->vsize = ptr->size = sz - 0x9a; ptr->vaddr = ptr->paddr = 0x9a; ptr->srwx = R_BIN_SCN_READABLE | R_BIN_SCN_EXECUTABLE | R_BIN_SCN_MAP; // r-x ptr->add = true; r_list_append (ret, ptr); return ret; }
static RList *sections(RBinFile *bf) { RList *ret = NULL; RBinSection *sections[4] = { NULL, NULL, NULL, NULL }; int i, corrupt = false; if (!(ret = r_list_new ())) { return NULL; } /* FIRM has always 4 sections, normally the 4th section is not used */ for (i = 0; i < 4; i++) { /* Check if section is used */ if (loaded_header.sections[i].size) { sections[i] = R_NEW0 (RBinSection); /* Firmware Type ('0'=ARM9/'1'=ARM11) */ if (loaded_header.sections[i].type == 0x0) { strncpy (sections[i]->name, "arm9", 4); } else if (loaded_header.sections[i].type == 0x1) { strncpy (sections[i]->name, "arm11", 5); } else { corrupt = true; break; } sections[i]->size = loaded_header.sections[i].size; sections[i]->vsize = loaded_header.sections[i].size; sections[i]->paddr = loaded_header.sections[i].offset; sections[i]->vaddr = loaded_header.sections[i].address; sections[i]->srwx = r_str_rwx ("mrwx"); sections[i]->add = true; } } /* Append sections or free them if file is corrupt to avoid memory leaks */ for (i = 0; i < 4; i++) { if (sections[i]) { if (corrupt) { free (sections[i]); } else { r_list_append (ret, sections[i]); } } } if (corrupt) { r_list_free (ret); return NULL; } return ret; }
R_API RList *r_core_asm_bwdisassemble (RCore *core, ut64 addr, int n, int len) { RCoreAsmHit *hit; RAsmOp op; RList *hits = NULL; ut8 *buf; ut64 at; int instrlen, ni, idx; if (!(hits = r_core_asm_hit_list_new ())) return NULL; buf = (ut8 *)malloc (len); if (!buf) { r_list_destroy (hits); return NULL; } if (r_io_read_at (core->io, addr-len, buf, len) != len) { r_list_destroy (hits); free (buf); return NULL; } for (idx = 1; idx < len; idx++) { if (r_cons_singleton ()->breaked) break; at = addr - idx; ni = 1; while (at < addr) { r_asm_set_pc (core->assembler, at); //XXX HACK We need another way to detect invalid disasm!! if (!(instrlen = r_asm_disassemble (core->assembler, &op, buf+(len-(addr-at)), addr-at)) || strstr (op.buf_asm, "invalid")) { break; } else { at += instrlen; if (at == addr) { if (ni == n) { if (!(hit = r_core_asm_hit_new ())) { r_list_destroy (hits); free (buf); return NULL; } hit->addr = addr-idx; hit->len = idx; hit->code = NULL; r_list_append (hits, hit); } } else ni++; } } } r_asm_set_pc (core->assembler, addr); free (buf); return hits; }
static RList* sections(RBinFile *arch) { RList *ret = NULL; if (!(ret = r_list_new ())) return NULL; RBinSection *ptr; if (!(ptr = R_NEW0 (RBinSection))) return ret; strcpy (ptr->name, "vtable"); ptr->paddr = ptr->vaddr = 0; ptr->size = ptr->vsize = 0x100; ptr->srwx = R_BIN_SCN_MAP; ptr->add = true; r_list_append (ret, ptr); if (!(ptr = R_NEW0 (RBinSection))) return ret; strcpy (ptr->name, "header"); ptr->paddr = ptr->vaddr = 0x100; ptr->size = ptr->vsize = sizeof (SMD_Header); ptr->srwx = R_BIN_SCN_MAP; ptr->add = true; r_list_append (ret, ptr); if (!(ptr = R_NEW0 (RBinSection))) return ret; strcpy (ptr->name, "text"); ptr->paddr = ptr->vaddr = 0x100 + sizeof (SMD_Header); { SMD_Header * hdr = (SMD_Header*)(arch->buf->buf + 0x100); ut64 baddr = hdr->RamStart; ptr->vaddr += baddr; } ptr->size = ptr->vsize = arch->buf->length - ptr->paddr; ptr->srwx = R_BIN_SCN_MAP; ptr->add = true; r_list_append (ret, ptr); return ret; }
static RList* symbols(RBinFile *arch) { RList *ret = NULL; RBinSymbol *ptr[3]; if (!(ret = r_list_new())) return NULL; ret->free = free; if (!(ptr[0] = R_NEW0 (RBinSymbol))) return ret; if (!ptr[0]->name) { ptr[0]->name = calloc(1, R_BIN_SIZEOF_STRINGS); } strncpy (ptr[0]->name, "NMI_VECTOR_START_ADDRESS", R_BIN_SIZEOF_STRINGS); ptr[0]->vaddr = NMI_VECTOR_START_ADDRESS; ptr[0]->size = 2; ptr[0]->ordinal = 0; r_list_append (ret, ptr[0]); if (!(ptr[1] = R_NEW0 (RBinSymbol))) return ret; if (!ptr[1]->name) { ptr[1]->name = calloc(1, R_BIN_SIZEOF_STRINGS); } strncpy (ptr[1]->name, "RESET_VECTOR_START_ADDRESS", R_BIN_SIZEOF_STRINGS); ptr[1]->vaddr = RESET_VECTOR_START_ADDRESS; ptr[1]->size = 2; ptr[1]->ordinal = 1; r_list_append (ret, ptr[1]); if (!(ptr[2] = R_NEW0 (RBinSymbol))) return ret; if (!ptr[2]->name) { ptr[2]->name = calloc(1, R_BIN_SIZEOF_STRINGS); } strncpy (ptr[2]->name, "IRQ_VECTOR_START_ADDRESS", R_BIN_SIZEOF_STRINGS); ptr[2]->vaddr = IRQ_VECTOR_START_ADDRESS; ptr[2]->size = 2; ptr[2]->ordinal = 2; r_list_append (ret, ptr[2]); return ret; }
static RList* entries(RBinArch *arch) { RList *ret; RBinAddr *ptr = NULL; if (!(ret = r_list_new ())) return NULL; ret->free = free; if (!(ptr = R_NEW (RBinAddr))) return ret; memset (ptr, '\0', sizeof (RBinAddr)); ptr->offset = ptr->rva = 0xffff0; r_list_append (ret, ptr); return ret; }
static void add_hit_to_hits(RList* hits, ut64 addr, int len, ut8 is_valid) { RCoreAsmHit *hit = r_core_asm_hit_new(); if (hit) { IFDBG eprintf("*** Inserting instruction (valid?: %d): instr_addr: 0x%"PFMT64x" instr_len: %d\n", is_valid, addr, len); hit->addr = addr; hit->len = len; hit->valid = is_valid; hit->code = NULL; if (!r_list_append (hits, hit)){ free (hit); IFDBG eprintf ("hit couldn't be added to the list in %s at %d\n", __FILE__, __LINE__); } } }
static RList* entries(RBinFile *bf) { RList *ret; RBinAddr *ptr = NULL; if (!(ret = r_list_new ())) { return NULL; } if (!(ptr = R_NEW0 (RBinAddr))) { return ret; } ptr->paddr = RAM_START_ADDRESS; ptr->vaddr = 0; r_list_append (ret, ptr); return ret; }
static RList *entries(RBinFile *bf) { RList *ret; RBinAddr *ptr = NULL; if (!(ret = r_list_new ())) { return NULL; } ret->free = free; if ((ptr = R_NEW0 (RBinAddr))) { ptr->paddr = 0x80; ptr->vaddr = ptr->paddr + baddr (bf); r_list_append (ret, ptr); } return ret; }
static RList *sections(RBinFile *arch) { RList *shared = r_list_new (); if (!shared) { return NULL; } RList *cobjs = r_list_new (); if (!cobjs) { return NULL; } interned_table = r_list_new (); if (!interned_table) { return NULL; } r_list_append (shared, cobjs); r_list_append (shared, interned_table); arch->o->bin_obj = shared; RList *sections = r_list_new (); if (!sections) { return NULL; } pyc_get_sections (sections, cobjs, arch->buf, version.magic); return sections; }
static RList* entries(RBinFile *arch) { RList* ret; RBinAddr *ptr = NULL; if (!(ret = r_list_new ())) return NULL; ret->free = free; if ((ptr = R_NEW0 (RBinAddr))) { ptr->paddr = 40 + sb.code_pa; ptr->vaddr = 40 + sb.code_pa + sb.vaddr; r_list_append (ret, ptr); } return ret; }
static RList* lines(RBinArch *arch) { int i; char *file = strdup (arch->file); RList *list = r_list_new (); RBinJavaObj *b = arch->bin_obj; file = r_str_replace (file, ".class", ".java", 0); for (i=0; i<b->lines.count; i++) { RBinDwarfRow *row = R_NEW (RBinDwarfRow); r_bin_dwarf_line_new (row, b->lines.addr[i], file, b->lines.line[i]); r_list_append (list, row); } free (file); return list; }
static RList* entries(RBinFile *arch) { RList* ret; RBinAddr *ptr = NULL; if (!(ret = r_list_new ())) return NULL; ret->free = free; if ((ptr = R_NEW (RBinAddr))) { ptr->paddr = 8*4; ptr->vaddr = 8*4;// + baddr (arch); r_list_append (ret, ptr); } return ret; }
/* Idea: At first, get all sections in vrange, meanwhile record all unsectioned area and store it via RIORange in a list, read all sections via mread, resolve maps for unsectioned areas and fill the gaps. last point must always prefere using io->desc*/ R_API int r_io_vread (RIO *io, ut64 vaddr, ut8 *buf, int len) { int tmp_len = len; ut8 *tmp_buf = buf; ut64 vendaddr, maddr, tmp_vaddr = vaddr; RIOMap *map; RIOSection *section; RIORange *range; RList *sections, *ranges = NULL, *maps; RListIter *iter, *ator; if (!io->desc) { eprintf ("r_io_vread: desc is NULL, WTF!\n"); return R_ERROR; } if (len < 0) { eprintf ("r_io_vread: wrong usage; len is smaller than 0. len: %i\n", len); return R_FAIL; } sections = r_io_section_get_in_vaddr_range (io, vaddr, vaddr+len); if (!r_list_empty (sections)) { //check if there is any section ranges = r_list_new(); ranges->free = free; r_list_foreach (sections, iter, section) { if (section->vaddr==0) continue; if (section->vaddr > tmp_vaddr) { range = r_io_range_new(); //create a new range range->from = tmp_vaddr; //record unsectioned area range->to = section->vaddr; r_list_append (ranges, range); //store the range tmp_vaddr = section->vaddr; //prepare for resolving the maddr tmp_len -= (tmp_vaddr - vaddr); tmp_buf += (tmp_vaddr - vaddr); //adjust buffer } vendaddr = tmp_vaddr + tmp_len; //calculate the virtual end address if (vendaddr > (section->vaddr + section->vsize)) //check if the virual end address is in the section too vendaddr = section->vaddr + section->vsize; //if not, size it down maddr = tmp_vaddr - section->vaddr + section->offset; //calculate the map address (address inside the map) if (maddr > ( section->offset + section->size)) { //check if the maddr is inside the physical section, if not, skip some things } else { if ((vendaddr - section->vaddr + section->offset) > (section->offset + section->size)) { //check if the virtual part of the section fits into the physical part r_io_mread (io, section->fd, maddr, tmp_buf, (section->offset + section->size) - maddr);//if not, read as far as possible } else { r_io_mread (io, section->fd, maddr, tmp_buf, vendaddr - tmp_vaddr); //read from the sections fd } } tmp_buf += (vendaddr - tmp_vaddr); //adjust buffer tmp_len -= (vendaddr - tmp_vaddr); //adjust length tmp_vaddr = vendaddr; //adjust address } }
static RList *imports(RBinFile *bf) { RBinWasmObj *bin = NULL; RList *imports = NULL; RBinImport *ptr = NULL; RList *ret = NULL; if (!bf || !bf->o || !bf->o->bin_obj) { return NULL; } bin = bf->o->bin_obj; if (!(ret = r_list_newf (r_bin_import_free))) { return NULL; } if (!(imports = r_bin_wasm_get_imports (bin))) { goto bad_alloc; } RBinWasmImportEntry *import = NULL; ut32 i = 0; RListIter *iter; r_list_foreach (imports, iter, import) { if (!(ptr = R_NEW0 (RBinImport))) { goto bad_alloc; } ptr->name = strdup (import->field_str); ptr->classname = strdup (import->module_str); ptr->ordinal = i; ptr->bind = r_str_const ("NONE"); switch(import->kind) { case R_BIN_WASM_EXTERNALKIND_Function: ptr->type = r_str_const ("FUNC"); break; case R_BIN_WASM_EXTERNALKIND_Table: ptr->type = r_str_const ("TABLE"); break; case R_BIN_WASM_EXTERNALKIND_Memory: ptr->type = r_str_const ("MEM"); break; case R_BIN_WASM_EXTERNALKIND_Global: ptr->type = r_str_const ("GLOBAL"); break; } r_list_append (ret, ptr); } return ret; bad_alloc: r_list_free (imports); r_list_free (ret); return NULL; }
R_API int r_mixed_add (RMixed *m, void *p) { RHashTable *ht; RHashTable64 *ht64; RList *list = NULL; ut64 value; int i, size, ret = false;; r_list_append (m->list, p); for (i=0; i<RMIXED_MAXKEYS; i++) { if (!m->keys[i]) continue; size = m->keys[i]->size; value = r_mixed_get_value (i, size, p); switch (size) { case 1: case 2: case 4: ht = m->keys[i]->hash.ht; list = r_hashtable_lookup (ht, (ut32)value); if (!list) { list = r_list_new (); r_hashtable_insert (ht, (ut32)value, list); } r_list_append (list, p); ret = true; break; case 8: ht64 = m->keys[i]->hash.ht64; list = r_hashtable64_lookup (ht64, value); if (!list) { list = r_list_new (); r_hashtable64_insert (ht64, value, list); } r_list_append (list, p); ret = true; break; } } return ret; }
static RList *sections(RBinFile *bf) { RList *ret = NULL; RBinSection *ptr9 = NULL, *ptr7 = NULL; if (!(ret = r_list_new ())) { return NULL; } if (!(ptr9 = R_NEW0 (RBinSection))) { r_list_free (ret); return NULL; } if (!(ptr7 = R_NEW0 (RBinSection))) { r_list_free (ret); free (ptr9); return NULL; } strncpy (ptr9->name, "arm9", 5); ptr9->size = loaded_header.arm9_size; ptr9->vsize = loaded_header.arm9_size; ptr9->paddr = loaded_header.arm9_rom_offset; ptr9->vaddr = loaded_header.arm9_ram_address; ptr9->srwx = r_str_rwx ("rwx"); ptr9->add = true; r_list_append (ret, ptr9); strncpy (ptr7->name, "arm7", 5); ptr7->size = loaded_header.arm7_size; ptr7->vsize = loaded_header.arm7_size; ptr7->paddr = loaded_header.arm7_rom_offset; ptr7->vaddr = loaded_header.arm7_ram_address; ptr7->srwx = r_str_rwx ("rwx"); ptr7->add = true; r_list_append (ret, ptr7); return ret; }
R_API RList *r_sys_dir(const char *path) { RList *list = NULL; #if __WINDOWS__ && !defined(__CYGWIN__) HANDLE fh; WIN32_FIND_DATAW entry; char *cfname; fh = r_sandbox_opendir (path, &entry); if (fh == INVALID_HANDLE_VALUE) { //IFDGB eprintf ("Cannot open directory %ls\n", wcpath); return list; } list = r_list_newf (free); if (list) { do { if ((cfname = r_utf16_to_utf8 (entry.cFileName))) { r_list_append (list, strdup (cfname)); free (cfname); } } while (FindNextFileW (fh, &entry)); } FindClose (fh); #else struct dirent *entry; DIR *dir = r_sandbox_opendir (path); if (dir) { list = r_list_new (); if (list) { list->free = free; while ((entry = readdir (dir))) { r_list_append (list, strdup (entry->d_name)); } } closedir (dir); } #endif return list; }
void parse_dbi_stream(void *parsed_pdb_stream, R_STREAM_FILE *stream_file) { SDbiStream *dbi_stream = (SDbiStream *) parsed_pdb_stream; SDBIExHeader *dbi_ex_header = 0; int pos = 0; char *dbiexhdr_data = 0, *p_tmp = 0; int size = 0, sz = 0; int i = 0; parse_dbi_header (&dbi_stream->dbi_header, stream_file); pos += sizeof (SDBIHeader) - 2; // 2 because enum in C equal to 4, but // to read just 2; stream_file_seek (stream_file, pos, 0); size = dbi_stream->dbi_header.module_size; dbiexhdr_data = (char *) malloc(size); if (!dbiexhdr_data) return; stream_file_read (stream_file, size, dbiexhdr_data); dbi_stream->dbiexhdrs = r_list_new(); p_tmp = dbiexhdr_data; while (i < size) { dbi_ex_header = (SDBIExHeader *) malloc (sizeof(SDBIExHeader)); if (!dbi_ex_header) break; // TODO: rewrite for signature where can to do chech CAN_READ true? sz = parse_dbi_ex_header (p_tmp, size, dbi_ex_header); if ((sz % _ALIGN)) { sz = sz + (_ALIGN - (sz % _ALIGN)); } i += sz; p_tmp += sz; r_list_append (dbi_stream->dbiexhdrs, dbi_ex_header); } free (dbiexhdr_data); // "Section Contribution" stream_file_seek(stream_file, dbi_stream->dbi_header.seccon_size, 1); // "Section Map" stream_file_seek(stream_file, dbi_stream->dbi_header.secmap_size, 1); // "File Info" stream_file_seek(stream_file, dbi_stream->dbi_header.filinf_size, 1); // "TSM" stream_file_seek(stream_file, dbi_stream->dbi_header.tsmap_size, 1); // "EC" stream_file_seek(stream_file, dbi_stream->dbi_header.ecinfo_size, 1); parse_dbg_header(&dbi_stream->dbg_header, stream_file); }
static RList *entries(RBinFile *arch) { struct r_bin_coff_obj *obj = (struct r_bin_coff_obj*)arch->o->bin_obj; RList *ret; RBinAddr *ptr = NULL; if (!(ret = r_list_new ())) return NULL; ret->free = free; ptr = r_coff_get_entry(obj); r_list_append(ret, ptr); return ret; }
static RList* entries(RBinFile *bf) { RList *ret = r_list_new (); RBinAddr *ptr = NULL; if (bf && bf->buf != NULL) { if (!ret) return NULL; ret->free = free; if (!(ptr = R_NEW0 (RBinAddr))) return ret; ptr->paddr = ptr->vaddr = ptr->haddr = 0x100; r_list_append (ret, ptr); } return ret; }
static RList* entries(RBinFile *arch) { RList *ret; RBinAddr *addr; DolHeader *dol; if (!arch || !arch->o || !arch->o->bin_obj) { return NULL; } ret = r_list_new (); addr = R_NEW0 (RBinAddr); dol = arch->o->bin_obj; addr->vaddr = (ut64)dol->entrypoint; addr->paddr = addr->vaddr & 0xFFFF; r_list_append (ret, addr); return ret; }
static RList *entries(RBinFile *bf) { // Should be 3 offsets pointed by NMI, RESET, IRQ after mapping && default = 1st CHR RList *ret; RBinAddr *ptr = NULL; if (!(ret = r_list_new ())) { return NULL; } if (!(ptr = R_NEW0 (RBinAddr))) { return ret; } SMD_Header *hdr = (SMD_Header *) (bf->buf->buf + 0x100); ut64 baddr = hdr->RomStart; ptr->paddr = ptr->vaddr = baddr + 0x100 + sizeof (SMD_Header); // vtable[1]; r_list_append (ret, ptr); return ret; }