0. LOG 打印
首先：Android.mk 中添加 llog
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_LDLIBS += -llog
LOCAL_MODULE := demo
LOCAL_SRC_FILES := demo.c
include $(BUILD_SHARED_LIBRARY)
再：
include <android/log.h>
然后:
__android_log_print(ANDROID_LOG_INFO,"Wooo","--------1--------");
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,TAG,__VA_ARGS__)
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,TAG,__VA_ARGS__)
調用：
LOGI("gMethods %s,%s,%p\n ",gMethods[0].name,gMethods[0].signature,gMethods[0].fnPtr);
1. 聲明
導入
#include <jni.h>
#include <android/log.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include "mycommom.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#include "packer.h"
#include <jni.h>
#include <dlfcn.h>
#include <android/log.h>
#include <errno.h>
#include <assert.h>
#include <sys/system_properties.h>
#include <string>
#include <cstdlib>
#include <sys/stat.h>
#include <sys/types.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <vector>
#include <bits/unique_ptr.h>
基本類型
jclass myLoadedApk; // 聲明類
jfieldID LoadedApk_mClassLoader; // 聲明 FieldID
jmethodID Application_onCreate; // 聲明 MethodID
jint sdk_int; // 聲明 int
jobject mObj; // 聲明 Object
JNINativeMethod *dvm_dalvik_system_DexFile; // 聲明本地方法
JValue* pResult； // 聲明的序列化
還有基本類型：
jbyte、jboolean、jchar、jshort、jint、jlong、jfloat、jdouble
void 標識無類型
對應的數組類型有：
jstring、jobjectArray、jbooleanArray、jbyteArray、jcharArray、jshortArray、jintArray、jlongArray、jfloatArray、jdoubleArray、jthrowable
以上類型對應的 smali 及對應的簽名:
char[] [C
float[] [F
double[] [D
long[] [J
String[] [Ljava/lang/String;
Object[] [Ljava/lang/Object;
剩余的簽名：
boolean Z
short S
byte B
int I
void V
函數示例：
int fun1() 對應簽名()I
int fun1(int i) 對應簽名(I)I
2. JNINativeMethod 聲明
這個對應這是一個結構體：
typedef struct {
const char* name;
const char* signature;
void* fnPtr;
} JNINativeMethod;
第一個變量name是Java中函數的名字。
第二個變量signature，用字符串是描述了函數的參數和返回值 （(II)V）
第三個變量fnPtr是函數指針，指向C函數。
- 示例一（這個是自己聲明的本地方法）：
void native_attachContextBaseContext(JNIEnv *env, jclass clazz,jobject ctx);
void native_onCreate(JNIEnv *env, jclass clazz);
static JNINativeMethod method_table[] = {
{ "attachBaseContext", "(Landroid/content/Context;)V", (void*)native_attachContextBaseContext}, // 聲明本地方法，在類前面聲明
{ "onCreate","()V",(void*)native_onCreate}, // 觀察三個參數
};
以上返回的是 method_table 數組，元素是 JNINativeMethod
- 示例二（這里是調用第三方的 so 文件里的函數）：
void (*openDexFile)(const u4* args,union JValue* pResult); // 聲明方法類型，JValue 序列化聲明
void *ldvm = (void*) dlopen("libdvm.so", 1); // 這個通過 dlopen 是找到 so 文件
JNINativeMethod* dvm_dalvik_system_DexFile = (JNINativeMethod*) dlsym(ldvm,"dvm_dalvik_system_DexFile"); // 這個是通過 dlsym 找到方法指針
if(0 == lookup(dvm_dalvik_system_DexFile, "openDexFile", "([B)I", &openDexFile)) // lookup 函數尋找函數，并賦予到 openDexFile 指針
{
openDexFile = NULL;
LOGI("method does not found ");
return ;
}
else
{
LOGI("openDexFile method found ! HAVE_BIG_ENDIAN");
}
char* dexbase = (char*)mmap(0, dexLen, 3, 2, handle, 0); // mmap 映射，handle 為文件描述符
char* arr;
arr=(char*)malloc(16+dexLen);
ArrayObject *ao=(ArrayObject*)arr;
ao->length=dexLen;
memcpy(arr+16,dexbase,dexLen);
munmap(dexbase, dexLen); // 內存映射解除
u4 args[] = { (u4) ao };
union JValue pResult; // 聲明傳入參數
jint result; // 返回值
if(openDexFile != NULL)
{
openDexFile(args,&pResult); // 函數調用
result = (jint) pResult.l; // 獲取返回值
}
int lookup(JNINativeMethod *table, const char *name, const char *sig,void (**fnPtrout)(u4 const *, union JValue *))
{
int i = 0;
while (table[i].name != NULL) // 這個方法名字不等于 name
{
LOGI("lookup %d %s" ,i,table[i].name);
if ((strcmp(name, table[i].name) == 0)
&& (strcmp(sig, table[i].signature) == 0))
{
*fnPtrout = table[i].fnPtr; // 賦予函數指針
return 1;
}
i++;
}
return 0;
}
3. 方法注冊
首先聲明方法，然后調用函數注冊
JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved); // 在 JNI_OnLoad 內開始注冊
#define JNIREG_CLASS "com/example/unpack/StubApplication" // 聲明類
# define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0]))) // 用于算出方法數組包含參數
JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
JNIEnv* env = 0;
jint result = -1;
if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) { // 從當前運行環境中取出版本字符串，判斷 jni 合法性
return result;
}
int status=register_ndk_load(env);
if(!status)
{
LOGI("register call failed");
}
return JNI_VERSION_1_4;
}
static JNINativeMethod method_table[] = { // 方法數組
{ "attachBaseContext", "(Landroid/content/Context;)V", (void*)native_attachContextBaseContext},
{ "onCreate","()V",(void*)native_onCreate},
};
int register_ndk_load(JNIEnv *env)
{
return registerNativeMethods(env, JNIREG_CLASS, method_table, NELEM(method_table)); // 傳入參數，環境、類名、方法數組、方法數量
}
static int registerNativeMethods(JNIEnv* env, const char* className,JNINativeMethod* gMethods, int numMethods)
{
jclass clazz;
clazz = (*env)->FindClass(env, className);
if (clazz == 0) {
return JNI_FALSE;
}
LOGI("gMethods %s,%s,%p\n ",gMethods[0].name,gMethods[0].signature,gMethods[0].fnPtr);
if ((*env)->RegisterNatives(env, clazz, gMethods, numMethods) < 0) { // 方法注冊
return JNI_FALSE;
}
return JNI_TRUE;
}
4. 尋找類
- 函數調用，返回類對象到 myContextWrapper 指針內
if( !myFindClass(env,&Build_version,"android/os/Build$VERSION"))
{
LOGI("ERROR:Build$VERSION");
return;
}
jfieldID fieldID= ((*env)->GetStaticFieldID)(env, Build_version, "SDK_INT", "I"); // 函數調用，獲取 field
sdk_int=(*env)->GetStaticIntField(env,Build_version,fieldID); // 獲取 version_id
LOGI("sdk_int %d\n",sdk_int);
實現函數：
jclass myFindClass(JNIEnv *env,jclass* ptr,char* name)
{
jobject g_cls_string;
jclass clazz = (*env)->FindClass(env,name);
if(clazz)
{
g_cls_string = (*env)->NewGlobalRef(env,clazz);
*ptr=g_cls_string;
return g_cls_string;
}
else
{
return 0;
}
}
- 根據 object 獲取類
jclass v19 = (*env)->GetObjectClass(env, application_obj); //獲取 application_obj 為類對象
獲取父類
jclass BaseDexClassLoader = env->GetSuperclass(PathClassLoader);新建一個對象
由方法 ID 和 class 對象獲取一個新的 obiect 對象
jstring newapp= (*env)->NewStringUTF(env, "android.app.Application");
jobject findclass_classz = (*env)->CallObjectMethod(env, classLoader,classLoader_findClass, newapp);
jmethodID initMethod = (*env)->GetMethodID(env, findclass_classz, "<init>", "()V");
onCreateObj = (*env)->NewObject(env, findclass_classz, initMethod);
5. 獲取 MethodID 并調用
獲取 MethodID
Application_onCreate = (*env)->GetMethodID(env, myApplication, "onCreate", "()V");
// myApplication 指的是 Application 類，onCreate 方法名， ()V 方法簽名
獲取 StaticMethodID
currentActivityThread = (*env)->GetStaticMethodID(env, ActivityThread,"currentActivityThread","()Landroid/app/ActivityThread;");
// ActivityThread 類，currentActivityThread 方法名， ()Landroid/app/ActivityThread; 方法簽名
調用返回值是 int 類型的函數
int count = (*env)->CallIntMethod(env, v11, arraylist_size);
調用返回值是 Object 類型的靜態函數
jobject tmp= (*env)->CallStaticObjectMethod(env, mySystem, system_getProperty, vmname);
// mySystem 指 java/lang/System 類，system_getProperty 指 getProperty(Ljava/lang/String;)Ljava/lang/String; 方法，vmname 為傳入的字符串參數
調用非靜態函數
jobject v9 = (*env)->CallObjectMethod(env, arraymap_mPackages, ArrayMap_get, thePackagename);
// arraymap_mPackages 為數組，ArrayMap_get 為方法 ID，thePackagename 是 key 值
調用無返回值函數
(*env)->CallNonvirtualVoidMethod(env, application_obj, myContextWrapper, ContextWrapper_attachBaseContext,ctx);
// application_obj 為默認傳入的 obj，myContextWrapper 是 "android/content/ContextWrapper" 類，ContextWrapper_attachBaseContext 是 attachBaseContext(Landroid/content/Context;)V 方法，ctx 是傳入參數
調用無返回值函數
(*env)->CallVoidMethod(env, onCreateObj, Application_onCreate);
// onCreateObj 是 Application 對象，Application_onCreate 是方法 ID
6. 獲取 FieldID 并設置
獲取一個類內的一個變量 FieldID
mPackages=(*env)->GetFieldID(env, ActivityThread, "mPackages", "Landroid/util/ArrayMap;");
// ActivityThread 類對象，mPackages 變量名，Landroid/util/ArrayMap 變量類型、簽名
根據 ID 獲取一個類實例內的變量值
jobject arraymap_mPackages =(*env)->GetObjectField(env, theCurrentActivityThread, mPackages);
// theCurrentActivityThread 為一個類調用方法返回的對象，mPackages 為 FieldID
// theCurrentActivityThread 是一個對象
設置 Field 變量
(*env)->SetObjectField(env, DexFile, mCookie, art_MarCookie);
// DexFile 是要設置到的主體對象， mCookie 是對應的 FieldID（對應 DexFile 內的一個屬性），art_MarCookie 是要設置到 mCookie 的對象。就等同于：DexFile.mCookie.set(art_MarCookie)
示例如下：
DexPathList_Element_dexFile = (*env)->GetFieldID(env,myElement,"dexFile","Ldalvik/system/DexFile;");
jobject Element = (*env)->GetObjectArrayElement(env, v15, i);
jobject DexFile = (*env)->GetObjectField(env, Element, DexPathList_Element_dexFile);
mCookie = (*env)->GetFieldID(env,myDexFile, "mCookie", "I");
art_MarCookie=(*env)->CallStaticObjectMethod(env, myDexFile, myOpenDexFile, inPath,0,0);
(*env)->SetObjectField(env, DexFile, mCookie, art_MarCookie);
設置 int
env->SetIntField(mini_dex_obj, cookie_field, mCookie);
7. 字符串處理
格式標準化
jstring thePackagename=(*env)->NewStringUTF(env,mPackageName);
將字符串轉為 char 數組
const char* v22 = (*env)->GetStringUTFChars(env, tmp, 0); // tmp 為字符串
LOGI("------- vmNameStr:%s", v22);
(*env)->ReleaseStringUTFChars(env, tmp, v22); // 函數通知 JVM 這塊內存已經不使用了，你可以清除了
拼接字符串
char szPath[260]={0}; // 申請空間
sprintf(szPath,"/data/data/%s/files/dump.dex",mPackageName); // 字符串輸出為 szPath
// const char* mPackageName; 類型
設置 vm 的 APKPATH
setenv("APKPATH", mPackageResourePath, 1); // mPackageResourePath 為路徑字符串
8. 數組的獲取處理
獲取一個數組的長度
int count = (*env)->GetArrayLength(env, v15);
// v15 是一個數組
遍歷一個數組
while(i<count)
{
jobject Element = (*env)->GetObjectArrayElement(env, v15, i);
}
9. 刪除占用內存
env->DeleteLocalRef(DexFileClass); // DexFileClass 是 jclass
env->DeleteLocalRef(apk); // apk 是 jstring
10. 一些小功能
1. 讀取 maps 獲取信息
char* get_path_frommaps(const char* pkgName,char* filter1,char* filter2)
{
int pid=getpid();
char map[256]={0};
sprintf(map,"/proc/%d/maps",pid);
FILE* fd=fopen(map,"r");
if(!fd){
LOGE("[-]open %s failed",map);
return NULL;
}
while(true){
char line_buffer[256]={0};
if(!fgets(line_buffer,255,fd))
break;
//尋找帶有包名和.dex或.odex的行
if (strstr(line_buffer,pkgName) && (strstr(line_buffer,filter1)|| strstr(line_buffer,filter2))) {
LOGD("[+]targt line buffer:%s",line_buffer);
char* p =strchr(line_buffer,'/');
//獲取需要復制的長度
//line_buffer結尾是一個換行符
int copy_len=strlen(line_buffer)-(p-(char*)line_buffer)-1;
memcpy((void*)g_fake_dex_path,p,copy_len);
LOGD("[+]find dex path:%s from maps",g_fake_dex_path);
return g_fake_dex_path;
}
}
fclose(fd);
return NULL;
}
2. 調用 libart.so 內的方法
{
std::string location = "";
std::string err_msg;
void* g_ArtHandle=NULL;
g_ArtHandle=get_lib_handle("libart.so"); // 獲取 so 句柄
org_artDexFileOpenMemory22 func = (org_artDexFileOpenMemory22)dlsym(g_ArtHandle, "_ZN3art7DexFile10OpenMemoryEPKhjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEjPNS_6MemMapEPKNS_7OatFileEPS9_");
if(!func){
LOGE("[-]sdk_int:%d dlsym openMemory failed:%s",g_sdk_int,dlerror());
return NULL;
}
const Header* dex_header = reinterpret_cast<const Header*>(base);
void *value = func((const unsigned char *)base, size, location, dex_header->checksum_, NULL, NULL, &err_msg); // 方法調用。size 是 dex 的大小
if(!value){
LOGE("[-]call artDexFileOpenMemory22 failed");
return NULL;
}
LOGD("[+]openMemory value:%p",value);
return value;
}
void* get_lib_handle(const char* lib_path)
{
void *handle_art = dlopen(lib_path, RTLD_NOW);
if (!handle_art) {
LOGE("[-]get %s handle failed:%s",dlerror());
return NULL;
}
return handle_art;
}
.h 內聲明方法類型
typedef void* (*org_artDexFileOpenMemory22)(const uint8_t* base, size_t size,const std::string& location, uint32_t location_checksum,void* mem_map, const void*oat_file, std::string* error_msg);
