webpack逆向加载器

1.webpack是什么
概念：Webpack 是一种用于构建 JavaScript 应用程序的静态模块打包器，它能够以一种相对一致且开放的处理方式，加载应用中的所有资源文件（图片、CSS、视频、字体文件等），并将其合并打包成浏览器兼容的 Web 资源文件。
功能：

模块的打包：通过打包整合不同的模块文件保证各模块之间的引用和执行
代码编译：通过丰富的loader可以将不同格式文件如.sass/.vue/.jsx转译为浏览器可以执行的文件
扩展功能：通过社区丰富的plugin可以实现多种强大的功能，例如代码分割、代码混淆、代码压缩、按需加载.....等等

webpack加载器形式

!function(x){
    function xx(n){
        return ..call(**.exports, ***, ***.exports, xx)
    }
    }()

1.先去找加密网站的加密入口。全局搜索，hook参数
2.找到分发器的位置，或者说是加载器，就比如上方中的exports的位置
3.用到了哪些模块就导入哪些模块
4.将函数入口的地方返回全局，最终返回

以aHR0cHM6Ly9zeW5jb25odWIuY29zY29zaGlwcGluZy5jb20v的加载器为例，分析webpack加载器逻辑

!function (e) {
    function t(t) {
        for (var i, r, c = t[0], s = t[1], u = t[2], l = 0, M = []; l < c.length; l++)
            r = c[l],
            Object.prototype.hasOwnProperty.call(o, r) && o[r] && M.push(o[r][0]),
                o[r] = 0;
        for (i in s)
            Object.prototype.hasOwnProperty.call(s, i) && (e[i] = s[i]);
        for (d && d(t); M.length;)
            M.shift()();
        return a.push.apply(a, u || []),
            n()
    } //加载需要的模块

    function n() {
        for (var e, t = 0; t < a.length; t++) {
            for (var n = a[t], i = !0, r = 1; r < n.length; r++) {
                var s = n[r];
                0 !== o[s] && (i = !1)
            }
            i && (a.splice(t--, 1),
                e = c(c.s = n[0]))
        }
        return e
    } //启动函数

    var i = {}
        , r = {
        app: 0
    }
        , o = {
        app: 0
    }
        , a = [];

    function c(t) {
        if (i[t])
            return i[t].exports;
        var n = i[t] = {
            i: t,
            l: !1,
            exports: {}
        };
        return e[t].call(n.exports, n, n.exports, c),
            n.l = !0,
            n.exports
    }// webpack加载器
    sign = c;
    c.e = function (e) {"..."} //具体代码过长，动态加载所需要的静态资源
        ,
        c.m = e,
        c.c = i,
        c.d = function (e, t, n) { // e:n.exports, t:"b", n:return r
            c.o(e, t) || Object.defineProperty(e, t, {
                enumerable: !0,
                get: n
            })
        } //模块已存在则调用，不存在则添加
        ,
        c.r = function (e) {
            "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e, Symbol.toStringTag, {
                value: "Module"
            }),
                Object.defineProperty(e, "__esModule", {
                    value: !0
                })
        } 
        ,
        c.t = function (e, t) {
            if (1 & t && (e = c(e)),
            8 & t)
                return e;
            if (4 & t && "object" == typeof e && e && e.__esModule)
                return e;
            var n = Object.create(null);
            if (c.r(n),
                Object.defineProperty(n, "default", {
                    enumerable: !0,
                    value: e
                }),
            2 & t && "string" != typeof e)
                for (var i in e)
                    c.d(n, i, function (t) {
                        return e[t]
                    }
                        .bind(null, i));
            return n
        }
        ,
        c.n = function (e) {
            var t = e && e.__esModule ? function () {
                        return e.default
                    }
                    : function () {
                        return e
                    }
            ;
            return c.d(t, "a", t),
                t
        }
        ,
        c.o = function (e, t) {
            return Object.prototype.hasOwnProperty.call(e, t)
        }
        ,
        c.p = "/",
        c.oe = function (e) {
            throw e
        }
    ;
    var s = this.webpackJsonp = this.webpackJsonp || []
        , u = s.push.bind(s); //将s.push函数指针指向最开始的s
    s.push = t,
        s = s.slice();
    for (var l = 0; l < s.length; l++)
        t(s[l]);
    var d = u;
    a.push([1, "chunk-elementUI", "chunk-libs"]), //加载其它文件中的模块
        n()
}({
    MuMZ: function(e, t, n){"..."},
    XBrZ: function(t, e, r){"..."}
        ...
})

网站中调用MuMZ模块对参数进行了加密，通过跟栈得知c函数为本次webpack结构中的加载器，可以通过将c函数全局变量化，方便调用MuMZ函数中的逻辑。
由于自执行函数，在MuMZ下继续添加MuMZ函数中依赖的模块，去成功调用加密函数