この記事ではAndroid端末で対象のアプリが使っているNative APIやJava APIをフックして、任意の処理を差し込む方法を解説します。
おことわり
本記事は純粋に技術的好奇心を満たすためのものであり、悪意ある行為を推奨するものではありません。
目的
- 対象プロセス(VictimApp)がNDK内で利用している
std::randをフックして任意の値を返すようにする。 - 対象プロセス(VictimApp)のandroid.app.ActivityThread(AndroidのPrivate API)をフックし、任意の処理を差し込む。
用意するもの
- ARM系のrootedな端末(本記事で利用したのは rootedなAndroid 5.1.1端末)
- Android Studio 3.0.1
- ADB, Android SDK/NDK
Androidをroot化する方法や、各種開発環境のセットアップは本記事では割愛します。
作るもの
- 任意の処理を含むライブラリ (本記事では
libhooker.so) - 対象プロセス上で任意の処理を実行するための実行バイナリ (本記事では
inject) - 任意のJava Classを含むAPK (本記事ではhookerAppの
app-debug.apk)
本記事で引用しているソースコードは以下にあります。
APIフックを実行するアプリ
APIフックの犠牲となるアプリ
APIフックの手法(概要)
対象プロセスで任意の処理を実行するために、まず実行したい関数を持つライブラリを作成します。( libhooker.so )
次に、ライブラリを対象プロセスにインジェクトするための実行バイナリ( inject )を作成します。
このライブラリインジェクトの手順はNative APIフックとJava APIフックのどちらも共通です。
Native APIフックの概要
- ライブラリインジェクト (インジェクト用プロセス/Native World)
- ptraceを利用し、対象プロセスにフック用ライブラリを読み込ませる。
- その後ライブラリ内の自前の関数(フック用関数)を対象プロセス上で実行する。
- 手順2. Native APIフック (対象プロセス/Native World)
- 対象プロセス上で改めて任意ライブラリを読み込み、メモリ上に展開(dlopen)する。
- そのライブラリに含まれる関数と、置き換えたいNative APIを置換する。
Java APIフックの概要
- ライブラリインジェクト (インジェクト用プロセス/Native World)
- ptraceを利用し、対象プロセスにフック用ライブラリを読み込ませる。
- その後ライブラリ内の自前の関数(フック用関数)を対象プロセス上で実行する。
- Java Classインジェクト (対象プロセス/Native World)
- 対象プロセス上のJNIEnv経由で、フック用のAPKをclassLoaderに読み込ませる。
- そのAPKに含まれる関数を、対象プロセス上で実行する。
- Java APIフック (対象プロセス/Java World)
- リフレクションを利用し、Private APIを任意の処理に置換する。
Native APIフックの手法解説
手順1. 実行したい関数を持つライブラリを作成
まず始めに、対象プロセスにインジェクトしたいライブラリを作成します。
hooker.c (抜粋)
hooker.c(抜粋)
// placeholder
int (*old_rand)() = NULL;
// 置き換える関数
int new_rand() {
return 99;
}
/**
* std::randを置き換える
* @param new_rand 置き換え関数のアドレス
* @param old_rand プレースホルダー
* @return
*/
int hook_rand(uint32_t new_rand, uint32_t *old_rand) {
if (registerInlineHook((uint32_t) rand, new_rand, &old_rand) != ELE7EN_OK) {
LOGD("Failed registerInlineHook\n");
return 1;
}
if (inlineHook((uint32_t) rand) != ELE7EN_OK) {
LOGD("Failed inlineHook\n");
return 2;
}
return 0;
}
/**
* inject関数からinject_remote_processで呼び出される
* @param so_file_path
* @return
*/
int hook_entry(char *so_file_path) {
LOGD("Hook success, pid = %d\n", getpid());
void *hooker = dlopen(so_file_path, RTLD_NOW);
uint32_t new_rand_pointer = (uint32_t) dlsym(hooker, "new_rand");
uint32_t *old_rand_pointer = (uint32_t *) dlsym(hooker, "old_rand");
LOGD("Hook result = %d\n", hook_rand(new_rand_pointer, old_rand_pointer));
return 0;
}
インジェクトするライブラリは、実行するためのエントリポイントを用意しておきます。(ここでは hook_entry)
このライブラリは、実行時にptraceによって一時的に対象プロセスにロードされ、実行が終わったらアンロードされます。
そのため、関数アドレスの置き換えなどのように恒久的に変化させておきたい場合は、上記例のように関数内で改めてdlopenを用いて
ライブラリをロードします。
（このようにしないと、hook_entry を抜けた後に置き換えた関数アドレスが不正なものになってしまう。）
この例で使っている inlineHook は https://github.com/ele7enxxh/Android-Inline-Hook を利用させてもらいました。
ARMプロセッサのレジスタを書き換え、対象関数を置き換えるということをしています。
手順2. ライブラリを対象プロセスにインジェクトする実行ファイルの作成
inject.c
inject.c
#include <string.h>
#include <dlfcn.h>
#include <sys/mman.h>
#include "process_util.h"
#include "ptrace_util.h"
#define FUNCTION_NAME_ADDR_OFFSET 0x100
#define FUNCTION_OFFSET 0x100
const char *libc_path = "/system/lib/libc.so";
const char *linker_path = "/system/bin/linker";
/**
* 指定されたプロセスに対してsoファイルをinjectし、そのプロセス上で関数を実行する。
*
* @param target_pid: 対象プロセスのPID
* @param library_path: injectしたいsoファイルのパス
* @param function_name: 実行したいsoファイル内の関数
* @param program_args: 上記関数に渡す引数
*/
int inject_remote_process(pid_t target_pid, const char *library_path,
const char *function_name, uint32_t param_count,
const char **program_args) {
LOGD("start injecting process< %d > \n", target_pid);
// 1. プロセスにアタッチする
if (ptrace_attach(target_pid) < 0) {
LOGD("attach error");
return -1;
}
// 2. 対象プロセスのレジスタを取得し、保持しておく。
struct pt_regs regs, original_regs;
if (ptrace_getregs(target_pid, ®s) < 0) {
LOGD("getregs error");
return -1;
}
memcpy(&original_regs, ®s, sizeof(regs));
// 3. 対象プロセスのmmap関数のアドレスを取得
unsigned int target_mmap_addr = (unsigned int) get_remote_func_address(target_pid, libc_path, (void *) mmap);
LOGD("target mmap address: %x\n", target_mmap_addr);
// 4. 対象プロセスのmmap関数を使ってメモリを割り当てる
// mmapの引数 see: https://linuxjm.osdn.jp/html/LDP_man-pages/man2/mmap.2.html
// void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
long parameters[6];
parameters[0] = 0; // addr
parameters[1] = 0x400; // length
parameters[2] = PROT_READ | PROT_WRITE | PROT_EXEC; // prot
parameters[3] = MAP_ANONYMOUS | MAP_PRIVATE; // flags
parameters[4] = 0; // fd
parameters[5] = 0; // offset
if (ptrace_call_wrapper(target_pid, "mmap", target_mmap_addr, parameters, 6, ®s) < 0) {
LOGD("call target mmap error");
return -1;
}
// mmap関数の実行結果取得 (mmap() は成功するとマップされた領域へのポインターを返す。)
uint8_t *target_mmap_base = ptrace_retval(®s);
LOGD("target_mmap_base: %x\n", target_mmap_base);
// 5. 対象プロセスの、dlopen関数のインジェクトを行う
// 関数プロトタイプ：void *dlopen(const char *filename, int flag);
// 対象プロセスのdlopen関数のアドレスを取得する
void *target_dlopen_addr = get_remote_func_address(target_pid, linker_path, (void *) dlopen);
LOGD("target dlopen address: %x\n", target_dlopen_addr);
// mmapで割り当てられたアドレスにInjectしたいライブラリパスを書き込む
ptrace_writedata(target_pid, target_mmap_base, library_path, strlen(library_path) + 1);
// dlopen用パラメータ設定
parameters[0] = target_mmap_base; // filename: library_path
parameters[1] = RTLD_NOW | RTLD_GLOBAL; // flag: 要解決、シンボルをグローバル公開
// 対象プロセス上でdlopenを実行
if (ptrace_call_wrapper(target_pid, "dlopen", target_dlopen_addr, parameters, 2, ®s) < 0) {
LOGD("call target dlopen error");
return -1;
}
// dlopenの実行結果取得 (dlopen() は成功するとライブラリのハンドルを返す。)
void *target_so_handle = ptrace_retval(®s);
// 6. dlsym関数により、ライブラリ内の対象関数のアドレスをインジェクトする。
// 関数プロトタイプ：void *dlsym(void *handle, const char *symbol);
// 対象プロセスのdlsym関数のアドレスを取得する
void *target_dlsym_addr = get_remote_func_address(target_pid, linker_path, (void *) dlsym);
LOGD("target dlsym address: %x\n", target_dlsym_addr);
// 実行したい関数名をメモリに書き込む
ptrace_writedata(target_pid, target_mmap_base + FUNCTION_NAME_ADDR_OFFSET, function_name,
strlen(function_name) + 1);
parameters[0] = target_so_handle; // handle: 対象ライブラリのハンドル
parameters[1] = target_mmap_base + FUNCTION_NAME_ADDR_OFFSET; // symbol: 関数名
// 対象プログラム上でdlsymを実行
if (ptrace_call_wrapper(target_pid, "dlsym", target_dlsym_addr, parameters, 2, ®s) < 0) {
LOGD("call target dlsym error");
return -1;
}
// dlsymの実行結果取得 (dlsym() は成功すると指定されたシンボルのアドレスを返す。)
void *hook_func_addr = ptrace_retval(®s);
LOGD("target %s address: %x\n", function_name, target_dlsym_addr);
// 7. 対象関数を呼び出す
// 関数が必要とするパラメータをメモリに書き込む
for (uint32_t i = 0; i < param_count; ++i) {
ptrace_writedata(target_pid,
target_mmap_base + FUNCTION_OFFSET * (2 + i),
(const uint8_t *) program_args[i],
strlen(program_args[i]) + 1);
parameters[i] = target_mmap_base + FUNCTION_OFFSET * (2 + i);
}
// 対象プログラム上で対象関数を実行
if (ptrace_call_wrapper(target_pid, function_name, hook_func_addr, parameters, param_count, ®s) < 0) {
LOGD("call target %s error", function_name);
return -1;
}
// 8. dlclose関数を呼び出す
// 関数プロトタイプ: int dlclose(void *handle);
void *target_dlclose_addr = get_remote_func_address(target_pid, linker_path, (void *) dlclose);
parameters[0] = target_so_handle; // 対象ライブラリのハンドル
// 対象プログラム上でdlcloseを実行
if (ptrace_call_wrapper(target_pid, "dlclose", target_dlclose_addr, parameters, 1, ®s) < -1) {
LOGD("call target dlclose error");
return -1;
}
// 9. 元々のレジスタを復元する
ptrace_setregs(target_pid, &original_regs);
// 10. 対象プロセスからデタッチ
ptrace_detach(target_pid);
return 0;
}
int main(int argc, char **argv) {
char * target_process_name = argv[1];
char * so_file_path = argv[2];
char * method_name = argv[3];
uint32_t param_count = (uint32_t) atoi(argv[4]);
pid_t target_pid;
target_pid = find_pid_of(target_process_name);
if (-1 == target_pid) {
LOGD("Can't find the process\n");
return -1;
}
char * program_args[param_count];
for (uint32_t i = 0; i < (argc - 5) && i < param_count; ++i) {
program_args[i] = argv[5 + i];
}
inject_remote_process(target_pid,
so_file_path,
method_name,
param_count,
(const char **) program_args
);
return 0;
}
本プログラムの引数は以下の通りです。
- argv[1] : インジェクトの犠牲対象となるプロセスの名前
- argv[2] : インジェクトしたいsoファイルのパス
- argv[3] : インジェクトしたいsoファイル内の関数名
- argv[4] : 関数が受取る引数の個数
- argv[5]以降 : 関数が受取る引数(char *)
任意ライブラリのインジェクトおよびインジェクトしたライブラリ内の関数の実行は以下の流れになります。
- PTRACE_ATTACHで、対象プロセスにアタッチする
- PTRACE_GETREGSで、対象プロセスのARMプロセッサレジスタを取得する
- 対象プロセスのmmap関数のアドレスを取得する
- 対象プロセス上でmmapを実行しメモリを確保する
- 対象プロセスのdlopen関数のアドレスを取得し、対象プロセスにインジェクトしたいライブラリをロードする
- 対象プロセスのdlsym関数のアドレスを取得し、対象プロセス上の実行したい関数のシンボルを検索してアドレスを取得する
- 対象プロセス上でインジェクトしたライブラリ内の関数を実行する
- 対象プロセスのdlclose関数のアドレスを取得し、対象プロセスからインジェクトしたライブラリをアンロードする
- PTRACE_SETREGSで、2で取得したレジスタを書き戻す
- PTRACE_DETACHで、対象プロセスからデタッチする
手順3. インジェクト実行ファイルの実行
手順2で作成した inject を端末上で直接実行するか、アプリを通じて実行すると対象プロセスにインジェクトすることができます。
直接実行の例)
※「/data/data/net.cimadai.hooker_app/files」以下に inject を配置しておく
PC>$ adb shell
Android>$ su
Android># cd /data/data/net.cimadai.hooker_app/files
Android># ./inject \
net.cimadai.victim_app \
/data/data/net.cimadai.hooker_app/lib/libhooker.so \
hook_entry \
1 \
/data/data/net.cimadai.hooker_app/lib/libhooker.so
アプリから実行する例)
MainActivity.java (抜粋)
MainActivity.java(抜粋)
public class MainActivity extends AppCompatActivity {
final String TAG = HookTool.TAG;
final String TargetApp = "net.cimadai.victim_app";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final File execFile = new File(MainActivity.this.getFilesDir()+"/inject");
final File soFile = new File(MainActivity.this.getFilesDir().getParentFile().getPath() + "/lib/libhooker.so");
// injectはassetsに入れているので、filesディレクトリに書き出す。
try {
String folder = "armeabi-v7a";
AssetManager assetManager = getAssets();
InputStream in = assetManager.open(folder + "/" + "inject");
OutputStream out = this.openFileOutput("inject", MODE_PRIVATE);
byte[] buff = new byte[1024];
long size = 0;
int nRead;
while ((nRead = in.read(buff)) != -1) {
out.write(buff, 0, nRead);
size += nRead;
}
out.flush();
out.close();
Boolean ret = execFile.setExecutable(true);
Log.d(TAG, String.format("Exec path: %s %b", execFile.getAbsolutePath(), ret));
} catch (IOException e) {
Toast.makeText(MainActivity.this, "Failed to extract injector!", Toast.LENGTH_SHORT).show();
}
// Targetアプリのstd::randをフックする
Button hookApi = (Button) findViewById(R.id.hook_api);
hookApi.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Log.d(TAG, "HookApi onclick");
final String method = "hook_entry";
String[] cmd = new String[] {
"su",
"-c",
execFile.getAbsolutePath(), // inject
TargetApp, // target process
soFile.getAbsolutePath(), // inject so path
method, // method name
"1", // param count
soFile.getAbsolutePath() // param
};
runCommand(method, cmd);
}
});
}
void runCommand(String label, String[] cmd) {
Process p;
try {
p = Runtime.getRuntime().exec(cmd);
p.waitFor();
if (p.exitValue() == 0) {
toastMessage("Succeeded to " + label);
} else {
toastMessage("Failed to " + label);
}
} catch (InterruptedException | IOException e) {
e.printStackTrace();
toastMessage("Failed to " + label);
}
}
}
アプリから実行する場合は、inject をAPK内のassetsに含めておき、アプリ内でfilesディレクトリに展開して利用します。
assetsに配置するための設定は以下のCMakeLists.txtで行います。
CMakeLists.txt
CMakeLists.txt
cmake_minimum_required(VERSION 3.4.1)
# 実行ファイルの出力先をassetsにする。
set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/src/main/assets/${ANDROID_ABI}")
# インジェクト用ライブラリ(libhooker.so)の定義
add_library( hooker
SHARED
src/main/cpp/hooker.c
src/main/cpp/relocate.c
src/main/cpp/inline_hook.c
src/main/cpp/invoke_dex_method.c
)
# インジェクト実行ファイル(inject)の定義
add_executable(inject
src/main/cpp/ptrace_util.c
src/main/cpp/process_util.c
src/main/cpp/inject.c
)
# リンクするライブラリ
find_library( log-lib log )
# リンク設定
target_link_libraries( hooker ${log-lib} )
target_link_libraries( inject ${log-lib} )
また、実行時にsupersuなどの確認ダイアログがポップアップしますので許可をしてください。
実行結果
以下のように、対象プロセスにライブラリファイルをインジェクトし、std::randをフックすることができます。
? D/INJECT: start injecting process< 19876 >
? D/INJECT: target mmap address: b6e458f9
? D/INJECT: Calling [mmap] in target process <19876>
? D/INJECT: Target process returned from mmap, return value=af87a000, pc=0
? D/INJECT: target_mmap_base: af87a000
? D/INJECT: target dlopen address: b6faaf65
? D/INJECT: Calling [dlopen] in target process <19876>
? D/INJECT: Target process returned from dlopen, return value=b0ecfbd4, pc=0
? D/INJECT: target dlsym address: b6faaf6d
? D/INJECT: Calling [dlsym] in target process <19876>
? D/INJECT: Target process returned from dlsym, return value=af4c4fe9, pc=0
? D/INJECT: target hook_entry address: b6faaf6d
? D/INJECT: Calling [hook_entry] in target process <19876>
victim_app D/INJECT: Hook success, pid = 19876
victim_app D/INJECT: Hook result = 0
? D/INJECT: Target process returned from hook_entry, return value=0, pc=0
? D/INJECT: Calling [dlclose] in target process <19876>
? D/INJECT: Target process returned from dlclose, return value=0, pc=0
左: std::randそのまま。 右: std::randをフックして99を返している。
Java APIフックの手法解説
Java APIのフックは、Native APIのフックと違いJavaの世界で作業を行う必要があります。
Native APIフックとの違いは、以下の２点です。
- APK(またはDEX)ファイルからインジェクトするクラスをロードする。
- インジェクトしたクラス内で既存のAndroidの処理を書き換える。
対象プロセスにライブラリをインジェクトし、任意の処理を実行するinject のコードは同じものを利用します。
APK(またはDEX)ファイルからインジェクトするクラスをロードする
hooker.c (抜粋)
hooker.c
/**
* APKのメソッドをインジェクトして実行する
* @param apkPath インジェクトしたいAPK(DEX)
* @param cachePath 対象プロセスが書き込み権限を持つディレクトリ
* @param className APK内の実行したいクラス名
* @param methodName クラス内の実行したいメソッド名
* @return
*/
int inject_entry(char * apkPath, char * cachePath, char * className, char * methodName) {
LOGD("Start inject entry: %s, %s, %s, %s\n", apkPath, cachePath, className, methodName);
int ret = invoke_dex_method(apkPath, cachePath, className, methodName, 0, NULL);
LOGD("APK inject result = %d\n", ret);
return 0;
}
invoke_dex_method.c
invoke_dex_method.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <jni.h>
#include <dlfcn.h>
#include "log_util.h"
JNIEnv* (*getJNIEnv)();
/**
* DEXファイルをインジェクトし、メソッドを実行する。
* @param dexPath インジェクトするdexファイル
* @param dexOptDir キャッシュパス。対象アプリ・対象プロセスの書き込み権限に注意。
* @param className インジェクト後に実行したいクラス名
* @param methodName 実行したいメソッド名
* @param argc 引数の数
* @param argv 引数
* @return
*/
int invoke_dex_method(const char* dexPath, const char* dexOptDir, const char* className, const char* methodName, int argc, char *argv[]) {
LOGD("dexPath = %s, dexOptDir = %s, className = %s, methodName = %s\n", dexPath, dexOptDir, className, methodName);
// JNIEnvの取得
void* handle = dlopen("/system/lib/libandroid_runtime.so", RTLD_NOW);
getJNIEnv = dlsym(handle, "_ZN7android14AndroidRuntime9getJNIEnvEv");
JNIEnv* env = getJNIEnv();
LOGD("JNIEnv = %x\n", env);
// ClassLoaderのgetSystemClassLoaderを呼び出し、現在のプロセスのClassLoaderを取得
jclass classloaderClass = (*env)->FindClass(env,"java/lang/ClassLoader");
jmethodID getsysloaderMethod = (*env)->GetStaticMethodID(env,classloaderClass, "getSystemClassLoader", "()Ljava/lang/ClassLoader;");
jobject loader = (*env)->CallStaticObjectMethod(env, classloaderClass, getsysloaderMethod);
LOGD("loader = %x\n", loader);
// 現在のClassLoaderで処理するために、DexClassLoaderでdexファイルを読み込む
jstring dexpath = (*env)->NewStringUTF(env, dexPath);
jstring dex_odex_path = (*env)->NewStringUTF(env,dexOptDir);
jclass dexLoaderClass = (*env)->FindClass(env,"dalvik/system/DexClassLoader");
jmethodID initDexLoaderMethod = (*env)->GetMethodID(env, dexLoaderClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/ClassLoader;)V");
jobject dexLoader = (*env)->NewObject(env, dexLoaderClass, initDexLoaderMethod,dexpath,dex_odex_path,NULL,loader);
LOGD("dexLoader = %x\n", dexLoader);
// DexClassLoaderを使って実行するコードを読み込む
jmethodID findclassMethod = (*env)->GetMethodID(env,dexLoaderClass,"findClass","(Ljava/lang/String;)Ljava/lang/Class;");
jstring javaClassName = (*env)->NewStringUTF(env,className);
jclass javaClientClass = (*env)->CallObjectMethod(env,dexLoader,findclassMethod,javaClassName);
if (!javaClientClass) {
LOGD("Failed to load target class %s\n", className);
printf("Failed to load target class %s\n", className);
return -1;
}
// インジェクトするメソッドを取得する
jmethodID start_inject_method = (*env)->GetStaticMethodID(env, javaClientClass, methodName, "()V");
if (!start_inject_method) {
LOGD("Failed to load target method %s\n", methodName);
printf("Failed to load target method %s\n", methodName);
return -1;
}
// メソッドを実行 (このメソッドはpublic static voidなメソッドである必要がある。)
(*env)->CallStaticVoidMethod(env,javaClientClass,start_inject_method);
return 0;
}
hooker.c に新たにinject_entry関数を追加します。
この関数では、渡された引数をもとに対象プロセスに対してJavaのメソッドをインジェクトして実行します。
インジェクトしたクラス内で既存のAndroidの処理を書き換える。
次に、インジェクトされるクラスとメソッドを作成していきます。
HookTool.java
HookTool.java
package net.cimadai.hookerApp;
import android.annotation.SuppressLint;
import android.os.Handler;
import android.util.Log;
import java.lang.reflect.Field;
public class HookTool {
public static final String TAG = "INJECT";
public static void dexInject() throws ClassNotFoundException, IllegalAccessException {
Log.d(TAG, "This is dex code. Start hooking process in Java world.");
try {
// PrivateなActivityThreadをフックする。
// see: http://androidxref.com/5.1.1_r6/xref/frameworks/base/core/java/android/app/ActivityThread.java#sCurrentActivityThread
@SuppressLint("PrivateApi") Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
Field currentActivityThreadField = activityThreadClass.getDeclaredField("sCurrentActivityThread");
currentActivityThreadField.setAccessible(true);
Object currentActivityThread = currentActivityThreadField.get(null);
Field mHField = activityThreadClass.getDeclaredField("mH");
mHField.setAccessible(true);
Handler mH = (Handler) mHField.get(currentActivityThread);
Field mCallbackField = Handler.class.getDeclaredField("mCallback");
mCallbackField.setAccessible(true);
Handler.Callback oriCallback = (Handler.Callback) mCallbackField.get(mH);
Handler.Callback hookCallBack = new HookCallback(oriCallback);
mCallbackField.set(mH, hookCallBack);
} catch (IllegalArgumentException | NoSuchFieldException e) {
e.printStackTrace();
Log.d(TAG, "Failed to hook in Java world.");
}
}
}
HookCallback.java
HookCallback.java
package net.cimadai.hookerApp;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
/**
* ActivityThread内の`mH: Handle`内のmCallbackをフックするクラス
* http://androidxref.com/5.1.1_r6/xref/frameworks/base/core/java/android/os/Handler.java
* コンストラクタで元々のコールバックを渡す。
*/
public class HookCallback implements Handler.Callback {
private final String TAG = HookTool.TAG;
public static final int RESUME_ACTIVITY = 107;
public static final int PAUSE_ACTIVITY = 101;
private Handler.Callback mParentCallback;
public HookCallback(Handler.Callback parentCallback){
mParentCallback = parentCallback;
}
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case RESUME_ACTIVITY:
Log.d(TAG, "Hook activity resume!!!");
break;
case PAUSE_ACTIVITY:
Log.d(TAG, "Hook activity pause!!!");
break;
default:
Log.d(TAG, "Hook a " + msg.what);
break;
}
if (mParentCallback != null){
return mParentCallback.handleMessage(msg);
}else{
return false;
}
}
}
これらのクラスを作成し、Android Studioのメニューの Build -> Build APK(s) でビルドします。
出来た app-debug.apk を端末上にpushし、read権限を付与しておきます。
この状態で、injectを端末上で直接実行するか、アプリを通じて実行すると対象プロセスにHookTool.javaおよびをHookCallback.javaをインジェクトすることができます。
直接実行の例)
※「/data/data/net.cimadai.hooker_app/files」以下に inject 、 app-debug.apk を配置しておく。
PC>$ adb shell
Android>$ su
Android># cd /data/data/net.cimadai.hooker_app/files
Android># ll
root@C5503:/data/data/net.cimadai.hooker_app/files # ll
-rwxrwxrwx root sdcard_r 1635546 2017-12-31 23:45 app-debug.apk
-rwxrw---- u0_a264 u0_a264 55492 2018-01-01 18:47 inject
Android># ./inject \
net.cimadai.victim_app \
/data/data/net.cimadai.hooker_app/lib/libhooker.so \
inject_entry \
4 \
/data/data/net.cimadai.hooker_app/files/app-debug.apk \
/data/data/net.cimadai.victim_app/cache \
net/cimadai/hookerApp/HookTool \
dexInject
アプリから実行する例)
MainActivity.java (抜粋)
MainActivity.java
public class MainActivity extends AppCompatActivity {
final String TAG = HookTool.TAG;
final String TargetApp = "net.cimadai.victim_app";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// ...
// TargetアプリのコアコードのActivityThreadをフックする
Button injectDex = (Button) findViewById(R.id.inject_dex);
injectDex.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Log.d(TAG, "InjectDex onclick");
if (apkFile.exists() && apkFile.canRead()) {
final String method = "inject_entry";
String[] cmd = new String[] {
"su",
"-c",
execFile.getAbsolutePath(), // inject
TargetApp, // target process
soFile.getAbsolutePath(), // inject so path
method, // method name
"4", // param count
apkFile.getAbsolutePath(), // param 1 (inject dex file path)
cacheDir.getAbsolutePath(), // param 2 (cache dir)
"net/cimadai/hookerApp/HookTool", // param 3 (inject class)
"dexInject" // param 4 (inject method)
};
Log.d(TAG, apkFile.getAbsolutePath());
Log.d(TAG, cacheDir.getAbsolutePath());
runCommand(method, cmd);
} else {
if (!apkFile.exists()) {
toastMessage("There is no app-debug.apk or not.");
}
if (!apkFile.canRead()) {
toastMessage("The app-debug.apk is not readable.");
}
}
}
});
}
// ...
}
実行結果
以下のように、対象プロセスにクラスをインジェクトし、Activityのライフサイクルに処理を挟み込むことができます。
この例ではログ出力を追加していますので、対象プロセスをバックグラウンドにしたりフォアグラウンドにすることでログが出力されます。
victim_app D/INJECT: Hook activity pause!!!
victim_app D/INJECT: Hook a 104
victim_app D/INJECT: Hook a 140
victim_app D/INJECT: Hook activity resume!!!
victim_app D/INJECT: Hook a 149
まとめ
本記事ではARM SoCを持つ対象と端末上で動作する任意のプロセスに任意のライブラリをインジェクトして任意の関数を実行する方法と、そのプロセス内の処理を自在に変更する方法を解説しました。
このような手法により自身のアプリの処理を書き換えられてしまう可能性もありますので、
Androidでメモリ改ざん攻撃やデバッグのためのptraceを防ぐことができる開発者向けのセキュリティサービスを利用するのが良いでしょう。