Android类加载（一）——DVM、ART、Dexopt、DexAot名词解析

Posted 2023-05-17

参考技术A android类加载（一）——DVM、ART、Dexopt、DexAot名词解析
Android类加载（二）——双亲委托机制
Android类加载（三）——源码解读

DVM基于寄存器，JVM基于栈

寄存器是CPU上面的一块存储空间，栈是内存上面的一段连续的存储空间，所以CPU直接访问自己上面的一块空间的数据的效率肯定要大于访问内存上面的数据。基于栈架构的程序在运行时虚拟机需要频繁的从栈上读取或写入数据，这个过程需要更多的指令分派与内存访问次数，会耗费不少CPU时间，对于像手机设备资源有限的设备来说，这是相当大的一笔开销。DVM基于寄存器架构。数据的访问通过寄存器间直接传递，这样的访问方式比基于栈方式要快很多。

执行的字节码文件不一样

DVM执行的是.dex文件，JVM执行的是.class文件。

DVM解释执行的是dex字节码.dex：.java –> .class –> .dex –> .apk

JVM运行的是java字节码.class：.java –> .class –> .jar

本质上java文件编译后都是字节码，只不过JVM运行的是.class字节码，而DVM运行的是.dex字节码

Dalvik：Dalvik是谷歌公司自己设计用于Android平台的Java虚拟机（DVM）。支持已转换为.dex格式的应用程序的运行。.dex格式是专门为DVM设计的一种压缩格式，适合内存和处理器有限的系统，例如Android系统。（DVM负责解释.dex文件为机器码）

ART：Android Runtime，Android4.4中引入的一个开发者选项，也是Android5.0及更高版本的默认模式。在应用安装的时候把字节码预编译成机器语言，这一机制叫做Ahead-Of-Time（AOT）预编译。这样应用程序虽然安装会很慢，但是执行效率将更高，启动更快。

Android 逆向ART 脱壳 ( DexClassLoader 脱壳 | ART 虚拟机下 DexClassLoader 类加载器脱壳点总结 )

文章目录

• 一、ART 虚拟机下 DexClassLoader 类加载器脱壳点总结
• • 1、file_magic.cc#OpenAndReadMagic 函数
  • 2、dex_file.cc#DexFile::OpenCommon
  • 3、dex_file.cc#DexFile::DexFile
• 总结 ( 兼容 InMemoryDexClassLoader 和 DexClassLoader 两种类加载器的 脱壳点 )

一、ART 虚拟机下 DexClassLoader 类加载器脱壳点总结

---

从 /art/runtime/dex_file.cc#DexFile::Open 函数开始分析脱壳点位置 ;

其中调用的 /art/runtime/base/file_magic.cc#OpenAndReadMagic 函数 , 可以作为脱壳点 ;

在 /art/runtime/dex_file.cc#OpenFile 函数中 , 调用了 /art/runtime/dex_file.cc#OpenCommon 函数 , 是脱壳点 ;

bool DexFile::Open(const char* filename,
                   const std::string& location,
                   bool verify_checksum,
                   std::string* error_msg,
                   std::vector<std::unique_ptr<const DexFile>>* dex_files) 
  ScopedTrace trace(std::string("Open dex file ") + std::string(location));
  DCHECK(dex_files != nullptr) << "DexFile::Open: out-param is nullptr";
  uint32_t magic;
  // ★ 脱壳点后汉书 
  File fd = OpenAndReadMagic(filename, &magic, error_msg);
  if (fd.Fd() == -1) 
    DCHECK(!error_msg->empty());
    return false;
  
  if (IsZipMagic(magic)) 
    return DexFile::OpenZip(fd.Release(), location, verify_checksum, error_msg, dex_files);
  
  if (IsDexMagic(magic)) 
  	// ★ 脱壳点函数
    std::unique_ptr<const DexFile> dex_file(DexFile::OpenFile(fd.Release(),
                                                              location,
                                                              /* verify */ true,
                                                              verify_checksum,
                                                              error_msg));
    if (dex_file.get() != nullptr) 
      dex_files->push_back(std::move(dex_file));
      return true;
     else 
      return false;
    
  
  *error_msg = StringPrintf("Expected valid zip or dex file: '%s'", filename);
  return false;

1、file_magic.cc#OpenAndReadMagic 函数

file_magic.cc#OpenAndReadMagic 函数是 脱壳点 , 第一个参数 const char* filename 是 Dex 文件的路径 ;

调用该函数的上一个调用位置是 /art/runtime/dex_file.cc#DexFile::Open 函数 ;

file_magic.cc 源码 :

#include "file_magic.h"

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

#include "android-base/stringprintf.h"

#include "base/logging.h"
#include "base/unix_file/fd_file.h"
#include "dex_file.h"

namespace art 

using android::base::StringPrintf;

File OpenAndReadMagic(const char* filename, uint32_t* magic, std::string* error_msg) 
  CHECK(magic != nullptr);
  File fd(filename, O_RDONLY, /* check_usage */ false);
  if (fd.Fd() == -1) 
    *error_msg = StringPrintf("Unable to open '%s' : %s", filename, strerror(errno));
    return File();
  
  int n = TEMP_FAILURE_RETRY(read(fd.Fd(), magic, sizeof(*magic)));
  if (n != sizeof(*magic)) 
    *error_msg = StringPrintf("Failed to find magic in '%s'", filename);
    return File();
  
  if (lseek(fd.Fd(), 0, SEEK_SET) != 0) 
    *error_msg = StringPrintf("Failed to seek to beginning of file '%s' : %s", filename,
                              strerror(errno));
    return File();
  
  return fd;


bool IsZipMagic(uint32_t magic) 
  return (('P' == ((magic >> 0) & 0xff)) &&
          ('K' == ((magic >> 8) & 0xff)));


bool IsDexMagic(uint32_t magic) 
  return DexFile::IsMagicValid(reinterpret_cast<const uint8_t*>(&magic));


  // namespace art

源码路径 : /art/runtime/base/file_magic.cc#OpenAndReadMagic

2、dex_file.cc#DexFile::OpenCommon

dex_file.cc#DexFile::OpenCommon 函数中 , 可以获取 Dex 文件在内存中的起始地址 ;

注意 : 该脱壳点 与 InMemoryDexClassLoader 类加载器的脱壳点重合 ;

std::unique_ptr<DexFile> DexFile::OpenCommon(const uint8_t* base,
                                             size_t size,
                                             const std::string& location,
                                             uint32_t location_checksum,
                                             const OatDexFile* oat_dex_file,
                                             bool verify,
                                             bool verify_checksum,
                                             std::string* error_msg,
                                             VerifyResult* verify_result) 
  if (verify_result != nullptr) 
    *verify_result = VerifyResult::kVerifyNotAttempted;
  
  std::unique_ptr<DexFile> dex_file(new DexFile(base,
                                                size,
                                                location,
                                                location_checksum,
                                                oat_dex_file));
  if (dex_file == nullptr) 
    *error_msg = StringPrintf("Failed to open dex file '%s' from memory: %s", location.c_str(),
                              error_msg->c_str());
    return nullptr;
  
  if (!dex_file->Init(error_msg)) 
    dex_file.reset();
    return nullptr;
  
  if (verify && !DexFileVerifier::Verify(dex_file.get(),
                                         dex_file->Begin(),
                                         dex_file->Size(),
                                         location.c_str(),
                                         verify_checksum,
                                         error_msg)) 
    if (verify_result != nullptr) 
      *verify_result = VerifyResult::kVerifyFailed;
    
    return nullptr;
  
  if (verify_result != nullptr) 
    *verify_result = VerifyResult::kVerifySucceeded;
  
  return dex_file;

源码地址 : /art/runtime/dex_file.cc#OpenCommon

3、dex_file.cc#DexFile::DexFile

在 dex_file.cc#DexFile::DexFile 构造函数中 , 可以获取到 Dex 文件地址 ;

注意 : 该脱壳点 与 InMemoryDexClassLoader 类加载器的脱壳点重合 ;

DexFile::DexFile(const uint8_t* base,
                 size_t size,
                 const std::string& location,
                 uint32_t location_checksum,
                 const OatDexFile* oat_dex_file)
    : begin_(base),
      size_(size),
      location_(location),
      location_checksum_(location_checksum),
      header_(reinterpret_cast<const Header*>(base)),
      string_ids_(reinterpret_cast<const StringId*>(base + header_->string_ids_off_)),
      type_ids_(reinterpret_cast<const TypeId*>(base + header_->type_ids_off_)),
      field_ids_(reinterpret_cast<const FieldId*>(base + header_->field_ids_off_)),
      method_ids_(reinterpret_cast<const MethodId*>(base + header_->method_ids_off_)),
      proto_ids_(reinterpret_cast<const ProtoId*>(base + header_->proto_ids_off_)),
      class_defs_(reinterpret_cast<const ClassDef*>(base + header_->class_defs_off_)),
      method_handles_(nullptr),
      num_method_handles_(0),
      call_site_ids_(nullptr),
      num_call_site_ids_(0),
      oat_dex_file_(oat_dex_file) 
  CHECK(begin_ != nullptr) << GetLocation();
  CHECK_GT(size_, 0U) << GetLocation();
  // Check base (=header) alignment.
  // Must be 4-byte aligned to avoid undefined behavior when accessing
  // any of the sections via a pointer.
  CHECK_ALIGNED(begin_, alignof(Header));

  InitializeSectionsFromMapList();

源码地址 : /art/runtime/dex_file.cc#DexFile

---

总结 ( 兼容 InMemoryDexClassLoader 和 DexClassLoader 两种类加载器的 脱壳点 )

加固厂商可能使用 InMemoryDexClassLoader 类加载器 , 也可能使用 DexClassLoader 类加载器 , 这里为了保证不管使用什么类加载器 , 都可以进行脱壳 , 选择 $2$ 个类加载器都有的脱壳点 , 可以兼容两种类加载器 ;