Android ART dex2oat 載入加速淺析

阿新 • • 發佈：2019-01-09

前言

手機淘寶外掛化框架Atlas在ART上首次啟動的時候，會通過禁用dex2oat來達到外掛迅速啟動的目的。之後後臺進行dex2oat，下次啟動如果dex2oat完成了則啟用dex2oat，如果沒有完成則繼續禁用dex2oat。但是這部分程式碼淘寶並沒有開源。且由於Atlas後續持續維護的可能性極低，加上Android 9.0上禁用失敗及64位動態庫在部分系統上禁用會發生crash。此文結合逆向與正向的角度來分析Atlas是通過什麼手段達到禁用dex2oat的，以及微店App是如何實踐達到禁用的目的。

逆向日誌分析

由於手淘Atlas這部分程式碼是閉源的，因此我們無法正向分析其原理。所以我們可以從逆向的角度進行分析。逆向分析的關鍵一步就是懂得看控制檯日誌，從日誌中入手進行分析。

通過在Android 5.0，Android 6.0，Android 7.0，Android 8.0 和 Android 9.0上執行外掛化的App，我們發現，控制檯會輸出一部分關鍵性的日誌。內容如下

通過在AOSP中查詢關鍵日誌 Generation of oat file .... not attempt because dex2oat is disabled 即可繼續發現貓膩。最終我們會發現這部分資訊出現在了class_linker.cc類或者oat_file_manager.cc類中。

正向原始碼分析

有了以上基礎，我們嘗試從原始碼角度進行正向分析。

在Java層我們載入一個Dex是通過DexFile.loadDex()方法進行載入。此方法最終會走到native方法 openDexFileNative，Android 5.0的原始碼如下

android-5.0.0_r7/runtime/native/dalvik_system_DexFile.cc#101

static jlong DexFile_openDexFileNative(JNIEnv* env, jclass, jstring javaSourceName, jstring javaOutputName, jint) {
  ScopedUtfChars sourceName(env, javaSourceName);
  if (sourceName.c_str() == NULL) {
    return 0;
  }
  NullableScopedUtfChars outputName(env, javaOutputName);
  if 
 (env->ExceptionCheck()) {
    return 0;
  }
  ClassLinker* linker = Runtime::Current()->GetClassLinker();
  std::unique_ptr<std::vector<const DexFile*>> dex_files(new std::vector<const DexFile*>());
  std::vector<std::string> error_msgs;
  //關鍵呼叫在這裡
  bool success = linker->OpenDexFilesFromOat(sourceName.c_str(), outputName.c_str(), &error_msgs,
                                             dex_files.get());
  if (success || !dex_files->empty()) {
    // In the case of non-success, we have not found or could not generate the oat file.
    // But we may still have found a dex file that we can use.
    return static_cast<jlong>(reinterpret_cast<uintptr_t>(dex_files.release()));
  } else {
    // The vector should be empty after a failed loading attempt.
    DCHECK_EQ(0U, dex_files->size());
    ScopedObjectAccess soa(env);
    CHECK(!error_msgs.empty());
    // The most important message is at the end. So set up nesting by going forward, which will
    // wrap the existing exception as a cause for the following one.
    auto it = error_msgs.begin();
    auto itEnd = error_msgs.end();
    for ( ; it != itEnd; ++it) {
      ThrowWrappedIOException("%s", it->c_str());
    }
    return 0;
  }
}
複製程式碼

最終會呼叫到ClassLinker中的OpenDexFilesFromOat方法

對應程式碼過長，這裡不貼了，見

android-5.0.0_r7/runtime/class_linker.cc#811

OpenDexFilesFromOat函式主要做了如下幾步

1、檢測我們是否已經有一個開啟的oat檔案
2、如果沒有已經開啟的oat檔案，則從磁碟上檢測是否有一個已經生成的oat檔案
3、如果磁碟上有一個生成的oat檔案，則檢測該oat檔案是否過期了以及是否包含了我們所有的dex檔案
4、如果以上都不滿足，則會重新生成

首次開啟時，1-3步必然是不滿足的，最終會走到第四個邏輯，這一步有一個關鍵性的程式碼直接決定了生成oat檔案是否生成成功

if (Runtime::Current()->IsDex2OatEnabled() && has_flock && scoped_flock.HasFile()) {
   // Create the oat file.
   open_oat_file.reset(CreateOatFileForDexLocation(dex_location, scoped_flock.GetFile()->Fd(),
                                                   oat_location, error_msgs));
}
複製程式碼

核心函式Runtime::Current()->IsDex2OatEnabled()，判斷dex2oat是否開啟，如果開啟，則建立oat檔案並進行更新。

以上是Android 5.0的原始碼，Android 6.0-Android 9.0會有所差異。DexFile_openDexFileNative最終會呼叫到runtime->GetOatFileManager().OpenDexFilesFromOat()，繼續會呼叫到OatFileAssistant類中的MakeUpToDate函式，一直呼叫到GenerateOatFile(Androiod 6.0-7.0)或GenerateOatFileNoChecks(Android 8.0-9.0)等型別函式，相關程式碼見如下連結。

最終我們也會發現一段關鍵性的程式碼，如下

Runtime* runtime = Runtime::Current();
if (!runtime->IsDex2OatEnabled()) {
    *error_msg = "Generation of oat file for dex location " + dex_location_
                 + " not attempted because dex2oat is disabled.";
    return kUpdateNotAttempted;
}
複製程式碼

可以看到，我們已經看到了我們逆向日誌分析時，從控制檯看到的日誌內容，Generation of oat file....not attempted because dex2oat is disabled，這說明我們原始碼找對了。

通過以上分析，我們發現Android 5.0-Android 9.0最終都會走到Runtime::Current()->IsDex2OatEnabled()函式，如果dex2oat沒有開啟，則不會進行後續oat檔案生成的操作，而是直接return返回。所以結論已經很明確了，就是通過設定該函式的返回值為false，達到禁用dex2oat的目的。

通過檢視Runtime類的程式碼，可以發現IsDex2OatEnabled其實很簡單，就是返回了一個dex2oat_enabled_成員變數與另一個image_dex2oat_enabled_成員變數。原始碼見：

bool IsDex2OatEnabled() const {
    return dex2oat_enabled_ && IsImageDex2OatEnabled();
}
bool IsImageDex2OatEnabled() const {
    return image_dex2oat_enabled_;
}
複製程式碼

因此最終我們的目的就很明確了，只要把成員變數dex2oat_enabled_的值和image_dex2oat_enabled_的值進行修改，將它們修改成false，就達到了直接禁用的目的。如果要重新開啟，則重新還原他們的值為true即可，預設情況下，該值始終是true。

不過經過驗證後發現手淘Atlas是通過禁用IsImageDex2OatEnabled()達到目的的，即它是通過修改image_dex2oat_enabled_而不是dex2oat_enabled_，這一點在相容性方面十分重要，在一定程度上保障了部分機型的相容性（比如一加，8.0之後加入了一個變數，導致資料結構向後偏移1位元組；VIVO/OPPO部分機型加入變數，導致資料結構向後偏移1位元組），因此為了保持策略上的一致性，我們只修改image_dex2oat_enabled_，不修改dex2oat_enabled_。

原理與實現

有了以上理論基礎，我們必須進行實踐，用結論驗證猜想，才會有說服力了。

上面已經說到我們只需要修改Runtime中image_dex2oat_enabled_成員變數的值，將其對應的image_dex2oat_enabled_變數修改為false即可。

因此第一步我們需要拿到這個Runtime的地址。

在JNI中，每一個Java中的native方法對應的jni函式，都有一個JNIEnv* 指標入參，通過該指標變數的GetJavaVM函式，我們可以拿到一個JavaVM*的指標變數

JavaVM *javaVM;
env->GetJavaVM(&javaVM);
複製程式碼

而JavaVm在JNI中的資料結構定義為（原始碼地址見 android-9.0.0_r20/include_jni/jni.h）

typedef _JavaVM JavaVM;
struct _JavaVM {
    const struct JNIInvokeInterface* functions;
};
複製程式碼

可以看到，只有一個JNIInvokeInterface*指標變數

而在Android中，實際使用的是JavaVMExt（原始碼地址見 android-9.0.0_r20/runtime/java_vm_ext.h），它繼承了JavaVM，它的資料結構可以簡單理解為

class JavaVMExt : public JavaVM {
private:
    Runtime* const runtime_;
}
複製程式碼

根據記憶體佈局，我們可以將JavaVMExt等效定義為

struct JavaVMExt {
    void *functions;
    void *runtime;
};
複製程式碼

指標型別，在32位上佔4位元組，在64位上佔8位元組。

因此我們只需要將我們之前拿到的JavaVM *指標，強制轉換為JavaVMExt*指標，通過JavaVMExt*指標拿到Runtime*指標

JavaVM *javaVM;
env->GetJavaVM(&javaVM);
JavaVMExt *javaVMExt = (JavaVMExt *) javaVM;
void *runtime = javaVMExt->runtime;
複製程式碼

剩下的事就非常簡單了，我們只需要將Runtime資料結構重新定義一遍，這裡值得注意的是Android各版本Runtime資料結構不一致，所以需要進行區分，這裡以Android 9.0為例。

/**
 * 9.0, GcRoot中成員變數是class型別，所以用int代替GcRoot
 */
struct PartialRuntime90 {
    // 64 bit so that we can share the same asm offsets for both 32 and 64 bits.
    uint64_t callee_save_methods_[kCalleeSaveSize90];
    int pre_allocated_OutOfMemoryError_;
    int pre_allocated_NoClassDefFoundError_;
    void *resolution_method_;
    void *imt_conflict_method_;
    // Unresolved method has the same behavior as the conflict method, it is used by the class linker
    // for differentiating between unfilled imt slots vs conflict slots in superclasses.
    void *imt_unimplemented_method_;
 
    // Special sentinel object used to invalid conditions in JNI (cleared weak references) and
    // JDWP (invalid references).
    int sentinel_;
 
    InstructionSet instruction_set_;
    QuickMethodFrameInfo callee_save_method_frame_infos_[kCalleeSaveSize90]; // QuickMethodFrameInfo = uint32_t * 3
 
    void *compiler_callbacks_;
    bool is_zygote_;
    bool must_relocate_;
    bool is_concurrent_gc_enabled_;
    bool is_explicit_gc_disabled_;
    bool dex2oat_enabled_;
    bool image_dex2oat_enabled_;
 
    std::string compiler_executable_;
    std::string patchoat_executable_;
    std::vector<std::string> compiler_options_;
    std::vector<std::string> image_compiler_options_;
    std::string image_location_;
 
    std::string boot_class_path_string_;
    std::string class_path_string_;
    std::vector<std::string> properties_;
};
複製程式碼

注意，尤其需要注意內部佈局中存在對齊問題，即一、結構體變數中成員的偏移量必須是成員大小的整數倍（0被認為是任何數的整數倍）二、結構體大小必須是所有成員大小的整數倍。

所以我們必須完整的定義原資料結構，不能存在偏移。否則結構體地址就會錯亂。

之後將runtime強制轉換為PartialRuntime90*即可

PartialRuntime90 *partialRuntime = (PartialRuntime90 *) runtime;
複製程式碼

拿到PartialRuntime90之後，直接修改該資料結構中的image_dex2oat_enabled_即可完成禁用

partialRuntime->image_dex2oat_enabled_ = false
複製程式碼

不過這整個流程需要注意幾個問題，通過相容性測試報告反饋來看，存在瞭如下幾個問題 1、Android 5.1-Android 9.0相容性極好 2、Android 5.0存在部分產商自定義該資料結構，加入了成員導致image_dex2oat_enabled_向後偏移4位元組，又或是部分產商Android 5.0使用了Android 5.1的資料結構導致。 3、部分x86的PAD執行arm的APP，此種場景十分特殊，因此我們選擇無視此種機型，不處理 4、考慮校驗性問題，需要使用一個變數校驗我們是否定址正確，進行適當降級操作，我們選擇以指令集變數instruction_set_作為參考。它是一個列舉變數，正常取值範圍為int 型別 1-7，如果該值不滿足，我們選擇不處理，避免不必要的crash問題。 5、一旦定址失敗，我們選擇使用兜底策略進行重試，直接查詢指令集變數instruction_set_偏移值，轉換為另一個公共的資料結構型別進行操作

這裡貼出Android 5.0-9.0各系統Runtime的資料結構


/**
 * 5.0，GcRoot中成員變數是指標型別，所以用void*代替GcRoot
 */
struct PartialRuntime50 {
    void *callee_save_methods_[kCalleeSaveSize50]; //5.0 5.1 void *
    void *pre_allocated_OutOfMemoryError_;
    void *pre_allocated_NoClassDefFoundError_;
    void *resolution_method_;
    void *imt_conflict_method_;
    void *default_imt_; //5.0 5.1

    InstructionSet instruction_set_;
    QuickMethodFrameInfo callee_save_method_frame_infos_[kCalleeSaveSize50]; // QuickMethodFrameInfo = uint32_t * 3

    void *compiler_callbacks_;
    bool is_zygote_;
    bool must_relocate_;
    bool is_concurrent_gc_enabled_;
    bool is_explicit_gc_disabled_;
    bool dex2oat_enabled_;
    bool image_dex2oat_enabled_;

    std::string compiler_executable_;
    std::string patchoat_executable_;
    std::vector<std::string> compiler_options_;
    std::vector<std::string> image_compiler_options_;
    std::string image_location_;

    std::string boot_class_path_string_;
    std::string class_path_string_;
    std::vector<std::string> properties_;
};

/**
 * 5.1，GcRoot中成員變數是指標型別，所以用void*代替GcRoot
 */
struct PartialRuntime51 {
    void *callee_save_methods_[kCalleeSaveSize50];  //5.0 5.1 void *
    void *pre_allocated_OutOfMemoryError_;
    void *pre_allocated_NoClassDefFoundError_;
    void *resolution_method_;
    void *imt_conflict_method_;
    // Unresolved method has the same behavior as the conflict method, it is used by the class linker
    // for differentiating between unfilled imt slots vs conflict slots in superclasses.
    void *imt_unimplemented_method_;
    void *default_imt_;  //5.0 5.1

    InstructionSet instruction_set_;
    QuickMethodFrameInfo callee_save_method_frame_infos_[kCalleeSaveSize50]; // QuickMethodFrameInfo = uint32_t * 3

    void *compiler_callbacks_;
    bool is_zygote_;
    bool must_relocate_;
    bool is_concurrent_gc_enabled_;
    bool is_explicit_gc_disabled_;
    bool dex2oat_enabled_;
    bool image_dex2oat_enabled_;

    std::string compiler_executable_;
    std::string patchoat_executable_;
    std::vector<std::string> compiler_options_;
    std::vector<std::string> image_compiler_options_;
    std::string image_location_;

    std::string boot_class_path_string_;
    std::string class_path_string_;
    std::vector<std::string> properties_;
};

/**
 * 6.0-7.1，GcRoot中成員變數是class型別，所以用int代替GcRoot
 */
struct PartialRuntime60 {
    // 64 bit so that we can share the same asm offsets for both 32 and 64 bits.
    uint64_t callee_save_methods_[kCalleeSaveSize50];
    int pre_allocated_OutOfMemoryError_;
    int pre_allocated_NoClassDefFoundError_;
    void *resolution_method_;
    void *imt_conflict_method_;
    // Unresolved method has the same behavior as the conflict method, it is used by the class linker
    // for differentiating between unfilled imt slots vs conflict slots in superclasses.
    void *imt_unimplemented_method_;

    // Special sentinel object used to invalid conditions in JNI (cleared weak references) and
    // JDWP (invalid references).
    int sentinel_;

    InstructionSet instruction_set_;
    QuickMethodFrameInfo callee_save_method_frame_infos_[kCalleeSaveSize50]; // QuickMethodFrameInfo = uint32_t * 3

    void *compiler_callbacks_;
    bool is_zygote_;
    bool must_relocate_;
    bool is_concurrent_gc_enabled_;
    bool is_explicit_gc_disabled_;
    bool dex2oat_enabled_;
    bool image_dex2oat_enabled_;

    std::string compiler_executable_;
    std::string patchoat_executable_;
    std::vector<std::string> compiler_options_;
    std::vector<std::string> image_compiler_options_;
    std::string image_location_;

    std::string boot_class_path_string_;
    std::string class_path_string_;
    std::vector<std::string> properties_;
};

/**
 * 8.0-8.1, GcRoot中成員變數是class型別，所以用int代替GcRoot
 */
struct PartialRuntime80 {
    // 64 bit so that we can share the same asm offsets for both 32 and 64 bits.
    uint64_t callee_save_methods_[kCalleeSaveSize80];
    int pre_allocated_OutOfMemoryError_;
    int pre_allocated_NoClassDefFoundError_;
    void *resolution_method_;
    void *imt_conflict_method_;
    // Unresolved method has the same behavior as the conflict method, it is used by the class linker
    // for differentiating between unfilled imt slots vs conflict slots in superclasses.
    void *imt_unimplemented_method_;

    // Special sentinel object used to invalid conditions in JNI (cleared weak references) and
    // JDWP (invalid references).
    int sentinel_;

    InstructionSet instruction_set_;
    QuickMethodFrameInfo callee_save_method_frame_infos_[kCalleeSaveSize80]; // QuickMethodFrameInfo = uint32_t * 3

    void *compiler_callbacks_;
    bool is_zygote_;
    bool must_relocate_;
    bool is_concurrent_gc_enabled_;
    bool is_explicit_gc_disabled_;
    bool dex2oat_enabled_;
    bool image_dex2oat_enabled_;

    std::string compiler_executable_;
    std::string patchoat_executable_;
    std::vector<std::string> compiler_options_;
    std::vector<std::string> image_compiler_options_;
    std::string image_location_;

    std::string boot_class_path_string_;
    std::string class_path_string_;
    std::vector<std::string> properties_;
};

/**
 * 9.0, GcRoot中成員變數是class型別，所以用int代替GcRoot
 */
struct PartialRuntime90 {
    // 64 bit so that we can share the same asm offsets for both 32 and 64 bits.
    uint64_t callee_save_methods_[kCalleeSaveSize90];
    int pre_allocated_OutOfMemoryError_;
    int pre_allocated_NoClassDefFoundError_;
    void *resolution_method_;
    void *imt_conflict_method_;
    // Unresolved method has the same behavior as the conflict method, it is used by the class linker
    // for differentiating between unfilled imt slots vs conflict slots in superclasses.
    void *imt_unimplemented_method_;

    // Special sentinel object used to invalid conditions in JNI (cleared weak references) and
    // JDWP (invalid references).
    int sentinel_;

    InstructionSet instruction_set_;
    QuickMethodFrameInfo callee_save_method_frame_infos_[kCalleeSaveSize90]; // QuickMethodFrameInfo = uint32_t * 3

    void *compiler_callbacks_;
    bool is_zygote_;
    bool must_relocate_;
    bool is_concurrent_gc_enabled_;
    bool is_explicit_gc_disabled_;
    bool dex2oat_enabled_;
    bool image_dex2oat_enabled_;

    std::string compiler_executable_;
    std::string patchoat_executable_;
    std::vector<std::string> compiler_options_;
    std::vector<std::string> image_compiler_options_;
    std::string image_location_;

    std::string boot_class_path_string_;
    std::string class_path_string_;
    std::vector<std::string> properties_;
};
複製程式碼

資料結構轉換完成後，我們需要進行簡單的校驗，只需要找到一個特徵進行校驗，這裡我們校驗指令集變數instruction_set_是否取值正確，該值是一個列舉，正常取值範圍1-7

/**
 * instruction set
 */
enum class InstructionSet {
    kNone,
    kArm,
    kArm64,
    kThumb2,
    kX86,
    kX86_64,
    kMips,
    kMips64,
    kLast,
};

複製程式碼

只要該值不在範圍內，則認為定址失敗

if (partialInstructionSetRuntime->instruction_set_ <= InstructionSet::kNone ||
    partialInstructionSetRuntime->instruction_set_ >= InstructionSet::kLast) {
    return NULL;
}
複製程式碼

定址失敗後，我們通過執行期指令集特徵變數進行重試查詢

在C++中我們可以通過巨集定義，簡單獲取執行期的指令集

#if defined(__arm__)
static constexpr InstructionSet kRuntimeISA = InstructionSet::kArm;
#elif defined(__aarch64__)
static constexpr InstructionSet kRuntimeISA = InstructionSet::kArm64;
#elif defined(__mips__) && !defined(__LP64__)
static constexpr InstructionSet kRuntimeISA = InstructionSet::kMips;
#elif defined(__mips__) && defined(__LP64__)
static constexpr InstructionSet kRuntimeISA = InstructionSet::kMips64;
#elif defined(__i386__)
static constexpr InstructionSet kRuntimeISA = InstructionSet::kX86;
#elif defined(__x86_64__)
static constexpr InstructionSet kRuntimeISA = InstructionSet::kX86_64;
#else
static constexpr InstructionSet kRuntimeISA = InstructionSet::kNone;
#endif
複製程式碼

需要注意的是如果是InstructionSet::kArm，我們需要優先將其轉為成InstructionSet::kThumb2進行查詢。如果C++中的執行期指令集變數查詢失敗，則我們使用Java層獲取的指令集變數進行查詢

在Java中我們通過反射可以獲取執行期指令集

private static Integer currentInstructionSet = null;

enum InstructionSet {
    kNone(0),
    kArm(1),
    kArm64(2),
    kThumb2(3),
    kX86(4),
    kX86_64(5),
    kMips(6),
    kMips64(7),
    kLast(8);

    private int instructionSet;

    InstructionSet(int instructionSet) {
        this.instructionSet = instructionSet;
    }

    public int getInstructionSet() {
        return instructionSet;
    }
}

/**
 * 當前指令集字串，Android 5.0以上支援，以下返回null
 */
private static String getCurrentInstructionSetString() {
    if (Build.VERSION.SDK_INT < 21) {
        return null;
    }
    try {
        Class<?> clazz = Class.forName("dalvik.system.VMRuntime");
        Method currentGet = clazz.getDeclaredMethod("getCurrentInstructionSet");
        return (String) currentGet.invoke(null);
    } catch (Throwable e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * 當前指令集列舉int值，Android 5.0以上支援，以下返回0
 */
private static int getCurrentInstructionSet() {
    if (currentInstructionSet != null) {
        return currentInstructionSet;
    }
    try {
        String invoke = getCurrentInstructionSetString();
        if ("arm".equals(invoke)) {
            currentInstructionSet = InstructionSet.kArm.getInstructionSet();
        } else if ("arm64".equals(invoke)) {
            currentInstructionSet = InstructionSet.kArm64.getInstructionSet();
        } else if ("x86".equals(invoke)) {
            currentInstructionSet = InstructionSet.kX86.getInstructionSet();
        } else if ("x86_64".equals(invoke)) {
            currentInstructionSet = InstructionSet.kX86_64.getInstructionSet();
        } else if ("mips".equals(invoke)) {
            currentInstructionSet = InstructionSet.kMips.getInstructionSet();
        } else if ("mips64".equals(invoke)) {
            currentInstructionSet = InstructionSet.kMips64.getInstructionSet();
        } else if ("none".equals(invoke)) {
            currentInstructionSet = InstructionSet.kNone.getInstructionSet();
        }
    } catch (Throwable e) {
        currentInstructionSet = InstructionSet.kNone.getInstructionSet();
    }
    return currentInstructionSet != null ? currentInstructionSet : InstructionSet.kNone.getInstructionSet();
}   
複製程式碼

在C++和JAVA層獲取到指令集變數的值後，我們通過該變數的值進行定址

template<typename T>
int findOffset(void *start, int regionStart, int regionEnd, T value) {

    if (NULL == start || regionEnd <= 0 || regionStart < 0) {
        return -1;
    }
    char *c_start = (char *) start;

    for (int i = regionStart; i < regionEnd; i += 4) {
        T *current_value = (T *) (c_start + i);
        if (value == *current_value) {
            LOGE("found offset: %d", i);
            return i;
        }
    }
    return -2;
}

//如果是arm則優先使用kThumb2查詢，查詢不到則再使用arm重試
int isa = (int) kRuntimeISA;
int instructionSetOffset = -1;
instructionSetOffset = findOffset(runtime, 0, 100, isa == (int) InstructionSet::kArm
                                                   ? (int) InstructionSet::kThumb2
                                                   : isa);
if (instructionSetOffset < 0 && isa == (int) InstructionSet::kArm) {
    //如果是arm用thumb2查詢失敗，則使用arm重試查詢
    LOGE("retry find offset when thumb2 fail: %d", InstructionSet::kArm);
    instructionSetOffset = findOffset(runtime, 0, 100, InstructionSet::kArm);
}

//如果kRuntimeISA找不到，則使用java層傳入的currentInstructionSet，該值由java層反射獲取到傳入jni函式中
if (instructionSetOffset <= 0) {
    isa = currentInstructionSet;
    LOGE("retry find offset with currentInstructionSet: %d", isa == (int) InstructionSet::kArm
                                                             ? (int) InstructionSet::kThumb2
                                                             : isa);
    instructionSetOffset = findOffset(runtime, 0, 100, isa == (int) InstructionSet::kArm
                                                       ? (int) InstructionSet::kThumb2 : isa);
    if (instructionSetOffset < 0 && isa == (int) InstructionSet::kArm) {
        LOGE("retry find offset with currentInstructionSet when thumb2 fail: %d",
             InstructionSet::kArm);
        //如果是arm用thumb2查詢失敗，則使用arm重試查詢
        instructionSetOffset = findOffset(runtime, 0, 100, InstructionSet::kArm);
    }
    if (instructionSetOffset <= 0) {
        return NULL;
    }
}
複製程式碼

查詢到instructionSetOffset的地址偏移後，通過各系統的資料結構，計算出image_dex2oat_enabled_地址偏移即可，這裡不再詳細說明。

深坑之Xposed

當你覺得一切很美好的時候，一個深坑突然冒了出來，Xposed！由於Xposed執行期對art進行了hook，實際使用的是libxposed_art.so而不是libart.so，並且對應資料結構存在篡改現象，以5.0-6.0篡改的最為惡劣，其專案地址為 github.com/rovo89/andr…

5.0 runtime.h

bool is_recompiling_;
bool is_zygote_;
bool is_minimal_framework_;
bool must_relocate_;
bool is_concurrent_gc_enabled_;
bool is_explicit_gc_disabled_;
bool dex2oat_enabled_;
bool image_dex2oat_enabled_;
複製程式碼

5.1 runtime.h

bool is_recompiling_;
bool is_zygote_;
bool is_minimal_framework_;
bool must_relocate_;
bool is_concurrent_gc_enabled_;
bool is_explicit_gc_disabled_;
bool dex2oat_enabled_;
bool image_dex2oat_enabled_;
複製程式碼

6.0 runtime.h

bool is_zygote_;
bool is_minimal_framework_;
bool must_relocate_;
bool is_concurrent_gc_enabled_;
bool is_explicit_gc_disabled_;
bool dex2oat_enabled_;
bool image_dex2oat_enabled_;
複製程式碼

可以看到，在5.0和5.1上，資料結構多了is_recompiling_和is_minimal_framework_，實際image_dex2oat_enabled_存在向後偏移2位元組的問題；在6.0上，資料結構多了is_minimal_framework_，實際image_dex2oat_enabled_存在向後偏移1位元組的問題；而在Android 7.0及以上，暫時未存在篡改runtime.h的現象。因此可在native層判斷是否存在xposed框架，存在則手動校準偏移值。

判斷是否存在xposed函式如下

static bool initedXposedInstalled = false;
static bool xposedInstalled = false;
/**
 * xposed是否安裝
 * /system/framework/XposedBridge.jar
 * /data/data/de.robv.android.xposed.installer/bin/XposedBridge.jar
 */
bool isXposedInstalled() {
    if (initedXposedInstalled) {
        return xposedInstalled;
    }
    if (!initedXposedInstalled) {
        char *classPath = getenv("CLASSPATH");
        if (classPath == NULL) {
            xposedInstalled = false;
            initedXposedInstalled = true;
            return false;
        }
        char *subString = strstr(classPath, "XposedBridge.jar");
        xposedInstalled = subString != NULL;
        initedXposedInstalled = true;
        return xposedInstalled;
    }
    return xposedInstalled;
}
複製程式碼

然後進行偏移校準，這裡也不再細說。

相容性

做到了如上的幾步之後，其實相容性是相當不錯了，通過testin的相容性測試可以看出，基本已經覆蓋常見機型，但是由於testin的相容性只能覆蓋testin上約50%左右的機型，剩餘50%機型無法覆蓋到，因此我選擇了人肉遠端真機除錯，覆蓋剩餘50%機型，經過驗證後，對testin上99%+的機型都是支援的，且同時支援32位和64位動態庫，在相容性方面，已經遠遠超越Atlas。

在相容性測試中，發現一部分機型runtime資料結構存在篡改問題，進一步驗證了Atlas為什麼修改image_dex2oat_enabled_變數而不是修改dex2oat_enabled_變數，因為dex2oat_enabled_可能存在向後偏移一位元組的問題(甚至是2位元組，如xposed和一加9.0.2比較新的系統就存在2位元組偏移)，導致定址錯誤，修改的其實是其原來的地址（即現有真實地址的前一個位元組），導致禁用失敗。而通過修改image_dex2oat_enabled_變數，即使dex2oat_enabled_向後偏移一位元組，由於修改的是image_dex2oat_enabled_，所以實際修改的其實就是dex2oat_enabled_現在偏移後的地址，實際上還是達到了禁用的效果。這裡有點繞，可以細細品味一下。這個操作，可以相容大部分機型。

這裡貼出一部分資料結構存在偏移的機型。

題外話 Dalvik上dex2opt加速

在art上首次載入外掛，會通過禁用dex2oat達到加速效果，那麼在dalvik上首次載入外掛，其實也存在類似的問題，dalvik上是通過dexopt進行dex的優化操作，這個操作，也是比較耗時的，因此在dalvik上，需要一種類似於dex2oat的方式來達到禁用dex2opt的效果。經過驗證後，發現Atlas是通過禁用verify達到一定的加速，因此我們只需要禁用class verify即可。

原始碼以Android 4.4.4進行分析，見 android.googlesource.com/platform/da…

在Java層我們載入一個Dex是通過DexFile.loadDex()方法進行載入。此方法最終會走到native方法 openDexFileNative，Android 4.4.4的原始碼如下

android.googlesource.com/platform/da…

最終會呼叫到dvmRawDexFileOpen或者dvmJarFileOpen

這兩個方法，最終都會先查詢快取檔案是否存在，如果不存在，最終都會呼叫到dvmOptimizeDexFile函式，見：

android.googlesource.com/platform/da…

而dvmOptimizeDexFile函式開頭有這麼一段邏輯

bool dvmOptimizeDexFile(int fd, off_t dexOffset, long dexLength,
    const char* fileName, u4 modWhen, u4 crc, bool isBootstrap)
{
    const char* lastPart = strrchr(fileName, '/');
    if (lastPart != NULL)
        lastPart++;
    else
        lastPart = fileName;
    ALOGD("DexOpt: --- BEGIN '%s' (bootstrap=%d) ---", lastPart, isBootstrap);
    pid_t pid;
    /*
     * This could happen if something in our bootclasspath, which we thought
     * was all optimized, got rejected.
     */
    //關鍵程式碼
    if (gDvm.optimizing) {
        ALOGW("Rejecting recursive optimization attempt on '%s'", fileName);
        return false;
    }
    //此處省略n行程式碼
}
複製程式碼

也就是說gDvm.optimizing的值為true的時候，直接被return了，因此我們只需要修改此值為true，即可達到禁用dexopt的目的，但是當設此值為true時，那所有dexopt操作都會發生IOException，導致類載入失敗，存在crash風險，所以不能修改此值，看來只能修改class verify為不校驗了，沒有其他好的方法。事實證明，去掉這一步校驗可以節約至少1倍的時間。

此外發現部分4.2.2和4.4.4存在資料結構偏移問題，可通過幾個特徵資料結構進行重試，重新定位關鍵資料結構進行重試。這裡我們通過 dexOptMode，classVerifyMode，registerMapMode，executionMode四個特徵變數的取值範圍進行重試定位，有興趣自行研究一下，不再細說。

通過檢視原始碼發現gDvm是匯出的，見 android.googlesource.com/platform/da…

extern struct DvmGlobals gDvm;
複製程式碼

因此我們只需要藉助dlopen和dlsym拿到整個DvmGlobals資料結構的起始地址，修改對應的變數的值即可。不過不幸的是，Android 4.0-4.4這個資料結構各版本都不大一致，需要判斷版本進行適配操作。這裡以Android 4.4為例。

首先使用dlopen和dlsym獲得對應匯出符號表地址

void *dvm_handle = dlopen("libdvm.so", RTLD_LAZY);
dlerror();//清空錯誤資訊
if (dvm_handle == NULL) {
    return;
}
void *symbol = dlsym(dvm_handle, "gDvm");
const char *error = dlerror();
if (error != NULL) {
    dlclose(dvm_handle);
    return;
}
if (symbol == NULL) {
    LOGE("can't get symbol.");
    dlclose(dvm_handle);
    return;
}
DvmGlobals44 *dvmGlobals = (DvmGlobals44 *) symbol;
複製程式碼

然後直接修改classVerifyMode的值即可

dvmGlobals->classVerifyMode = DexClassVerifyMode::VERIFY_MODE_NONE;
複製程式碼

至此，就完成了dexopt的禁用class verify操作，可以看到，整個邏輯和art上禁用dex2oat十分相似，只需要找到一個變數，修改它即可。

值得注意的是，這裡有很多機型，存在部分資料結構向後偏移的問題，因此，這裡得通過幾個特徵資料結構進行定位，從而得到目標資料結構，這裡採用的資料結構為

struct DvmGlobalsRetry {
    DexOptimizerMode *dexOptMode;
    DexClassVerifyMode *classVerifyMode;
    RegisterMapMode *registerMapMode;
    ExecutionMode *executionMode;
    /*
     * VM init management.
     */
    bool *initializing;
    bool *optimizing;
};
複製程式碼

我們通過變數的範圍值，優先找到DexOptimizerMode和DexClassVerifyMode的偏移值，然後從DexClassVerifyMode之後找到RegisterMapMode的偏移值，從RegisterMapMode之後找到ExecutionMode的偏移值，最終得到classVerifyMode的偏移值，經過驗證，該方法99%+能得到正確的偏移值，從而進行重試。

部分異常機型資料結構偏移如下

思考：是否AOSP中間某一個版本存在資料結構偏移? 通過檢視AOSP原始碼發現並沒有類似偏移，因此不得而知為什麼這些Android 4.2.2中dexOptMode向後偏移4位元組，Android 4.4.4中dexOptMode向後偏移16位元組。偏移值是如此驚人的一致，因此可能的確存在一個git提交，該提交中DvmGlobals資料結構剛好存在如上偏移導致。

Android 4.0-Android 4.4.4，除個別機型偏移值無法計算出來之外，以及dlsym無法獲取匯出符號表（基本都是X86的PAD），這兩種case不予支援，其餘testin上4.0-4.4機型全部覆蓋，相容性幾乎100%（部分偏移值錯誤可通過4個特徵資料結構進行定位，最終得到正確的偏移值）

總結

至此，完成了art上dex2oat禁用達到加速以及dalvik上dex2opt禁用class verify達到加速。

作者簡介

李樟取，@WeiDian，2016年加入微店，目前主要負責微店App的基礎支撐開發工作。

Android ART dex2oat 載入加速淺析

前言

逆向日誌分析

正向原始碼分析

原理與實現

深坑之Xposed

相容性

題外話 Dalvik上dex2opt加速

總結

作者簡介

Android ART dex2oat 載入加速淺析

Android屬性allowBackup安全風險淺析

Android異步載入全解析之開篇瞎扯淡

android非硬件加速繪制簡單流程

Android異步載入學習筆記之四：利用緩存優化網絡載入圖片及ListView載入優化

Android ART runtime簡述

Android art模式 androidruntime

解決Android的Webview載入頁面空白問題

Android Hook框架adbi原始碼淺析（二）

Android Hook框架adbi原始碼淺析（一）

Android把Glide載入的圖片變為圓形頭像

Launcher3 Workspace載入流程淺析(基於Aosp P版本)

Android使用Glide載入https連結的圖片不顯示的原因

Android開發 - ImageView載入Base64編碼的圖片

Android apk動態載入機制的研究（二）資源載入和activity生命週期管理

Android中ViewPager載入空白

Android Studio 3.1 加速編譯速度

Android 使用ArrayAdapter 載入Bean資料

完美解決Android的WebView載入失敗（404，500），顯示的自定義檢視

Android ListView 與 RecyclerView 對比淺析--快取機制[轉]

Android ART dex2oat 載入加速淺析

前言

逆向日誌分析

正向原始碼分析

原理與實現

深坑之Xposed

相容性

題外話 Dalvik上dex2opt加速

總結

作者簡介

相關推薦