早期學習寫殼代碼

原創 Ericky_ 2018-08-30 00:09

早期自己弄的一些東西，大牛繞過。
入門寫殼的同學可以參考看看。
效果如下：
這裏寫圖片描述
Java 層：

package com.droider.crackme0201;


import java.lang.String;
import android.app.Application;
import android.content.Context;
import android.content.res.Configuration;

public class TestApplication extends Application {
    static{
        System.loadLibrary("Nothing");

    }

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        ErickyGuard(base);
        ErickyProtect(base);

    }


    public native void ErickyGuard(Context context);
    public native Object ErickyProtect(Context context);

}

C層：

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <jni.h>
#include <android/log.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/types.h>
#include <elf.h>
#include <sys/mman.h>
#include <assert.h>
#define DEBUG
#define   LOG_TAG    "LOG_TEST"
#define   LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define   LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
// 獲取數組的大小
# define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))
// 指定要註冊的類，對應完整的java類名
#define JNIREG_CLASS "com/droider/crackme0201/TestApplication"
//Function  Statements

jstring   CharTojstring(JNIEnv*   env,   char*   str);
jobject invokeStaticMethodss (JNIEnv *env,jstring class_name, jstring method_name, jobjectArray pareTyple, jobjectArray pareVaules);
jobject   getFieldOjbect(JNIEnv *env,       jstring class_name, jobject obj, jstring fieldName);
void     setFieldOjbect(JNIEnv *env, jstring class_name, jstring fieldName, jobject obj, jobject filedVaule);
void        guard( JNIEnv* env,jobject thiz,jobject context );
JNIEXPORT jobject JNICALL sub_2222( JNIEnv* env,
                                                  jobject thiz,jobject context )

{

    jclass native_clazz = env->GetObjectClass(context);
    jmethodID methodID_func = env->GetMethodID(native_clazz,"getPackageName", "()Ljava/lang/String;");
    jstring packagename =(jstring)(env->CallObjectMethod(context, methodID_func));
    //**************************************
    char *aa="android.app.ActivityThread", *bb = "currentActivityThread";
    jstring jaa= CharTojstring(env,aa);
    jstring jbb = CharTojstring(env,bb);
    jobjectArray pareTyple;
    jobjectArray pareVaules;
    jobject currentActivityThread = invokeStaticMethodss(env,jaa,jbb,pareTyple,pareVaules );
    char *cc="android.app.ActivityThread", *dd = "mPackages";
    jstring jcc= CharTojstring(env,cc);
    jstring jdd = CharTojstring(env,dd);
            jclass class_hashmap=env->FindClass("java/util/HashMap");
            jmethodID hashmap_construct_method=env->GetMethodID(class_hashmap, "<init>","()V");
            jobject obj_hashmap =env->NewObject(class_hashmap, hashmap_construct_method, "");
            obj_hashmap = getFieldOjbect(env,jcc, currentActivityThread,jdd);
       // new一个WeakReference对象java.lang.ref.WeakReference   get_get_obj ==wr.get();
            jclass class_WeakReference=env->FindClass("java/lang/ref/WeakReference");
            if(class_WeakReference==NULL){
                LOGI("class_WeakReference Not Found ");

            }
            jmethodID WeakReference_get_method=env->GetMethodID(class_WeakReference, "get","()Ljava/lang/Object;");
            if(WeakReference_get_method==NULL){
                            LOGI("WeakReference_get_method Not Found ");

                        }
            jmethodID get_func = env->GetMethodID(class_hashmap,"get","(Ljava/lang/Object;)Ljava/lang/Object;");
            if(get_func==NULL){
                                    LOGI("get_func Not Found ");
            }
            jobject get_obj =env->CallObjectMethod(obj_hashmap, get_func,packagename);
            if(get_obj==NULL){
                                                LOGI("get_obj Not Found ");
            }
            jobject get_get_obj = env->CallObjectMethod(get_obj, WeakReference_get_method);
            if(get_get_obj==NULL){
                                                            LOGI("get_get_obj Not Found ");
             }
            //Strings prepared
            const char *str = env->GetStringUTFChars(packagename, 0);
            char parameter1[128];
            char parameter2[128];
            char parameter3[128];
            const char *qz ="/data/data/", *hz1 = "/.cache/classdex.jar" ,*hz2 = "/.cache",*hz3 = "/.cache/";
            strcpy(parameter1, qz);
            strcat(parameter1, str);
            strcat(parameter1, hz1);
            strcpy(parameter2, qz);
            strcat(parameter2, str);
            strcat(parameter2, hz2);
            strcpy(parameter3, qz);
            strcat(parameter3, str);
            strcat(parameter3, hz3);
            env->ReleaseStringUTFChars(packagename, str);
            jstring jparameter1 = CharTojstring(env,parameter1);
            jstring jparameter2 = CharTojstring(env,parameter2);
            jstring jparameter3 = CharTojstring(env,parameter3);
            char *loadapk = "android.app.LoadedApk",*mClassLoader = "mClassLoader";
            jstring jloadapk= CharTojstring(env,loadapk);
            jstring jmClassLoader = CharTojstring(env,mClassLoader);
            jclass class_DexClassloader=env->FindClass("dalvik/system/DexClassLoader");
            if(class_DexClassloader==NULL){
                        LOGI("class_DexClassloader Not Found ");
                     }
            jmethodID DexClassloader_construct_method=env->GetMethodID(class_DexClassloader, "<init>","(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/ClassLoader;)V");
            if(DexClassloader_construct_method==NULL){
                                                                    LOGI("DexClassloader_construct_method Not Found ");
                     }
            jobject obj_DexClassloader =env->NewObject(class_DexClassloader, DexClassloader_construct_method,jparameter1,jparameter2,jparameter3,getFieldOjbect(env,jloadapk,get_get_obj,jmClassLoader));
            if(obj_DexClassloader==NULL){
                                                                    LOGI("obj_DexClassloader Not Found ");
             }
            setFieldOjbect(env,jloadapk,jmClassLoader,get_get_obj, obj_DexClassloader);

            return get_get_obj;
}
JNIEXPORT void JNICALL sub_1111( JNIEnv* env,
                                                  jobject thiz,jobject context )
{
    guard(env,thiz,context );
}

// Java和JNI函數的綁定表
static JNINativeMethod method_table[] = {
    { "ErickyProtect", "(Landroid/content/Context;)Ljava/lang/Object;", (void*)sub_2222 },//綁定Ericky3
    { "ErickyGuard", "(Landroid/content/Context;)V", (void*)sub_1111 },//Ericky1
};
// 註冊native方法到java中
static int registerNativeMethods(JNIEnv* env, const char* className,
        JNINativeMethod* gMethods, int numMethods)
{
    jclass clazz;
    clazz = env->FindClass( className);
    if (clazz == NULL) {
        return JNI_FALSE;
    }
    if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
        return JNI_FALSE;
    }

    return JNI_TRUE;
}

int register_ndk_load(JNIEnv *env)
{
    // 調用註冊方法
    return registerNativeMethods(env, JNIREG_CLASS,
            method_table, NELEM(method_table));
}

JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
    JNIEnv* env = NULL;
    jint result = -1;

    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        return result;
    }

    register_ndk_load(env);

    // 返回jni的版本
    return JNI_VERSION_1_4;
}
//Copy fuctions and initial fuctions
void guard( JNIEnv* env,jobject thiz,jobject context )
{
            jclass native_clazz = env->GetObjectClass(context);
            jmethodID methodID_func = env->GetMethodID(native_clazz,"getPackageName", "()Ljava/lang/String;");
            jstring packagename =(jstring)(env->CallObjectMethod(context, methodID_func));
                const char *str = env->GetStringUTFChars(packagename, 0);
                char destination[128];
                const char *blank ="/data/data/", *c = "/.cache/";
                strcpy(destination, blank);
                strcat(destination, str);
                strcat(destination, c);
                LOGI("stringcccccccccccccccc %s",destination);//去字符串s%

                env->ReleaseStringUTFChars(packagename, str);
                jint a = mkdir(destination,777);

                LOGI("Created a file in android! %d",a);//去字符串s%
                const char *pre = "chmod 755 ";
                char cmd[128];
                strcpy(cmd, pre);
                strcat(cmd, destination);
                LOGI("cmd %s",cmd);//去字符串s%
                jstring jcmd = CharTojstring(env,cmd);

            //exec
                jclass Runtime = env->FindClass("java/lang/Runtime");
                jmethodID Runtime_func = env->GetStaticMethodID(Runtime,"getRuntime","()Ljava/lang/Runtime;");
                jobject class_obj = env->CallStaticObjectMethod(Runtime, Runtime_func);
                jclass class_java = env->GetObjectClass(class_obj);

                jmethodID exec_func = env->GetMethodID(class_java,"exec","(Ljava/lang/String;)Ljava/lang/Process;");
                jobject method_obj =env->CallObjectMethod(class_obj, exec_func,jcmd);
                jclass class_method_obj= env->GetObjectClass(method_obj);

                jmethodID waitfor_func = env->GetMethodID(class_method_obj,"waitFor","()I");
                jint result = env->CallIntMethod(method_obj,waitfor_func);

                LOGI("CallIntMethod %d",result);//去字符串s%
    //***************************************************************************************Copy fuctions
                //************************despath
                    // 获得 Context 类
                    jclass native_clazz2 = env->GetObjectClass(context);
                    jmethodID methodID_func2 = env->GetMethodID(native_clazz2,"getPackageName", "()Ljava/lang/String;");
                    jstring packagename2 =(jstring)(env->CallObjectMethod(context, methodID_func2));
                    const char *str2 = env->GetStringUTFChars(packagename2, 0);
                    char destination2[128];
                    const char *blank2 ="/data/data/", *c2 = "/.cache/classdex.jar";
                    strcpy(destination2, blank2);
                    strcat(destination2, str2);
                    strcat(destination2, c2);
                    LOGI("string %s",destination2);
                    LOGI("log test ok ");
                    env->ReleaseStringUTFChars(packagename2, str2);
                    jstring jdestination = CharTojstring(env,destination2);
                    jmethodID methodID_getApplicationInfo = env->GetMethodID(native_clazz2,"getApplicationInfo", "()Landroid/content/pm/ApplicationInfo;");
                    jobject ApplicationInfo =env->CallObjectMethod(context, methodID_getApplicationInfo);
                    jclass cls_ApplicationInfo=env->GetObjectClass(ApplicationInfo);

                    jfieldID JarFieldId = env->GetFieldID(cls_ApplicationInfo,"publicSourceDir", "Ljava/lang/String;");

                    jstring SourceDir =(jstring)(env->GetObjectField(ApplicationInfo,JarFieldId));
                        const char *strs = env->GetStringUTFChars(SourceDir, 0);
                        char destinations[128];
                        strcpy(destinations, strs);
                        jbyteArray bytes = env->NewByteArray(65536);
                        LOGI("HAHAHAHHAHAHAHA %s",destinations);//
                        env->ReleaseStringUTFChars(SourceDir, strs);
                        LOGI("HAHAHAHHAHAHAHA222222222222222“");
                        //initial strings
                        char *classdex_jar2="assets/ErickyProtect.so";//包裏的文件
                        jstring jclassdex_jar = CharTojstring(env,classdex_jar2);
                        ////////////new JarFile
                        jclass cls_JarFile = env->FindClass("java/util/jar/JarFile");
                        jmethodID methodID_JarFile = env->GetMethodID(cls_JarFile,"<init>", "(Ljava/lang/String;)V");
                    jobject localJarFile = env->NewObject(cls_JarFile, methodID_JarFile,SourceDir);

                        //localjarFile getEntry method
                        jmethodID methodID_getentry = env->GetMethodID(cls_JarFile,"getEntry", "(Ljava/lang/String;)Ljava/util/zip/ZipEntry;");
                        jobject LocalZipEntry = env->CallObjectMethod(localJarFile,methodID_getentry,jclassdex_jar);
                        //localjarFile getInputStream method
                        jmethodID methodID_getInputStream = env->GetMethodID(cls_JarFile,"getInputStream", "(Ljava/util/zip/ZipEntry;)Ljava/io/InputStream;");
                        jobject BufferinputstreamParam = env->CallObjectMethod(localJarFile,methodID_getInputStream,LocalZipEntry);

                        //new a File class
                        jclass cls_File = env->FindClass("java/io/File");
                        jmethodID methodID_File = env->GetMethodID(cls_File,"<init>", "(Ljava/lang/String;)V");
                        jobject localFile = env->NewObject(cls_File, methodID_File,jdestination);

                        //new  BufferedInputStream
                        jclass cls_BufferedInputStream = env->FindClass("java/io/BufferedInputStream");
                        jmethodID methodID_BufferedInputStream = env->GetMethodID(cls_BufferedInputStream,"<init>", "(Ljava/io/InputStream;)V");
                        jobject localBufferedInputStream = env->NewObject(cls_BufferedInputStream, methodID_BufferedInputStream,BufferinputstreamParam);
                        //new FileoutputStream

                        jclass cls_FileOutputStream = env->FindClass("java/io/FileOutputStream");
                        jmethodID methodID_FileOutputStream= env->GetMethodID(cls_FileOutputStream,"<init>", "(Ljava/io/File;)V");
                        jobject BufferoutputstreamParam = env->NewObject(cls_FileOutputStream, methodID_FileOutputStream,localFile);

                        //new BufferedOutputStream
                        jclass cls_BufferedOutputStream = env->FindClass("java/io/BufferedOutputStream");
                        jmethodID methodID_BufferedOutputStream = env->GetMethodID(cls_BufferedOutputStream,"<init>", "(Ljava/io/OutputStream;)V");
                        jobject localBufferedOutputStream = env->NewObject(cls_BufferedOutputStream, methodID_BufferedOutputStream,BufferoutputstreamParam);
                        //some preparations
                        jmethodID methodID_write = env->GetMethodID(cls_BufferedOutputStream,"write", "([BII)V");
                        jmethodID methodID_read = env->GetMethodID(cls_BufferedInputStream,"read", "([B)I");
                        jmethodID output_flush = env->GetMethodID(cls_BufferedOutputStream,"flush", "()V");
                        jmethodID output_close = env->GetMethodID(cls_BufferedOutputStream,"close", "()V");
                        jmethodID input_close = env->GetMethodID(cls_BufferedInputStream,"close", "()V");

                        while(true){
                            jint i =env->CallIntMethod(localBufferedInputStream,methodID_read,bytes);
                            LOGI("IIIIIIIIII %d",i);
                            if (i <= 0){
                                env->CallVoidMethod(localBufferedOutputStream,output_flush);
                                env->CallVoidMethod(localBufferedOutputStream,output_close);
                                env->CallVoidMethod(localBufferedInputStream,input_close);
                                return;
                            }
                            env->CallVoidMethod(localBufferedOutputStream,methodID_write,bytes,0,i);
                            LOGI("afterwrite %d",i);

                        }

}
jstring   CharTojstring(JNIEnv*   env,   char*   str)
{
    jsize   len   =   strlen(str);

    jclass   clsstring   =   env->FindClass("java/lang/String");
    jstring   strencode   =   env->NewStringUTF("GB2312");

    jmethodID   mid   =   env->GetMethodID(clsstring,   "<init>",   "([BLjava/lang/String;)V");
    jbyteArray   barr   =   env-> NewByteArray(len);

    env-> SetByteArrayRegion(barr,0,len,(jbyte*)str);
    return (jstring)env-> NewObject(clsstring,mid,barr,strencode);
}
jobject   getFieldOjbect(JNIEnv *env,
        jstring class_name, jobject obj, jstring fieldName)
{
            jclass context = env->FindClass("java/lang/Class");
            jmethodID forName_func = env->GetStaticMethodID(context,"forName","(Ljava/lang/String;)Ljava/lang/Class;");
            jobject class_obj = env->CallStaticObjectMethod(context, forName_func,class_name);
            jclass class_java = env->GetObjectClass(class_obj);

            jmethodID getField_func = env->GetMethodID(class_java,"getDeclaredField","(Ljava/lang/String;)Ljava/lang/reflect/Field;");
            jobject method_obj =env->CallObjectMethod(class_obj, getField_func,fieldName);
            jclass class_method_obj= env->GetObjectClass(method_obj);

            jmethodID setaccess_func = env->GetMethodID(class_method_obj,"setAccessible","(Z)V");
            env->CallVoidMethod(method_obj,setaccess_func,true);

            jmethodID get_func = env->GetMethodID(class_method_obj,"get","(Ljava/lang/Object;)Ljava/lang/Object;");
            jobject get_obj =env->CallObjectMethod(method_obj,get_func,obj);

            env->DeleteLocalRef(class_java);
            env->DeleteLocalRef(method_obj);
            return get_obj;

}
jobject  invokeStaticMethodss (JNIEnv *env,jstring class_name, jstring method_name, jobjectArray pareTyple, jobjectArray pareVaules)
{
        jclass context = env->FindClass("java/lang/Class");
        jmethodID forName_func = env->GetStaticMethodID(context,"forName","(Ljava/lang/String;)Ljava/lang/Class;");
        jobject class_obj = env->CallStaticObjectMethod(context, forName_func,class_name);
        jclass class_java = env->GetObjectClass(class_obj);

        jmethodID getMethod_func = env->GetMethodID(class_java,"getMethod","(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;");
        jobject method_obj =env->CallObjectMethod(class_obj, getMethod_func,method_name,pareTyple);
        jclass class_method_obj= env->GetObjectClass(method_obj);

        jmethodID invoke_func = env->GetMethodID(class_method_obj,"invoke","(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;");
        jobject invoke_obj =env->CallObjectMethod(method_obj,invoke_func,NULL,pareVaules);
        env->DeleteLocalRef(class_java);
        env->DeleteLocalRef(method_obj);
        return invoke_obj;
}
void     setFieldOjbect(JNIEnv *env, jstring class_name, jstring fieldName, jobject obj, jobject filedVaule)

{
                jclass context = env->FindClass("java/lang/Class");
                jmethodID forName_func = env->GetStaticMethodID(context,"forName","(Ljava/lang/String;)Ljava/lang/Class;");
                jobject class_obj = env->CallStaticObjectMethod(context, forName_func,class_name);
                jclass class_java = env->GetObjectClass(class_obj);

                jmethodID getField_func = env->GetMethodID(class_java,"getDeclaredField","(Ljava/lang/String;)Ljava/lang/reflect/Field;");
                jobject method_obj =env->CallObjectMethod(class_obj, getField_func,fieldName);
                jclass class_method_obj= env->GetObjectClass(method_obj);

                jmethodID setaccess_func = env->GetMethodID(class_method_obj,"setAccessible","(Z)V");
                env->CallVoidMethod(method_obj,setaccess_func,true);

                jmethodID set_func = env->GetMethodID(class_method_obj,"set","(Ljava/lang/Object;Ljava/lang/Object;)V");
                env->CallVoidMethod(method_obj,set_func,obj,filedVaule);

                env->DeleteLocalRef(class_java);
                env->DeleteLocalRef(method_obj);



}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Android代碼混淆，就這麼簡單

前言 在這個乞丐都精通C++的時代，我們的代碼安全實在是不敢保證，爲了保護我們的代碼不被牛逼的乞丐篡改，代碼混淆還是必須的。大多數人還是認爲代碼混淆是很複雜的事情，我自己也這麼認爲。。。 看完這篇博客，也許就會發現，其實沒那麼難

Maybe_ren 2020-07-08 12:37:11

利用rxjava實現監聽EditView裏的文字在規定時間間隔不變後進行聯想搜索

當EditView輸入的內容變化停止幾秒鐘之後再去後進行搜索， debounce：防抖 當一個事件發送出來之後，在約定時間內沒有再次發送這個事件，則發射這個事件，如果再次觸發了，則重新計算時間。 switchMap :當源Observ

丶咿呀咿呀 2020-07-08 12:20:52

在虛擬機中安裝android apk

第一步：下載並解壓android SDK到自己硬盤上。第二步：在系統環境變量中增加系統變量SDK_ROOT，並讓它指向android SDK安裝目錄之下的tools文件夾。第三步：在cmd命令狀態下進入android SDK安裝目錄之下的

shaochengand 2020-07-08 11:56:57

Android studio 升級後項目出錯

升級完android studio運行項目出現以下錯誤 Default interface methods are only supported starting with Android N (--min-api 24): void a

mr.rui 2020-07-08 11:51:59

Android應對進程被殺死--Service（二）

Service組件在android開發中經常遇到，其經常作爲後臺服務，需要始終保持運行，負責處理一些必要（見不得人）的任務。而一些安全軟件，如360等，會有結束進程的功能，如果不做Service的保持，就會被其殺掉。 在早些時

lyl953147712 2020-07-08 11:46:59

Windows Running “flutter pub get“ in XXX卡死

Running “flutter pub get” in XXX卡死的主要原因是因爲網絡訪問問題，我們可以通過設置FlutterIO.cn來規避，具體操作如下： 右鍵我的電腦->屬性->高級系統設置->環境變量，添加環境變量，

小海编码日记 2020-07-08 12:40:51

Android操作Exif-ExifInterface全解析

簡介： Exif是一種圖像文件格式，它的數據存儲與JPEG格式是完全相同的。實際上Exif格式就是在JPEG格式頭部插入了數碼照片的信息，包括拍攝時的光圈、快門、白平衡、ISO、焦距、日期時間等各種和拍攝條件以及相機品牌、型號、色

Maybe_ren 2020-07-08 12:37:11

selinux-實現

實現 SELinux SELinux 設爲了“默認拒絕”模式，也就是說，對於在內核中存在鉤子的每一次訪問，都必須獲得政策的明確許可。這意味着政策文件中包含規則、類型、類、權限等方面的大量信息。關於 SELinux 的完整注意事項不在

vrix 2020-07-08 12:37:00

selinux-概覽

Android 中的安全增強型 Linux 簡介 Android 安全模型部分基於應用沙盒的概念。每個應用都在自己的沙盒內運行。在 Android 4.3 之前的版本中，這些沙盒是通過爲每個應用創建獨一無二的 Linux UID

vrix 2020-07-08 12:37:00

selinux-驗證

驗證 SELinux Android 強烈建議原始設備製造商 (OEM) 全面測試其 SELinux 實現。製造商在實現 SELinux 時，應先爲設備上需要測試的所有內容應用新政策。 應用新政策後，可以通過執行 getenfor

vrix 2020-07-08 12:37:00

Android受限廣播(protected-broadcast)

在閱讀Android源碼Telephony模塊時，發現在AndroidManifest.xml文件裏聲明瞭大量的protected-broadcast： <protected-broadcast android:name="andr

vrix 2020-07-08 12:37:00

selinux-自定義

自定義 SELinux 集成這一基本級別的功能並全面分析結果後，您可以添加自己的政策設置，以便涵蓋自己對 Android 操作系統進行的自定義。當然，這些政策仍必須要滿足 Android 兼容性計劃的要求，並且不會移除默認的 SEL

vrix 2020-07-08 12:37:00

在Android端實現基於OPENGL ES 的深度學習前向傳播框架

github項目地址 首先感謝夕陽嘆大神提供的思路，大家先可以去https://blog.csdn.net/jxt1234and2010/article/details/71056736看看，基本把實現的流程都說了一遍，我照着思路實現了一

koibiki 2020-07-08 12:23:30

Desire rom - build kernel

  參考:http://code.google.com/p/androidteam/wiki/AndroidKernelCompileAndRun     交叉編譯器下載:    git clone git://android.git.k

dkyang 2020-07-08 12:22:51

Android 使用mina框架 搭建socket客戶端，進行與服務器端通信

注意： 在設置編碼過濾的時候 一定要注意 服務器端和客戶端的編碼要一致 mina框架解釋 簡單理解就是 ：封裝了底層的讀寫流操作，提供高級操作API的通訊框架 當前發行的 MINA 版本支持基於Java NIO 技術的 T

lyl953147712 2020-07-08 11:46:59