javascript-obfuscator · ghost · Dec 2, 2019 · Dec 2, 2019
diff --git a/dist/index.browser.js b/dist/index.browser.js
diff --git a/dist/index.cli.js b/dist/index.cli.js
diff --git a/dist/index.js b/dist/index.js
diff --git a/src/node-transformers/obfuscating-transformers/LiteralTransformer.ts b/src/node-transformers/obfuscating-transformers/LiteralTransformer.ts
@@ -16,6 +16,7 @@ import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
 import { NodeMetadata } from '../../node/NodeMetadata';
 import { NodeUtils } from '../../node/NodeUtils';
+import { StringLiteralObfuscatingReplacer } from './obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer';

 @injectable()
 export class LiteralTransformer extends AbstractNodeTransformer {
@@ -88,9 +89,15 @@ export class LiteralTransformer extends AbstractNodeTransformer {
                break;

            case 'string':
-                newLiteralNode = this.literalObfuscatingReplacerFactory(
+                const replacer: StringLiteralObfuscatingReplacer = <StringLiteralObfuscatingReplacer> this.literalObfuscatingReplacerFactory(
                    LiteralObfuscatingReplacer.StringLiteralObfuscatingReplacer
-                ).replace(literalNode.value);
+                );
+
+                if (replacer.isReservedString(literalNode.value)) {
+                    return literalNode;
+                }
+
+                newLiteralNode = replacer.replace(literalNode.value);

                break;


diff --git a/...s/obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer.ts b/...s/obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer.ts
@@ -128,6 +128,21 @@ export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
        return rc4KeyLiteralNode;
    }

+    /**
+     * @param {string} value
+     * @returns {boolean}
+     */
+    public isReservedString (value: string): boolean {
+        if (!this.options.reservedStrings.length) {
+            return false;
+        }
+
+        return this.options.reservedStrings
+            .some((reservedString: string) => {
+                return new RegExp(reservedString, 'g').exec(value) !== null;
+            });
+    }
+
    /**
     * @param {string} nodeValue
     * @returns {Node}
@@ -277,19 +292,4 @@ export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
            callExpressionArgs
        );
    }
-
-    /**
-     * @param {string} value
-     * @returns {boolean}
-     */
-    private isReservedString (value: string): boolean {
-        if (!this.options.reservedStrings.length) {
-            return false;
-        }
-
-        return this.options.reservedStrings
-            .some((reservedString: string) => {
-                return new RegExp(reservedString, 'g').exec(value) !== null;
-            });
-    }
 }
diff --git a/...node-transformers/obfuscating-transformers/literal-transformer/LiteralTransformer.spec.ts b/...node-transformers/obfuscating-transformers/literal-transformer/LiteralTransformer.spec.ts
@@ -395,6 +395,30 @@ describe('LiteralTransformer', () => {
                    });
                });

+                describe('Variant #1: single reserved string value', () => {
+                    const stringLiteralRegExp: RegExp = /const foo *= *'foo baz';/;
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-3.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                stringArray: true,
+                                stringArrayThreshold: 1,
+                                reservedStrings: ['foo baz']
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('match #2: should not touch reserved strings', () => {
+                      assert.match(obfuscatedCode, stringLiteralRegExp);
+                    });
+                });
+
                describe('Variant #2: two reserved string values', () => {
                    const stringLiteralRegExp1: RegExp = /const foo *= *'foo';/;
                    const stringLiteralRegExp2: RegExp = /const bar *= *'bar';/;
@@ -454,7 +478,7 @@ describe('LiteralTransformer', () => {
            });

            describe('Variant #4: correct escape of special characters', () => {
-                const stringLiteralRegExp: RegExp = /var baz *= *'Cannot\\x20find\\x20module\\x20\\x27' *\+ *foo *\+ *'\\x27';/;
+                const stringLiteralRegExp: RegExp = /var baz *= *'Cannot *find *module *\\'' *\+ *foo *\+ *'\\x27';/;

                let obfuscatedCode: string;

@@ -471,7 +495,7 @@ describe('LiteralTransformer', () => {
                });

                it('match #1: should ignore reserved strings', () => {
-                    assert.match(obfuscatedCode, stringLiteralRegExp);
+                    assert.match(obfuscatedCode, stringLiteralRegExp, obfuscatedCode);
                });
            });
        });

diff --git a/...ormers/obfuscating-transformers/literal-transformer/fixtures/reserved-strings-option-3.js b/...ormers/obfuscating-transformers/literal-transformer/fixtures/reserved-strings-option-3.js
@@ -0,0 +1 @@
+const foo = 'foo baz';