diff --git a/src/elf_check_elf.c b/src/elf_check_elf.c index e0f3217a8194d4580e88d6881042e9b09a72af49..fed8a7a6f51bf96c4ed12d4490f882df5a17df40 100644 --- a/src/elf_check_elf.c +++ b/src/elf_check_elf.c @@ -78,7 +78,7 @@ static void check_rela_dyn(elf_link_t *elf_link) continue; } Elf64_Sym *sym = elf_get_dynsym_by_rela(out_ef, rela); - const char *sym_name = elf_get_dynsym_name(out_ef, sym); + const char *sym_name = elf_get_sym_name(out_ef, sym); if (is_dynsym_valid(sym, sym_name) == false) { SI_LOG_EMERG("%s is UND\n", sym_name); } diff --git a/src/elf_link_common.c b/src/elf_link_common.c index 9239a048439adbd2e8491d1fe34444a462c1a3f4..4881bc640443c9209e2864d49e429e3b6a5a0033 100644 --- a/src/elf_link_common.c +++ b/src/elf_link_common.c @@ -83,6 +83,78 @@ bool is_gnu_weak_symbol(Elf64_Sym *sym) return false; } +// .interp is needed by dyn-mode, staitc-mode template do not have +static char *needed_sections[] = { + ".interp", + ".note.gnu.build-id", + ".note.ABI-tag", + ".gnu.hash", + ".dynsym", + ".dynstr", + ".rela.dyn", + ".rela.plt", + ".text", + ".rodata", + ".eh_frame_hdr", // this section's header is not modified, is it really needed? + ".tdata", + ".tbss", + ".init_array", + ".fini_array", + ".data.rel.ro", + ".dynamic", + ".got", + ".data", + ".bss", + ".symtab", + ".strtab", + ".shstrtab", +}; +#define NEEDED_SECTIONS_LEN (sizeof(needed_sections) / sizeof(needed_sections[0])) + +bool is_section_needed(elf_link_t *elf_link, elf_file_t *ef, Elf64_Shdr *sec) +{ + char *name = elf_get_section_name(ef, sec); + + // first section name is empty + if (name == NULL || *name == '\0') { + return true; + } + + // no use .plt, so delete .rela.plt + if (is_direct_call_optimize(elf_link) == true) { + if (!strcmp(name, ".rela.plt")) { + return false; + } + } + + for (unsigned i = 0; i < NEEDED_SECTIONS_LEN; i++) { + if (!strcmp(name, needed_sections[i])) { + return true; + } + } + + if (is_delete_symbol_version(elf_link) == false) { + if (!strcmp(name, ".gnu.version") || !strcmp(name, ".gnu.version_r")) { + return true; + } + } + + return false; + + /* + TODO: clean code, below is original implementation, don't have any effect now + if ((sec->sh_type == SHT_RELA) && (!(sec->sh_flags & SHF_ALLOC))) + return false; + if (sec->sh_type == SHT_GNU_versym || sec->sh_type == SHT_GNU_verdef || + sec->sh_type == SHT_GNU_verneed) + return false; + if (elf_is_debug_section(ef, sec)) + return false; + + return true; + */ +} + // symbol_name string can not change void append_symbol_mapping(elf_link_t *elf_link, char *symbol_name, unsigned long symbol_addr) { @@ -234,11 +306,11 @@ void init_vdso_symbol_addr(elf_link_t *elf_link) elf_show_dynsym(vdso_ef); - int sym_count = vdso_ef->dynsym_sec->sh_size / sizeof(Elf64_Sym); - Elf64_Sym *syms = (Elf64_Sym *)(((void *)vdso_ef->hdr) + vdso_ef->dynsym_sec->sh_offset); + int sym_count = elf_get_dynsym_count(vdso_ef); + Elf64_Sym *syms = elf_get_dynsym_array(vdso_ef); for (int j = 0; j < sym_count; j++) { Elf64_Sym *sym = &syms[j]; - char *name = elf_get_dynsym_name(vdso_ef, sym); + char *name = elf_get_sym_name(vdso_ef, sym); // vdso func __kernel_clock_getres if (name == NULL || name[0] != '_') { continue; @@ -264,11 +336,11 @@ void init_ld_symbol_addr(elf_link_t *elf_link) // addr relative to main ELF unsigned long hdr_addr = ld_hdr_addr_to_main_elf(ef); - int sym_count = ef->dynsym_sec->sh_size / sizeof(Elf64_Sym); - Elf64_Sym *syms = (Elf64_Sym *)(((void *)ef->hdr) + ef->dynsym_sec->sh_offset); + int sym_count = elf_get_dynsym_count(ef); + Elf64_Sym *syms = elf_get_dynsym_array(ef); for (int j = 0; j < sym_count; j++) { Elf64_Sym *sym = &syms[j]; - char *name = elf_get_dynsym_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); if (name == NULL || name[0] == '\0') { continue; } @@ -300,15 +372,16 @@ void show_sec_mapping(elf_link_t *elf_link) elf_sec_mapping_t *sec_rels = elf_link->sec_mapping_arr->data; elf_sec_mapping_t *sec_rel = NULL; + SI_LOG_INFO("dst_addr dst_off dst_sec_addr src_sec_addr src_sec_name src_file\n"); for (int i = 0; i < len; i++) { sec_rel = &sec_rels[i]; char *name = elf_get_section_name(sec_rel->src_ef, sec_rel->src_sec); const char *fname = si_basename(sec_rel->src_ef->file_name); - SI_LOG_INFO("%08lx %08lx %08lx - %08lx %08lx - %08lx %-20s %-20s %016lx %016lx\n", + SI_LOG_INFO("%08lx %08lx %08lx - %08lx %08lx - %08lx %-20s %-20s\n", sec_rel->dst_mem_addr, sec_rel->dst_file_offset, sec_rel->dst_sec->sh_addr, sec_rel->dst_sec->sh_addr + sec_rel->dst_sec->sh_size, sec_rel->src_sec->sh_addr, sec_rel->src_sec->sh_addr + sec_rel->src_sec->sh_size, - name, fname, (unsigned long)sec_rel->src_sec, (unsigned long)sec_rel->dst_sec); + name, fname); } } @@ -487,7 +560,7 @@ Elf64_Shdr *find_tmp_section_by_name(elf_link_t *elf_link, const char *sec_name) } // addr != offset from RELRO segment -unsigned long _get_new_elf_addr(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long addr) +static unsigned long _get_new_elf_addr(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long addr) { int len = elf_link->sec_mapping_arr->len; elf_sec_mapping_t *sec_rels = elf_link->sec_mapping_arr->data; @@ -552,6 +625,25 @@ unsigned long _get_new_elf_addr(elf_link_t *elf_link, elf_file_t *src_ef, unsign return NOT_FOUND; } +static bool is_in_sec_mapping(elf_link_t *elf_link, elf_file_t *src_ef, Elf64_Shdr *src_sec) +{ + int len = elf_link->sec_mapping_arr->len; + elf_sec_mapping_t *sec_rels = elf_link->sec_mapping_arr->data; + elf_sec_mapping_t *sec_rel = NULL; + + for (int i = 0; i < len; i++) { + sec_rel = &sec_rels[i]; + if (sec_rel->src_ef != src_ef) { + continue; + } + if (sec_rel->src_sec == src_sec) { + return true; + } + } + return false; +} + +// .note.gnu.property section is delete, so can not find unsigned long get_new_addr_by_old_addr(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long addr) { unsigned long ret = _get_new_elf_addr(elf_link, src_ef, addr); @@ -560,6 +652,18 @@ unsigned long get_new_addr_by_old_addr(elf_link_t *elf_link, elf_file_t *src_ef, return ret; } + // if section delete, ignore error + Elf64_Shdr *sec = elf_find_section_by_addr(src_ef, addr); + if (sec == NULL) { + goto out; + } + char *sec_name = elf_get_section_name(src_ef, sec); + SI_LOG_DEBUG("sec name: %s\n", sec_name); + if (is_in_sec_mapping(elf_link, src_ef, sec) == false) { + return 0UL; + } + +out: // something wrong had happen si_log_set_global_level(SI_LOG_LEVEL_DEBUG); show_sec_mapping(elf_link); @@ -567,9 +671,25 @@ unsigned long get_new_addr_by_old_addr(elf_link_t *elf_link, elf_file_t *src_ef, return NOT_FOUND; } +unsigned long get_new_addr_by_old_addr_ok(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long addr) +{ + unsigned long ret = _get_new_elf_addr(elf_link, src_ef, addr); + SI_LOG_DEBUG("get addr: %s %lx %lx\n", src_ef->file_name, addr, ret); + if (ret != NOT_FOUND) { + return ret; + } + // ignore NOT_FOUND + return 0; +} + unsigned long get_new_offset_by_old_offset(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long offset) { - // addr != offset after RELRO segment + // addr != offset after .rodata segment, .tdata is not eq + Elf64_Phdr *p = src_ef->data_Phdr; + if (offset >= p->p_offset) { + si_panic("error: %s offset %lx\n", src_ef->file_name, offset); + } + return get_new_addr_by_old_addr(elf_link, src_ef, offset); } @@ -589,7 +709,7 @@ static unsigned long _get_new_addr_by_sym_name(elf_link_t *elf_link, char *sym_n Elf64_Sym *syms = (Elf64_Sym *)(((void *)ef->hdr) + ef->symtab_sec->sh_offset); for (int j = 0; j < sym_count; j++) { sym = &syms[j]; - char *name = elf_get_symbol_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); if (elf_is_same_symbol_name(sym_name, name) && sym->st_shndx != SHN_UNDEF) { goto out; } @@ -602,7 +722,7 @@ static unsigned long _get_new_addr_by_sym_name(elf_link_t *elf_link, char *sym_n Elf64_Sym *syms = (Elf64_Sym *)(((void *)ef->hdr) + ef->symtab_sec->sh_offset); for (int j = 0; j < sym_count; j++) { sym = &syms[j]; - char *name = elf_get_symbol_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); if (elf_is_same_symbol_name(sym_name, name) && sym->st_shndx != SHN_UNDEF) { goto out; } @@ -748,14 +868,9 @@ static unsigned long get_ifunc_new_addr(elf_link_t *elf_link, elf_file_t *ef, El } static unsigned long _get_new_addr_by_sym(elf_link_t *elf_link, elf_file_t *ef, - Elf64_Sym *sym, bool is_dynsym) + Elf64_Sym *sym) { - char *sym_name = NULL; - if (is_dynsym) { - sym_name = elf_get_dynsym_name(ef, sym); - } else { - sym_name = elf_get_symbol_name(ef, sym); - } + char *sym_name = elf_get_sym_name(ef, sym); // WEAK func is used by GNU debug, libc do not have that func if (is_gnu_weak_symbol(sym) == true) { @@ -783,23 +898,18 @@ static unsigned long _get_new_addr_by_sym(elf_link_t *elf_link, elf_file_t *ef, return _get_new_addr_by_sym_name(elf_link, sym_name); } -unsigned long get_new_addr_by_sym_ok(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym) +unsigned long get_new_addr_by_symobj_ok(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym) { - unsigned long ret = _get_new_addr_by_sym(elf_link, ef, sym, false); + unsigned long ret = _get_new_addr_by_sym(elf_link, ef, sym); if (ret == NOT_FOUND) { return 0; } return ret; } -unsigned long get_new_addr_by_sym(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym) -{ - return _get_new_addr_by_sym(elf_link, ef, sym, false); -} - -unsigned long get_new_addr_by_dynsym(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym) +unsigned long get_new_addr_by_symobj(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym) { - return _get_new_addr_by_sym(elf_link, ef, sym, true); + return _get_new_addr_by_sym(elf_link, ef, sym); } unsigned long elf_get_new_tls_offset(elf_link_t *elf_link, elf_file_t *ef, unsigned long obj_tls_offset) @@ -847,7 +957,7 @@ int get_new_sym_index_no_clear(elf_link_t *elf_link, elf_file_t *src_ef, unsigne return 0; } - const char *name = get_sym_name_dynsym(src_ef, old_index); + const char *name = elf_get_dynsym_name_by_index(src_ef, old_index); return find_dynsym_index_by_name(&elf_link->out_ef, name, false); } @@ -858,7 +968,7 @@ int get_new_sym_index(elf_link_t *elf_link, elf_file_t *src_ef, unsigned int old return 0; } - const char *name = get_sym_name_dynsym(src_ef, old_index); + const char *name = elf_get_dynsym_name_by_index(src_ef, old_index); return find_dynsym_index_by_name(&elf_link->out_ef, name, true); } diff --git a/src/elf_link_common.h b/src/elf_link_common.h index bb587941d7b7bbed993680381b8b34bacffe7648..0bf5a3fd0e8c22ea2f5009b53d80d8b528587050 100644 --- a/src/elf_link_common.h +++ b/src/elf_link_common.h @@ -274,24 +274,24 @@ static inline void modify_elf_file(elf_link_t *elf_link, unsigned long loc, void bool is_symbol_maybe_undefined(const char *name); bool is_gnu_weak_symbol(Elf64_Sym *sym); +bool is_section_needed(elf_link_t *elf_link, elf_file_t *ef, Elf64_Shdr *sec); -unsigned long get_new_offset_by_old_offset(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long offset); unsigned long get_new_addr_by_old_addr(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long addr); -unsigned long _get_new_elf_addr(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long addr); +unsigned long get_new_addr_by_old_addr_ok(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long addr); +unsigned long get_new_offset_by_old_offset(elf_link_t *elf_link, elf_file_t *src_ef, unsigned long offset); +unsigned long get_new_addr_by_symobj_ok(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym); +unsigned long get_new_addr_by_symobj(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym); + int get_new_section_index(elf_link_t *elf_link, elf_file_t *src_ef, unsigned int sec_index); unsigned long get_new_name_offset(elf_link_t *elf_link, elf_file_t *src_ef, Elf64_Shdr *src_sec, unsigned long offset); +int get_new_sym_index_no_clear(elf_link_t *elf_link, elf_file_t *src_ef, unsigned int old_index); +int get_new_sym_index(elf_link_t *elf_link, elf_file_t *src_ef, unsigned int old_index); +// for temp sections char *elf_get_tmp_section_name(elf_link_t *elf_link, Elf64_Shdr *shdr); Elf64_Shdr *find_tmp_section_by_name(elf_link_t *elf_link, const char *sec_name); Elf64_Shdr *find_tmp_section_by_src(elf_link_t *elf_link, Elf64_Shdr *shdr); -unsigned long get_new_addr_by_sym_ok(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym); -unsigned long get_new_addr_by_sym(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym); -unsigned long get_new_addr_by_dynsym(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym); - -int get_new_sym_index_no_clear(elf_link_t *elf_link, elf_file_t *src_ef, unsigned int old_index); -int get_new_sym_index(elf_link_t *elf_link, elf_file_t *src_ef, unsigned int old_index); - void show_sec_mapping(elf_link_t *elf_link); void append_sec_mapping(elf_link_t *elf_link, elf_file_t *ef, Elf64_Shdr *sec, Elf64_Shdr *dst_sec); void append_obj_mapping(elf_link_t *elf_link, elf_file_t *ef, Elf64_Shdr *sec, void *src_obj, void *dst_obj); diff --git a/src/elf_link_elf.c b/src/elf_link_elf.c index c21688ac9ce09fb45f4a0c4761725d696efb221e..a6ee43c2bd1f2eb4edfdb7b2a54e313cbdab6029 100644 --- a/src/elf_link_elf.c +++ b/src/elf_link_elf.c @@ -178,78 +178,6 @@ void copy_elf_file(elf_file_t *in, off_t in_offset, elf_file_t *out, off_t out_o (void)memcpy(dest, src, len); } -// .interp is needed by dyn-mode, staitc-mode template do not have -static char *needed_sections[] = { - ".interp", - ".note.gnu.build-id", - ".note.ABI-tag", - ".gnu.hash", - ".dynsym", - ".dynstr", - ".rela.dyn", - ".rela.plt", - ".text", - ".rodata", - ".eh_frame_hdr", // this section's header is not modified, is it really needed? - ".tdata", - ".tbss", - ".init_array", - ".fini_array", - ".data.rel.ro", - ".dynamic", - ".got", - ".data", - ".bss", - ".symtab", - ".strtab", - ".shstrtab", -}; -#define NEEDED_SECTIONS_LEN (sizeof(needed_sections) / sizeof(needed_sections[0])) - -static bool is_section_needed(elf_link_t *elf_link, elf_file_t *ef, Elf64_Shdr *sec) -{ - char *name = elf_get_section_name(ef, sec); - - // first section name is empty - if (name == NULL || *name == '\0') { - return true; - } - - // no use .plt, so delete .rela.plt - if (is_direct_call_optimize(elf_link) == true) { - if (!strcmp(name, ".rela.plt")) { - return false; - } - } - - for (unsigned i = 0; i < NEEDED_SECTIONS_LEN; i++) { - if (!strcmp(name, needed_sections[i])) { - return true; - } - } - - if (is_delete_symbol_version(elf_link) == false) { - if (!strcmp(name, ".gnu.version") || !strcmp(name, ".gnu.version_r")) { - return true; - } - } - - return false; - - /* - TODO: clean code, below is original implementation, don't have any effect now - if ((sec->sh_type == SHT_RELA) && (!(sec->sh_flags & SHF_ALLOC))) - return false; - if (sec->sh_type == SHT_GNU_versym || sec->sh_type == SHT_GNU_verdef || - sec->sh_type == SHT_GNU_verneed) - return false; - if (elf_is_debug_section(ef, sec)) - return false; - - return true; - */ -} - static Elf64_Shdr *add_tmp_section(elf_link_t *elf_link, elf_file_t *ef, Elf64_Shdr *src_sec) { if (is_section_needed(elf_link, ef, src_sec) == false) { @@ -1222,6 +1150,11 @@ static int sym_cmp_func(const void *src_sym_a_, const void *src_sym_b_) static inline Elf64_Addr get_symbol_new_value(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym, char *name) { + if (elf_is_symbol_type_section(sym)) { + // section may be delete in out ef, so section symbol can not get new value + return get_new_addr_by_old_addr_ok(elf_link, ef, sym->st_value); + } + // _get_new_elf_addr will be unable to find symbol addr if // it is the boundary of two sections and no shndx is available. // _DYNAMIC is the the start of .dynamic @@ -1247,11 +1180,11 @@ static inline Elf64_Addr get_symbol_new_value(elf_link_t *elf_link, elf_file_t * si_panic("elf_find_section_by_name fail: __libc_atexit\n"); } unsigned long old_start_addr = sec->sh_addr; - unsigned long new_start_addr = _get_new_elf_addr(elf_link, ef, old_start_addr); + unsigned long new_start_addr = get_new_addr_by_old_addr(elf_link, ef, old_start_addr); return new_start_addr + sec->sh_size; } - return _get_new_elf_addr(elf_link, ef, sym->st_value); + return get_new_addr_by_old_addr(elf_link, ef, sym->st_value); } static inline Elf32_Section get_symbol_new_section(elf_link_t *elf_link, elf_file_t *ef, @@ -1277,8 +1210,15 @@ static inline Elf64_Word get_symbol_new_name(elf_link_t *elf_link, elf_file_t *e return get_new_name_offset(elf_link, ef, strtab, name); } -// after dst_sym->st_name modify, then elf_get_symbol_name for the out_ef can use -static void modify_symbol(elf_link_t *elf_link, Elf64_Shdr *sec, bool is_dynsym) +static inline Elf64_Sym *get_src_sym_by_dst(elf_link_t *elf_link, Elf64_Sym *dst_sym, elf_sec_mapping_t *m) +{ + unsigned long out_ef_sec_begin = ((unsigned long)elf_link->out_ef.hdr) + m->dst_file_offset; + unsigned long offset_to_sec = (unsigned long)dst_sym - out_ef_sec_begin; + void *sec_data = elf_get_section_data(m->src_ef, m->src_sec); + return (Elf64_Sym *)(sec_data + offset_to_sec); +} + +static void modify_symbol(elf_link_t *elf_link, Elf64_Shdr *sec) { int len = sec->sh_size / sizeof(Elf64_Sym); Elf64_Sym *base = ((void *)elf_link->out_ef.hdr) + sec->sh_offset; @@ -1286,20 +1226,15 @@ static void modify_symbol(elf_link_t *elf_link, Elf64_Shdr *sec, bool is_dynsym) for (int i = 0; i < len; i++) { Elf64_Sym *dst_sym = &base[i]; elf_sec_mapping_t *m = elf_find_sec_mapping_by_dst(elf_link, dst_sym); + Elf64_Sym *src_sym = get_src_sym_by_dst(elf_link, dst_sym, m); - dst_sym->st_shndx = get_symbol_new_section(elf_link, m->src_ef, dst_sym); - dst_sym->st_name = get_symbol_new_name(elf_link, m->src_ef, dst_sym, m->src_sec->sh_link); + dst_sym->st_shndx = get_symbol_new_section(elf_link, m->src_ef, src_sym); + dst_sym->st_name = get_symbol_new_name(elf_link, m->src_ef, src_sym, m->src_sec->sh_link); - // after dst_sym->st_name modify, then elf_get_symbol_name for the out_ef can use - char *name = NULL; - if (is_dynsym == true) { - name = elf_get_dynsym_name(&elf_link->out_ef, dst_sym); - } else { - name = elf_get_symbol_name(&elf_link->out_ef, dst_sym); - } - SI_LOG_DEBUG("modify_symbol: %s\n", name); + char *name = elf_get_sym_name(m->src_ef, src_sym); + SI_LOG_DEBUG("sym name: %s %s\n", m->src_ef->file_name, name); - dst_sym->st_value = get_symbol_new_value(elf_link, m->src_ef, dst_sym, name); + dst_sym->st_value = get_symbol_new_value(elf_link, m->src_ef, src_sym, name); } } @@ -1313,7 +1248,7 @@ static Elf64_Sym *find_defined_symbol(elf_file_t *ef, Elf64_Shdr *sec, char *sym if (dst_sym->st_shndx == SHN_UNDEF || dst_sym->st_name == 0) { continue; } - char *name = elf_get_dynsym_name(ef, dst_sym); + char *name = elf_get_sym_name(ef, dst_sym); if (elf_is_same_symbol_name(sym_name, name)) { return dst_sym; } @@ -1332,7 +1267,7 @@ static void delete_undefined_symbol(elf_file_t *ef, Elf64_Shdr *sec) if (dst_sym->st_shndx != SHN_UNDEF || dst_sym->st_name == 0) { continue; } - char *name = elf_get_dynsym_name(ef, dst_sym); + char *name = elf_get_sym_name(ef, dst_sym); Elf64_Sym *find = find_defined_symbol(ef, sec, name); if (find != NULL) { (void)memset(dst_sym, 0, sizeof(Elf64_Sym)); @@ -1410,9 +1345,9 @@ static void modify_hash(elf_file_t *elf_file, Elf64_Shdr *sec, Elf64_Shdr *dyn, static void modify_dynsym(elf_link_t *elf_link) { - SI_LOG_DEBUG("modify_dynsym: \n"); + SI_LOG_DEBUG("modify dynsym: \n"); Elf64_Shdr *sec = find_tmp_section_by_name(elf_link, ".dynsym"); - modify_symbol(elf_link, sec, true); + modify_symbol(elf_link, sec); // delete undefined symbol, so dlsym can find the addr delete_undefined_symbol(&elf_link->out_ef, sec); @@ -1429,9 +1364,9 @@ static void modify_dynsym(elf_link_t *elf_link) static void modify_symtab(elf_link_t *elf_link) { - SI_LOG_DEBUG("modify_symtab: \n"); + SI_LOG_DEBUG("modify symtab: \n"); Elf64_Shdr *sec = find_tmp_section_by_name(elf_link, ".symtab"); - modify_symbol(elf_link, sec, false); + modify_symbol(elf_link, sec); sort_symbol_table(&elf_link->out_ef, sec); @@ -1542,7 +1477,7 @@ static void modify_init_and_fini(elf_link_t *elf_link) elf_file_t *ef = get_main_ef(elf_link); for (unsigned j = 0; j < DISABLED_FUNCS_LEN; j++) { Elf64_Sym *sym = elf_find_symbol_by_name(ef, disabled_funcs[j]); - unsigned long addr = get_new_addr_by_sym_ok(elf_link, ef, sym); + unsigned long addr = get_new_addr_by_symobj_ok(elf_link, ef, sym); if (hdr->e_machine == EM_AARCH64) { elf_write_u32(out_ef, addr, AARCH64_INSN_RET); } else { diff --git a/src/elf_read_elf.c b/src/elf_read_elf.c index 3181377955b864a34a33bff73a94bfd77b0dedab..22c69436e9026b8d110dbac7e1860a5bc46e42b7 100644 --- a/src/elf_read_elf.c +++ b/src/elf_read_elf.c @@ -46,11 +46,6 @@ static inline char *elf_get_version_name(elf_file_t *ef, Elf64_Vernaux *vernaux) return ef->dynstr_data + vernaux->vna_name; } -static inline void *elf_get_section_data(elf_file_t *ef, Elf64_Shdr *sec) -{ - return (((void *)ef->hdr) + sec->sh_offset); -} - static inline Elf64_Shdr *elf_get_version_section(elf_file_t *ef) { return elf_find_section_by_name(ef, ".gnu.version"); @@ -97,21 +92,18 @@ char *elf_get_dynsym_version_name(elf_file_t *ef, Elf64_Sym *sym) return elf_get_version_name(ef, vernaux); } -bool elf_is_copy_symbol(elf_file_t *ef, Elf64_Sym *sym, bool is_dynsym) +bool elf_is_copy_symbol(elf_file_t *ef, Elf64_Sym *sym) { - char *sym_name = NULL; + char *sym_name = elf_get_sym_name(ef, sym); + bool is_dynsym = elf_is_dynsym(ef, sym); if (is_dynsym) { - sym_name = elf_get_dynsym_name(ef, sym); // stdout@GLIBC_2.2.5 (2) - // TODO: char *version_name = elf_get_dynsym_version_name(ef, sym); if (version_name == NULL) { return false; } - printf("zk--- %s %s\n", sym_name, version_name); return true; } else { - sym_name = elf_get_symbol_name(ef, sym); // symtab name have @LIBC char *c = index(sym_name, '@'); if (c) { @@ -150,15 +142,15 @@ bool elf_is_same_symbol_name(const char *a, const char *b) int find_dynsym_index_by_name(elf_file_t *ef, const char *name, bool clear) { - Elf64_Sym *syms = (Elf64_Sym *)(((void *)ef->hdr) + ef->dynsym_sec->sh_offset); - int count = ef->dynsym_sec->sh_size / sizeof(Elf64_Sym); + Elf64_Sym *syms = elf_get_dynsym_array(ef); + int count = elf_get_dynsym_count(ef); int found_index = -1; Elf64_Sym *sym = NULL; char *sym_name = NULL; for (int i = 0; i < count; i++) { sym = &syms[i]; - sym_name = elf_get_dynsym_name(ef, sym); + sym_name = elf_get_sym_name(ef, sym); if (elf_is_same_symbol_name(sym_name, name)) { if (clear && sym->st_shndx != 0) { return NEED_CLEAR_RELA; @@ -175,12 +167,6 @@ int find_dynsym_index_by_name(elf_file_t *ef, const char *name, bool clear) return found_index; } -char *get_sym_name_dynsym(elf_file_t *ef, unsigned int index) -{ - Elf64_Sym *syms = (Elf64_Sym *)(((void *)ef->hdr) + ef->dynsym_sec->sh_offset); - return elf_get_dynsym_name(ef, &syms[index]); -} - int elf_find_func_range_by_name(elf_file_t *ef, const char *func_name, unsigned long *start, unsigned long *end) { @@ -218,7 +204,7 @@ unsigned elf_find_symbol_index_by_name(elf_file_t *ef, const char *name) for (int i = 0; i < count; i++) { Elf64_Sym *sym = &syms[i]; - char *sym_name = elf_get_symbol_name(ef, sym); + char *sym_name = elf_get_sym_name(ef, sym); SI_LOG_DEBUG("%s %s\n", name, sym_name); if (elf_is_same_symbol_name(sym_name, name)) { return i; @@ -274,6 +260,7 @@ Elf64_Shdr *elf_find_section_by_addr(elf_file_t *ef, unsigned long addr) for (int i = 1; i < shnum; i++) { sec = &sechdrs[i]; + // sh_addr is zero when not SHF_ALLOC if (!(sec->sh_flags & SHF_ALLOC)) { continue; } @@ -291,7 +278,7 @@ Elf64_Shdr *elf_find_section_by_tls_offset(elf_file_t *ef, unsigned long obj_tls unsigned long addr = obj_tls_offset + ef->tls_Phdr->p_paddr; Elf64_Shdr *sec = elf_find_section_by_addr(ef, addr); - if (!(sec->sh_flags & SHF_TLS)) { + if ((sec == NULL) || !(sec->sh_flags & SHF_TLS)) { si_panic("elf_find_section_by_tls_offset fail\n"); return NULL; } @@ -749,11 +736,11 @@ void elf_show_dynsym(elf_file_t *ef) SI_LOG_DEBUG(" [Nr] Name\n"); - int sym_count = ef->dynsym_sec->sh_size / sizeof(Elf64_Sym); - Elf64_Sym *syms = (Elf64_Sym *)(((void *)ef->hdr) + ef->dynsym_sec->sh_offset); + int sym_count = elf_get_dynsym_count(ef); + Elf64_Sym *syms = elf_get_dynsym_array(ef); for (int j = 0; j < sym_count; j++) { Elf64_Sym *sym = &syms[j]; - char *name = elf_get_dynsym_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); SI_LOG_DEBUG(" [%2d] %-32s %016lx\n", j, name, sym->st_value); } } diff --git a/src/elf_read_elf.h b/src/elf_read_elf.h index 64e8005762986e4b46386f88ca231e0672b58605..a5cf7b11c32df9ced2b44b93b15d05070e317b6f 100644 --- a/src/elf_read_elf.h +++ b/src/elf_read_elf.h @@ -49,10 +49,9 @@ typedef struct { char *build_id; } elf_file_t; -static inline unsigned int elf_get_dynsym_index(elf_file_t *ef, Elf64_Sym *sym) +static inline void *elf_get_section_data(elf_file_t *ef, Elf64_Shdr *sec) { - Elf64_Sym *syms = (Elf64_Sym *)(((void *)ef->hdr) + ef->dynsym_sec->sh_offset); - return sym - syms; + return (((void *)ef->hdr) + sec->sh_offset); } static inline char *elf_get_section_name(const elf_file_t *ef, const Elf64_Shdr *sec) @@ -65,9 +64,18 @@ static inline char *elf_get_dynsym_name(elf_file_t *ef, Elf64_Sym *sym) return ef->dynstr_data + sym->st_name; } -static inline char *elf_get_symbol_name(elf_file_t *ef, Elf64_Sym *sym) +static inline bool elf_is_symbol_type_section(Elf64_Sym *sym) { if (ELF64_ST_TYPE(sym->st_info) == STT_SECTION) { + return true; + } + + return false; +} + +static inline char *elf_get_symbol_name(elf_file_t *ef, Elf64_Sym *sym) +{ + if (elf_is_symbol_type_section(sym)) { Elf64_Shdr *sec = &ef->sechdrs[sym->st_shndx]; return elf_get_section_name(ef, sec); } @@ -75,6 +83,52 @@ static inline char *elf_get_symbol_name(elf_file_t *ef, Elf64_Sym *sym) return ef->strtab_data + sym->st_name; } +static inline Elf64_Sym *elf_get_dynsym_array(elf_file_t *ef) +{ + return (Elf64_Sym *)elf_get_section_data(ef, ef->dynsym_sec); +} + +static inline int elf_get_dynsym_count(elf_file_t *ef) +{ + return ef->dynsym_sec->sh_size / sizeof(Elf64_Sym); +} + +static inline unsigned int elf_get_dynsym_index(elf_file_t *ef, Elf64_Sym *sym) +{ + Elf64_Sym *syms = elf_get_dynsym_array(ef); + return sym - syms; +} + +static inline char *elf_get_dynsym_name_by_index(elf_file_t *ef, unsigned int index) +{ + Elf64_Sym *syms = elf_get_dynsym_array(ef); + return elf_get_dynsym_name(ef, &syms[index]); +} + +static inline bool elf_is_dynsym(elf_file_t *ef, Elf64_Sym *sym) +{ + unsigned long begin = (unsigned long)elf_get_dynsym_array(ef); + unsigned long end = begin + ef->dynsym_sec->sh_size; + unsigned long addr = (unsigned long)sym; + if ((addr >= begin) && (addr < end)) { + return true; + } + + return false; +} + +static inline char *elf_get_sym_name(elf_file_t *ef, Elf64_Sym *sym) +{ + char *sym_name = NULL; + bool is_dynsym = elf_is_dynsym(ef, sym); + if (is_dynsym == true) { + sym_name = elf_get_dynsym_name(ef, sym); + } else { + sym_name = elf_get_symbol_name(ef, sym); + } + return sym_name; +} + static inline Elf64_Sym *elf_get_symtab_by_rela(elf_file_t *ef, Elf64_Rela *rela) { return (Elf64_Sym *)((void *)ef->hdr + ef->symtab_sec->sh_offset) + ELF64_R_SYM(rela->r_info); @@ -82,7 +136,7 @@ static inline Elf64_Sym *elf_get_symtab_by_rela(elf_file_t *ef, Elf64_Rela *rela static inline Elf64_Sym *elf_get_dynsym_by_rela(elf_file_t *ef, Elf64_Rela *rela) { - return (Elf64_Sym *)((void *)ef->hdr + ef->dynsym_sec->sh_offset) + ELF64_R_SYM(rela->r_info); + return elf_get_dynsym_array(ef) + ELF64_R_SYM(rela->r_info); } unsigned long elf_va_to_offset(elf_file_t *ef, unsigned long va); @@ -94,9 +148,9 @@ unsigned elf_find_symbol_index_by_name(elf_file_t *ef, const char *name); Elf64_Sym *elf_find_symbol_by_name(elf_file_t *ef, const char *sym_name); unsigned long elf_find_symbol_addr_by_name(elf_file_t *ef, char *sym_name); bool elf_is_same_symbol_name(const char *a, const char *b); -char *get_sym_name_dynsym(elf_file_t *ef, unsigned int index); +char *elf_get_dynsym_name_by_index(elf_file_t *ef, unsigned int index); int find_dynsym_index_by_name(elf_file_t *ef, const char *name, bool clear); -bool elf_is_copy_symbol(elf_file_t *ef, Elf64_Sym *sym, bool is_dynsym); +bool elf_is_copy_symbol(elf_file_t *ef, Elf64_Sym *sym); // section Elf64_Shdr *elf_find_section_by_tls_offset(elf_file_t *ef, unsigned long obj_tls_offset); diff --git a/src/elf_relocation.c b/src/elf_relocation.c index 75912ca25e4899688fd18f06f5416f79c0908f30..9393a69b28a8f64df9e21e0b095a5aa3faac7c6b 100644 --- a/src/elf_relocation.c +++ b/src/elf_relocation.c @@ -127,11 +127,11 @@ static void modify_rela_to_RELATIVE(elf_link_t *elf_link, elf_file_t *src_ef, El { // some symbol do not export in .dynsym, change to R_AARCH64_RELATIVE Elf64_Sym *sym = elf_get_dynsym_by_rela(src_ef, src_rela); - unsigned long ret = get_new_addr_by_dynsym(elf_link, src_ef, sym); + unsigned long ret = get_new_addr_by_symobj(elf_link, src_ef, sym); if (ret == NOT_FOUND) { // 1008: 48 8b 05 d9 2f 00 00 mov 0x2fd9(%rip),%rax # 3fe8 <__gmon_start__@Base> // some addr need be 0, use by cmp jump - char *name = elf_get_dynsym_name(src_ef, sym); + char *name = elf_get_sym_name(src_ef, sym); if (!is_symbol_maybe_undefined(name)) { si_panic("%s\n", name); } @@ -151,12 +151,12 @@ static void rela_use_relative(elf_link_t *elf_link, elf_file_t *src_ef, Elf64_Re elf_file_t *ef = get_libc_ef(elf_link); Elf64_Sym *sym = elf_get_dynsym_by_rela(src_ef, src_rela); - if (elf_is_copy_symbol(src_ef, sym, true) == false) { + if (elf_is_copy_symbol(src_ef, sym) == false) { // use local symbol addr ef = src_ef; } - char *sym_name = elf_get_dynsym_name(src_ef, sym); + char *sym_name = elf_get_sym_name(src_ef, sym); unsigned long old_sym_addr = elf_find_symbol_addr_by_name(ef, sym_name); unsigned long new_sym_addr = get_new_addr_by_old_addr(elf_link, ef, old_sym_addr); if (new_sym_addr == NOT_FOUND) { @@ -205,7 +205,7 @@ void modify_rela_dyn_item(elf_link_t *elf_link, elf_file_t *src_ef, Elf64_Rela * // 129a: 4c 8b 2d 4f 2d 00 00 mov 0x2d4f(%rip),%r13 # 3ff0 <___g_so_path_list@@Base-0x10> // 48: 0000000000004000 4096 OBJECT GLOBAL DEFAULT 27 ___g_so_path_list new_index = ELF64_R_SYM(dst_rela->r_info); - const char *sym_name = get_sym_name_dynsym(&elf_link->out_ef, new_index); + const char *sym_name = elf_get_dynsym_name_by_index(&elf_link->out_ef, new_index); if (elf_is_same_symbol_name(sym_name, "___g_so_path_list")) { // when ELF load, real addr will set dst_rela->r_info = ELF64_R_INFO(new_index, ELF64_R_TYPE(R_X86_64_RELATIVE)); diff --git a/src/elf_relocation_aarch64.c b/src/elf_relocation_aarch64.c index 754f45252464323d4ad74a9de25c5f71b44155b1..59dd86f160b2a84c61ec5ed385c3caede97e8314 100644 --- a/src/elf_relocation_aarch64.c +++ b/src/elf_relocation_aarch64.c @@ -394,7 +394,7 @@ static void fix_special_symbol_new_addr(elf_link_t *elf_link, elf_file_t *ef, El // template ELF .init_array is merge last one // __init_array_start need set begin of .init_array addr // __init_array_end need set end of .init_array addr - char *name = elf_get_symbol_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); if (elf_is_same_symbol_name(name, "__init_array_start")) { Elf64_Shdr *sec = find_tmp_section_by_name(elf_link, ".init_array"); *new_addr = sec->sh_addr; @@ -554,7 +554,7 @@ bool is_gmon_start_symbol(elf_file_t *ef, Elf64_Sym *sym) return false; } - char *name = elf_get_symbol_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); if (elf_is_same_symbol_name(name, "__gmon_start__")) { return true; } @@ -564,7 +564,7 @@ bool is_gmon_start_symbol(elf_file_t *ef, Elf64_Sym *sym) bool is_ehdr_start_symbol(elf_file_t *ef, Elf64_Sym *sym) { // 1689: 0000000000000000 0 NOTYPE LOCAL DEFAULT 1 __ehdr_start - char *name = elf_get_symbol_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); if (elf_is_same_symbol_name(name, "__ehdr_start")) { return true; } @@ -694,13 +694,13 @@ static void modify_branch_insn(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rela // For static ELF, the symbol that type is IFUNC need special treatment if (ELF64_ST_TYPE(sym->st_info) == STT_GNU_IFUNC) { - new_sym_addr = get_new_addr_by_sym_ok(elf_link, ef, sym); + new_sym_addr = get_new_addr_by_symobj_ok(elf_link, ef, sym); goto out; } else if (sym->st_value) { old_sym_addr = sym->st_value + rela->r_addend; new_sym_addr = get_new_addr_by_old_addr(elf_link, ef, old_sym_addr); } else { - new_sym_addr = get_new_addr_by_sym_ok(elf_link, ef, sym); + new_sym_addr = get_new_addr_by_symobj_ok(elf_link, ef, sym); } // WEAK func is used by GNU debug, libc do not have that func @@ -708,7 +708,7 @@ static void modify_branch_insn(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rela goto out; } - char *name = elf_get_symbol_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); if (unlikely(elf_is_same_symbol_name(name, "main"))) { elf_file_t *main_ef = get_main_ef(elf_link); old_sym_addr = elf_find_symbol_addr_by_name(main_ef, "main"); @@ -972,7 +972,7 @@ void modify_rela_plt(elf_link_t *elf_link, si_array_t *arr) case R_AARCH64_JUMP_SLOT: // 00000000003fffc8 0000000800000402 R_AARCH64_JUMP_SLOT 0000000000000000 puts@GLIBC_2.17 + 0 sym = elf_get_dynsym_by_rela(obj_rel->src_ef, src_rela); - ret = get_new_addr_by_dynsym(elf_link, obj_rel->src_ef, sym); + ret = get_new_addr_by_symobj(elf_link, obj_rel->src_ef, sym); if (ret == NOT_FOUND) { ret = 0; } diff --git a/src/elf_relocation_x86_64.c b/src/elf_relocation_x86_64.c index b127c89b686d15927a44d04d8b360c342b4d0bd3..cce2625d96281a569ce76eaa1ff60f0392796c07 100644 --- a/src/elf_relocation_x86_64.c +++ b/src/elf_relocation_x86_64.c @@ -79,7 +79,7 @@ static void elf_write_jmp_addr(elf_file_t *ef, unsigned long addr_, unsigned lon static int modify_insn_direct_jmp(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rela *rela, Elf64_Sym *sym) { unsigned long loc = get_new_addr_by_old_addr(elf_link, ef, rela->r_offset); - unsigned long sym_addr = get_new_addr_by_sym_ok(elf_link, ef, sym); + unsigned long sym_addr = get_new_addr_by_symobj_ok(elf_link, ef, sym); if (sym_addr == 0) { return -1; } @@ -212,13 +212,11 @@ static void modify_tls_insn_got(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rela static void modify_insn_data_offset(elf_link_t *elf_link, elf_file_t *ef, unsigned long loc, int addend) { int offset_in_insn = elf_read_s32_va(ef, loc); - // obj old addr - unsigned long obj_addr = offset_in_insn + loc - addend; - // new addr - obj_addr = get_new_addr_by_old_addr(elf_link, ef, obj_addr); - loc = get_new_addr_by_old_addr(elf_link, ef, loc); + unsigned long old_obj_addr = offset_in_insn + loc - addend; + unsigned long new_obj_addr = get_new_addr_by_old_addr(elf_link, ef, old_obj_addr); + unsigned long new_loc = get_new_addr_by_old_addr(elf_link, ef, loc); - modify_insn_offset(elf_link, loc, obj_addr, addend); + modify_insn_offset(elf_link, new_loc, new_obj_addr, addend); } static bool is_need_change_addr(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym *sym) @@ -235,7 +233,7 @@ static bool is_need_change_addr(elf_link_t *elf_link, elf_file_t *ef, Elf64_Sym return true; } - char *sym_name = elf_get_symbol_name(ef, sym); + char *sym_name = elf_get_sym_name(ef, sym); unsigned long ret = get_new_addr_by_symbol_mapping(elf_link, sym_name); if (ret != NOT_FOUND) { return true; @@ -264,14 +262,14 @@ static void modify_insn_func_offset(elf_link_t *elf_link, elf_file_t *ef, Elf64_ // This is where to make the change unsigned long loc = get_new_addr_by_old_addr(elf_link, ef, rela->r_offset); - unsigned long sym_addr = get_new_addr_by_sym_ok(elf_link, ef, sym); + unsigned long sym_addr = get_new_addr_by_symobj_ok(elf_link, ef, sym); if (sym_addr == 0) { // share mode libc func is use plt, no need change if (is_share_mode(elf_link)) { return; } - const char *sym_name = elf_get_symbol_name(ef, sym); + const char *sym_name = elf_get_sym_name(ef, sym); if (is_symbol_maybe_undefined(sym_name)) { goto out; } @@ -294,7 +292,7 @@ static void fix_main_for_static_mode(elf_link_t *elf_link, elf_file_t *ef, Elf64 // 00000000002011fb 00000dd500000002 R_X86_64_PC32 0000000000200af0 main - 4 // 3541: 0000000000200af0 1763 FUNC GLOBAL DEFAULT 13 main // 2011f8: 48 8d 3d f1 f8 ff ff lea -0x70f(%rip),%rdi # 200af0
- char *name = elf_get_symbol_name(ef, sym); + char *name = elf_get_sym_name(ef, sym); if (elf_is_same_symbol_name(name, "main")) { modify_insn_func_offset(elf_link, ef, rela, sym); } @@ -317,8 +315,8 @@ static void modify_insn_for_pc32(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rel // libc environ is weak, so other ELF have the some var // feature: 48 89 05 96 f8 0d 00 mov %rax,0xdf896(%rip) // 952: 00000000001f4ce0 8 OBJECT WEAK DEFAULT 44 environ@@GLIBC_2.2.5 - if (is_direct_point_var_optimize(elf_link) && elf_is_copy_symbol(ef, sym, false)) { - unsigned long sym_addr = get_new_addr_by_sym(elf_link, ef, sym); + if (is_direct_point_var_optimize(elf_link) && elf_is_copy_symbol(ef, sym)) { + unsigned long sym_addr = get_new_addr_by_symobj(elf_link, ef, sym); if (sym_addr != NOT_FOUND) { unsigned char *insn = get_insn_begin_by_offset(elf_link, ef, rela); int ret = elf_insn_change_mov_to_lea(insn); @@ -339,6 +337,17 @@ static void modify_insn_for_pc32(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rel modify_insn_data_offset(elf_link, ef, rela->r_offset, rela->r_addend); } +// rela r_addend not have offset to symbol, so get offset form insn imm value +// 00000000000398fb 000024440000002a R_X86_64_REX_GOTPCRELX 00000000001ec648 __ctype_b@GLIBC_2.2.5 - 4 +// 9284: 00000000001ec648 8 OBJECT GLOBAL DEFAULT 36 __ctype_b@GLIBC_2.2.5 +// 398f8: 48 8b 0d 81 25 1b 00 mov 0x1b2581(%rip),%rcx # 1ebe80 <__ctype_b@GLIBC_2.2.5-0x7c8> +// 0x1ec648 - 0x7c8 = 1ebe80 +static void modify_insn_imm_offset(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rela *rela, Elf64_Sym *sym) +{ + (void)sym; + modify_insn_data_offset(elf_link, ef, rela->r_offset, rela->r_addend); +} + // retrun value tell skip num int modify_local_call_rela(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rela *rela) { @@ -408,8 +417,7 @@ int modify_local_call_rela(elf_link_t *elf_link, elf_file_t *ef, Elf64_Rela *rel break; case R_X86_64_GOTPCREL: case R_X86_64_REX_GOTPCRELX: - // TODO: feature, sym may not exist, change data offset - modify_insn_data_offset(elf_link, ef, rela->r_offset, rela->r_addend); + modify_insn_imm_offset(elf_link, ef, rela, sym); break; case R_X86_64_64: case R_X86_64_32S: diff --git a/tests/bash/Makefile b/tests/bash/Makefile index a1ef80424f74d73cdcb068fbf546c14dfb421f7a..caccf9f24867e3ad1ab44d8c3fdec7c897b6d77a 100644 --- a/tests/bash/Makefile +++ b/tests/bash/Makefile @@ -11,6 +11,7 @@ BASH=/usr/bin/bash BASH_R=$(RELOCATION_DIR)$(BASH).relocation LIBC=/usr/lib64/libc.so.6 +# relocation is xz LIBC_R=$(RELOCATION_DIR)$(LIBC).relocation VERSION_ID=$(shell cat /etc/os-release | grep VERSION_ID) @@ -79,8 +80,8 @@ run: env: echo 0 > /proc/sys/kernel/randomize_va_space cat /proc/sys/kernel/randomize_va_space - readelf -W -a $(BASH_R) > bash.elf - objdump -d $(BASH_R) > bash.asm + readelf -W -a $(BASH) > bash.elf + objdump -d $(BASH) > bash.asm readelf -W -a $(LIBC_R) > libc.so.elf objdump -d $(LIBC_R) > libc.so.asm readelf -W -a $(LIBTINFO_R) > libtinfo.so.elf