Merge pull request #322 from javascript-obfuscator/0.18.2-bugfixes

0.18.2 version

CHANGELOG.md

@@ -1,5 +1,10 @@
 Change Log
 ===
+v0.18.2
+---
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/320
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/319
+
 v0.18.1
 ---
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/317

package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "0.18.1",
+  "version": "0.18.2",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",

src/node-transformers/converting-transformers/properties-extractors/AbstractPropertiesExtractor.ts

@@ -70,6 +70,14 @@ export abstract class AbstractPropertiesExtractor implements IPropertiesExtracto
         return null;
     }
 
+    /**
+     * @param {Node} node
+     * @returns {propertyValueNode is Pattern}
+     */
+    protected static isProhibitedHostParent (node: ESTree.Node): node is ESTree.Pattern {
+        return NodeGuards.isMemberExpressionNode(node);
+    }
+
     /**
      * @param {Node} node
      * @returns {propertyValueNode is Pattern}

src/node-transformers/converting-transformers/properties-extractors/AssignmentExpressionPropertiesExtractor.ts

@@ -30,6 +30,7 @@ export class AssignmentExpressionPropertiesExtractor extends AbstractPropertiesE
         objectExpressionNode: ESTree.ObjectExpression,
         hostNode: ESTree.AssignmentExpression
     ): ESTree.Node {
+        const hostParentNode: ESTree.Node | undefined = hostNode.parentNode;
         const leftNode: ESTree.MemberExpression | ESTree.Pattern = hostNode.left;
 
         // left node shouldn't be as Pattern node
@@ -37,6 +38,11 @@ export class AssignmentExpressionPropertiesExtractor extends AbstractPropertiesE
             return objectExpressionNode;
         }
 
+        // left node shouldn't be as Pattern node
+        if (hostParentNode && AbstractPropertiesExtractor.isProhibitedHostParent(hostParentNode)) {
+            return objectExpressionNode;
+        }
+
         return this.transformObjectExpressionNode(
             objectExpressionNode,
             leftNode

src/node-transformers/obfuscating-transformers/FunctionTransformer.ts

@@ -126,7 +126,7 @@ export class FunctionTransformer extends AbstractNodeTransformer {
      */
     private isGlobalFunctionDeclarationIdentifier (node: ESTree.Identifier, parentNode: ESTree.Node): boolean {
         if (!NodeGuards.isFunctionDeclarationNode(parentNode) || parentNode.id !== node) {
-            return false
+            return false;
         }
 
         const lexicalScopeNode: TNodeWithLexicalScope | undefined = NodeLexicalScopeUtils.getLexicalScopes(parentNode)[1];

src/node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer.ts

@@ -134,7 +134,7 @@ export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
      */
     public replace (nodeValue: string): ESTree.Node {
         if (this.isReservedString(nodeValue)) {
-            return NodeFactory.literalNode(nodeValue);
+            return this.replaceWithReservedLiteralNode(nodeValue);
         }
 
         const useStringArray: boolean = this.canUseStringArray(nodeValue);
@@ -227,6 +227,16 @@ export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
         );
     }
 
+    /**
+     * @param {string} value
+     * @returns {Node}
+     */
+    private replaceWithReservedLiteralNode (value: string): ESTree.Node {
+        return NodeFactory.literalNode(
+            this.escapeSequenceEncoder.encode(value, false)
+        );
+    }
+
     /**
      * @param {string} value
      * @returns {Node}

test/dev/dev.ts

@@ -6,10 +6,8 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-        function foo (foo) {}
-
-        new foo();
-
+        var n;
+        (n = {foo: 'bar'}).baz = n.foo;
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/ObjectExpressionKeysTransformer.spec.ts

@@ -519,5 +519,31 @@ describe('ObjectExpressionKeysTransformer', () => {
                 });
             });
         });
+
+        describe('Variant #4: assignment expression and member expression', () => {
+            const match: string = `` +
+                `var ${variableMatch}; *` +
+                `\\(${variableMatch} *= *{'foo': *'bar'}\\)\\['baz'] *= *${variableMatch}\\['foo'];` +
+            ``;
+            const regExp: RegExp = new RegExp(match);
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/assignment-expression-and-member-expression.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        transformObjectKeys: true
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('shouldn\'t transform object keys', () => {
+                assert.match(obfuscatedCode,  regExp);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/assignment-expression-and-member-expression.js

@@ -0,0 +1,4 @@
+(function(){
+    var n;
+    (n = {foo: 'bar'}).baz = n.foo;
+})();

test/functional-tests/node-transformers/obfuscating-transformers/literal-transformer/LiteralTransformer.spec.ts

@@ -313,7 +313,7 @@ describe('LiteralTransformer', () => {
                     let obfuscatedCode: string;
 
                     before(() => {
-                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option.js');
+                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
 
                         obfuscatedCode = JavaScriptObfuscator.obfuscate(
                             code,
@@ -342,7 +342,7 @@ describe('LiteralTransformer', () => {
                     let obfuscatedCode: string;
 
                     before(() => {
-                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option.js');
+                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
 
                         obfuscatedCode = JavaScriptObfuscator.obfuscate(
                             code,
@@ -373,7 +373,7 @@ describe('LiteralTransformer', () => {
                     let obfuscatedCode: string;
 
                     before(() => {
-                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option.js');
+                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
 
                         obfuscatedCode = JavaScriptObfuscator.obfuscate(
                             code,
@@ -402,7 +402,7 @@ describe('LiteralTransformer', () => {
                     let obfuscatedCode: string;
 
                     before(() => {
-                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option.js');
+                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
 
                         obfuscatedCode = JavaScriptObfuscator.obfuscate(
                             code,
@@ -432,7 +432,7 @@ describe('LiteralTransformer', () => {
                 let obfuscatedCode: string;
 
                 before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option.js');
+                    const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
 
                     obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
@@ -452,6 +452,28 @@ describe('LiteralTransformer', () => {
                     assert.match(obfuscatedCode, stringLiteralRegExp2);
                 });
             });
+
+            describe('Variant #4: correct escape of special characters', () => {
+                const stringLiteralRegExp: RegExp = /var baz *= *'Cannot\\x20find\\x20module\\x20\\x27' *\+ *foo *\+ *'\\x27';/;
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-2.js');
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            reservedStrings: ['a']
+                        }
+                    ).getObfuscatedCode();
+                });
+
+                it('match #1: should ignore reserved strings', () => {
+                    assert.match(obfuscatedCode, stringLiteralRegExp);
+                });
+            });
         });
     });
 

test/functional-tests/node-transformers/obfuscating-transformers/literal-transformer/fixtures/reserved-strings-option-2.js

@@ -0,0 +1,2 @@
+var foo = 'bar';
+var baz = 'Cannot find module \'' + foo + '\'';