加密so文件中指定的函数

来源：互联网发布：vb app 编辑：程序博客网时间：2024/04/30 15:16

加密so文件中指定的函数

作者: 0n1y3nd丶分类: 逆向学习发布时间: 2014-09-04 22:24 ė 61条评论

前言

上一篇文章中详细分析了对so文件中自定义section的加密，这一篇来分析下对so文件中自定义函数的加密

原文地址：http://bbs.pediy.com/showthread.php?t=191649

0×1

需要加密的函数是： Java_com_example_shelldemo2_MainActivity_getString

0×2

加密

a、整个加密过程中最重要的便是在文件中找到指定函数的位置，然后去做加密处理，最后将加密过后的数据写入原位置

b、从一个ELF动态链接库文件中，根据已知的函数名称，找到相应的函数起始地址的过程如下：

从ELF的header找到文件的偏移ehdr->e_phoff。找到d_tag为PT_DYNAMIC的pargram header。

一个phdr对应一个Segment。包含了好几个节

从这个Segment开始位置找到名为：DT_DYNAMIC的节，然后从这个节中找到Elf32_Sym这个一个结构

根据结构的成员变量st_name，来和函数名称比较，相符，就用st_value和st_size两个变量找到函数的数据

c、结合代码详细分析此流程

①、main函数：

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
int main(int argc, char **argv){
    char secName[] = ".text";
    char funcName[] = "Java_com_example_shelldemo2_MainActivity_getString";
    char *content = NULL;
    int fd, i;
    Elf32_Off secOff;
    funcInfo info;
 
    if(argc < 2){
        puts("Usage: shellAdder2 libxxx.so .(section) function");
        return -1;
    }
    fd = open(argv[1], O_RDWR);
    if(fd < 0){
        printf("open %s failed\n", argv[1]);
        goto _error;
    }
 
    /*
    根据section名称 找到section，返回值是section table的sh_offset
    */
 
    secOff = findTargetSectionAddr(fd, secName);   
    if(secOff == -1){
        printf("Find section %s failed\n", secName);
        goto _error;
    }
 
    /*
    根据函数名称，找到函数信息，返回的是一个结构体，包含函数数据的偏移地址和大小
    */
 
    if(getTargetFuncInfo(fd, funcName, &info) == -1){
        printf("Find function %s failed\n", funcName);
        goto _error;
    }
 
    /*
    根据函数的偏移地址和大小，去读取函数，然后做加密处理
    */
 
    content = (char*) malloc(info.st_size);
    if(content == NULL){
        puts("Malloc space failed");
        goto _error;
    }
 
    lseek(fd, info.st_value - 1, SEEK_SET);
    if(read(fd, content, info.st_size) != info.st_size){
        puts("Malloc space failed");
        goto _error;
    }
 
    /*
    将函数数据加密处理
    */
 
    for(i=0;i<info.st_size -1;i++){
        content[i] = ~content[i];
    }
 
    /*
    加密后，写回原位置
    */
 
    lseek(fd, info.st_value, SEEK_SET);
    if(write(fd, content, info.st_size) != info.st_size){
        puts("Write modified content to .so failed");
        goto _error;
    }
    puts("Complete!");
 
_error:
    free(content);
    close(fd);
    return 0;
}

②、findTargetSectionAddr 函数，根据section名称找到对应的section位置，这里就不做详细介绍了，上一篇中已经详细提到过。

③、getTargetFuncInfo 函数，根据函数名称，寻找函数地址及大小

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
staticchargetTargetFuncInfo(intfd,constchar*funcName,funcInfo*info){
    charflag=-1,*dynstr;
    inti;
    Elf32_SymfunSym;
    Elf32_Phdrphdr;
    Elf32_Offdyn_off;
    Elf32_Worddyn_size,dyn_strsz;
    Elf32_Dyndyn;
    Elf32_Addrdyn_symtab,dyn_strtab,dyn_hash;
    unsignedfunHash,nbucket,nchain,funIndex;
 
    lseek(fd,ehdr.e_phoff,SEEK_SET);    //elf header中e_phoff表示的是程序头的偏移
                                          /*
                                           循环遍历，找到.dynamic这个section   并记录其大小和偏移
    */
    for(i=0;i<ehdr.e_phnum;i++){      
        if(read(fd,&phdr,sizeof(Elf32_Phdr))!=sizeof(Elf32_Phdr)){  //读取peogram header 保存在phdr中
            puts("Read segment failed");
            goto_error;
        }
        if(phdr.p_type==  PT_DYNAMIC){  // PT_DYNAMIC 表示数组元素给出动态链接信息
            dyn_size=phdr.p_filesz;    // p_filesz  段在文件映像中所占的字节数
            dyn_off=phdr.p_offset;      // 从文件头到该段第一个字节的偏移
            flag=0;
            printf("Find section %s, size = 0x%x, addr = 0x%x\n",".dynamic",dyn_size,dyn_off);
            break;
        }
    }
    if(flag){
        puts("Find .dynamic failed");
        goto_error;
    }
    flag=0;
 
    lseek(fd,dyn_off,SEEK_SET);  //定位到.dynamic
    for(i=0;i<dyn_size/sizeof(Elf32_Dyn);i++){
        if(read(fd,&dyn,sizeof(Elf32_Dyn))!=sizeof(Elf32_Dyn)){
            puts("Read .dynamic information failed");
            goto_error;
        }    
        if(dyn.d_tag==DT_SYMTAB){      //循环遍历，找到d_tag为DT_SYMATAB的一项，  dyn此元素包含符号表的地址
            dyn_symtab=dyn.d_un.d_ptr;    //此 Elf32_Addr 对象代表程序的虚拟地址
            flag+=1;
            printf("Find .dynsym, addr = 0x%x\n",dyn_symtab);
        }
        if(dyn.d_tag==DT_HASH){        //循环遍历，找到.hash
            dyn_hash=dyn.d_un.d_ptr;
            flag+=2;
            printf("Find .hash, addr = 0x%x\n",dyn_hash);
        }
        if(dyn.d_tag==DT_STRTAB){      //找到.dynstr的位置
            dyn_strtab=dyn.d_un.d_ptr;
            flag+=4;
            printf("Find .dynstr, addr = 0x%x\n",dyn_strtab);
        }
        if(dyn.d_tag==DT_STRSZ){        //找到.dynstr的大小
            dyn_strsz=dyn.d_un.d_val;
            flag+=8;
            printf("Find .dynstr size, size = 0x%x\n",dyn_strsz);
        }
    }
    if((flag&0x0f)!=0x0f){          //判断是不是全部都找到了
        puts("Find needed .section failed\n");
        goto_error;
    }
 
    dynstr=(char*)malloc(dyn_strsz);  //根据大小申请内存空间
    if(dynstr==NULL){
        puts("Malloc .dynstr space failed");
        goto_error;
    }
 
    lseek(fd,dyn_strtab,SEEK_SET);    //定位到dyn_strtab  读取.dynstr里面的字符串值
    if(read(fd,dynstr,dyn_strsz)!=dyn_strsz){
        puts("Read .dynstr failed");
        goto_error;
    }
    //  print_all(dynstr, dyn_strsz);
 
    funHash=elfhash(funcName);      //调用elf_hash函数，根据函数名计算一个索引值
    printf("Function %s hashVal = 0x%x\n",funcName,funHash);
 
    lseek(fd,dyn_hash,SEEK_SET);    //读取hash表中的nbucket
    if(read(fd,&nbucket,4)!=4){
        puts("Read hash nbucket failed\n");
        goto_error;
    }
    printf("nbucket = %d\n",nbucket);
 
    if(read(fd,&nchain,4)!=4){  //读取hash表中的nchain
        puts("Read hash nchain failed\n");
        goto_error;
    }
    //  printf("nchain = %d\n", nchain);
 
    funHash=funHash%nbucket;
    printf("funHash mod nbucket = %d \n",funHash);
 
    lseek(fd,funHash*4,SEEK_CUR);
    if(read(fd,&funIndex,4)!=4){
        puts("Read funIndex failed\n");
        goto_error;
    }
 
    lseek(fd,dyn_symtab+funIndex*sizeof(Elf32_Sym),SEEK_SET);  //
    if(read(fd,&funSym,sizeof(Elf32_Sym))!=sizeof(Elf32_Sym)){
        puts("Read funSym failed");
        goto_error;
    }
 
    if(strcmp(dynstr+funSym.st_name,funcName)!=0)//循环，在chain表中查找需要的符号表
    {
        while(1)
        {
            lseek(fd,dyn_hash+4*(2+nbucket+funIndex),SEEK_SET);  //在chain数组中定位
 
            if(read(fd,&funIndex,4)!=4)
            {
                puts("Read funIndex failed\n");
                goto_error;
            }
 
            if(funIndex==0)
            {
                puts("Cannot find funtion!\n");
                goto_error;
            }
 
            lseek(fd,dyn_symtab+funIndex*sizeof(Elf32_Sym),SEEK_SET);//根据索引，在syn_symtab中找到对应的结构体
 
            if(read(fd,&funSym,sizeof(Elf32_Sym))!=sizeof(Elf32_Sym))
            {
                puts("In FOR loop, Read funSym failed");
                goto_error;
            }
 
            if(strcmp(dynstr+funSym.st_name,funcName)==0)
            {
                break;
            }
        }
    }
 
    printf("Find: %s, offset = 0x%x, size = 0x%x\n",funcName,funSym.st_value,funSym.st_size);
    info->st_value=funSym.st_value;
    info->st_size=funSym.st_size;
    free(dynstr);
    return0;
 
_error:
    free(dynstr);
    return-1;
}

该函数返回包含函数信息的结构体funcInfo

1
2
3
4
typedef struct _funcInfo{
        Elf32_Addr st_value;
        Elf32_Word st_size;
}funcInfo;

st_value代表位置，st_size代表大小，根据位置和大小去读取函数的信息。

d、文字叙述：

根据e_phoff找到第一个program header

C++
1
2
3
4
5
6
7
8
9
10
11
typedefstruct
{
    Elf32_Wordp_type;/*segment的类型：PT_LOAD = 1 可加载的段*/
    Elf32_Offp_offset;/*从文件头到该段第一个字节的偏移*/
    Elf32_Addrp_vaddr;/*该段第一个字节被放到内存中的虚拟地址*/
    Elf32_Addrp_paddr;/*在linux中这个成员没有任何意义，值与p_vaddr相同*/
    Elf32_Wordp_filesz;/*该段在文件映像中所占的字节数*/
    Elf32_Wordp_memsz;/*该段在内存映像中占用的字节数*/
    Elf32_Wordp_flags;/*段标志*/
    Elf32_Wordp_align;/*p_vaddr是否对齐*/
}Elf32_phdr;

根据p_type 找到 p_type == PT_DYNAMIC 的这个phdr [数组元素给出动态链接信息]

此段包含.dynamic这个section。

通过.dynamic这个里面的p_offset就能找到Elf32_Dyn这样一个结构体

1
2
3
4
5
6
7
typedef struct dynamic{
    Elf32_Sword d_tag;//标识
    union{
             Elf32_Sword d_val; //表示一个整数值，可以有多种解释
             Elf32_Addr d_ptr; //代表程序的虚拟地址
            } d_un;
    }Elf32_Dyn;

根据d_tag标识，找到标识为 d_tag == DT_SYMTAB、d_tag == DT_HASH、d_tag ==DT_STRTAB、d_tag == DT_STRSZ、的这一系列section。

申请大小为d_uu.d_val的内存空间，为读取.dynstr做准备

可以借助readelf查看.dynstr这个节里的内容

可以知道.dynstr这个section中保存的正是所有函数的名称

通过函数名称，调用elfhash函数，计算出一个hash值

读取hash表里面的一些信息

读取.hash这个section的前四字节。保存在nbucket

读取.hash这个section的第4-8字节。保存在nchain

那么，这两个数值有什么用呢

这得从hash表的组织结构说起

hash表的结构如下：

nbucket

nchain

bucket[nbucket]

chain[nchain]

4部分，nbucket，nchain，bucket数组，chain数组

两个数组中都保存着符号表索引。

hash函数根据函数名称得到一个hash值，设为X，则bucket[X % nbucket]给出了一个索引，设为Y

该索引可用于符号表，也可用于chain表，如果符号表项不是所需要的，那么chain[Y]则给出了具有相同hash值的下一个符号表项

我们就可以根据chain这个类似于链的结构，一直向下搜索。直到找到所需的符号表项。或者chain项中包含值STN_UNDEF。

通过hash表，能够找到一系列的符号表

符号表结构如下

1
2
3
4
5
6
7
8
typedef  struct{
        Elf32_Wordst_name;//名称，索引到字符串表
        Elf32_Addrst_value;//给出相关联的符号的取值。依赖于具体的上下文.
        Elf32_Wordst_size;//相关的尺寸大小
        unsignedcharst_info;//给出符号的类型和绑定属性.
        unsignedcharst_other;//该成员当前包含 0，其含义没有定义。
        Elf32_Halfst_shndx;//给出相关的节区头部表索引。某些索引具有特殊含义。
}Elf32_sym;

通过st_name来判断找到的符号表正是我们需要的

所有有了下面这样一个循环

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
if(strcmp(dynstr + funSym.st_name, funcName) != 0)
  {
    while(1)
    {
            lseek(fd, dyn_hash + 4 * (2 + nbucket + funIndex), SEEK_SET);
 
            if(read(fd, &funIndex, 4) != 4)
               {
                puts("Read funIndex failed\n");
             goto _error;
               }
 
            if(funIndex == 0)
               {
            puts("Cannot find funtion!\n");
            goto _error;
            }
 
            lseek(fd, dyn_symtab + funIndex * sizeof(Elf32_Sym), SEEK_SET);
 
            if(read(fd, &funSym, sizeof(Elf32_Sym)) != sizeof(Elf32_Sym))
               {
             puts("In FOR loop, Read funSym failed");
            goto _error;
              }
 
            if(strcmp(dynstr + funSym.st_name, funcName) == 0)
               {
                break;
              }
    }
  }

这个循环的发生是在bucket数组中没有找到我们需要的符号表才进入的。也就是说，这个过程其实是在遍历chain这个数组

lseek(fd, dyn_hash + 4 * (2 + nbucket + funIndex), SEEK_SET);

其中funIndex是函数的索引值

hash表前两项是 nbucket 和 nchain 两个int型数据。

还有一个int型数组bucket[] 长度是nbucket

所以，根据dyn_hash + (2 + nbucket + funIndex) * 4 便实现了根据索引定位到chain数组中函数的位置

然后再去dyn_symtab中找到对应的Elf32_Sym结构

根据其中的st_name来进行判断，循环查找

0×3

解密

a、解密的过程和加密过程基本上一致的，只是说我们必须得到内存中去寻找那一系列的地址。

大致过程是：

在内存中找到so文件被加载到的地址，记为base

寻找函数

修改内存页属性

解密函数数据

还原内存页属性

b、解密入口函数如下：

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
voidinit_getString(){
    constchartarget_fun[]="Java_com_example_shelldemo2_MainActivity_getString";
    funcInfoinfo;
    inti;
    unsignedintnpage,base=getLibAddr();
 
    __android_log_print(ANDROID_LOG_INFO,"JNITag","base addr =  0x%x",base);
 
    if(getTargetFuncInfo(base,target_fun,&info)==-1){
      print_debug("Find Java_com_example_shelldemo2_MainActivity_getString failed");
      return;
    }
 
    npage=info.st_size/PAGE_SIZE+((info.st_size%PAGE_SIZE==0)?0:1);
 
    if(mprotect((void*)((base+info.st_value)/PAGE_SIZE*PAGE_SIZE),npage,PROT_READ|PROT_EXEC|PROT_WRITE)!=0){
        print_debug("mem privilege change failed");
    }
 
    for(i=0;i<info.st_size-1;i++){
        char*addr=(char*)(base+info.st_value-1+i);
        *addr=~(*addr);
    }
 
    if(mprotect((void*)((base+info.st_value)/PAGE_SIZE*PAGE_SIZE),npage,PROT_READ|PROT_EXEC)!=0){
        print_debug("mem privilege change failed");
    }
 
}

里面用到了getLibAddr，getTargetFuncInfo两个函数。

getLibAddr函数用来在程序的内存空间中找到so被加载到的位置。

getTargetFuncInfo函数是用来在程序内存空间中的so中找到需要解密的函数。

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
staticchargetTargetFuncInfo(unsignedlongbase,constchar*funcName,funcInfo*info){
    charflag=-1,*dynstr;
    inti;
    Elf32_Ehdr*ehdr;
    Elf32_Phdr*phdr;
    Elf32_Offdyn_vaddr;
    Elf32_Worddyn_size,dyn_strsz;
    Elf32_Dyn*dyn;
    Elf32_Addrdyn_symtab,dyn_strtab,dyn_hash;
    Elf32_Sym*funSym;
    unsignedfunHash,nbucket;
    unsigned*bucket,*chain;
 
    ehdr=(Elf32_Ehdr*)base;
    phdr=(Elf32_Phdr*)(base+ehdr->e_phoff);
//    __android_log_print(ANDROID_LOG_INFO, "JNITag", "phdr =  0x%p, size = 0x%x\n", phdr, ehdr->e_phnum);
    for(i=0;i<ehdr->e_phnum;++i){
//        __android_log_print(ANDROID_LOG_INFO, "JNITag", "phdr =  0x%p\n", phdr);
        if(phdr->p_type==  PT_DYNAMIC){
            flag=0;
            print_debug("Find .dynamic segment");
            break;
        }
        phdr++;
    }
    if(flag)
        goto_error;
    dyn_vaddr=phdr->p_vaddr+base;
    dyn_size=phdr->p_filesz;
    __android_log_print(ANDROID_LOG_INFO,"JNITag","dyn_vadd =  0x%x, dyn_size =  0x%x",dyn_vaddr,dyn_size);
    flag=0;
    for(i=0;i<dyn_size/sizeof(Elf32_Dyn);++i){
        dyn=(Elf32_Dyn*)(dyn_vaddr+i*sizeof(Elf32_Dyn));
        if(dyn->d_tag==DT_SYMTAB){
            dyn_symtab=(dyn->d_un).d_ptr;
            flag+=1;
            __android_log_print(ANDROID_LOG_INFO,"JNITag","Find .dynsym section, addr = 0x%x\n",dyn_symtab);
        }
        if(dyn->d_tag==DT_HASH){
            dyn_hash=(dyn->d_un).d_ptr;
            flag+=2;
            __android_log_print(ANDROID_LOG_INFO,"JNITag","Find .hash section, addr = 0x%x\n",dyn_hash);
        }
        if(dyn->d_tag==DT_STRTAB){
            dyn_strtab=(dyn->d_un).d_ptr;
            flag+=4;
            __android_log_print(ANDROID_LOG_INFO,"JNITag","Find .dynstr section, addr = 0x%x\n",dyn_strtab);
        }
        if(dyn->d_tag==DT_STRSZ){
            dyn_strsz=(dyn->d_un).d_val;
            flag+=8;
            __android_log_print(ANDROID_LOG_INFO,"JNITag","Find strsz size = 0x%x\n",dyn_strsz);
        }
    }
    if((flag&0x0f)!=0x0f){
        print_debug("Find needed .section failed\n");
        goto_error;
    }
    dyn_symtab+=base;
    dyn_hash+=base;
    dyn_strtab+=base;
    dyn_strsz+=base;
 
    funHash=elfhash(funcName);
    funSym=(Elf32_Sym*)dyn_symtab;
    dynstr=(char*)dyn_strtab;
    nbucket=*((int*)dyn_hash);
    bucket=(int*)(dyn_hash+8);
    chain=(unsignedint*)(dyn_hash+4*(2+nbucket));
 
    flag=-1;
    __android_log_print(ANDROID_LOG_INFO,"JNITag","hash = 0x%x, nbucket = 0x%x\n",funHash,nbucket);
    for(i=bucket[funHash%nbucket];i!=0;i=chain[i]){
        __android_log_print(ANDROID_LOG_INFO,"JNITag","Find index = %d\n",i);
        if(strcmp(dynstr+(funSym+i)->st_name,funcName)==0){
            flag=0;
            __android_log_print(ANDROID_LOG_INFO,"JNITag","Find %s\n",funcName);
            break;
        }
    }
    if(flag)goto_error;
    info->st_value=(funSym+i)->st_value;
    info->st_size=(funSym+i)->st_size;
    __android_log_print(ANDROID_LOG_INFO,"JNITag","st_value = %d, st_size = %d",info->st_value,info->st_size);
    return0;
_error:
    return-1;
}

可以看到，和加密过程中寻找函数地址是一样的。只是在定位过程中得计算偏移地址。

0×4

加密程序执行效果：

解密过程效果：

0 0