精易论坛

标题: 解锁繁花剧场会员 [打印本页]

作者: 电脑简单 时间: 5 天前
标题: 解锁繁花剧场会员
先搜索VIP  发现这2个很可疑[attach]1379085[/attach]

查找调用处发现这个方法进行了调用
[attach]1379086[/attach]

继续一步一步的跟进去
[attach]1379087[/attach]
[attach]1379088[/attach]

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

先试一下frIDA hook  一下
[attach]1379089[/attach]

果然有检测

好了先写过检测的脚本费了九牛二虎之力终于写好了
[attach]1379090[/attach]

我们再来看看原先的我们打开的界面
[attach]1379091[/attach]

hook 之后的
[attach]1379092[/attach]

好了大功告成帖子写的不是好
请见谅 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飞飞 时间: 5 天前
牛掰

欢迎光临精易论坛 (https://125.confly.eu.org/)