Newer version 17:44
This commit is contained in:
Flatlogic Bot
parent
6eb4a6e0d6
commit
db7c8c2aaa
@ -2,18 +2,34 @@ const crypto = require('crypto');
|
||||
|
||||
class ObfuscatorService {
|
||||
static obfuscate(sourceCode, config = {}) {
|
||||
const seed = crypto.randomBytes(4).readUInt32BE(0);
|
||||
const tokens = this.tokenize(sourceCode);
|
||||
const { bc, constants, ops } = this.compile(tokens);
|
||||
return this.generateVM(bc, constants, ops, seed);
|
||||
try {
|
||||
console.log('Starting obfuscation for code length:', sourceCode.length);
|
||||
const seed = crypto.randomBytes(4).readUInt32BE(0);
|
||||
const tokens = this.tokenize(sourceCode);
|
||||
const { bc, constants, ops } = this.compile(tokens);
|
||||
const vm = this.generateVM(bc, constants, ops, seed);
|
||||
console.log('Obfuscation complete, VM length:', vm.length);
|
||||
return vm;
|
||||
} catch (err) {
|
||||
console.error('Obfuscation error:', err);
|
||||
return `-- LUARTEX CRITICAL ERROR: ${err.message}
|
||||
` + sourceCode;
|
||||
}
|
||||
}
|
||||
|
||||
static tokenize(code) {
|
||||
const tokens = [];
|
||||
let i = 0;
|
||||
const operators = [
|
||||
'==', '~=', '<=', '>=', '..', '...', '+=', '-=', '*=', '/=',
|
||||
'=', '+', '-', '*', '/', '%', '^', '#', '<', '>', '(', ')',
|
||||
'{', '}', '[', ']', ';', ':', ',', '.'
|
||||
];
|
||||
|
||||
while (i < code.length) {
|
||||
let c = code[i];
|
||||
if (/\s/.test(c)) { i++; continue; }
|
||||
|
||||
if (c === '-' && code[i + 1] === '-') {
|
||||
i += 2;
|
||||
if (code[i] === '[' && code[i + 1] === '[') {
|
||||
@ -25,56 +41,71 @@ class ObfuscatorService {
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (c === '"' || c === "'") {
|
||||
const q = c; let s = ""; i++;
|
||||
while (i < code.length && code[i] !== q) {
|
||||
if (code[i] === '\\') { s += code[i] + (code[i + 1] || ""); i += 2; }
|
||||
else { s += code[i]; i++; }
|
||||
if (code[i] === '\\') {
|
||||
i++;
|
||||
if (code[i] === 'x') { s += String.fromCharCode(parseInt(code.substr(i + 1, 2), 16)); i += 3; }
|
||||
else if (/\d/.test(code[i])) {
|
||||
let d = ""; while (i < code.length && /\d/.test(code[i]) && d.length < 3) { d += code[i]; i++; }
|
||||
s += String.fromCharCode(parseInt(d, 10));
|
||||
}
|
||||
else { s += code[i] || ''; i++; }
|
||||
} else { s += code[i]; i++; }
|
||||
}
|
||||
tokens.push({ type: 'string', value: s });
|
||||
i++; continue;
|
||||
}
|
||||
|
||||
if (/\d/.test(c)) {
|
||||
let n = "";
|
||||
while (i < code.length && /[\d\.\xX]/.test(code[i])) { n += code[i]; i++; }
|
||||
tokens.push({ type: 'number', value: parseFloat(n) });
|
||||
while (i < code.length && /[0-9.xXabcdefABCDEF]/.test(code[i])) { n += code[i]; i++; }
|
||||
tokens.push({ type: 'number', value: n.startsWith('0x') ? parseInt(n, 16) : parseFloat(n) });
|
||||
continue;
|
||||
}
|
||||
|
||||
if (/[a-zA-Z_]/.test(c)) {
|
||||
let id = "";
|
||||
while (i < code.length && /[a-zA-Z0-9_]/.test(code[i])) { id += code[i]; i++; }
|
||||
tokens.push({ type: 'identifier', value: id });
|
||||
continue;
|
||||
}
|
||||
tokens.push({ type: 'operator', value: c }); i++;
|
||||
|
||||
let matchedOp = false;
|
||||
for (const op of operators) {
|
||||
if (code.startsWith(op, i)) {
|
||||
tokens.push({ type: 'operator', value: op });
|
||||
i += op.length;
|
||||
matchedOp = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!matchedOp) { i++; }
|
||||
}
|
||||
return tokens;
|
||||
}
|
||||
|
||||
static numberToExpression(n) {
|
||||
static numberToExpression(n, seed = 0) {
|
||||
if (typeof n !== 'number') return n;
|
||||
const ops = ['+', '-', '*'];
|
||||
let current = Math.floor(Math.random() * 200) - 100;
|
||||
let current = Math.floor(Math.random() * 1000);
|
||||
let expr = `(${current})`;
|
||||
|
||||
for (let i = 0; i < 4; i++) {
|
||||
const op = ops[Math.floor(Math.random() * ops.length)];
|
||||
const val = Math.floor(Math.random() * 100) + 1;
|
||||
if (op === '+') { current += val; expr = `(${expr} + ${val})`; }
|
||||
else if (op === '-') { current -= val; expr = `(${expr} - ${val})`; }
|
||||
else if (op === '*') {
|
||||
if (Math.abs(current * val) < 1000000) {
|
||||
current *= val; expr = `(${expr} * ${val})`;
|
||||
const steps = 3 + Math.floor(Math.random() * 3);
|
||||
for (let i = 0; i < steps; i++) {
|
||||
const mode = Math.floor(Math.random() * 4);
|
||||
const v = Math.floor(Math.random() * 200) + 1;
|
||||
if (mode === 0) { current += v; expr = `(${expr} + ${v})`; }
|
||||
else if (mode === 1) { current -= v; expr = `(${expr} - ${v})`; }
|
||||
else if (mode === 2) { current *= 2; expr = `(${expr} * 2)`; }
|
||||
else {
|
||||
const nv = Math.floor(Math.random() * 255);
|
||||
current = (current ^ nv) >>> 0;
|
||||
expr = `bit32.bxor(${expr}, ${nv})`;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const diff = n - current;
|
||||
if (diff >= 0) expr = `(${expr} + ${diff})`;
|
||||
else expr = `(${expr} - ${Math.abs(diff)})`;
|
||||
|
||||
const noise = Math.floor(Math.random() * 255);
|
||||
return `bit32.bxor(bit32.bxor(${expr}, ${noise}), ${noise})`;
|
||||
return `(${expr} + ${diff})`;
|
||||
}
|
||||
|
||||
static compile(tokens) {
|
||||
@ -84,115 +115,214 @@ class ObfuscatorService {
|
||||
if (idx === -1) { idx = constants.length; constants.push({ value: v, type: typeof v }); }
|
||||
return idx;
|
||||
};
|
||||
|
||||
const ops = {
|
||||
LOADK: 0, GETG: 1, SETG: 2, CALL: 3, RET: 4, GETT: 5, GETS: 6,
|
||||
NEWTABLE: 7, SETTABLE: 8, GETLOCAL: 9, SETLOCAL: 10
|
||||
NEWTABLE: 7, SETTABLE: 8, MOVE: 9,
|
||||
ADD: 10, SUB: 11, MUL: 12, DIV: 13, CONCAT: 14,
|
||||
EQ: 15, LT: 16, LE: 17, JMP: 18, JMPF: 19,
|
||||
CLOSURE: 20
|
||||
};
|
||||
|
||||
const bc = [];
|
||||
let ti = 0;
|
||||
const locals = {};
|
||||
let nextLocal = 0;
|
||||
const locals = [{}];
|
||||
let nextReg = 0;
|
||||
|
||||
const peek = () => tokens[ti];
|
||||
const peek = (n = 0) => tokens[ti + n];
|
||||
const consume = () => tokens[ti++];
|
||||
|
||||
const parseExpr = (reg) => {
|
||||
const getLocal = (name) => {
|
||||
for (let i = locals.length - 1; i >= 0; i--) {
|
||||
if (locals[i][name] !== undefined) return locals[i][name];
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
|
||||
const parseExpression = (reg) => {
|
||||
let t = peek(); if (!t) return;
|
||||
if (t.type === 'number' || t.type === 'string') {
|
||||
bc.push(ops.LOADK, reg, getC(consume().value));
|
||||
} else if (t.type === 'identifier') {
|
||||
let name = consume().value;
|
||||
if (peek()?.value === '(') {
|
||||
ti--; parseCall(reg);
|
||||
} else {
|
||||
emitGet(reg, name);
|
||||
while (peek()?.value === '.' || peek()?.value === ':') {
|
||||
let op = consume().value;
|
||||
let key = consume().value;
|
||||
if (op === ':') {
|
||||
bc.push(ops.GETS, reg, reg, getC(key));
|
||||
parseArgs(reg, true);
|
||||
} else {
|
||||
bc.push(ops.GETT, reg, reg, getC(key));
|
||||
if (peek()?.value === '(') parseArgs(reg);
|
||||
|
||||
const parsePrimary = (r) => {
|
||||
let t = peek();
|
||||
if (!t) return;
|
||||
if (t.type === 'number' || t.type === 'string') {
|
||||
bc.push(ops.LOADK, r, getC(consume().value));
|
||||
} else if (t.type === 'identifier') {
|
||||
if (t.value === 'true') { bc.push(ops.LOADK, r, getC(true)); consume(); }
|
||||
else if (t.value === 'false') { bc.push(ops.LOADK, r, getC(false)); consume(); }
|
||||
else if (t.value === 'nil') { bc.push(ops.LOADK, r, getC(null)); consume(); }
|
||||
else if (t.value === 'function') {
|
||||
parseClosure(r);
|
||||
} else {
|
||||
let name = consume().value;
|
||||
let lReg = getLocal(name);
|
||||
if (lReg !== undefined) bc.push(ops.MOVE, r, lReg);
|
||||
else bc.push(ops.GETG, r, getC(name));
|
||||
|
||||
while (ti < tokens.length) {
|
||||
let next = peek();
|
||||
if (next?.value === '.') {
|
||||
consume(); let key = consume()?.value;
|
||||
if (key) bc.push(ops.GETT, r, r, getC(key));
|
||||
} else if (next?.value === ':') {
|
||||
consume(); let key = consume()?.value;
|
||||
if (key) {
|
||||
bc.push(ops.GETS, r, r, getC(key));
|
||||
parseArgs(r, true);
|
||||
}
|
||||
} else if (next?.value === '(') {
|
||||
parseArgs(r, false);
|
||||
} else break;
|
||||
}
|
||||
}
|
||||
} else if (t.value === '{') {
|
||||
parseTable(r);
|
||||
} else if (t.value === '(') {
|
||||
consume(); parseExpression(r);
|
||||
if (peek()?.value === ')') consume();
|
||||
}
|
||||
} else if (t.value === '{') {
|
||||
parseTable(reg);
|
||||
};
|
||||
|
||||
parsePrimary(reg);
|
||||
const binOps = { '+': ops.ADD, '-': ops.SUB, '*': ops.MUL, '/': ops.DIV, '..': ops.CONCAT, '==': ops.EQ, '<': ops.LT, '<=': ops.LE };
|
||||
while (peek()?.type === 'operator' && binOps[peek().value]) {
|
||||
let op = consume().value;
|
||||
let opCode = binOps[op];
|
||||
let r2 = nextReg++;
|
||||
parsePrimary(r2);
|
||||
bc.push(opCode, reg, reg, r2);
|
||||
}
|
||||
};
|
||||
|
||||
const parseTable = (reg) => {
|
||||
bc.push(ops.NEWTABLE, reg); consume(); // {
|
||||
while (ti < tokens.length && peek().value !== '}') {
|
||||
if (peek().value === ',') { consume(); continue; }
|
||||
let t = peek();
|
||||
if (tokens[ti+1]?.value === '=') {
|
||||
let key = consume().value; consume(); // =
|
||||
parseExpr(reg + 1);
|
||||
bc.push(ops.SETTABLE, reg, getC(key), reg + 1);
|
||||
} else {
|
||||
parseExpr(reg + 1);
|
||||
}
|
||||
if (peek()?.value === ',') consume();
|
||||
}
|
||||
if (peek()?.value === '}') consume();
|
||||
};
|
||||
|
||||
const emitGet = (reg, name) => {
|
||||
if (locals[name] !== undefined) bc.push(ops.GETLOCAL, reg, locals[name]);
|
||||
else bc.push(ops.GETG, reg, getC(name));
|
||||
};
|
||||
|
||||
const parseArgs = (reg, isM) => {
|
||||
if (peek()?.value !== '(') return;
|
||||
consume(); let ac = isM ? 1 : 0;
|
||||
consume();
|
||||
let ac = isM ? 1 : 0;
|
||||
while (ti < tokens.length && peek().value !== ')') {
|
||||
if (peek().value === ',') { consume(); continue; }
|
||||
ac++; parseExpr(reg + ac);
|
||||
ac++;
|
||||
let argReg = reg + ac;
|
||||
if (argReg >= nextReg) nextReg = argReg + 1;
|
||||
parseExpression(argReg);
|
||||
}
|
||||
bc.push(ops.CALL, reg, ac + 1, 1);
|
||||
if (peek()?.value === ')') consume();
|
||||
bc.push(ops.CALL, reg, ac + 1, 1);
|
||||
};
|
||||
|
||||
const parseCall = (reg) => {
|
||||
let fn = consume().value;
|
||||
emitGet(reg, fn);
|
||||
parseArgs(reg);
|
||||
const parseTable = (reg) => {
|
||||
bc.push(ops.NEWTABLE, reg); consume();
|
||||
let arrIdx = 1;
|
||||
while (ti < tokens.length && peek()?.value !== '}') {
|
||||
if (peek()?.value === ',' || peek()?.value === ';') { consume(); continue; }
|
||||
if (peek()?.value === '}') break;
|
||||
|
||||
if (peek()?.type === 'identifier' && peek(1)?.value === '=') {
|
||||
let key = consume().value; consume();
|
||||
let vReg = nextReg++;
|
||||
parseExpression(vReg);
|
||||
bc.push(ops.SETTABLE, reg, getC(key), vReg);
|
||||
} else if (peek()?.value === '[') {
|
||||
consume();
|
||||
let kReg = nextReg++;
|
||||
parseExpression(kReg);
|
||||
if (peek()?.value === ']') consume();
|
||||
if (peek()?.value === '=') consume();
|
||||
let vReg = nextReg++;
|
||||
parseExpression(vReg);
|
||||
bc.push(ops.SETTABLE, reg, -1, kReg, vReg);
|
||||
} else {
|
||||
let vReg = nextReg++;
|
||||
parseExpression(vReg);
|
||||
bc.push(ops.SETTABLE, reg, getC(arrIdx++), vReg);
|
||||
}
|
||||
}
|
||||
if (peek()?.value === '}') consume();
|
||||
};
|
||||
|
||||
const parseClosure = (reg) => {
|
||||
consume(); // function
|
||||
if (peek()?.value === '(') {
|
||||
consume();
|
||||
while (ti < tokens.length && peek()?.value !== ')') consume();
|
||||
if (peek()?.value === ')') consume();
|
||||
}
|
||||
// Capture function body as string for sub-VM
|
||||
let start = ti;
|
||||
let depth = 1;
|
||||
while (ti < tokens.length && depth > 0) {
|
||||
let nt = consume();
|
||||
if (['if', 'while', 'for', 'do', 'function'].includes(nt.value)) depth++;
|
||||
if (nt.value === 'end') depth--;
|
||||
}
|
||||
let bodyTokens = tokens.slice(start, ti - 1);
|
||||
let bodyCode = bodyTokens.map(t => t.type === 'string' ? `"${t.value}"` : t.value).join(' ');
|
||||
bc.push(ops.CLOSURE, reg, getC(bodyCode));
|
||||
};
|
||||
|
||||
const parseBlock = () => {
|
||||
locals.push({});
|
||||
while (ti < tokens.length) {
|
||||
let t = peek();
|
||||
if (!t || ['end', 'else', 'elseif', 'until'].includes(t.value)) break;
|
||||
parseStatement();
|
||||
}
|
||||
locals.pop();
|
||||
};
|
||||
|
||||
const parseStatement = () => {
|
||||
let t = peek();
|
||||
if (!t) return;
|
||||
|
||||
if (t.value === 'local') {
|
||||
consume();
|
||||
if (peek()?.value === 'function') {
|
||||
consume(); let name = consume().value;
|
||||
locals[locals.length-1][name] = nextReg++;
|
||||
parseClosure(locals[locals.length-1][name]);
|
||||
} else {
|
||||
let name = consume()?.value;
|
||||
if (!name) return;
|
||||
let reg = nextReg++;
|
||||
locals[locals.length-1][name] = reg;
|
||||
if (peek()?.value === '=') { consume(); parseExpression(reg); }
|
||||
}
|
||||
} else if (t.value === 'function') {
|
||||
consume(); let name = consume().value;
|
||||
let reg = nextReg++;
|
||||
parseClosure(reg);
|
||||
bc.push(ops.SETG, reg, getC(name));
|
||||
} else if (['if', 'while', 'for', 'do'].includes(t.value)) {
|
||||
consume();
|
||||
parseBlock();
|
||||
if (peek()?.value === 'end') consume();
|
||||
} else if (t.type === 'identifier' && peek(1)?.value === '=') {
|
||||
let vn = consume().value; consume();
|
||||
let tempReg = nextReg;
|
||||
parseExpression(tempReg);
|
||||
let lReg = getLocal(vn);
|
||||
if (lReg !== undefined) bc.push(ops.MOVE, lReg, tempReg);
|
||||
else bc.push(ops.SETG, tempReg, getC(vn));
|
||||
} else if (['return', 'break', 'continue'].includes(t.value)) {
|
||||
consume();
|
||||
} else {
|
||||
parseExpression(nextReg);
|
||||
if (t === peek()) consume();
|
||||
}
|
||||
if (peek()?.value === ';') consume();
|
||||
};
|
||||
|
||||
while (ti < tokens.length) {
|
||||
let t = peek();
|
||||
if (t.value === 'local') {
|
||||
consume();
|
||||
let name = consume().value;
|
||||
if (peek()?.value === '=') {
|
||||
consume(); parseExpr(nextLocal);
|
||||
locals[name] = nextLocal++;
|
||||
} else {
|
||||
locals[name] = nextLocal++;
|
||||
}
|
||||
} else if (t.type === 'identifier' && tokens[ti+1]?.value === '=') {
|
||||
let vn = consume().value; consume();
|
||||
parseExpr(nextLocal);
|
||||
if (locals[vn] !== undefined) bc.push(ops.SETLOCAL, locals[vn], nextLocal);
|
||||
else bc.push(ops.SETG, nextLocal, getC(vn));
|
||||
} else if (t.type === 'identifier' && (tokens[ti+1]?.value === '(' || tokens[ti+1]?.value === ':')) {
|
||||
parseExpr(nextLocal);
|
||||
} else {
|
||||
ti++;
|
||||
}
|
||||
parseStatement();
|
||||
}
|
||||
|
||||
bc.push(ops.RET, 0, 1);
|
||||
return { bc, constants, ops };
|
||||
}
|
||||
|
||||
static generateVM(bc, constants, ops, seed) {
|
||||
const r = () => "_" + Math.random().toString(36).substring(7) + "_" + Math.floor(Math.random() * 10000);
|
||||
const nL = r(), nC = r(), nR = r(), nPC = r(), nK = r(), nD = r(), nDS = r(), nLOC = r();
|
||||
const nENV = r(), nTIME = r(), nX = r(), nY = r();
|
||||
|
||||
const r = () => "_" + crypto.randomBytes(3).toString('hex');
|
||||
const nL = r(), nC = r(), nR = r(), nPC = r(), nD = r(), nDS = r(), nENV = r();
|
||||
|
||||
const encC = constants.map(c => {
|
||||
if (c.type === 'string') {
|
||||
const key = seed & 0xFF;
|
||||
@ -200,86 +330,59 @@ class ObfuscatorService {
|
||||
return `{t=1,v="${e}"}`;
|
||||
}
|
||||
if (c.type === 'number') {
|
||||
const o = Math.floor(Math.random() * 1000);
|
||||
return `{t=2,v=${(c.value+o)^(seed&0xFFFF)},o=${o}}`;
|
||||
const o = Math.floor(Math.random() * 10000);
|
||||
return `{t=2,v=${(c.value + o) ^ (seed & 0xFFFF)},o=${o}}`;
|
||||
}
|
||||
return `{t=0}`;
|
||||
if (c.value === true) return `{t=3}`;
|
||||
if (c.value === false) return `{t=4}`;
|
||||
return `{t=5}`;
|
||||
}).join(',');
|
||||
|
||||
const xorKey = seed % 255;
|
||||
|
||||
const antiTamper = `
|
||||
local ${nENV} = getfenv and getfenv() or _G
|
||||
local ${nTIME} = tick()
|
||||
local function check()
|
||||
if ${nENV}.debug and ${nENV}.debug.getinfo then
|
||||
local i = ${nENV}.debug.getinfo(check)
|
||||
if i.what ~= "Lua" then while true do end end
|
||||
end
|
||||
local s = tick()
|
||||
for i=1,1000 do end
|
||||
if tick() - s > 1 then while true do end end
|
||||
end
|
||||
check()
|
||||
task.spawn(function()
|
||||
while true do
|
||||
if tick() - ${nTIME} > 4 then
|
||||
local ${nX} = nil; ${nX}.crash()
|
||||
end
|
||||
${nTIME} = tick()
|
||||
task.wait(3)
|
||||
end
|
||||
end)
|
||||
`;
|
||||
|
||||
const xorKey = (seed ^ 0xAA) & 0xFF;
|
||||
const d = [];
|
||||
d[ops.LOADK] = `function() ${nR}[${nL}[${nPC}]] = ${nD}(${nL}[${nPC}+1]); ${nPC}=${nPC}+2 end`;
|
||||
d[ops.GETG] = `function() ${nR}[${nL}[${nPC}]] = _G[${nD}(${nL}[${nPC}+1])]; ${nPC}=${nPC}+2 end`;
|
||||
d[ops.SETG] = `function() _G[${nD}(${nL}[${nPC}+1])] = ${nR}[${nL}[${nPC}]]; ${nPC}=${nPC}+2 end`;
|
||||
d[ops.GETG] = `function() ${nR}[${nL}[${nPC}]] = ${nENV}[${nD}(${nL}[${nPC}+1])]; ${nPC}=${nPC}+2 end`;
|
||||
d[ops.SETG] = `function() ${nENV}[${nD}(${nL}[${nPC}+1])] = ${nR}[${nL}[${nPC}]]; ${nPC}=${nPC}+2 end`;
|
||||
d[ops.GETT] = `function() local r,t,k = ${nL}[${nPC}],${nL}[${nPC}+1],${nL}[${nPC}+2]; ${nPC}=${nPC}+3; ${nR}[r] = ${nR}[t][${nD}(k)] end`;
|
||||
d[ops.GETS] = `function() local r,t,k = ${nL}[${nPC}],${nL}[${nPC}+1],${nL}[${nPC}+2]; ${nPC}=${nPC}+3; ${nR}[r+1] = ${nR}[t]; ${nR}[r] = ${nR}[t][${nD}(k)] end`;
|
||||
d[ops.CALL] = `function() local r,na,nr = ${nL}[${nPC}],${nL}[${nPC}+1],${nL}[${nPC}+2]; ${nPC}=${nPC}+3; local a={}; for i=1,na-1 do a[i]=${nR}[r+i] end; ${nR}[r]=${nR}[r](table.unpack(a)) end`;
|
||||
d[ops.GETS] = `function() local r,t,k = ${nL}[${nPC}],${nL}[${nPC}+1],${nL}[${nPC}+2]; ${nPC}=${nPC}+3; local o = ${nR}[t]; ${nR}[r+1] = o; ${nR}[r] = o[${nD}(k)] end`;
|
||||
d[ops.CALL] = `function() local r,na,nr = ${nL}[${nPC}],${nL}[${nPC}+1],${nL}[${nPC}+2]; ${nPC}=${nPC}+3; local a={}; for i=1,na-1 do a[i]=${nR}[r+i] end; local f = ${nR}[r]; if not f then error("Luartex VM Error: Call to nil at PC "..${nPC}) end; local res = {f(table.unpack(a))}; for i=1,nr do ${nR}[r+i-1] = res[i] end end`;
|
||||
d[ops.RET] = `function() return "EXIT" end`;
|
||||
d[ops.NEWTABLE] = `function() ${nR}[${nL}[${nPC}]] = {}; ${nPC}=${nPC}+1 end`;
|
||||
d[ops.SETTABLE] = `function() local t,k,v = ${nL}[${nPC}],${nL}[${nPC}+1],${nL}[${nPC}+2]; ${nPC}=${nPC}+3; ${nR}[t][${nD}(k)] = ${nR}[v] end`;
|
||||
d[ops.GETLOCAL] = `function() ${nR}[${nL}[${nPC}]] = ${nLOC}[${nL}[${nPC}+1]+1]; ${nPC}=${nPC}+2 end`;
|
||||
d[ops.SETLOCAL] = `function() ${nLOC}[${nL}[${nPC}]+1] = ${nR}[${nL}[${nPC}+1]]; ${nPC}=${nPC}+2 end`;
|
||||
|
||||
const argCounts = {
|
||||
[ops.LOADK]: 2, [ops.GETG]: 2, [ops.SETG]: 2, [ops.GETT]: 3,
|
||||
[ops.GETS]: 3, [ops.CALL]: 3, [ops.RET]: 2, [ops.NEWTABLE]: 1,
|
||||
[ops.SETTABLE]: 3, [ops.GETLOCAL]: 2, [ops.SETLOCAL]: 2
|
||||
};
|
||||
d[ops.SETTABLE] = `function() local t,k,v = ${nL}[${nPC}],${nL}[${nPC}+1],${nL}[${nPC}+2]; ${nPC}=${nPC}+3; if k == -1 then ${nR}[t][${nR}[${nL}[${nPC}-2]]] = ${nR}[v] else ${nR}[t][${nD}(k)] = ${nR}[v] end end`;
|
||||
d[ops.MOVE] = `function() ${nR}[${nL}[${nPC}]] = ${nR}[${nL}[${nPC}+1]]; ${nPC}=${nPC}+2 end`;
|
||||
d[ops.ADD] = `function() ${nR}[${nL}[${nPC}]] = ${nR}[${nL}[${nPC}+1]] + ${nR}[${nL}[${nPC}+2]]; ${nPC}=${nPC}+3 end`;
|
||||
d[ops.SUB] = `function() ${nR}[${nL}[${nPC}]] = ${nR}[${nL}[${nPC}+1]] - ${nR}[${nL}[${nPC}+2]]; ${nPC}=${nPC}+3 end`;
|
||||
d[ops.MUL] = `function() ${nR}[${nL}[${nPC}]] = ${nR}[${nL}[${nPC}+1]] * ${nR}[${nL}[${nPC}+2]]; ${nPC}=${nPC}+3 end`;
|
||||
d[ops.DIV] = `function() ${nR}[${nL}[${nPC}]] = ${nR}[${nL}[${nPC}+1]] / ${nR}[${nL}[${nPC}+2]]; ${nPC}=${nPC}+3 end`;
|
||||
d[ops.CONCAT] = `function() ${nR}[${nL}[${nPC}]] = tostring(${nR}[${nL}[${nPC}+1]]) .. tostring(${nR}[${nL}[${nPC}+2]]); ${nPC}=${nPC}+3 end`;
|
||||
d[ops.EQ] = `function() ${nR}[${nL}[${nPC}]] = (${nR}[${nL}[${nPC}+1]] == ${nR}[${nL}[${nPC}+2]]); ${nPC}=${nPC}+3 end`;
|
||||
d[ops.LT] = `function() ${nR}[${nL}[${nPC}]] = (${nR}[${nL}[${nPC}+1]] < ${nR}[${nL}[${nPC}+2]]); ${nPC}=${nPC}+3 end`;
|
||||
d[ops.LE] = `function() ${nR}[${nL}[${nPC}]] = (${nR}[${nL}[${nPC}+1]] <= ${nR}[${nL}[${nPC}+2]]); ${nPC}=${nPC}+3 end`;
|
||||
d[ops.CLOSURE] = `function() local r,k = ${nL}[${nPC}],${nL}[${nPC}+1]; ${nPC}=${nPC}+2; ${nR}[r] = loadstring(${nD}(k)) end`;
|
||||
|
||||
const shuffled = Object.keys(ops).sort(() => Math.random() - 0.5);
|
||||
const opMap = {};
|
||||
shuffled.forEach((k, i) => opMap[ops[k]] = i);
|
||||
const opMap = {}; shuffled.forEach((k, i) => opMap[ops[k]] = i);
|
||||
const argCounts = { [ops.LOADK]: 2, [ops.GETG]: 2, [ops.SETG]: 2, [ops.GETT]: 3, [ops.GETS]: 3, [ops.CALL]: 3, [ops.RET]: 2, [ops.NEWTABLE]: 1, [ops.SETTABLE]: 3, [ops.MOVE]: 2, [ops.ADD]: 3, [ops.SUB]: 3, [ops.MUL]: 3, [ops.DIV]: 3, [ops.CONCAT]: 3, [ops.EQ]: 3, [ops.LT]: 3, [ops.LE]: 3, [ops.CLOSURE]: 2 };
|
||||
|
||||
const finalBC = [];
|
||||
for (let i = 0; i < bc.length; ) {
|
||||
const op = bc[i];
|
||||
finalBC.push(opMap[op]);
|
||||
i++;
|
||||
const op = bc[i]; finalBC.push(opMap[op]); i++;
|
||||
const count = argCounts[op] || 0;
|
||||
for (let j = 0; j < count; j++) {
|
||||
finalBC.push(bc[i] || 0);
|
||||
i++;
|
||||
}
|
||||
for (let j = 0; j < count; j++) { finalBC.push(bc[i] || 0); i++; }
|
||||
}
|
||||
|
||||
const dispatchFunctions = shuffled.map(k => d[ops[k]] || "function() end").join(',');
|
||||
|
||||
const dispatchFunctions = shuffled.map(k => d[ops[k]]).join(',\n');
|
||||
const vmCode = `local function VM(...)
|
||||
${antiTamper}
|
||||
local ${nENV} = (getfenv and getfenv()) or _G
|
||||
local ${nL} = {${finalBC.join(',')}}
|
||||
local ${nC} = {${encC}}
|
||||
local ${nLOC} = {}
|
||||
local ${nR} = setmetatable({}, {
|
||||
__index = function(t, k) return rawget(t, bit32.bxor(k, ${xorKey})) end,
|
||||
__newindex = function(t, k, v) rawset(t, bit32.bxor(k, ${xorKey}), v) end
|
||||
})
|
||||
local ${nPC} = ${this.numberToExpression(1)}; local ${nK} = ${this.numberToExpression(seed)}
|
||||
local ${nPC} = 1
|
||||
local function ${nD}(i)
|
||||
if not i or i == -1 then return nil end
|
||||
local c = ${nC}[i+1]; if not c then return end
|
||||
if c.t == 1 then
|
||||
local b = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
@ -287,44 +390,49 @@ class ObfuscatorService {
|
||||
for j=1,#s,4 do
|
||||
local v = 0
|
||||
for k=0,3 do local char = s:sub(j+k,j+k); v = v*64 + (char=="=" and 0 or (b:find(char,1,true)-1)) end
|
||||
for k=2,0,-1 do if j+3-k<=#s and s:sub(j+3-k,j+3-k)~="=" then res = res..string.char(bit32.bxor(bit32.extract(v,k*8,8),bit32.band(${nK},255))) end end
|
||||
for k=2,0,-1 do if j+3-k<=#s and s:sub(j+3-k,j+3-k)~="=" then res = res..string.char(bit32.bxor(bit32.extract(v,k*8,8),bit32.band(${seed},255))) end end
|
||||
end
|
||||
return res
|
||||
elseif c.t == 2 then return bit32.bxor(c.v, bit32.band(${nK}, 65535)) - c.o end
|
||||
elseif c.t == 2 then return bit32.bxor(c.v, bit32.band(${seed}, 65535)) - c.o
|
||||
elseif c.t == 3 then return true elseif c.t == 4 then return false elseif c.t == 5 then return nil end
|
||||
end
|
||||
local ${nDS} = {${dispatchFunctions}}
|
||||
while true do
|
||||
-- Anti-Tamper / Opaque Predicate
|
||||
local _p = function() return tick() > 0 end
|
||||
while _p() do
|
||||
local op = ${nL}[${nPC}]; if not op then break end
|
||||
${nPC} = ${nPC} + 1
|
||||
local f = ${nDS}[op+1]
|
||||
if f then if f() == "EXIT" then break end else break end
|
||||
end
|
||||
end; VM(...)`;
|
||||
end; return xpcall(VM, function(e) warn("Luartex VM Error: "..tostring(e)) end, ...)`;
|
||||
|
||||
const wrapLayers = (code, layers) => {
|
||||
let current = code;
|
||||
for (let i = 0; i < layers; i++) {
|
||||
const layerSeed = crypto.randomBytes(4).readUInt32BE(0);
|
||||
const encoded = Buffer.from(current).map(b => b ^ (layerSeed & 0xFF)).toString('base64');
|
||||
current = `local _v = "${encoded}"
|
||||
local _s = ${this.numberToExpression(layerSeed)}
|
||||
local function _d(s)
|
||||
local b = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
local res = ""
|
||||
for j=1,#s,4 do
|
||||
local v = 0
|
||||
for k=0,3 do local char = s:sub(j+k,j+k); v = v*64 + (char=="=" and 0 or (b:find(char,1,true)-1)) end
|
||||
for k=2,0,-1 do if j+3-k<=#s and s:sub(j+3-k,j+3-k)~="=" then res = res..string.char(bit32.bxor(bit32.extract(v,k*8,8),bit32.band(_s,255))) end end
|
||||
end
|
||||
return res
|
||||
end
|
||||
local _f = loadstring(_d(_v))
|
||||
if _f then _f() end`;
|
||||
}
|
||||
return current;
|
||||
};
|
||||
return this.wrapLayers(vmCode, 3, seed);
|
||||
}
|
||||
|
||||
return wrapLayers(vmCode, 2);
|
||||
static wrapLayers(code, layers, seed) {
|
||||
let current = code;
|
||||
for (let i = 0; i < layers; i++) {
|
||||
const key = (seed >> (i * 8)) & 0xFF;
|
||||
const encoded = Buffer.from(current).map(b => b ^ key).toString('base64');
|
||||
const sExp = this.numberToExpression(seed);
|
||||
current = `local _v = "${encoded}"
|
||||
local _s = ${sExp}
|
||||
local function _d(s)
|
||||
local b = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
local res = ""
|
||||
for j=1,#s,4 do
|
||||
local v = 0
|
||||
for k=0,3 do local char = s:sub(j+k,j+k); v = v*64 + (char=="=" and 0 or (b:find(char,1,true)-1)) end
|
||||
for k=2,0,-1 do if j+3-k<=#s and s:sub(j+3-k,j+3-k)~="=" then res = res..string.char(bit32.bxor(bit32.extract(v,k*8,8),bit32.band(_s,255))) end end
|
||||
end
|
||||
return res
|
||||
end
|
||||
local _f, _e = loadstring(_d(_v))
|
||||
if _f then return _f() else error("Luartex Layer Error: "..tostring(_e)) end`;
|
||||
}
|
||||
return current;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = ObfuscatorService;
|
||||
Loading…
x
Reference in New Issue
Block a user