HOOK脚本

最新推荐文章于 2024-05-14 19:02:10 发布
最新推荐文章于 2024-05-14 19:02:10 发布
阅读量351 收藏
点赞数
文章标签： javascript 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluedream21str/article/details/129659417
版权

(function() {
    'use strict';
    var xzz = {}
    !(function()  {
    'use strict';
    const $toString = Function.toString;
    const myFunction_toString_symbol = Symbol('('.concat('', ')_', (Math.random() + '').toString(36)));
    const myToString = function toString() {
        return typeof this == 'function' && this[myFunction_toString_symbol] || $toString.call(this);
    };
    function set_native(func,key,value) {
         try {
                Object.defineProperty(func, key, {
                    "enumerable": false,
                    "configurable": true,
                    "writable": true,
                    "value": value
                })
            } catch (e) {
                console.log("保护函数出错 => ", e)
                debugger
            }
    };
   // delete Function.prototype['toString'];
    set_native(Function.prototype,"toString",myToString);
    set_native(Function.prototype.toString,myFunction_toString_symbol,"function toString() { [native code] }")
    this.functionprotect = (func,func_name,type) => {
        set_native(func, myFunction_toString_symbol ,`function ${func_name || ''}() { [native code] }`);
    };
}).call(xzz);
    console.clear = function () {};
    xzz.functionprotect(console.clear,'clear');
    xzz.hook_env_name = ['window','document'];
    xzz.hook_env_blacklist = [];
    xzz.hook_env = [];;
    xzz.hook_env[0] = window;
    xzz.hook_env[1] = document;


    for (let l=0;l<xzz.hook_env_name.length;l++) {
        xzz[xzz.hook_env_name[l] + '_hook'] = []
        for (let func_name in xzz.hook_env[l]) {
            if (typeof xzz.hook_env[l][func_name] == 'function')  xzz[xzz.hook_env_name[l] + '_hook'].push(func_name)
        }
        for (let ll=0;ll< xzz[xzz.hook_env_name[l] + '_hook'].length;ll++) {
            if ( xzz[xzz.hook_env_name[l] + '_hook'][ll] == 'eval') continue;
            if ( xzz[xzz.hook_env_name[l] + '_hook'][ll] == 'assign') continue;
           xzz.hook_env[l][xzz[xzz.hook_env_name[l] + '_hook'][ll]] =  function(hook_func) {
                return function() {
                    let ret = hook_func.apply(this, arguments);
                    let time = new Date();
                    try {
                        console.log('[*] '+xzz.hook_env[l]+'->'+(this.__proto__ + '')+'hooked function-->'+hook_func.name+',arg:',arguments)
                    } catch (e) {
                        console.log('[*] '+xzz.hook_env[l]+'hooked function-->'+hook_func.name+',arg:',arguments)
                    }
                    console.log('[*] cookie:',document.cookie)
                    debugger
                    return ret;
                };
            }(xzz.hook_env[l][xzz[xzz.hook_env_name[l] + '_hook'][ll]]);
            xzz.functionprotect(xzz.hook_env[l][xzz[xzz.hook_env_name[l] + '_hook'][ll]],xzz[xzz.hook_env_name[l] + '_hook'][0]);
        }
    }

   xzz.cookie_ = '';
    Object.defineProperty(document, 'cookie', {
    //hook set方法也就是赋值的方法
    //当前也可以hook get方法
     set: function(val) {

            //这样就可以快速给下面这个代码行下断点
            //从而快速定位设置cookie的代码
         debugger
         console.log('[*]  Hook捕获到cookie设置->', val);
         xzz.cookie_ = val;
         return val;
     },

     get: function(val) {
            //这样就可以快速给下面这个代码行下断点
            //从而快速定位设置cookie的代码
          //  console.log('[*] Hook捕获到cookie获取->', val);
            return xzz.cookie_;
         }
    });
    xzz.proxy = function (obj, objname, type) {
    function isSymbol(value) {
        const type = typeof value
        return type === 'symbol' || type === 'object'
    }

    function isSymbol2(value) {
        const type = typeof value
        return type == 'symbol' || (type === 'object' && value != null && Object.prototype.toString.call(value) == '[object Symbol]')
    }

    function getMethodHandler(WatchName) {
        let methodhandler = {
            apply(target, thisArg, argArray) {
                let result = Reflect.apply(target, thisArg, argArray)
                if (isSymbol(result)) {
                    console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [${argArray.toString().slice(0, 60)}]`)
                } else {
                    if (argArray+''.length > 60) {
                        console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [function], result is [${result}].`)
                    }else{
                    console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [${argArray.toString().slice(0, 60)}], result is [${result}].`)
                    }


                }
                return result
            },
            construct(target, argArray, newTarget) {
                var result = Reflect.construct(target, argArray, newTarget)
                if (isSymbol(result)) {

                    console.log(`[${WatchName}] construct function name is [${target.name}], argArray is [${argArray.toString().slice(0, 60)}]`)
                } else {
                    if (argArray+''.length > 60) {
                        console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [function], result is [${result}].`)
                    }else{
                    console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [${argArray.toString().slice(0, 60)}], result is [${result}].`)
                    }
                    //
                }
                return result;
            }
        }
        return methodhandler
    }

    function getObjhandler(WatchName) {
        let handler = {
            get(target, propKey, receiver) {
                // if (propKey === "constructor"){
                //     debugger;
                // }
                if (propKey == 'length') {
                    xzzvm.memory.debuger.run('Proxy')
                }


                let result = Reflect.get(target, propKey, receiver)
                if (result instanceof Object && propKey !== 'cbb_id') {
                    if (typeof result === "function") {
                        if (isSymbol(propKey)) {
                            console.log(`[${WatchName}] getting propKey is [symbol] , it is function`)

                        } else {
                            // if (propKey !== 'cbb_id') {
                                console.log(`[${WatchName}] getting propKey is [${propKey}] , it is function`)
                            // }

                        }
                        return new Proxy(result, getMethodHandler(WatchName))
                    } else {
                        if (isSymbol(propKey)) {
                            console.log(`[${WatchName}] getting propKey is [msybol], result is [${(result)}]`);

                        } else {
                            // if (propKey !== 'cbb_id') {
                                console.log(`[${WatchName}] getting propKey is [${propKey}], result is [${(result)}]`);
                            // }

                        }
                    }
                    let paic = ["Function", "Array"]
                    if (paic.indexOf(propKey) != -1 || paic.indexOf(target) != -1 || isSymbol2(propKey)) {
                        return result

                    }
                    return new Proxy(result, getObjhandler(`${WatchName}.${propKey}`))
                    // return result
                }
                if (isSymbol(result)) {
                    // if (propKey !== 'cbb_id') {
                        console.log(`[${WatchName}] getting propKey is [${propKey?.description ?? propKey}]`)
                    // }

                } else {
                    // if (propKey !== 'cbb_id') {

                        console.log(`[${WatchName}] getting propKey is [${propKey?.description ?? propKey}], result is [${result}]`);
                    // }

                }
                return result;
            },
            set(target, propKey, value, receiver) {
                if (propKey === "innerHTML"){
                    debugger;
                }

                if (value instanceof Object) {
                    if (typeof value === "function") {
                        if (isSymbol(WatchName)) {
                            // if (propKey !== 'cbb_id') {
                                console.log(`[symbolName] setting propKey is [${propKey}] , it is function`)
                            // }

                        } else {
                            if (isSymbol(propKey)) {
                                console.log(`[${WatchName}] setting propKey is [symbolpropKey] , it is function`)

                            } else {
                                // if (propKey !== 'cbb_id') {
                                    console.log(`[${WatchName}] setting propKey is [${propKey}] , it is function`)
                                // }

                            }

                        }
                    } else if (isSymbol(value)) {
                        // if (propKey !== 'cbb_id') {
                            console.log(`[${WatchName}] setting propKey is [${propKey}]`)
                        // }
                    } else {
                        // if (propKey !== 'cbb_id') {
                            console.log(`[${WatchName}] setting propKey is [${propKey}], value is [${(value)}]`);
                        // }
                    }
                } else {
                    if (isSymbol(value)) {
                        // if (propKey !== 'cbb_id') {
                            console.log(`[${WatchName}] setting propKey is [${propKey}]`);
                        // }
                    } else {
                        // if (propKey !== 'cbb_id') {
                            console.log(`[${WatchName}] setting propKey is [${propKey}], value is [${value}]`);
                        // }
                    }
                }
                return Reflect.set(target, propKey, value, receiver);
            },
            has(target, propKey) {
                var result = Reflect.has(target, propKey);
                if (isSymbol(result)) {
                    // if (propKey !== 'cbb_id') {
                        console.log(`[${WatchName}] has propKey [${propKey}]`)
                    // }
                } else {
                    // if (propKey !== 'cbb_id') {
                        console.log(`[${WatchName}] has propKey [${propKey}], result is [${result}]`)
                    // }
                }
                return result;
            },
            deleteProperty(target, propKey) {
                if (propKey === "__fycb"){
                    return true
                }
                var result = Reflect.deleteProperty(target, propKey);
                if (isSymbol(result)) {
                    // if (propKey !== 'cbb_id') {
                        console.log(`[${WatchName}] delete propKey [${propKey}]`)
                    // }

                } else {
                    // if (propKey !== 'cbb_id') {
                        console.log(`[${WatchName}] delete propKey [${propKey}], result is [${result}]`)
                    // }

                }

                return result;
            },
            getOwnPropertyDescriptor(target, propKey) {
                var result = Reflect.getOwnPropertyDescriptor(target, propKey);
                if (isSymbol(result)) {
                    if (isSymbol2(propKey)) {
                        console.log(`[${WatchName}] getOwnPropertyDescriptor  propKey [symbol] result is [${(result)}]`)
                    } else {
                        // if (propKey !== 'cbb_id') {
                            if ('_$It' == ''+propKey){
                                eval('debu'+'gger')
                            // }
                            console.log(`[${WatchName}] getOwnPropertyDescriptor  propKey [${propKey}] result is [${(result)}]`)
                        }
                    }
                } else {
                    if (isSymbol(propKey)) {
                        console.log(`[${WatchName}] getOwnPropertyDescriptor  propKey `)
                    } else {
                        // if (propKey !== 'cbb_id') {
                            console.log(`[${WatchName}] getOwnPropertyDescriptor  propKey [${propKey}]`)
                        // }
                    }
                }
                return result;
            },
            defineProperty(target, propKey, attributes) {
                var result = Reflect.defineProperty(target, propKey, attributes);
                if (isSymbol(result)) {
                    // if (propKey !== 'cbb_id') {
                        console.log(`[${WatchName}] defineProperty propKey [${propKey}] attributes is [${(attributes)}], result is [${result}]`)
                    // }
                } else {
                    if (isSymbol(propKey)) {
                        console.log(`[${WatchName}] defineProperty propKey [symbolpropKey] attributes is [${(attributes)}]`)
                    } else {
                        // if (propKey !== 'cbb_id') {
                            console.log(`[${WatchName}] defineProperty propKey [${propKey}] attributes is [${(attributes)}]`)
                        // }
                    }
                }
                return result
            },
            getPrototypeOf(target) {
                var result = Reflect.getPrototypeOf(target)
                if (isSymbol(result)) {
                    console.log(`[${WatchName}] getPrototypeOf result is [${(result)}]`)

                } else {
                    console.log(`[${WatchName}] getPrototypeOf `)
                }
                return result;
            },
            setPrototypeOf(target, proto) {
                console.log(`[${WatchName}] setPrototypeOf proto is [${(proto)}]`)
                return Reflect.setPrototypeOf(target, proto);
            },
            preventExtensions(target) {
                console.log(`[${WatchName}] preventExtensions`)
                return Reflect.preventExtensions(target);
            },
            isExtensible(target) {
                var result = Reflect.isExtensible(target)
                console.log(`[${WatchName}] isExtensible, result is [${result}]`)
                return result;
            },
            ownKeys(target) {
                var result = Reflect.ownKeys(target)
                console.log(`[${WatchName}] invoke ownkeys, result is [${(JSON.stringify(result))}]`)
                if (typeof result === typeof []) {
                    let fo = result.indexOf("globalMy")
                    if (fo !== -1){
                        result.splice(fo,1)
                    }
                }

                return result
            },
            apply(target, thisArg, argArray) {
                let result = Reflect.apply(target, thisArg, argArray)
                if (isSymbol(result)) {
                    console.log(`[${WatchName}] apply function name is [${target.name}]`)

                } else {
                    if (argArray+''.length > 60) {
                        console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [function], result is [${result}].`)
                    }else{
                    console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [${argArray}], result is [${result}].`)
                    }

                }
                return result
            },

            construct(target, argArray, newTarget) {
                var result = Reflect.construct(target, argArray, newTarget)
                if (isSymbol(result)) {
                    console.log(`[${WatchName}] construct function name is [${target.name}]`)
                } else {
                    if (argArray+''.length > 60) {
                       console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [function], result is [${result}].`)
                    }else{
                    console.log(`[${WatchName}] apply function name is [${target.name}], argArray is [${argArray.slice(0, 60)}], result is [${result}].`)
                    }
                    //
                }
                return result;
            }
        }
        return handler;
    }

    if (type === "method") {
        return new Proxy(obj, getMethodHandler(objname));
    }
    return new Proxy(obj, getObjhandler(objname));
}

    localStorage = xzz.proxy(localStorage,'localStorage')

})();

心之筑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hook脚本注入动态库
05-25
XcodeHook其他app的脚本软件,可以快速修改签名信息,完成重签名
一个通杀的Hook脚本与例子
灰太的表格的博客
02-02 784
一个通杀的Hook脚本与例子
JavaScript常用的Hook脚本
瑞凯
05-25 1124
抄写一篇文文章， 自己记录 转载至以下文章 常见的Hook脚本 监听 键盘 与 鼠标 事件 // 判断是否按下F12 onkeydown事件 /* 提示： 与 onkeydown 事件相关联的事件触发次序: onkeydown onkeypress onkeyup */ // F12的键码为 123，可以直接全局搜索 keyCode == 123, == 123 ,keyCode document.onkeydown = function() { if (window.event &
js常用hook脚本
逆向新手的博客
07-30 2178
/严格模式，检查所有错误'usestrict'//document为要hook的对象,属性是cookieObject.defineProperty(document,'cookie',{//hookset方法也就是赋值的方法，get就是获取的方法set//这样就可以快速给下面这个代码行下断点，从而快速定位设置cookie的代码debugger;//在此处自动断下console.log('Hook捕获到set-cookie->',val);...
【app逆向】hook脚本详解（一）：基本的hook脚本使用
weixin_43822401的博客
11-05 1420
总结：hook是app逆向的高频操作，保留好本脚本留用。
Git Hook
weixin_33721344的博客
08-06 300
git hook 通过在代码commit和push之前执行一个脚本，来实现一些检查性工作
svn hook脚本，实现commit提交逻辑检查，评论格式，文件格式逻辑设定
05-25
svn上传管理时，经常需要规定固定的评论格式，还有文件格式限制，本示例实现了上述逻辑，需要的同学可以参考
FridaApp_Python的Hook脚本.zip
07-16
FridaApp_Python的Hook脚本.zip。 frida 框架下 ，通过 python 脚本 hook 安卓 app 的 java 函数
frida-script:储存自己的FRIDA HOOK脚本
07-24
frida-script 储存自己的FRIDA HOOK脚本
hook git仓库自动更新脚本
02-10
hook git仓库自动更新脚本,服务器自动更新部署
JS逆向hook通用脚本合集
z_ipython的博客
03-06 2558
JavaScript eval() 函数的作用是计算 JavaScript 字符串，并把它作为脚本代码来执行。如果参数是一个表达式，eval() 函数将执行表达式。如果参数是 Javascript 语句，eval() 将执行 Javascript 语句，经常被用来动态执行 JS。Cookie Hook 用于定位 Cookie 中关键参数生成位置，以下代码演示了当 Cookie 中匹配到了 v 关键字， 则插入断点。
【FridaHook整理】Frida安装及Hook安卓常用脚本
热门推荐
杰孑的博客
04-06 2万+
1 概述 在逆向过程中，Frida是非常常用的Hook工具，这个工具在日常使用的过程中，有很多通用方法，这里记录一下，方便查阅，部分函数使用的时候，可能需要稍微修改一下，本文记录是Android的方法，不涉及其他的 主要是搬迁的一下参考文章的片段 Android逆向之旅—Hook神器家族的Frida工具使用详解 Frida官方文档 看雪 Frida官方手册 - JavaScript API（篇一） 看雪 Frida官方手册 - JavaScript API（篇二） Js中几种String Byte转换方法
Frida Hook框架
TF的博客
05-03 770
Hook的原理简单地说就是，在这个新的函数中你想做什么都可以，为所欲为。
(PHP) git webhook 自动部署脚本
李青林的博客
10-24 966
在git管理中配置POST请求该方法进行自动调用 public function giteepush() { //git webhook 自动部署脚本 //项目存放物理路径,第一次clone时,必须保证该目录为空 $isClone = true;//设置是否已经Clone到本地,true:已经clone,直接pull,false:先clo...
油猴Tampermonkey脚本hook案例
一起学习哈
06-06 1480
注释内容解释@match这个注释的内容最为重要，它决定了你的脚本应用到哪个具体的网页，还是应用到所有的网页@run-at确定了脚本的注入时机，在js逆向中也很重要油猴脚本所有注释介绍属性名作用@name脚本的名字@namespace区分相同名称的脚本，一般写成作者名字或者网址就可以了@version版本号描述@author作者名字@match匹配的网址才会执行对应的脚本@grant。
爬虫（js逆向）hook实现方式-油猴脚本-javascript抠代码实战-硬抠高度ob混淆-应对内存溢出-debugger缩小范围（5）
稳稳C9的博客
07-18 2605
爬虫（js逆向）hook实现方式-油猴脚本-javascript抠代码实战-硬抠高度ob混淆-应对内存溢出-debugger缩小范围，hook对象属性，函数hook、javascript扣代码流程
TypeScript中的函数类型注解：精确定义行为与意图
逐星的博客
05-11 404
在TypeScript中，函数不仅是一段执行特定任务的代码块，它们还可以拥有自己的类型。函数类型注解允许开发者定义函数的参数类型和返回值类型，从而提高代码的可读性和可维护性。函数类型注解是TypeScript中定义函数时的重要特性，它有助于确保函数参数和返回值符合预期，从而提高代码的准确性和安全性。
(Vue3+TS+Volar) 全局组件配置类型声明的最佳实践
最新发布
从今年开始写写博客~~
05-14 208
简评：Volar官方全局组件的推荐写法，基于Volar，必须安装该插件，GlobalComponents是Volar专门为了解决全局组件类型而新增的类型接口。定义全局组件：使用GlobalComponents类型接口声明类型。
请帮我写一段frida的Hook脚本
02-06
好的，我会尽力帮助您。 这是一段使用 Frida 工具进行 Hook 的脚本示例： ```javascript // 导入 Frida 模块 const Frida = require('frida'); // 获取设备并启动会话 Frida.enumerateDevices().then(onDevicesEnumerated); function onDevicesEnumerated(devices) { const device = devices[0]; const session = device.attach('com.example.app'); // 在目标函数上定义 Hook const script = ` Interceptor.attach(Module.findExportByName("libnative.so", "function_name"), { onEnter: function(args) { // 在这里处理参数 console.log("function_name called with arguments: " + args[0] + ", " + args[1]); }, onLeave: function(retval) { // 在这里处理返回值 console.log("function_name returned: " + retval); } }); `; // 加载并运行脚本 session.createScript(script).load().then(onScriptLoaded); } function onScriptLoaded(script) { // 脚本加载成功后，即可开始监听 script.post({ type: 'listen' }); } ``` 在上面的脚本中，我们使用 `Interceptor.attach()` 方法在目标函数上定义了 Hook。在 `onEnter` 回调函数中，我们可以处理函数的参数；在 `onLeave` 回调函数中，我们可以处理函数的返回值。 希望这些信息能帮助您。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值