解锁 繁花剧场 会员

电脑简单

先搜索VIP  发现这2个很可疑


查找调用处   发现这个方法进行了调用


继续一步一步的跟进去



这里我们知道逻辑大概是 调用请求获取用户的信息 通过userInfo 中的 getVipStatus  getVipType  getSvipEndDate  判断VIP的类型等级 和到期的日期


先试一下frIDA hook  一下


果然有检测

好了先写过检测的脚本   费了九牛二虎之力终于写好了


我们再来看看 原先的 我们打开的界面


hook 之后的


好了 大功告成    帖子写的不是好
请见谅   APP名称  繁花剧场 可以在应用商城下载到 大家可以试试

下面是JS代码：

console.log("[+] 启动智能反检测脚本...");

// 智能时间管理
var g_start_time = Date.now();
var g_last_time = 0;
var g_time_calls = 0;
var g_proc_blocks = 0;

// 1. 智能时间检测绕过 - 允许时间正常流逝
function smartTimeBypass() {
    console.log("[+] 智能时间检测绕过...");
   
    var clock_gettimePtr = Module.findExportByName("libc.so", "clock_gettime");
    if (clock_gettimePtr) {
        Interceptor.attach(clock_gettimePtr, {
            onEnter: function(args) {
                this.clk_id = args[0].toInt32();
                this.tp = args[1];
            },
            onLeave: function(retval) {
                if (retval.toInt32() === 0 && this.tp) {
                    try {
                        // 读取当前返回的时间
                        var current_sec = Memory.readU64(this.tp).toNumber();
                        var current_nsec = Memory.readU64(this.tp.add(8)).toNumber();
                        var current_time = current_sec * 1000 + Math.floor(current_nsec / 1000000);
                        
                        // 检测异常快速的时间调用（可能是检测行为）
                        if (g_last_time > 0) {
                            var time_diff = current_time - g_last_time;
                           
                            // 如果时间间隔小于1毫秒，可能是检测行为
                            if (time_diff < 1) {
                                // 添加小的随机延迟，使时间看起来更自然
                                var fake_delay = Math.random() * 5 + 1; // 1-6毫秒
                                var new_time = g_last_time + fake_delay;
                                var new_sec = Math.floor(new_time / 1000);
                                var new_nsec = (new_time % 1000) * 1000000;
                                
                                Memory.writeU64(this.tp, new_sec);
                                Memory.writeU64(this.tp.add(8), new_nsec);
                                
                                g_last_time = new_time;
                                g_time_calls++;
                                return;
                            }
                        }
                        
                        // 正常情况下，允许时间自然流逝
                        g_last_time = current_time;
                        
                    } catch (e) {
                        // 如果出错，不修改时间
                    }
                }
            }
        });
    }
   
    // 也处理 gettimeofday
    var gettimeofdayPtr = Module.findExportByName("libc.so", "gettimeofday");
    if (gettimeofdayPtr) {
        Interceptor.attach(gettimeofdayPtr, {
            onEnter: function(args) {
                this.tv = args[0];
            },
            onLeave: function(retval) {
                if (retval.toInt32() === 0 && this.tv) {
                    try {
                        var current_sec = Memory.readU64(this.tv).toNumber();
                        var current_usec = Memory.readU64(this.tv.add(8)).toNumber();
                        var current_time = current_sec * 1000 + Math.floor(current_usec / 1000);
                        
                        if (g_last_time > 0) {
                            var time_diff = current_time - g_last_time;
                            if (time_diff < 1) {
                                var fake_delay = Math.random() * 5 + 1;
                                var new_time = g_last_time + fake_delay;
                                var new_sec = Math.floor(new_time / 1000);
                                var new_usec = (new_time % 1000) * 1000;
                                
                                Memory.writeU64(this.tv, new_sec);
                                Memory.writeU64(this.tv.add(8), new_usec);
                                
                                g_last_time = new_time;
                                return;
                            }
                        }
                        
                        g_last_time = current_time;
                    } catch (e) {
                        // 忽略错误
                    }
                }
            }
        });
    }
}

// 2. 选择性进程检测绕过 - 只阻止特定文件
function selectiveProcessBypass() {
    console.log("[+] 选择性进程检测绕过...");
   
    // 需要阻止的关键文件
    var blocked_files = [
        "/cmdline",
        "/status",
        "/comm",
        "/maps",
        "/stat"
    ];
   
    var fopenPtr = Module.findExportByName("libc.so", "fopen");
    if (fopenPtr) {
        Interceptor.attach(fopenPtr, {
            onEnter: function(args) {
                var filename = Memory.readUtf8String(args[0]);
                this.filename = filename;
               
                if (filename.indexOf("/proc/") === 0) {
                    // 只阻止特定的敏感文件
                    for (var i = 0; i < blocked_files.length; i++) {
                        if (filename.indexOf(blocked_files) !== -1) {
                            this.should_block = true;
                            g_proc_blocks++;
                            break;
                        }
                    }
                }
            },
            onLeave: function(retval) {
                if (this.should_block) {
                    // 不返回 NULL，而是重定向到 /dev/null
                    // 这样应用程序可以正常打开文件，但读取不到内容
                    if (retval.toInt32() !== 0) {
                        // 文件成功打开，但我们需要让它读取不到有用信息
                        // 这里暂时保持原样，在 read 函数中处理
                    }
                }
            }
        });
    }
   
    // Hook read 函数，修改敏感文件的读取内容
    var readPtr = Module.findExportByName("libc.so", "read");
    if (readPtr) {
        Interceptor.attach(readPtr, {
            onEnter: function(args) {
                this.fd = args[0].toInt32();
                this.buf = args[1];
                this.count = args[2].toInt32();
            },
            onLeave: function(retval) {
                if (retval.toInt32() > 0) {
                    try {
                        var content = Memory.readUtf8String(this.buf, Math.min(retval.toInt32(), 256));
                        
                        // 检查是否包含 Frida 相关信息
                        if (content.toLowerCase().indexOf("frida") !== -1 ||
                            content.indexOf("gum-js-loop") !== -1 ||
                            content.indexOf("gmain") !== -1) {
                           
                            // 替换为无害的内容
                            var fake_content = "com.android.systemui\n";
                            Memory.writeUtf8String(this.buf, fake_content);
                            retval.replace(fake_content.length);
                        }
                    } catch (e) {
                        // 忽略读取错误
                    }
                }
            }
        });
    }
}

// 3. 轻量级字符串检测绕过
function lightweightStringBypass() {
    console.log("[+] 轻量级字符串检测绕过...");
   
    var dangerous_strings = ["frida", "gum", "linjector"];
   
    var strstrPtr = Module.findExportByName("libc.so", "strstr");
    if (strstrPtr) {
        Interceptor.attach(strstrPtr, {
            onEnter: function(args) {
                try {
                    this.needle = Memory.readUtf8String(args[1]);
                } catch (e) {
                    this.needle = null;
                }
            },
            onLeave: function(retval) {
                if (this.needle) {
                    var needle_lower = this.needle.toLowerCase();
                    for (var i = 0; i < dangerous_strings.length; i++) {
                        if (needle_lower.indexOf(dangerous_strings) !== -1) {
                            retval.replace(0);
                            return;
                        }
                    }
                }
            }
        });
    }
}

// 4. 基础系统调用绕过
function basicSyscallBypass() {
    console.log("[+] 基础系统调用绕过...");
   
    var ptracePtr = Module.findExportByName("libc.so", "ptrace");
    if (ptracePtr) {
        Interceptor.attach(ptracePtr, {
            onEnter: function(args) {
                this.fake_result = true;
            },
            onLeave: function(retval) {
                if (this.fake_result) {
                    retval.replace(0);
                }
            }
        });
    }
}

// 5. 线程检测绕过 - 允许部分访问
function smartThreadBypass() {
    console.log("[+] 智能线程检测绕过...");
   
    var opendirPtr = Module.findExportByName("libc.so", "opendir");
    if (opendirPtr) {
        Interceptor.attach(opendirPtr, {
            onEnter: function(args) {
                var dirname = Memory.readUtf8String(args[0]);
                // 只阻止 /proc/self/task 目录访问
                if (dirname === "/proc/self/task") {
                    this.block_access = true;
                }
            },
            onLeave: function(retval) {
                if (this.block_access) {
                    retval.replace(0);
                }
            }
        });
    }
}





function hookVIPMethod() {
    Java.perform(function() {
        try {
            // 尝试直接使用类名
            let C4723T = Java.use("com.dz.business.base.utils.a$T");
            C4723T["pkU"].implementation = function (userInfo) {
                console.log('pkU is called' + ', ' + 'userInfo: ' + userInfo);
               
                try {
                    let UserInfoClass = userInfo.getClass();
            
                    // 修改vipStatus字段（Integer类型）
                    let vipStatusField = UserInfoClass.getDeclaredField("vipStatus");
                    vipStatusField.setAccessible(true);
                    vipStatusField.set(userInfo, Java.use("java.lang.Integer").valueOf(1)); // 设置为1，即激活状态
                    
                    // 同样修改vipType字段（Integer类型）
                    let vipTypeField = UserInfoClass.getDeclaredField("vipType");
                    vipTypeField.setAccessible(true);
                    vipTypeField.set(userInfo, Java.use("java.lang.Integer").valueOf(3)); // 设置为3，钻石VIP
                    
                    let backDateField = UserInfoClass.getDeclaredField("backDate");
                    backDateField.setAccessible(true);
                    backDateField.set(userInfo, Java.use("java.lang.Long").valueOf(2751505386000));

                    const FUTURE_DATE = "超级至尊会员";  // 永不过期
                      userInfo.setSvipEndDate(FUTURE_DATE);

            // 设置时间戳：2099-12-31 23:59:59 的时间戳（毫秒）
         
            // 设置会员描述信息
                      userInfo.setAuWatchDesc("至尊永久会员");

                    console.log('修改之后的 ' + userInfo);
                } catch (e) {
                    console.log("错误的原因: " + e.message);
                }

                let ret = this.pkU(userInfo);
                console.log('pkU ret value is ' + ret);
                return ret;
            };
            console.log("执行到了这里"+C4723T);
        } catch (e) {
            console.log("错误信息"+e);
            // 枚举类加载器
         
        }
    });
}



// 主函数
function main() {
    console.log("=".repeat(50));
    console.log("[+] 智能反检测脚本启动");
    console.log("[+] 使用平衡策略，避免应用程序卡死");
    console.log("=".repeat(50));
   
    try {
        smartTimeBypass();        // 智能时间处理
        selectiveProcessBypass(); // 选择性进程检测
        lightweightStringBypass(); // 轻量级字符串检测
        basicSyscallBypass();     // 基础系统调用
        smartThreadBypass();      // 智能线程检测
        hookVIPMethod();

        
        console.log("[+] 智能反检测脚本加载完成");
        console.log("[+] 应用程序应该可以正常运行");
        
    } catch (e) {
        console.log("[!] 错误: " + e.message);
    }
}

// 启动
main();

// 每60秒报告一次状态
setInterval(function() {
    if (g_time_calls > 0 || g_proc_blocks > 0) {
        console.log("[+] 状态: 处理了 " + g_time_calls + " 次异常时间调用, 阻止了 " + g_proc_blocks + " 次进程检测");
    }
}, 60000);

KD飞飞

牛掰