obfulox/obfulox.ts

Advanced JavaScript code encryptor with multi-layer encryption and obfuscation

import { jsConfuser } from 'js-confuser';

interface ObfuscationOptions {
  file: string;
  base64: boolean;
  linelox: number;
  obfulox: boolean;
  LZString: boolean;
  uniCode: boolean;
  jsConfuser: boolean;
  arrayObfuscation: boolean;
  stringObfuscation: boolean;
  integrity: boolean;
  deadCode: boolean;
  uniCodeType: string;
  idObfulox: string;
  lock: {
    antiDebug: boolean;
    selfDefending: boolean;
  };
  codeobfulox: boolean;
}

interface ObfuscationResult {
  code: string;
  idObfulox: string;
  metadata: {
    timestamp: number;
    options: Partial<ObfuscationOptions>;
  };
}

const generateIdObfulox = (): string => {
  return Math.random().toString(36).substr(2, 10);
};

export async function obfuscationlox(
  fileName: string, 
  options: ObfuscationOptions
): Promise<ObfuscationResult> {
  const idObfulox = generateIdObfulox();
  
  const lock = {
    antiDebug: options.lock.antiDebug,
    selfDefending: options.lock.selfDefending,
  };
  
  const obfuscationOptions = {
    jsConfuser: options.jsConfuser,
    arrayObfuscation: options.arrayObfuscation,
    stringObfuscation: options.stringObfuscation,
    integrity: options.integrity,
    deadCode: options.deadCode,
    uniCodeType: options.uniCodeType,
    idObfulox,
    lock,
  };
  
  const obfuscatedCode = await jsConfuser.obfuscateFile({
    input: fileName,
    output: 'obfuscated',
    options: obfuscationOptions,
  });
  
  const markedCode = `/* OBFULOX_ID:${idObfulox} */\n${obfuscatedCode}`;
  return {
    code: markedCode,
    idObfulox,
    metadata: {
      timestamp: Date.now(),
      options: {
        jsConfuser: options.jsConfuser,
        arrayObfuscation: options.arrayObfuscation,
        stringObfuscation: options.stringObfuscation,
        integrity: options.integrity,
        deadCode: options.deadCode,
        uniCodeType: options.uniCodeType,
        lock: options.lock,
      }
    }
  };
}

export async function deobfuscationlox(
  obfuscatedCode: string,
  idObfulox: string
): Promise<string> {
  const idMatch = obfuscatedCode.match(/\/\* OBFULOX_ID:(\w+) \*\//);
  if (!idMatch) {
    throw new Error('The code does not have a valid obfuscation ID.');
  }
  
  const extractedId = idMatch[1];
  if (extractedId !== idObfulox) {
    throw new Error('Obfuscation ID mismatch. Decrypt failed..');
  }
  let cleanCode = obfuscatedCode.replace(/\/\* OBFULOX_ID:\w+ \*\/\n?/, '');
  console.warn('Full deobfuscation is not possible automatically..');
  console.warn('Valid ID. The original code must be stored separately during obfuscation..');
  
  return cleanCode;
}

export function extractIdObfulox(obfuscatedCode: string): string | null {
  const idMatch = obfuscatedCode.match(/\/\* OBFULOX_ID:(\w+) \*\//);
  return idMatch ? idMatch[1] : null;
}

export function validateIdObfulox(
  obfuscatedCode: string, 
  idObfulox: string
): boolean {
  const extractedId = extractIdObfulox(obfuscatedCode);
  return extractedId === idObfulox;
}