如何修改动态库符号表

静态库和动态库相关知识 iOS和静态库和动态库相关知识 Symbol Type 说明 U undefined(未定义) A absolute(绝对符号) T text section symbol(__TEXT.__text) D data section symbol(__DATA.__data) B bss section symbol(__DATA.__bss) C common symbol(只能出现在 类型的文件中) - debugger symbol table S ... 阅读详情

如何修改动态库符号表


    一、ELF 文件和有关术语

Unix 系统的可执行文件和动态库文件是以 ELF 格式存放的。为使下面的叙述
清晰而没有伎义,先简要介绍一下 ELF 文件格式,并约定一些术语。关于ELF
文件格式的详细情况请参看有关文献。

ELF 文件中代码、连接信息和注释是以节(section)为单位存放的,并存有一
个节头表(section header)。对每一节,在节头表中都有一个表项(节头表项)
与之对应,表项记录了该节的一些信息,例如该节在文件中的位置信息和该节
的字节长度信息。

程序运行读入内存时,是以程序段(program segment)为单位读入的。在 ELF
文件中有一个程序头表(program header table),每个程序段在程序头表中有
一个表项(程序头表项)与之对应,表项记录了该程序段的有关信息,例如该程
序段在文件中的位置信息和该程序段的字节长度信息。程序段的内容由若干节
组成,节的内容组合在一起连成一片构成程序段的内容。

在所有这些节中,有一节的内容由字符串构成,这些字符串是各节的名称,叫
节名。下面称这一节为节名表。另有一节,节名为".dynsym",它的内容为符
号表,符号表的每一表项记录了一个符号的有关信息,例如该符号对应的代码
的地址值。还有一节,节名为".dynstr",它的内容由字符串构成。大多数符
号在该节中有一个字符串与之对应,这个字符串是该符号的符号名。而每一函
数对应一个符号,函数名即为符号名。下面称被某一函数对应的符号为函数符
号。

ELF 文件开始处的一段叫 ELF 文件头。它记录了程序头表在文件中的偏移、
程序头表的表项数目、程序头表每一表项的字节长度、节头表在文件中的偏移、
节头表的表项数目、节头表每个表项的字节长度。它还记录了节名表所在的节
的索引序号。

二、动态库符号表修改方法

修改动态库符号表的方法和步骤如下:

第一步:

读取 ELF 文件头,取出

    (1) 程序头表在文件中的偏移,获取程序头表在文件中的位置;
    (2) 程序头表的表项数目和程序头表每一表项的字节长度;
    (3) 节头表在文件中的偏移,获取节头表在文件中的位置;
    (4) 节头表的表项数目和节头表每个表项的字节长度;
    (3) 节名表所在的节的索引序号。

ELF 文件头在文件中的偏移为零,即起始于 ELF 文件开头的第一字节,它的
数据结构为:

#define EI_NIDENT (16)

typedef uint16_t Elf32_Half;
typedef uint32_t Elf32_Word;
typedef uint32_t Elf32_Addr;
typedef uint32_t Elf32_Off;
typedef uint16_t Elf32_Section;

typedef struct
{
   unsigned char e_ident[EI_NIDENT];  /* Magic number及其他信息 */
   Elf32_Half    e_type;              /* ELF 文件类型 */
   Elf32_Half    e_machine;           /* 机器型号 */
   Elf32_Word    e_version;           /* 版本 */
   Elf32_Addr    e_entry;             /* 程序入口虚地址 */
   Elf32_Off     e_phoff;             /* 程序头表在文件中的偏移 */
   Elf32_Off     e_shoff;             /* 节头表在文件中的偏移 */
   Elf32_Word    e_flags;             /* 处理器标志 */
   Elf32_Half    e_ehsize;            /* ELF 文件头长度 */
   Elf32_Half    e_phentsize;         /* 程序头表每个表项长度 */
   Elf32_Half    e_phnum;             /* 程序头表的表项总数 */
   Elf32_Half    e_shentsize;         /* 节头表每个表项长度 */
   Elf32_Half    e_shnum;             /* 节头表的表项总数 */
   Elf32_Half    e_shstrndx;          /* 节名表所在的节的表项索引号 */
} Elf32_Ehdr;

第二步:

依据节头表在文件中的偏移和节名表所在的节的索引序号,定出节名表在节头
表中对应的表项的文件偏移,即定出该表项在文件中的位置。读取该表项,取
出节名表在文件中的偏移和该节在文件中的字节长度。节头表由若干表项组成,
每个表项的内容按下面的数据结构来组织:

typedef struct
{
   Elf32_Word    sh_name;             /* 节名索引号 */
   Elf32_Word    sh_type;             /* 节类型 */
   Elf32_Word    sh_flags;            /* 节标志 */
   Elf32_Addr    sh_addr;             /* 执行时该节虚地址 */
   Elf32_Off     sh_offset;           /* 在文件中的偏移 */
   Elf32_Word    sh_size;             /* 节长度 */
   Elf32_Word    sh_link;             /* 到其他节的连接 */
   Elf32_Word    sh_info;             /* 其他信息 */
   Elf32_Word    sh_addralign;        /* alignment */
   Elf32_Word    sh_entsize;          /* 如内容为表,每个表项的长度 */
} Elf32_Shdr;

第三步:

按节名表在文件中的偏移和该节的长度读取节名表,并缓存在一个缓冲区中。

第四步:

依据节头表在文件中的偏移、节头表的表项总数、以及节头表每个表项长度搜
索节头表。对每个节头表项,读出节名索引号,由节名索引号从上面缓存在缓
冲区中节名表得出该节头表项对应的节的名字。如果名字为".dynsym",记录
该节的在文件中的偏移和字节长度。名字为 ".dynsym" 的节的内容是符号表,
除了记录它在文件中的偏移和字节长度外,还要记下它的每个表项的长度。每
个表项即是对一个符号所记录的信息,表项的数据结构为:

typedef struct
{
   Elf32_Word    st_name;       /* 符号名索引号 */
   Elf32_Addr    st_value;      /* 符号地址值 */
   Elf32_Word    st_size;       /* 符号对应的代码长度 */
   unsigned char st_info;       /* 符号类型和梆定信息 */
   unsigned char st_other;      /* 未用,值为 0 */
   Elf32_Section st_shndx;      /* 所在节的节索引号 */
} Elf32_Sym;

在搜索节头表时,除了找 ".dynsym" 节外,还要找到名字为 ".dynstr" 的节,
记下它的在文件中的偏移和字节长度。由该结在文件中的偏移和字节长度读取
它的内容,并缓存在一个缓冲区中。

第五步:

按第四步中得到的 ..dynsym节的字节长度和符号表的表项的长度算出符号表表
项数目,也即符号的数目。然后依据第四步中得到的符号表(即.dynsym节)在
文件中的偏移把文件指针打到符号表所在的位置,检索符号表找到要修改的符
号。方法是从符号表表项中读出符号名索引号(st_name)的值,这个值即是该
表项记录其信息的符号的符号名字符串在 .dynstr 节中的偏移,由这个值在
第四步中缓存 .dynstr 节的缓冲区中取出符号名,把符号名和要找的符号的
符号名进行比较。

第六步:

第五步中找到了要修改的符号,现在可以进行修改了。所谓修改符号就是修改
该符号在符号表(.dynsym 节)中表项,因为表项的内容是对该符号的有关信
息的记录。hook 时需要关注的是符号地址值(st_value)和符号对应的代码长
度(st_size)。可以把符号地址值(st_value)和符号对应的代码长度(st_size)
修改为动态库中另一符号的相应的 st_value 和 st_size 值。通常修改的是
函数符号。如果是函数符号,那么修改后当调用该函数时,实际调用的是上面
修改时取其 st_value 和 st_size 值的另一符号所对应的函数。也可以向ELF
文件中加入的一段几十字节的 shellcode 或其他代码,修改符号表时把所修
改的符号在符号表中的表项的 st_value 值指向这段 shellcode 或其他代码,
st_size 的值置为这段代码的字节长度。那么,程序调用被修改的符号所对应
的函数时,实际调用的是这段 shellcode 或其他代码。

三、示例程序

为对上面所说的进行解释,下面的给出一个示例程序。它打印出 ELF 文件的
有关信息,然后通过修改符号表把动态库的函数1 hook 到函数2。这样做以后,
如果某程序编译时与该动态库连接了,它调用函数1时,程序运行时实际调用
的是函数2。函数2可以是动态库本身就有的函数,也可以是你向 ELF 文件中
偷偷加入的一段几十字节的 shellcode。这是向系统置入后门的一个方法,特
别是 hook 经常被调用的动态库。

测试时做了一个小动态库,它仅有两个函数 haha() 和 huhu():
________________________________________________________
/* haha.c */

#include <stdio.h>

void haha(void)
{
   printf(" --- haha/n");
   return;
}
________________________________________________________
/* huhu.c */

#include <stdio.h>

void huhu(void)
{
   printf(" --- huhu/n");
   return;
}
________________________________________________________

[wangdb@redhat62 exploit]$ gcc -c -fPIC -O3 haha.c huhu.c
[wangdb@redhat62 exploit]$ gcc -shared haha.o huhu.o -o libtst.so.1.0
[wangdb@redhat62 exploit]$ ln -s libtst.so.1.0 libtst.so

程序 m.c 调用 huhu() 和 haha():
________________________________________________________
/* m.c */
int main()
{
   haha();
   huhu();
   return 0;
}
________________________________________________________

[wangdb@redhat62 exploit]$ gcc m.c -L. -ltst -o ttt
[wangdb@redhat62 exploit]$ gcc -O3 hook_elf.c -o elf_hook
[wangdb@redhat62 exploit]$ ./ttt
--- haha
--- huhu
[wangdb@redhat62 exploit]$ ./elf_hook libtst.so huhu haha
  .
  .
  .
[wangdb@redhat62 exploit]$ ./ttt
--- haha
--- haha
[wangdb@redhat62 exploit]$

下面是 hook_elf.c 程序:
_______________________________________________________________________

_________
/*
* C Program File: hook_elf.c  ---
*
* Description: This program read and print relevant information of ELF
*              File, then hook function fun1 to fun2. After hooking,

when
*              some program call function fun1, actually it is fun2

being
*              called.
* Usage:
*         hook_elf <lib***.so> <dst_sym> <src_sym>
*         (Note: when dst_sym == src_sym, ELF file is not changed.)
*
* Author: wangdb (wangdb@nsfocus.com)
*/

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdint.h>

#define EI_NIDENT (16)

typedef uint16_t Elf32_Half;
typedef uint32_t Elf32_Word;
typedef uint32_t Elf32_Addr;
typedef uint32_t Elf32_Off;
typedef uint16_t Elf32_Section;

/* 下面的数据结构定义取自 elf.h 头文件 */

/* The ELF file header. This appears at the start of every ELF file. */

typedef struct
{
   unsigned char e_ident[EI_NIDENT];  /* Magic number and other info */
   Elf32_Half    e_type;              /* Object file type */
   Elf32_Half    e_machine;           /* Architecture */
   Elf32_Word    e_version;           /* Object file version */
   Elf32_Addr    e_entry;             /* Entry point virtual address */
   Elf32_Off     e_phoff;             /* Program header table file

offset */
   Elf32_Off     e_shoff;             /* Section header table file

offset */
   Elf32_Word    e_flags;             /* Processor-specific flags */
   Elf32_Half    e_ehsize;            /* ELF header size in bytes */
   Elf32_Half    e_phentsize;         /* Program header table entry

size */
   Elf32_Half    e_phnum;             /* Program header table entry

count */
   Elf32_Half    e_shentsize;         /* Section header table entry

size */
   Elf32_Half    e_shnum;             /* Section header table entry

count */
   Elf32_Half    e_shstrndx;          /* Section header string table

index */
} myElf32_Ehdr;

/* Program segment header. */

typedef struct
{
   Elf32_Word    p_type;              /* Segment type */
   Elf32_Off     p_offset;            /* Segment file offset */
   Elf32_Addr    p_vaddr;             /* Segment virtual address */
   Elf32_Addr    p_paddr;             /* Segment physical address */
   Elf32_Word    p_filesz;            /* Segment size in file */
   Elf32_Word    p_memsz;             /* Segment size in memory */
   Elf32_Word    p_flags;             /* Segment flags */
   Elf32_Word    p_align;             /* Segment alignment */
} myElf32_Phdr;

/* Section header. */

typedef struct
{
   Elf32_Word    sh_name;             /* Section name (string tbl

index) */
   Elf32_Word    sh_type;             /* Section type */
   Elf32_Word    sh_flags;            /* Section flags */
   Elf32_Addr    sh_addr;             /* Section virtual addr at

execution */
   Elf32_Off     sh_offset;           /* Section file offset */
   Elf32_Word    sh_size;             /* Section size in bytes */
   Elf32_Word    sh_link;             /* Link to another section */
   Elf32_Word    sh_info;             /* Additional section information

*/
   Elf32_Word    sh_addralign;        /* Section alignment */
   Elf32_Word    sh_entsize;          /* Entry size if section holds

table */
} myElf32_Shdr;

/* Symbol table entry. */

typedef struct
{
   Elf32_Word    st_name;             /* Symbol name (string tbl index)

*/
   Elf32_Addr    st_value;            /* Symbol value */
   Elf32_Word    st_size;             /* Symbol size */
   unsigned char st_info;             /* Symbol type and binding */
   unsigned char st_other;            /* No defined meaning, 0 */
   Elf32_Section st_shndx;            /* Section index */
} myElf32_Sym;

/* The syminfo section if available contains additional information

about
   every dynamic symbol. */

typedef struct
{
   Elf32_Half si_boundto;             /* Direct bindings, symbol bound

to */
   Elf32_Half si_flags;               /* Per symbol flags */
} myElf32_Syminfo;


/* Main routine */

int main(int argc, char *argv[])
{
   myElf32_Ehdr *e_hdr_ptr;
   myElf32_Phdr *p_hdr_ptr;
   myElf32_Shdr *s_hdr_ptr;

   myElf32_Sym  *symptr;
   myElf32_Syminfo *HashSymPtr;

   int fd, i;
   unsigned char buf[256];

   unsigned int ProHdrFileOffset;
   unsigned int SecHdrFileOffset;
   unsigned int NamStrSecTblIndex;
   unsigned int ProHdrTblEntrNum;
   unsigned int SecHdrTblEntrNum;
   unsigned int ProHdrTblEntrSize;
   unsigned int SecHdrTblEntrSize;

   unsigned int SecNamStrTblFileOffset = 0;
   char SecNameStrTable[1024];
   unsigned int SecNameIndex = 0;

   unsigned char SymTblEntry[16];

   unsigned int DebugInfoFileOffset = 0;
   int DebugInfoSymTblNum = 0;
   unsigned int DebugInfoStrTblFileOffset = 0;
   char DebugInfoStrTable[4096];
   unsigned int DebugInfoStrTblSize = 0;

   unsigned int SymTblFileOffset = 0;
   int SymTblNum = 0;
   unsigned int SymNamStrTblFileOffset = 0;
   char SymNamStrTable[2048];
   unsigned int SymNamStrTblSize = 0;

   unsigned int HashOffset = 0;
   int HashTblNum = 0;

   unsigned char src_sym[16], dst_sym[16];
   unsigned char tmp_sym_addr[4];
   unsigned char tmp_sym_size[4];
   unsigned int src_sym_tbl = 0, dst_sym_tbl = 0;

   if (argc < 4) {
      fprintf(stderr, "Usage: %s <object_file> <dst_sym> <src_sym>/n",

argv[0]);
      exit(1);
   }

   if ( (fd = open(argv[1], O_RDONLY)) == -1 ) {
      fprintf(stderr, "Can't open file /"%s/"./n", argv[1]);
      exit(1);
   }

   fprintf(stdout, "Dump content of the ELF file '%s'/n", argv[1]);

   fprintf(stdout, "Part I: ELF File Header.../n");

   /* 读取 ELF 文件头 */
   if ( read(fd, buf, 52) != 52 ) {
      fprintf(stderr, "read error/n");
      close(fd); exit(1);
   }

   e_hdr_ptr = (myElf32_Ehdr *)buf;

   fprintf(stdout, "(Magic number and other info)e_ident: %s/n",
                    e_hdr_ptr->e_ident);
   fprintf(stdout, "(Object file type)e_type: 0x%04X/n",
                    e_hdr_ptr->e_type);
   fprintf(stdout, "(Architecture)e_machine: 0x%04X/n",
                    e_hdr_ptr->e_machine);
   fprintf(stdout, "(Object file version)e_version: 0x%08X/n",
                    e_hdr_ptr->e_version);
   fprintf(stdout, "(Entry point virtual address)e_entry: 0x%08X/n",
                    e_hdr_ptr->e_entry);
   fprintf(stdout, "(Program header table file offset)e_phoff: 0x%

08X/n",
                    e_hdr_ptr->e_phoff);
   fprintf(stdout, "(Section header table file offset)e_shoff: 0x%

08X/n",
                    e_hdr_ptr->e_shoff);
   fprintf(stdout, "(Processor-specific flags)e_flags: 0x%08X/n",
                    e_hdr_ptr->e_flags);
   fprintf(stdout, "(ELF header size in bytes)e_ehsize: 0x%04X/n",
                    e_hdr_ptr->e_ehsize);
   fprintf(stdout, "(Program header table entry size)e_phentsize: 0x%

04X/n",
                    e_hdr_ptr->e_phentsize);
   fprintf(stdout, "(Program header table entry count)e_phnum: 0x%

04X/n",
                    e_hdr_ptr->e_phnum);
   fprintf(stdout, "(Section header table entry size)e_shentsize: 0x%

04X/n",
                    e_hdr_ptr->e_shentsize);
   fprintf(stdout, "(Section header table entry count)e_shnum: 0x%

04X/n",
                    e_hdr_ptr->e_shnum);
   fprintf(stdout, "(Section header string table index)e_shstrndx: 0x%

04X/n",
                    e_hdr_ptr->e_shstrndx);

   /* 记下程序头表在文件中的偏移、节头表在文件中的偏移、
      节名表所在的节的索引序号、程序头表表项字节长度、程序头表表项数目

、
      节头表表项字节长度、节头表表项数目。*/
   ProHdrFileOffset  = (unsigned int)e_hdr_ptr->e_phoff;
   SecHdrFileOffset  = (unsigned int)e_hdr_ptr->e_shoff;
   NamStrSecTblIndex = (unsigned int)e_hdr_ptr->e_shstrndx;
   ProHdrTblEntrNum  = (unsigned int)e_hdr_ptr->e_phnum;
   SecHdrTblEntrNum  = (unsigned int)e_hdr_ptr->e_shnum;
   ProHdrTblEntrSize = (unsigned int)e_hdr_ptr->e_phentsize;
   SecHdrTblEntrSize = (unsigned int)e_hdr_ptr->e_shentsize;

   fprintf(stdout, "Part II: Program Header Table.../n");

   if ( lseek(fd, (off_t)ProHdrFileOffset, SEEK_SET) !=

ProHdrFileOffset ) {
      fprintf(stderr, "lseek to program header error./n");
      close(fd); exit(1);
   }

   for (i = 0; i < (int)ProHdrTblEntrNum; i++) {
      if ( read(fd, buf, (size_t)ProHdrTblEntrSize) !=
           (ssize_t)ProHdrTblEntrSize ) {
         fprintf(stderr, "read error/n");
         close(fd); exit(1);
      }
      fprintf(stdout, "Program Header Entry for Segment %d:/n", i + 1);
      p_hdr_ptr = (myElf32_Phdr *)buf;
      fprintf(stdout, "(Segment type)p_type: 0x%08X/n",
                       p_hdr_ptr->p_type);
      fprintf(stdout, "(Segment flags)p_flags: 0x%08X/n",
                       p_hdr_ptr->p_flags);
      fprintf(stdout, "(Segment file offset)p_offset: 0x%08X/n",
                       p_hdr_ptr->p_offset);
      fprintf(stdout, "(Segment virtual address)p_vaddr: 0x%08X/n",
                       p_hdr_ptr->p_vaddr);
      fprintf(stdout, "(Segment physical address)p_paddr: 0x%08X/n",
                       p_hdr_ptr->p_paddr);
      fprintf(stdout, "(Segment size in file)p_filesz: 0x%08X/n",
                       p_hdr_ptr->p_filesz);
      fprintf(stdout, "(Segment size in memory)p_memsz: 0x%08X/n",
                       p_hdr_ptr->p_memsz);
      fprintf(stdout, "(Segment alignment)p_align: 0x%08X/n",
                       p_hdr_ptr->p_align);
   }

   fprintf(stdout, "Part III: Section Header Table.../n");

   /* 定出节名表所在的节在节头表中对应的表项的文件偏移。*/
   SecNamStrTblFileOffset = SecHdrFileOffset + NamStrSecTblIndex * 40;
   if ( lseek(fd, (off_t)SecNamStrTblFileOffset, SEEK_SET) !=
        SecNamStrTblFileOffset || SecNamStrTblFileOffset == 0 ) {
      fprintf(stderr,
        "lseek to Section Table Entry for Section Name String Table

error./n");
      close(fd); exit(1);
   }
   if ( read(fd, buf, (size_t)SecHdrTblEntrSize) != (ssize_t)

SecHdrTblEntrSize ) {
      fprintf(stderr, "read error/n");
      close(fd); exit(1);
   }
   s_hdr_ptr = (myElf32_Shdr *)buf;
   SecNamStrTblFileOffset = (unsigned int)s_hdr_ptr->sh_offset;

   /* 读取节名表,并缓存在一个缓冲区中。*/
   if ( lseek(fd, (off_t)SecNamStrTblFileOffset, SEEK_SET) !=
        SecNamStrTblFileOffset || SecNamStrTblFileOffset == 0 ) {
      fprintf(stderr, "lseek to Section Name String Table error./n");
      close(fd); exit(1);
   }
   if ( read(fd, SecNameStrTable, (size_t)s_hdr_ptr->sh_size) !=
        (ssize_t)s_hdr_ptr->sh_size ) {
      fprintf(stderr, "read error/n");
      close(fd); exit(1);
   }

   if ( lseek(fd, (off_t)SecHdrFileOffset, SEEK_SET) !=

SecHdrFileOffset ||
        SecHdrFileOffset == 0 ) {
      fprintf(stderr, "lseek to section header error./n");
      close(fd); exit(1);
   }

   /* 记录符号表(即.dynsym节)在文件中的偏移,由它的字节长度和每个表项

的
      长度算出符号表的表项数目。同时记下.dynstr节在文件中的偏移和字节长

度。*/
   for (i = 0; i < (int)SecHdrTblEntrNum; i++) {
      if ( read(fd, buf, (size_t)SecHdrTblEntrSize) !=
           (ssize_t)SecHdrTblEntrSize ) {
         fprintf(stderr, "read error/n");
         close(fd); exit(1);
      }
      s_hdr_ptr = (myElf32_Shdr *)buf;
      /*if ( s_hdr_ptr->sh_type == 0x3 && s_hdr_ptr->sh_name == 0x11 )

{
         SecNamStrTblFileOffset = (unsigned int)s_hdr_ptr->sh_offset;
      }*/
      if ( strcmp(SecNameStrTable + s_hdr_ptr->sh_name, ".symtab") == 0

) {
         DebugInfoFileOffset = (unsigned int)s_hdr_ptr->sh_offset;
         DebugInfoSymTblNum = (int)((s_hdr_ptr->sh_size)/(s_hdr_ptr-

>sh_entsize));
      }
      if ( strcmp(SecNameStrTable + s_hdr_ptr->sh_name, ".strtab") == 0

) {
         DebugInfoStrTblFileOffset = (unsigned int)s_hdr_ptr-

>sh_offset;
         DebugInfoStrTblSize = (unsigned int)s_hdr_ptr->sh_size;
      }
      if ( strcmp(SecNameStrTable + s_hdr_ptr->sh_name, ".dynsym") == 0

) {
         SymTblFileOffset = (unsigned int)s_hdr_ptr->sh_offset;
         SymTblNum = (int)((s_hdr_ptr->sh_size)/(s_hdr_ptr-

>sh_entsize));
      }
      if ( strcmp(SecNameStrTable + s_hdr_ptr->sh_name, ".dynstr") == 0

) {
         SymNamStrTblFileOffset = (unsigned int)s_hdr_ptr->sh_offset;
         SymNamStrTblSize = (unsigned int)s_hdr_ptr->sh_size;
      }
      if ( strcmp(SecNameStrTable + s_hdr_ptr->sh_name, ".hash") == 0 )

{
         HashOffset = (unsigned int)s_hdr_ptr->sh_offset;
         HashTblNum = (int)((s_hdr_ptr->sh_size)/(s_hdr_ptr-

>sh_entsize));
      }
   }

   if ( lseek(fd, (off_t)SecHdrFileOffset, SEEK_SET) !=

SecHdrFileOffset ) {
      fprintf(stderr, "lseek to section header error./n");
      close(fd); exit(1);
   }

   for (i = 0; i < (int)SecHdrTblEntrNum; i++) {
      if ( read(fd, buf, (size_t)SecHdrTblEntrSize) !=
           (ssize_t)SecHdrTblEntrSize ) {
         fprintf(stderr, "read error/n");
         close(fd); exit(1);
      }
      s_hdr_ptr = (myElf32_Shdr *)buf;
      fprintf(stdout, "Section %d:/n", i);
      SecNameIndex = (unsigned int)s_hdr_ptr->sh_name;
      fprintf(stdout, "(Section name (string tbl index))sh_name: 0x%08X

-> %s/n",
                       s_hdr_ptr->sh_name, SecNameStrTable +

SecNameIndex);
      fprintf(stdout, "(Section type)sh_type: 0x%08X/n",
                       s_hdr_ptr->sh_type);
      fprintf(stdout, "(Section flags)sh_flags: 0x%08X/n",
                       s_hdr_ptr->sh_flags);
      fprintf(stdout, "(Section virtual addr at execution)sh_addr: 0x%

08X/n",
                       s_hdr_ptr->sh_addr);
      fprintf(stdout, "(Section file offset)sh_offset: 0x%08X/n",
                       s_hdr_ptr->sh_offset);
      fprintf(stdout, "(Section size in bytes)sh_size: 0x%08X/n",
                       s_hdr_ptr->sh_size);
      fprintf(stdout, "(Link to another section)sh_link: 0x%08X/n",
                       s_hdr_ptr->sh_link);
      fprintf(stdout, "(Additional section information)sh_info: 0x%

08X/n",
                       s_hdr_ptr->sh_info);
      fprintf(stdout, "(Section alignment)sh_addralign: 0x%08X/n",
                       s_hdr_ptr->sh_addralign);
      fprintf(stdout, "(Entry size if section holds table)sh_entsize:

0x%08X/n",
                       s_hdr_ptr->sh_entsize);
   }

   fprintf(stdout,
"**********************************************************************

**/n");

   if ( lseek(fd, (off_t)DebugInfoStrTblFileOffset, SEEK_SET) !=
        DebugInfoStrTblFileOffset || DebugInfoStrTblFileOffset == 0 ) {
      fprintf(stderr, "lseek to Debug Info String Table error./n");
      goto next;
   }
   read(fd, DebugInfoStrTable, (size_t)(DebugInfoStrTblSize + 1));

   if ( lseek(fd, (off_t)DebugInfoFileOffset, SEEK_SET) !=
        DebugInfoFileOffset || DebugInfoFileOffset == 0 ) {
      fprintf(stderr, "lseek to Debug Info Symbol Table error./n");
      goto next;
   }
   for (i = 0; i < DebugInfoSymTblNum; i++) {
      read(fd, SymTblEntry, (size_t)16);
      symptr = (myElf32_Sym *)SymTblEntry;
      fprintf(stdout, "Debug Infomation -> Symbol ID: %d/n", i);
      fprintf(stdout, "Symbol_index_and_name: 0x%08X -> %s/n",
                    symptr->st_name, DebugInfoStrTable + symptr-

>st_name);
      fprintf(stdout, "Symbol_value: 0x%08X/n", symptr->st_value);
      fprintf(stdout, "Symbol_size: 0x%08X/n", symptr->st_size);
      fprintf(stdout, "Symbol_type_and_binding: 0x%02X/n", symptr-

>st_info);
      fprintf(stdout, "Section_index: 0x%04X/n", symptr->st_shndx);
      fprintf(stdout,
         "--------------------------------------------------------/n");
   }

   fprintf(stdout,
"**********************************************************************

**/n");

next:

   /* 读取 .dynstr 节的内容,并缓存在一个缓冲区中。*/
   if ( lseek(fd, (off_t)SymNamStrTblFileOffset, SEEK_SET) !=
        SymNamStrTblFileOffset || SymNamStrTblFileOffset == 0 ) {
      fprintf(stderr, "lseek to Dynamical symbol name string

error./n");
      close(fd); exit(1);
   }
   read(fd, SymNamStrTable, (size_t)(SymNamStrTblSize + 1));
   if ( lseek(fd, (off_t)SymTblFileOffset, SEEK_SET) !=

SymTblFileOffset ||
        SymTblFileOffset == 0 ) {
      fprintf(stderr, "lseek to Dynamical symbol Table error./n");
      close(fd); exit(1);
   }
   for (i = 0; i < SymTblNum; i++) {
      read(fd, SymTblEntry, (size_t)16);
      symptr = (myElf32_Sym *)SymTblEntry;
      fprintf(stdout, "Symbol ID: %d/n", i);
      fprintf(stdout, "Symbol_index_and_name: 0x%08X -> %s/n",
                       symptr->st_name, SymNamStrTable + symptr-

>st_name);
      fprintf(stdout, "Symbol_value: 0x%08X/n", symptr->st_value);
      fprintf(stdout, "Symbol_size: 0x%08X/n", symptr->st_size);
      fprintf(stdout, "Symbol_type_and_binding: 0x%02X/n", symptr-

>st_info);
      fprintf(stdout, "Section_index: 0x%04X/n", symptr->st_shndx);
      fprintf(stdout,
         "--------------------------------------------------------/n");
   }

   fprintf(stdout,
"**********************************************************************

**/n");

   if ( lseek(fd, (off_t)HashOffset, SEEK_SET) != HashOffset ||
        HashOffset == 0 ) {
      fprintf(stderr, "lseek to hash table error./n");
      close(fd); exit(-1);
   }
   for (i = 0; i < HashTblNum; i++) {
      fprintf(stdout, "Hash Table ID: %d/n", i);
      read(fd, SymTblEntry, (size_t)4);
      HashSymPtr = (myElf32_Syminfo *)SymTblEntry;
      fprintf(stdout, "Direct_bindings, symbol_bound_to: 0x%04X/n",
                       HashSymPtr->si_boundto);
      fprintf(stdout, "Per_symbol_flags: 0x%04X/n", HashSymPtr-

>si_flags);
      fprintf(stdout,
         "--------------------------------------------------------/n");
   }

   close(fd);   /* End of Printing */

  /* Change symbol value, hook it */

   if ( (fd = open(argv[1], O_RDWR)) < 0 ) {
      fprintf(stderr, "Can't open object file '%s'./n", argv[1]);
      exit(-1);
   }

   /* 检索符号表搜索要修改的符号。*/
   if ( lseek(fd, (off_t)SymTblFileOffset, SEEK_SET) !=

SymTblFileOffset ) {
      fprintf(stderr, "lseek error./n");
      close(fd); exit(-1);
   }

   for (i = 0; i < SymTblNum; i++) {
      read(fd, SymTblEntry, (size_t)16);
      symptr = (myElf32_Sym *)SymTblEntry;
      if ( strcmp(argv[2], SymNamStrTable + symptr->st_name) == 0 ) {
         memcpy(dst_sym, SymTblEntry, 16);
         dst_sym_tbl = (unsigned int)lseek(fd, (off_t)0, SEEK_CUR) -

16;
      }
      if ( strcmp(argv[3], SymNamStrTable + symptr->st_name) == 0 ) {
         memcpy(src_sym, SymTblEntry, 16);
         src_sym_tbl = (unsigned int)lseek(fd, (off_t)0, SEEK_CUR) -

16;
      }
   }

   /* 修改符号表中要修改的符号所对应的表项的 st_value 和 st_size 值。*/
   symptr = (myElf32_Sym *)src_sym;
   memcpy(tmp_sym_addr, &symptr->st_value, 4);
   memcpy(tmp_sym_size, &symptr->st_size, 4);
   symptr = (myElf32_Sym *)dst_sym;
   memcpy(&symptr->st_value, tmp_sym_addr, 4);
   memcpy(&symptr->st_size, tmp_sym_size, 4);

   if ( dst_sym_tbl == 0 || src_sym_tbl == 0 ||
        lseek(fd, (off_t)dst_sym_tbl, SEEK_SET) != dst_sym_tbl ) {
      fprintf(stderr, "lseek error./n");
      close(fd); exit(-1);
   }
   if ( write(fd, dst_sym, (size_t)16) != (ssize_t)16 ) {
      fprintf(stderr, "write error/n");
      close(fd); exit(-1);
   }

   close(fd);
   return 0;
}

/* EOF */

剖析ELF文件格式的内容———文件头,段表,符号....(第三章) 目录 1.extern "C" 1.编译阶段——取名 2.链接阶段——找对应的名 参考: 2.extern变量名 1.extern "C" 在阅读代码的时候,常常会看到下面的代码片段: #ifdef __cplusplus extern "C" { #endif // 写例如dll导出函数的定义 #ifdef __cplusplus } #endif 这是一... 阅读详情

相关推荐

华硕主板UEFI模式下安装Ubuntu与Windows双系统全攻略

本文详细讲解了在华硕主板UEFI模式下安装Ubuntu与Windows双系统的完整流程。从安装前的BIOS关键设置(如处理安全启动与CSM)、使用GPT分区表,到在Windows中安全分配空间、手动创建Ubuntu分区,最后完成引导配置,提供了避免常见错误的实用技巧,确保双系统稳定共存。

weixin_29199873的博客 346

解决Linux多个动态库间的符号冲突问题

那linux下有没有类似window下的显式导出功能呢,有的。下面是介绍一种常用的只导出指定符号的方法。 1、加编译器选项fvisibility=hidden,加了这个选项后,默认的符号都不会导出 2、在需要导出的函数或者类名前加__attribute__ ((visibility("default"))) 一种是在编译期解决,就是在编译动态库的是加参数-Wl,-Bsymbolic 这个参数是传给链接器的,这个编译参数的作用是:优先使用本动态库中的符号,而不是全局符号。

hacker_lpy的博客 9363

机器学习-深嵌交叉验证(Nested Cross-Validation)

Section I: Code and Analyses 第一部分:代码 from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.svm import SVC from...

Santorinisu Blogs 2718

Elf32 文件重定位研究(二)

前面已经说过,elf目标文件如果要链接成可执行文件,那么需要经过符号解析和重定位,才能变成一个可执行程序。那么对于一个elf目标文件,应用程序能否动态加载他,并调用里面的内部函数去执行,答案是可以的。具体应该如何做,下面来看一下。 应用程序动态加载elf目标文件,先把该文件读到内存中,获取目标文件elf头得信息,得到elf文件sections得起始地址,获取各个section信息。然后根据sec...

oqqYuJi12345678的博客 759

从零到一:QT for OpenHarmony 开发环境实战搭建与踩坑指南

本文是一份详尽的QT for OpenHarmony开发环境搭建实战指南。文章手把手教你如何在Windows和macOS系统上,从环境准备、核心工具(DevEco Studio与社区版QT SDK)安装配置,到创建首个QT Quick项目、解决构建部署中的常见问题,最终实现应用在OpenHarmony设备上运行。内容涵盖关键配置修改、资源管理及深度踩坑经验,旨在帮助开发者高效开启跨平台开发之旅。

weixin_29190573的博客 328

U-Net图像分割实战:从论文解析到PyTorch代码实现

本文深入解析了U-Net图像分割模型的经典架构与核心思想,并提供了从零开始的PyTorch代码实现教程。通过详细拆解编码器-解码器结构、跳跃连接等关键组件,手把手指导读者构建完整的U-Net网络,涵盖数据准备、模型训练、推理部署全流程,是掌握图像分割实战技能的实用指南。

fire9的博客 343

【嵌入式】修改ELF文件中的符号表

RTOS系统应用经常需要导入三方库,但是RTOS系统有别于Linux系统,无法使用动态链接库,所以很多库都是重复的,这会导致链接过程中出现: symbol xxx multiply defined by xxx的错误。如果某个库重复了,例如常用的cJSON库,可以单独把cJSON库单独打包成库,而不用集成到整体的库中去,这样整个系统只需要包含一次cJSON.lib即可,节省了空间也防止了冲突。 但是使用的三方库多了之后,有时候又会出现各自的库有重复定义函数符号的问题,比如A.lib定义了test函数,B.

欢迎光临 1142

01-认识脑电信号及相关信号的预处理过程

脑电信号处理过程脑电实验为什么要预处理预处理方法降采样如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 脑电实验 本博客主要是记录基于脑电信号的情绪识别方法的研究...

脑机交流者的博客 7661

ELF Format 笔记(九)—— Elf32_Sym 结构的 st_value 和 st_shndx 成员

ilocker:关注 Android 安全(新手) QQ: 2597294287 前面的笔记中提到过 Elf32_Sym 结构,本篇笔记再写一下其中的 st_value 和 st_shndx 成员。 对于不同类型的 object file,st_value 的含义略有不同: · 对于 relocatable (.o) 文件,如果相应的 st_shndx 的值为 SHN_COMMON,则 s...

weixin_30882895的博客 831

从零开始STM32cubeide学习

使用的是正点原子的精英版,单片机是STM32F103ZET6,详细讲解完成跑马灯实验

weixin_44077208的博客 2285

【华为机试真题 Python实现】分苹果

《华为机试真题》专栏含牛客网华为专栏、华为面经试题、华为OD机试真题。如果您在准备华为的面试,期间有想了解的可以私信我,我会尽可能帮您解答,也可以给您一些建议!本文解法非最优解(即非性能最优)。A,B两个人把苹果分为两堆,A希望按照它的计算规则等分苹果,他的计算规则是按照二进制加法计算,并且不计算走位,12+5=9(1100+0101=9), B的计算规则是十进制加法,包括正常进位,B希望在满足A的情况下获取苹果重量最多,输入苹果的数量和每个苹果重量,输出满足A的情况下获取的苹果总重量, 如果无法满足A的要

3414

看一下函数的符号表 linux,使用objdump objcopy查看与修改符号表

我们在 Linux 下运行一个程序,有时会无法启动,报缺少某某库。这时需要查看可执行程序或者动态库中的符号表,动态库的依赖项, Linux 有现成的工具可用:objdump 。有时我们拿到一个静态库,想调用其中的函数,而某些函数作用域非全局,也可以通过修改符号来达到目的。 Linux 有现成的工具可用: objcopy 。下面我们来看看具体怎么使用。objdump 是 gcc 套件中用来查看 EL...

weixin_42421284的博客 1244

OpenClaw实战系列10(完结篇):企业级应用实战案例——从0到1搭建智能客服系统

本文以一家跨境电商公司为例,从需求分析、系统设计、分步搭建到上线运营,完整呈现智能客服系统的落地全过程。所有配置命令和截图均来自实测环境,你可以直接复制使用。

PeterPan的博客 1307

linux 下的hook

◆ 如何修改动态库符号表 作者:wangdb (mailto:wangdb@nsfocus.com) 主页:http://www.nsfocus.com/ 日期:2000-10-14 一、ELF 文件和有关术语Unix 系统的可执行文件和动态库文件是以 ELF 格式存放的。为使下面的叙述清晰而没有伎义,先简要介绍一下 ELF 文件格式,并约定一些术语。

助跑。。。。。。跳 4753

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

android 动态库符号表,Android NDK隐藏jni动态库的内部符号表

写过win32程序的朋友对dll导出函数名都很熟悉,大家都可以通过.def文件或者__declspec(dllexport)来指定导出的函数名。在android下,可执行文件或者动态链接库用的是elf格式,和win32的pe格式有所不同。当编译动态链接库时,缺省的编译选项下默认所有的符号表都会导出。以android-ndk下的san-angeles例子为例,用ndk编译之后生成的jni动态库导出的...

weixin_35691715的博客 1391

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

linux下查看动态库和静态库

静态库用ar -t YourFile动态库用 nm -D YourFile下面是ar和nm命令的一些参数说明1.ar基本用法  ar命令可以用来创建、修改库,也可以从库中提出单个模块。库是一单独的文件,里面包含了按照特定的结构组织起来的其它的一些文件(称做此库文件的member)。原始文件的内容、模式、时间戳、属主、组等属性都保留在库文件中。  下面是ar命令的格式:  a

Gabriel的专栏 2801

ELF重定向对象文件 by wangdb

ELF 文件中代码、连接信息和注释是以节(section)为单位存放的,并存有一 个节头表(section header)。对每一节,在节头表中都有一个表项(节头表项) 与之对应,表项记录了该节的一些信息,例如该节在文件中的位置信息和该节 的字节长度信息。 一、ELF 文件和有关术语 Unix 系统的可执行文件和动态库文件是以 ELF 格式存放的。为使下面的叙述 清晰而

luohaoxiang2008的专栏 572

objdump与objcopy使用详解

我们在 Linux 下运行一个程序,有时会无法启动,报缺少某某库。这时需要查看可执行程序或者动态库中的符号表,动态库的依赖项, Linux 有现成的工具可用:objdump 。 有时我们拿到一个静态库,想调用其中的函数,而某些函数作用域非全局,也可以通过修改符号来达到目的。 Linux 有现成的工具可用: objcopy 。 下面我们来看看具体怎么使用。 objd...

不忘初心 3567

Android技术-修改SO导出符号

经常在使用第三方SDK的时候会莫名其妙报错,其中最常见的一种就是SO符号冲突,比如libA.so静态链接了libC.a,而libB.so动态链接了libC.so。这样便会导致符号冲突。又或者在使用不同版本的动态库,也会造成符号冲突。基于以上背景,可能存在一下几种解决方案。符号冲突的so重命名。

Tasfa的博客 1074

IPAPatch代码注入原理深度解析:免越狱修改iOS应用的终极指南

IPAPatch是一款强大的iOS应用代码注入工具,让你无需越狱就能修改第三方应用的行为。通过巧妙的动态库注入和符号重绑定技术,IPAPatch实现了对iOS应用的深度定制。本文将深入解析IPAPatch的代码注入原理,帮助你理解这个神奇工具的工作机制。 ## 🔍 IPAPatch核心架构解析 IPAPatch的核心架构基于Xcode项目模板,通过动态库注入的方式实现代码修改。项目的主要结构

gitblog_00436的博客 978

IPAPatch工具链详解:optool、restore-symbol核心使用指南

IPAPatch 是一款强大的 iOS 应用补丁工具,让开发者无需越狱就能对第三方应用进行代码注入和调试。在这套工具链中,**optool** 和 **restore-symbol** 是两个核心组件,负责实现动态库加载和符号表恢复的关键功能。 ## 🔧 IPAPatch工具链架构概览 IPAPatch 项目结构清晰,工具链组件分工明确: - **Tools/optool** - 动态库加

gitblog_00224的博客 564
上一篇: WINDOWS的SHELLCODE编写高级技巧
下一篇: *printf()格式化串安全漏洞分析(上)
普通网友
博客等级 码龄22年 1万+粉丝 3156原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值