import * as fs from 'fs'; import { assert } from 'chai'; import { resolveSources } from 'source-map-resolve'; import { TDictionary } from '../../../src/types/TDictionary'; import { TIdentifierNamesCache } from '../../../src/types/TIdentifierNamesCache'; import { TInputOptions } from '../../../src/types/options/TInputOptions'; import { TOptionsPreset } from '../../../src/types/options/TOptionsPreset'; import { TTypeFromEnum } from '../../../src/types/utils/TTypeFromEnum'; import { IObfuscationResult } from '../../../src/interfaces/source-code/IObfuscationResult'; import { ISourceMap } from '../../../src/interfaces/source-code/ISourceMap'; import { SourceMapMode } from '../../../src/enums/source-map/SourceMapMode'; import { SourceMapSourcesMode } from '../../../src/enums/source-map/SourceMapSourcesMode'; import { StringArrayEncoding } from '../../../src/enums/node-transformers/string-array-transformers/StringArrayEncoding'; import { StringArrayIndexesType } from '../../../src/enums/node-transformers/string-array-transformers/StringArrayIndexesType'; import { StringArrayWrappersType } from '../../../src/enums/node-transformers/string-array-transformers/StringArrayWrappersType'; import { JavaScriptObfuscator } from '../../../src/JavaScriptObfuscatorFacade'; import { HIGH_OBFUSCATION_PRESET } from '../../../src/options/presets/HighObfuscation'; import { NO_ADDITIONAL_NODES_PRESET } from '../../../src/options/presets/NoCustomNodes'; import { IdentifierNamesGenerator } from '../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator'; import { OptionsPreset } from '../../../src/enums/options/presets/OptionsPreset'; import { buildLargeCode } from '../../helpers/buildLargeCode'; import { getRegExpMatch } from '../../helpers/getRegExpMatch'; import { getStringArrayRegExp } from '../../helpers/get-string-array-regexp'; import { readFileAsString } from '../../helpers/readFileAsString'; describe('JavaScriptObfuscator', () => { describe('obfuscate', () => { describe('correct source code', () => { let obfuscatedCode: string, sourceMap: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ); obfuscatedCode = obfuscationResult.getObfuscatedCode(); sourceMap = obfuscationResult.getSourceMap(); }); it('should return correct obfuscated code', () => { assert.isOk(obfuscatedCode); }); it('should return empty source map', () => { assert.isNotOk(sourceMap); }); }); describe('Empty or invalid source code', () => { describe('empty source code', () => { let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/empty-input.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, ).getObfuscatedCode(); }); it('should return an empty obfuscated code', () => { assert.isNotOk(obfuscatedCode); }); }); describe('empty source code with comments', () => { let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/comments-only.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { controlFlowFlattening: true, deadCodeInjection: true } ).getObfuscatedCode(); }); it('should return an empty obfuscated code', () => { assert.isNotOk(obfuscatedCode); }); }); describe('invalid source code type', () => { let obfuscatedCode: string; beforeEach(() => { obfuscatedCode = JavaScriptObfuscator.obfuscate( 1 as unknown as string ).getObfuscatedCode(); }); it('should return an empty obfuscated code', () => { assert.isNotOk(obfuscatedCode); }); }); }); describe('`sourceMap` option is `true`', () => { describe('`sourceMapMode` is `separate`', () => { let code: string, obfuscatedCode: string, sourceMap: ISourceMap, resolvedSources: string; beforeEach((done) => { code = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, sourceMap: true } ); obfuscatedCode = obfuscationResult.getObfuscatedCode(); sourceMap = JSON.parse(obfuscationResult.getSourceMap()); resolveSources(sourceMap, '/', fs.readFile, (error, result) => { resolvedSources = typeof result.sourcesContent[0] === 'string' ? result.sourcesContent[0] : ''; done(); }); }); it('should return correct obfuscated code', () => { assert.isOk(obfuscatedCode); }); it('should return correct source map mappings', () => { assert.isOk(sourceMap.mappings); }); it('should define placeholder `sources` field for source map', () => { assert.deepEqual(sourceMap.sources, ['sourceMap']); }); it('should define `sourcesContent` field for source map', () => { assert.isOk(sourceMap.sourcesContent); }); it('should resolve correct sources from source map', () => { assert.equal(resolvedSources, code); }); }); describe('`sourceMapMode` is `inline`', () => { const regExp: RegExp = /sourceMappingURL=data:application\/json;base64/; let code: string, obfuscatedCode: string, sourceMap: ISourceMap, resolvedSources: string; beforeEach((done) => { code = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, sourceMap: true, sourceMapMode: SourceMapMode.Inline } ); obfuscatedCode = obfuscationResult.getObfuscatedCode(); sourceMap = JSON.parse(obfuscationResult.getSourceMap()); resolveSources(sourceMap, '/', fs.readFile, (error, result) => { resolvedSources = typeof result.sourcesContent[0] === 'string' ? result.sourcesContent[0] : ''; done(); }); }); it('should return correct obfuscated code', () => { assert.isOk(obfuscatedCode); }); it('should return obfuscated code with inline source map as Base64 string', () => { assert.match(obfuscatedCode, regExp); }); it('should return correct source map mappings', () => { assert.isOk(sourceMap.mappings); }); it('should define placeholder `sources` field for source map', () => { assert.deepEqual(sourceMap.sources, ['sourceMap']); }); it('should define `sourcesContent` field for source map', () => { assert.isOk(sourceMap.sourcesContent); }); it('should resolve correct sources from source map', () => { console.log(resolvedSources); assert.equal(resolvedSources, code); }); }); describe('empty source code', () => { let obfuscatedCode: string, sourceMapNames: string[], sourceMapSources: string[], sourceMapMappings: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/empty-input.js'); const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate( code, { sourceMap: true } ); obfuscatedCode = obfuscationResult.getObfuscatedCode(); const sourceMapObject: any = JSON.parse(obfuscationResult.getSourceMap()); sourceMapNames = sourceMapObject.names; sourceMapSources = sourceMapObject.sources; sourceMapMappings = sourceMapObject.mappings; }); it('should return empty obfuscated code', () => { assert.isNotOk(obfuscatedCode); }); it('should return empty source map property `names`', () => { assert.deepEqual(sourceMapNames, []); }); it('should return empty source map property `sources`', () => { assert.deepEqual(sourceMapSources, []); }); it('should return empty source map property `mappings`', () => { assert.isNotOk(sourceMapMappings); }); }); describe('`sourceMapSourceMode` is set', () => { describe('`sourcesContent` value', () => { let code: string, obfuscatedCode: string, sourceMap: ISourceMap, resolvedSources: string; beforeEach((done) => { code = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, sourceMap: true, sourceMapSourcesMode: SourceMapSourcesMode.SourcesContent } ); obfuscatedCode = obfuscationResult.getObfuscatedCode(); sourceMap = JSON.parse(obfuscationResult.getSourceMap()); resolveSources(sourceMap, '/', fs.readFile, (error, result) => { resolvedSources = typeof result.sourcesContent[0] === 'string' ? result.sourcesContent[0] : ''; done(); }); }); it('should return correct obfuscated code', () => { assert.isOk(obfuscatedCode); }); it('should return correct source map mappings', () => { assert.isOk(sourceMap.mappings); }); it('should define `sources` field for source map', () => { assert.property(sourceMap, 'sources'); }); it('should define `sourcesContent` field for source map', () => { assert.property(sourceMap, 'sourcesContent'); }); it('should define placeholder `sources` field for source map', () => { assert.deepEqual(sourceMap.sources, ['sourceMap']); }); it('should define `sourcesContent` value with source code', () => { assert.deepEqual(sourceMap.sourcesContent[0], code); }); it('should resolve correct sources from source map', () => { assert.equal(resolvedSources, code); }); }); describe('`sources` value', () => { describe('`inputFileName` option is set', () => { let code: string, obfuscatedCode: string, sourceMap: ISourceMap; beforeEach(() => { code = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, inputFileName: 'someFile.js', sourceMap: true, sourceMapSourcesMode: SourceMapSourcesMode.Sources } ); obfuscatedCode = obfuscationResult.getObfuscatedCode(); sourceMap = JSON.parse(obfuscationResult.getSourceMap()); }); it('should return correct obfuscated code', () => { assert.isOk(obfuscatedCode); }); it('should return correct source map mappings', () => { assert.isOk(sourceMap.mappings); }); it('should define `sources` field for source map', () => { assert.property(sourceMap, 'sources'); }); it('should not define `sourcesContent` field for source map', () => { assert.notProperty(sourceMap, 'sourcesContent'); }); it('should define placeholder `sources` field for source map', () => { assert.deepEqual(sourceMap.sources, ['someFile.js']); }); }) describe('`inputFileName` option is not set', () => { let testFunc: () => IObfuscationResult; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); testFunc = () => JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, sourceMap: true, sourceMapSourcesMode: SourceMapSourcesMode.Sources } ); }); it('should throw an error', () => { assert.throws(testFunc, Error); }); }); }); }); }); describe('variable inside global scope', () => { describe('Variant #1: without `renameGlobals` option', () => { const regExp: RegExp = /^var test *= *0x\d+;$/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should return correct obfuscated code', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Variant #2: with `renameGlobals` option', () => { const regExp: RegExp = /^var _0x(\w){4,6} *= *0x\d+;$/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true } ).getObfuscatedCode(); }); it('should return correct obfuscated code', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Variant #3: with `renameGlobals` and `identifiersPrefix` options', () => { const regExp: RegExp = /^var foo_0x(\w){4,6} *= *0x\d+;$/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true, identifiersPrefix: 'foo' } ).getObfuscatedCode(); }); it('should return correct obfuscated code', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Variant #4: with `stringArray`, `renameGlobals` and `identifiersPrefix` options', () => { const stringArrayRegExp: RegExp = new RegExp( 'function foo_0x([a-f0-9]){4} *\\(\\) *{' + 'var _0x([a-f0-9]){4,6} *= *\\[\'abc\'];.*' + 'return foo_0x([a-f0-9]){4}\\(\\); *' + '}' ); const stringArrayCallRegExp: RegExp = /var foo_0x(\w){4,6} *= *foo_0x(\w){4}\(0x0\);/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/simple-input-2.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true, identifiersPrefix: 'foo', stringArray: true, stringArrayThreshold: 1 } ).getObfuscatedCode(); }); it('match #1: should return correct obfuscated code', () => { assert.match(obfuscatedCode, stringArrayRegExp); }); it('match #2: should return correct obfuscated code', () => { assert.match(obfuscatedCode, stringArrayCallRegExp); }); }); }); describe('variable inside block scope', () => { const regExp: RegExp = /^\(function *\(\) *\{ *var _0x[\w]+ *= *0x\d+; *\}(\(\)\)|\)\(\));?$/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/block-scope.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should return correct obfuscated code', () => { assert.match(obfuscatedCode, regExp); }); }); describe('variables inside global and block scopes', () => { describe('Variant #1: with `renameGlobals` and `identifiersPrefix` options', () => { const variableDeclaration1: RegExp = /var foo_0x(\w){4,6} *= *0x1;/; const variableDeclaration2: RegExp = /var foo_0x(\w){4,6} *= *0x2;/; const variableDeclaration3: RegExp = /var _0x(\w){4,6} *= *foo_0x(\w){4,6} *\+ *foo_0x(\w){4,6}/; const functionDeclaration: RegExp = /var foo_0x(\w){4,6} *= *function/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/identifiers-prefix.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true, identifiersPrefix: 'foo' } ).getObfuscatedCode(); }); it('match #1: should return correct obfuscated code', () => { assert.match(obfuscatedCode, variableDeclaration1); }); it('match #2: should return correct obfuscated code', () => { assert.match(obfuscatedCode, variableDeclaration2); }); it('match #3: should return correct obfuscated code', () => { assert.match(obfuscatedCode, variableDeclaration3); }); it('match #4: should return correct obfuscated code', () => { assert.match(obfuscatedCode, functionDeclaration); }); }); }); describe('latin literal variable value', () => { const stringArrayLatinRegExp: RegExp = getStringArrayRegExp(['abc']); const stringArrayCallRegExp: RegExp = /var test *= *_0x(\w){4}\(0x0\);/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/simple-input-2.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, stringArray: true, stringArrayThreshold: 1 } ).getObfuscatedCode(); }); it('match #1: should return correct obfuscated code', () => { assert.match(obfuscatedCode, stringArrayLatinRegExp); }); it('match #2: should return correct obfuscated code', () => { assert.match(obfuscatedCode, stringArrayCallRegExp); }); }); describe('cyrillic literal variable value', () => { const stringArrayCyrillicRegExp: RegExp = new RegExp( 'function _0x(\\w){4} *\\(\\) *{' + 'var _0x([a-f0-9]){4,6} *= *\\[\'абц\'];.*' + 'return _0x(\\w){4}\\(\\); *' + '}' ); const stringArrayCallRegExp: RegExp = /var test *= *_0x(\w){4}\(0x0\);/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/simple-input-cyrillic.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, stringArray: true, stringArrayThreshold: 1 } ).getObfuscatedCode(); }); it('match #1: should return correct obfuscated code', () => { assert.match(obfuscatedCode, stringArrayCyrillicRegExp); }); it('match #2: should return correct obfuscated code', () => { assert.match(obfuscatedCode, stringArrayCallRegExp); }); }); describe('seed', function () { this.timeout(60000); describe('same seed on each run', () => { const code: string = readFileAsString('./test/fixtures/sample.js'); const samples: number = 100; let obfuscatedCode1: string, obfuscatedCode2: string, seed: number = 12345, equalsCount: number = 0; beforeEach(() => { for (let i: number = 0; i < samples; i++) { if (i % 20 === 0) { seed++; } obfuscatedCode1 = JavaScriptObfuscator.obfuscate( code, { seed: seed } ).getObfuscatedCode(); obfuscatedCode2 = JavaScriptObfuscator.obfuscate( code, { seed: seed } ).getObfuscatedCode(); if (obfuscatedCode1 === obfuscatedCode2) { equalsCount++; } } }); it('should return same code every time with same `seed`', () => { assert.equal(equalsCount, samples); }); }); describe('Variant #1: different seed on each run', () => { const code: string = readFileAsString('./test/fixtures/sample.js'); let obfuscatedCode1: string, obfuscatedCode2: string; beforeEach(() => { obfuscatedCode1 = JavaScriptObfuscator.obfuscate( code, { seed: 12345 } ).getObfuscatedCode(); obfuscatedCode2 = JavaScriptObfuscator.obfuscate( code, { seed: 12346 } ).getObfuscatedCode(); }); it('should return different obfuscated code with different `seed` option value', () => { assert.notEqual(obfuscatedCode1, obfuscatedCode2); }); }); describe('Variant #2: different seed on each run', () => { const code: string = readFileAsString('./test/fixtures/sample.js'); let obfuscatedCode1: string, obfuscatedCode2: string; beforeEach(() => { obfuscatedCode1 = JavaScriptObfuscator.obfuscate( code, { seed: 0 } ).getObfuscatedCode(); obfuscatedCode2 = JavaScriptObfuscator.obfuscate( code, { seed: 0 } ).getObfuscatedCode(); }); it('should return different obfuscated code with different `seed` option value', () => { assert.notEqual(obfuscatedCode1, obfuscatedCode2); }); }); describe('Variant #3: same seed for different source code', () => { const code1: string = readFileAsString(__dirname + '/fixtures/simple-input-cyrillic.js'); const code2: string = readFileAsString(__dirname + '/fixtures/simple-input-2.js'); const regExp: RegExp = new RegExp( 'function _0x(\\w){4} *\\(\\) *{' + 'var _0x([a-f0-9]){4,6} *= *\\[\'.*\'];.*' + 'return _0x(\\w){4}\\(\\); *' + '}' ); let match1: string, match2: string; beforeEach(() => { const obfuscatedCode1: string = JavaScriptObfuscator.obfuscate( code1, { seed: 123, stringArrayThreshold: 1 } ).getObfuscatedCode(); const obfuscatedCode2: string = JavaScriptObfuscator.obfuscate( code2, { seed: 123, stringArrayThreshold: 1 } ).getObfuscatedCode(); match1 = getRegExpMatch(obfuscatedCode1, regExp); match2 = getRegExpMatch(obfuscatedCode2, regExp); }); it('should return different String Array names for different source code with same seed', () => { assert.notEqual(match1, match2); }); }); }); /** * https://github.com/estools/escodegen/pull/408 */ describe('`ObjectPattern` with single `RestElement`', () => { const regExp: RegExp = /const {\.\.\.foo} *= *{};/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/object-pattern-single-rest-element.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should not break on `ObjectPattern` with single `RestElement`', () => { assert.match(obfuscatedCode, regExp); }); }); /** * https://github.com/estools/escodegen/pull/415 */ describe('Precedence of `SequenceExpression` in computed property', () => { const regExp: RegExp = /class Foo *{ *\[\(bar, *baz\)]\(\) *{ *} * *}/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/precedence-of-sequence-expression-in-computed-property.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should generate a valid js code', () => { assert.match(obfuscatedCode, regExp); }); }); describe('new.target MetaProperty', () => { const regExp: RegExp = /new\.target *=== *Foo/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/new-target.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should keep new.target MetaProperty', () => { assert.match(obfuscatedCode, regExp); }); }); describe('import.meta support', () => { const regExp: RegExp = /console\['log']\(import\.meta\['url']\);/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/import-meta.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should support `import.meta`', () => { assert.match(obfuscatedCode, regExp); }); }); /** * https://github.com/javascript-obfuscator/javascript-obfuscator/issues/710 */ describe('export * as', () => { const regExp: RegExp = /export *\* *as foo from *'bar';/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/export-all-named-support.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should support `export * as` syntax', () => { assert.match(obfuscatedCode, regExp); }); }); /** * https://github.com/estools/escodegen/pull/407 */ describe('valid exponentiation operator precedence', () => { const regExp: RegExp = /var foo *= *\( *0x1 *- *0x2 *\) *\*\* *0x2;/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/exponentiation-operator-precedence.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should support exponentiation operator', () => { assert.match(obfuscatedCode, regExp); }); }); describe('BigInt support', () => { const regExp: RegExp = /return 0x20000000000001n *\+ *0xan *\+ *0xan;/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/bigint-support.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should support BigInt', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Optional chaining support', () => { const regExp: RegExp = new RegExp( 'const _0x(\\w){4,6} *= *{ *' + '\'bar\': *\\(\\) *=> *{} *' + '}; *' + '_0x(\\w){4,6}\\?\\.\\[\'bar\']\\?\\.\\(\\);' ); let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/optional-chaining-support.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should support optional chaining', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Nullish coalescing support', () => { const regExp: RegExp = /\(foo *\?\? *bar\) *&& *baz;/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/nullish-coalescing-support.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should support nullish coalescing operator', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Numeric separators support', () => { const regExp: RegExp = /const foo *= *0x64;/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/numeric-separators-support.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should support numeric separators', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Top-level await support', () => { const regExp: RegExp = /await 0x1;/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/top-level-await-support.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET } ).getObfuscatedCode(); }); it('should support top-level await', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Class static block support', () => { const regExp: RegExp = new RegExp( 'let _0x(\\w){4,6} *= *0x1; *' + 'class _0x(\\w){4,6} *{ *' + 'static *\\[\'_0x(\\w){4,6}\']; *' + 'static *{ *' + 'let _0x(\\w){4,6} *= *0x2; *' + '_0x(\\w){4,6}\\[\'_0x(\\w){4,6}\'] *= *0x3; *' + '_0x(\\w){4,6} *= *0x4; *' + '_0x(\\w){4,6} *= *0x5; *' + '} *' + '}' ); let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/class-static-block-support-1.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true, renameProperties: true } ).getObfuscatedCode(); console.log(obfuscatedCode); }); it('should support class static block await', () => { assert.match(obfuscatedCode, regExp); }); }); describe('Private identifiers support', () => { const regExp: RegExp = new RegExp( 'class Foo *{ *' + '#bar *= *0x1; *' + '\\[\'method\'] *\\(\\) *{ *' + 'this\.#bar *= *0x2;' + '} *' + '}' ); let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/private-identifier.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameProperties: true } ).getObfuscatedCode(); }); it('should support private identifiers', () => { assert.match(obfuscatedCode, regExp); }); }); describe('mangled identifier names generator', () => { const regExp: RegExp = /var c *= *0x1/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/mangle.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator, stringArray: true, stringArrayThreshold: 1 } ).getObfuscatedCode(); }); it('should mangle obfuscated code', () => { assert.match(obfuscatedCode, regExp); }); }); describe('mangled shuffled identifier names generator', () => { const regExp: RegExp = /var [a-zA-Z] *= *0x1/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/mangle.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { identifierNamesGenerator: IdentifierNamesGenerator.MangledShuffledIdentifierNamesGenerator } ).getObfuscatedCode(); }); it('should mangle obfuscated code', () => { assert.match(obfuscatedCode, regExp); }); }); describe('dictionary identifier names generator', () => { const regExp1: RegExp = /var [abc] *= *0x1; *var [abc] *= *0x2; *var [abc] *= *0x3;/; const regExp2: RegExp = /var [ABC] *= *0x4; *var [ABC] *= *0x5; *var [ABC] *= *0x6;/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/dictionary-identifiers.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, identifierNamesGenerator: IdentifierNamesGenerator.DictionaryIdentifierNamesGenerator, identifiersDictionary: ['a', 'b', 'c'] } ).getObfuscatedCode(); }); it('Match #1: should generate identifier based on the dictionary', () => { assert.match(obfuscatedCode, regExp1); }); it('Match #2: should generate identifier based on the dictionary', () => { assert.match(obfuscatedCode, regExp2); }); }); describe('parse module', () => { describe('Variant #1: import', () => { const importRegExp: RegExp = /import *{foo} *from *'.\/foo';/; const variableDeclarationRegExp: RegExp = /var test *= *0x1/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/parse-module-1.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate(code).getObfuscatedCode(); }); it('Match #1: should correctly obfuscate a import', () => { assert.match(obfuscatedCode, importRegExp); }); it('Match #2: should correctly obfuscate a module', () => { assert.match(obfuscatedCode, variableDeclarationRegExp); }); }); describe('Variant #2: export', () => { const regExp: RegExp = /export *const foo *= *0x1;/; let obfuscatedCode: string; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/parse-module-2.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate(code).getObfuscatedCode(); }); it('should correctly obfuscate a module', () => { assert.match(obfuscatedCode, regExp); }); }); }); describe('identifier names cache generation', () => { describe('Variant #1: `identifierNamesCache` and `renameGlobal` options are enabled. Existing cache is passed', () => { const expectedIdentifierNamesCache: TIdentifierNamesCache = { globalIdentifiers: { foo: 'a', bar: 'b', baz: 'baz_value_from_cache' }, propertyIdentifiers: {} }; let identifierNamesCache: TIdentifierNamesCache; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/identifier-names-cache-1.js'); identifierNamesCache = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true, identifierNamesCache: { globalIdentifiers: { baz: 'baz_value_from_cache' }, propertyIdentifiers: {} }, identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator } ).getIdentifierNamesCache(); }); it('Match #1: should correctly generate identifier names cache', () => { assert.deepEqual(identifierNamesCache, expectedIdentifierNamesCache); }); }); describe('Variant #2: `identifierNamesCache` and `renameGlobal` options are enabled', () => { const expectedIdentifierNamesCache: TIdentifierNamesCache = { globalIdentifiers: { foo: 'a', bar: 'b' }, propertyIdentifiers: {} }; let identifierNamesCache: TIdentifierNamesCache; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/identifier-names-cache-1.js'); identifierNamesCache = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true, identifierNamesCache: { globalIdentifiers: {}, propertyIdentifiers: {} }, identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator } ).getIdentifierNamesCache(); }); it('Match #1: should correctly generate identifier names cache', () => { assert.deepEqual(identifierNamesCache, expectedIdentifierNamesCache); }); }); describe('Variant #3: `identifierNamesCache` and `renameGlobal` options are enabled. Source code without global variables', () => { const expectedIdentifierNamesCache: TIdentifierNamesCache = { globalIdentifiers: {}, propertyIdentifiers: {} }; let identifierNamesCache: TIdentifierNamesCache; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/identifier-names-cache-2.js'); identifierNamesCache = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true, identifierNamesCache: { globalIdentifiers: {}, propertyIdentifiers: {} }, identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator } ).getIdentifierNamesCache(); }); it('Match #1: should correctly generate identifier names cache', () => { assert.deepEqual(identifierNamesCache, expectedIdentifierNamesCache); }); }); describe('Variant #4: `identifierNamesCache` option is disabled', () => { const expectedIdentifierNamesCache: TIdentifierNamesCache = null; let identifierNamesCache: TIdentifierNamesCache; beforeEach(() => { const code: string = readFileAsString(__dirname + '/fixtures/identifier-names-cache-1.js'); identifierNamesCache = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true, identifierNamesCache: null, identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator } ).getIdentifierNamesCache(); }); it('Match #1: should correctly generate identifier names cache', () => { assert.deepEqual(identifierNamesCache, expectedIdentifierNamesCache); }); }); }); describe('3.5k variables', function () { this.timeout(200000); const expectedValue: number = 3500; let result: number; beforeEach(() => { const code: string = buildLargeCode(expectedValue); const obfuscatedCode: string = JavaScriptObfuscator.obfuscate( code, { compact: true, controlFlowFlattening: true, controlFlowFlatteningThreshold: 1, deadCodeInjection: true, deadCodeInjectionThreshold: 1, disableConsoleOutput: false, numbersToExpressions: true, simplify: true, renameProperties: true, stringArrayRotate: true, stringArray: true, stringArrayEncoding: [ StringArrayEncoding.Base64, StringArrayEncoding.Rc4 ], stringArrayIndexesType: [ StringArrayIndexesType.HexadecimalNumber, StringArrayIndexesType.HexadecimalNumericString ], stringArrayIndexShift: true, stringArrayWrappersChainedCalls: true, stringArrayWrappersCount: 10, stringArrayWrappersParametersMaxCount: 5, stringArrayWrappersType: StringArrayWrappersType.Function, stringArrayThreshold: 1, transformObjectKeys: true, unicodeEscapeSequence: false } ).getObfuscatedCode(); result = eval(obfuscatedCode); }); it('should correctly obfuscate 3.5k variables', () => { assert.equal(result, expectedValue); }); }); describe('Eval `Hello World`', function () { this.timeout(20000); const samplesCount: number = 100; const expectedEvaluationResult: string = 'Hello World'; let isEvaluationSuccessful: boolean = true; before(() => { const code: string = readFileAsString(__dirname + '/fixtures/eval-hello-world.js'); for (let i = 0; i < samplesCount; i++) { const obfuscatedCode: string = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, compact: false, controlFlowFlattening: true, controlFlowFlatteningThreshold: 1, deadCodeInjection: true, deadCodeInjectionThreshold: 1, disableConsoleOutput: true, identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator, renameProperties: true, simplify: false, stringArray: true, stringArrayThreshold: 1, stringArrayWrappersChainedCalls: true, stringArrayWrappersCount: 1, stringArrayWrappersType: StringArrayWrappersType.Variable } ).getObfuscatedCode(); const evaluationResult: string = eval(obfuscatedCode); if (evaluationResult !== expectedEvaluationResult) { isEvaluationSuccessful = false; break; } } }); it('should correctly evaluate obfuscated code', () => { assert.equal(isEvaluationSuccessful, true); }); }); describe('Identifier names collision between base code and appended string array nodes', function () { this.timeout(10000); const samplesCount: number = 30; let collisionError: string | null = null; let obfuscateFunc: (identifierNamesGenerator: TTypeFromEnum) => IObfuscationResult; before(() => { const code: string = readFileAsString(__dirname + '/fixtures/custom-nodes-identifier-names-collision.js'); obfuscateFunc = (identifierNamesGenerator: TTypeFromEnum) => { return JavaScriptObfuscator.obfuscate( code, { identifierNamesGenerator, compact: false, renameGlobals: true, identifiersDictionary: ['foo', 'bar', 'baz', 'bark', 'hawk', 'foozmos', 'cow', 'chikago'], stringArray: true } ); }; [ IdentifierNamesGenerator.DictionaryIdentifierNamesGenerator, IdentifierNamesGenerator.MangledIdentifierNamesGenerator ].forEach((identifierNamesGenerator: TTypeFromEnum) => { for (let i = 0; i < samplesCount; i++) { const obfuscationResult = obfuscateFunc(identifierNamesGenerator); const obfuscatedCode = obfuscationResult.getObfuscatedCode(); const seed = obfuscationResult.getOptions().seed; try { eval(obfuscatedCode); } catch (error) { collisionError = `Seed: ${seed}. Error: ${error.message}`; break; } } }); }); it('It does not create identifier names collision', () => { assert.isNull(collisionError); }); }); describe('Prevailing kind of variables', () => { const baseParams: TInputOptions = { compact: true, controlFlowFlattening: true, controlFlowFlatteningThreshold: 1, deadCodeInjection: true, deadCodeInjectionThreshold: 1, debugProtection: true, debugProtectionInterval: true, disableConsoleOutput: false, stringArrayRotate: true, selfDefending: true, stringArray: true, stringArrayThreshold: 1, transformObjectKeys: true, unicodeEscapeSequence: false }; describe('`var` kind', function () { let obfuscatedCode: string; before(() => { const code: string = readFileAsString(__dirname + '/fixtures/prevailing-kind-of-variables-var.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, ...baseParams, stringArrayEncoding: [StringArrayEncoding.Rc4] } ).getObfuscatedCode(); }); it('does not break on run', () => { assert.doesNotThrow(() => eval(obfuscatedCode)); }); }); describe('`const` kind', function () { describe('Variant #1: StringArrayEncoding: rc4', () => { let obfuscatedCode: string; before(() => { const code: string = readFileAsString(__dirname + '/fixtures/prevailing-kind-of-variables-const.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, ...baseParams, stringArrayEncoding: [StringArrayEncoding.Rc4] } ).getObfuscatedCode(); }); it('does not break on run', () => { assert.doesNotThrow(() => eval(obfuscatedCode)); }); }); describe('Variant #2: StringArrayEncoding: base64', () => { let obfuscatedCode: string; before(() => { const code: string = readFileAsString(__dirname + '/fixtures/prevailing-kind-of-variables-const.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, ...baseParams, stringArrayEncoding: [StringArrayEncoding.Rc4] } ).getObfuscatedCode(); }); it('does not break on run', () => { assert.doesNotThrow(() => eval(obfuscatedCode)); }); }); }); describe('`let` kind', function () { describe('Variant #1: StringArrayEncoding: rc4', () => { let obfuscatedCode: string; before(() => { const code: string = readFileAsString(__dirname + '/fixtures/prevailing-kind-of-variables-let.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, ...baseParams, stringArrayEncoding: [StringArrayEncoding.Rc4] } ).getObfuscatedCode(); }); it('does not break on run', () => { assert.doesNotThrow(() => eval(obfuscatedCode)); }); }); describe('Variant #2: StringArrayEncoding: base64', () => { let obfuscatedCode: string; before(() => { const code: string = readFileAsString(__dirname + '/fixtures/prevailing-kind-of-variables-let.js'); obfuscatedCode = JavaScriptObfuscator.obfuscate( code, { ...NO_ADDITIONAL_NODES_PRESET, ...baseParams, stringArrayEncoding: [StringArrayEncoding.Base64] } ).getObfuscatedCode(); }); it('does not break on run', () => { assert.doesNotThrow(() => eval(obfuscatedCode)); }); }); }); }); }); describe('obfuscateMultiple', () => { describe('multiple source codes', () => { const regExp1: RegExp = /var a0_0x(\w){4,6} *= *0x1;/; const regExp2: RegExp = /var a1_0x(\w){4,6} *= *'abc';/; let obfuscatedCode1: string; let obfuscatedCode2: string; beforeEach(() => { const sourceCode1: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js'); const sourceCode2: string = readFileAsString(__dirname + '/fixtures/simple-input-2.js'); const obfuscationResultsObject = JavaScriptObfuscator.obfuscateMultiple( { sourceCode1, sourceCode2 }, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true } ); obfuscatedCode1 = obfuscationResultsObject.sourceCode1.getObfuscatedCode(); obfuscatedCode2 = obfuscationResultsObject.sourceCode2.getObfuscatedCode(); }); it('Match #1: should return correct obfuscated code', () => { assert.match(obfuscatedCode1, regExp1); }); it('Match #2: should return correct obfuscated code', () => { assert.match(obfuscatedCode2, regExp2); }); }); describe('invalid source codes object', () => { let testFunc: () => TDictionary; beforeEach(() => { testFunc = () => JavaScriptObfuscator.obfuscateMultiple( 'foo' as any, { ...NO_ADDITIONAL_NODES_PRESET, renameGlobals: true } ); }); it('Should throw an error if source codes object is not a plain object', () => { assert.throw(testFunc, Error); }); }); }); describe('getOptionsByPreset', () => { describe('Variant #1: base behaviour', () => { const optionsPresetName: TOptionsPreset = OptionsPreset.HighObfuscation; let options: TInputOptions; before(() => { options = JavaScriptObfuscator.getOptionsByPreset(optionsPresetName); }); it('Should return options for passed options preset name', () => { assert.deepEqual(options, HIGH_OBFUSCATION_PRESET); }); }); describe('Variant #2: unknown options preset name', () => { const optionsPresetName: TOptionsPreset = 'foobar' as TOptionsPreset; let testFunc: () => TInputOptions; before(() => { testFunc = () => JavaScriptObfuscator.getOptionsByPreset(optionsPresetName); }); it('Should throws an error when unknown option preset is passed', () => { assert.throws(testFunc, 'Options for preset name `foobar` are not found'); }); }); }); });