[ js.hook.js ]

javascript钩子; 劫持方法/伪造参数/篡改结果/还原劫持
目前为 2015-11-24 提交的版本。查看最新版本。
换行
// ==UserScript==
// @name  [ js.hook.js ]
// @description javascript钩子; 劫持方法/伪造参数/篡改结果/还原劫持
// @namespace js.hook.js
// @version 0.0.2
// @author  vc1
// ==/UserScript==
 
 
 
;
(function (name, ctx) {
 
    /*
     *
     *  [ js.hook.js ]
     *
     *  javascript钩子
     *
     *  * 劫持方法
     *  * 伪造参数
     *  * 篡改结果
     *  * 还原劫持
     *
     *  * 2015-11-24
     *  * vc1
     *
     */
 
    // 'use stric'
 
    var definition = (function () {
 
        /*
         * 入口方法
         *
         * hook(alert)
         * hook('window.alert')
         * hook('MyOjbect.User.info.edit')
         */
        function hook() {
            if (this instanceof hook) {
                return hook.prototype.__init__.apply(this, arguments);
            }
 
            var t = hook.prototype.__getTarget__.apply(null, arguments);
 
            // 已经劫持过了，返回已有的钩子
            if (hook.prototype.storage[t.fn_object_name] && hook.prototype.storage[t.fn_object_name][t.fn_name]) {
                return hook.prototype.storage[t.fn_object_name][t.fn_name].exports;
            }
 
            return new hook(t.fn_object, t.fn_object_name, t.fn_name, t.fn_real);
        }
 
        hook.prototype.storage = {};
        var eval = window.eval;
 
        hook.prototype.__init__ = function (fn_object, fn_object_name, fn_name, fn_real) {
            // 原始方法正身
            this.fn_real = fn_real;
            // 被劫持的方法名
            this.fn_name = fn_name;
            // 被劫持的方法所在对象，默认 window
            this.fn_object = fn_object;
            // 所在对象名称
            this.fn_object_name = fn_object_name;
            // 伪造传入参数
            this.fakeArgFn = null;
            // 伪造返回结果
            this.fakeRstFn = null;
            // 对外暴露的功能
            this.exports = {
                fake: this.fake.bind(this),
                fakeArg: this.fakeArg.bind(this),
                fakeRst: this.fakeRst.bind(this),
                off: this.off.bind(this),
                offArg: this.offArg.bind(this),
                offRst: this.offRst.bind(this),
            };
 
            var t = this;
            this.exports_var = Object.defineProperties({},
            {
                'fn_real': {
                    value: fn_real,
                    enumerable: true
                },
                'fn_name': {
                    value: fn_name,
                    enumerable: true
                },
                'fn_object_name': {
                    value: fn_object_name,
                    enumerable: true
                },
                'fn_object': {
                    value: fn_object,
                    enumerable: true
                },
                fakeArgFn: {
                    get: function () {
                        return t.fakeArgFn;
                    }
                },
                fakeRstFn: {
                    get: function () {
                        return t.fakeRstFn;
                    }
                }
            });
            // 保存当前钩子
            this.storage[fn_object_name] = this.storage[fn_object_name] || {};
            this.storage[fn_object_name][fn_name] = this;
 
            return this.exports;
        };
 
        // 支持多种输入形式
        hook.prototype.__getTarget__ = function () {
            var fn_real, // 原始方法正身
                fn_name = 'alert',
                // 被劫持的方法名
                fn_object_name = "Window",
                fn_object = window; // 被劫持的方法所在对象，默认 window
            if (arguments.length === 1) {
                var arg = arguments[0];
                // 传入字符串
                if (arg.__proto__ === String.prototype) {
                    var dotidx = arg.lastIndexOf('.');
                    if (~dotidx) { // 'window.alert'
                        fn_object_name = arg.slice(0, dotidx);
                        fn_object = eval(fn_object_name);
                        fn_name = arg.slice(dotidx + 1);
                        fn_real = fn_object[fn_name];
                    } else { // 'alert'
                        fn_name = arg;
                    }
                } else { // 传入一个方法，所在对象默认 window
                    fn_real = arg;
                    fn_name = fn_real.name;
                }
            } else if (arguments.length == 2) { // 不推荐
                fn_real = fn_object[fn_name];
                fn_name = arguments[1];
                fn_object = arguments[0];
                fn_object_name = fn_object.constructor.name;
            }
 
            if (!(fn_object && fn_name && fn_real)) {
                console.error(fn_object);
                console.error(fn_object_name);
                console.error(fn_name);
                console.error(fn_real);
                throw new Error('hook fail');
            }
 
            return {
                'fn_real': fn_real,
                'fn_name': fn_name,
                'fn_object': fn_object,
                'fn_object_name': fn_object_name,
            };
        };
 
        /*
         * 替换原始方法
         *
         * 作用等于 temp=alert; alert=function(){// your function}
         *
         * fakeFn(arguments, t.exports_var, scope, this)
         * 接收到的参数列表, 原始方法信息, 对象实例或原对象, 执行时的作用域
         *
         */
        hook.prototype.fake = function (fakeFn) {
            var t = this;
            var puppet = eval("(function " + this.fn_real.name + "() {" +
                "var scope = this instanceof t.fn_object.constructor ? this :" +
                "    t.fn_object;" +
                "return fakeFn.call(scope, arguments, t.exports_var.fn_real, scope, t.exports_var, this);" +
                "})");
            for (var prop in this.fn_real) {
                puppet[prop] = this.fn_real[prop];
            }
            puppet.toString = function () {
                return 'function ' + t.fn_real.name + '() { [native code] }';
            };
            this.fn_object[this.fn_name] = puppet;
            return this.exports;
        };
 
        /*
         * 在原方法前，劫持传入的参数
         *
         * fakeArg('直接替换为要传入的参数', ...)
         * fakeArg(function(原参数,){
         *     //
         *     return [修改后的参数]
         * })
         *
         * 无返回则采用原始参数
         */
        hook.prototype.fakeArg = function (arg) {
            this.__fakeArgRst__();
            this.fakeArgFn = this.__getFun__(arguments);
            return this.exports;
        };
 
        /*
         * 在原方法后，劫持返回的数据
         *
         * fakeRst('直接替换为要传入的参数')
         * fakeRst(function(原返回值){
         *     //
         *     return 修改后的返回值
         * })
         */
        hook.prototype.fakeRst = function (arg) {
            this.__fakeArgRst__();
            this.fakeRstFn = this.__getFun__(arg);
            return this.exports;
        };
 
 
        /*
         * 开启劫持arg/rst
         */
        hook.prototype.__fakeArgRst__ = function () {
            var t = this;
            var fakeArgRstFn = function (args, fn_real, scope, t, raw_this) {
                var faked_arg = t.fakeArgFn ? t.fakeArgFn.apply(scope, args) || args : args;
                faked_arg && !Array.isArray(faked_arg) &&
                    (!faked_arg.hasOwnProperty('callee') && !faked_arg.hasOwnProperty('length')) &&
                    (faked_arg = [faked_arg]);
                var real_rst = t.fn_real.apply(scope, faked_arg);
                var faked_rst = t.fakeRstFn ? t.fakeRstFn.call(scope, real_rst) : real_rst;
                return faked_rst;
            };
            this.fake(fakeArgRstFn);
        };
 
        /*
         * 关闭劫持
         *
         * 传入参数为空：关闭前后所有劫持   hook(alert).off()
         * 传入字符串 "arg" 或 "rst"：关闭对应劫持   hook(alert).off('arg')
         * 传入方法：关闭对应劫持
         *
         * 前后劫持全部关闭后，还原被 hook 的方法
         */
        hook.prototype.off = function (filter) {
            if (!filter) {
                delete this.fakeArgFn;
                delete this.fakeRstFn;
            } else if (typeof filter === 'function' || filter.__proto__ === String.prototype) {
                (this.fakeArgFn === fn || filter === 'arg') && delete this.fakeArgFn;
                (this.fakeRstFn === fn || filter === 'rst') && delete this.fakeRstFn;
            }
 
            if (!this.fakeArgFn && !this.fakeRstFn) {
                this.fn_object[this.fn_name] = this.fn_real;
                //delete this.storage[this.fn_object_name][this.fn_name];
            }
 
            return this.exports;
        };
 
        /*
         * 关闭前面的参数劫持
         *
         */
        hook.prototype.offArg = function (filter) {
            filter = filter || 'arg';
            this.off(filter);
            return this.exports;
        };
 
        /*
         * 关闭后面的结果劫持
         *
         */
        hook.prototype.offRst = function (filter) {
            filter || 'rst';
            this.off(filter);
            return this.exports;
        };
 
 
        /*
         * 直接修改参数或返回结果
         */
        hook.prototype.__getcloser__ = function (args) {
            return function () {
                return args;
            };
        };
        hook.prototype.__getFun__ = function (arg) {
            return typeof arg[0] == 'function' ? arg[0] : this.__getcloser__(arg);
        };
 
        return hook;
 
    });
 
    //检测上下文环境是否为AMD或CMD
    var hasDefine = typeof define === 'function',
        // 检测上下文环境是否为Node
        hasExports = typeof module !== 'undefined' && typeof module !== 'function' && module.exports;
    if (!name) {
        return definition();
    } else if (ctx) {
        // 设置环境后则挂载到此对象
        /*
        void function(name, ctx){
            ...
        }('hook', window);
        */
        ctx[name] = definition();
    } else if (hasDefine) {
        //AMD环境或CMD环境
        define(name, definition);
    } else if (hasExports) {
        //定义为普通Node模块
        module.exports = definition();
    }
    return definition();
 
 
 
    // 效果演示
 
    /*
 
 
 
    window.tool = {
        say: '一个计算器开始工作了：',
        calc: function (msg, n) {
            console.log(this.say);
            console.warn('calc收到参数：' + msg + ', ' + n);
            var r = n * n;
            console.warn('calc结果：' + r);
            return r;
        }
    }
 
    var hook = window.js_hook_js;
 
    console.clear();
    console.info('一个计算器：');
 
    console.group('原始方法：\n\ntool.calc');
    console.log(tool.calc);
    console.info('设置参数：' + '专注于计算平方的计算器' + ', ' + 42);
    console.info('接收到的结果：' + tool.calc('专注于计算平方的计算器', 42));
    console.groupEnd();
    console.log('\n');
 
    console.group("劫持后：\n\nhook('window.tool.calc').fakeArg('这个计算器坏了', -1).fakeRst('<(ˉ^ˉ)> 告诉你坏了');");
    hook('window.tool.calc').fakeArg('这个计算器坏了', -1).fakeRst('<(ˉ^ˉ)> 告诉你坏了');
    console.log(tool.calc);
    console.info('设置参数：' + '专注于计算平方的计算器' + ', ' + 42);
    console.info('接收到的结果：' + tool.calc('专注于计算平方的计算器', 42));
    console.groupEnd();
    console.log('\n');
 
    console.group("还原后：\n\nhook('window.tool.calc').off();");
    hook('window.tool.calc').off();
    console.log(tool.calc);
    console.info('设置参数：' + '专注于计算平方的计算器' + ', ' + 42);
    console.info('接收到的结果：' + tool.calc('专注于计算平方的计算器', 42));
    console.groupEnd();
    console.log('\n');
 
    console.group("替换：\n\nhook('window.tool.calc').fake(function(){...})");
    hook('window.tool.calc').fake(function (args, fn_real, scope, h, raw_scope) {
        console.log('调用者：' + args.callee.caller);
        console.log('this：');
        console.log(this);
        console.log('args：');
        console.log(args);
        console.log('fn_real：');
        console.log(fn_real);
        console.log('scope：');
        console.log(scope);
        console.log('h：');
        console.log(h);
        console.log('raw_scope：');
        console.log(raw_scope);
        return fn_real.apply({
            say: '怎么还是那个计算器：'
        }, args);
    });
    console.log(tool.calc);
    console.info('设置参数：' + '专注于计算平方的计算器' + ', ' + 42);
    console.info('接收到的结果：' + (function calc_caller() {
        return tool.calc.call({
            say: '换个计算器吧'
        }, '专注于计算平方的计算器', 42);
    })());
    console.groupEnd();
    console.log('\n');
 
 
 
    */
 
})('js_hook_js', window);