Android逆向(反调，脱壳，过ssl证书脚本)

于 2024-09-08 20:58:00 发布
阅读量1.5k 收藏 19
点赞数 30
分类专栏： Android逆向 文章标签： android ssl 逆向 frida
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73452266/article/details/142030900
版权

文章目录

总结

暑假做了两个月的Android逆向，记录一下自己学到的东西。对于app渗透有了一些思路。
这两个月主要做的是代码分析，对于分析完后的持久化等没有学习。主要是如何反编译源码，如何找到关键函数。
在这里插入图片描述

基础

Android基础

开始学习Android逆向，需要先掌握一些Android开发常见的知识点：

1、需要了解一个apk的目录架构，什么文件放在什么位置，将apk当作zip解压可以看到xml文件(声明入口，权限，服务等)、lib文件(so文件)、asserts文件等
2、知道一些常见的函数，(请求的url函数，处理json的函数等)，便于后续hook，可以边学边记录，

工具

jadx：反编译工具，得到的java代码较清晰，但是可能会有部分反编译不了
GDA：反编译工具，相对于jadx可能稍微不太好读，但是该工具编译快，且能够直接调用frida，更加方便
frida：编写hook脚本，相对于xpose更加方便调试，但是持久化比xpose麻烦。
模拟器，或者是root的手机。

定位关键代码

在反编译完代码需要的是找到我们需要分析的功能点。

页面activity定位

首先打开我们功能点所在的页面，比如我想查看我的个人记录处的代码逻辑，我就需要打开对应的页面，然后使用下面的命令，查看表层的activity名称，然后去源代码中寻找对应的activity。

查看表层activity的名称
adb shell "dumpsys activity top | grep --color=always ACTIVITY"

在这里插入图片描述

数据包参数定位

找到对应功能的数据包，然后根据里面的参数去代码中搜索
比如：这里我想要找这个app是如何触发升级的，于是我拦截他的数据包，然后看到其中的参数app_version，于是我去代码中搜索app_version，如果太多，也可以换参数vm。
在这里插入图片描述

堆栈追踪

假如我们需要找的功能，调用了一处函数，但是我们又不知道在哪里调用的，这个时候我们可以打印堆栈。frida脚本放结尾。
我们找到了tostring函数，然后打印堆栈发现a方法调用了tostring

============================= 调用堆栈开始 =======================

com.netease.commonupgrade.CommonUpgradeResponse.toString(Native Method)
com.netease.commonupgrade.CommonUpgradeResponse.a(Native Method)
com.netease.commonupgrade.CommonUpgradeImpl.a(SourceFile:114)
com.netease.commonupgrade.CommonUpgradeImpl.a(SourceFile:49)
com.netease.service.pris.v4.CheckUpdateTransaction.a(SourceFile:158)
com.netease.framework.task.AsyncTransaction.run(SourceFile:52)
java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167)
java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641)
java.lang.Thread.run(Thread.java:919)
============================= 调用堆栈结束 ==========================

编写

编写frida脚本，刚开始的时候我们可以多看看其他人的脚本，然后去frida官网查询相关的函数。
对于一些简单的分析，直接用GDA就可以，选中对应的函数，右键hook方法，或者自定义脚本然后将代码复制出来。

//GDA复制的代码可以直接使用：
Java.perform(function() {
	var targetClass='com.netease.commonupgrade.CommonUpgradeResponse';
	var methodName='a';
	var gclass = Java.use(targetClass);
	gclass[methodName].overload('int').implementation = function(arg0) {
		console.log('\nGDA[Hook a(int)]'+'\n\targ0 = '+arg0);
		var i=this[methodName](arg0);
		console.log('\treturn '+i);
		printStack();
		return i;
	}
})

反调

对于反调试，一些常见的手段就是检测相关的特征。

检测文件：检测在/data/local/tmp文件夹下是否存在名称为frida，ida的调试文件等。检测文件的权限是否为x（第二个较少）。
端口检查: 检测常用的调试端口是否打开
ptrace占用： 检测父进程
TracePid：检测调试的变量

常用的绕过手段。

将检测的文件重定向
改名称，端口
将相关代码nop

一些检测的路径。

“/data/data/” + ProName + “/maps”;
“/data/data/” + ProName + “/fmaps”;
“/data/data/” + ProName + “/task”;
“/data/data/” + ProName + “/exe”;
“/data/data/” + ProName + “/mounts”;
"/data/data/ + ProName + /status;

脱壳

这个工具脱壳比较好，一些企业壳也可以脱，如爱加密，360的企业壳。脱的不是完整的但是分析代码已经差不多了。

https://www.52pojie.cn/thread-1781276-1-1.html

踩坑：
1.Android14的手机有问题，读取不到脚本文件
2.一个脚本不行，换其它的试试，(上次虽然是360的壳，但是我没有脱成功，用通用的脚本脱成功了)

好用的脚本

过ssl证书校验抓包

做渗透需要抓包，但是一些app有证书校验，可以采用下面的脚本+burp抓包：
将证书放到脚本里面的路径，然后有反调的需要先过反调


setTimeout(function(){
    Java.perform(function (){
        console.log("");
        console.log("[.] Cert Pinning Bypass/Re-Pinning");

        var CertificateFactory = Java.use("java.security.cert.CertificateFactory");
        var FileInputStream = Java.use("java.io.FileInputStream");
        var BufferedInputStream = Java.use("java.io.BufferedInputStream");
        var X509Certificate = Java.use("java.security.cert.X509Certificate");
        var KeyStore = Java.use("java.security.KeyStore");
        var TrustManagerFactory = Java.use("javax.net.ssl.TrustManagerFactory");
        var SSLContext = Java.use("javax.net.ssl.SSLContext");

        // Load CAs from an InputStream
        console.log("[+] Loading our CA...")
        var cf = CertificateFactory.getInstance("X.509");
       
        try {
            var fileInputStream = FileInputStream.$new("/data/local/tmp/cert-der.crt");
            //***********************证书路径*******************************
        }
        catch(err) {
            console.log("[o] " + err);
        }
       
        var bufferedInputStream = BufferedInputStream.$new(fileInputStream);
        var ca = cf.generateCertificate(bufferedInputStream);
        bufferedInputStream.close();

        var certInfo = Java.cast(ca, X509Certificate);
        console.log("[o] Our CA Info: " + certInfo.getSubjectDN());

        // Create a KeyStore containing our trusted CAs
        console.log("[+] Creating a KeyStore for our CA...");
        var keyStoreType = KeyStore.getDefaultType();
        var keyStore = KeyStore.getInstance(keyStoreType);
        keyStore.load(null, null);
        keyStore.setCertificateEntry("ca", ca);
       
        // Create a TrustManager that trusts the CAs in our KeyStore
        console.log("[+] Creating a TrustManager that trusts the CA in our KeyStore...");
        var tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
        var tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
        tmf.init(keyStore);
        console.log("[+] Our TrustManager is ready...");

        console.log("[+] Hijacking SSLContext methods now...")
        console.log("[-] Waiting for the app to invoke SSLContext.init()...")

        SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").implementation = function(a,b,c) {
            console.log("[o] App invoked javax.net.ssl.SSLContext.init...");
            SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").call(this, a, tmf.getTrustManagers(), c);
            console.log("[+] SSLContext initialized with our custom TrustManager!");
        }
    });

},0);

反调的脚本

这个是我在github上找到的，然后加了很多注释，根据需要修改。

//检测： 
//    /proc/25896/maps
//    /proc/25896/status    TracerPID Check
//
//
var ProName = ProcessName();
const currentPid = Process.id;
console.log(currentPid);
function ProcessName() {
    //libc.so是系统的文件，里面加载着打开，读取，关闭等操作文件的c函数，jni在调用so层时会用到打开，读取等。（下面还用到了pthread_creeate）
    var openPtr = Module.getExportByName('libc.so', 'open');
    var open = new NativeFunction(openPtr, 'int', ['pointer', 'int']);
    var readPtr = Module.getExportByName('libc.so', 'read');
    var read = new NativeFunction(readPtr, 'int', ['int', 'pointer', 'int']);
    var closePtr = Module.getExportByName('libc.so', 'close');
    var close = new NativeFunction(closePtr, 'int', ['int']);
    var path = Memory.allocUtf8String('/proc/self/cmdline');
    //父进程名检测
    var fd = open(path, 0);
    if (fd != -1) {
        var buffer = Memory.alloc(0x1000);
        var result = read(fd, buffer, 0x1000);
        close(fd);
        result = ptr(buffer).readCString();
        return result;
    }
    return -1;
}
//假设一个libxyz.so文件,追踪libxyz.so库，自己修改
//var ourlib = "libexec.so";
//获取pthread_create函数的地址
//var p_pthread_create = Module.findExportByName("libc.so", "pthread_create");
//var pthread_create = new NativeFunction(p_pthread_create, "int", ["pointer", "pointer", "pointer", "pointer"]);
//拦截和替换 pthread_create 函数
/*
Interceptor.replace(p_pthread_create, new NativeCallback(function(ptr0, ptr1, ptr2, ptr3) {
    //函数原型
    //int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
    //thread：一个指向 pthread_t 类型的指针，用于存储新创建线程的标识符。
    //attr：一个指向 pthread_attr_t 类型的指针，用于指定新线程的属性（例如堆栈大小、调度策略等），通常可以传入 NULL 使用默认属性。
    //start_routine：一个函数指针，指向新线程将要执行的函数，该函数必须具有 void * 类型的参数并返回 void * 类型的指针。
    //arg：传递给 start_routine 函数的参数。

    var ret = ptr(0);
    if (gmn(ptr0) == ourlib) {
        console.log("Thread Created ptr0 : ", gmn(ptr0), Mod, ptr0.sub(Mod));
    }
    
    if (gmn(ptr1) == ourlib) {
        var Mod = Module.findBaseAddress(ourlib)
        console.log("Thread Created ptr1 : ", gmn(ptr1), Mod, ptr1.sub(Mod));
        Interceptor.attach(Mod.add(ptr1.sub(Mod)), {
            onEnter: function(args) {
                console.log("New Thread Func", ptr1.sub(Mod), "arg : ", args[0], args[1]);
            },
            onLeave: function(retval) {
                console.log("New Thread Func Return : ", retval);
            }
        });
    }
    if (gmn(ptr2) == ourlib) {
        var Mod = Module.findBaseAddress(ourlib)
        console.log("Thread Created ptr2 : ", gmn(ptr2), Mod, ptr2.sub(Mod));
        Interceptor.attach(Mod.add(ptr2.sub(Mod)), {
            onEnter: function(args) {
                console.log("New Thread Func", ptr2.sub(Mod), "arg : ", args[0], args[1]);
            },
            onLeave: function(retval) {
                console.log("New Thread Func Return : ", retval);
            }
        });
    }
    if (gmn(ptr3) == ourlib) {
        var Mod = Module.findBaseAddress(ourlib)
        console.log("Thread Created ptr3 : ", gmn(ptr3), Mod, ptr3.sub(Mod));
        Interceptor.attach(Mod.add(ptr3.sub(Mod)), {
            onEnter: function(args) {
                console.log("New Thread Func", ptr3.sub(Mod), "arg : ", args[0], args[1]);
            },
            onLeave: function(retval) {
                console.log("New Thread Func Return : ", retval);
            }
        });
    }
    if (ptr1.isNull() && ptr3.isNull()) {
        console.warn("loading fake pthread_create");
        // return -1 if you not want to create that thread 
        return pthread_create(ptr0, ptr1, ptr2, ptr3);
        // return -1;
    } else {       
        return pthread_create(ptr0, ptr1, ptr2, ptr3);;
    }
    
}, "int", ["pointer", "pointer", "pointer", "pointer"]));

function gmn(fnPtr) {
     if (fnPtr != null) {
        try {
            //获取函数所在模块的名字          
            return Process.getModuleByAddress(fnPtr).name;          
        } catch (e) {console.error(e);}            
    }
}*/

// 检测frida
/*
inet_aton
作用： 将一个 IPv4 地址的字符串表示转换为网络字节序的整数表示。
参数： addrs 是 IPv4 地址的字符串指针；structure 是一个 in_addr 结构体的指针，用于存放转换后的结果。
返回值： 成功返回 1，失败返回 0。
popen
作用： 打开一个管道，通过调用 shell 命令来执行一个进程，并返回一个标准 I/O 流。
参数： path 是要执行的 shell 命令的字符串；type 是打开模式（如 "r" 或 "w"）。
返回值： 成功返回指向文件流的指针，失败返回 NULL。
symlink
作用： 创建一个符号链接。
参数： target 是要链接到的目标路径；path 是要创建的符号链接路径。
返回值： 成功返回 0，失败返回 -1。
symlinkat
作用： 在指定的文件描述符（目录）下创建一个符号链接。
参数： target 是要链接到的目标路径；fd 是目录文件描述符；path 是要创建的符号链接路径。
返回值： 成功返回 0，失败返回 -1。
inet_addr
作用： 将一个点分十进制的 IPv4 地址转换为网络字节序的整数表示。
参数： path 是点分十进制 IPv4 地址的字符串。
返回值： 成功返回一个无符号 32 位整数表示的 IP 地址，失败返回 INADDR_NONE。
socket
作用： 创建一个套接字。
参数： domain 是地址族（如 AF_INET 表示 IPv4）；type 是套接字类型（如 SOCK_STREAM 表示流套接字）；proto 是协议（如 0 表示自动选择合适的协议）。
返回值： 成功返回一个文件描述符，表示创建的套接字；失败返回 -1。
connect
作用： 建立与远程套接字的连接。
参数： fd 是套接字的文件描述符；addr 是指向目标地址结构的指针；len 是地址结构的长度。
返回值： 成功返回 0，失败返回 -1。
send
作用： 发送数据到套接字。
参数： socksfd 是套接字的文件描述符；msg 是指向要发送数据的缓冲区的指针；slen 是要发送的数据的长度；flag 是附加标志。
返回值： 成功返回发送的字节数，失败返回 -1。
sendto
作用： 发送数据到指定的套接字地址。
参数： socksfd 是套接字的文件描述符；msg 是指向要发送数据的缓冲区的指针；slen 是要发送的数据的长度；flag 是附加标志；daddr 是目标地址的指针；dlen 是目标地址的长度。
返回值： 成功返回发送的字节数，失败返回 -1。
open
作用： 打开或创建一个文件或其他资源。
参数： pathname 是要打开的文件路径；flag 是打开标志（如 O_RDONLY 表示只读）。
返回值： 成功返回文件描述符，失败返回 -1。
read
作用： 从文件描述符读取数据。
参数： fd 是文件描述符；buffer 是用于接收数据的缓冲区的指针；count 是要读取的最大字节数。
返回值： 成功返回实际读取的字节数，可能会少于请求的字节数；失败返回 -1。
*/

var inet_atonPtr = Module.findExportByName(null, "inet_aton");
console.log(`inet_atonPtr: ${inet_atonPtr}`);
var inet_aton = new NativeFunction(inet_atonPtr, 'int', ['pointer', 'pointer']);

Interceptor.replace(inet_atonPtr, new NativeCallback(function(addrs, structure) {
    var retval = inet_aton(addrs, structure);
    //console.log(1);
    //console.log("inet_aton : ", addrs.readCString())
    return retval;
}, 'int', ['pointer', 'pointer']))

var popenPtr = Module.findExportByName("libc.so", "popen");
var popen = new NativeFunction(popenPtr, 'pointer', ['pointer', 'pointer']);
Interceptor.replace(popenPtr, new NativeCallback(function(path, type) {
    var retval = popen(path, type);
    //console.log(2);
    //console.log("popen : ", path.readCString());
    return retval;
}, 'pointer', ['pointer', 'pointer']))

var symlinkPtr = Module.findExportByName("libc.so", "symlink");
var symlink = new NativeFunction(symlinkPtr, 'int', ['pointer', 'pointer']);
Interceptor.replace(symlinkPtr, new NativeCallback(function(target, path) {
    var retval = symlink(target, path);
    //console.log(3);
    //console.log("symlink: ", target.readCString(), path.readCString());
    return retval;
}, 'int', ['pointer', 'pointer']))

var symlinkatPtr = Module.findExportByName("libc.so", "symlinkat");
var symlinkat = new NativeFunction(symlinkatPtr, 'int', ['pointer', 'int', 'pointer']);
Interceptor.replace(symlinkatPtr, new NativeCallback(function(target, fd, path) {
    var retval = symlinkat(target, fd, path);
    //console.log(4);
    //console.log("symlinkat : ", target.readCString(), path.readCString());
    return retval;
}, 'int', ['pointer', 'int', 'pointer']))

var inet_addrPtr = Module.findExportByName("libc.so", "inet_addr");
var inet_addr = new NativeFunction(inet_addrPtr, 'int', ['int']);
Interceptor.replace(inet_addrPtr, new NativeCallback(function(path) {
    var retval = inet_addr(path);
    //console.log(5);
    //console.log("inet_addr : ", path.readCString())
    return retval;
}, 'int', ['int']))

var socketPtr = Module.findExportByName("libc.so", "socket");
var socket = new NativeFunction(socketPtr, 'int', ['int', 'int', 'int']);
Interceptor.replace(socketPtr, new NativeCallback(function(domain, type, proto) {
    var retval = socket(domain, type, proto);
    //console.log(6);
    //console.warn("socket  : ", domain, type, proto, "Return : ", retval)
    return retval;
}, 'int', ['int', 'int', 'int']))

var connectPtr = Module.findExportByName("libc.so", "connect");
var connect = new NativeFunction(connectPtr, 'int', ['int', 'pointer', 'int']);
Interceptor.replace(connectPtr, new NativeCallback(function(fd, addr, len) {
    var retval = connect(fd, addr, len);
    var family = addr.readU16();
    var port = addr.add(2).readU16();
    //port = ((port & 0xff) << 8) | (port >> 8);
    //console.log(7);
    //console.warn("Connect : ", family, "Port : ", port, "Return : ", retval);
    return retval;
}, 'int', ['int', 'pointer', 'int']))

var sendPtr = Module.findExportByName("libc.so", "send");
var send2 = new NativeFunction(sendPtr, 'int', ['int', 'pointer', 'int', 'int']);
Interceptor.replace(sendPtr, new NativeCallback(function(socksfd, msg, slen, flag, daddr, dlen) {
    var retval = send2(socksfd, msg, slen, flag);
    //console.log(8);
    //console.log("send : ", socksfd, msg.readCString(), slen, flag);
    return retval;
}, 'int', ['int', 'pointer', 'int', 'int']))

var sendtoPtr = Module.findExportByName("libc.so", "sendto");
var sendto = new NativeFunction(sendtoPtr, 'int', ['int', 'pointer', 'int', 'int', 'pointer', 'int']);
Interceptor.replace(sendtoPtr, new NativeCallback(function(socksfd, msg, slen, flag, daddr, dlen) {
    var retval = sendto(socksfd, msg, slen, flag, daddr, dlen);
    //console.log(9);
      //console.log("sendto : ",socksfd,msg.readCString(),slen,flag,daddr,dlen);                                       
    return retval;
}, 'int', ['int', 'pointer', 'int', 'int', 'pointer', 'int']))

const openPtr = Module.getExportByName('libc.so', 'open');
const open = new NativeFunction(openPtr, 'int', ['pointer', 'int']);
var readPtr = Module.findExportByName("libc.so", "read");
var read = new NativeFunction(readPtr, 'int', ['int', 'pointer', "int"]);

//这一段就是hookopen函数，将记录了文件是否被调试的文件进行了重定向
//ProName：进程名
var FakeMaps = "/data/data/" + ProName + "/maps";
var FOpenMaps = "/data/data/" + ProName + "/fmaps";
var FakeTask = "/data/data/" + ProName + "/task";
var FakeExE = "/data/data/" + ProName + "/exe";
var FakeMounts = "/data/data/" + ProName + "/mounts";
var FakeStatus = "/data/data/" + ProName + "/status";
var MapsFile = new File(FakeMaps, "w");
var TaskFile = new File(FakeTask, "w");
var ExEFile = new File(FakeExE, "w");
var FMapsFile = new File(FOpenMaps, "w");
var FMountFile = new File(FakeMounts, "w");
var StatusFile = new File(FakeStatus, "w");
var MapsBuffer = Memory.alloc(512);
var TaskBuffer = Memory.alloc(512);
var ExEBuffer = Memory.alloc(512);
var FopenBuffer = Memory.alloc(512);
var MountBuffer = Memory.alloc(512);
var StatusBuffer = Memory.alloc(512);
var Open64MapsBuffer = Memory.alloc(512);
//openptr在前面申明了，是open函数的地址
Interceptor.replace(openPtr, new NativeCallback(function(pathname, flag) {
    //pathname = "/proc/" + currentPid + "/maps";
    var FD = open(pathname, flag);
    var ch = pathname.readCString();
    //如果路径是/proc/xxx/maps
    if (ch.indexOf("/proc/") >= 0 && ch.indexOf("maps") >= 0) {
          console.log("open : ", pathname.readCString(),11111) 
          //parseInt:将字符串转换成整数
        while (parseInt(read(FD, MapsBuffer, 512)) !== 0) {
            //读取打开的文件的字符串
            var MBuffer = MapsBuffer.readCString();
            //将所有调试文件的名字替换
            //console.log(1);
            MBuffer = MBuffer.replaceAll("/data/local/tmp/re.frida.server/frida-agent-64.so", "FakingMaps");
            MBuffer = MBuffer.replaceAll("re.frida.server", "FakingMaps");
            MBuffer = MBuffer.replaceAll("re.frida", "FakingMaps");
            MBuffer = MBuffer.replaceAll("re.", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida.", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida-agent-64.so", "FakingMaps");
            MBuffer = MBuffer.replaceAll("rida-agent-64.so", "FakingMaps");
            MBuffer = MBuffer.replaceAll("agent-64.so", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida-agent-32.so", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida-helper-32", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida-helper", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida-agent", "FakingMaps");
            MBuffer = MBuffer.replaceAll("pool-frida", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida-", "FakingMaps");
            MBuffer = MBuffer.replaceAll("/data/local/tmp", "/data");
            MBuffer = MBuffer.replaceAll("server", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida-server", "FakingMaps");
            MBuffer = MBuffer.replaceAll("linjector", "FakingMaps");
            MBuffer = MBuffer.replaceAll("gum-js-loop", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida_agent_main", "FakingMaps");
            MBuffer = MBuffer.replaceAll("gmain", "FakingMaps");
            MBuffer = MBuffer.replaceAll("frida", "FakingMaps");
            MBuffer = MBuffer.replaceAll("magisk", "FakingMaps");
            MBuffer = MBuffer.replaceAll(".magisk", "FakingMaps");
            MBuffer = MBuffer.replaceAll("/sbin/.magisk", "FakingMaps");
            MBuffer = MBuffer.replaceAll("libriru", "FakingMaps");
            MBuffer = MBuffer.replaceAll("xposed", "FakingMaps");
            MapsFile.write(MBuffer);
             //console.log("MBuffer : ",MBuffer);                                     
        }
        var filename = Memory.allocUtf8String(FakeMaps);
        return open(filename, flag);
    }
    //如果路径是/proc/xxx/task，检测正在运行的任务
    if (ch.indexOf("/proc") >= 0 && ch.indexOf("task") >= 0) {
        // console.log("open : ", pathname.readCString()) 
        while (parseInt(read(FD, TaskBuffer, 512)) !== 0) {
            var buffer = TaskBuffer.readCString();
            buffer = buffer.replaceAll("re.frida.server", "FakingTask");
            buffer = buffer.replaceAll("frida-agent-64.so", "FakingTask");
            buffer = buffer.replaceAll("rida-agent-64.so", "FakingTask");
            buffer = buffer.replaceAll("agent-64.so", "FakingTask");
            buffer = buffer.replaceAll("frida-agent-32.so", "FakingTask");
            buffer = buffer.replaceAll("frida-helper-32", "FakingTask");
            buffer = buffer.replaceAll("frida-helper", "FakingTask");
            buffer = buffer.replaceAll("frida-agent", "FakingTask");
            buffer = buffer.replaceAll("pool-frida", "FakingTask");
            buffer = buffer.replaceAll("frida", "FakingTask");
            buffer = buffer.replaceAll("/data/local/tmp", "/data");
            buffer = buffer.replaceAll("server", "FakingTask");
            buffer = buffer.replaceAll("frida-server", "FakingTask");
            buffer = buffer.replaceAll("linjector", "FakingTask");
            buffer = buffer.replaceAll("gum-js-loop", "FakingTask");
            buffer = buffer.replaceAll("frida_agent_main", "FakingTask");
            buffer = buffer.replaceAll("gmain", "FakingTask");
            buffer = buffer.replaceAll("magisk", "FakingTask");
            buffer = buffer.replaceAll(".magisk", "FakingTask");
            buffer = buffer.replaceAll("/sbin/.magisk", "FakingTask");
            buffer = buffer.replaceAll("libriru", "FakingTask");
            buffer = buffer.replaceAll("xposed", "FakingTask");
            buffer = buffer.replaceAll("pool-spawner", "FakingTask");
            buffer = buffer.replaceAll("gdbus", "FakingTask");            
            TaskFile.write(buffer);
            // console.log(buffer);
        }
        var filename2 = Memory.allocUtf8String(FakeTask);
        return open(filename2, flag);
    }
    //如果路径是/proc/xxx/mounts
    if (ch.indexOf("/proc/") >= 0 && ch.indexOf("mounts") >= 0) {
        console.log("open : ", pathname.readCString())
        while (parseInt(read(FD, MountBuffer, 512)) !== 0) {
            var MNTBuffer = MountBuffer.readCString();
            MNTBuffer = MNTBuffer.replaceAll("magisk", "StaySafeStayHappy");
            MNTBuffer = MNTBuffer.replaceAll("/sbin/.magisk", "StaySafeStayHappy");
            MNTBuffer = MNTBuffer.replaceAll("libriru", "StaySafeStayHappy");
            MNTBuffer = MNTBuffer.replaceAll("xposed", "StaySafeStayHappy");
            MNTBuffer = MNTBuffer.replaceAll("mirror", "StaySafeStayHappy");
            MNTBuffer = MNTBuffer.replaceAll("system_root", "StaySafeStayHappy");
            MNTBuffer = MNTBuffer.replaceAll("xposed", "StaySafeStayHappy")
            FMountFile.write(MNTBuffer);
            // console.log("MNTBuffer : ",MNTBuffer);                                     
        }
        var mountname = Memory.allocUtf8String(FakeMounts);
        return open(mountname, flag);
    }
    
      if (ch.indexOf("/proc/") >=0 && ch.indexOf("status") >=0) {     
         console.log("open : ", pathname.readCString()) 
         while (parseInt(read(FD, StatusBuffer, 512)) !== 0) {
         var PStatus = StatusBuffer.readCString();   
         if (PStatus.indexOf("TracerPid:") > -1) {
                StatusBuffer.writeUtf8String("TracerPid:\t0");
                console.log("Bypassing TracerPID Check");               
            }
         StatusFile.write(PStatus);                                                
                }
            var statusname = Memory.allocUtf8String(FakeStatus);
            return open(statusname, flag);  
    }
     
    if (ch.indexOf("/proc") >= 0 && ch.indexOf("exe") >= 0) {
        console.log("open : ", pathname.readCString())
        while (parseInt(read(FD, ExEBuffer, 512)) !== 0) {
            var buffer = ExEBuffer.readCString();
            //  console.warn(buffer)
            buffer = buffer.replaceAll("frida-agent-64.so", "StaySafeStayHappy");
            buffer = buffer.replaceAll("frida-agent-32.so", "StaySafeStayHappy");
            buffer = buffer.replaceAll("re.frida.server", "StaySafeStayHappy");
            buffer = buffer.replaceAll("frida-helper-32", "StaySafeStayHappy");
            buffer = buffer.replaceAll("frida-helper", "StaySafeStayHappy");
            buffer = buffer.replaceAll("pool-frida", "StaySafeStayHappy");
            buffer = buffer.replaceAll("frida", "StaySafeStayHappy");
            buffer = buffer.replaceAll("/data/local/tmp", "/data");
            buffer = buffer.replaceAll("frida-server", "StaySafeStayHappy");
            buffer = buffer.replaceAll("linjector", "StaySafeStayHappy");
            buffer = buffer.replaceAll("gum-js-loop", "StaySafeStayHappy");
            buffer = buffer.replaceAll("frida_agent_main", "StaySafeStayHappy");
            buffer = buffer.replaceAll("gmain", "StaySafeStayHappy");
            buffer = buffer.replaceAll("frida-agent", "StaySafeStayHappy");
            ExEFile.write(buffer);
        }
        var filename3 = Memory.allocUtf8String(FakeExE);
        return open(filename3, flag);
    }
    return FD;
}, 'int', ['pointer', 'int']))
var fgetsPtr = Module.findExportByName("libc.so", "fgets");
var fgets = new NativeFunction(fgetsPtr, 'pointer', ['pointer', 'int', 'pointer']);
Interceptor.replace(fgetsPtr, new NativeCallback(function(buf, size, fp) {
    //var retval = fgets(buf, size, fp);
    var buffer = buf.readCString();
    buffer = buffer.replaceAll("re.frida.server", "FakingGets");
    buffer = buffer.replaceAll("frida-agent-64.so", "FakingGets");
    buffer = buffer.replaceAll("rida-agent-64.so", "FakingGets");
    buffer = buffer.replaceAll("agent-64.so", "FakingGets");
    buffer = buffer.replaceAll("frida-agent-32.so", "FakingGets");
    buffer = buffer.replaceAll("frida-helper-32", "FakingGets");
    buffer = buffer.replaceAll("frida-helper", "FakingGets");
    buffer = buffer.replaceAll("frida-agent", "FakingGets");
    buffer = buffer.replaceAll("pool-frida", "FakingGets");
    buffer = buffer.replaceAll("frida", "FakingGets");
    buffer = buffer.replaceAll("/data/local/tmp", "/data");
    buffer = buffer.replaceAll("server", "FakingGets");
    buffer = buffer.replaceAll("frida-server", "FakingGets");
    buffer = buffer.replaceAll("linjector", "FakingGets");
    buffer = buffer.replaceAll("gum-js-loop", "FakingGets");
    buffer = buffer.replaceAll("frida_agent_main", "FakingGets");
    buffer = buffer.replaceAll("gmain", "FakingGets");
    buffer = buffer.replaceAll("magisk", "FakingGets");
    buffer = buffer.replaceAll(".magisk", "FakingGets");
    buffer = buffer.replaceAll("/sbin/.magisk", "FakingGets");
    buffer = buffer.replaceAll("libriru", "FakingGets");
    buffer = buffer.replaceAll("xposed", "FakingGets");
    buf.writeUtf8String(buffer);
    //  console.log(buf.readCString());
    return fgets(buf, size, fp);
}, 'pointer', ['pointer', 'int', 'pointer']))

var readlinkPtr = Module.findExportByName("libc.so", "readlink");
var readlink = new NativeFunction(readlinkPtr, 'int', ['pointer', 'pointer', 'int']);
Interceptor.replace(readlinkPtr, new NativeCallback(function(pathname, buffer, bufsize) {
    var retval = readlink(pathname, buffer, bufsize);  
    //从内存中读取字符串，判断是否含有特征字符
     if(buffer.readCString().indexOf("frida")!==-1 ||
            buffer.readCString().indexOf("gum-js-loop")!==-1||
            buffer.readCString().indexOf("gmain")!==-1 ||
            buffer.readCString().indexOf("linjector")!==-1 || 
            buffer.readCString().indexOf("/data/local/tmp")!==-1 || 
            buffer.readCString().indexOf("pool-frida")!==-1 || 
            buffer.readCString().indexOf("frida_agent_main")!==-1 ||
            buffer.readCString().indexOf("re.frida.server")!==-1 || 
            buffer.readCString().indexOf("frida-agent")!==-1 ||
            buffer.readCString().indexOf("frida-agent-64.so")!==-1 ||
            buffer.readCString().indexOf("frida-agent-32.so")!==-1 ||
            buffer.readCString().indexOf("frida-helper-32.so")!==-1 ||
            buffer.readCString().indexOf("frida-helper-64.so")!==-1                        
            ){
            console.log(buffer.readCString(), "Check in readlink");
            buffer.writeUtf8String("/system/framework/services.jar");            
            return readlink(pathname, buffer, bufsize);  
     }
     
//    console.log("readlink : ", pathname.readCString(), buffer.readCString());
    return retval;   
}, 'int', ['pointer', 'pointer', 'int']))


var readlinkatPtr = Module.findExportByName("libc.so", "readlinkat");
var readlinkat = new NativeFunction(readlinkatPtr, 'int', ['int', 'pointer', 'pointer', 'int']);
Interceptor.replace(readlinkatPtr, new NativeCallback(function(dirfd, pathname, buffer, bufsize) {
    var retval = readlinkat(dirfd, pathname, buffer, bufsize);
    
     if(buffer.readCString().indexOf("frida")!==-1 ||
            buffer.readCString().indexOf("gum-js-loop")!==-1||
            buffer.readCString().indexOf("gmain")!==-1 ||
            buffer.readCString().indexOf("linjector")!==-1 || 
            buffer.readCString().indexOf("/data/local/tmp")!==-1 || 
            buffer.readCString().indexOf("pool-frida")!==-1 || 
            buffer.readCString().indexOf("frida_agent_main")!==-1 ||
            buffer.readCString().indexOf("re.frida.server")!==-1 || 
            buffer.readCString().indexOf("frida-agent")!==-1 ||
            buffer.readCString().indexOf("frida-agent-64.so")!==-1 ||
            buffer.readCString().indexOf("frida-agent-32.so")!==-1 ||
            buffer.readCString().indexOf("frida-helper-32.so")!==-1 ||
            buffer.readCString().indexOf("frida-helper-64.so")!==-1                              
            ){
            console.log(buffer.readCString(), "Check in readlinkat");
            buffer.writeUtf8String("/system/framework/services.jar");           
            return readlinkat(dirfd, pathname, buffer, bufsize);
     }
     
 //   console.log("readlinkat : ", pathname.readCString(), buffer.readCString());
   return retval;
}, 'int', ['int', 'pointer', 'pointer', 'int']))

/*
Interceptor.attach(Module.findExportByName(null, "strstr"),{
    onEnter: function(args){
        this.frida = false;
        console.log(3);
        var str1 = args[0].readCString();
        var str2 = args[1].readCString();      
        if(str1.indexOf("frida")!==-1  || str2.indexOf("frida")!==-1 ||
          str1.indexOf("gum-js-loop")!==-1 || str2.indexOf("gum-js-loop")!==-1 ||
          str1.indexOf("gmain")!==-1 || str2.indexOf("gmain")!==-1 ||
          str1.indexOf("linjector")!==-1  || str2.indexOf("linjector")!==-1 ||
          str1.indexOf("/data/local/tmp")!==-1  || str2.indexOf("/data/local/tmp")!==-1 ||
          str1.indexOf("pool-frida")!==-1  || str2.indexOf("pool-frida")!==-1 ||
          str1.indexOf("frida_agent_main")!==-1  || str2.indexOf("frida_agent_main")!==-1 ||
          str1.indexOf("re.frida.server")!==-1  || str2.indexOf("re.frida.server")!==-1 ||
          str1.indexOf("frida-agent")!==-1  || str2.indexOf("frida-agent")!==-1 ||
          str1.indexOf("pool-spawner")!==-1  || str2.indexOf("pool-spawner")!==-1 ||
          str1.indexOf("frida-agent-64.so")!==-1  || str2.indexOf("frida-agent-64.so")!==-1 ||
          str1.indexOf("frida-agent-32.so")!==-1  || str2.indexOf("frida-agent-32.so")!==-1 ||
          str1.indexOf("frida-helper-32.so")!==-1  || str2.indexOf("frida-helper-32.so")!==-1 ||
          str1.indexOf("frida-helper-64.so")!==-1  || str2.indexOf("frida-helper-64.so")!==-1  ||
          str1.indexOf("/sbin/.magisk")!==-1  || str2.indexOf("/sbin/.magisk")!==-1  ||
          str1.indexOf("libriru")!==-1  || str2.indexOf("libriru")!==-1  ||
          str1.indexOf("magisk")!==-1  || str2.indexOf("magisk")!==-1  
                                         
          ){          
            this.frida = true;
            console.log("检测到:strstr : ",str1,str2);
        }
    },
    onLeave: function(retval){
        if (this.frida) {
            retval.replace(ptr("0x0"));
        }
    }
});
*/

//Enabling it might give crash on some apps 
/*
Interceptor.attach(Module.findExportByName("libc.so", "read"), {
    onEnter: function(args) {
        try {
            var buffer = args[1].readCString();
            if (buffer.indexOf("frida") >= 0) {
                buffer = buffer.replaceAll("re.frida.server", "StaySafeStayHappy");
                buffer = buffer.replaceAll("frida-agent-64.so", "StaySafeStayHappy");
                buffer = buffer.replaceAll("rida-agent-64.so", "StaySafeStayHappy");
                buffer = buffer.replaceAll("agent-64.so", "StaySafeStayHappy");
                buffer = buffer.replaceAll("frida-agent-32.so", "StaySafeStayHappy");
                buffer = buffer.replaceAll("frida-helper-32", "StaySafeStayHappy");
                buffer = buffer.replaceAll("frida-helper", "StaySafeStayHappy");
                buffer = buffer.replaceAll("frida-agent", "StaySafeStayHappy");
                buffer = buffer.replaceAll("pool-frida", "StaySafeStayHappy");
                buffer = buffer.replaceAll("frida", "StaySafeStayHappy");
                buffer = buffer.replaceAll("/data/local/tmp", "/data");
                buffer = buffer.replaceAll("server", "StaySafeStayHappy");
                buffer = buffer.replaceAll("frida-server", "StaySafeStayHappy");
                buffer = buffer.replaceAll("linjector", "StaySafeStayHappy");
                buffer = buffer.replaceAll("gum-js-loop", "StaySafeStayHappy");
                buffer = buffer.replaceAll("frida_agent_main", "StaySafeStayHappy");
                buffer = buffer.replaceAll("gmain", "StaySafeStayHappy");
                buffer = buffer.replaceAll("magisk", "StaySafeStayHappy");
                buffer = buffer.replaceAll(".magisk", "StaySafeStayHappy");
                buffer = buffer.replaceAll("/sbin/.magisk", "StaySafeStayHappy");
                buffer = buffer.replaceAll("libriru", "StaySafeStayHappy");
                buffer = buffer.replaceAll("xposed", "StaySafeStayHappy");
                args[1].writeUtf8String(buffer);
            }
        } catch (e) {
            //console.error(e);
        }
    }
});
*/

/*
var memcpyPtr = Module.findExportByName("libc.so", "memcpy");
var memcpy = new NativeFunction(memcpyPtr, 'pointer', ['pointer', 'pointer', 'int']);
Interceptor.replace(memcpyPtr, new NativeCallback(function(dest, src, len) {
    var retval = memcpy(dest, src, len);
    if(dest.readCString() != null && src.readCString() != null && (dest.readCString().indexOf("frida")>=0 || src.readCString().indexOf("frida")>=0) )
    {
        //console.warn("memcpy : ",dest.readCString(),src.readCString());
        var buffer = dest.readCString();
        var buffer2 = src.readCString();
        buffer = buffer.replaceAll("re.frida.server","StaySafeStayHappy");                                                         
        buffer = buffer.replaceAll("frida-agent-64.so","StaySafeStayHappy");
        buffer = buffer.replaceAll("rida-agent-64.so","StaySafeStayHappy");
        buffer = buffer.replaceAll("agent-64.so","StaySafeStayHappy");        
        buffer = buffer.replaceAll("frida-agent-32.so","StaySafeStayHappy");       
        buffer = buffer.replaceAll("frida-helper-32","StaySafeStayHappy");        
        buffer = buffer.replaceAll("frida-helper","StaySafeStayHappy"); 
        buffer = buffer.replaceAll("frida-agent","StaySafeStayHappy");        
        buffer = buffer.replaceAll("pool-frida","StaySafeStayHappy");            
        buffer = buffer.replaceAll("frida","StaySafeStayHappy");
        buffer = buffer.replaceAll("/data/local/tmp","/data");
        buffer = buffer.replaceAll("server","StaySafeStayHappy");
        buffer = buffer.replaceAll("frida-server","StaySafeStayHappy");
        buffer = buffer.replaceAll("linjector","StaySafeStayHappy");
        buffer = buffer.replaceAll("gum-js-loop","StaySafeStayHappy");
        buffer = buffer.replaceAll("frida_agent_main","StaySafeStayHappy");
        buffer = buffer.replaceAll("gmain","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("re.frida.server","StaySafeStayHappy");                                                         
        buffer2 = buffer2.replaceAll("frida-agent-64.so","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("rida-agent-64.so","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("agent-64.so","StaySafeStayHappy");        
        buffer2 = buffer2.replaceAll("frida-agent-32.so","StaySafeStayHappy");       
        buffer2 = buffer2.replaceAll("frida-helper-32","StaySafeStayHappy");        
        buffer2 = buffer2.replaceAll("frida-helper","StaySafeStayHappy"); 
        buffer2 = buffer2.replaceAll("frida-agent","StaySafeStayHappy");        
        buffer2 = buffer2.replaceAll("pool-frida","StaySafeStayHappy");            
        buffer2 = buffer2.replaceAll("frida","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("/data/local/tmp","/data");
        buffer2 = buffer2.replaceAll("server","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("frida-server","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("linjector","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("gum-js-loop","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("frida_agent_main","StaySafeStayHappy");
        buffer2 = buffer2.replaceAll("gmain","StaySafeStayHappy");
        dest.writeUtf8String(buffer);
        src.writeUtf8String(buffer2);
       // console.log(buffer,buffer2);
        return memcpy(dest, src, len);
    }
    return retval;
}, 'pointer', ['pointer', 'pointer', 'int']))
*/

打印堆栈

将函数加在代码中，然后在hook的函数中调用printStack();即可。


// 日志打印和调用堆栈输出函数
// 日志输出
function LOG(sth)
{
    console.log(sth);
}
// 打印调用堆栈的函数
function printStack()
{
    Java.perform
    (
        function()
        {
            var Exception = Java.use("java.lang.Exception"); //加载Java类 java.lang.Exception
            var ins = Exception.$new("Exception");// Exception构造方法调用
            var straces = ins.getStackTrace();// 调用Exception对象的getStackTrace方法
            if (straces != undefined && straces != null) 
            {
                var strace = straces.toString();
                var replaceStr = strace.replace(/,/g, "\n");
                LOG("============================= 调用堆栈开始 =======================\n");
                LOG(replaceStr);
                LOG("============================= 调用堆栈结束 ==========================\n");
                Exception.$dispose();
            }
        }   
    );
}

bilibili反调的脚本

在网上找到的，可以绕过bilibili的反调。

function create_fake_pthread_create() {
    const fake_pthread_create = Memory.alloc(4096)
    Memory.protect(fake_pthread_create, 4096, "rwx")
    Memory.patchCode(fake_pthread_create, 4096, code => {
        const cw = new Arm64Writer(code, { pc: ptr(fake_pthread_create) })
        cw.putRet()
    })
    return fake_pthread_create
}
 
function hook_dlsym() {
    var count = 0
    console.log("=== HOOKING dlsym ===")
    var interceptor = Interceptor.attach(Module.findExportByName(null, "dlsym"),
        {
            onEnter: function (args) {
                const name = ptr(args[1]).readCString()
                console.log("[dlsym]", name)
                if (name == "pthread_create") {
                    count++
                }
            },
            onLeave: function(retval) {
                if (count == 1) {
                    retval.replace(fake_pthread_create)
                }
                else if (count == 2) {
                    retval.replace(fake_pthread_create)
                    // 完成2次替换, 停止hook dlsym
                    interceptor.detach()
                }
            }
        }
    )
    return Interceptor
}
 
function hook_dlopen() {
    var interceptor = Interceptor.attach(Module.findExportByName(null, "android_dlopen_ext"),
        {
            onEnter: function (args) {
                var pathptr = args[0];
                if (pathptr !== undefined && pathptr != null) {
                    var path = ptr(pathptr).readCString();
                    console.log("[LOAD]", path)
                    if (path.indexOf("libmsaoaidsec.so") > -1) {
                        hook_dlsym()
                    }
                }
            }
        }
    )
    return interceptor
}
 
// 创建虚假pthread_create
var fake_pthread_create = create_fake_pthread_create()
var dlopen_interceptor = hook_dlopen()
&阿权&
关注
专栏目录
100天精通Andriod逆向——第5天：app逆向流程简介
Amo Xiang的博客
08-11 3768
app逆向流程简介
Android 逆向工程之APK混淆处理方案分析
最新发布
qq_38794072的博客
07-24 1256
提供apk给到外部，外部对apk进行二次处理后重新给我们一个新apk。尝试分析源apk文件和处理后的apk文件区别，根据其中区别推测外部的混淆处理方案，尽可能还原外部对apk的处理方式。以下对处理和未处理的apk文件用新、旧apk名称表示。通过反编译工具分析可以得出外部处理的新 app 操作主要是对 dex 文件增加了垃圾代码提高主包的相似度，避免被Google识别，然后进行了混淆处理。处理 dex 利用 BlackObfuscator-GUI 等工具处理后对 apk。
Android逆向之实战逆向APP
铁柱的博客
01-20 2343
经过前2篇逆向前置知识的铺垫之后，我们终于要开始逆向实操了。以下操作主要是体现一下逆向的流程以及实操，为了安全考虑，并不会直接给出APP名称。从目标出发，一步步去完成我们的目标，回头再看，大家就会发现，不过如此罢了。
Andriod APP逆向——JNI开发
m0_57126939的博客
02-02 617
JNI 是本地语言编程接口（Java Native Interface）。它允许运行在 JVM 中的 Java 代码和用C、C++ 或 汇编 写的本地代码相互操作。
安卓逆向-《安卓逆向这档事》
qq_44804602的博客
12-14 1552
汉化软件（第2节第3点）更改软件名称和图标（第2节第4点）
android app逆向分析,如何开始对Android应用的逆向分析？
weixin_35951275的博客
05-26 1318
本文是我的关于如何开始Android逆向系列文章的第一部分。在文末提供了一个文档，你可以根据该文档说明部署同我一样的实验环境。在了解android应用的逆向之前，你必须对android平台及其架构和android应用程序的构建块(组件)已有了一个较好的理解。如果你并不了解这些，那么我建议你先参阅以下链接，然后再继续浏览本文。我当前的实验室环境如下：主机系统为windows，其中安装了virtual...
android app 逆向
T3119205的专栏
01-09 215
好久没有写blog了，这两天工作没有那么忙，记得上次反编译在回编译还是3年以前在windows上，今天又想研究研究逆向了，于是就把mac上的操作步骤记录一下，写的不好的地方欢迎拍砖，吼吼～ 既然要逆向，首先得有工具哇，工具很多，根据个人喜欢去选择，我今天选择的是apktool 一、工具安装 apktool ：https://ibotpeaches.github.io/Apktool/inst...
【安卓逆向】360加固-脱壳修复
YJJYXM的博客
10-08 2万+
最近花了一些时间学习逆向脱壳，这方面一直投入的时间比较少。样本经过某加固宝进行加固，这里简单记录一下脱壳过程和思路，感谢某数字公司对安全加固的无私贡献，让我有机会小小的提高一下这方面的技能。 DUMP classes.dex 打开APK包中的classes.dex看一下： 已经变成了壳代{过}{滤}理，没有一点原APK的代码。在assets中，有两个壳相关的SO： 尝试从内存中DUMP原cla...
android内核名修改工具,修改手机内核绕过ptrace
weixin_28719225的博客
05-26 2286
前面一篇文章《Android反调试手段收集》在讲常用的反调试方法中有一条是检测进程的TracerPid的值正常情况下为0，在被调试时变成父进程的pid，应对这种情况我们可以通过修改手机内核中代码，将这个pid永久性改为0。具体方法也都是前人总结的https://bbs.pediy.com/thread-207538.htm，这里只根据自己的设备做一遍操作演示。设备：Nexus5系统版本：4.4.4...
180705 逆向-Linux的逆向
whklhhhh的博客
07-12 1546
常用工具和命令 nm 列出目标文件的所有符号 objdump -d参数表示反编译.text段中的程序代码 readelf 查看ELF文件的各种信息 IDA gdb IDA 与PE程序基本类似，将ELF程序拖入IDA也可以快速的反汇编，主要借助hex-ray插件来反编译出可读性较高的伪代码 实验-passwd_generator trick patch dynam...
安卓app逆向工程
11-21
最新安卓app反编译工具，适合对安卓源码有兴趣的朋友使用，本想免费分享，但是平台最低只能选1分，sorry。
安卓逆向—反调试汇总
contrary_的博客
04-28 1331
给大家介绍一下反调试汇总的原理及实现方式，以及各种反调试的扩展 反调试汇总： 针对于一些大型apk 反调试不一定是让你不能调试 -> 让你得到一个错误的结果 逆向某一个算法 传参 中间会根据一些数据运算 如果检测到反调试 计算错误 **1.IDA调试端口检测** 监测android_server文件端口信息 默认的23946(5D8A) 更改端口 31927 -> 过掉此反调试 **2.调试器进程名检测** 监测android_server gdbserver gdb等进程
某安卓app逆向全过程
GaryDaliy的博客
08-14 1285
一、前言 在抓取优奢易拍app中某个品牌的包包，请求数据的url为 url = 'https://javasc.isheyipai.com/sheyipai-app-web/app/community/getBbsBySearchBoxV2' 请求方式为post，发送的data为 data = { 'appVersion':'1980', 'batch':'54359', 'bbsUserId':'1039287079', ...
android app 逆向工程
个人开发之路
09-19 865
好吧，其实想说的是反编译。 没什么，就是觉得一个叫什么的工具挺好用的，包含了jd-gui，来看源码的。 基本上可读性还是比较好的。
Android逆向（一）Android逆向工具（一）
热门推荐
zhaojun的博客
03-19 3万+
最近一周时间，在学习和研究Android逆向，接下来一段时间，写一系列Android逆向的博客，来总结和记录自己所掌握的知识，也希望为正在学习Android逆向的朋友带来一点帮助。
Android逆向工具简单介绍
学无止境
10-25 3345
Android APK生成过程安卓开发中代码和资源文件打包成 APK 的过程主要包括：编译、加密和打包。安卓逆向就是解压、解密和反编译了。安卓逆向说白了就是重新获取 APK 的源码，甚至有些灰产会修改部分应用内容之后重新打包。正道用途的话，很多大企业有安卓逆向工程师，负责企业应用的安全工作，“以子之矛，攻子之盾”，测试加强自己应用的安全性。我们 Android 开发工程师有时候也会用一些逆向小技巧，看看竞品的应用某个功能实现方法之类的。
android 逆向工程
shangguan
07-25 1028
很多人写文章，喜欢把什么行业现状啊，研究现状啊什么的写了一大通，感觉好像在写毕业论文似的，我这不废话，先直接上几个图，感受一下。第一张图是在把代码注入到地图里面，启动首页的时候弹出个浮窗，下载网络的图片，苍老师你们不会不认识吧？ 第二张图是微信运动步数作弊，6不6？ ok，那我们从头说起……1.反编译 Android 的反编译，相信大家都应该有所了解，apktool、JEB 等工具。我们先看一
Android 逆向工程
mazaiting的博客
12-18 415
1. Apk签名 1). 创建签名文件 新建项目 -&gt; build -&gt; Generate Signed Bundle/APK... -&gt; Create new... 图1.png 2). 填写签名文件相关信息 点击确认会生成signed.jks文件，将signed.jks文件拷贝至&lt;项目路径&gt;/app/下 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

&阿权&

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值