android so分析入门

文章最后更新时间为：2023年08月13日 00:45:22

1. 认识NDK开发

NDK（Native Development Kit）是一种开发工具，允许开发人员使用C和C++等本地编程语言来编写Android应用程序的部分或全部代码。

Android应用通常使用Java或Kotlin编写，但有时候需要使用C或C++编写的代码以实现更高效、更复杂的计算或访问底层硬件。NDK提供了这些功能，允许开发人员使用C或C++编写代码，然后将其编译成本地库，以便在Android应用中使用。

在Android平台上，NDK和JNI通常一起使用，以允许Java应用程序调用本地代码或与本地代码进行交互。开发人员可以使用JNI来编写Java代码和本地代码之间的接口，并使用NDK编写本地代码，然后将其编译为本地库。最后，Java应用程序可以使用System.loadLibrary()方法来加载这些本地库，并使用JNI接口与本地代码交互。

下面通过android studio新建一个ndk项目：

然后在MainActivity中加载so文件，并且调用so中定义的stringFromJNI函数：

在so中的函数需要通过jni接口注册到java代码中，有两种注册方式：静态注册和动态注册。

• 静态注册：静态注册比较简单，在so中的函数满足"Java_类名_方法名"的命名要求时，便相当于直接注册为jni函数，但是名字太长
  且每个函数都需要符合这种命名规则，不适用于大型项目，所以一般的app都是采用动态注册的方式
• 动态注册：动态注册是使用了RegisterNatives函数，将so中定义的函数和java中的函数一一对应，动态注册的优点是可以在运行时动态加载本地库并注册本地方法，因此具有更好的灵活性。

下面是动静态注册的案例:

# native-lib.cpp

#include <jni.h>
#include <string>
#include <android/log.h>


// 定义一个名为"Java_类名_方法名"的函数，通过静态注册，在程序启动时自动注册Native方法。
extern "C" JNIEXPORT jstring JNICALL
Java_com_example_ndkdemo_MainActivity_stringFromJNI(
        JNIEnv* env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}


jint func1(JNIEnv *env, jclass clazz, jint a, jint b) {
    return a + b;
}
jint func2(JNIEnv *env, jclass clazz, jint a, jint b) {
    return a - b;
}

/**
 * JNINativeMethod结构体
 * 包含：
 * 1. name: 变量name是Java中函数的名字；
 * 2. signature: 方法签名，用字符串是描述了Java中函数的参数和返回值，比如下面的(II)I对应的就是java中的 int (int a,int b)
 * 3. fnPtr-c: 函数指针，指向native函数。前面都要接 (void *)
 *
 */
static const JNINativeMethod mMethod[]={
        {"add","(II)I", (void *)func1},
        {"del","(II)I", (void *)func2},
};


jint RegisterNatives(JNIEnv *env) {
    jclass clazz = env->FindClass("com/example/ndkdemo/MainActivity");
    if (clazz == NULL) {
        __android_log_print(ANDROID_LOG_INFO, "mmm", "con't find class: com/example/ndkdemo/MainActivity");
        return JNI_ERR;
    }
    int len = sizeof(mMethod) / sizeof(mMethod[0]);

//    RegisterNatives的三个参数:
//    clazz：指定的类，即 native 方法所属的类
//    methods：方法数组，这里需要了解一下 JNINativeMethod 结构体
//    nMethods：方法数组的长度
//    成功则返回 JNI_OK (0)，失败则返回一个负值。
    return env->RegisterNatives(clazz, mMethod,
                                len);
}

// JNI_OnLoad动态注册:动态注册通过RegisterNatives方法把C/C++中的方法映射到Java中的native方法
// 该函数的返回值是一个整数，它表示了JNI版本号，这个版本号是由JNI规范定义的，用于验证JNI库是否与当前VM匹配。
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;

    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
        return JNI_ERR;
    }
    jint result = RegisterNatives(env);
    __android_log_print(ANDROID_LOG_INFO, "mmm", "RegisterNatives result: %d", result);
    if (result < 0) {
        return JNI_ERR;
    }
    return JNI_VERSION_1_6;
}

在动态注册时，java函数和ndk函数的对应关系在JNINativeMethod结构体中定义，比如上面代码中的:

/**
 * JNINativeMethod结构体
 * 包含：
 * 1. name: 变量name是Java中函数的名字；
 * 2. signature: 方法签名，用字符串是描述了Java中函数的参数和返回值，比如下面的(II)I对应的就是java中的 int (int a,int b)
 * 3. fnPtr-c: 函数指针，指向native函数。前面都要接 (void *)
 *
 */
static const JNINativeMethod mMethod[]={
        {"add","(II)I", (void *)func1},
        {"del","(II)I", (void *)func2},
};

add是java函数的名字，(void *)func1是native函数的指针，中间的(II)I是类型，I代表int，所以(II)I表示int (int a, int b)。

在JNI接口中，Java数据类型和本地代码（C/C++）数据类型是需要进行对应的。下面是一些常见的Java数据类型和本地代码数据类型的对应关系：

上面的都是基本类型。如果Java类型是对象，而其对应的C函数名的类型如下，其中signature类型是以"L"开头，以";"结尾，中间是用"/" 隔开的包及类名，如果JAVA对象位于一个嵌入类，则用$作为类名间的分隔符。

2. 认识so文件格式

Android系统使用的.so文件格式是基于标准的可执行和共享库格式ELF（Executable and Linkable Format）。

so文件大体上可分为四部分，一般来说从上往下是ELF Header->Program Header Table->Section Header Table->Section，ELF文件的结构非常灵活，不同的段和节可以根据需要添加或删除，结构图(虫神)如下

主要部分含义为:

• ELF Header：文件头，位于文件起始位置，包含了ELF文件的基本信息，如文件类型、入口点地址、段表和节表在文件中的偏移量等。
• Program Header Table：程序头表是由多个程序头（Program Header）组成的表格，每个程序头都描述了一个段（Segment），包括段的类型、大小、文件偏移量、内存偏移量、内存对齐等信息
• Section Header Table：节区头表，描述了ELF文件中所有节的信息，如节的名称、类型、大小、偏移量等。

• Section: 一般指ELF文件中的数据段或代码段，包含了程序执行所需的数据和代码信息。android的.so文件中常见的节区包括：

  • .text：包含可执行代码，即程序的代码段。
  • .rodata：包含只读数据，如字符串常量等。
  • .data：包含程序的全局和静态变量，即程序的数据段。
  • .bss：包含未初始化的全局和静态变量，即程序的未初始化数据段。
  • .strtab：字符串表，存放字符串数据。
  • .dynstr：包含动态链接时使用的字符串表，类似于.strtab，但只包含需要导出的字符串。
  • .symtab：包含静态链接时使用的符号表。
  • .dynsym：包含动态链接时使用的符号表，类似于.symtab，但只包含需要导出的符号。
  • .dynamic：包含了一些动态链接器需要的信息，例如导出符号表、库依赖关系、重定位表、初始化和终止函数等信息。

查看so信息可以使用readelf工具，常见用法如下：

 -a 显示so文件所有信息
 -h 查看ELF file header
 -l 查看program headers
 -S 查看section-headers
 -e 查看所有头信息，等于-h -l -S
 -s 显示符号表
 -d 显示动态节 

readelf -h libndkdemo.so
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              DYN (Shared object file)
  Machine:                           AArch64
  Version:                           0x1
  Entry point address:               0x1db4c
  Start of program headers:          64 (bytes into file)
  Start of section headers:          293192 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           56 (bytes)
  Number of program headers:         9
  Size of section headers:           64 (bytes)
  Number of section headers:         25
  Section header string table index: 24

每个字段的含义可以参考android frame中的elf.h，也可以参考https://bbs.kanxue.com/thread-272077.htm

3. arm汇编常见指令

arm指令现在可以用chatgpt进行翻译，但是熟能生巧，先记录一下常见的arm汇编常见指令，下列内容摘抄自互联网：

3.1 寄存器

在ARM64架构下，CPU提供了33个寄存器, 其中前31个（0~30）是通用寄存器 (general-purpose integer registers)，最后2个(31,32)是专用寄存器（sp 寄存器和 pc 寄存器)。

前面0~30个通用寄存器的访问方式有2种：

• 当将其作为 32bit 寄存器的时候，使用 W0 ~ W30 来引用它们。（数据保存在寄存器的低32位）
• 当将其作为 64bit 寄存器的时候，使用 X0 ~ X30 来引用它们。

第31个专用寄存器的访问方式有4种:

• 当将其作为 32bit 栈帧指针寄存器（stack pointer) 的时候，使用 WSP 来引用它。
• 当将其作为 62bit 栈帧指针寄存器（stack pointer) 的时候，使用 SP 来引用它。
• 当将其作为 32bit 零寄存器( zero register )的时候，使用 WZR 来引用它。
• 当将其作为 62bit 零寄存器( zero register )的时候，使用 ZR 来引用它。

3.2 寻址方式

3.3 压栈和出栈指令

3.4 跳转指令

3.5 算术运算指令

加减乘除相关指令：

3.6 逻辑运算

与或非相关指令：

4. IDA分析so

解压apk文件，so文件位于lib目录下，arm64-v8a代表64位，armeabi-v7a代表32位，在这两个文件夹下的so的功能是一致的，只不过是为了适配不同的arm运行环境。

以上面写的ndkdemo为例，使用ida反编译libndkdemo.so文件，一般来说，第一步就是直接在导出函数中搜索java关键词或者JNI_OnLoad关键词，然后F5大法直接查看伪代码：

由于没有做混淆和加固，这里的伪C代码还是比较清晰的。这里我的ida版本是7.7，可以直接识别JNIEnv类型，如果ida版本较老，未识别出来，则需要手动导入jni.h，然后点击入参，按y修改参数类型，具体过程可以百度或者参考https://blog.csdn.net/LoopherBear/article/details/88689354

4.1 WPeChatGPT插件的使用

chatgpt出来后，我们可以很方便的使用chatgpt帮我们分析汇编语言或者伪代码的含义。在ida中可以使用https://github.com/WPeace-HcH/WPeChatGPT这个插件。安装步骤如下：

运行如下命令安装所需包。
pip install -r ./requirements.txt

1. 下载github项目，修改脚本WPeChatGPT.py，添加API key到变量 openai.api_key，修改proxy代理地址。
2. 复制脚本文件WPeChatGPT.py及文件夹Auto-WPeGPT_WPeace到IDA的plugins文件夹
3. 安装python依赖，注意这里需要将依赖安装到ida使用的python环境中，我这里的安装命令为D:\bin\IDA_Pro_7.7\python38\python.exe -m pip install anytree openai urllib3==1.25.11
4. 最后重启 IDA 后即可使用。

使用效果如下, 还是很nice的

如果没有key，可以在网页使用，下面是一些prompt

• 对下面的C语言伪代码函数进行分析，分别推测该函数的使用环境、预期目的、详细的函数功能，最后为这个函数取一个新的名字。（用简体中文回答我，并且回答开始前加上'---GPT_START---'字符串结束后加上'---GPT_END---'字符串：
• 分析下面的C语言伪代码并用python3代码进行还原:
• 查找下面这个C语言伪代码函数的漏洞并提出可能的利用方法:

4.2 动态调试

尝试分析下下面的样本：

https://wwtn.lanzout.com/iO4PY1553ibe
密码:hv87

抓取登录包，发现参数如下：

POST /api/v1/auth/login/sms HTTP/1.1
Content-Type: application/json
Connection: close
Charset: UTF-8
User-Agent: Dalvik/2.1.0 (Linux; U; Android 12; Pixel 6 Build/SQ3A.220705.001.B2)
Host: api.xxx.com
Accept-Encoding: gzip
Content-Length: 635

{"app_ver":"100","sign":"a523aed8f3a1ec8f929c4d909664dfd01738e6da","nonce":"914wz91691753188068","tzrd":"P1RlbHWY2DLNB3bdN9HSjrvBDNKFkeKtJT45hctOqsHY1OF1\/ZzMWHNB9St0iAb\/ggfdspsexUSVHyAgWJ\/THVS6HqLhQgBmYJsOR+P0EkZdSpHDfPd1TclNX75mahTuqUya6C3Uf9DwO9\/q5eNmZzEftI4ONEbZMB9tEjTxzkUjJlPw22bY11Zg69q2o5JGdbZDMrUNBqPzHK4usNnOwHul0w2urdt5kV33jlQ40eORK9OkPx1lqzX3iI\/G1SGG3Q6sta0iHQMZIBPptf1vY+RKmQ94rlM93rO4g7UJfPxJOq4GIs4rssn9ouISAnEMCAcUkF7dst4dilql6Cp2KiX7Ig6p3vIbiboRSP3CizLtW6TaBheG2ajUtrb+GQKCMMS5TgNeO\/pnF7VoPj2x8Fqb+7hWR5Yj8faT4FP7C1+U\/Mou09TvRSvXZLYRQrZBAiV+bVVpap\/\/12d0TiE6jykNqhsdswTW\/oF9JmId\/p0=","timestamp":"1691753188"}

尝试分析sign参数和tzrd参数，通过frida hook java算法，得到tzrd参数是在java层AES加密得到，而sign参数是通过native方法生成：

于是通过ida打开libtre，从导出函数找到sign函数：

未正确识别变量，于是按y修改变量名，得到下面这样的结果：

jstring __fastcall Java_com_maihan_tredian_util_TreUtil_sign(JNIEnv *a1, jclass a2, jstring a3)
{
  const char *v5; // r0
  int v6; // r10
  const char *v7; // r4
  size_t v8; // r5
  char *v9; // r5
  JNIEnv v10; // r0
  size_t v11; // r0
  const char *v12; // r4
  size_t v13; // r0
  int v14; // r0
  int v15; // r0
  int i; // r4
  int v17; // r2
  int v19[2]; // [sp+0h] [bp-170h] BYREF
  JNIEnv *v20; // [sp+8h] [bp-168h]
  void *v21; // [sp+Ch] [bp-164h]
  char v22; // [sp+17h] [bp-159h] BYREF
  _DWORD v23[2]; // [sp+18h] [bp-158h] BYREF
  __int16 v24; // [sp+20h] [bp-150h]
  char v25[100]; // [sp+28h] [bp-148h] BYREF
  char v26[20]; // [sp+8Ch] [bp-E4h] BYREF
  int v27[7]; // [sp+A0h] [bp-D0h] BYREF
  __int16 v28; // [sp+BCh] [bp-B4h]
  int v29; // [sp+100h] [bp-70h]
  int v30; // [sp+104h] [bp-6Ch]
  char v31[76]; // [sp+108h] [bp-68h] BYREF

  strcpy(v31, "b2qKgtaW4,9z9D`Fmst?K5JZbLYOY]NP6ssGf2U~;zk9oCNgoytV!}wW7ia+`w9g");
  v5 = (*a1)->GetStringUTFChars(a1, a3, &v22);
  v6 = 0;
  if ( v5 )
  {
    v21 = &_stack_chk_guard;
    v7 = v5;
    v19[0] = (int)a3;
    v8 = strlen(v31);
    v19[1] = (int)v19;
    v9 = (char *)v19 - ((strlen(v7) + v8 + 8) & 0xFFFFFFF8);
    strcpy(v9, v7);
    strcat(v9, v31);
    v10 = *a1;
    v20 = a1;
    v10->ReleaseStringUTFChars(a1, (jstring)v19[0], v7);
    v11 = strlen(v9);
    v12 = (const char *)&v19[-2 * v11];
    j_base64_encode_new(v9, v12, v11);
    v28 = 0;
    v27[0] = 1732584193;
    v27[1] = -271733879;
    v27[2] = -1732584194;
    v27[3] = 271733878;
    v27[4] = -1009589776;
    v27[5] = 0;
    v27[6] = 0;
    v29 = 0;
    v30 = 0;
    memset(v25, 0, sizeof(v25));
    v13 = strlen(v12);
    v14 = j_SHA1Input(v27, v12, v13);
    if ( v14 )
      fprintf((FILE *)((char *)&_sF + 168), "SHA1Input Error %d.\n", v14);
    v15 = j_SHA1Result(v27, v26);
    if ( v15 )
    {
      fprintf((FILE *)((char *)&_sF + 168), "SHA1Result Error %d, could not compute message digest.\n", v15);
    }
    else
    {
      for ( i = 0; i != 20; ++i )
      {
        v17 = (unsigned __int8)v26[i];
        v23[0] = 0;
        v23[1] = 0;
        v24 = 0;
        sprintf((char *)v23, "%02x", v17);
        strncat(v25, (const char *)v23, 5u);
      }
    }
    return (*v20)->NewStringUTF(v20, v25);
  }
  return (jstring)v6;
}

先用chatgpt帮我们分析一下:

看起来就是sha1进行了散列，但是具体输入值是什么，这里尝试通过动态调试so来获取。

1.首先启动android_server

在IDA目录下的dbgsrv，选择跟手机架构一致的server
adb push android_server /data/local/tmp/
adb shell
su
cd /data/local/tmp/
chmod 777 android_server
./android_server

2.转发本地端口

adb forward tcp:23946 tcp:23946

3.以debug模式启动app

首先重打包app，设置debug属性为true
adb shell am start -D -n com.xxx/.activity.WelcomeActivity

4.ida在sign函数开头按f2打上断点

5.按照下列的步骤 attach process

Debugger-->attach debuger选择remote arm android debugger

然后Debugger-->process option写入hostname为127.0.0.1

然后Debugger->attach to process，搜索、选中app进程

6. 点击运行，在手机上点击登录，便会停在下面的断点处：

尝试F8单步调试即可。

首先可以看到函数的输入就是字符串拼接的其他参数：

然后将输入拼接一段字符串常量，再进行base64加密。

然后对base64密文进行标准的sha1加密

4.3 常用快捷键

• n：更改变量的名称
• y: 修改变量的类型
• Tab/F5: 反编译
• shift+f12：打开string窗口
• x：对着某个函数、变量按该快捷键，可以查看它的交叉引用
• f2: 下断点
• F7: 单步进入调试
• F8: 按照顺序一行一行，单步调试
• F9: 直接跳到下一个断点处
• g: 直接跳到某个地址

5. 参考

• https://www.52pojie.cn/thread-1787667-1-1.html
• https://bbs.kanxue.com/thread-272077.htm
• https://zhuanlan.zhihu.com/p/388683540