备份: 完整开发状态(含反混淆脚本和临时文件)

This commit is contained in:
ccdojox-crypto
2025-12-17 17:18:02 +08:00
parent 9e2333c90c
commit 7e9ea173a7
2872 changed files with 326818 additions and 249 deletions

210
generate_all_maps.js Normal file
View File

@@ -0,0 +1,210 @@
/**
* 通用解码脚本 - 使用 eval 执行解码器
* 为每个混淆文件生成解码映射
*/
const fs = require('fs');
const path = require('path');
const baseDir = 'D:/temp/破解/cursorpro-0.4.5';
// 全局变量
var vip = 'cursor';
/**
* 为单个文件生成解码映射
*/
function generateMapForFile(inputPath, outputPath, filename) {
console.log(`\n${'='.repeat(50)}`);
console.log(`处理: ${filename}`);
console.log('='.repeat(50));
// 检查是否已存在
if (fs.existsSync(outputPath)) {
const existing = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
console.log(`已存在: ${Object.keys(existing).length} 条映射`);
return;
}
const code = fs.readFileSync(inputPath, 'utf8');
console.log(`文件大小: ${(code.length / 1024).toFixed(2)} KB`);
// 1. 找函数名
const funcMatch = code.match(/function (_0x[a-f0-9]+)\(/g);
if (!funcMatch) {
console.log('未找到函数');
return;
}
const funcNames = [...new Set(funcMatch)].map(f => f.match(/_0x[a-f0-9]+/)[0]);
console.log(`找到 ${funcNames.length} 个函数`);
// 2. 找字符串数组函数 (无参数的函数)
const arrFuncName = funcNames.find(n => {
const regex = new RegExp(`function ${n}\\(\\)\\s*\\{`);
return regex.test(code);
});
if (!arrFuncName) {
console.log('未找到字符串数组函数');
return;
}
console.log(`字符串数组函数: ${arrFuncName}`);
// 3. 提取并执行字符串数组函数
const arrMatch = code.match(new RegExp(`function ${arrFuncName}\\(\\)[\\s\\S]*?return ${arrFuncName}\\(\\);\\}`));
if (!arrMatch) {
console.log('无法提取字符串数组函数');
return;
}
try {
eval(arrMatch[0]);
console.log('字符串数组函数已定义');
} catch (e) {
console.log(`字符串数组函数执行失败: ${e.message}`);
return;
}
// 4. 找解码函数 (两个参数的函数)
const decFuncName = funcNames.find(n => {
const regex = new RegExp(`function ${n}\\s*\\(\\s*_0x[a-f0-9]+\\s*,\\s*_0x[a-f0-9]+\\s*\\)\\s*\\{`);
return regex.test(code) && n !== arrFuncName;
});
if (!decFuncName) {
console.log('未找到解码函数');
return;
}
console.log(`解码函数: ${decFuncName}`);
// 5. 提取并执行解码函数
const decStart = code.indexOf(`function ${decFuncName}(`);
let braceCount = 0, decEnd = decStart, foundStart = false;
for (let i = decStart; i < code.length; i++) {
if (code[i] === '{') { braceCount++; foundStart = true; }
else if (code[i] === '}') {
braceCount--;
if (foundStart && braceCount === 0) {
decEnd = i + 1;
break;
}
}
}
const decCode = code.substring(decStart, decEnd);
try {
eval(decCode);
console.log('解码函数已定义');
} catch (e) {
console.log(`解码函数执行失败: ${e.message}`);
return;
}
// 6. 执行 IIFE (初始化洗牌)
// 查找 IIFE: (function(...){...})(...,_0xXXXX,...)
const iifePattern = new RegExp(`\\(function\\s*\\([^)]*\\)\\s*\\{[\\s\\S]*?\\}\\)\\s*\\([^,]+,[^,]+,\\s*${arrFuncName}\\s*,[^)]+\\)`, 'g');
const iifeMatches = code.match(iifePattern);
if (iifeMatches) {
for (const iifeCode of iifeMatches) {
try {
eval(iifeCode);
console.log('IIFE 已执行');
break;
} catch (e) {
console.log(`IIFE 执行失败: ${e.message}`);
}
}
} else {
// 尝试另一种 IIFE 模式
const altIife = code.match(/;\s*\(function\s*\([^)]*\)\s*\{[\s\S]*?\}\)\s*\([^)]+\)\s*;/);
if (altIife) {
try {
eval(altIife[0]);
console.log('备用 IIFE 已执行');
} catch (e) {
console.log(`备用 IIFE 执行失败: ${e.message}`);
}
}
}
// 7. 获取解码函数引用
let decode;
try {
decode = eval(decFuncName);
if (typeof decode !== 'function') {
console.log('解码函数不是函数');
return;
}
console.log('解码函数可用');
} catch (e) {
console.log(`获取解码函数失败: ${e.message}`);
return;
}
// 8. 收集所有调用并解码
const regex = /_0x[a-zA-Z0-9]+\s*\(\s*(0x[0-9a-fA-F]+)\s*,\s*'([^']+)'\s*\)/g;
const decodedMap = {};
let match;
let successCount = 0;
let failCount = 0;
while ((match = regex.exec(code)) !== null) {
const fullMatch = match[0];
const index = parseInt(match[1], 16);
const key = match[2];
if (!decodedMap[fullMatch]) {
try {
const decoded = decode(index, key);
if (typeof decoded === 'string') {
decodedMap[fullMatch] = decoded;
successCount++;
} else {
failCount++;
}
} catch (e) {
failCount++;
}
}
}
console.log(`成功解码: ${successCount}`);
console.log(`解码失败: ${failCount}`);
// 9. 保存映射
if (successCount > 0) {
fs.writeFileSync(outputPath, JSON.stringify(decodedMap, null, 2));
console.log(`已保存: ${outputPath}`);
}
}
// 主函数
function main() {
console.log('╔════════════════════════════════════════════════════╗');
console.log('║ 通用解码映射生成器 ║');
console.log('║ 使用 eval 执行解码器 ║');
console.log('╚════════════════════════════════════════════════════╝');
const files = [
{ input: '原版本/extension/out/webview/provider.js', output: 'provider_decoded_map.json' },
{ input: '原版本/extension/out/extension.js', output: 'extension_decoded_map.json' },
{ input: '原版本/extension/out/utils/account.js', output: 'account_decoded_map.json' },
{ input: '原版本/extension/out/utils/sqlite.js', output: 'sqlite_decoded_map.json' },
{ input: '原版本/extension/out/api/client.js', output: 'client_decoded_map.json' }
];
for (const file of files) {
const inputPath = path.join(baseDir, file.input);
const outputPath = path.join(baseDir, file.output);
if (!fs.existsSync(inputPath)) {
console.log(`\n跳过: ${file.input} (不存在)`);
continue;
}
generateMapForFile(inputPath, outputPath, file.input);
}
console.log('\n' + '='.repeat(50));
console.log('完成!');
}
main();