Linux在程序运行时替换文件,[操作系统]linux下实现在程序运行时的函数替换(热补丁)...

青旅半醒 2023-10-04 13:10 8阅读 0赞

\[操作系统\]linux下实现在程序运行时的函数替换(热补丁)

2016-07-02 10:00:07

声明：以下的代码成果，是参考了网上的injso技术，文章最后会给出地址。

但是injso文章中的代码存在一些问题，所以后面出现的代码是经过我个人修改和检测的。

最近因为在学习一些调试的技术，但是很少有提到如何在函数运行时实现函数替换的。

为什么会想到这一点？因为在学习调试时，难免会看到一些内核方面的调试技术，内核中的调试有一个kprobe，很强大，可以实现运行时的函数替换。其原理就是hook，钩子，但是学习了这个kprobe之后会发现，kprobe内部有检测所要钩的函数是不是属于内核空间，必须是内核函数才能实现替换。而实际上，我的工作大部分还是在应用层的，所以想要实现应用程序的热补丁技术。

一些基础的知识这边的就不展开了，需要的基础有，elf文件格式，ptrace，waitpid，应用程序间通信时的信号，汇编。1、elf文件加载过程

elf简单地说是由以下四部分组成的，elf文件头，program header和section header，内容。其中program header是运行时使用的，而section header并不会被加载进程序运行空间，但他们可以在编译时被指定该段的加载地址等信息，当然一般这个链接脚本.lds是由gcc默认的。

第一步，加载elf文件头，检验文件类型版本等，重要的是找到program header的地址和header的个数，如果连接器脚本是默认的，那么elf文件头会被加载在0x804800地址处。

第二步，加载program header，接着扫描program header，找到一个类型为PT\_INTERP的program header，这个header里面放着的是有关解释器的地址，这时候将解释器程序的elf文件头加载进来。一般是这样：

INTERP 0x000134 0x08048134 0x08048134 0x00013 0x00013 R 0x1

\[Requesting program interpreter: /lib/ld-linux.so.2\]

第三步，扫描program header，如果类型为PT\_LOAD，则将该段加载进来。

第四步，判断是否需要解释器程序，如果需要，把解释器程序加载进来，并把程序入口设置为解释器程序的地址。否则是应用程序本身的入口。反汇编为\_start标号。

第五步，设置命令行传入的参数等应用程序需要的信息。

第六步，解释器程序开始运行，加载程序需要的库，填写重定向符号表中的地址信息。2.elf文件动态链接过程

上一步，解释器程序根据program header已经将应用程序的段都加载进内存了，接下来再扫描program header，找到类型为PT\_DYNAMIC，这里面包含了很多由section header描述的内容，包括重定向表，符号表，字符串表等等。解释器需要这个段描述的一些信息。

DT\_NEEDED描述了所需要的动态库名称，DT\_REL描述了重定位表地址，DT\_JMPREL描述了重定位表地址(这个表是懒惰链接使用的)，DT\_PLTGOT全局偏移表地址。

此时解释器程序就可以根据所需要的动态库，将其加载进内存。每一个被加载进来的库的相关信息会被记录在link\_map结构中，这个结构是一个链表，保存了所有的动态信息。

其中，全局偏移表got，got\[0\]保存了PT\_DYNAMIC的起始地址，got\[1\]保存link\_map的地址，而link\_map中就可以找到PT\_DYNAMIC的起始地址，和下一个或者上一个共享文件或者可执行文件的link\_map地址。

DT\_REL这个重定向表中的符号必须在此时就被解析完成。

而DT\_JMPREL这个重定向表中的符号可以在运行时再解析。

所有的库和符号全部解析完成之后，解释器程序就会把控制权交给可执行文件的\_start。程序开始执行。3.替换函数和被替换函数

被替换程序源码。\#include \#include int main()\{ while(1)\{ sleep(10); printf("%d : original\\n",time(0)); \}\}

替换新库代码。\#include int newmyprint()\{write(1,"hahahahahahaha",14);return 0;\}

够简单明了吧，如果替换成功，目标程序将会一直输出“哈哈哈哈哈哈”。4.功能函数

ptrace相关代码：/\* 读进程寄存器 \*/void ptrace\_readreg(int pid, struct user\_regs\_struct \*regs)\{ if(ptrace(PTRACE\_GETREGS, pid, NULL, regs)) printf("\*\*\* ptrace\_readreg error \*\*\*\\n");/\*printf("ptrace\_readreg\\n");printf("%x\\n",regs->ebx);printf("%x\\n",regs->ecx);printf("%x\\n",regs->edx);printf("%x\\n",regs->esi);printf("%x\\n",regs->edi);printf("%x\\n",regs->ebp);printf("%x\\n",regs->eax);printf("%x\\n",regs->xds);printf("%x\\n",regs->xes);printf("%x\\n",regs->xfs);printf("%x\\n",regs->xgs);printf("%x\\n",regs->orig\_eax);printf("%x\\n",regs->eip);printf("%x\\n",regs->xcs);printf("%x\\n",regs->eflags);printf("%x\\n",regs->esp);printf("%x\\n",regs->xss);\*/\}/\* 写进程寄存器 \*/void ptrace\_writereg(int pid, struct user\_regs\_struct \*regs)\{/\*printf("ptrace\_writereg\\n");printf("%x\\n",regs->ebx);printf("%x\\n",regs->ecx);printf("%x\\n",regs->edx);printf("%x\\n",regs->esi);printf("%x\\n",regs->edi);printf("%x\\n",regs->ebp);printf("%x\\n",regs->eax);printf("%x\\n",regs->xds);printf("%x\\n",regs->xes);printf("%x\\n",regs->xfs);printf("%x\\n",regs->xgs);printf("%x\\n",regs->orig\_eax);printf("%x\\n",regs->eip);printf("%x\\n",regs->xcs);printf("%x\\n",regs->eflags);printf("%x\\n",regs->esp);printf("%x\\n",regs->xss);\*/ if(ptrace(PTRACE\_SETREGS, pid, NULL, regs)) printf("\*\*\* ptrace\_writereg error \*\*\*\\n");\}/\* 关联到进程 \*/void ptrace\_attach(int pid)\{ if(ptrace(PTRACE\_ATTACH, pid, NULL, NULL) < 0) \{ perror("ptrace\_attach"); exit(-1); \} waitpid(pid, NULL, /\*WUNTRACED\*/0); ptrace\_readreg(pid, &oldregs);\}/\* 进程继续 \*/void ptrace\_cont(int pid)\{ int stat; if(ptrace(PTRACE\_CONT, pid, NULL, NULL) < 0) \{ perror("ptrace\_cont"); exit(-1); \} /\*while(!WIFSTOPPED(stat)) waitpid(pid, &stat, WNOHANG);\*/\}/\* 脱离进程 \*/void ptrace\_detach(int pid)\{ ptrace\_writereg(pid, &oldregs); if(ptrace(PTRACE\_DETACH, pid, NULL, NULL) < 0) \{ perror("ptrace\_detach"); exit(-1); \}\}/\* 写指定进程地址 \*/void ptrace\_write(int pid, unsigned long addr, void \*vptr, int len)\{ int count; long word; count = 0; while(count < len) \{ memcpy(&word, vptr + count, sizeof(word)); word = ptrace(PTRACE\_POKETEXT, pid, addr + count, word); count += 4; if(errno != 0) printf("ptrace\_write failed\\t %ld\\n", addr + count); \}\}/\* 读指定进程 \*/int ptrace\_read(int pid, unsigned long addr, void \*vptr, int len)\{ int i,count; long word; unsigned long \*ptr = (unsigned long \*)vptr; i = count = 0;//printf("ptrace\_read addr = %x\\n",addr); while (count < len) \{//printf("ptrace\_read addr+count = %x\\n",addr + count); word = ptrace(PTRACE\_PEEKTEXT, pid, addr + count, NULL);while(word < 0)\{if(errno == 0)break;//printf("ptrace\_read word = %x\\n",word);perror("ptrace\_read failed");return 2;\} count += 4; ptr\[i++\] = word; \}return 0;\}/\* 在进程指定地址读一个字符串 \*/char \* ptrace\_readstr(int pid, unsigned long addr)\{ char \*str = (char \*) malloc(64); int i,count; long word; char \*pa; i = count = 0; pa = (char \*)&word; while(i <= 60) \{ word = ptrace(PTRACE\_PEEKTEXT, pid, addr + count, NULL); count += 4; if (pa\[0\] == 0) \{ str\[i\] = 0; break; \} else str\[i++\] = pa\[0\]; if (pa\[1\] == 0) \{ str\[i\] = 0; break; \} else str\[i++\] = pa\[1\]; if (pa\[2\] ==0) \{ str\[i\] = 0; break; \} else str\[i++\] = pa\[2\]; if (pa\[3\] ==0) \{ str\[i\] = 0; break; \} else str\[i++\] = pa\[3\]; \} return str;\}/\* 将指定数据压入进程堆栈并返回堆栈指针 \*/void \* ptrace\_push(int pid, void \*paddr, int size)\{ unsigned long esp; struct user\_regs\_struct regs; ptrace\_readreg(pid, &regs); esp = regs.esp; esp -= size; esp = esp - esp % 4; regs.esp = esp; ptrace\_writereg(pid, &regs); ptrace\_write(pid, esp, paddr, size); return (void \*)esp;\}/\* 在进程内调用指定地址的函数 \*/void ptrace\_call(int pid, unsigned long addr)\{ void \*pc; struct user\_regs\_struct regs; int stat; void \*pra; pc = (void \*) 0x41414140; pra = ptrace\_push(pid, &pc, sizeof(pc)); ptrace\_readreg(pid, &regs); regs.eip = addr; ptrace\_writereg(pid, &regs); ptrace\_cont(pid); //while(WIFSIGNALED(stat)) // waitpid(pid, &stat, WNOHANG);\}

这里面的东西我就不展开了，对ptrace的学习，请自行man。

/\*因为应用程序可能不存在hash表，所以通过读取源文件的section header获取符号表的入口数，其实是被误导了，但也学习了hash表的作用，用来快速查找符号表中的信息和字符串表中的信息\*//\*int getnchains(int pid,unsigned long base\_addr)\{printf("getnchains enter \\n"); Elf32\_Ehdr \*ehdr = (Elf32\_Ehdr \*) malloc(sizeof(Elf32\_Ehdr)); Elf32\_Shdr \*shdr = (Elf32\_Shdr \*)malloc(sizeof(Elf32\_Shdr));unsigned long shdr\_addr;int i = 0;int fd;char filename\[1024\] = \{0\}; ptrace\_read(pid, base\_addr, ehdr, sizeof(Elf32\_Ehdr)); shdr\_addr = base\_addr + ehdr->e\_shoff; //printf("getnchains ehdr->e\_shoff\\t %p\\n", ehdr->e\_shoff);snprintf(filename, sizeof(filename), "/proc/%d/exe", pid);fd = open(filename, O\_RDONLY);if (lseek(fd, ehdr->e\_shoff, SEEK\_SET) < 0) exit(-1);/\*while(ie\_shnum)\{read(fd, shdr, ehdr->e\_shentsize);printf("getnchains i = %d\\n",i);printf("getnchains shdr->sh\_type = %x\\n",shdr->sh\_type);printf("getnchains shdr->sh\_name = %x\\n",shdr->sh\_name);printf("getnchains shdr->sh\_size = %x\\n",shdr->sh\_size);printf("getnchains shdr->sh\_entsize = %x\\n",shdr->sh\_entsize);i++;\} while(shdr->sh\_type != SHT\_SYMTAB)read(fd, shdr, ehdr->e\_shentsize);nchains = shdr->sh\_size/shdr->sh\_entsize;//printf("getnchains shdr->sh\_type = %d\\n",shdr->sh\_type);//printf("getnchains shdr->sh\_name = %d\\n",shdr->sh\_name);//printf("getnchains shdr->sh\_size = %d\\n",shdr->sh\_size);//printf("getnchains shdr->sh\_entsize = %d\\n",shdr->sh\_entsize);//printf("getnchains nchains = %x\\n",nchains);close(fd);free(ehdr);free(shdr);printf("getnchains exit \\n");\}\*//\* 取得指向link\_map链表首项的指针 \*/struct link\_map \* get\_linkmap(int pid)\{ Elf32\_Ehdr \*ehdr = (Elf32\_Ehdr \*) malloc(sizeof(Elf32\_Ehdr)); Elf32\_Phdr \*phdr = (Elf32\_Phdr \*) malloc(sizeof(Elf32\_Phdr)); Elf32\_Dyn \*dyn = (Elf32\_Dyn \*) malloc(sizeof(Elf32\_Dyn)); Elf32\_Word got; struct link\_map \*map = (struct link\_map \*)malloc(sizeof(struct link\_map)); int i = 1;unsigned long tmpaddr; ptrace\_read(pid, IMAGE\_ADDR, ehdr, sizeof(Elf32\_Ehdr)); phdr\_addr = IMAGE\_ADDR + ehdr->e\_phoff; printf("phdr\_addr\\t %p\\n", phdr\_addr); ptrace\_read(pid, phdr\_addr, phdr, sizeof(Elf32\_Phdr)); while(phdr->p\_type != PT\_DYNAMIC) ptrace\_read(pid, phdr\_addr += sizeof(Elf32\_Phdr), phdr,sizeof(Elf32\_Phdr)); dyn\_addr = phdr->p\_vaddr; printf("dyn\_addr\\t %p\\n", dyn\_addr); ptrace\_read(pid, dyn\_addr, dyn, sizeof(Elf32\_Dyn)); while(dyn->d\_tag != DT\_PLTGOT) \{tmpaddr = dyn\_addr + i \* sizeof(Elf32\_Dyn);//printf("get\_linkmap tmpaddr = %x\\n",tmpaddr); ptrace\_read(pid,tmpaddr, dyn, sizeof(Elf32\_Dyn)); i++; \} got = (Elf32\_Word)dyn->d\_un.d\_ptr; got += 4; //printf("GOT\\t\\t %p\\n", got); ptrace\_read(pid, got, &map\_addr, 4); printf("map\_addr\\t %p\\n", map\_addr);map = map\_addr; //ptrace\_read(pid, map\_addr, map, sizeof(struct link\_map)); free(ehdr); free(phdr); free(dyn); return map;\}/\* 取得给定link\_map指向的SYMTAB、STRTAB、HASH、JMPREL、PLTRELSZ、RELAENT、RELENT信息 这些地址信息将被保存到全局变量中，以方便使用 \*/void get\_sym\_info(int pid, struct link\_map \*lm)\{ Elf32\_Dyn \*dyn = (Elf32\_Dyn \*) malloc(sizeof(Elf32\_Dyn)); unsigned long dyn\_addr;//printf("get\_sym\_info lm = %x\\n",lm);//printf("get\_sym\_info lm->l\_ld's offset = %x\\n",&((struct link\_map \*)0)->l\_ld);//printf("get\_sym\_info &lm->l\_ld = %x\\n",&(lm->l\_ld)); //dyn\_addr = (unsigned long)&(lm->l\_ld);//进入被跟踪进程获取动态节的地址 ptrace\_read(pid,&(lm->l\_ld) , &dyn\_addr, sizeof(dyn\_addr)); ptrace\_read(pid,&(lm->l\_addr) , &link\_addr, sizeof(dyn\_addr)); ptrace\_read(pid, dyn\_addr, dyn, sizeof(Elf32\_Dyn));//if(link\_addr == 0)//getnchains(pid,IMAGE\_ADDR);/\*elsegetnchains(pid,link\_addr);\*/ while(dyn->d\_tag != DT\_NULL)\{//printf("get\_sym\_info dyn->d\_tag = %x\\n",dyn->d\_tag);//printf("get\_sym\_info dyn->d\_un.d\_ptr = %x\\n",dyn->d\_un.d\_ptr); switch(dyn->d\_tag) \{ case DT\_SYMTAB: symtab = dyn->d\_un.d\_ptr;break; case DT\_STRTAB: strtab = dyn->d\_un.d\_ptr; break; /\*case DT\_HASH://可能不存在哈希表，此时nchains是错误的，这个值可以通过符号表得到//printf("get\_sym\_info hash table's addr = %x\\n",dyn->d\_un.d\_ptr);//printf("get\_sym\_info symtbl's entry = %x\\n",(dyn->d\_un.d\_ptr) + 4); ptrace\_read(pid, (dyn->d\_un.d\_ptr) + 4,&nchains, sizeof(nchains)); break;\*/ case DT\_JMPREL: jmprel = dyn->d\_un.d\_ptr; break; case DT\_PLTRELSZ: totalrelsize = dyn->d\_un.d\_val; break; case DT\_RELAENT: relsize = dyn->d\_un.d\_val; break; case DT\_RELENT: relsize = dyn->d\_un.d\_val; break;case DT\_REL:reldyn = dyn->d\_un.d\_ptr;break;case DT\_RELSZ:reldynsz = dyn->d\_un.d\_val;break; \}ptrace\_read(pid, dyn\_addr += sizeof(Elf32\_Dyn), dyn, sizeof(Elf32\_Dyn)); \}//printf("get\_sym\_info link\_addr = %x\\n",link\_addr);//printf("get\_sym\_info symtab = %x\\n",symtab);//printf("get\_sym\_info relsize = %x\\n",relsize);//printf("get\_sym\_info reldyn = %x\\n",reldyn);//printf("get\_sym\_info totalrelsize = %x\\n",totalrelsize);//printf("get\_sym\_info jmprel = %x\\n",jmprel);//printf("get\_sym\_info nchains = %x\\n",nchains);//printf("get\_sym\_info strtab = %x\\n",strtab); nrels = totalrelsize / relsize;nreldyns = reldynsz/relsize;//printf("get\_sym\_info nreldyns = %d\\n",nreldyns);//printf("get\_sym\_info nrels = %d\\n",nrels); free(dyn);printf("get\_sym\_info exit\\n");\}/\* 在指定的link\_map指向的符号表查找符号，它仅仅是被上面的find\_symbol使用 \*/unsigned long find\_symbol\_in\_linkmap(int pid, struct link\_map \*lm, char \*sym\_name)\{ Elf32\_Sym \*sym = (Elf32\_Sym \*) malloc(sizeof(Elf32\_Sym));int i = 0; char \*str; unsigned long ret;int flags = 0; get\_sym\_info(pid, lm); do\{if(ptrace\_read(pid, symtab + i \* sizeof(Elf32\_Sym), sym, sizeof(Elf32\_Sym)))return 0;i++;//printf("find\_symbol\_in\_linkmap sym->st\_name = %x\\tsym->st\_size = %x\\tsym->st\_value = %x\\n",sym->st\_name,sym->st\_size,sym->st\_value);//printf("find\_symbol\_in\_linkmap Elf32\_Sym's size = %d\\n",sizeof(Elf32\_Sym));//printf("\\nfind\_symbol\_in\_linkmap sym->st\_name = %x\\n",sym->st\_name); if (!sym->st\_name && !sym->st\_size && !sym->st\_value)//全为0是符号表的第一项 continue;//printf("\\nfind\_symbol\_in\_linkmap strtab = %x\\n",strtab); str = (char \*) ptrace\_readstr(pid, strtab + sym->st\_name);//printf("\\nfind\_symbol\_in\_linkmap str = %s\\n",str);//printf("\\nfind\_symbol\_in\_linkmap sym->st\_value = %x\\n",sym->st\_value); if (strcmp(str, sym\_name) == 0) \{printf("\\nfind\_symbol\_in\_linkmap str = %s\\n",str);printf("\\nfind\_symbol\_in\_linkmap sym->st\_value = %x\\n",sym->st\_value); free(str);if(sym->st\_value == 0)//值为0代表这个符号本身就是重定向的内容continue;flags = 1; //str = ptrace\_readstr(pid, (unsigned long)lm->l\_name); //printf("find\_symbol\_in\_linkmap lib name \[%s\]\\n", str); //free(str); break; \} free(str); \}while(1); if (flags != 1) ret = 0; else ret = link\_addr + sym->st\_value; free(sym); return ret;\}/\* 解析指定符号 \*/unsigned long find\_symbol(int pid, struct link\_map \*map, char \*sym\_name)\{ struct link\_map \*lm = map; unsigned long sym\_addr; char \*str;unsigned long tmp; //sym\_addr = find\_symbol\_in\_linkmap(pid, map, sym\_name); //return 0; //if (sym\_addr) // return sym\_addr;//printf("\\nfind\_symbol map = %x\\n",map);//ptrace\_read(pid,(char \*)map+12,&tmp,4);//lm = tmp;//printf("find\_symbol lm = %x\\n",lm); //ptrace\_read(pid, (unsigned long)map->l\_next, lm, sizeof(struct link\_map)); sym\_addr = find\_symbol\_in\_linkmap(pid, lm, sym\_name); while(!sym\_addr ) \{ ptrace\_read(pid, (char \*)lm+12, &tmp, 4);//获取下一个库的link\_map地址if(tmp == 0)return 0;lm = tmp;//printf("find\_symbol lm = %x\\n",lm); /\*str = ptrace\_readstr(pid, (unsigned long)lm->l\_name); if(str\[0\] == '/0') continue; printf("\[%s\]\\n", str); free(str);\*/ if ((sym\_addr = find\_symbol\_in\_linkmap(pid, lm, sym\_name))) break; \} return sym\_addr;\}/\* 查找符号的重定位地址 \*/unsigned long find\_sym\_in\_rel(int pid, char \*sym\_name)\{ Elf32\_Rel \*rel = (Elf32\_Rel \*) malloc(sizeof(Elf32\_Rel)); Elf32\_Sym \*sym = (Elf32\_Sym \*) malloc(sizeof(Elf32\_Sym)); int i; char \*str; unsigned long ret; struct link\_map \*lm;lm = map\_addr; //get\_dyn\_info(pid); do\{get\_sym\_info(pid,lm); ptrace\_read(pid, (char \*)lm+12, &lm, 4); //首先查找过程连接的重定位表 for(i = 0; i< nrels ;i++) \{ ptrace\_read(pid, (unsigned long)(jmprel + i \* sizeof(Elf32\_Rel)), rel, sizeof(Elf32\_Rel)); if(ELF32\_R\_SYM(rel->r\_info)) \{ ptrace\_read(pid, symtab + ELF32\_R\_SYM(rel->r\_info) \* sizeof(Elf32\_Sym), sym, sizeof(Elf32\_Sym)); str = ptrace\_readstr(pid, strtab + sym->st\_name); if (strcmp(str, sym\_name) == 0) \{if(sym->st\_value != 0)\{free(str);continue;\}modifyflag = 1; free(str); break; \} free(str); \} \}if(modifyflag == 1)break;//没找到的话，再找在链接时就重定位的重定位表for(i = 0; i< nreldyns;i++) \{ ptrace\_read(pid, (unsigned long)(reldyn+ i \* sizeof(Elf32\_Rel)), rel, sizeof(Elf32\_Rel)); if(ELF32\_R\_SYM(rel->r\_info)) \{ ptrace\_read(pid, symtab + ELF32\_R\_SYM(rel->r\_info) \* sizeof(Elf32\_Sym), sym, sizeof(Elf32\_Sym)); str = ptrace\_readstr(pid, strtab + sym->st\_name); if (strcmp(str, sym\_name) == 0) \{if(sym->st\_value != 0)\{free(str);continue;\}modifyflag = 2; free(str); break; \} free(str); \} \}if(modifyflag == 2)break; \}while(lm);//printf("find\_sym\_in\_rel flags = %d\\n",flags); if (modifyflag == 0) ret = 0; else ret = link\_addr + rel->r\_offset;//printf("find\_sym\_in\_rel link\_addr = %x\\t sym->st\_value = %x\\n",link\_addr , sym->st\_value); free(rel);free(sym); return ret;\}/\* 在进程自身的映象中(即不包括动态共享库，无须遍历link\_map链表)获得各种动态信息 \*//\*void get\_dyn\_info(int pid)\{ Elf32\_Dyn \*dyn = (Elf32\_Dyn \*) malloc(sizeof(Elf32\_Dyn)); int i = 0; ptrace\_read(pid, dyn\_addr + i \* sizeof(Elf32\_Dyn), dyn, sizeof(Elf32\_Dyn)); i++; while(dyn->d\_tag)\{ switch(dyn->d\_tag) \{ case DT\_SYMTAB: //puts("DT\_SYMTAB"); symtab = dyn->d\_un.d\_ptr; break; case DT\_STRTAB: strtab = dyn->d\_un.d\_ptr; //puts("DT\_STRTAB"); break; case DT\_JMPREL: jmprel = dyn->d\_un.d\_ptr; //puts("DT\_JMPREL"); //printf("jmprel\\t %p\\n", jmprel); break; case DT\_PLTRELSZ: totalrelsize = dyn->d\_un.d\_val; //puts("DT\_PLTRELSZ"); break; case DT\_RELAENT: relsize = dyn->d\_un.d\_val; //puts("DT\_RELAENT"); break; case DT\_RELENT: relsize = dyn->d\_un.d\_val; //puts("DT\_RELENT"); break; \} ptrace\_read(pid, dyn\_addr + i \* sizeof(Elf32\_Dyn), dyn, sizeof(Elf32\_Dyn)); i++; \} nrels = totalrelsize / relsize; free(dyn);\}\*//\*void call\_dl\_open(int pid, unsigned long addr, char \*libname)\{ void \*pRLibName; struct user\_regs\_struct regs; /\* 先找个空间存放要装载的共享库名，我们可以简单的把它放入堆栈 pRLibName = ptrace\_push(pid, libname, strlen(libname) + 1); /\* 设置参数到寄存器 ptrace\_readreg(pid, &regs); regs.eax = (unsigned long) pRLibName; regs.ecx = 0x0; regs.edx = RTLD\_LAZY; ptrace\_writereg(pid, &regs); /\* 调用\_dl\_open ptrace\_call(pid, addr); puts("call \_dl\_open ok");\}\*//\*\#define RTLD\_LAZY0x00001\#define RTLD\_NOW0x00002\#defineRTLD\_BINDING\_MASK 0x3\#define RTLD\_NOLOAD0x00004\#define RTLD\_DEEPBIND0x00008\#define RTLD\_GLOBAL0x00100\#define RTLD\_LOCAL0\#define RTLD\_NODELETE0x01000 \*/void call\_\_libc\_dlopen\_mode(int pid, unsigned long addr, char \*libname)\{ void \*plibnameaddr; //printf("call\_\_libc\_dlopen\_mode libname = %s\\n",libname);//printf("call\_\_libc\_dlopen\_mode addr = %x\\n",addr);//将需要加载的共享库地址压栈 plibnameaddr = ptrace\_push(pid, libname, strlen(libname) + 1);ptrace\_push(pid,&mode,sizeof(int));ptrace\_push(pid,&plibnameaddr,sizeof(plibnameaddr)); /\* 调用\_\_libc\_dlopen\_mode \*/ ptrace\_call(pid, addr);\}void call\_printf(int pid, unsigned long addr, char \*string)\{ void \*paddr; paddr = ptrace\_push(pid, string, strlen(string) + 1);ptrace\_push(pid,&paddr,sizeof(paddr)); ptrace\_call(pid, addr);\}

作者所做的修改，读者可以对比文章最后的连接中的代码。

这边对于程序的具体解释，就不具体展开了。

需要注意的是，原来是采用\_dl\_open的方式加载库函数，但是ld库并没有这个符号导出。而libc库中导出了一个可以加载库的\_\_libc\_dlopen\_mode函数。5.主函数

先说一下流程，

a.获取被跟踪进程的link\_map地址

b.根据link\_map给出的信息，搜索符号表，遍历每一个link\_map中的符号表，直到找到想要找的符号。这里是printf或者\_\_libc\_dlopen\_mode函数

c.将库路径包括库名称传递给调用\_\_libc\_dlopen\_mode的函数，该函数即call\_\_libc\_dlopen\_mode会把\_\_libc\_dlopen\_mode函数需要的参数，路径和加载方式压栈，在让被跟踪进

程开始运行之前，压入一个非法地址，当\_\_libc\_dlopen\_mode返回时返回到一个非法地址时，就会发生中断，此时跟踪进程可以waitpid跟踪到。好，设置寄存器，并让被跟踪进程开

始运行。打开库之后，被跟踪进程因中断而被跟踪进程再次获得控制权。

d.再一次根据之前保存的link\_map信息，当然完全可以直接用上一次搜索结果结束之后的link\_map往后找，因为新库一定在最后，但是本文还是从头开始找，找到新库中的

newmyprint地址。

e.还是根据link\_map信息查找printf的重定向地址，在rel.dyn节中，有关这个rel.dyn和rel.plt等节之间的关系，可以看我的其他博文。

f.将newmyprint的地址填入printf的重定向地址。

g.将被跟踪进程原先的寄存器设置回去，释放控制。

h.被跟踪进程开始输出“哈哈哈哈哈”。

上源码：

int main(int argc, char \*argv\[\])\{ int pid; struct link\_map \*map; char sym\_name\[256\]; unsigned long sym\_addr; unsigned long new\_addr,old\_addr,rel\_addr;int status = 0;char libpath\[1024\];char oldfunname\[128\];char newfunname\[128\];//mode = atoi(argv\[2\]);if(argc < 5)\{printf("usage : ./injso pid libpath oldfunname newfunname\\n");exit(-1);\} /\* 从命令行取得目标进程PID\*/ pid = atoi(argv\[1\]); /\* 从命令行取得新库名称\*/memset(libpath,0,sizeof(libpath));memcpy(libpath,argv\[2\],strlen(argv\[2\])); /\* 从命令行取得旧函数的名称\*/memset(oldfunname,0,sizeof(oldfunname));memcpy(oldfunname,argv\[3\],strlen(argv\[3\])); /\* 从命令行取得新函数的名称\*/memset(newfunname,0,sizeof(newfunname));memcpy(newfunname,argv\[4\],strlen(argv\[4\]));printf("main pid = %d\\n",pid);printf("main libpath : %s\\n",libpath);printf("main oldfunname : %s\\n",oldfunname);printf("main newfunname : %s\\n",newfunname); /\* 关联到目标进程\*/ ptrace\_attach(pid); /\* 得到指向link\_map链表的指针 \*/ map = get\_linkmap(pid); /\* get\_linkmap \*/ sym\_addr = find\_symbol(pid, map, "printf"); printf("found printf at addr %p\\n", sym\_addr); if(sym\_addr == 0)goto detach;call\_printf(pid,sym\_addr,"injso successed\\n");waitpid(pid,&status,0);printf("status = %x\\n",status); /\*ptrace\_writereg(pid, &oldregs);ptrace\_cont(pid);waitpid(pid,&status,0);//printf("status = %x\\n",status); //ptrace\_readreg(pid, &oldregs);//oldregs.eip = 0x8048414; //ptrace\_writereg(pid, &oldregs);ptrace\_cont(int pid)(pid);ptrace\_detach(pid);exit(0);\*/ /\* 发现\_\_libc\_dlopen\_mode，并调用它 \*/ sym\_addr = find\_symbol(pid, map, "\_\_libc\_dlopen\_mode"); /\* call \_dl\_open \*/ printf("found \_\_libc\_dlopen\_mode at addr %p\\n", sym\_addr); if(sym\_addr == 0)goto detach; call\_\_libc\_dlopen\_mode(pid, sym\_addr,libpath); /\* 注意装载的库地址 \*/ //while(1);waitpid(pid,&status,0);/\* 找到新函数的地址 \*/ strcpy(sym\_name, newfunname); /\* intercept \*/ sym\_addr = find\_symbol(pid, map, sym\_name); printf("%s addr\\t %p\\n", sym\_name, sym\_addr);if(sym\_addr == 0)goto detach; /\* 找到旧函数在重定向表的地址 \*/ strcpy(sym\_name, oldfunname); rel\_addr = find\_sym\_in\_rel(pid, sym\_name); printf("%s rel addr\\t %p\\n", sym\_name, rel\_addr);if(rel\_addr == 0)goto detach; /\* 找到用于保存read地址的指针 \*/ //strcpy(sym\_name, "oldread"); //old\_addr = find\_symbol(pid, map, sym\_name); //printf("%s addr\\t %p\\n", sym\_name, old\_addr); /\* 函数重定向 \*/ puts("intercept..."); /\* intercept \*/ //ptrace\_read(pid, rel\_addr, &new\_addr, sizeof(new\_addr)); //ptrace\_write(pid, old\_addr, &new\_addr, sizeof(new\_addr)); //rel\_addr = 0x8048497;如果是静态地址，也就是未导出该符号地址，那么只能通过反汇编先找到该函数被调用的地方，将这个地方的跳转地址修改 if(modifyflag == 2)sym\_addr = sym\_addr - rel\_addr - 4;printf("main modify sym\_addr = %x\\n",sym\_addr);ptrace\_write(pid, rel\_addr, &sym\_addr, sizeof(sym\_addr)); puts("injectso ok");detach:printf("prepare to detach\\n");ptrace\_detach(pid);return 0; \}

这里面有一个很重要的地方，如果不先在目标进程中调用printf就不能够调用\_\_lib\_dlopen\_mode成功，这个原因很奇怪，根据当时的core文件来看崩溃在了下面的这个函数，原因是\_dl\_open\_hook这个全局变量为0，但实际上运行过printf之后，这个\_dl\_open\_hook还是0。这个有待后续检验。void \*\_\_libc\_dlsym (void \*map, const char \*name)\{ struct do\_dlsym\_args args; args.map = map; args.name = name;\#ifdef SHARED if (\_\_builtin\_expect (\_dl\_open\_hook != NULL, 0)) return \_dl\_open\_hook->dlsym (map, name);\#endif return (dlerror\_run (do\_dlsym, &args) ? NULL : (void \*) (DL\_SYMBOL\_ADDRESS (args.loadbase, args.ref)));\}

运行结果：

root@leo-desktop:injso\# ./test

1467364356 : original

injso successed

hahahahahahahahahahahahahaha6.如何替换未导出符号的地址

被替换函数源码：\#include //int fun2();int fun1()\{ printf("fun1\\n");// fun2();\}int main()\{ signed int i = 0x40011673 ; i = i - 0x4001172d ; printf("i = %x\\n",i); while(1)\{ i = fun1(); sleep(10); \} return 1;\}

这个怎么来替换fun1函数的地址呢？

首先反汇编得到main的机器码，如下，08048468 : 8048468: 55 push %ebp 8048469: 89 e5 mov %esp,%ebp 804846b: 83 e4 f0 and $0xfffffff0,%esp 804846e: 83 ec 20 sub $0x20,%esp 8048471: c7 44 24 1c 73 16 01 movl $0x40011673,0x1c(%esp) 8048478: 40 8048479: 81 6c 24 1c 2d 17 01 subl $0x4001172d,0x1c(%esp) 8048480: 40 8048481: b8 75 85 04 08 mov $0x8048575,%eax 8048486: 8b 54 24 1c mov 0x1c(%esp),%edx 804848a: 89 54 24 04 mov %edx,0x4(%esp) 804848e: 89 04 24 mov %eax,(%esp) 8048491: e8 ce fe ff ff call 8048364 8048496: e8 b9 ff ff ff call 8048454 804849b: 89 44 24 1c mov %eax,0x1c(%esp) 804849f: c7 04 24 0a 00 00 00 movl $0xa,(%esp) 80484a6: e8 c9 fe ff ff call 8048374 80484ab: eb e9 jmp 8048496 80484ad: 90 nop 80484ae: 90 nop 80484af: 90 nop

可以看到在地址0x8048496处的机器码是跳转到fun1函数的，那么这个ffffffb9就是call的操作数，操作数地址0x8048497，也就是说把这个地址中的数值改掉就可以了，有关这个call或者jmp的地址计算可以查看我的另外一篇博文。

有关这个如何跳转的方法，已经在主函数的代码中给出了，但是被我注释掉了，大家感兴趣的话，可以自己试试。

效果：

root@leo-desktop:lib2lib\# ./a.out

i = ffffff46

fun1

injso successed

hahahahahahaha^C

这里面的无关代码，大家仔细看，是为了证明call的函数地址计算方式的。7.总结

那么讲到现在的话，已经实现了不管函数符号是否导出都可以实现运行时替换的代码。

这里面主要的技术是，elf文件格式，运行时加载的过程，跳转地址的计算，运行时链接的过程，也就是plt表(当然这个也可以从我的另一篇博文中看到)。

比较遗憾的是有关那个奔溃，有网友如果找到了原因，请回复下，3q。当然我也会自己再研究下。

最后补上全局变量和头文件：\#include \#include \#include \#include \#include \#include \#include \#include \#include \#include \#include \#include \#include \#define IMAGE\_ADDR 0x08048000int mode = 2;struct user\_regs\_struct oldregs;Elf32\_Addr phdr\_addr;Elf32\_Addr dyn\_addr;Elf32\_Addr map\_addr;Elf32\_Addr symtab;Elf32\_Addr strtab;Elf32\_Addr jmprel;Elf32\_Addr reldyn;Elf32\_Word reldynsz;Elf32\_Word totalrelsize;Elf32\_Word relsize;unsigned long link\_addr;int nrels;int nreldyns;//int nchains;int modifyflag = 0;/\*char libpath\[128\] = "/mnt/hgfs/svnroot/test/injectsov2/prj\_linux/so.so";\*/

8.修正

针对在调用\_\_libc\_dlopen\_mode函数之前需要调用printf的问题，终于让我在晚上解决了。

首先，我尝试了调用其他函数而不是printf函数，发现效果一样，包括第一次是调用\_\_libc\_dlopen\_mode，第二次对该函数的调用都可以成功。

其次，那么现在问题就集中在了这两个\_\_libc\_dlopen\_mode调用之间的差别在哪里，程序段肯定是一致的，栈也是一致的，而堆空间未使用，还有一个重要的因素，那就是寄存器。

最后，发现在调用\_\_libc\_dlopen\_mode前，有四个寄存器不同，分别是eax，orig\_eax,eflags和esp。我一开始认为，通用寄存器eax和orig\_eax不会对程序的执行造成影响。但是通过实验，仅调一次\_\_libc\_dlopen\_mode，部分寄存器赋正确执行时的值，发现对eax和orig\_eax被赋于正确执行时的值时，程序可以正常运行，而且不仅仅必须是一种值，比如eax可以是0,1,0xffffffff，很多值都可以，但是被赋予0xfffffdfc和0xfffffdff等值时会失败，试验过并不是因为d这一位决定的，0xfffffdf0或者d00是可以运行成功的。(gdb) disassemble \_\_libc\_dlopen\_modeDump of assembler code for function \_\_libc\_dlopen\_mode: 0x00232640 :push %ebp 0x00232641 :mov %esp,%ebp 0x00232643 :sub $0x1c,%esp 0x00232646 :mov %ebx,-0x8(%ebp) 0x00232649 :mov 0x8(%ebp),%eax 0x0023264c :call 0x144a0f 0x00232651 :add $0x519a3,%ebx 0x00232657 :mov 0xc(%ebp),%edx 0x0023265a :mov %esi,-0x4(%ebp) 0x0023265d :mov %eax,-0x14(%ebp) 0x00232660 :mov %edx,-0x10(%ebp) 0x00232663 :mov 0x354c(%ebx),%esi 0x00232669 :test %esi,%esi

在实验中，还发现对eax赋于不正确的值时，当时忘了记了，还让程序跑飞了。崩了，但是新库已经加载上了。所以这个函数替换还是有一定的风险，或者说libc库本身存在一定的bug。

所以现在问题找到了，在于eax和orig\_eax上，但是对\_\_libc\_dlopen\_mode反汇编发现，eax在函数开头就被赋予了通过栈传递的参数2的值，所以eax不应该影响程序的运行，但实际上影响了，这一点让我觉得很奇怪，如果有任何网友对这个原因知晓的话，麻烦回复，万分感谢。

linux共享库注射地址：http://www.docin.com/p-634172083.html

转载请保留本文网址：http://www.shaoqun.com/a/235536.html

\*特别声明：以上内容来自于网络收集，著作权属原作者所有，如有侵权，请联系我们：admin@shaoqun.com。

linux