Crack Slide | 某验 4 代分析笔记
前言
以官网demo为研究对象，仅限于安全研究，不公开具体源码。接下来我们就进入正题
正文
观察分析
首先是获取滑块，提交参数有这些，captcha_id固定值，challenge(uuid,可以自己生成，不是必需参数，不传也可以)，callback(带时间戳的固定值)，其余的也是固定值
返回参数，有这些
然后是验证码提交参数，除了上面返回的，和一些固定值，只有w值是未知的，接下来就来分析这个w参数
直接搜好像是搜不出来的，但是获取验证码，和验证码提交都用到了这个js，就很可疑
点进去后，嗯，混淆过的(怎么可能不混淆呢)，啥也搜不出来
ast解混淆
首先是ast解混淆的代码，这里用大佬写好的
const parser = require("@babel/parser");
const traverse = require("@babel/traverse").default;
const t = require("@babel/types");
const generator = require("@babel/generator").default;
const fs = require("fs");
// #######################################
// 还原需要用到的js源码
// #######################################
//里面内容太多了，字符限制，粘不出来，要提换成自己的
EtDyg.$_AC = function () {}();
//里面内容太多了，字符限制，粘不出来，要提换成自己的
EtDyg.$_Bj = function () {}();
EtDyg.$_CK = function () {
return typeof EtDyg.$_AC.$_EHFHu === "function" ? EtDyg.$_AC.$_EHFHu.apply(EtDyg.$_AC, arguments) : EtDyg.$_AC.$_EHFHu;
};
EtDyg.$_DB = function () {
return typeof EtDyg.$_Bj.$_EHGHy === "function" ? EtDyg.$_Bj.$_EHGHy.apply(EtDyg.$_Bj, arguments) : EtDyg.$_Bj.$_EHGHy;
};
function EtDyg() {}
// #######################################
// AST解析函数
// #######################################
// 删除节点中的extra属性（二进制、Unicode等编码 -> utf-8）
function replace_unicode(path) {
let node = path.node;
if (node.extra === undefined)
return;
delete node.extra;
}
// 定义一个全局变量，存放待替换变量名
let name_array = [];
function get_name_array(path) {
let {kind, declarations} = path.node
if (kind !== 'var'
|| declarations.length !== 3
|| declarations[0].init === null
|| declarations[0].init.property === undefined)
return;
//这个$_CK对应上面的EtDyg.$_CK
if (declarations[0].init.property.name !== "$_CK")
return;
// 获取待替换节点变量名
let name1 = declarations[0].id.name
// 获取待输出变量名
let name2 = declarations[2].id.name
// 将变量名存入数组
name_array.push(name1, name2)
// 删除下一个节点
path.getNextSibling().remove()
// 删除下一个节点
path.getNextSibling().remove()
// 删除path节点
path.remove()
}
function replace_name_array(path) {
let {callee, arguments} = path.node
if (callee === undefined || callee.name === undefined)
return;
// 不在name_array中的节点不做替换操作
if (name_array.indexOf(callee.name) === -1)
return;
// cvFBi.$_Cg函数获取结果
let value = EtDyg.$_CK(arguments[0].value);
// 创建节点并替换结果
let string_node = t.stringLiteral(value)
path.replaceWith(string_node)
}
function replace_$_Cg(path) {
let {arguments, callee} = path.node
// 解析arguments参数
if (arguments.length !== 1) return;
if (arguments[0].type !== 'NumericLiteral') return;
// 解析callee
if (callee.type !== 'MemberExpression') return;
let {object, property} = callee;
if (object.type !== 'Identifier' || property.type !== 'Identifier') return;
//这个$_CK对应上面的EtDyg.$_CK
if (property.name === '$_CK') {
// 计算值
let value = EtDyg.$_CK(arguments[0].value);
// 创建节点并替换
let string_node = t.stringLiteral(value)
path.replaceWith(string_node)
}
}
// 控制流平坦化
function replace_ForStatement(path) {
var node = path.node;
// 获取上一个节点，也就是VariableDeclaration
var PrevSibling = path.getPrevSibling();
// 判断上个节点的各个属性，防止报错
if (PrevSibling.type === undefined
|| PrevSibling.container === undefined
|| PrevSibling.container[0].declarations === undefined
|| PrevSibling.container[0].declarations[0].init === null
|| PrevSibling.container[0].declarations[0].init.object === undefined
|| PrevSibling.container[0].declarations[0].init.object.object === undefined)
return;
//这个$_CK对应上面的EtDyg.$_DB
if (PrevSibling.container[0].declarations[0].init.object.object.callee.property.name !== '$_DB')
return;
// SwitchStatement节点
var body = node.body.body;
// 判断当前节点的body[0]属性和body[0].discriminant是否存在
if (!t.isSwitchStatement(body[0]))
return;
if (!t.isIdentifier(body[0].discriminant))
return;
// 获取控制流的初始值
var argNode = PrevSibling.container[0].declarations[0].init;
var init_arg_f = argNode.object.property.value;
var init_arg_s = argNode.property.value;
var init_arg = EtDyg.$_DB()[init_arg_f][init_arg_s];
// 提取for节点中的if判断参数的value作为判断参数
var break_arg_f = node.test.right.object.property.value;
var break_arg_s = node.test.right.property.value;
var break_arg = EtDyg.$_DB()[break_arg_f][break_arg_s];
// 提取switch下所有的case
var case_list = body[0].cases;
var resultBody = [];
// 遍历全部的case
for (var i = 0; i < case_list.length; i++) {
for (; init_arg != break_arg;) {
// 提取并计算case后的条件判断的值
var case_arg_f = case_list[i].test.object.property.value;
var case_arg_s = case_list[i].test.property.value;
var case_init = EtDyg.$_DB()[case_arg_f][case_arg_s];
if (init_arg == case_init) {
//当前case下的所有节点
var targetBody = case_list[i].consequent;
// 删除break节点，和break节点的上一个节点的一些无用代码
if (t.isBreakStatement(targetBody[targetBody.length - 1])
&& t.isExpressionStatement(targetBody[targetBody.length - 2])
&& targetBody[targetBody.length - 2].expression.right.object.object.callee.object.name == "EtDyg") {
// 提取break节点的上一个节点AJgjJ.EMf()后面的两个索引值
var change_arg_f = targetBody[targetBody.length - 2].expression.right.object.property.value;
var change_arg_s = targetBody[targetBody.length - 2].expression.right.property.value;
// 修改控制流的初始值
init_arg = EtDyg.$_DB()[change_arg_f][change_arg_s];
targetBody.pop(); // 删除break
targetBody.pop(); // 删除break节点的上一个节点
}
//删除break
else if (t.isBreakStatement(targetBody[targetBody.length - 1])) {
targetBody.pop();
}
resultBody = resultBody.concat(targetBody);
break;
} else {
break;
}
}
}
//替换for节点，多个节点替换一个节点用replaceWithMultiple
path.replaceWithMultiple(resultBody);
//删除上一个节点
PrevSibling.remove();
}
// 删除无关函数
function delete_func(path) {
let {expression} = path.node
if (expression === undefined
|| expression.left === undefined
|| expression.left.property === undefined)
return;
//这些值都对应上面的EtDyg后面的，需要自己根据自己的源码替换
if (expression.left.property.name === '$_AC'
|| expression.left.property.name === '$_CK'
|| expression.left.property.name === '$_Bj'
|| expression.left.property.name === '$_DB'
) {
path.remove()
}
}
// #######################################
// AST还原流程
// #######################################
// 需要解码的文件位置
let encode_file = "gcaptcha4.js"
// 解码后的文件位置
let decode_file = "gcaptcha4_decode.js"
// 读取需要解码的js文件, 注意文件编码为utf-8格式
let jscode = fs.readFileSync(encode_file, {encoding: "utf-8"});
// 将js代码修转成AST语法树
let ast = parser.parse(jscode);
// AST结构修改逻辑
const visitor = {
StringLiteral: {
enter: [replace_unicode]
},
VariableDeclaration: {
enter: [get_name_array]
},
CallExpression: {
enter: [replace_name_array, replace_$_Cg]
},
ForStatement: {
enter: [replace_ForStatement]
},
ExpressionStatement: {
enter: [delete_func]
},
}
// 遍历语法树节点，调用修改函数
traverse(ast, visitor);
// 将ast转成js代码，{jsescOption: {"minimal": true}} unicode -> 中文
let {code} = generator(ast, opts = {jsescOption: {"minimal": true}});
// 将js代码保存到文件
fs.writeFile(decode_file, code, (err) => {
});
经过ast解混淆还原后的代码就清晰很多了，1.2w行的代码，还原后只剩6000多行，而且控制流也还原了，此处只想说一句牛逼，然后用reres插件，或者其他工具，替换网站原来的js文件，最后搜索"w"就能定位到了。由下面的代码看，w值就是变量r的值，r值又是在上面生成的，那就打上断点，滑动滑块，开始分析
源码分析
首先是参数e。
device_id：是根据浏览器生成的标识，可以写死
em：固定值
ep：固定值
geetest：固定值
lang：固定值
lot_number：最开始获取滑块的接口返回的
passtime：滑动滑块的时长，由下面track数组里的小数组的第三个参数相加得来
pow_msg（不是必传参数）：由几个固定值加上滑块的captcha_id和lot_number和16位，16进制随机数
pow_sign（不是必传参数）：将pow_msg，md5加密后生成的值
setLeft：滑块滑动的距离
track：滑动轨迹
userresponse：一个固定算法，下面再说
yizo：是无论键还是值，都是随机的，但是没用，写死就行
而l.default.stringify(e),就是个序列化的操作,同JSON.stringify(e)
先说下这两个不是必传的参数pow_msg和pow_sign
源码中搜下pow_msg就能找到，就在这里，具体逻辑在上面说了，有兴趣的话，可以自己跟进函数看看
setLeft，track和passtime，搜索了网上现成的生成代码
import ddddocr
import random
def generate_distance(slice_url, bg_url):
"""
带带弟弟ocr识别距离
:param bg_url: 背景图地址
:param slice_url: 滑块图地址
:return: distance: 距离
"""
slide = ddddocr.DdddOcr(det=False, ocr=False, show_ad=False)
slice_image = requests.get(slice_url).content
bg_image = requests.get(bg_url).content
result = slide.slide_match(slice_image, bg_image, simple_target=True)
return result['target'][0]
def generate_track(distance):
"""
轨迹生成（百度出来的）
:param distance: 滑动的距离
"""
def __ease_out_expo(step):
return 1 if step == 1 else 1 - pow(2, -10 * step)
tracks = [[random.randint(20, 60), random.randint(10, 40), 0]]
count = 30 + int(distance / 2)
_x, _y = 0, 0
for item in range(count):
x = round(__ease_out_expo(item / count) * distance)
t = random.randint(10, 20)
if x == _x:
continue
tracks.append([x - _x, _y, t])
_x = x
tracks.append([0, 0, random.randint(200, 300)])
passtime = sum([track[2] for track in tracks])
return tracks, passtime
userresponse
搜索userresponse就能找到，具体逻辑在这里
用python还原下就是,captcha_width是验证码图片的长度
def get_userresponse(setLeft, captcha_width=300):
"""获取e参数里面的userresponse"""
e = 340
i = .8876 * e / captcha_width
return setLeft / i
到这里，e参数里面的值，基本就完成了
然后一步步往下跟，到了这里，最后return的是hex编码后的o和a进行了字符串的拼接
先看a，a里面有个参数n，首先进入到c["guid"]这个函数里面看看，是这样的
n的参数有了，下面看看a是怎么生成的，在这个函数里，我们看到了一个关键词RSA，基本就可以断定，是RSA加密了，既然是RSA，那么肯定是有公钥的
接着往下跟，这里可以看到这个this里面有setPublic关键词
然后进入到这个函数中，打上断点，重新滑动滑块看看，这样就找到了公钥，这里有个坑，因为这个公钥是hex编码的，不同于常见的base64公钥。因为RSA加密是定长的，最后只要密文是256位的，基本就没问题了
然后是这个o的值，函数有两个参数，一个是e，一个是跟上面一样的n，e的值就是上面分析出来的e的值
单步进入后，发现了几个关键词
如果接着跟，还能发现一个关键词AES，就可以断定这个是AES加密，使用PKCS7填充，MODE为CBC
最后字符串拼接下这两个加密的值，就是最终的w值了
最后提交参数，没问题，撒花
End.
评论