四虎永久在线精品免费影视,添逼小说,综合久久国产对白

上述文章中，詳細介紹了瑞數的特征、如何區分不同版本、瑞數的代碼結構以及各自的作用，本文就不再贅述了，不了解的同志可以先去看看之前的文章。

逆向目標

目標：瑞數 6 代
網站：aHR0cHM6Ly93d3cudXJidGl4LmhrLw==

Cookie 入口定位

與以往的四代、五代一樣，定位 Cookie，首選 Hook，通過 Fiddler 插件、油猴腳本、瀏覽器插件等方式注入以下 Hook 代碼：

(function() {
    var cookieTemp = "";
    Object.defineProperty(document, 'cookie', {
        set: function(val) {
            console.log('Hook捕獲到cookie設置- >', val);
            debugger;
            cookieTemp = val;
            return val;
        },
        get: function() {
            return cookieTemp;
        }
    });
})();

VM 代碼以及 $_ts 變量獲取

參考 5 代文章：人均瑞數系列，瑞數 5 代 JS 逆向分析

流程分析

與五代一致，用本地替換固定一套代碼。通過 (947, 1) 定位到加密流程入口，開始進行流程分析，從現在開始只需要 F9 操作，并且做好記錄，其中大部分流程與 5 代一致，可以參考之前的文章。下文中不會對流程中的每一步進行講解，只會記錄對結果有影響的關鍵步驟。

步驟1

這一步調用了一個方法，得到了一個類似時間戳的值，進入方法內部：

對兩個時間戳以及當前時間戳做了計算，記錄 _$MM，_$En 的值，后續還會用到。

步驟2

這里對兩個數組進行了拼接操作，_$4y 為 16 位數組，_$bx 為 4 位數組：

先來看 16 位數組 _$4y 的生成，搜索 _$4y =，可以定位到一處：

先看參數 _$yx._$N$ 的值，AMEExbhbQVYKGNjj8cTp.A，通過全局搜索可以發現這個值是在 JS 文件中：

再看 _$yx，觀察它的值，可以發現與 $_ts 一致，后續還會有多處會用到 _$yx:

參數值找到了，還剩方法 _$Vg 。進入方法內部，可以看到它進行了很多運算，這里直接扣下來就行：

16 位數組搞定了，還有 4 位數組 _$bx ，同樣進行搜索，一共有 6 處，其中 5 處能夠比較明顯的看出是 _$bx 的生成流程，全部打下斷點。首選創建了一個 4 位數組：

下面就是對數組的每一位進行了賦值，這段邏輯很簡單，但是實現卻比較復雜：

var _$3B = _$5W[_$yx._$Go](_$Ke, _$tm);
_$bx[1] = _$3B;  // 102
============================================
var _$I$ = _$5W[_$yx._$OA](_$dk);
_$bx[3] = _$I$;  // 102
============================================
var _$dk = _$5W[_$yx._$Lr]();
_$bx[2] = _$dk;  // 127
============================================
var _$j9 = _$5W[_$yx._$0f](_$jU, _$I$);
_$bx[0] = _$j9;  // 108

首先 _$yx._$xx 返回一個變量名，上文中講到了 _$yx 就是 $_ts 。然后 _$5W 是一個對象，里面存放著多個方法，根據_$yx._$xx 返回的變量名來調用對應的方法。_$5W 中的方法都有一個特點，就是結構相同，如下：

function _$Vk() {
    var _$pn = [249];
    Array.prototype.push.apply(_$pn, arguments);
    return _$2W.apply(this, _$pn);
}

這里其實不用在意方法內部做了什么，經測試可以發現，方法中的數組如 [249] 與方法最終結果值存在對應關系，我們只需要找到調用的方法中數組值就可以知道方法的返回值，這里直接將關系給出：

valueMap = {
    194: 103,
    274: 103,
    306: 100,
    251: 203,
    247: 0,
    272: 126,
    240: 103,
    290: 225,
    285: 203,
    249: 102,
    283: 102,
    298: 181,
    281: 11,
    256: 224,
    264: 181,
    266: 108,
    268: 240,
    302: 208,
    304: 180,
    308: 127,
    270: 101,
}

如 _$5W[_$yx._$Go](_$Ke, _$tm) ，這個方法中數組為 [249] ，而 249 對應的值為 102，那么 _$5W[_$yx._$Go](_$Ke, _$tm) 的返回值就是 102。

到這里就是 16 位數組和 4 位數組的生成，將它們拼接后得到一個 20 位數組。

步驟3

這里對時間戳進行了運算，_$tm 的值為步驟1中時間戳計算的結果 _$I$。

步驟4

步驟5

這里將步驟3、4中的結果存入數組賦值給了 _$xg。

步驟6

這里將兩位數組轉為了八位數組，進入 _$CY 方法內部看看，也是一些樸實無華的操作，扣下來即可：

步驟7

下面有一段較長的流程，都是在對一些自動化特征進行檢測，可以直接跳過：

步驟8

生成了一個 128 位數組，最終 cookie 也是由這個數組轉化得來：

步驟9

首先將步驟2中生成的 20 位數組存入 128 位數組：

步驟10

這四處值可以固定：

步驟11

這里 _$Ke 值為 4 位數組：

搜索 _$Ke 可以定位到生成點，由方法 _$Js 生成：

進入 _$Js 內部，發現值的生成由 _$Zb 實現：

進入 _$Zb，可以發現這行是用于生成 0 - 255 的隨機數：

那么 4 位數組的生成就解決了，由四個 0 - 255 間的隨機數組成。

步驟12

_$g5 為 8 位數組，這個數組的由來比較棘手，先搜索_$g5，一共有四處結果，全部斷下：

這里可以看到要找的值是 _$zi，但是 _$zi 出現的地方很多，通過搜索定位不到 8 位數組的生成位置，這里只能追棧，回到上一個棧：

可以看到 _$pn 中包含了一個字符串 zbOdssUZRkdTixew3tpf4WGN.rNLK_jWMTTqMIafmZV，這個字符串就是八位數組生成的關鍵值，經測試，這個字符串可以固定。那么 F9 繼續往下走：

這里會進入一個新分支，而生成的值就是我們要找的八位數組，跟進去：

到這里就找到了八位數組的生成點，_$mq 為上文中的字符串，_$gr 會生成隨機的 21 位數組，_$zW 生成最終八位數組：

先看 _$gr ，進入該方法，代碼如下。

var _$dk = _$Vg(_$2s(_$SK[46]) + _$yx._$1E);
return _$Gi(_$dk);

_$Vg 方法前文中已經講到了，扣下來即可。前文講到了，_$yx 就是 $_ts ，因此 _$yx._$1E 的值在網頁返回的代碼中，需要動態匹配。再看 _$2s，進入該方法：

var _$zi = _$mq % _$SK[83];
var _$uC = _$mq - _$zi;
_$zi = _$cl(_$zi);
_$zi ^= _$yx._$y3;
_$uC += _$zi;
return _$Yv[_$uC];

首先看方法 _$cl，需要關注的值是 _$yx._$O2，動態匹配即可：

var _$dk = [0, 1, _$SK[113], _$SK[11], _$SK[124], _$SK[41]];
return (_$k4 > > _$yx._$O2) | ((_$k4 & _$dk[_$yx._$O2]) < < (_$SK[91] - _$yx._$O2));

然后是 _$yx._$y3，同樣需要動態匹配。最后是 _$Yv ，這是一個 64 位數組，通過搜索 _$Yv[ 可以定位到它的生成點：

_$k4 的值也是網頁返回的 JS 代碼中的，需動態匹配，_$j9 方法直接扣下來即可。

到這里 _$dk 的值就能拿到了，得到的是一個 16 位數組。還剩 _$Gi，這個方法主要是對數組值進行了一些邏輯操作，缺啥補啥即可。

到這里 21 位數組也得到了，離最終的八位數組還剩 _$zW 方法，代碼如下：

var _$dk = _$Vg(_$k4);
var _$jU = new _$35(_$fO);
return _$jU._$ZL(_$dk, true);

_$Vg 講過了，_$35 中內容比較多，這里不做講解，缺啥補啥即可。

那么八位數組的生成就結束了。

步驟13

以下四處值可以固定：

步驟14

這里將一個八位數組 _$tj 的值添加到了數組中，而這個八位數組就是 步驟6 中生成的八位數組：

步驟15

這里將下標 12 的位置空了出來，其余各處值均可固定：

在該步驟中，也是對一些環境進行了檢測，流程較長，慢慢跟即可。

步驟16

其中 _$rt 固定為 https:443，_$wk 方法將字符串轉數組，該方法可以直接扣下來：

步驟17

這里會進入一個新分支，得到一個固定值，感興趣的可以跟進去看一下，流程比較長，主要是對 UA 等環境值進行了處理：

步驟18

這里對 128 位數組下標 12 的位置做了重新賦值，_$jU 的值為固定值，細心的朋友在前面幾個步驟的調試過程中會發現一些 | 運算，如 _$jU |= _$SK[189]; 這些就是在計算 _$jU 的值：

進入 _$8c 方法中，代碼如下：

[(_$k4 > >> _$SK[162]) & _$SK[4], (_$k4 > >> _$SK[189]) & _$SK[4], (_$k4 > >> _$SK[43]) & _$SK[4], _$k4 & _$SK[4]];

也是在進行一些邏輯運行，這里直接扣下來即可。

步驟19

這里對 128 位數組進行了切割，保留了有值的部分，得到一個 18 位數組：

步驟20

這行代碼利用了 concat 與 apply 方法將 18 位數組轉為了一個一維的大數組：

步驟21

這一步會進入一個新分支，得到一個 32 位的數組，跟進去：

兩個方法 _$BW 與 _$o9，_$o9 生成一個隨機的 37 位數組，_$BW 生成 32 位數組，先看 _$o9。：

_$o9 與步驟12中的 _$gr 方法相似，區別在于 _$2s 的參數值以及 _$yx._$BL：

var _$dk = _$Vg(_$2s(_$SK[66]) + _$yx._$BL);
_$sP(_$SK[152], _$dk.length !== _$SK[173]);
return _$Gi(_$dk);

然后看 _$BW ，在步驟12中提到了一個方法_$35，在扣 _$35 時也會遇到 _$BW，這里就單獨的講一下_$BW：

將代碼整理一下，如下：

function _$BW(_$k4) {
    var _$dk = _$k4.slice(0);
    if (_$dk.length < 5) {
        return;
    }
    var _$jU = _$dk.pop();
    var _$I$ = 0
    , _$IM = _$dk.length;
    while (_$I$ < _$IM) {
        _$dk[_$I$++] ^= _$jU;
    }
    var _$j9 = _$dk.length - 4;
    var _$Ff = _$PO() - _$0f(_$dk.slice(_$j9))[0];
    if (_$Ff > _$rT) {
        if (_$Ff > 255) {
            _$rT = 255;
        } else {
            _$rT = _$Ff;
        }
    }
    _$dk = _$dk.slice(0, _$j9);
    var _$df = parseFloat("11.678");
    var _$52 = Math.floor(Math.log(_$Ff / _$df + Math.floor("1.234")));
    var _$zi = _$dk.length;
    var _$Pa = _$yx._$AX[_$ic];
    _$I$ = 0;
    while (_$I$ < _$zi) {
        _$dk[_$I$] = _$52 | (_$dk[_$I$++] ^ _$Pa);
    }
    _$Db(_$SK[43], _$52);
    return _$dk;
}

可以發現關鍵點有三處，_$PO 、_$0f 與 _$yx._$AX。

_$PO 返回當前時間戳（秒）的四舍五入整數值。_$0f 方法則是數組進行轉換，其中涉及到一些邏輯運算，可以直接扣下來。_$yx._$AX 不用多說，需動態匹配。

這里就得到了一個 32 位數組，但是該分支還沒有結束，繼續往下走。

下面又對生成的 32 位數組進行了處理，得到一個 16 位數組，兩個方法 _$aT 與 _$9J：

_$aT 代碼整理后如下，直接用即可：

function _$aT(_$k4) {
    var _$dk = _$k4.slice(0, 16);
    var _$jU, _$I$ = 0, _$IM;
    _$IM = _$dk.length;
    while (_$I$ < _$IM) {
        _$jU = Math.abs(_$dk[_$I$]);
        _$dk[_$I$++] = _$jU > 256 ? 256 : _$jU;
    }
    return _$dk;
}

_$9J 代碼整理后如下，有一個_$4c 方法需注意，也是缺少補啥：

function _$9J() {
    var _$dk = new _$4c();
    for (var _$jU = 0; _$jU < arguments.length; _$jU++) {
        _$dk._$1l(arguments[_$jU]);
    }
    return _$dk._$Dt().slice(0, 16);
}

16 位數組跟完后繼續往下走，會生成另一個 16位數組，不過這個就比較簡單了，_$9J、_$BW、_$gr 在前文都已經提到了：

繼續往下走，會到一個for循環里面，這里對上面生成的 32 位數組以及 16 位數組進行處理，生成一個32 位數組：

到這里該分支就結束了，最終得到了32 位數組。

步驟22

下面主要是對時間戳進行了一些處理，涉及到的時間戳都來自于步驟1中：

這里通過時間戳計算得到了四個值，[1695610803, 1695611070, 394, -901278768]，下面又將這四個值轉成了一個 16 位的數組，_$CY 方法在上文中也提到了：

步驟23

這里對上一步中生成的數組進行了位異或操作：

在這里就生成了最終cookie的一部分，_$52 是上面處理后的 16 位數組，方法 _$Cj 前面沒有遇到，這里直接扣下來即可：

這里也是將瑞數的標識加上了，那么到這里 173 位 cookie 的第一部分就出來了：

步驟24

這里又進到了一個新分支：

首先取了一個值，也是需要動態匹配的：

然后將該值拼接到了一個數組 _$r3 后面，_$r3 的值就是 步驟20 中 18位數組合并成的新數組：

這里將數組轉成了一串數字：

進入方法_$hM 內部，主要涉及到了一個256 位數組 _$yx._$4y，這個值可以直接固定，整理代碼如下：

function _$hM(_$k4) {
    if (typeof _$k4 === _$A9(_$PM[7]))
        _$k4 = _$wk(_$k4);
    var _$dk = _$yx._$4y || (_$yx._$4y = _$iV());
    var _$jU = -1
    , _$I$ = _$k4.length;
    for (var _$IM = 0; _$IM < _$I$; ) {
        _$jU = (_$jU > >> -1) ^ _$dk[(_$jU ^ _$k4[_$IM++]) & 255];
    }
    return (_$jU ^ -1) > >> 0;
}

這里對那串數字進行了轉換，得到了一個四位數組，_$8c 上文已經提到了：

到這里該分支就結束了，得到了四位數組。

步驟25

這里將四位數組與 _$r3 進行了拼接：

_$dk 為 步驟21 中的 32 位數組，_$Cj 上文提到了，那么還剩 _$o$，也是缺啥補啥即可：

到這里 173 位 cookie 的第二部分就出來了，最后將兩部分拼接就得到了最終的 173 位 cookie ：

至此，逆向流程結束。

動態匹配

六代與五代最大的區別應該就是動態值的匹配方式發生了變化。數據匹配一般有兩種方案，正則和AST，這里推薦正則。

以 步驟2 中的四位數組為例：

var _$3B = _$5W[_$yx._$Go](_$Ke, _$tm);
var _$I$ = _$5W[_$yx._$OA](_$dk);
var _$dk = _$5W[_$yx._$Lr]();
var _$j9 = _$5W[_$yx._$0f](_$jU, _$I$);

前面已經講到了 _$3B 值與所引用的方法內部的一位數組存在映射關系，想要拿到值就需要找到對應的方法。已知 _$5W 是一個對象，里面包含所有方法，_$yx._$Go 返回一個字符串，根據返回的字符串來引用方法，得到結果。那么首先要定位 _$5W ，因為代碼是動態的，每一次這個包含方法的對象名都不一樣，所以這里就需要找到一個固定的關鍵字來進行定位。這里可以用 842, 來找到 _$5W。定位到 _$5W 后就可以通過 _$5W[ 來匹配四個索引：