251 lines
8.5 KiB
JavaScript
251 lines
8.5 KiB
JavaScript
/**
|
|
* 控制流简化工具
|
|
* 移除对象包装的简单操作
|
|
*/
|
|
const fs = require('fs');
|
|
|
|
// 尝试使用 babel
|
|
let babel, traverse, generate, t;
|
|
try {
|
|
babel = require('@babel/core');
|
|
traverse = require('@babel/traverse').default;
|
|
generate = require('@babel/generator').default;
|
|
t = require('@babel/types');
|
|
} catch (e) {
|
|
console.log('需要安装 babel 依赖...');
|
|
require('child_process').execSync('npm install @babel/core @babel/traverse @babel/generator @babel/types --save-dev', {
|
|
stdio: 'inherit',
|
|
cwd: 'D:/temp/破解/cursorpro-0.4.5'
|
|
});
|
|
babel = require('@babel/core');
|
|
traverse = require('@babel/traverse').default;
|
|
generate = require('@babel/generator').default;
|
|
t = require('@babel/types');
|
|
}
|
|
|
|
const inputPath = 'D:/temp/破解/cursorpro-0.4.5/deobfuscated_full/extension/out/webview/provider.js';
|
|
const outputPath = 'D:/temp/破解/cursorpro-0.4.5/deobfuscated_full/extension/out/webview/provider_simplified.js';
|
|
|
|
console.log('╔════════════════════════════════════════════════════╗');
|
|
console.log('║ 控制流简化工具 ║');
|
|
console.log('╚════════════════════════════════════════════════════╝');
|
|
|
|
const code = fs.readFileSync(inputPath, 'utf8');
|
|
console.log(`读取文件: ${(code.length / 1024).toFixed(2)} KB`);
|
|
|
|
console.log('\n[1] 解析 AST...');
|
|
let ast;
|
|
try {
|
|
ast = babel.parseSync(code, {
|
|
sourceType: 'script',
|
|
plugins: []
|
|
});
|
|
console.log('AST 解析成功');
|
|
} catch (e) {
|
|
console.error('AST 解析失败:', e.message);
|
|
process.exit(1);
|
|
}
|
|
|
|
console.log('\n[2] 收集对象定义...');
|
|
|
|
// 存储对象属性的映射
|
|
const objectMappings = new Map();
|
|
|
|
// 第一遍：收集所有 const varX = { 'key': function... } 形式的定义
|
|
traverse(ast, {
|
|
VariableDeclarator(path) {
|
|
if (!t.isIdentifier(path.node.id)) return;
|
|
if (!t.isObjectExpression(path.node.init)) return;
|
|
|
|
const varName = path.node.id.name;
|
|
const props = {};
|
|
let isSimpleObject = true;
|
|
|
|
for (const prop of path.node.init.properties) {
|
|
if (!t.isObjectProperty(prop)) {
|
|
isSimpleObject = false;
|
|
break;
|
|
}
|
|
|
|
let key;
|
|
if (t.isStringLiteral(prop.key)) {
|
|
key = prop.key.value;
|
|
} else if (t.isIdentifier(prop.key)) {
|
|
key = prop.key.name;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
// 检查是否是简单的函数包装器
|
|
if (t.isFunctionExpression(prop.value)) {
|
|
const func = prop.value;
|
|
if (func.body.body.length === 1 && t.isReturnStatement(func.body.body[0])) {
|
|
const ret = func.body.body[0].argument;
|
|
|
|
// 二元操作: return a === b
|
|
if (t.isBinaryExpression(ret) && func.params.length === 2) {
|
|
const [p1, p2] = func.params;
|
|
if (t.isIdentifier(ret.left) && t.isIdentifier(ret.right) &&
|
|
ret.left.name === p1.name && ret.right.name === p2.name) {
|
|
props[key] = { type: 'binary', operator: ret.operator };
|
|
}
|
|
}
|
|
// 逻辑操作: return a && b
|
|
else if (t.isLogicalExpression(ret) && func.params.length === 2) {
|
|
const [p1, p2] = func.params;
|
|
if (t.isIdentifier(ret.left) && t.isIdentifier(ret.right) &&
|
|
ret.left.name === p1.name && ret.right.name === p2.name) {
|
|
props[key] = { type: 'logical', operator: ret.operator };
|
|
}
|
|
}
|
|
// 函数调用: return a(b) 或 return a(b, c)
|
|
else if (t.isCallExpression(ret)) {
|
|
if (t.isIdentifier(ret.callee) && ret.callee.name === func.params[0]?.name) {
|
|
props[key] = { type: 'call', argCount: ret.arguments.length };
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// 字符串字面量
|
|
else if (t.isStringLiteral(prop.value)) {
|
|
props[key] = { type: 'string', value: prop.value.value };
|
|
}
|
|
// 数字字面量
|
|
else if (t.isNumericLiteral(prop.value)) {
|
|
props[key] = { type: 'number', value: prop.value.value };
|
|
}
|
|
}
|
|
|
|
if (Object.keys(props).length > 0) {
|
|
objectMappings.set(varName, props);
|
|
}
|
|
}
|
|
});
|
|
|
|
console.log(`找到 ${objectMappings.size} 个可简化的对象定义`);
|
|
|
|
console.log('\n[3] 简化调用...');
|
|
let simplifiedCount = 0;
|
|
|
|
traverse(ast, {
|
|
// 简化 obj.key(a, b) 或 obj['key'](a, b) 调用
|
|
CallExpression(path) {
|
|
const callee = path.node.callee;
|
|
|
|
if (!t.isMemberExpression(callee)) return;
|
|
if (!t.isIdentifier(callee.object)) return;
|
|
|
|
const objName = callee.object.name;
|
|
const mapping = objectMappings.get(objName);
|
|
if (!mapping) return;
|
|
|
|
let propName;
|
|
if (t.isStringLiteral(callee.property)) {
|
|
propName = callee.property.value;
|
|
} else if (t.isIdentifier(callee.property) && !callee.computed) {
|
|
propName = callee.property.name;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
const propInfo = mapping[propName];
|
|
if (!propInfo) return;
|
|
|
|
const args = path.node.arguments;
|
|
|
|
// 二元操作
|
|
if (propInfo.type === 'binary' && args.length === 2) {
|
|
path.replaceWith(t.binaryExpression(propInfo.operator, args[0], args[1]));
|
|
simplifiedCount++;
|
|
}
|
|
// 逻辑操作
|
|
else if (propInfo.type === 'logical' && args.length === 2) {
|
|
path.replaceWith(t.logicalExpression(propInfo.operator, args[0], args[1]));
|
|
simplifiedCount++;
|
|
}
|
|
// 函数调用
|
|
else if (propInfo.type === 'call' && args.length >= 1) {
|
|
const fn = args[0];
|
|
const fnArgs = args.slice(1);
|
|
path.replaceWith(t.callExpression(fn, fnArgs));
|
|
simplifiedCount++;
|
|
}
|
|
},
|
|
|
|
// 简化 obj.key 或 obj['key'] 属性访问（字符串/数字）
|
|
MemberExpression(path) {
|
|
if (path.parent && t.isCallExpression(path.parent) && path.parent.callee === path.node) {
|
|
return; // 已在 CallExpression 中处理
|
|
}
|
|
|
|
if (!t.isIdentifier(path.node.object)) return;
|
|
|
|
const objName = path.node.object.name;
|
|
const mapping = objectMappings.get(objName);
|
|
if (!mapping) return;
|
|
|
|
let propName;
|
|
if (t.isStringLiteral(path.node.property)) {
|
|
propName = path.node.property.value;
|
|
} else if (t.isIdentifier(path.node.property) && !path.node.computed) {
|
|
propName = path.node.property.name;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
const propInfo = mapping[propName];
|
|
if (!propInfo) return;
|
|
|
|
if (propInfo.type === 'string') {
|
|
path.replaceWith(t.stringLiteral(propInfo.value));
|
|
simplifiedCount++;
|
|
} else if (propInfo.type === 'number') {
|
|
path.replaceWith(t.numericLiteral(propInfo.value));
|
|
simplifiedCount++;
|
|
}
|
|
}
|
|
});
|
|
|
|
console.log(`简化了 ${simplifiedCount} 处调用`);
|
|
|
|
console.log('\n[4] 移除未使用的对象定义...');
|
|
let removedCount = 0;
|
|
|
|
// 收集所有标识符使用情况
|
|
const usedIdentifiers = new Set();
|
|
traverse(ast, {
|
|
Identifier(path) {
|
|
if (!path.isReferencedIdentifier()) return;
|
|
usedIdentifiers.add(path.node.name);
|
|
}
|
|
});
|
|
|
|
// 移除未使用的变量声明
|
|
traverse(ast, {
|
|
VariableDeclarator(path) {
|
|
if (!t.isIdentifier(path.node.id)) return;
|
|
const name = path.node.id.name;
|
|
|
|
if (objectMappings.has(name) && !usedIdentifiers.has(name)) {
|
|
path.remove();
|
|
removedCount++;
|
|
}
|
|
}
|
|
});
|
|
|
|
console.log(`移除了 ${removedCount} 个未使用的对象`);
|
|
|
|
console.log('\n[5] 生成代码...');
|
|
const output = generate(ast, {
|
|
comments: false,
|
|
compact: false,
|
|
concise: false
|
|
}, code);
|
|
|
|
console.log('\n[6] 保存文件...');
|
|
fs.writeFileSync(outputPath, output.code);
|
|
console.log(`保存到: ${outputPath}`);
|
|
console.log(`新文件大小: ${(output.code.length / 1024).toFixed(2)} KB`);
|
|
|
|
console.log('\n✅ 完成！');
|