某数据网站search_company_for_lib接口payload和sig值的生成

七八年前抓过一些企业相关的数据，那个时候经济好，风投多，各种风投公司钱多找个中心新公司投资，程序员和爬虫的公司也飞速上涨，比起现在经济真的好怀念啊。

最近可能要换工作，新公司可能要高一些企业数据估计还要一些创投融资相关的数据，于是想起来了当时比较火的几个平台，先简单看看。萝卜投研、犀牛数据、创业邦、36克、钛媒体之类的。

今天看的这个比较麻烦，参数加密了返回的数据竟然也加密了。

第一步点击看下接口加载了那些数据。

请求参数有两个，一个长的一个短的，长的估计可以还原的就是des或者aes之类的。短的看着像是 md5.

返回数据大概率 还是des,L开头大概率是，之前做的一个网站全是L开头的数据，json第一个大罗括号 加密大概应该是L.。

从这来看网站很费心思，参数关键词一个比一个端，直接搜索一个比一个多，打算点会要命的。没有一两天追不过了。一种是xhr连接的断点，还有一个就是搜索接口连接。这里搜索的接口连接。

接口名称能对上，点击 断住了，，参数感觉像，具体啥意思还不清楚，往后追。

从上面可以看出 ，l是原始参数，F是l加密后的，p是f等的。

var f = Object(u.c)(Object(u.d)(JSON.stringify(s.payload))), 
    p = Object(u.e)(f);

 核心的代码就在这两行，进入到方法中。

执行结果一样一样的。

加密方式就是先调用e1 在调用e2,sig就是md5(加了一个_p)这就是基本解决了。

var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
    , _p = "W5D80NFZHAYB8EUI2T649RT2MNRMVE2O";
function _u_e(e) {
    if (null == e)
        return null;
    e = e.replace(/\r\n/g, "\n");
    for (var t = "", n = 0; n < e.length; n++) {
        var r = e.charCodeAt(n);
        r < 128 ? t += String.fromCharCode(r) : r > 127 && r < 2048 ? (t += String.fromCharCode(r >> 6 | 192),
            t += String.fromCharCode(63 & r | 128)) : (t += String.fromCharCode(r >> 12 | 224),
            t += String.fromCharCode(r >> 6 & 63 | 128),
            t += String.fromCharCode(63 & r | 128))
    }
    return t
}
function e2(e) {
    if (null == (e = _u_e(e)))
        return null;
    for (var t = "", n = 0; n < e.length; n++) {
        var r = _p.charCodeAt(n % _p.length);
        t += String.fromCharCode(e.charCodeAt(n) ^ r)
    }
    return t
}

function e1(e) {
    if (null == e)
        return null;
    for (var t, n, r, o, i, a, s, u = "", c = 0; c < e.length; )
        o = (t = e.charCodeAt(c++)) >> 2,
            i = (3 & t) << 4 | (n = e.charCodeAt(c++)) >> 4,
            a = (15 & n) << 2 | (r = e.charCodeAt(c++)) >> 6,
            s = 63 & r,
            isNaN(n) ? a = s = 64 : isNaN(r) && (s = 64),
            u = u + _keyStr.charAt(o) + _keyStr.charAt(i) + _keyStr.charAt(a) + _keyStr.charAt(s);
    return u
}
function sig(e) {
    return md5(e + _p).toUpperCase()
}
function test() {
    n = {"payload":{"date":[],"round":[],"location":[],"tag":[],"yellow":[],"yellow_tag":[],"domestic":"true","funding_date":[],"input":"","order":"desc","sort":76004,"page":0,"size":20}}
    var c = JSON.stringify(n),l = JSON.parse(c);
    var f = e1(e2(JSON.stringify(l.payload)))
    console.log(f)

}

test()

下面是kimi 生成的python代码，看起来也不错。

import json
import hashlib
import base64

_keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
_p = "W5D80NFZHAYB8EUI2T649RT2MNRMVE2O"

def _u_e(e):
    if e is None:
        return None
    e = e.replace("\r\n", "\n")
    t = ""
    for char in e:
        if ord(char) < 128:
            t += char
        elif 128 <= ord(char) < 2048:
            t += chr((ord(char) >> 6) | 192) + chr((ord(char) & 63) | 128)
        else:
            t += chr((ord(char) >> 12) | 224) + chr(((ord(char) >> 6) & 63) | 128) + chr((ord(char) & 63) | 128)
    return t

def e2(e):
    if e is None or e == "":
        return None
    t = ""
    for i, char in enumerate(e):
        r = ord(_p[i % len(_p)])
        t += chr((ord(char) ^ r))
    return t

def e1(e):
    if e is None:
        return None
    u = ""
    c = 0
    while c < len(e):
        t = ord(e[c])
        c += 1
        o = t >> 2
        if c < len(e):
            n = ord(e[c])
            c += 1
            i = ((t & 3) << 4) + (n >> 4)
            if c < len(e):
                r = ord(e[c])
                c += 1
                a = ((n & 15) << 2) + (r >> 6)
                s = r & 63
                u += _keyStr[o] + _keyStr[i] + _keyStr[a] + _keyStr[s]
            else:
                if not n == 0:
                    u += _keyStr[o] + _keyStr[i] + _keyStr[a] + '='
                else:
                    u += _keyStr[o] + _keyStr[i] + '=='
    return u

def sig(e):
    return hashlib.md5((e + _p).encode()).hexdigest().upper()

def test():
    n = {"payload": {"date":[], "round":[], "location":[], "tag":[], "yellow":[], "yellow_tag":[], "domestic":"true", "funding_date":[], "input":"","order":"desc", "sort":76004, "page":0, "size":20}}
    c = json.dumps(n)
    l = json.loads(c)
    f = e1(e2(json.dumps(l["payload"])))
    print(f)

test()

再往后就是正文的数据了。

这个位置传入的是密文，返回一个二进制。

 和上面一样，调用两次，返回明文。

var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
    , _p = "W5D80NFZHAYB8EUI2T649RT2MNRMVE2O";

function _u_d(e) {
    for (var t = "", n = 0, r = 0, o = 0, i = 0; n < e.length; )
        (r = e.charCodeAt(n)) < 128 ? (t += String.fromCharCode(r),
            n++) : r > 191 && r < 224 ? (o = e.charCodeAt(n + 1),
            t += String.fromCharCode((31 & r) << 6 | 63 & o),
            n += 2) : (o = e.charCodeAt(n + 1),
            i = e.charCodeAt(n + 2),
            t += String.fromCharCode((15 & r) << 12 | (63 & o) << 6 | 63 & i),
            n += 3);
    return t
}

function d1(e) {
    var t, n, r, o, i, a, s = "", u = 0;
    for (e = e.replace(/[^A-Za-z0-9\+\/\=]/g, ""); u < e.length; )
        t = _keyStr.indexOf(e.charAt(u++)) << 2 | (o = _keyStr.indexOf(e.charAt(u++))) >> 4,
            n = (15 & o) << 4 | (i = _keyStr.indexOf(e.charAt(u++))) >> 2,
            r = (3 & i) << 6 | (a = _keyStr.indexOf(e.charAt(u++))),
            s += String.fromCharCode(t),
        64 != i && (s += String.fromCharCode(n)),
        64 != a && (s += String.fromCharCode(r));
    return s
}
function d2(e) {
    for (var t = "", n = 0; n < e.length; n++) {
        var r = _p.charCodeAt(n % _p.length);
        t += String.fromCharCode(e.charCodeAt(n) ^ r)
    }
    return t = _u_d(t)
}

var all_data = {"code":0,"d":"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\u003d","v":1}
var data = all_data["d"]
console.log(data)
var d = d1(data)
    , m = d2(d)
    , v = JSON.parse(m);

console.log(v)

这个代码有点复杂，还原成python的逻辑没成功，但是，基本已经可以完成数据的请求和还原了。