关于javaScript逆向hook里面的cookie以及其他常用hook汇总

62 阅读 0 评论 41 点赞

我是靠谱客的博主饱满缘分，最近开发中收集的这篇文章主要介绍关于javaScript逆向hook里面的cookie以及其他常用hook汇总，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

个人理解：hook某个元素，实际上就是定位某个元素，例如cookie里面有个abc为名字，123为值，我们要查找设置cookie={abc:123}的位置，首先就要知道，cookie的设置是set方法，再例如发送一个ajax请求，就需要明确的知道，发送ajax需要有一个XMLHttpRequest对象，这个对象会用到open方法，在open方法中使用了url,要hook到url，实际上就是对open方法的重写，同理，hook到cookie时，也是对设置cookie的set方法进行重写
总结：hook就是对某个js对象里面方法的重写

var xhr = new XMLHttpRequest();
xhr.open(method, url, async, username, password);
// method：HTTP 请求方法，必须参数，值包括 POST、GET 和 HEAD，大小写不敏感。
// url：请求的 URL 字符串，必须参数，大部分浏览器仅支持同源请求。
// async：指定请求是否为异步方式，默认为 true。如果为 false，当状态改变时会立即调用onreadystatechange 属性指定的回调函数。
// username：可选参数，如果服务器需要验证，该参数指定用户名，如果未指定，当服务器需要验证时，会弹出验证窗口。
// password：可选参数，验证信息中的密码部分，如果用户名为空，则该值将被忽略。
xhr.send(body);

hooke到cookie写法一,据说__lookupSetter__和__lookupGetter__已经被某些浏览器弃用了

var code = function(){
    var org = document.cookie.__lookupSetter__('cookie');
    document.__defineSetter__("cookie",function(cookie){
        if(cookie.indexOf('cookie的参数名称')>-1){
            debugger;
        }
        org = cookie;
    });
    document.__defineGetter__("cookie",function(){return org;});
}
// 如果使用浏览器插件，实际上下面四行没有必要使用，下面四行是在浏览器刚加载第一个js的首行时下断点用的，刷新浏览器就没用了
var script = document.createElement('script');
script.textContent = '(' + code + ')()';
(document.head||document.documentElement).appendChild(script);
script.parentNode.removeChild(script);

/hook到cookie写法二，ES6支持的写法，长期可用


(function() {
    "use strict";
    var cookieTemp = "";
    Object.defineProperty(document, "cookie", {
        writable: false, // 表示能否修改属性的值，即值是可写的还是只读
        configurable: false, // 表示能否通过 delete 删除属性、能否修改属性的特性，或者将属性修改为访问器属性
        set: function(val) {
            if (val.indexOf("cookie的参数名称") != -1) {
                debugger ;
            }
            console.log("Hook捕获Cookie设置->", val);
            cookieTemp = val;
            return val;
        },
 
        get: function() {
            return cookieTemp;
        }
    })
}
)();

hook到header中包含Authorization时


var code = function(){
var org = window.XMLHttpRequest.prototype.setRequestHeader;
window.XMLHttpRequest.prototype.setRequestHeader = function(key,value){
    if(key=='Authorization'){
        debugger;
    }
    return org.apply(this,arguments);
}
}
var script = document.createElement('script');
script.textContent = '(' + code + ')()';
(document.head||document.documentElement).appendChild(script);
script.parentNode.removeChild(script);

hook请求的url里包含abc时


var code = function(){
var open = window.XMLHttpRequest.prototype.open;
window.XMLHttpRequest.prototype.open = function (method, url, async){
    if (url.indexOf("abc")>-1){
        debugger;
    }
    return open.apply(this, arguments);
};
}
var script = document.createElement('script');
script.textContent = '(' + code + ')()';
(document.head||document.documentElement).appendChild(script);
script.parentNode.removeChild(script);

hook到 constructor 构造器构造出来的debugger

var _constructor = constructor;
Function.prototype.constructor = function(s) {
    if (s == "debugger") {
        console.log(s);
        return null;
    }
    return _constructor(s);
}

hook到 eval构造器构造出来的debugger

(function() {
    'use strict';
    var eval_ = window.eval;
    window.eval = function(x) {
        eval_(x.replace("debugger;", "  ; "));
    }
    ;
    window.eval.toString = eval_.toString;
}
)();

hook到json的stringify或者parse时

var my_stringify = JSON.stringify;
JSON.stringify = function (params) {
    //这里可以添加其他逻辑比如 debugger
    console.log("json_stringify params:",params);
    return my_stringify(params);
};

var my_parse = JSON.parse;
JSON.parse = function (params) {
    //这里可以添加其他逻辑比如 debugger
    console.log("json_parse params:",params);
    return my_parse(params);
};

window属性的属性hook，例如：window._t.ccc = “XXX”

// 定义hook属性
var window_flag_1 = "_t";
var window_flag_2 = "ccc";
var key_value_map = {};
var window_value = window[window_flag_1];
// hook
Object.defineProperty(window, window_flag_1, {
    get: function(){
        console.log("Getting",window,window_flag_1,"=",window_value);
        //debugger
        return window_value
    },
    set: function(val) {
        console.log("Setting",window, window_flag_1, "=",val);
        window_value = val;
        key_value_map[window[window_flag_1]] = window_flag_1;
        set_obj_attr(window[window_flag_1],window_flag_2);
});
function set_obj_attr(obj,attr){
    var obj_attr_value = obj[attr];
    Object.defineProperty(obj,attr, {
        get: function() {
            console.log("Getting", key_value_map[obj],attr, "=", obj_attr_value);
            //debugger
            return obj_attr_value;
        },
        set: function(val){
            console.log("Setting", key_value_map[obj], attr, "=", val);
            obj_attr_value = val;
    });
}

hook过掉debugger

(()=>{
    Function.prototype.__constructor = Function.prototype.constructor;
    Function.prototype.constructor = function(){
        if(arguments && typeof arguments[0]==='string'){
            if("debugger"===arguments[0]){
                return
            }
            return Function.prototype.__constructor.apply(this,arguments);
        }
    }
})()