Merge pull request #211 from z0ffy/feature/multi-page

feat: enhance obfuscation process with registry management

Author: z0ffy

src/type.ts

@@ -9,6 +9,12 @@ export type BundleList = Array<[string, Rollup.OutputChunk]>;
 export interface WorkerMessage {
   config: Config;
   chunk: BundleList;
+  registryState?: string[];
+}
+
+export interface WorkerResponse {
+  results: ObfuscationResult[];
+  registryState: string[];
 }
 
 export type SizeResult = { original: FormatSizeResult; gzip: FormatSizeResult };

src/utils/index.ts

@@ -105,19 +105,86 @@ export function getChunkName(id: string, manualChunks: string[]): string {
   return VENDOR_MODULES;
 }
 
+export class ObfuscatedFilesRegistry {
+  private static instance: ObfuscatedFilesRegistry;
+  private obfuscatedFiles: Set<string> = new Set();
+
+  private constructor() {
+  }
+
+  public static getInstance(): ObfuscatedFilesRegistry {
+    if (!ObfuscatedFilesRegistry.instance) {
+      ObfuscatedFilesRegistry.instance = new ObfuscatedFilesRegistry();
+    }
+    return ObfuscatedFilesRegistry.instance;
+  }
+
+  public markAsObfuscated(fileName: string): void {
+    if (!fileName) return;
+    this.obfuscatedFiles.add(fileName);
+  }
+
+  public isObfuscated(fileName: string): boolean {
+    if (!fileName) return false;
+    return this.obfuscatedFiles.has(fileName);
+  }
+
+  public getAllObfuscatedFiles(): string[] {
+    return Array.from(this.obfuscatedFiles);
+  }
+
+  public clear(): void {
+    this.obfuscatedFiles.clear();
+  }
+
+  public serialize(): string[] {
+    return Array.from(this.obfuscatedFiles);
+  }
+
+  public updateFromSerialized(serializedFiles: string[]): void {
+    if (!serializedFiles || !Array.isArray(serializedFiles)) return;
+
+    serializedFiles.forEach((file) => {
+      this.obfuscatedFiles.add(file);
+    });
+  }
+}
+
 export function obfuscateBundle(finalConfig: Config, fileName: string, bundleItem: Rollup.OutputChunk): string {
   const _log = new Log(finalConfig.log);
+  const registry = ObfuscatedFilesRegistry.getInstance();
+
+  if (registry.isObfuscated(fileName)) {
+    _log.info(`skipping ${fileName} (already in obfuscated registry)`);
+    return bundleItem.code;
+  }
+
   _log.info(`obfuscating ${fileName}...`);
   const obfuscatedCode = javascriptObfuscator.obfuscate(bundleItem.code, finalConfig.options).getObfuscatedCode();
   _log.info(`obfuscation complete for ${fileName}.`);
+
+  registry.markAsObfuscated(fileName);
+  _log.info(`added ${fileName} to obfuscated files registry`);
+
   return obfuscatedCode;
 }
 
 export function obfuscateLibBundle(finalConfig: Config, fileName: string, code: string): { code: string; map: Rollup.SourceMapInput } {
   const _log = new Log(finalConfig.log);
+  const registry = ObfuscatedFilesRegistry.getInstance();
+
+  if (registry.isObfuscated(fileName)) {
+    _log.info(`skipping ${fileName} (already in obfuscated registry)`);
+    return { code, map: null };
+  }
+
   _log.info(`obfuscating ${fileName}...`);
   const obfuscated = javascriptObfuscator.obfuscate(code, finalConfig.options);
   _log.info(`obfuscation complete for ${fileName}.`);
+
+  registry.markAsObfuscated(fileName);
+  _log.info(`added ${fileName} to obfuscated files registry`);
+
   return {
     code: obfuscated.getObfuscatedCode(),
     map: obfuscated.getSourceMap(),
@@ -127,15 +194,28 @@ export function obfuscateLibBundle(finalConfig: Config, fileName: string, code:
 export function createWorkerTask(finalConfig: Config, chunk: BundleList) {
   return new Promise((resolve, reject) => {
     const worker = new Worker(path.join(__dirname, WORKER_FILE_PATH));
-    worker.postMessage({ config: finalConfig, chunk });
+    const registry = ObfuscatedFilesRegistry.getInstance();
+
+    worker.postMessage({
+      config: finalConfig,
+      chunk,
+      registryState: registry.serialize(),
+    });
 
     worker.on('message', (value) => {
-      chunk.forEach(([fileName, bundleItem]) => {
-        const result = value.find((i: ObfuscationResult) => i.fileName === fileName);
-        if (result && result.obfuscatedCode) {
-          bundleItem.code = result.obfuscatedCode;
-        }
-      });
+      if (value.results && Array.isArray(value.results)) {
+        chunk.forEach(([fileName, bundleItem]) => {
+          const result = value.results.find((i: ObfuscationResult) => i.fileName === fileName);
+          if (result && result.obfuscatedCode) {
+            bundleItem.code = result.obfuscatedCode;
+          }
+        });
+      }
+
+      if (value.registryState && Array.isArray(value.registryState)) {
+        registry.updateFromSerialized(value.registryState);
+      }
+
       resolve(value);
       worker.unref();
     });

src/utils/is.ts

@@ -23,13 +23,23 @@ export function isBoolean(input: any): input is boolean {
   return Object.prototype.toString.call(input) === '[object Boolean]';
 }
 
-export function isFileNameExcluded(name: string, excludes: (RegExp | string)[]): boolean {
-  for (const exclude of excludes) {
-    if (isRegExp(exclude)) {
-      if (exclude.test(name)) return true;
-    } else if (isString(exclude)) {
-      if (name.includes(exclude)) return true;
-    }
+export function isFileNameExcluded(fileName: string, excludes: (RegExp | string)[] | RegExp | string): boolean {
+  if (!excludes) return false;
+
+  if (Array.isArray(excludes)) {
+    return excludes.some((exclude) => {
+      if (isString(exclude)) {
+        return fileName.includes(exclude);
+      } else if (isRegExp(exclude)) {
+        return exclude.test(fileName);
+      }
+      return false;
+    });
+  } else if (isString(excludes)) {
+    return fileName.includes(excludes);
+  } else if (isRegExp(excludes)) {
+    return excludes.test(fileName);
   }
+
   return false;
 }

src/worker/index.ts

@@ -1,15 +1,46 @@
 import { parentPort } from 'node:worker_threads';
-import { ObfuscationResult, WorkerMessage } from '../type';
-import { obfuscateBundle } from '../utils';
+import javascriptObfuscator from 'javascript-obfuscator';
+import { Log, ObfuscatedFilesRegistry } from '../utils';
+import type { ObfuscationResult, WorkerMessage } from '../type';
 
-parentPort?.on('message', (message: WorkerMessage) => {
-  const { config, chunk } = message;
+if (parentPort) {
+  parentPort.on('message', (message: WorkerMessage) => {
+    const results: ObfuscationResult[] = [];
+    const _log = new Log(message.config.log);
+    const registry = ObfuscatedFilesRegistry.getInstance();
 
-  const result: ObfuscationResult[] = chunk.map(([fileName, bundleItem]) => {
-    const obfuscatedCode = obfuscateBundle(config, fileName, bundleItem);
+    if (message.registryState && Array.isArray(message.registryState)) {
+      registry.updateFromSerialized(message.registryState);
+    }
 
-    return { fileName, obfuscatedCode };
-  });
+    for (const [fileName, bundleItem] of message.chunk) {
+      if (registry.isObfuscated(fileName)) {
+        _log.info(`skipping ${fileName} (already in obfuscated registry)`);
+        results.push({
+          fileName,
+          obfuscatedCode: bundleItem.code,
+        });
+        continue;
+      }
+
+      _log.info(`worker obfuscating ${fileName}...`);
+      const obfuscated = javascriptObfuscator.obfuscate(bundleItem.code, message.config.options);
+      _log.info(`worker obfuscation complete for ${fileName}.`);
+
+      registry.markAsObfuscated(fileName);
+      _log.info(`worker added ${fileName} to obfuscated files registry`);
 
-  parentPort?.postMessage(result);
-});
+      results.push({
+        fileName,
+        obfuscatedCode: obfuscated.getObfuscatedCode(),
+      });
+    }
+
+    if (parentPort) {
+      parentPort.postMessage({
+        results,
+        registryState: registry.serialize(),
+      });
+    }
+  });
+}