Android逆向之旅---基於對so中的函數加密技術實現so加固

時間  2019-12-09
標籤 android 逆向 之旅 基於 函數 加密 技術 實現 加固 欄目 Android 简体版
原文   原文鏈接

1、前言

今天咱們繼續來介紹so加固方式，在前面一篇文章中咱們介紹了對so中指定的段(section)進行加密來實現對so加固java

http://blog.csdn.net/jiangwei0910410003/article/details/49962173
android

這篇文章咱們延續以前的這篇文章來介紹一下如何對函數進行加密來實現加固，固然這篇文章和前篇文章有不少相似的地方，這裏就不作太多的解釋了，因此還請閱讀這篇文章以前先去了解前一篇文章。shell


2、技術原理

這篇和以前的那篇文章惟一的不一樣點就是如何找到指定的函數的偏移地址和大小windows

那麼咱們先來了解一下so中函數的表現形式：數組

在so文件中，每一個函數的結構描述是存放在.dynsym段中的。每一個函數的名稱保存在.dynstr段中的，相似於以前說過的每一個section的名稱都保存在.shstrtab段中，因此在前面的文章中咱們找到指定段的時候，就是經過每一個段的sh_name字段到.shstrtab中尋找名字便可，並且咱們知道.shstrtab這個段在頭文件中是有一個index的，就是在全部段列表中的索引值，因此很好定位.shstrtab.安全

可是在這篇文章咱們可能遇到一個問題，就是不能按照這種方式去查找指定函數名了：微信


可能有的人意識到一個方法，就是咱們能夠經過section的type來獲取.dynsym和.dynstr。咱們看到上圖中.dynsym類型是：DYNSYM,數據結構

.dynstr類型是STRTAB,可是這種方法是不行的，由於這個type不是惟一的，也就說不一樣的section，type可能相同，咱們沒辦法區分，好比.shstrtab和.dynstr的type都是STRTAB.其實從這裏咱們就知道這兩個段的區別了：app

.shstrtab值存儲段的名稱，.dynstr是存儲so中的全部符號名稱。ide

那麼咱們該怎麼辦呢？這時候咱們再去看一下elf的說明文檔：

http://download.csdn.net/detail/jiangwei0910410003/9204051

咱們看到有一個.hash段，在上圖中咱們也能夠看到的：

由 Elf32_Word 對象組成的哈希表支持符號表訪問。下面的例子有助於解釋哈希表


組織,不過不是規範的一部分。bucket 數組包含 nbucket 個項目,chain 數組包含 nchain 個項目,下標都是從 0 開始。bucket 和 chain 中都保存符號表索引。Chain 表項和符號表存在對應。符號 表項的數目應該和 nchain 相等,因此符號表的索引也可用來選取 chain 表項。哈希 函數可以接受符號名而且返回一個能夠用來計算 bucket 的索引。
所以,若是哈希函數針對某個名字返回了數值 X,則 bucket[X%nbucket] 給出了 一個索引 y,該索引可用於符號表,也可用於 chain 表。若是符號表項不是所須要的, 那麼 chain[y] 則給出了具備相同哈希值的下一個符號表項。咱們能夠沿着 chain 鏈 一直搜索,直到所選中的符號表項包含了所須要的符號,或者 chain 項中包含值 STN_UNDEF。

上面的描述感受有點複雜，其實說的簡單點就是：

用目標函數名在用hash函數獲得一個hash值，而後再作一些計算就能夠獲得這個函數在.dynsym段中這個函數對應的條目了。關於這個hash函數，是公用的，咱們在Android中的bonic/linker.c源碼中也是能夠找到的：

unsigned long elf_hash (const unsigned char *name) {
unsigned long h = 0, g; while (*name)
{
	h=(h<<4)+*name++; if (g = h & 0xf0000000)
	h^=g>>24; h&=-g;
}
return h; 
}
那麼咱們只要獲得.hash段便可，可是咱們怎麼獲取到這個section中呢？elf中並無對這個段進行數據結構的描述，有人可能想到了咱們在上圖看到.hash段的type是HASH,那麼咱們再經過這個type來獲取？可是以前說了，這個type不是惟一的，經過他來獲取section是不靠譜的？那麼咱們該怎麼辦呢？這時候咱們就要看一下程序頭信息了：


咱們知道程序頭信息是最後so被加載到內存中的映像描述，這裏咱們看到有一個.dynamic段。咱們再看看so文件的裝載視圖和連接視圖：


這個咱們在以前也說過，在so被加載到內存以後，就沒有section了，對應的是segment了，也就是程序頭中描述的結構，並且一個segment能夠包含多個section,相同的section能夠被包含到不一樣的segment中。.dynamic段通常用於動態連接的，因此.dynsym和.dynstr，.hash確定包含在這裏。咱們能夠解析了程序頭信息以後，經過type獲取到.dynamic程序頭信息，而後獲取到這個segment的偏移地址和大小，在進行解析成elf32_dyn結構。下面兩種圖就是程序頭的type類型和dyn結構描述，能夠在elf.h中找到：

/**
 * typedef struct dynamic{
  Elf32_Sword d_tag;
  union{
    Elf32_Sword	d_val;
    Elf32_Addr	d_ptr;
  } d_un;
} Elf32_Dyn;
 */
public static class elf32_dyn{
public byte[] d_tag = new byte[4];
public byte[] d_val = new byte[4];
public byte[] d_ptr = new byte[4];

/*public static class d_un{
public static byte[] d_val = new byte[4];
public static byte[] d_ptr = new byte[4];
}*/

@Override
public String toString(){
return "d_tag:"+Utils.bytes2HexString(d_tag)+";d_un_d_val:"+Utils.bytes2HexString(d_val)+";d_un_d_ptr:"+Utils.bytes2HexString(d_ptr);
}
}
這裏，須要注意的是，C語言中的union聯合體結構，因此咱們在Java解析的時候須要注意，後面會詳細介紹。

這裏的三個字段很好理解：

d_tag：標示，標示這個dyn是什麼類型的，是.dynsym仍是.dynstr等

d_val：這個section的大小

d_ptr：這個section的偏移地址

細心的同窗可能會發現一個問題，就是在這裏尋找.dynamic也是經過類型的，而後再找到對應的section.這種方式和以前說的經過type來尋找section,有兩個不一樣：

第1、在程序頭信息中，type標示.dynamic段是惟一的，因此能夠經過type來進行尋找

第2、咱們看到上面的連接視圖和裝載視圖發現，咱們這種經過程序頭中的信息來查找.dysym等section靠譜點，由於當so被加載到內存中，就不存在了section了，只有segment了。


3、實現方案

編寫native程序，只是native直接返回字符串給UI。須要作的是對Java_com_example_shelldemo2_MainActivity_getString函數進行加密。加密和解密都是基於裝載視圖實現。須要注意的是，被加密函數若是用static聲明，那麼函數是不會出如今.dynsym中，是沒法在裝載視圖中經過函數名找到進行解密的。固然，也能夠採用取巧方式，相似上節，把地址和長度信息寫入so頭中實現。Java_com_example_shelldemo2_MainActivity_getString須要被調用，那麼必定是能在.dynsym找到的。
加密流程：
1)  讀取文件頭，獲取e_phoff、e_phentsize和e_phnum信息
2)  經過Elf32_Phdr中的p_type字段，找到DYNAMIC。從下圖能夠看出，其實DYNAMIC就是.dynamic section。從p_offset和p_filesz字段獲得文件中的起始位置和長度
3)  遍歷.dynamic，找到.dynsym、.dynstr、.hash section文件中的偏移和.dynstr的大小。在個人測試環境下，fedora 14和windows7 Cygwin x64中elf.h定義.hash的d_tag標示是：DT_GNU_HASH;而安卓源碼中的是：DT_HASH。
4)  根據函數名稱，計算hash值
5)  根據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;
  }
}
6)  找到函數對應的Elf32_Sym符號後，便可根據st_value和st_size字段找到函數的位置和大小
7)  後面的步驟就和上節相同了，這裏就不贅述

解密流程爲加密逆過程，大致相同，只有一些細微的區別，具體以下：
1)  找到so文件在內存中的起始地址
2)  也是經過so文件頭找到Phdr；從Phdr找到PT_DYNAMIC後，需取p_vaddr和p_filesz字段，並不是p_offset，這裏須要注意。
3)  後續操做就加密相似，就不贅述。對內存區域數據的解密，也須要注意讀寫權限問題。


上面就介紹了完了，下面咱們就能夠來開始coding了。

4、代碼實現

第1、native程序

#include <jni.h>
#include <android/log.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <elf.h>
#include <sys/mman.h>

#define DEBUG

typedef struct _funcInfo{
  Elf32_Addr st_value;
  Elf32_Word st_size;
}funcInfo;


void init_getString() __attribute__((constructor));

static void print_debug(const char *msg){
#ifdef DEBUG
	__android_log_print(ANDROID_LOG_INFO, "JNITag", "%s", msg);
#endif
}

static unsigned elfhash(const char *_name)
{
    const unsigned char *name = (const unsigned char *) _name;
    unsigned h = 0, g;

    while(*name) {
        h = (h << 4) + *name++;
        g = h & 0xf0000000;
        h ^= g;
        h ^= g >> 24;
    }
    return h;
}

static unsigned int getLibAddr(){
  unsigned int ret = 0;
  char name[] = "libdemo.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;
}

static char getTargetFuncInfo(unsigned long base, const char *funcName, funcInfo *info){
	char flag = -1, *dynstr;
	int i;
	Elf32_Ehdr *ehdr;
	Elf32_Phdr *phdr;
	Elf32_Off dyn_vaddr;
	Elf32_Word dyn_size, dyn_strsz;
	Elf32_Dyn *dyn;
    Elf32_Addr dyn_symtab, dyn_strtab, dyn_hash;
	Elf32_Sym *funSym;
	unsigned funHash, 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 = (unsigned int *)(dyn_hash + 4 * (2 + nbucket));

	flag = -1;
	__android_log_print(ANDROID_LOG_INFO, "JNITag", "hash = 0x%x, nbucket = 0x%x\n", funHash, nbucket);
	int mod = (funHash % nbucket);
	__android_log_print(ANDROID_LOG_INFO, "JNITag", "mod = %d\n", mod);
	__android_log_print(ANDROID_LOG_INFO, "JNITag", "i = 0x%d\n", bucket[mod]);

	for(i = bucket[mod]; 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);
	return 0;
_error:
	return -1;
}

void init_getString(){
	const char target_fun[] = "Java_com_example_shelldemo2_MainActivity_getString";
	funcInfo info;
	int i;
	unsigned int npage, 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);
	__android_log_print(ANDROID_LOG_INFO, "JNITag", "npage =  0x%d", npage);
	__android_log_print(ANDROID_LOG_INFO, "JNITag", "npage =  0x%d", PAGE_SIZE);

	if(mprotect((void *) ((base + info.st_value) / PAGE_SIZE * PAGE_SIZE), 4096*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), 4096*npage, PROT_READ | PROT_EXEC) != 0){
		print_debug("mem privilege change failed");
	}

}

JNIEXPORT jstring JNICALL
Java_com_example_shelldemo2_MainActivity_getString( JNIEnv* env,
                                                  jobject thiz )
{
#if defined(__arm__)
  #if defined(__ARM_ARCH_7A__)
    #if defined(__ARM_NEON__)
      #define ABI "armeabi-v7a/NEON"
    #else
      #define ABI "armeabi-v7a"
    #endif
  #else
   #define ABI "armeabi"
  #endif
#elif defined(__i386__)
   #define ABI "x86"
#elif defined(__mips__)
   #define ABI "mips"
#else
   #define ABI "unknown"
#endif
	return (*env)->NewStringUTF(env, "Native method return!");
}
這裏就不想作太多解釋了，代碼邏輯和以前文章中的加密section中的代碼相似，只有在尋找函數的地方有點不一樣，這個也再也不這裏說明了，在加密的代碼中我在說明一下。


第2、加密程序

一、Java版本加密程序

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;
		}

	}

}
這裏的解密程序，須要說明一下。

1)、定位到.dynamic的segment,解析成elf32_dyn結構信息

//尋找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));
}
這裏有一個解析elf32_dyn結構： 

private static elf32_dyn parseDynamic(byte[] src){
	elf32_dyn dyn = new elf32_dyn();
	dyn.d_tag = Utils.copyBytes(src, 0, 4);
	dyn.d_ptr = Utils.copyBytes(src, 4, 4);
	dyn.d_val = Utils.copyBytes(src, 4, 4);
	return dyn;
}
這裏須要注意的是，elf32_dyn中用到了聯合體union結構，Java中是不存在這個類型的，因此咱們須要瞭解這個聯合體的含義，這裏雖然是三個字段，可是大小是8個字節，而不是12字節，這個須要注意的。dyn.d_val和dyn.d_val是在一個聯合體中的。

2)、計算目標函數的hash值，獲得函數的偏移值和大小

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;
	}

}
這裏的尋找邏輯有點饒人，可是咱們知道了解原理便可：

結合上面的這張圖就能夠理解了。其中nbucket和nchain，bucket[i]和chain[i]都是4個字節。他們的值就是目標函數在.dynsym中的位置。


二、C版加密程序

#include <stdio.h>
#include <fcntl.h>
#include "elf.h"
#include <stdlib.h>
#include <string.h>

typedef struct _funcInfo{
  Elf32_Addr st_value;
  Elf32_Word st_size;
}funcInfo;

Elf32_Ehdr ehdr;

//For Test
static void print_all(char *str, int len){
  int i;
  for(i=0;i<len;i++)
  {
    if(str[i] == 0)
      puts("");
    else
      printf("%c", str[i]);
  }
}

static unsigned elfhash(const char *_name)
{
    const unsigned char *name = (const unsigned char *) _name;
    unsigned h = 0, g;

    while(*name) {
        h = (h << 4) + *name++;
        g = h & 0xf0000000;
        h ^= g;
        h ^= g >> 24;
    }
    return h;
}

static Elf32_Off findTargetSectionAddr(const int fd, const char *secName){
  Elf32_Shdr shdr;
  char *shstr = NULL;
  int i;
  
  lseek(fd, 0, SEEK_SET);
  if(read(fd, &ehdr, sizeof(Elf32_Ehdr)) != sizeof(Elf32_Ehdr)){
    puts("Read ELF header error");
    goto _error;
  }
  
  lseek(fd, ehdr.e_shoff + sizeof(Elf32_Shdr) * ehdr.e_shstrndx, SEEK_SET);
  
  if(read(fd, &shdr, sizeof(Elf32_Shdr)) != sizeof(Elf32_Shdr)){
    puts("Read ELF section string table error");
    goto _error;
  }
  
  if((shstr = (char *) malloc(shdr.sh_size)) == NULL){
    puts("Malloc space for section string table failed");
    goto _error;
  }
  
  lseek(fd, shdr.sh_offset, SEEK_SET);
  if(read(fd, shstr, shdr.sh_size) != shdr.sh_size){
    puts(shstr);
    puts("Read string table failed");
    goto _error;
  }
  
  lseek(fd, ehdr.e_shoff, SEEK_SET);
  for(i = 0; i < ehdr.e_shnum; i++){
    if(read(fd, &shdr, sizeof(Elf32_Shdr)) != sizeof(Elf32_Shdr)){
      puts("Find section .text procedure failed");
      goto _error;
    }
    if(strcmp(shstr + shdr.sh_name, secName) == 0){
      printf("Find section %s, addr = 0x%x\n", secName, shdr.sh_offset);
      break;
    }
  }
  free(shstr);
  return shdr.sh_offset;
_error:
  return -1;
}

static char getTargetFuncInfo(int fd, const char *funcName, funcInfo *info){
  char flag = -1, *dynstr;
  int i;
  Elf32_Sym funSym;
  Elf32_Phdr phdr;
  Elf32_Off dyn_off;
  Elf32_Word dyn_size, dyn_strsz;
  Elf32_Dyn dyn;
  Elf32_Addr dyn_symtab, dyn_strtab, dyn_hash;
  unsigned funHash, nbucket, nchain, funIndex;
  
  lseek(fd, ehdr.e_phoff, SEEK_SET);
  for(i=0;i < ehdr.e_phnum; i++){
    if(read(fd, &phdr, sizeof(Elf32_Phdr)) != sizeof(Elf32_Phdr)){
      puts("Read segment failed");
      goto _error;
    }
    if(phdr.p_type ==  PT_DYNAMIC){
      dyn_size = phdr.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;

  printf("dyn_size:%d\n",dyn_size);
  printf("count:%d\n",(dyn_size/sizeof(Elf32_Dyn)));
  printf("off:%x\n",dyn_off);
  
  lseek(fd, dyn_off, SEEK_SET);
  for(i=0;i < dyn_size / sizeof(Elf32_Dyn); i++){
	int sizes = read(fd, &dyn, sizeof(Elf32_Dyn));
    if(sizes != sizeof(Elf32_Dyn)){
      puts("Read .dynamic information failed");
      //goto _error;
	  break;
    }    
    if(dyn.d_tag == DT_SYMTAB){
      dyn_symtab = dyn.d_un.d_ptr;
      flag += 1;
      printf("Find .dynsym, addr = 0x%x, val = 0x%x\n", dyn_symtab, dyn.d_un.d_val);
    }

    if(dyn.d_tag == DT_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){
      dyn_strtab = dyn.d_un.d_ptr;
      flag += 4;
      printf("Find .dynstr, addr = 0x%x\n", dyn_strtab);
    }
    if(dyn.d_tag == DT_STRSZ){
      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);
  if(read(fd, dynstr, dyn_strsz) != dyn_strsz){
    puts("Read .dynstr failed");
    goto _error;
  }
  
  funHash = elfhash(funcName);
  printf("Function %s hashVal = 0x%x\n", funcName, funHash);
  
  lseek(fd, dyn_hash, SEEK_SET);
  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){
    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;
  }

  printf("funcIndex:%d\n", funIndex);
  
  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){
    while(1){
		printf("hash:%x,nbucket:%d,funIndex:%d\n",dyn_hash,nbucket,funIndex);
		lseek(fd, dyn_hash + 4 * (2 + nbucket + funIndex), SEEK_SET);
		if(read(fd, &funIndex, 4) != 4){
		  puts("Read funIndex failed\n");
		  goto _error;
		}

		printf("funcIndex:%d\n", funIndex);
		
		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;
		}
    }
  }
  
  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);
  return 0;
  
_error:
  free(dynstr);
  return -1;
}

int main(int argc, char **argv){
  char secName[] = ".text";
  char funcName[] = "Java_com_example_shelldemo2_MainActivity_getString";
  char *soName = "libdemo.so";
  char *content = NULL;
  int fd, i;
  Elf32_Off secOff;
  funcInfo info;

  unsigned a = elfhash(funcName);
  printf("a:%d\n", a);
  
  fd = open(soName, O_RDWR);
  if(fd < 0){
    printf("open %s failed\n", argv[1]);
    goto _error;
  }
  
  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-1, 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;
}
這裏就不作介紹了。


上面對so中的函數加密成功了，那麼下面咱們來驗證加密，咱們使用IDA進行查看：


看到咱們加密的函數內容已經面目全非了，看不到信息了。

比較加密前的：


哈哈，加密成功了~~


案例下載地址：http://download.csdn.net/detail/jiangwei0910410003/9289009


第3、測試Android項目

咱們用加密以後的so文件來測試一下：

package com.example.shelldemo;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;

public class MainActivity extends Activity {

	private TextView tv;
	private native String getString();
	
	static{
		System.loadLibrary("demo");
	}
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		tv = (TextView) findViewById(R.id.tv);
		tv.setText(getString());
	}
}
運行結果：


運行成功啦。


5、總結

這篇文章是延續以前的加密section文章繼續講述了加密函數來實現so加固，這個和加密section惟一的區別就是如何找到加密函數的偏移地址和大小，其餘都是相似的，那麼對於so加固的知識點就用這兩篇文章來介紹了，固然這兩種方式都是有缺點的，就是若是咱們在init_getString函數下斷點，而後動態調試一下，就能夠很輕易的破解了，並且經過dump出內存中運行的dex也是能夠作到的，因此，沒有絕對的安全，只有相對的攻防~~

PS: 關注微信，最新Android技術實時推送

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程