Merge pull request #698 from javascript-obfuscator/tagged-template-literal-obfuscation

Added `TaggedTemplateLiteral` obfuscation

CHANGELOG.md

@@ -3,6 +3,7 @@ Change Log
 v1.10.0
 ---
 * **Feature:** Optional chaining support!
+* Added `TaggedTemplateLiteral` obfuscation. https://github.com/javascript-obfuscator/javascript-obfuscator/issues/696
 * Improved `disableConsoleOutput` template. https://github.com/javascript-obfuscator/javascript-obfuscator/issues/691
 
 v1.9.0

src/enums/node/NodeType.ts

@@ -43,6 +43,7 @@ export enum NodeType {
     SwitchCase = 'SwitchCase',
     SwitchStatement = 'SwitchStatement',
     TaggedTemplateExpression = 'TaggedTemplateExpression',
+    TemplateElement = 'TemplateElement',
     TemplateLiteral = 'TemplateLiteral',
     ThrowStatement = 'ThrowStatement',
     TryStatement = 'TryStatement',

src/node-transformers/converting-transformers/TemplateLiteralTransformer.ts

@@ -39,15 +39,6 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
         return !!node && NodeGuards.isLiteralNode(node) && typeof node.value === 'string';
     }
 
-    /**
-     * @param {Node} node
-     * @param {Node | null} parentNode
-     * @returns {boolean}
-     */
-    private static isValidTemplateLiteralNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.TemplateLiteral {
-        return NodeGuards.isTemplateLiteralNode(node) && !NodeGuards.isTaggedTemplateExpressionNode(parentNode);
-    }
-
     /**
      * @param {NodeTransformationStage} nodeTransformationStage
      * @returns {IVisitor | null}
@@ -57,7 +48,7 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
             case NodeTransformationStage.Converting:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && TemplateLiteralTransformer.isValidTemplateLiteralNode(node, parentNode)) {
+                        if (parentNode && NodeGuards.isTemplateLiteralNode(node)) {
                             return this.transformNode(node, parentNode);
                         }
                     }
@@ -69,11 +60,51 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {TemplateLiteral} templateLiteralNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
+     * @param {ESTree.TemplateLiteral} templateLiteralNode
+     * @param {ESTree.Node} parentNode
+     * @returns {ESTree.Node}
      */
     public transformNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
+        if (NodeGuards.isTaggedTemplateExpressionNode(parentNode)) {
+            return this.transformTaggedTemplateLiteralNodeNode(templateLiteralNode, parentNode);
+        } else {
+            return this.transformTemplateLiteralNodeNode(templateLiteralNode, parentNode);
+        }
+    }
+
+    /**
+     * @param {ESTree.TemplateLiteral} templateLiteralNode
+     * @param {ESTree.Node} parentNode
+     * @returns {ESTree.Node}
+     */
+    private transformTaggedTemplateLiteralNodeNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
+        return NodeFactory.templateLiteral(
+            [this.transformTemplateLiteralNodeNode(templateLiteralNode, parentNode)],
+            [
+                NodeFactory.templateElement(
+                    {
+                        raw: '',
+                        cooked: ''
+                    },
+                    false
+                ),
+                NodeFactory.templateElement(
+                    {
+                        raw: '',
+                        cooked: ''
+                    },
+                    true
+                )
+            ]
+        );
+    }
+
+    /**
+     * @param {ESTree.TemplateLiteral} templateLiteralNode
+     * @param {ESTree.Node} parentNode
+     * @returns {ESTree.Expression}
+     */
+    private transformTemplateLiteralNodeNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Expression {
         const templateLiteralExpressions: ESTree.Expression[] = templateLiteralNode.expressions;
 
         let nodes: ESTree.Expression[] = [];

src/node/NodeFactory.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import * as escodegen from 'escodegen';
 import * as ESTree from 'estree';
 
@@ -448,6 +449,40 @@ export class NodeFactory {
         };
     }
 
+    /**
+     * @param {ESTree.TemplateElement["value"]} value
+     * @param {boolean} tail
+     * @returns {ESTree.TemplateElement}
+     */
+    public static templateElement (
+        value: ESTree.TemplateElement['value'],
+        tail: boolean
+    ): ESTree.TemplateElement {
+        return {
+            type: NodeType.TemplateElement,
+            value,
+            tail,
+            metadata: { ignoredNode: false }
+        };
+    }
+
+    /**
+     * @param {ESTree.Expression[]} expressions
+     * @param {ESTree.TemplateElement[]} quasis
+     * @returns {ESTree.TemplateLiteral}
+     */
+    public static templateLiteral (
+        expressions: ESTree.Expression[],
+        quasis: ESTree.TemplateElement[]
+    ): ESTree.TemplateLiteral {
+        return {
+            type: NodeType.TemplateLiteral,
+            expressions,
+            quasis,
+            metadata: { ignoredNode: false }
+        };
+    }
+
     /**
      * @param {VariableDeclarator[]} declarations
      * @param {string} kind

test/dev/dev.ts

@@ -17,9 +17,7 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
-            compact: false,
-            stringArray: true,
-            stringArrayThreshold: 1
+            compact: false
         }
     ).getObfuscatedCode();
 

test/functional-tests/node-transformers/converting-transformers/template-literal-transformer/TemplateLiteralTransformer.spec.ts

@@ -149,7 +149,7 @@ describe('TemplateLiteralTransformer', () => {
     });
 
     describe('Variant #6: tagged template literal', () => {
-        it('shouldn\'t transform es6 tagged template literal to es5', () => {
+        it('shouldn transform es6 tagged template literal to es5', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/tagged-template-literal.js');
 
             obfuscatedCode = JavaScriptObfuscator.obfuscate(
@@ -162,7 +162,7 @@ describe('TemplateLiteralTransformer', () => {
 
             assert.match(
                 obfuscatedCode,
-                /tag`foo *\${0x1 *\+ *0x1} *bar`;/
+                /tag`\${'foo\\x20' *\+ *\(0x1 *\+ *0x1\) *\+ *'\\x20bar'}`;/
             );
         });
     });