Android Linker 與 SO 加殼技術

原創 flyeagle317 2020-02-21 23:14

1. 前言

Android 系統安全愈發重要，像傳統pc安全的可執行文件加固一樣，應用加固是Android系統安全中非常重要的一環。目前Android 應用加固可以分爲dex加固和Native加固，Native 加固的保護對象爲 Native 層的 SO 文件，使用加殼、反調試、混淆、VM 等手段增加SO文件的反編譯難度。目前最主流的 SO 文件保護方案還是加殼技術， 在SO文件加殼和脫殼的攻防技術領域，最重要的基礎的便是對於 Linker 即裝載鏈接機制的理解。對於非安全方向開發者，深刻理解系統的裝載與鏈接機制也是進階的必要條件。

本文詳細分析了 Linker 對 SO 文件的裝載和鏈接過程，最後對 SO 加殼的關鍵技術進行了簡要的介紹。

對於 Linker 的學習，還應該包括 Linker 自舉、可執行文件的加載等技術，但是限於本人的技術水平，本文的討論範圍限定在 SO 文件的加載，也就是在調用dlopen("libxx.SO")之後，Linker 的處理過程。

本文基於 Android 5.0 AOSP 源碼，僅針對 ARM 平臺，爲了增強可讀性，文中列舉的源碼均經過刪減，去除了其他 CPU 架構的相關源碼以及錯誤處理。

P.S. :閱讀本文的讀者需要對 ELF 文件結構有一定的瞭解。

2. SO 的裝載與鏈接

2.1 整體流程說明

1. do_dlopen 
調用 dl_open 後，中間經過 dlopen_ext, 到達第一個主要函數 do_dlopen:

soinfo* do_dlopen(const char* name, int flags, const Android_dlextinfo* extinfo) {
  protect_data(PROT_READ | PROT_WRITE);
  soinfo* si = find_library(name, flags, extinfo); // 查找 SO
  if (si != NULL) {
    si->CallConstructors(); // 調用 SO 的 init 函數
  }
  protect_data(PROT_READ);
  return si;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

do_dlopen 調用了兩個重要的函數，第一個是find_library, 第二個是 soinfo 的成員函數 CallConstructors，find_library 函數是 SO 裝載鏈接的後續函數， 完成 SO 的裝載鏈接後， 通過 CallConstructors 調用 SO 的初始化函數。

2. find_library_internal 
find_library 直接調用了 find_library_internal，下面直接看 find_library_internal函數:

static soinfo* find_library_internal(const char* name, int dlflags, const Android_dlextinfo* extinfo) {
  if (name == NULL) {
    return somain;
  }
  soinfo* si = find_loaded_library_by_name(name);  // 判斷 SO 是否已經加載
  if (si == NULL) {
    TRACE("[ '%s' has not been found by name.  Trying harder...]", name);
    si = load_library(name, dlflags, extinfo);     // 繼續 SO 的加載流程
  }
  if (si != NULL && (si->flags & FLAG_LINKED) == 0) {
    DL_ERR("recursive link to \"%s\"", si->name);
    return NULL;
  }
  return si;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

find_library_internal 首先通過 find_loaded_library_by_name 函數判斷目標 SO 是否已經加載，如果已經加載則直接返回對應的soinfo指針，沒有加載的話則調用 load_library 繼續加載流程，下面看 load_library 函數。

3. load_library

static soinfo* load_library(const char* name, int dlflags, const Android_dlextinfo* extinfo) {
    int fd = -1;
    ...
    // Open the file.
    fd = open_library(name);                // 打開 SO 文件，獲得文件描述符 fd

    ElfReader elf_reader(name, fd);         // 創建 ElfReader 對象
    ...
    // Read the ELF header and load the segments.
    if (!elf_reader.Load(extinfo)) {        // 使用 ElfReader 的 Load 方法，完成 SO 裝載
        return NULL;
    }

    soinfo* si = soinfo_alloc(SEARCH_NAME(name), &file_stat);  // 爲 SO 分配新的 soinfo 結構
    if (si == NULL) {
        return NULL;
    }
    si->base = elf_reader.load_start();  // 根據裝載結果，更新 soinfo 的成員變量
    si->size = elf_reader.load_size();
    si->load_bias = elf_reader.load_bias();
    si->phnum = elf_reader.phdr_count();
    si->phdr = elf_reader.loaded_phdr();
    ...
    if (!soinfo_link_image(si, extinfo)) {  // 調用 soinfo_link_image 完成 SO 的鏈接過程
      soinfo_free(si);
      return NULL;
    }
    return si;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

load_library 函數呈現了 SO 裝載鏈接的整個流程，主要有3步: 
1. 裝載:創建ElfReader對象，通過 ElfReader 對象的 Load 方法將 SO 文件裝載到內存 
2. 分配soinfo:調用 soinfo_alloc 函數爲 SO 分配新的 soinfo 結構，並按照裝載結果更新相應的成員變量 
3. 鏈接: 調用 soinfo_link_image 完成 SO 的鏈接

通過前面的分析，可以看到， load_library 函數中包含了 SO 裝載鏈接的主要過程, 後文主要通過分析 ElfReader 類和 soinfo_link_image 函數, 來分別介紹 SO 的裝載和鏈接過程。

2.2 裝載

在 load_library 中， 首先初始化 elf_reader 對象, 第一個參數爲 SO 的名字， 第二個參數爲文件描述符 fd: 
ElfReader elf_reader(name, fd) 
之後調用 ElfReader 的 load 方法裝載 SO。

    ...
    // Read the ELF header and load the segments.
    if (!elf_reader.Load(extinfo)) {
        return NULL;
    }
    ...
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

ElfReader::Load 方法如下:

bool ElfReader::Load(const Android_dlextinfo* extinfo) {
  return ReadElfHeader() &&             // 讀取 elf header
         VerifyElfHeader() &&           // 驗證 elf header
         ReadProgramHeader() &&         // 讀取 program header
         ReserveAddressSpace(extinfo) &&// 分配空間
         LoadSegments() &&              // 按照 program header 指示裝載 segments
         FindPhdr();                    // 找到裝載後的 phdr 地址
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

ElfReader::Load 方法首先讀取 SO 的elf header，再對elf header進行驗證，之後讀取program header，根據program header 計算 SO 需要的內存大小並分配相應的空間，緊接着將 SO 按照以 segment 爲單位裝載到內存，最後在裝載到內存的 SO 中找到program header，方便之後的鏈接過程使用。 
下面深入 ElfReader 的這幾個成員函數進行詳細介紹。

2.2.1 read&verify elfheader

bool ElfReader::ReadElfHeader() {
  ssize_t rc = read(fd_, &header_, sizeof(header_));

  if (rc != sizeof(header_)) {
    return false;
  }
  return true;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

ReadElfHeader 使用 read 直接從 SO 文件中將 elf_header 讀取 header_ 中，header_ 爲 ElfReader 的成員變量，類型爲 Elf32_Ehdr，通過 header 可以方便的訪問 elf header中各個字段，elf header中包含有 program header table、section header table等重要信息。 
對 elf header 的驗證包括: 
- magic字節 
- 32/64 bit 與當前平臺是否一致 
- 大小端 
- 類型:可執行文件、SO … 
- 版本:一般爲 1，表示當前版本 
- 平臺:ARM、x86、amd64 …

有任何錯誤都會導致加載失敗。

2.2.2 Read ProgramHeader

bool ElfReader::ReadProgramHeader() {
  phdr_num_ = header_.e_phnum;      // program header 數量

  // mmap 要求頁對齊
  ElfW(Addr) page_min = PAGE_START(header_.e_phoff);
  ElfW(Addr) page_max = PAGE_END(header_.e_phoff + (phdr_num_ * sizeof(ElfW(Phdr))));
  ElfW(Addr) page_offset = PAGE_OFFSET(header_.e_phoff);

  phdr_size_ = page_max - page_min;
  // 使用 mmap 將 program header 映射到內存
  void* mmap_result = mmap(NULL, phdr_size_, PROT_READ, MAP_PRIVATE, fd_, page_min);

  phdr_mmap_ = mmap_result;
  // ElfReader 的成員變量 phdr_table_ 指向program header table
  phdr_table_ = reinterpret_cast<ElfW(Phdr)*>(reinterpret_cast<char*>(mmap_result) + page_offset);
  return true;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

將 program header 在內存中單獨映射一份，用於解析program header 時臨時使用，在 SO 裝載到內存後，便會釋放這塊內存，轉而使用裝載後的 SO 中的program header。

2.2.3 reserve space & 計算 load size

bool ElfReader::ReserveAddressSpace(const Android_dlextinfo* extinfo) {
  ElfW(Addr) min_vaddr;
  // 計算 加載SO 需要的空間大小
  load_size_ = phdr_table_get_load_size(phdr_table_, phdr_num_, &min_vaddr);
  // min_vaddr 一般情況爲零，如果不是則表明 SO 指定了加載基址
  uint8_t* addr = reinterpret_cast<uint8_t*>(min_vaddr);
  void* start;

  int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS;
  start = mmap(addr, load_size_, PROT_NONE, mmap_flags, -1, 0);

  load_start_ = start;
  load_bias_ = reinterpret_cast<uint8_t*>(start) - addr;
  return true;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

首先調用 phdr_table_get_load_size 函數獲取 SO 在內存中需要的空間load_size，然後使用 mmap 匿名映射，預留出相應的空間。

關於load_bias_: SO 可以指定加載基址，但是 SO 指定的加載基址可能不是頁對齊的，這種情況會導致實際映射地址和指定的加載地址有一個偏差，這個偏差便是 load_bias_，之後在針對虛擬地址進行計算時需要使用 load_bias_ 修正。普通的 SO 都不會指定加載基址，這時min_vaddr = 0，則 load_bias_ = load_start_，即load_bias_ 等於加載基址，下文會將 load_bias_ 直接稱爲基址。

下面深入phdr_table_get_load_size分析一下 load_size 的計算:使用成員變量 phdr_table 遍歷所有的program header， 找到所有類型爲 PT_LOAD 的 segment 的 p_vaddr 的最小值，p_vaddr + p_memsz 的最大值，分別作爲 min_vaddr 和 max_vaddr，在將兩個值分別對齊到頁首和頁尾，最終使用對齊後的 max_vaddr - min_vaddr 得到 load_size。

size_t phdr_table_get_load_size(const ElfW(Phdr)* phdr_table, size_t phdr_count,
                                ElfW(Addr)* out_min_vaddr,
                                ElfW(Addr)* out_max_vaddr) {
  ElfW(Addr) min_vaddr = UINTPTR_MAX;
  ElfW(Addr) max_vaddr = 0;
  bool found_pt_load = false;
  for (size_t i = 0; i < phdr_count; ++i) {  // 遍歷 program header
    const ElfW(Phdr)* phdr = &phdr_table[i];
    if (phdr->p_type != PT_LOAD) {
      continue;
    }
    found_pt_load = true;
    if (phdr->p_vaddr < min_vaddr) {
      min_vaddr = phdr->p_vaddr;         // 記錄最小的虛擬地址
    }
    if (phdr->p_vaddr + phdr->p_memsz > max_vaddr) {
      max_vaddr = phdr->p_vaddr + phdr->p_memsz;  // 記錄最大的虛擬地址
    }
  }
  if (!found_pt_load) {
    min_vaddr = 0;
  }
  min_vaddr = PAGE_START(min_vaddr);      // 頁對齊
  max_vaddr = PAGE_END(max_vaddr);      // 頁對齊
  if (out_min_vaddr != NULL) {
    *out_min_vaddr = min_vaddr;
  }
  if (out_max_vaddr != NULL) {
    *out_max_vaddr = max_vaddr;
  }
  return max_vaddr - min_vaddr;         // load_size = max_vaddr - min_vaddr
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

2.2.4 Load Segments

遍歷 program header table，找到類型爲 PT_LOAD 的 segment: 
1. 計算 segment 在內存空間中的起始地址 seg_start 和結束地址 seg_end，seg_start 等於虛擬偏移加上基址load_bias_，同時由於 mmap 的要求，都要對齊到頁邊界得到 seg_page_start 和 seg_page_end。 
2. 計算 segment 在文件中的頁對齊後的起始地址 file_page_start 和長度 file_length。 
3. 使用 mmap 將 segment 映射到內存，指定映射地址爲 seg_page_start，長度爲 file_length，文件偏移爲 file_page_start。

bool ElfReader::LoadSegments() {
  for (size_t i = 0; i < phdr_num_; ++i) {
    const ElfW(Phdr)* phdr = &phdr_table_[i];

    if (phdr->p_type != PT_LOAD) {
      continue;
    }
    // Segment 在內存中的地址.
    ElfW(Addr) seg_start = phdr->p_vaddr + load_bias_;
    ElfW(Addr) seg_end   = seg_start + phdr->p_memsz;

    ElfW(Addr) seg_page_start = PAGE_START(seg_start);
    ElfW(Addr) seg_page_end   = PAGE_END(seg_end);

    ElfW(Addr) seg_file_end   = seg_start + phdr->p_filesz;

    // 文件偏移
    ElfW(Addr) file_start = phdr->p_offset;
    ElfW(Addr) file_end   = file_start + phdr->p_filesz;

    ElfW(Addr) file_page_start = PAGE_START(file_start);
    ElfW(Addr) file_length = file_end - file_page_start;

    if (file_length != 0) {
      // 將文件中的 segment 映射到內存
      void* seg_addr = mmap(reinterpret_cast<void*>(seg_page_start),
                            file_length,
                            PFLAGS_TO_PROT(phdr->p_flags),
                            MAP_FIXED|MAP_PRIVATE,
                            fd_,
                            file_page_start);
    }
    // 如果 segment 可寫, 並且沒有在頁邊界結束，那麼就將 segemnt end 到頁邊界的內存清零。
    if ((phdr->p_flags & PF_W) != 0 && PAGE_OFFSET(seg_file_end) > 0) {
      memset(reinterpret_cast<void*>(seg_file_end), 0, PAGE_SIZE - PAGE_OFFSET(seg_file_end));
    }

    seg_file_end = PAGE_END(seg_file_end);
    // 將 (內存長度 - 文件長度) 對應的內存進行匿名映射
    if (seg_page_end > seg_file_end) {
      void* zeromap = mmap(reinterpret_cast<void*>(seg_file_end),
                           seg_page_end - seg_file_end,
                           PFLAGS_TO_PROT(phdr->p_flags),
                           MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE,
                           -1,
                           0);
    }
  }
  return true;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

2.3 分配 soinfo

load_library 在調用 load_segments 完成裝載後，接着調用 soinfo_alloc 函數爲目標SO分配soinfo，soinfo_alloc 函數實現如下:

static soinfo* soinfo_alloc(const char* name, struct stat* file_stat) {

  soinfo* si = g_soinfo_allocator.alloc();  //分配空間，可以簡單理解爲 malloc
  // Initialize the new element.
  memset(si, 0, sizeof(soinfo));
  strlcpy(si->name, name, sizeof(si->name));
  si->flags = FLAG_NEW_SOINFO;

  sonext->next = si;    // 加入到存有所有 soinfo 的鏈表中
  sonext = si;
  return si;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

Linker 爲 每個 SO 維護了一個soinfo結構，調用 dlopen時，返回的句柄其實就是一個指向該 SO 的 soinfo 指針。soinfo 保存了 SO 加載鏈接以及運行期間所需的各類信息，簡單列舉一下:

裝載鏈接期間主要使用的成員: 
- 裝載信息 
- const ElfW(Phdr)* phdr; 
- size_t phnum; 
- ElfW(Addr) base; 
- size_t size;

  • 符號信息

    • const char* strtab;
    • ElfW(Sym)* symtab;

  • 重定位信息

    • ElfW(Rel)* plt_rel;
    • size_t plt_rel_count;
    • ElfW(Rel)* rel;
    • size_t rel_count;

  • init 函數和 finit 函數

    • Linker_function_t* init_array;
    • size_t init_array_count;
    • Linker_function_t* fini_array;
    • size_t fini_array_count;
    • Linker_function_t init_func;
    • Linker_function_t fini_func;

運行期間主要使用的成員: 
- 導出符號查找（dlsym）: 
- const char* strtab; 
- ElfW(Sym)* symtab; 
- size_t nbucket; 
- size_t nchain; 
- unsigned* bucket; 
- unsigned* chain; 
- ElfW(Addr) load_bias;

  • 異常處理: 
    • unsigned* ARM_exidx;
    • size_t ARM_exidx_count;

load_library 在爲 SO 分配 soinfo 後，會將裝載結果更新到 soinfo 中，後面的鏈接過程就可以直接使用soinfo的相關字段去訪問 SO 中的信息。

    ...
    si->base = elf_reader.load_start();
    si->size = elf_reader.load_size();
    si->load_bias = elf_reader.load_bias();
    si->phnum = elf_reader.phdr_count();
    si->phdr = elf_reader.loaded_phdr();
    ...
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2.4 鏈接

鏈接過程由 soinfo_link_image 函數完成，主要可以分爲四個主要步驟:

1. 定位 dynamic section， 
由函數 phdr_table_get_dynamic_section 完成，該函數會遍歷 program header，找到爲類型爲 PT_DYNAMIC 的 header, 從中獲取的是 dynamic section 的信息，主要就是虛擬地址和項數。

2. 解析 dynamic section 
dynamic section本質上是類型爲Elf32_Dyn的數組，Elf32_Dyn 結構如下

typedef struct {
    Elf32_Sword d_tag;      /* 類型(e.g. DT_SYMTAB)，決定 d_un 表示的意義*/
    union {
        Elf32_Word  d_val;  /* 根據 d_tag的不同，有不同的意義*/
        Elf32_Addr  d_ptr;  /* 虛擬地址 */
    } d_un;
} Elf32_Dyn;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Elf32_Dyn結構的d_tag屬性表示該項的類型，類型決定了dun中信息的意義，e.g.:當d_tag = DT_SYMTAB表示該項存儲的是符號表的信息，d_un.d_ptr 表示符號表的虛擬地址的偏移，當d_tag = DT_RELSZ時，d_un.d_val 表示重定位表rel的項數。 
解析的過程就是遍歷數組中的每一項，根據d_tag的不同，獲取到不同的信息。 
dynamic section 中包含的信息主要包括以下 3 類: 
- 符號信息 
- 重定位信息 
- init&finit funcs

3. 加載 needed SO 
調用 find_library 獲取所有依賴的 SO 的 soinfo 指針，如果 SO 還沒有加載，則會將 SO 加載到內存，分配一個soinfo*[]指針數組，用於存放 soinfo 指針。

4. 重定位 
重定位SO 鏈接中最複雜同時也是最關鍵的一步。重定位做的工作主要是修復導入符號的引用，下面一節將對重定位過程進行詳細分析。

soinfo_link_image 的示意代碼:

static bool soinfo_link_image(soinfo* si, const Android_dlextinfo* extinfo) {
...
    // 1. 獲取 dynamic section 的信息，si->dynamic 指向 dynamic section
    phdr_table_get_dynamic_section(phdr, phnum, base, &si->dynamic,
                                   &dynamic_count, &dynamic_flags);
...
    // 2. 解析dynamic section
    uint32_t needed_count = 0;
    for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
        switch (d->d_tag) {
         // 以下爲符號信息
         case DT_HASH:
            si->nbucket = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr)[0];
            si->nchain = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr)[1];
            si->bucket = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr + 8);
            si->chain = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr + 8 + si->nbucket * 4);
            break;
         case DT_SYMTAB:
            si->symtab = reinterpret_cast<ElfW(Sym)*>(base + d->d_un.d_ptr);
            break;
         case DT_STRTAB:
            si->strtab = reinterpret_cast<const char*>(base + d->d_un.d_ptr);
            break;
         // 以下爲重定位信息
         case DT_JMPREL:
            si->plt_rel = reinterpret_cast<ElfW(Rel)*>(base + d->d_un.d_ptr);
            break;
         case DT_PLTRELSZ:
            si->plt_rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
            break;
         case DT_REL:
            si->rel = reinterpret_cast<ElfW(Rel)*>(base + d->d_un.d_ptr);
            break;
         case DT_RELSZ:
            si->rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
            break;
         // 以下爲 init&finit funcs
         case DT_INIT:
            si->init_func = reinterpret_cast<Linker_function_t>(base + d->d_un.d_ptr);
            break;
         case DT_FINI:
            ...
         case DT_INIT_ARRAY:
            si->init_array = reinterpret_cast<Linker_function_t*>(base + d->d_un.d_ptr);
            break;
         case DT_INIT_ARRAYSZ:
            ...
         case DT_FINI_ARRAY:
            ...
         case DT_FINI_ARRAYSZ:
            ...
         // SO 依賴
         case DT_NEEDED:
            ...
        ...
        }
...
    // 3. 加載依賴的SO
    for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
        if (d->d_tag == DT_NEEDED) {
            soinfo* lsi = find_library(library_name, 0, NULL);
            si->add_child(lsi);
            *pneeded++ = lsi;
        }
    }
    *pneeded = NULL;
...
    // 4. 重定位
    soinfo_relocate(si, si->plt_rel, si->plt_rel_count, needed);
    soinfo_relocate(si, si->rel, si->rel_count, needed);
...
    // 設置已鏈接標誌
    si->flags |= FLAG_LINKED;
    DEBUG("[ finished linking %s ]", si->name);
｝
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75

2.4.1 重定位 relocate

Android ARM 下需要處理兩個重定位表，plt_rel 和 rel，plt 指的是延遲綁定，但是 Android 目前並不對延遲綁定做特殊處理，直接與普通的重定位同時處理。兩個重定位的表都由 soinfo_relocate 函數處理。 
soinfo_relocate 函數需要遍歷重定位表，處理每個重定位項，每個重定位項的處理過程可以分爲 3 步: 
1. 解析重定位項和導入符號的信息

重定位項的結構如下

typedef struct {
     Elf32_Addr  r_offset;   /* 需要重定位的位置的偏移 */
     Elf32_Word  r_info;     /* 高24位爲符號在符號表中的index，低8位爲重定位類型 */
} Elf32_Rel;
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

首先從重定位項獲取的信息如下: 
- 重定位的類型 type 
- 符號在符號表中的索引號 sym，sym 爲0表示爲本SO內部的重定位，如果不爲0，意味着該符號爲導入符號 
- 重定位的目標地址 reloc，使用r_offset + si_load_bias，相當於 偏移地址+基地址

符號表表項的結構爲elf32_sym:

typedef struct elf32_sym {
    Elf32_Word  st_name;    /* 名稱 - index into string table */
    Elf32_Addr  st_value;   /* 偏移地址 */
    Elf32_Word  st_size;    /* 符號長度（ e.g. 函數的長度） */
    unsigned char   st_info;    /* 類型和綁定類型 */
    unsigned char   st_other;   /* 未定義 */
    Elf32_Half  st_shndx;   /* section header的索引號，表示位於哪個 section 中 */
} Elf32_Sym;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

2. 如果 sym 不爲0，則查找導入符號的信息 
如果 sym 不爲0，則繼續使用 sym 在符號表中獲取符號信息，從符號信息中進一步獲取符號的名稱。隨後調用 soinfo_do_lookup 函數在所有依賴的 SO 中根據符號名稱查找符號信息，返回值類型爲 elf32_sym，同時還會返回含有該符號的 SO 的 soinfo( lsi )，如果查找成功則該導入符號的地址爲: 
sym_addr = s->st_value + lsi->load_bias;

3. 修正需要重定位的地址 
根據重定位類型的不同，修正重定位地址，具體的重定位類型定義和計算方法可以參考 aaelf 文檔的 4.6.1.2 節。 
對於導入符號，則使用根據第二步得到 sym_addr 去修正，對於 SO 內部的相對偏移修正，則直接將reloc的地址加上 SO 的基址。

static int soinfo_relocate(soinfo* si, ElfW(Rel)* rel, unsigned count, soinfo* needed[]) {
    ElfW(Sym)* s;
    soinfo* lsi;

    // 遍歷重定位表
    for (size_t idx = 0; idx < count; ++idx, ++rel) {
        //
        // 1. 解析重定位項和導入符號的信息
        //
        // 重定位類型
        unsigned type = ELFW(R_TYPE)(rel->r_info);
        // 導入符號在符號表中的 index，可以爲0,(修正 SO 內部的相對偏移)
        unsigned sym = ELFW(R_SYM)(rel->r_info);
        // 需要重定位的地址
        ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + si->load_bias);
        ElfW(Addr) sym_addr = 0;
        const char* sym_name = NULL;

        if (type == 0) { // R_*_NONE
            continue;
        }
        if (sym != 0) {
            //
            // 2. 如果 sym 有效，則查找導入符號
            //
            // 從符號表中獲得符號信息，在根據符號信息從字符串表中獲取字符串名
            sym_name = reinterpret_cast<const char*>(si->strtab + si->symtab[sym].st_name);
            // 在依賴的 SO 中查找符號，返回值爲 Elf32_Sym 類型
            s = soinfo_do_lookup(si, sym_name, &lsi, needed);
            if (s == NULL) {}
                // 查找失敗，不關心
            } else {
                // 查找成功，最終的符號地址 = s->st_value + lsi->load_bias
                // s->st_value 是符號在依賴 SO 中的偏移，lsi->load_bias 爲依賴 SO 的基址
                sym_addr = static_cast<ElfW(Addr)>(s->st_value + lsi->load_bias);
            }
        } else {
            s = NULL;
        }
        //
        // 3. 根據重定位類型，修正需要重定位的地址
        //
        switch (type) {
        // 判斷重定位類型，將需要重定位的地址 reloc 修正爲目標符號地址
        // 修正導入符號
        case R_ARM_JUMP_SLOT:
            *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
            break;
        case R_ARM_GLOB_DAT:
            *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
            break;
        case R_ARM_ABS32:
            *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
            break;
        case R_ARM_REL32:
            *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr - rel->r_offset;
            break;
        // 不支持
        case R_ARM_COPY:
            /*
             * ET_EXEC is not supported SO this should not happen.
             */
            DL_ERR("%s R_ARM_COPY relocations are not supported", si->name);
            return -1;
        // SO 內部的偏移修正
        case R_ARM_RELATIVE:
            if (sym) {
                DL_ERR("odd RELATIVE form...");
                return -1;
            }
            *reinterpret_cast<ElfW(Addr)*>(reloc) += si->base;
            break;

        default:
            DL_ERR("unknown reloc type %d @ %p (%zu)", type, rel, idx);
            return -1;
        }
    }
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80

2.5 CallConstructors

在編譯 SO 時，可以通過鏈接選項-init或是給函數添加屬性__attribute__((constructor))來指定 SO 的初始化函數，這些初始化函數在 SO 裝載鏈接後便會被調用，再之後纔會將 SO 的 soinfo 指針返回給 dl_open 的調用者。SO 層面的保護手段，有兩個介入點, 一個是 jni_onload, 另一個就是初始化函數，比如反調試、脫殼等，逆向分析時經常需要動態調試分析這些初始化函數。

完成 SO 的裝載鏈接後，返回到 do_dlopen 函數, do_open 獲得 find_library 返回的剛剛加載的 SO 的 soinfo，在將 soinfo 返回給其他模塊使用之前，最後還需要調用 soinfo 的成員函數 CallConstructors。

soinfo* do_dlopen(const char* name, int flags, const Android_dlextinfo* extinfo) {
...
  soinfo* si = find_library(name, flags, extinfo);
  if (si != NULL) {
    si->CallConstructors();
  }
  return si;
...
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

CallConstructors 函數會調用 SO 的首先調用所有依賴的 SO 的 soinfo 的 CallConstructors 函數，接着調用自己的 soinfo 成員變量 init 和 看 init_array 指定的函數，這兩個變量在在解析 dynamic section 時賦值。

void soinfo::CallConstructors() {
  //如果已經調用過，則直接返回
  if (constructors_called) {
    return;
  }
  // 調用依賴 SO 的 Constructors 函數
  get_children().for_each([] (soinfo* si) {
    si->CallConstructors();
  });
  // 調用 init_func
  CallFunction("DT_INIT", init_func);
  // 調用 init_array 中的函數
  CallArray("DT_INIT_ARRAY", init_array, init_array_count, false);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

有了以上分析基礎後，在需要動態跟蹤初始化函數時，我們就知道可以將斷點設在 do_dlopen 或是 CallConstructors。

3. 加殼技術

在病毒和版權保護領域，“殼”一直扮演着極爲重要的角色。通過加殼可以對代碼進行壓縮和加密，同時再輔以虛擬化、代碼混淆和反調試等手段，達到防止靜態和動態分析。

在 Android 環境中，Native 層的加殼主要是針對動態鏈接庫 SO，SO 加殼的示意圖如下: 
 
加殼工具、loader、被保護SO。

  • SO: 即被保護的目標 SO。
  • loader: 自身也是一個 SO，系統加載時首先加載 loader，loader 首先還原出經過加密、壓縮、變換的 SO，再將 SO 加載到內存，並完成鏈接過程，使 SO 可以正常被其他模塊使用。
  • 加殼工具: 將被保護的 SO 加密、壓縮、變換，並將結果作爲數據與 loader 整合爲 packed SO。

下面對 SO 加殼的關鍵技術進行簡單介紹。

3.1 loader 執行時機

Linker 加載完 loader 後，loader 需要將被保護的 SO 加載起來，這就要求 loader 的代碼需要被執行，而且要在 被保護 SO 被使用之前，前文介紹了 SO 的初始化函數便可以滿足這個要求，同時在 Android 系統下還可以使用 JNI_ONLOAD 函數，因此 loader 的執行時機有兩個選擇: 
- SO 的 init 或 initarray 
- jni_onload

3.2 loader 完成 SO 的加載鏈接

loader 開始執行後，首先需要在內存中還原出 SO，SO 可以是經過加密、壓縮、變換等手段，也可已單純的以完全明文的數據存儲，這與 SO 加殼的技術沒有必要的關係，在此不進行討論。 
在內存中還原出 SO 後，loader 還需要執行裝載和鏈接，這兩個過程可以完全模仿 Linker 來實現，下面主要介紹一下相對 Linker，loader 執行這兩個過程有哪些變化。

3.2.1 裝載

還原後的 SO 在內存中，所以裝載時的主要變化就是從文件裝載到從內存裝載。 
Linker 在裝載 PT_LAOD segment時，使用 SO 文件的描述符 fd：

      void* seg_addr = mmap(reinterpret_cast<void*>(seg_page_start),
                            file_length,
                            PFLAGS_TO_PROT(phdr->p_flags),
                            MAP_FIXED|MAP_PRIVATE,
                            fd_,
                            file_page_start);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

按照 Linker 裝載，PT_LAOD segment時，需要分爲兩步：

      // 1、改用匿名映射
      void* seg_addr = mmap(reinterpret_cast<void*>(seg_page_start),
                            file_length,
                            PFLAGS_TO_PROT(phdr->p_flags),
                            MAP_FIXED|MAP_PRIVATE,
                            -1,
                            0);
     // 2、將內存中的 segment 複製到映射的內存中
     memcpy(seg_addr+seg_page_offset, elf_data_buf + phdr->p_offset, phdr->p_filesz);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

注意第2步複製 segment 時，目標地址需要加上 seg_page_offset，seg_page_offset 是 segment 相對與頁面起始地址的偏移。 
其他的步驟基本按照 Linker 的實現即可，只需要將一些從文件讀取修改爲從內存讀取，比如讀 elfheader和program header時。

3.2.2 分配 soinfo

soinfo 保存了 SO 裝載鏈接和運行時需要的所有信息，爲了維護相關的信息，loader 可以照搬 Linker 的 soinfo 結構，用於存儲中間信息，裝載鏈接結束後，還需要將 soinfo 的信息修復到 Linker 維護的soinfo，3.3節進行詳細說明。

3.2.3 鏈接

鏈接過程完全是操作內存，不論是從文件裝載還是內存裝載，鏈接過程都是一樣，完全模仿 Linker 即可。 
另外鏈接後記得順便調用 SO 初始化函數( init 和 init_array )。

3.3 soinfo 修復

SO 加殼的最關鍵技術點在於 soinfo 的修復，由於 Linker 加載的是 loader，而實際對外使用的是被保護的 SO，所以 Linker 維護的 soinfo 可以說是錯誤，loader 需要將自己維護的 soinfo 中的部分信息導出給 Linker 的soinfo。

修復過程如下： 
1. 獲取 Linker 維護的 soinfo，可以通過 dlopen 打開自己來獲得：self_soinfo = dlopen(self)。 
2. 將 loader soinfo 中的信息導出到 self_soinfo，最簡單粗暴的方式就是直接賦值，比如：self_soinfo.base = soinfo.base。需要導出的主要有以下幾項： 
- SO地址範圍：base、size、load_bias 
- 符號信息:sym_tab、str_tab、 
- 符號查找信息：nbucket、nchain、bucket、chain 
- 異常處理：ARM_exidx、ARM_exidx_count

參考

  • <<Linkers and loaders>>
  • <<ELF for the ARM Architecture>>
站內首發文章
flyeagle317
發佈了30 篇原創文章 · 獲贊 9 · 訪問量 5萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

gradle 配置鏡像

文件位置：./gradle/init.gradle def repoConfig = { all { ArtifactRepository repo -> if (repo instanceof MavenArtif

原創 2024-06-06 23:07:52

基於TAE的數字鑰匙自動化測試解決方案

方案概述        在汽車發展和用戶需求的推動下，汽車鑰匙開始從傳統的機械鑰匙向數字化、智能化方向發展。目前常見的數字鑰匙集成了藍牙、NFC、UWB等技術實現了移動設備與車端的通信，可以幫助用戶便捷的實現車輛功能控制。隨着數字鑰匙的廣泛

原創 2024-05-29 23:11:46

同樣的APP爲何在Android 8以後網絡感覺變卡？

前言  在無線網絡技術不斷髮展的今天，Wi-Fi已經成爲了我們日常生活中不可或缺的一部分。無論是家庭娛樂、辦公還是在線遊戲，Wi-Fi都在提供着便捷的互聯網接入服務。然而，在安卓8.1後，爲了進一步延長安卓設備的待機時間。原生安卓(AO

原創 2024-05-23 23:57:27

「實用推薦」如何爲桌面 & 移動跨平臺應用選擇UI框架/APP架構？

DevExpress .NET MAUI UI組件庫提供了用於Android和iOS移動開發的高性能UI組件，該庫包括數據網格、圖表、日程、數據編輯器、CollectionView和選項卡組件。 獲取DevExpress .NET MAUI

原創 2024-05-21 12:19:30

有隙可乘 - Android 序列化漏洞分析實戰

作者：vivo 互聯網大前端團隊 - Ma Lian 本文主要描述了FileProvider，startAnyWhere實現，Parcel不對稱漏洞以及這三者結合產生的漏洞利用實戰，另外闡述了漏洞利用的影響和修復預防措施，這個漏洞波及了

原創 2024-05-16 12:09:07

【深圳招聘】Taro 團隊招前端開發工程師！

Taro 團隊再再再招人啦！我們正在尋找多位有經驗的「前端開發工程師」加入我們的團隊。如果您具備以下技能和經驗，我們期待您的加入： 工作職責 參與 Taro 框架開發，同時在跨端和全棧等技術方向攻克難題； 參與跨團隊合作，完成整體項目規

原創 2024-05-13 21:53:04

Docker 的 Busybox 操作系統鏡像

BusyBox是一個遵循GPL協議、以自由軟件形式發行的應用程序。 Busybox在單一的可執行文件中提供了精簡的Unix工具集，可運行於多款POSIX環境的操作系統，例如Linux（包括Android）、Hurd、FreeBSD等等。 由

原創 2024-05-13 11:45:19

Qt/C++音視頻開發70-無感切換通道/無縫切換播放視頻/多通道流暢切換/不同視頻打開無縫切換

一、前言 之前就寫過這個方案，當時做的是ffmpeg內核版本，由於ffmpeg內核解析都是代碼實現，所以無縫切換非常完美，看不到絲毫的中間切換過程，看起來就像是在一個通道畫面中。其實這種切換隻能說是取巧辦法，最佳的辦法應該是公用一個open

原創 2024-04-18 10:40:53

愛奇藝APP Android低端機性能優化

01    背景介紹 在智能手機市場上，高端機型經常備受矚目，但低端機型亦佔據了不可忽視的份額。衆多廠商爲滿足低端市場的需求，不斷推出低配系列手機。另外過去幾年的中高端

原創 2024-04-16 01:06:42

Qt血的教訓/細數Qt開發的各種坑/又愛又恨/歡迎圍觀留言評論

一、吐槽總結 搞Qt開發十幾年了，最初從Qt4.6開始，一直追新到現在的6.7版本，中間經歷過無數的血的教訓，簡直是又愛又恨。其實Qt挺好的，但是還是要忍不住吐槽一下，本人還是希望Qt發展的越來越好，這樣我的飯碗就能保住了。 1. 版本衆多

原創 2024-04-07 10:39:53

Kotlin高效App爬取工具：利用HttpClient與代理服務器的技巧

在當今數字化時代，移動應用（App）數據的價值日益凸顯，而爲了獲取並分析這些數據，開發高效的數據爬取工具變得至關重要。Kotlin作爲一種現代化、功能強大的編程語言，與HttpClient等強大工具的結合，爲構建高效的App數據爬取工具提

原創 2024-03-28 00:45:02

一文全面瞭解O2OA(翱途)開發平臺的技術棧

O2OA（翱途）開發平臺採用JavaEE技術棧分佈式架構設計，是一款真正全代碼（包含服務器、安卓以及IOS客戶端）開源的企業應用定製化開發平臺，適用於企業OA、協同辦公類信息化系統的建設和開發。 平臺擁有流程管理、門戶管理、信息管理、數據管

原創 2024-03-04 11:03:13

adb功能速查

最近需要弄android調試，把adb功能列於此方便查看。本文內容主要來自以下地址 https://developer.android.com/tools/adb?hl=zh-cn   查詢設備 adb devices -l   將

原創 2024-02-29 23:53:16

2024年首個iOS AI病毒來了！偷人臉照片，轉銀行卡餘額...

2024年2月15日，國外安全公司Group-IB宣佈，發現一個名爲“GoldPickaxe”的惡意軟件。該惡意軟件的iOS版本，誘騙用戶進行人臉識別、提交身份證件，然後基於用戶的人臉信息進行深度僞造。 通過深度僞造的虛假的人臉視頻，欺詐分

原創 2024-02-29 00:54:54

奇異果投屏的進化之路

筆者按：奇異果投屏伴隨奇異果TV一路發展至2022年，日活用戶已達300多萬，用戶和我們都對投屏的功能和性能提出了更多的訴求和更高要求，因此2022開始系統地對投屏功能和性能做了擴展和優化。本文立足於TV端，爲大家介紹愛奇藝站內投屏優化過

原創 2024-02-21 03:08:35