Android SO文件保护加固——加密篇（二）

最新推荐文章于 2025-05-09 16:06:41 发布

转载最新推荐文章于 2025-05-09 16:06:41 发布 · 1.5k 阅读

安全专栏收录该内容

34 篇文章

订阅专栏

本文详细介绍了一种无需源码即可对Android平台上的.so文件中的特定函数进行加密的方法，包括加密原理、实现步骤及逆向解密流程。适用于提高应用程序的安全性和防止静态分析。

已经很长一段时间没更新了，一方面本人技术一般，不知道能给技术网友分享点什么有价值的东西，一方面，有时候实验室事比较多，时间长了就分享的意识就单薄了，今天接着前面那个so文件重要函数段加密，接着更，接下来开始书写。

一、原理篇

在很多时候我们对一个.so文件中重要的函数段加密时，是无法拿到源码的，当然并不排除可能在以后随着Android开发与安全结合，出现逆向开发者，在开发的时候就进行一些重要的函数的保护，在上一篇中是对特定的section的加密，加密就可以根据section来进行查找加密不需要源码，而解密是利用linker在加载执行的时候利用__attribute__((constructor))的特性实行so加载时的自解密的特性；

在这一篇中，我们不需要源码，我们拿到待需要保护的.so文件进行加密，怎么加密呢？是基于特定函数进行加密，具体的原理后面会详解；我们知道任何函数在加密过后，在你加载执行的时候都是需要解密的，如果不进行解密的话是一定会报错的，因此这里面比较重要的就是解密时机，只要在加密函数被执行前进行解密完就ok，可以另外写一个.so文件为解密文件，只要在执行函数前解密就可以，原理就是这样。

基本上大致的步骤为：

1.首先要给你进行保护的.so文件中的重要函数加密；
2.逆向开发，自己写针对以上待解密的.so文件；
3.然后修改smali层进行调用解密so文件；

二、详解篇

这里重点讲解对于一个.so文件的重要函数进行加密，逆向开发以及解密在下面实现篇进行介绍；

我们可以用IDA工具拿到要加密的函数名，比如本篇中：

接下来最重要的就是怎么在这个.so文件中找到这个函数名，需要对ELF文件有足够的了解：有一篇北大的关于ELF篇的详细分析文档，当然我都会传到后面附件中。

在加密之前要明白一点就是在ELF文件中一些关于动态链接的时候的一些重要的节区，观察下面这个表格:

可以看出这几个节区的重要性，因此接着看下面这个加密的流程；这一块是借鉴网上大神的一个源码，当然后面会给出分享，我只是在此做出一个梳理有利于读者的学习和理解：

加密流程如下：

1.解析文件头，获取e_phoff、e_phentsize和e_phnum等字段的信息，后面根据这些信息进一步得到p_offset和p_filesz；

2.根据程序头部的结构中的p_type得到Dynamic段的偏移值和大小；

关键代码段为：

3.遍历Dynamic段找到dynsym、.dynstr、.hash section文件中的偏移和.dynstr的大小；这块大家可能比较好奇为什么一个段中有这么多节，这是因为在执行时，把一些相同权限的节放在一起，以减少空间浪费；

大家或许会问为什么有.hash节？

因为别的与此函数名相关的section的type有可能会相同)

比如看这个so文件

这个时候我们看到在北大的ELF分析中讲到：（以下是对原内容的截取）

因此我们可以来分析hash .dynamic段一般用于动态链接的，所以.dynsym和.dynstr，.hash肯定包含在这里。我们可以解析了程序头信息之后，通过type获取到.dynamic程序头信息，然后获取到这个segment的偏移地址和大小

4.根据函数的方法名，计算所对应的hash值，根据hash值，找到下标hash % nbuckets的

bucket；根据bucket中的值，读取.dynsym中的对应索引的Elf32_Sym符号；从符号的

st_name所以找到在.dynstr中对应的字符串与函数名进行比较。若不等，则根据

chain[hash % nbuckets]找下一个Elf32_Sym符号，直到找到或者chain终止为止

5.找到函数方法后进行加密；

三、实现篇

Number01：首先我们自己写一个样本

样本很简答，就是在本地层写一个算法，样本源码会在后面给出链接大致上如下：

JNIEXPORT jstring JNICALL Java_com_example_zbb_test01_MainActivity_getStringFromNative
        (JNIEnv *env, jobject obj, jstring str)
{
   // jstring   CharTojstring(JNIEnv* env,   char* str);
    //首先将string类型的转化为char类型的字符串
    const char *strAry=(*env)->GetStringUTFChars(env,str,0);
    if(strAry==NULL){
        return NULL;
    }
    int len=strlen(strAry);
    char* last=(char*)malloc((len+1)* sizeof(char));
    memset(last,0,len+1);
    //char buf[]={'z','h','a','o','b','e','i','b','e','i'};
    char* buf ="beibei";
    int buf_len=strlen(buf);
    int i;
    for(i=0;i<len;i++){
        last[i]=strAry[i]|buf[i%buf_len];
        if(last[i]==0){
            last[i]=strAry[i];
        }
    }
    last[len]=0;
    return (*env)->NewStringUTF(env, last);
}

Number02:对形成的.so文件的重要函数名进行加密

接着对形成的.so文件中的"Java_com_example_zbb_test01_MainActivity_getStringFromNative"进行加密，当然这块的加密方法读者可以自己来定义，具体的看以下的代码：

[java]view plaincopy 
   
 <span style="font-size:24px;">private static void encodeFunc(byte[] fileByteArys){  
         //寻找Dynamic段的偏移值和大小  
         int dy_offset = 0,dy_size = 0;  
         for(elf32_phdr phdr : type_32.phdrList){  
             if(Utils.byte2Int(phdr.p_type) == ElfType32.PT_DYNAMIC){  
                 dy_offset = Utils.byte2Int(phdr.p_offset);  
                 dy_size = Utils.byte2Int(phdr.p_filesz);  
             }  
         }  
         System.out.println("dy_size:"+dy_size);  
         int dynSize = 8;  
         int size = dy_size / dynSize;  
         System.out.println("size:"+size);  
         byte[] dest = new byte[dynSize];  
         for(int i=0;i<size;i++){  
             System.arraycopy(fileByteArys, i*dynSize + dy_offset, dest, 0, dynSize);  
             type_32.dynList.add(parseDynamic(dest));  
         }  
           
         //type_32.printDynList();  
           
         byte[] symbolStr = null;  
         int strSize=0,strOffset=0;  
         int symbolOffset = 0;  
         int dynHashOffset = 0;  
         int funcIndex = 0;  
         int symbolSize = 16;  
           
         for(elf32_dyn dyn : type_32.dynList){  
             if(Utils.byte2Int(dyn.d_tag) == ElfType32.DT_HASH){  
                 dynHashOffset = Utils.byte2Int(dyn.d_ptr);  
             }else if(Utils.byte2Int(dyn.d_tag) == ElfType32.DT_STRTAB){  
                 System.out.println("strtab:"+dyn);  
                 strOffset = Utils.byte2Int(dyn.d_ptr);  
             }else if(Utils.byte2Int(dyn.d_tag) == ElfType32.DT_SYMTAB){  
                 System.out.println("systab:"+dyn);  
                 symbolOffset = Utils.byte2Int(dyn.d_ptr);  
             }else if(Utils.byte2Int(dyn.d_tag) == ElfType32.DT_STRSZ){  
                 System.out.println("strsz:"+dyn);  
                 strSize = Utils.byte2Int(dyn.d_val);  
             }  
         }  
           
         symbolStr = Utils.copyBytes(fileByteArys, strOffset, strSize);  
         //打印所有的Symbol Name,注意用0来进行分割，C中的字符串都是用0做结尾的  
         /*String[] strAry = new String(symbolStr).split(new String(new byte[]{0})); 
         for(String str : strAry){ 
             System.out.println(str); 
         }*/  
           
         for(elf32_dyn dyn : type_32.dynList){  
             if(Utils.byte2Int(dyn.d_tag) == ElfType32.DT_HASH){  
                 //这里的逻辑有点绕  
                 /** 
                  * 根据hash值，找到下标hash % nbuckets的bucket；根据bucket中的值，读取.dynsym中的对应索引的Elf32_Sym符号； 
                  * 从符号的st_name所以找到在.dynstr中对应的字符串与函数名进行比较。若不等，则根据chain[hash % nbuckets]找下一个Elf32_Sym符号， 
                  * 直到找到或者chain终止为止。这里叙述得有些复杂，直接上代码。 
                     for(i = bucket[funHash % nbucket]; i != 0; i = chain[i]){ 
                       if(strcmp(dynstr + (funSym + i)->st_name, funcName) == 0){ 
                         flag = 0; 
                         break; 
                       } 
                     } 
                  */  
                 int nbucket = Utils.byte2Int(Utils.copyBytes(fileByteArys, dynHashOffset, 4));  
                 int nchian = Utils.byte2Int(Utils.copyBytes(fileByteArys, dynHashOffset+4, 4));  
                 int hash = (int)elfhash(funcName.getBytes());  
                 hash = (hash % nbucket);  
                 //这里的8是读取nbucket和nchian的两个值  
                 funcIndex = Utils.byte2Int(Utils.copyBytes(fileByteArys, dynHashOffset+hash*4 + 8, 4));  
                 System.out.println("nbucket:"+nbucket+",hash:"+hash+",funcIndex:"+funcIndex+",chian:"+nchian);  
                 System.out.println("sym:"+Utils.bytes2HexString(Utils.int2Byte(symbolOffset)));  
                 System.out.println("hash:"+Utils.bytes2HexString(Utils.int2Byte(dynHashOffset)));  
                   
                 byte[] des = new byte[symbolSize];  
                 System.arraycopy(fileByteArys, symbolOffset+funcIndex*symbolSize, des, 0, symbolSize);  
                 Elf32_Sym sym = parseSymbolTable(des);  
                 System.out.println("sym:"+sym);  
                 boolean isFindFunc = Utils.isEqualByteAry(symbolStr, Utils.byte2Int(sym.st_name), funcName);  
                 if(isFindFunc){  
                     System.out.println("find func....");  
                     return;  
                 }  
                   
                 while(true){  
                     /** 
                      *  lseek(fd, dyn_hash + 4 * (2 + nbucket + funIndex), SEEK_SET); 
                         if(read(fd, &funIndex, 4) != 4){ 
                           puts("Read funIndex failed\n"); 
                           goto _error; 
                         } 
                      */  
                     //System.out.println("dyHash:"+Utils.bytes2HexString(Utils.int2Byte(dynHashOffset))+",nbucket:"+nbucket+",funIndex:"+funcIndex);  
                     funcIndex = Utils.byte2Int(Utils.copyBytes(fileByteArys, dynHashOffset+4*(2+nbucket+funcIndex), 4));  
                     System.out.println("funcIndex:"+funcIndex);  
                       
                     System.arraycopy(fileByteArys, symbolOffset+funcIndex*symbolSize, des, 0, symbolSize);  
                     sym = parseSymbolTable(des);  
                       
                     isFindFunc = Utils.isEqualByteAry(symbolStr, Utils.byte2Int(sym.st_name), funcName);  
                     if(isFindFunc){  
                         System.out.println("find func...");  
                         int funcSize = Utils.byte2Int(sym.st_size);  
                         int funcOffset = Utils.byte2Int(sym.st_value);  
                         System.out.println("size:"+funcSize+",funcOffset:"+funcOffset);  
                         //进行目标函数代码部分进行加密  
                         //这里需要注意的是从funcOffset-1的位置开始  
                         byte[] funcAry = Utils.copyBytes(fileByteArys, funcOffset-1, funcSize);  
                         for(int i=0;i<funcAry.length-1;i++){  
                             funcAry[i] = (byte)(funcAry[i] ^ 0xFF);  
                         }  
                         Utils.replaceByteAry(fileByteArys, funcOffset-1, funcAry);  
                         break;  
                     }  
                 }  
                 break;  
             }  
               
         }  
           
     }</span>  

核心部分代码已经在上面介绍；

加密过后再IDA中表现为：

Number03:接下来我们进行逆向开发解密文件的分析：

解密流程为加密逆过程，大体相同，只有一些细微的区别，具体如下：

1) 找到so文件在内存中的起始地址
2) 也是通过so文件头找到Phdr；从Phdr找到PT_DYNAMIC后，需取p_vaddr和p_filesz字段，并非p_offset，这里需要注意。
3) 后续操作就加密类似，就不赘述。对内存区域数据的解密，也需要注意读写权限问题。

[cpp]view plaincopy 
   
 #include <jni.h>  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <string.h>  
 #include <unistd.h>  
 #include <sys/types.h>  
 #include <elf.h>  
 #include <sys/mman.h>  
 #include <android/log.h>  
 //解密函数  
   
 void init_getStringFromNative() __attribute__((constructor));  
 unsigned long getLibAddr();  
   
 void clearcache(char* begin, char *end)  
 {  
     const int syscall = 0xf0002;  
     __asm __volatile (  
         "mov     r0, %0\n"  
         "mov     r1, %1\n"  
         "mov     r7, %2\n"  
         "mov     r2, #0x0\n"  
         "svc     0x00000000\n"  
         :  
         :   "r" (begin), "r" (end), "r" (syscall)  
         :   "r0", "r1", "r7"  
         );  
 }  
   
 void init_getStringFromNative(){  
   char name[15];  
   unsigned int nblock;  
   unsigned int nsize;  
   unsigned long base;  
   unsigned long text_addr;  
   unsigned int i;  
   Elf32_Ehdr *ehdr;  
   Elf32_Shdr *shdr;  
   
   base = getLibAddr();  
   
   ehdr = (Elf32_Ehdr *)base;  
   text_addr = ehdr->e_shoff + base;  
   
   nblock = ehdr->e_entry >> 16;  
   nsize = ehdr->e_entry & 0xffff;  
   
   if(mprotect((void *) base, 4096 * nsize, PROT_READ | PROT_EXEC | PROT_WRITE) != 0){  
       __android_log_print(ANDROID_LOG_INFO, "JNITag", "mem privilege change failed");  
   }  
   
   for(i=0;i< nblock; i++){  
     char *addr = (char*)(text_addr + i);  
     *addr = ~(*addr);  
   }  
   
   if(mprotect((void *) base, 4096 * nsize, PROT_READ | PROT_EXEC) != 0){  
       __android_log_print(ANDROID_LOG_INFO, "JNITag", "mem privilege change failed");  
   }  
   
   clearcache((char*)text_addr, (char*)(text_addr + nblock -1));  
   
   __android_log_print(ANDROID_LOG_INFO, "JNITag", "Decrypt success");  
 }  
   
 unsigned long getLibAddr(){  
   unsigned long ret = 0;  
   char name[] = "libegg.so";  
   char buf[4096], *temp;  
   int pid;  
   FILE *fp;  
   pid = getpid();  
   sprintf(buf, "/proc/%d/maps", pid);  
   fp = fopen(buf, "r");  
   if(fp == NULL)  
   {  
     puts("open failed");  
     goto _error;  
   }  
   while(fgets(buf, sizeof(buf), fp)){  
     if(strstr(buf, name)){  
       temp = strtok(buf, "-");  
       ret = strtoul(temp, NULL, 16);  
       break;  
     }  
   }  
 _error:  
   fclose(fp);  
   return ret;  
 }  

Number04:然后修改smali层进行调用解密so文件：

然后在AK中重打包，在手机上运行，结果是OK的，但是在模拟器上出问题了，具体的原因还需进一步分析，如果网友有知道的望告知。

四、总结篇

通过这两篇的有无源码的so文件中特定setion还是无源码特定函数的加密，在一定程度上都能够防一些静态分析，但是防不了动态分析，只要加密无论是多么复杂的加密方法，但是就一定在执行的时候以解密后的形式在内存中完整的出现，因此只要在IDA中找到开始和结束的libegg.so的起始地址，dump出来就可以，因此下一步就是反dump和反调试来防止动态分析，以后有机会进一步分析。

最后附件是所有相关的代码和文件如图所示：