本文以乐固2.8.1（后面还有2.10.3.1）为例，介绍乐固壳的分析和脱壳过程。

一、绕过反调试
首先，使用ida加载libshella-2.8.1.so后，出现以下section错误提示，点“OK”后仍然可以加载成功：

这说明“乐固”在section做了一些手脚。要解决这个问题，我们需要明白关于section和segment的一些不同：
1. ELF中的section主要提供给Linker使用， 而segment提供给Loader用，Linker需要关心.text, .rel，.text, .data, .rodata等等，关键是Linker需要做relocation。而Loader只需要知道Read/Write/Execute的属性。
2.一个executable的ELF文件可以没有section，但必须有segment。ELF文件中间部分是共用的（也就是代码段、数据段等）
由第2点可知，既然ELF可以没有section，我们就将section_header_table的数据全部清0，然后再用ida打开，发现没有这个错误提示了。
在修复的libshella-2.8.1.so的Exports表中找到JNI_OnLoad函数，发现该函数是加密的：

我们知道so 文件加载时首先会查看 .init 或 .init_array 段是否存在，如果存在那么就先运行这段的内容，如果不存在的话那么就检查是否存在JNI_OnLoad，存在则执行。所以JNI_OnLoad的解密就应该是在 .init 或 .init_array 段中。
因为 .init 或者 .init_array 在 IDA 动态调试的时候是不会显示出来的，所以需要静态分析出这两段的偏移量然后动态调试的时候计算出绝对位置，然后在 make code（快捷键：c），这样才可以看到该段内的代码内容。
那么，如何定位到执行so文件的init或init_array函数呢？
方法1：
1）从手机或虚拟机中pull出来linker
2）搜索字符串“[ Calling %s @ %p for ‘%s’ ]”,见下图：

3)查找引用此字符串的地址：

4)到sub_271C处，见下图 ：

方法2：使用 IDA 加载 .so 文件，按ctrl+s快捷键查看 “Segments” 视图，这里会列出不同类型的代码段信息，如下图所示。

方法3：readelf -a查看init_array的偏移地址：

我尝试了前两种方法都没成功，不知为什么。使用第三种方法，如上图，得到init_array地址：0x9e20。通过ida定位到该地址，发现调用了两个函数tencent1115357682105733551029和sub_14D4

第一个函数tencent1115357682105733551029为空函数，可以直接忽略：

主要看第二个函数
int sub_B6F084D4()
{
unsigned int v0; // ST44_4
unsigned int v1; // ST40_4
unsigned __int64 v2; // kr00_8
char v3; // ST27_1
int j; // [sp+14h] [bp-44h]
int v6; // [sp+18h] [bp-40h]
int v7; // [sp+1Ch] [bp-3Ch]
char v8; // [sp+2Eh] [bp-2Ah]
char v9; // [sp+2Fh] [bp-29h]
char v10; // [sp+30h] [bp-28h]
char v11; // [sp+33h] [bp-25h]
unsigned int v12; // [sp+34h] [bp-24h]
_DWORD *v13; // [sp+38h] [bp-20h]
unsigned int v14; // [sp+48h] [bp-10h]
unsigned int i; // [sp+4Ch] [bp-Ch]

for ( i = (unsigned int)sub_B6F084D4 & 0xFFFFF000; *(_DWORD *)i != 1179403647; i -= 4096 )
;
v14 = 0;
v13 = (_DWORD *)(i + *(_DWORD *)(i + 28));
v12 = 0;
while ( v12 < *(unsigned __int16 *)(i + 44) )
{
if ( *v13 != 1 || v13[6] != 5 )
{
if ( *v13 == 1 && v13[6] == 6 )
{
v0 = v13[2] & 0xFFFFF000;
v1 = (v13[2] + v13[4] + 4095) & 0xFFFFF000;
break;
}
}
else
{
v14 = (v13[2] + v13[4] + 4095) & 0xFFFFF000;
}
++v12;
v13 += 8;
}
v11 = 43;
v10 = -103;
v9 = 32;
v8 = 21;
v2 = (unsigned __int64)word_B6F11010[0] << 16;
v7 = LOWORD(word_B6F11010[0]);
v6 = LOWORD(word_B6F11010[0]) – (word_B6F11010[0] >> 16);
mprotect_0(i + HIDWORD(v2), (v6 + 4095) & 0xFFFFF000, 3);
for ( j = HIDWORD(v2); j <= v7; ++j )
{
v3 = *(_BYTE *)(i + j);
*(_BYTE *)(i + j) ^= (unsigned __int8)((j ^ (v10 – v9)) + v8) ^ v11;
*(_BYTE *)(i + j) += v10 ^ v9 & v8;
v11 += v3 & (v10 + v9 – v8) & j;
v10 += v3 ^ (v11 + j);
v9 ^= (unsigned __int8)(v3 – v11) ^ (unsigned __int8)j;
v8 -= v3 + v11 – j;
}
mprotect_0(i + HIDWORD(v2), (v6 + 4095) & 0xFFFFF000, 5);
sub_B6F083DC(i + HIDWORD(v2), v6);
word_B6F11010[0] = i;
dword_B6F11380 = i;
unk_B6F11384 = v14;
return sub_B6F0F630();
}
我们看到这个函数主要进行了一些字节变换，然后调用了mprotect，sub_B6F083DC和sub_B6F0F630三个函数。sub_B6F083DC函数就是做了 cacheflush和syscall操作，不管它。

我们来看看sub_B6F0F630函数，发现该函数调用pthread_create创建了一个线程，第三个参数是线程运行函数的起始地址。

通过ida定位这个地址，查看pthread_create创建的线程调用的函数如下：
int __fastcall sub_B6F0EBD0(int a1)
{
int v2; // r0
int v3; // r0
char *v4; // r3
int *v5; // r1
int *v6; // r3
int v7; // r2
unsigned int v8; // r0
char *v9; // r3
char v10; // [sp-10h] [bp-490h]
char v11; // [sp-Fh] [bp-48Fh]
char v12; // [sp-Eh] [bp-48Eh]
char v13; // [sp-Dh] [bp-48Dh]
char v14; // [sp-Ch] [bp-48Ch]
char v15; // [sp-Bh] [bp-48Bh]
char v16; // [sp-Ah] [bp-48Ah]
char v17; // [sp-9h] [bp-489h]
char v18; // [sp-8h] [bp-488h]
char v19; // [sp-7h] [bp-487h]
char v20; // [sp-6h] [bp-486h]
char v21; // [sp-5h] [bp-485h]
char v22; // [sp-4h] [bp-484h]
char v23; // [sp-3h] [bp-483h]
char v24; // [sp-2h] [bp-482h]
int v25; // [sp+0h] [bp-480h]
int v26; // [sp+4h] [bp-47Ch]
int v27; // [sp+8h] [bp-478h]
int v28; // [sp+Ch] [bp-474h]
int v29; // [sp+10h] [bp-470h]
int v30; // [sp+14h] [bp-46Ch]
int v31; // [sp+18h] [bp-468h]
int v32; // [sp+1Ch] [bp-464h]
int v33; // [sp+20h] [bp-460h]
int v34; // [sp+24h] [bp-45Ch]
int v35; // [sp+28h] [bp-458h]
int v36; // [sp+2Ch] [bp-454h]
int v37; // [sp+30h] [bp-450h]
int v38; // [sp+34h] [bp-44Ch]
int v39; // [sp+38h] [bp-448h]
int v40; // [sp+3Ch] [bp-444h]
void *v41; // [sp+40h] [bp-440h]
char *v42; // [sp+44h] [bp-43Ch]
void *v43; // [sp+48h] [bp-438h]
char v44; // [sp+4Ch] [bp-434h]
char v45; // [sp+4Dh] [bp-433h]
char v46; // [sp+4Eh] [bp-432h]
char v47; // [sp+4Fh] [bp-431h]
char v48; // [sp+50h] [bp-430h]
char v49; // [sp+51h] [bp-42Fh]
char v50; // [sp+52h] [bp-42Eh]
char v51; // [sp+53h] [bp-42Dh]
char v52; // [sp+54h] [bp-42Ch]
char v53; // [sp+55h] [bp-42Bh]
char v54; // [sp+56h] [bp-42Ah]
char v55; // [sp+57h] [bp-429h]
char v56; // [sp+58h] [bp-428h]
char v57; // [sp+59h] [bp-427h]
char v58; // [sp+5Ah] [bp-426h]
char v59; // [sp+5Bh] [bp-425h]
int watch_fd; // [sp+5Ch] [bp-424h]
char v61; // [sp+60h] [bp-420h]
int v62; // [sp+460h] [bp-20h]
int v63; // [sp+464h] [bp-1Ch]
int v64; // [sp+468h] [bp-18h]
int v65; // [sp+46Ch] [bp-14h]

v65 = a1;
++dword_B6F11378;
v43 = &loc_B6F10F44;
v42 = &v44;
v41 = &loc_B6F10F44;
unk_B6F11388 = sub_B6F08218(1024); // malloc
v40 = sub_B6F0DDEC();
unk_B6F1138C = sub_B6F0DEE0(0, v65, unk_B6F11384);
v64 = getppid_0();
v50 = unk_B6F112B7 ^ 0x96;
v49 = unk_B6F112B6 ^ 0xF7;
v58 = unk_B6F112BF ^ 0xE1;
v51 = unk_B6F112B8 ^ 0x9E;
v46 = unk_B6F112B3 ^ 0x85;
v53 = unk_B6F112BA ^ 0x98;
v59 = unk_B6F112C0;
v44 = unk_B6F112B1 ^ 0xE9;
v47 = unk_B6F112B4 ^ 0x95;
v56 = unk_B6F112BD ^ 0xCA;
v54 = unk_B6F112BB ^ 0xEE;
v48 = unk_B6F112B5 ^ 0xEA;
v45 = unk_B6F112B2 ^ 0x97;
v57 = unk_B6F112BE ^ 0xD3;
v55 = unk_B6F112BC ^ 0xA5;
v52 = unk_B6F112B9 ^ 0xFB;
v63 = sub_B6F082D8((int)&v44); // opendir
if ( v63 )
{
v39 = 4095;
watch_fd = init();
v38 = watch_fd;
sub_B6F08338(); // fcntl
v2 = sub_B6F08338();
v22 = byte_B6F112CD ^ 0x8D;
v10 = unk_B6F112C1 ^ 0x91;
v19 = byte_B6F112CA ^ 0xC5;
v21 = byte_B6F112CC ^ 0x80;
v13 = byte_B6F112C4 ^ 0xD3;
v15 = byte_B6F112C6 ^ 0xE1;
v17 = byte_B6F112C8 ^ 0xCA;
v18 = byte_B6F112C9 ^ 0xE1;
v24 = byte_B6F112CF;
v23 = byte_B6F112CE ^ 0xC8;
v11 = byte_B6F112C2 ^ 0x87;
v12 = byte_B6F112C3 ^ 0x96;
v20 = byte_B6F112CB ^ 0xDA;
v14 = byte_B6F112C5 ^ 0xD7;
v16 = byte_B6F112C7 ^ 0xE2;
v37 = v2;
v36 = add_watch(watch_fd, &v10, 4095);
while ( 1 )
{
v62 = sub_B6F082E4(v63); // readdir
if ( !v62 )
break;
if ( *(_BYTE *)(v62 + 18) & 4 && &word_2E != (__int16 *)*(unsigned __int8 *)(v62 + 19) )
{
*(&v10 – 11) = byte_B6F112DD ^ 0x8D;
*(&v10 – 22) = byte_B6F112D2 ^ 0x9E;
*(&v10 – 12) = byte_B6F112DC ^ 0xAD;
*(&v10 – 5) = byte_B6F112E3 ^ 0x86;
*(&v10 – 14) = byte_B6F112DA ^ 0xE1;
*(&v10 – 8) = byte_B6F112E0 ^ 0xB1;
*(&v10 – 10) = byte_B6F112DE ^ 0xCF;
*(&v10 – 15) = byte_B6F112D9 ^ 0xB1;
*(&v10 – 24) = unk_B6F112D0 ^ 0xA7;
*(&v10 – 13) = byte_B6F112DB ^ 0xE0;
*(&v10 – 7) = byte_B6F112E1 ^ 0xA2;
*(&v10 – 3) = byte_B6F112E5 ^ 0xAB;
*(&v10 – 17) = byte_B6F112D7 ^ 0x8B;
*(&v10 – 2) = byte_B6F112E6;
*(&v10 – 23) = byte_B6F112D1 ^ 0xBD;
*(&v10 – 19) = byte_B6F112D5 ^ 0xCC;
*(&v10 – 9) = byte_B6F112DF ^ 0xA7;
*(&v10 – 6) = byte_B6F112E2 ^ 0xE6;
*(&v10 – 16) = byte_B6F112D8 ^ 0xA0;
*(&v10 – 18) = byte_B6F112D6 ^ 0x83;
*(&v10 – 21) = byte_B6F112D3 ^ 0x98;
*(&v10 – 20) = byte_B6F112D4 ^ 0xD2;
*(&v10 – 4) = byte_B6F112E4 ^ 0xC2;
v35 = sub_B6F082F0(); // sprintf
v34 = add_watch(watch_fd, &v61, 4095);
}
}
v33 = sub_B6F08314(v63); // closedir
while ( 1 )
{
*(&v10 – 12) = byte_B6F112FC ^ 0x8D;
*(&v10 – 7) = byte_B6F11301;
*(&v10 – 10) = byte_B6F112FE ^ 0xD9;
*(&v10 – 14) = byte_B6F112FA ^ 0xD2;
*(&v10 – 17) = byte_B6F112F7 ^ 0xD5;
*(&v10 – 19) = byte_B6F112F5 ^ 0x81;
*(&v10 – 22) = byte_B6F112F2 ^ 0xB8;
*(&v10 – 13) = byte_B6F112FB ^ 0xC7;
*(&v10 – 15) = byte_B6F112F9 ^ 0xB2;
*(&v10 – 18) = byte_B6F112F6 ^ 0x81;
*(&v10 – 24) = unk_B6F112F0 ^ 0x9C;
*(&v10 – 9) = byte_B6F112FF ^ 0x95;
*(&v10 – 20) = byte_B6F112F4 ^ 0x82;
*(&v10 – 23) = byte_B6F112F1 ^ 0x81;
*(&v10 – 16) = byte_B6F112F8 ^ 0x88;
*(&v10 – 8) = byte_B6F11300 ^ 0xC;
*(&v10 – 11) = byte_B6F112FD ^ 0xC8;
*(&v10 – 21) = byte_B6F112F3 ^ 0x8B;
v3 = sub_B6F0DFA0((int)(&v10 – 24));
if ( v3 != v64 )
{
*(&v10 – 16) = byte_B6F112F8 ^ 0x88;
*(&v10 – 11) = byte_B6F112FD ^ 0xC8;
*(&v10 – 24) = unk_B6F112F0 ^ 0x9C;
*(&v10 – 9) = byte_B6F112FF ^ 0x95;
*(&v10 – 8) = byte_B6F11300 ^ 0xC;
*(&v10 – 10) = byte_B6F112FE ^ 0xD9;
*(&v10 – 20) = byte_B6F112F4 ^ 0x82;
*(&v10 – 18) = byte_B6F112F6 ^ 0x81;
*(&v10 – 7) = byte_B6F11301;
*(&v10 – 23) = byte_B6F112F1 ^ 0x81;
*(&v10 – 19) = byte_B6F112F5 ^ 0x81;
*(&v10 – 14) = byte_B6F112FA ^ 0xD2;
*(&v10 – 21) = byte_B6F112F3 ^ 0x8B;
*(&v10 – 12) = byte_B6F112FC ^ 0x8D;
*(&v10 – 13) = byte_B6F112FB ^ 0xC7;
*(&v10 – 22) = byte_B6F112F2 ^ 0xB8;
*(&v10 – 15) = byte_B6F112F9 ^ 0xB2;
*(&v10 – 17) = byte_B6F112F7 ^ 0xD5;
if ( sub_B6F0DFA0((int)(&v10 – 24)) )
{
*(&v10 – 6) = byte_B6F11304 ^ 0xAF;
*(&v10 – 8) = unk_B6F11302 ^ 0x8B;
*(&v10 – 5) = byte_B6F11305 ^ 0xF3;
*(&v10 – 7) = byte_B6F11303 ^ 0xCB;
*(&v10 – 4) = byte_B6F11306;
*(&v10 – 13) = byte_B6F1130A ^ 0xA7;
*(&v10 – 5) = byte_B6F11312 ^ 0xDF;
*(&v10 – 9) = byte_B6F1130E ^ 0xB5;
*(&v10 – 14) = byte_B6F11309 ^ 0xAC;
*(&v10 – 4) = byte_B6F11313 ^ 0x80;
*(&v10 – 8) = byte_B6F1130F ^ 0xFD;
*(&v10 – 12) = byte_B6F1130B ^ 0xC4;
*(&v10 – 7) = byte_B6F11310 ^ 0xE7;
*(&v10 – 15) = byte_B6F11308 ^ 0xC5;
*(&v10 – 16) = unk_B6F11307 ^ 0xA9;
*(&v10 – 3) = byte_B6F11314;
*(&v10 – 6) = byte_B6F11311 ^ 0x9E;
*(&v10 – 10) = byte_B6F1130D ^ 0x93;
*(&v10 – 11) = byte_B6F1130C ^ 0xE3;
v32 = sub_B6F081C4(6, (int)(&v10 – 8), (int)(&v10 – 16));// _android_log_print
v31 = sub_B6F0826C(9); // raise
}
}
if ( read_0(watch_fd, &v61, &dword_354[43]) > 0 )
{
*(&v10 – 5) = byte_B6F11305 ^ 0xF3;
*(&v10 – 4) = byte_B6F11306;
*(&v10 – 6) = byte_B6F11304 ^ 0xAF;
*(&v10 – 8) = unk_B6F11302 ^ 0x8B;
*(&v10 – 7) = byte_B6F11303 ^ 0xCB;
v4 = &v10 – 16;
*v4 = unk_B6F11315 ^ 0xB2;
*(&v10 – 14) = byte_B6F11317 ^ 0xA6;
*(&v10 – 11) = byte_B6F1131A ^ 0xBF;
*(&v10 – 13) = byte_B6F11318 ^ 0xBA;
*(&v10 – 15) = byte_B6F11316 ^ 0xAF;
*(&v10 – 10) = byte_B6F1131B ^ 0x92;
*(&v10 – 7) = byte_B6F1131E ^ 0xE7;
*(&v10 – 9) = byte_B6F1131C ^ 0x9E;
*(&v10 – 8) = byte_B6F1131D ^ 0xB3;
*(&v10 – 12) = byte_B6F11319 ^ 0xDD;
v4[10] = byte_B6F1131F;
v30 = sub_B6F081C4(6, (int)(&v10 – 8), (int)(&v10 – 16));// _android_log_print
v29 = sub_B6F0826C(9); // raise
}
v5 = (int *)((char *)dword_440 + (_DWORD)v43);
v6 = (int *)((char *)&dword_440[2] + (_DWORD)v43);
++*(int *)((char *)&dword_354[56] + (_DWORD)v43);
v7 = *v5;
v28 = *v6;
v8 = sub_B6F0DEE0(0, v65, v7);
if ( v28 != v8 )
{
*(&v10 – 5) = byte_B6F11305 ^ 0xF3;
*(&v10 – 4) = byte_B6F11306;
*(&v10 – 7) = byte_B6F11303 ^ 0xCB;
*(&v10 – 8) = unk_B6F11302 ^ 0x8B;
*(&v10 – 6) = byte_B6F11304 ^ 0xAF;
v9 = &v10 – 8;
*v9 = unk_B6F11320 ^ 0xCD;
*(&v10 – 6) = byte_B6F11322 ^ 0x87;
*(&v10 – 7) = byte_B6F11321 ^ 0xDF;
*(&v10 – 3) = byte_B6F11325 ^ 0xF5;
*(&v10 – 5) = byte_B6F11323 ^ 0xFC;
*(&v10 – 2) = byte_B6F11326;
v9[4] = byte_B6F11324 ^ 0x1A;
v27 = sub_B6F081C4(6, (int)(&v10 – 8), (int)(&v10 – 8));// _android_log_print
v26 = sub_B6F0826C(9); // raise
}
v25 = sub_B6F08350(1); // sleep
}
}
return 0;
}
这个函数在while(1)循环中根据不同条件调用了3个raise() 函数，肯定是跟反调试相关的。不管怎么样，我们把这个创建线程的代码nop掉就可以了。具体方法是，在ida的Hex View窗口，定位到调用该函数的地址处，按F2，将对应十六进制改成“00 00 A0 E1”，再按F2保存就可以了。

二、找到RegisterNatives
过了反调试，接下来就是找Jni_OnLoad函数了。前面我们知道Jni_OnLoad的相对偏移地址为0x9e20，通过 [基地址+偏移地址] 得到绝对地址，ida定位到该地址，按快捷键C将数据转换成代码，下断点，F9运行到这里，就是Jni_OnLoad了，具体代码如下：
int __fastcall sub_763575A8(int a1, int a2)
{
char v2; // r0
int v4; // [sp+0h] [bp-450h]
int (__fastcall *v5)(_DWORD, _DWORD); // [sp+4h] [bp-44Ch]
int v6; // [sp+8h] [bp-448h]
int v7; // [sp+Ch] [bp-444h]
int *v8; // [sp+14h] [bp-43Ch]
int v9; // [sp+18h] [bp-438h]
int v10; // [sp+1Ch] [bp-434h]
int v11; // [sp+20h] [bp-430h]
int v12; // [sp+28h] [bp-428h]
int (__fastcall *mydlsym)(_DWORD, _DWORD); // [sp+2Ch] [bp-424h]
int v14; // [sp+30h] [bp-420h]
int v15; // [sp+34h] [bp-41Ch]
int v16; // [sp+434h] [bp-1Ch]
int v17; // [sp+438h] [bp-18h]

v17 = a1;
v16 = a2;
v12 = 0;
400A2255(&v15, 1024, 0);
while ( sub_763579D4(&v15) )
;
if ( !unk_7635B37C )
v11 = 4007B1F9(9);
while ( 1 )
{
v2 = 0;
if ( unk_7635B378 )
v2 = 1;
if ( !(((unsigned __int8)v2 ^ 1) & 1) )
break;
*((_BYTE *)&v4 – 7) = byte_7635B025 ^ 0xB5;
*((_BYTE *)&v4 – 8) = byte_7635B024 ^ 0x81;
*((_BYTE *)&v4 – 4) = byte_7635B028 ^ 0xEC;
*((_BYTE *)&v4 – 6) = byte_7635B026 ^ 0xD4;
*((_BYTE *)&v4 – 5) = byte_7635B027 ^ 0xF5;
*((_BYTE *)&v4 – 3) = byte_7635B029;
*((_BYTE *)&v4 – 13) = byte_7635B207 ^ 0xBA;
*((_BYTE *)&v4 – 6) = byte_7635B20E;
*((_BYTE *)&v4 – 14) = byte_7635B206 ^ 0x88;
*((_BYTE *)&v4 – 8) = byte_7635B20C ^ 0xD3;
*((_BYTE *)&v4 – 9) = byte_7635B20B ^ 0xC9;
*((_BYTE *)&v4 – 12) = byte_7635B208 ^ 0xF7;
*((_BYTE *)&v4 – 11) = byte_7635B209 ^ 0xED;
*((_BYTE *)&v4 – 16) = byte_7635B204 ^ 0xD1;
*((_BYTE *)&v4 – 10) = byte_7635B20A ^ 0xEB;
*((_BYTE *)&v4 – 15) = byte_7635B205 ^ 0xCE;
*((_BYTE *)&v4 – 7) = byte_7635B20D ^ 0x91;
v10 = log(6);
}
v9 = 6;
v8 = &v15;
v7 = sub_76354568(&v15, dword_7635B020);
v14 = link_dlopen(v8, 0);
*((_BYTE *)&v4 – 6) = unk_7635B219;
*((_BYTE *)&v4 – 14) = unk_7635B211 ^ 0x8B;
*((_BYTE *)&v4 – 7) = unk_7635B218 ^ 0xB0;
*((_BYTE *)&v4 – 8) = unk_7635B217 ^ 0x92;
*((_BYTE *)&v4 – 9) = unk_7635B216 ^ 0xCD;
*((_BYTE *)&v4 – 11) = unk_7635B214 ^ 0x84;
*((_BYTE *)&v4 – 16) = unk_7635B20F ^ 0xC3;
*((_BYTE *)&v4 – 12) = unk_7635B213 ^ 0xA4;
*((_BYTE *)&v4 – 13) = unk_7635B212 ^ 0xB1;
*((_BYTE *)&v4 – 10) = unk_7635B215 ^ 0x9E;
*((_BYTE *)&v4 – 15) = unk_7635B210 ^ 0xDB;
mydlsym = (int (__fastcall *)(_DWORD, _DWORD))link_dlsym();
*((_BYTE *)&v4 – 7) = byte_7635B025 ^ 0xB5;
*((_BYTE *)&v4 – 4) = byte_7635B028 ^ 0xEC;
*((_BYTE *)&v4 – 3) = byte_7635B029;
*((_BYTE *)&v4 – 8) = byte_7635B024 ^ 0x81;
*((_BYTE *)&v4 – 5) = byte_7635B027 ^ 0xF5;
*((_BYTE *)&v4 – 6) = byte_7635B026 ^ 0xD4;
*((_BYTE *)&v4 – 13) = unk_7635B21D ^ 0xAA;
*((_BYTE *)&v4 – 12) = unk_7635B21E ^ 0xBE;
*((_BYTE *)&v4 – 16) = unk_7635B21A ^ 0x84;
*((_BYTE *)&v4 – 15) = unk_7635B21B ^ 0xC9;
*((_BYTE *)&v4 – 6) = unk_7635B224;
*((_BYTE *)&v4 – 7) = unk_7635B223 ^ 0xC7;
*((_BYTE *)&v4 – 14) = unk_7635B21C ^ 0xA9;
*((_BYTE *)&v4 – 11) = unk_7635B21F ^ 0x95;
*((_BYTE *)&v4 – 9) = unk_7635B221 ^ 0x9D;
*((_BYTE *)&v4 – 10) = unk_7635B220 ^ 0xDC;
*((_BYTE *)&v4 – 8) = unk_7635B222 ^ 0xC2;
v6 = log(v9);
if ( !mydlsym )
return 65540;
v5 = mydlsym;
return mydlsym(v17, v16);
}
我们看到这段代码调用了dlopen和dlsym两个函数。dlopen打开一个动态链接库，dlsym根据动态链接库操作句柄(handle)与符号(symbol)，返回符号对应的地址。使用这个函数不但可以获取函数地址，也可以获取变量地址。我们按F7根据这个函数调用，进入到如下代码处：

一个一个地查看各个调用函数，在unk_764F47C4函数中发现了有registerNatives的调用

跟进sub_76389780函数，发现偏移0x35C，这正是registerNatives相对于JNINativeInterface的偏移。在这里下断点，F9运行到这里。

我们知道RegisterNatives的函数原型是：
jint RegisterNatives(jclass clazz, const JNINativeMethod* methods,
jint nMethods)
第二个参数是JNINativeMethod结构体
typedef struct {
const char* name;
const char* signature;
void* fnPtr;
} JNINativeMethod;
在这里，就是v6，指向结构体数组地址：0x76AE2004。结构体的第三个成员是函数指针，指向该函数的地址。
第三个参数表示注册的函数个数，在这里为v4，其值为5，表示注册了5个native函数。如下图所示：

我们通过查看这个地址，得到这5个函数分别为：
0x76ad1839 load(Landroid/content/Context;)
0x76acdd71 runCreate(Landroid/content/Context;)
0x76acd985 changeEnv(Landroid/content/Context;)
0x76aca1a9 reciver(Landroid/content/Intent;)
0c76acd8c5 txEntries(Ldalvik/system/DexFile;)

我们把重点放在native函数load上。它在段debug175中的偏移量为0xC839。此函数用于解密隐藏在classes.dex中的数据，以获取真正DEX文件并加载它。这里要注意一点：函数指针指向的地址为0x76ad1839，则真正的函数代码在 0x76ad1839+1 位置。以下是load函数的C代码。

load函数会判断系统是Art还是dalvik，根据不同的系统进行不同的操作。因为本人的系统是4.4，所以选择sub_767B3CD0函数进行跟踪（检测dalvik和art的方法可以参考https://stackoverflow.com/questions/19830342/how-can-i-detect-the-android-runtime-dalvik-or-art）。
三、dump dex
这个函数比较长，这里只截取关键部分。找到”classes.dex”字符串，在这里下断点，F9运行到这里。代码如下：

要理解这段代码的意思，我们需要掌握以下知识点：
（1）dex header的大小固定为0x70
（2）0x28为odex文件格式中dex_header的相对偏移地址，所以(odexAddr + 0x28)为该odex文件格式中dex header的绝对地址，如图所示：

（3）dex header中的data_size和data_off字段偏移分别为0x68和0x6C，如图所示：

orgDexOffset由sub_764918CA函数得出，其计算方法如下：其中a1为(v18+ 0x28)

所以，*（a1+0x6C）和*（a1+0x68）分别表示data_size和data_off字段的取值。这两个字段的值分别为0x38C14和0x9710：

以下是对上面关键代码的说明：
1. 获取odex文件data@app@com.example.helloworld_1.apk@classes.dex的基址。
2. 通过DEX头中的data_size和data_off字段来获得真实DEX文件的偏移量。data_size为0x38C14，data_off为0x9710。偏移量为(0x38C14+0x9710+0x1000)>>12)<<12 = 0x43000。
3. 将真实的DEX的DEX头数据复制到新分配的内存中。真实DEX文件的起始地址等于odex的基地址加上0x43000和0x28。
4. 解密真实DEX文件的DEX头数据到新分配的内存中。
5. dex真实文件大小为0xA7C14。

搞明白这些后，我们就可以进行脱壳了。待dex头解密完成后，使用脚本将其dump下来，dump的起始地址为odex的基址，结束地址可以从下图找到

dump代码如下：
static main(void)
{
auto fp, begin, end, ptr;
fp = fopen(“d:\\dump.odex”, “wb”);
begin = 0x75F26000;
end = 0x7601A000;
for ( ptr = begin; ptr < end; ptr ++ )
fputc(Byte(ptr), fp);
}
这是dump的odex文件，我们还需要dump下解密后的dex header。dump起始地址为0xBEFB73FC，大小为0x70。
然后用010editor打开odex文件，依次点击菜单“Edit”=>”Select Range”，开始地址填入43028，大小填入0xA7C14，选择这段数据，然后依次点击“File”=>“Save Selection…”保存为dex格式文件。然后再用010editor打开dump的解密后的dex header，依次选择“Edit”=>”Copy As”=>”Copy as Hex Text”复制下这段数据，再打开保存的dex文件，选择dex头部数据，依次点击“Edit”=>”Paste From”=>”Paste from Hex Text”，然后保存。用逆向工具打开该dex就可以看到逆向后的代码了：

上面就是乐固的脱壳过程。下面再说一下乐固2.10.3.1版本，其实，这个版本与改变并不是很多。还是按照以下步骤来进行
（1）绕过反调试
（2）找到RegisterNatives
（3）dump dex
具体的过程我这里就不详细描述了，有几个需要注意的地方说下。
下图Jni_OnLoad的部分代码，红色标记处为dlsym调用，跟进这里就可以了。

这里被加密的数据大小为0xE0，所以不再只是dex header部分，还有部分dex_string_ids数据，如图