js相关hook

混淆中常见

    /*apply()方法*/
    function.apply(thisObj[, argArray])
    
    /*call()方法*/
    function.call(thisObj[, arg1[, arg2[, [,...argN]]]]);

this常用用法
1.在一般函数方法中使用 this 指代全局对象
2.作为对象方法调用，this 指代上级对象
3.作为构造函数调用，this 指代new 出的对象
4.apply 调用 ，apply方法作用是改变函数的调用对象，此方法的第一个参数为改变后调用这个函数的对象，this指代第一个参数

连续赋值

用内存和引用的思想理解

var a = {n: 1};
var b = a;  
a.x = a = {n: 2};
console.log(a.x);  
console.log(b.x);

我们知道js的赋值运算顺序永远都是从右往左的，不过由于“.”是优先级最高的运算符，所以这行代码先“计算”了a.x,给对象添加了一个x属性，也就是b指的，接着赋值从右往左，a重新指向，并把a重新指向的赋值 给x属性。
b指向的对象不变
a指向的对象变化了
结果 a:{n:2} b:{n:1,x: {n: 2}}

字段hook

坑之一下面定义var会出错，var是函数作用域,let是块作用域

function observeKey(obj) {
    for (let key in obj) {
        let value = obj[key];
        console.log("key", key)
        Object.defineProperty(obj, key, {
            get() {
                console.log("读取属性", key, value);
                return value;
            },
            set(newValue) {
                var value = "";
                console.log("设置属性", newValue);
                value = newValue;
            }
        });

    }
}

function Person(name, age) {
    this.name = name;
    this.age = age;
    this.run = function() {
        console.log("run");
    }
}
Person.prototype.work = function() {
    console.log("work");
}

Person.prototype.sex = '男'

//静态方法
Person.fun = function() {
    console.log("fun 静态方法")
}

// var obj1 = Person;
// observeKey(obj1);
// console.log(obj1.fun());

var obj2 = new Person("name",18);
observeKey(obj2);
console.log(obj2.work());

函数hook

在原先hook基础上，做了下优化处理

function Hooks() {
    return {
        initEnv: function() {
            function getFuncName(fn) {
                // 获取函数名
                var strFunc = fn.toString();
                var _regex = /function\s+(\w+)\s*\(/;
                var patten = strFunc.match(_regex);
                if (patten) {
                    return patten[1];
                }
                return '';
            }

            Function.prototype.hook = function(hookFunc, context) {
                var _context = context || window;
                var _funcName =  getFuncName(this);;
                if (!_funcName || _context[_funcName].prototype && _context[_funcName].prototype.isHooked) {
                    console.log("Already has been hooked,unhook first");
                    return false;
                }
                _context['realFunc_' + _funcName] = this;
                try {
                    eval('_context[_funcName] = function ' + _funcName + '(){\n' + 'var args = Array.prototype.slice.call(arguments,0);\n' + 'var obj = this;\n' + 'hookFunc.apply(obj,args);\n' + "return _context['realFunc_" + _funcName + "'].apply(obj,args);\n" + '};');
                    _context[_funcName].prototype.isHooked = true;

                    return true;
                } catch (e) {
                    console.log("Hook failed,check the params.");
                    return false;
                }
            }
            Function.prototype.unhook = function(context) {
                var _context = context || window;;
                var _funcName = getFuncName(this);
                if (!_funcName || !_context[_funcName].prototype.isHooked) {
                    console.log("No function is hooked on");
                    return false;
                }
                _context[_funcName] = _context['realFunc_' + _funcName];
                delete _context['realFunc_' + _funcName];
                return true;
            }
        },
        cleanEnv: function() {
            if (Function.prototype.hasOwnProperty("hook")) {
                delete Function.prototype.hook;
            }
            if (Function.prototype.hasOwnProperty("unhook")) {
                delete Function.prototype.unhook;
            }
            return true;
        }
    };
}

var hook = Hooks();
hook.initEnv();
// 这个是要执行的正常的函数
function test() {
    console.log(arguments[0]);
}
// 这个是钩子函数
function hookFunc() {
    console.log("hookFunc");
}

// hookFunc钩住test
test.hook(hookFunc, window);
test.hook(hookFunc, window);
test("haha");
test.unhook();
test("haha");