FunctionControlFlowTransformer tests

src/stack-trace-analyzer/callee-data-extractors/ObjectExpressionCalleeDataExtractor.ts

@@ -23,10 +23,7 @@ export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtra
             functionExpressionName: string|number|null = null;
 
         if (Node.isMemberExpressionNode(callee)) {
-            const objectMembersCallsChain: TObjectMembersCallsChain = this.createObjectMembersCallsChain(
-                [],
-                callee
-            );
+            const objectMembersCallsChain: TObjectMembersCallsChain = this.createObjectMembersCallsChain([], callee);
 
             if (!objectMembersCallsChain.length) {
                 return null;

test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-1.js

@@ -0,0 +1,3 @@
+(function () {
+    var variable = 1 + 2;
+})();

test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-2.js

@@ -0,0 +1,11 @@
+(function () {
+    function foo () {
+        function bar () {
+            function baz () {
+                function bash () {
+                    var variable = 1 + 2;
+                }
+            }
+        }
+    }
+})();

test/functional-tests/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.spec.ts

@@ -15,7 +15,6 @@ describe('ConsoleOutputDisableExpressionNode', () => {
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 disableConsoleOutput: true
-
             }
         );
 

test/functional-tests/node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer.spec.ts

@@ -0,0 +1,90 @@
+import { assert } from 'chai';
+
+import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+
+import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+
+import { readFileAsString } from '../../../helpers/readFileAsString';
+
+import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
+
+describe('FunctionControlFlowTransformer', () => {
+    const variableMatch: string = '_0x([a-z0-9]){4,6}';
+    const rootControlFlowStorageNodeMatch: string = `` +
+        `var *${variableMatch} *= *\\{` +
+            `'(\\\\x[a-f0-9]*){3}' *: *function *${variableMatch} *\\(${variableMatch}, *${variableMatch}\\) *\\{` +
+                `return *${variableMatch} *\\+ *${variableMatch};` +
+            `\\}` +
+        `\\};` +
+    ``;
+    const innerControlFlowStorageNodeMatch: string = `` +
+        `var *${variableMatch} *= *\\{` +
+            `'(\\\\x[a-f0-9]*){3}' *: *function *${variableMatch} *\\(${variableMatch}, *${variableMatch}\\) *\\{` +
+                `return *${variableMatch}\\['(\\\\x[a-f0-9]*){3}'\\]\\(${variableMatch}, *${variableMatch}\\);` +
+            `\\}` +
+        `\\};` +
+    ``;
+
+    describe('transformNode (functionNode: ESTree.Function): ESTree.Node', () => {
+        describe('variant #1 - single `control flow storage` node with single item', () => {
+            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                readFileAsString(
+                    './test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-1.js'
+                ),
+                {
+                    ...NO_CUSTOM_NODES_PRESET,
+                    controlFlowFlattening: true,
+                    controlFlowFlatteningThreshold: 1
+                }
+            );
+            const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+            const regexp: RegExp = new RegExp(rootControlFlowStorageNodeMatch);
+
+            it('should add `control flow storage` node to the obfuscated code', () => {
+                assert.match(obfuscatedCode, regexp);
+            });
+        });
+
+        describe('variant #2 - two `control flow storage` nodes: root and inner', () => {
+            const samplesCount: number = 150;
+            const delta: number = 0.1;
+            const expectedValue: number = 0.5;
+            const regExp1: RegExp = new RegExp(
+                `\\(function\\(\\) *\\{ *${rootControlFlowStorageNodeMatch}`,
+                'g'
+            );
+            const regExp2: RegExp = new RegExp(
+                `function *${variableMatch} *\\(\\) *\\{ *${innerControlFlowStorageNodeMatch}`,
+                'g'
+            );
+
+            let totalValue: number = 0;
+
+            for (let i = 0; i < samplesCount; i++) {
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    readFileAsString(
+                        './test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-2.js'
+                    ),
+                    {
+                        ...NO_CUSTOM_NODES_PRESET,
+                        controlFlowFlattening: true,
+                        controlFlowFlatteningThreshold: 1
+                    }
+                );
+                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+
+                if (regExp1.test(obfuscatedCode)) {
+                    totalValue += obfuscatedCode.match(regExp1)!.length;
+
+                    if (regExp2.test(obfuscatedCode)) {
+                        totalValue += obfuscatedCode.match(regExp2)!.length;
+                    }
+                }
+            }
+
+            it('should add two `control flow storage` nodes (root and inner) to the obfuscated code in different scopes', () => {
+                assert.closeTo((totalValue - samplesCount) / samplesCount, expectedValue, delta);
+            });
+        });
+    });
+});

test/index.spec.ts

@@ -30,6 +30,7 @@ import './functional-tests/custom-nodes/domain-lock-nodes/DomainLockNode.spec';
 import './functional-tests/custom-nodes/string-array-nodes/StringArrayCallsWrapper.spec';
 import './functional-tests/custom-nodes/string-array-nodes/StringArrayRotateFunctionNode.spec';
 import './functional-tests/custom-nodes/string-array-nodes/StringArrayNode.spec';
+import './functional-tests/node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer.spec';
 import './functional-tests/node-transformers/node-control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer.spec';
 import './functional-tests/node-transformers/node-obfuscators/CatchClauseObfuscator.spec';
 import './functional-tests/node-transformers/node-obfuscators/FunctionDeclarationObfuscator.spec';