自定义Linker与SO加固#

1
soinfo* si = find_library(name);    // 查找并加载SO到内存
2
if (si != NULL) {
3
    si->CallConstructors();          // 调用SO的初始化函数
4
}

1
static soinfo* find_library(const char* name) {
2
  soinfo* si = find_library_internal(name);  // 寻找相应的SO信息
3
  if (si != NULL) {
4
    si->ref_count++;   // 这个计数很重要，用来判断SO是否已经加载过
5
  }
6
  return si;
7
}

1
// 直接看重点
2
if (dynamic != NULL) {
3
    for (Elf32_Dyn* d = dynamic; d->d_tag != DT_NULL; ++d) {
4
      if (d->d_tag == DT_NEEDED) {    // 先调用依赖库的构造函数
5
        const char* library_name = strtab + d->d_un.d_val;
6
        TRACE("\"%s\": calling constructors in DT_NEEDED \"%s\"", name, library_name);
7
        find_loaded_library(library_name)->CallConstructors();
8
      }
9
    }
10
}
11
// DT_INIT要在DT_INIT_ARRAY之前调用
12
TRACE("\"%s\": calling constructors", name);
13
CallFunction("DT_INIT", init_func);           // SO文件加壳的脱壳点！划重点！
14
CallArray("DT_INIT_ARRAY", init_array, init_array_count, false);

1
static soinfo* find_library_internal(const char* name) {
2
  if (name == NULL) {
3
    return somain;
4
  }
5

6
  soinfo* si = find_loaded_library(name);
7
  if (si != NULL) {
8
    if (si->flags & FLAG_LINKED) {
9
      return si;    // 已经加载过了，直接返回
10
    }
11
    DL_ERR("OOPS: recursive link to \"%s\"", si->name);
12
    return NULL;
13
  }
14

15
  TRACE("[ '%s' has not been loaded yet.  Locating...]", name);
16
  si = load_library(name);    // 真正加载SO文件的地方
17
  if (si == NULL) {
18
    return NULL;
19
  }
20

21
  TRACE("[ init_library base=0x%08x sz=0x%08x name='%s' ]",
22
        si->base, si->size, si->name);
23

24
  if (!soinfo_link_image(si)) {    // 执行重定位（会用mmap，所以在/proc/pid/maps能看到）
25
    munmap(reinterpret_cast<void*>(si->base), si->size);
26
    soinfo_free(si);
27
    return NULL;
28
  }
29

30
  return si;
31
}

1
static soinfo* load_library(const char* name) {
2
    // 打开文件
3
    int fd = open_library(name);
4
    if (fd == -1) {
5
        DL_ERR("library \"%s\" not found", name);
6
        return NULL;
7
    }
8

9
    // 读取ELF头并加载段
10
    ElfReader elf_reader(name, fd);
11
    if (!elf_reader.Load()) {    // 注意：这里只读Program段！
12
        return NULL;
13
    }
14

15
    const char* bname = strrchr(name, '/');
16
    // 为SO分配soinfo结构
17
    soinfo* si = soinfo_alloc(bname ? bname + 1 : name);
18
    if (si == NULL) {
19
        return NULL;
20
    }
21

22
    // 初始化soinfo对象
23
    si->base = elf_reader.load_start();
24
    si->size = elf_reader.load_size();
25
    si->load_bias = elf_reader.load_bias();
26
    si->flags = 0;
27
    si->entry = 0;
28
    si->dynamic = NULL;
29
    si->phnum = elf_reader.phdr_count();
30
    si->phdr = elf_reader.loaded_phdr();
31
    return si;
32
}

1
bool ElfReader::Load() {
2
  return ReadElfHeader() &&          // 读ELF头
3
         VerifyElfHeader() &&        // 校验ELF头
4
         ReadProgramHeader() &&      // 读程序头
5
         ReserveAddressSpace() &&    // 分配内存空间
6
         LoadSegments() &&           // 加载段（脱壳的好地方）
7
         FindPhdr();                 // 设置加载地址
8
}

1
public static String getExtractedImagePath(Context context) {
2
    File tempDir = new File(context.getCacheDir(), "yuuki_temp");
3
    if (!tempDir.exists()) {
4
        tempDir.mkdirs();
5
    }
6
    return new File(tempDir, "temp_image.webp").getAbsolutePath();
7
}
8

9
public static boolean extractImageFromApk(Context context, String outputPath) {
10
    String apkPath = context.getApplicationInfo().sourceDir;
11

12
    try (ZipInputStream zip = new ZipInputStream(new FileInputStream(apkPath))) {
13
        ZipEntry entry;
14
        while ((entry = zip.getNextEntry()) != null) {
15
            if (entry.getName().equals("res/mipmap-xxxhdpi-v4/ic_launcher.webp")) {
16
                File outFile = new File(outputPath);
17
                File parent = outFile.getParentFile();
18
                if (!parent.exists()) {
19
                    parent.mkdirs();
20
                }
21

22
                try (FileOutputStream out = new FileOutputStream(outFile)) {
23
                    byte[] buffer = new byte[1024];
24
                    int len;
25
                    while ((len = zip.read(buffer)) > 0) {
26
                        out.write(buffer, 0, len);
27
                    }
28
                    return true;
29
                }
30
            }
31
            zip.closeEntry();
32
        }
33
    } catch (IOException e) {
34
        e.printStackTrace();
35
    }
36

37
    return false;
38
}

1
bool ElfReader::HandleFileType() {
2
    // 检查文件是否包含隐藏的SO
3
    if (CryptoUtils::HasHiddenSO(mapped_file_, file_size_)) {
4
        LOGI("检测到隐藏的SO文件，开始提取并解密...");
5

6
        void* decrypted_data = nullptr;
7
        size_t decrypted_size = 0;
8

9
        if (!CryptoUtils::ExtractAndDecryptHiddenSO(mapped_file_, file_size_,
10
                                                    &decrypted_data, &decrypted_size)) {
11
            LOGE("提取和解密隐藏的SO失败");
12
            return false;
13
        }
14

15
        // 替换映射数据为解密后的数据
16
        decrypted_buffer_ = decrypted_data;
17
        is_decrypted_ = true;
18

19
        // 释放原始映射，使用解密缓冲区
20
        munmap(mapped_file_, file_size_);
21
        mapped_file_ = decrypted_buffer_;
22
        file_size_ = decrypted_size;
23

24
        LOGI("隐藏SO提取和解密成功，大小: %zu", decrypted_size);
25
    }
26

27
    return true;
28
}