From 11c7739af7665394ff4386b11d98d6b19de82cb5 Mon Sep 17 00:00:00 2001 From: kachalov Date: Fri, 13 May 2016 17:47:20 +0300 Subject: [PATCH] Added node interfaces --- src/NodeUtils.js | 15 +++++ src/NodeUtils.ts | 48 +++++++++++++++ .../nodes/IArrowFunctionExpressionNode.js | 1 + src/interfaces/nodes/ILiteralNode.js | 1 + src/interfaces/nodes/ILiteralNode.ts | 7 +++ src/interfaces/nodes/IMemberExpressionNode.js | 1 + src/interfaces/nodes/IMemberExpressionNode.ts | 9 +++ src/interfaces/nodes/IMethodDefinitionNode.js | 1 + src/interfaces/nodes/IMethodDefinitionNode.ts | 12 ++++ src/interfaces/nodes/IObjectExpressionNode.js | 1 + src/interfaces/nodes/IObjectExpressionNode.ts | 6 ++ src/interfaces/nodes/IPropertyNode.js | 1 + src/interfaces/nodes/IPropertyNode.ts | 12 ++++ .../nodes/IVariableDeclarationNode.js | 1 + .../nodes/IVariableDeclarationNode.ts | 7 +++ .../nodes/IVariableDeclaratorNode.js | 1 + .../nodes/IVariableDeclaratorNode.ts | 7 +++ src/node-obfuscators/LiteralObfuscator.js | 3 +- src/node-obfuscators/LiteralObfuscator.ts | 10 +++- .../MemberExpressionObfuscator.js | 40 +++++++------ .../MemberExpressionObfuscator.ts | 59 +++++++++++-------- .../MethodDefinitionObfuscator.js | 14 ++--- .../MethodDefinitionObfuscator.ts | 27 ++++----- src/node-obfuscators/NodeObfuscator.js | 7 ++- src/node-obfuscators/NodeObfuscator.ts | 12 ++-- .../ObjectExpressionObfuscator.js | 32 +++++----- .../ObjectExpressionObfuscator.ts | 51 +++++++++------- .../VariableDeclarationObfuscator.js | 25 ++++---- .../VariableDeclarationObfuscator.ts | 46 +++++++++------ 29 files changed, 312 insertions(+), 145 deletions(-) create mode 100644 src/interfaces/nodes/IArrowFunctionExpressionNode.js create mode 100644 src/interfaces/nodes/ILiteralNode.js create mode 100644 src/interfaces/nodes/ILiteralNode.ts create mode 100644 src/interfaces/nodes/IMemberExpressionNode.js create mode 100644 src/interfaces/nodes/IMemberExpressionNode.ts create mode 100644 src/interfaces/nodes/IMethodDefinitionNode.js create mode 100644 src/interfaces/nodes/IMethodDefinitionNode.ts create mode 100644 src/interfaces/nodes/IObjectExpressionNode.js create mode 100644 src/interfaces/nodes/IObjectExpressionNode.ts create mode 100644 src/interfaces/nodes/IPropertyNode.js create mode 100644 src/interfaces/nodes/IPropertyNode.ts create mode 100644 src/interfaces/nodes/IVariableDeclarationNode.js create mode 100644 src/interfaces/nodes/IVariableDeclarationNode.ts create mode 100644 src/interfaces/nodes/IVariableDeclaratorNode.js create mode 100644 src/interfaces/nodes/IVariableDeclaratorNode.ts diff --git a/src/NodeUtils.js b/src/NodeUtils.js index c6907456..18625af5 100644 --- a/src/NodeUtils.js +++ b/src/NodeUtils.js @@ -33,8 +33,23 @@ class NodeUtils { } return node.parentNode; } + static isBlockStatementNode(node) { + return node.type === 'BlockStatement'; + } static isIdentifierNode(node) { return node.type === 'Identifier'; } + static isLiteralNode(node) { + return node.type === 'Literal'; + } + static isMemberExpressionNode(node) { + return node.type === 'MemberExpression'; + } + static isPropertyNode(node) { + return node.type === 'Property'; + } + static isVariableDeclaratorNode(node) { + return node.type === 'VariableDeclarator'; + } } exports.NodeUtils = NodeUtils; diff --git a/src/NodeUtils.ts b/src/NodeUtils.ts index d51e7c1a..0e0f8cb4 100644 --- a/src/NodeUtils.ts +++ b/src/NodeUtils.ts @@ -1,5 +1,10 @@ +import { IBlockStatementNode } from "./interfaces/nodes/IBlockStatementNode"; import { IIdentifierNode } from "./interfaces/nodes/IIdentifierNode"; +import { ILiteralNode } from "./interfaces/nodes/ILiteralNode"; +import { IMemberExpressionNode } from "./interfaces/nodes/IMemberExpressionNode"; +import { IPropertyNode } from "./interfaces/nodes/IPropertyNode"; import { ITreeNode } from './interfaces/nodes/ITreeNode'; +import { IVariableDeclaratorNode } from "./interfaces/nodes/IVariableDeclaratorNode"; export class NodeUtils { /** @@ -62,6 +67,14 @@ export class NodeUtils { return node.parentNode; } + /** + * @param node + * @returns {boolean} + */ + public static isBlockStatementNode (node: ITreeNode): node is IBlockStatementNode { + return node.type === 'BlockStatement'; + } + /** * @param node * @returns {boolean} @@ -69,4 +82,39 @@ export class NodeUtils { public static isIdentifierNode (node: ITreeNode): node is IIdentifierNode { return node.type === 'Identifier'; } + + /** + * @param node + * @returns {boolean} + */ + public static isLiteralNode (node: ITreeNode): node is ILiteralNode { + return node.type === 'Literal'; + } + + /** + * @param node + * @returns {boolean} + */ + public static isMemberExpressionNode (node: ITreeNode): node is IMemberExpressionNode { + return node.type === 'MemberExpression'; + } + + + /** + * + * @param node + * @returns {boolean} + */ + public static isPropertyNode (node: ITreeNode): node is IPropertyNode { + return node.type === 'Property'; + } + + /** + * + * @param node + * @returns {boolean} + */ + public static isVariableDeclaratorNode (node: ITreeNode): node is IVariableDeclaratorNode { + return node.type === 'VariableDeclarator'; + } } diff --git a/src/interfaces/nodes/IArrowFunctionExpressionNode.js b/src/interfaces/nodes/IArrowFunctionExpressionNode.js new file mode 100644 index 00000000..3918c74e --- /dev/null +++ b/src/interfaces/nodes/IArrowFunctionExpressionNode.js @@ -0,0 +1 @@ +"use strict"; diff --git a/src/interfaces/nodes/ILiteralNode.js b/src/interfaces/nodes/ILiteralNode.js new file mode 100644 index 00000000..3918c74e --- /dev/null +++ b/src/interfaces/nodes/ILiteralNode.js @@ -0,0 +1 @@ +"use strict"; diff --git a/src/interfaces/nodes/ILiteralNode.ts b/src/interfaces/nodes/ILiteralNode.ts new file mode 100644 index 00000000..0da89adf --- /dev/null +++ b/src/interfaces/nodes/ILiteralNode.ts @@ -0,0 +1,7 @@ +import { ITreeNode } from "./ITreeNode"; + +export interface ILiteralNode extends ITreeNode { + value: boolean|number|string; + raw: string; + 'x-verbatim-property': any; +} \ No newline at end of file diff --git a/src/interfaces/nodes/IMemberExpressionNode.js b/src/interfaces/nodes/IMemberExpressionNode.js new file mode 100644 index 00000000..3918c74e --- /dev/null +++ b/src/interfaces/nodes/IMemberExpressionNode.js @@ -0,0 +1 @@ +"use strict"; diff --git a/src/interfaces/nodes/IMemberExpressionNode.ts b/src/interfaces/nodes/IMemberExpressionNode.ts new file mode 100644 index 00000000..c0365be1 --- /dev/null +++ b/src/interfaces/nodes/IMemberExpressionNode.ts @@ -0,0 +1,9 @@ +import { IIdentifierNode } from "./IIdentifierNode"; +import { ILiteralNode } from "./ILiteralNode"; +import { ITreeNode } from "./ITreeNode"; + +export interface IMemberExpressionNode extends ITreeNode { + computed: boolean; + object: IIdentifierNode; + property: IIdentifierNode|ILiteralNode; +} \ No newline at end of file diff --git a/src/interfaces/nodes/IMethodDefinitionNode.js b/src/interfaces/nodes/IMethodDefinitionNode.js new file mode 100644 index 00000000..3918c74e --- /dev/null +++ b/src/interfaces/nodes/IMethodDefinitionNode.js @@ -0,0 +1 @@ +"use strict"; diff --git a/src/interfaces/nodes/IMethodDefinitionNode.ts b/src/interfaces/nodes/IMethodDefinitionNode.ts new file mode 100644 index 00000000..4598d2bc --- /dev/null +++ b/src/interfaces/nodes/IMethodDefinitionNode.ts @@ -0,0 +1,12 @@ +import { IFunctionExpressionNode } from "./IFunctionExpressionNode"; +import { IIdentifierNode } from "./IIdentifierNode"; +import { ILiteralNode } from "./ILiteralNode"; +import { ITreeNode } from "./ITreeNode"; + +export interface IMethodDefinitionNode extends ITreeNode { + key: IIdentifierNode|ILiteralNode; + computed: boolean; + value: IFunctionExpressionNode; + kind: string; + static: boolean; +} \ No newline at end of file diff --git a/src/interfaces/nodes/IObjectExpressionNode.js b/src/interfaces/nodes/IObjectExpressionNode.js new file mode 100644 index 00000000..3918c74e --- /dev/null +++ b/src/interfaces/nodes/IObjectExpressionNode.js @@ -0,0 +1 @@ +"use strict"; diff --git a/src/interfaces/nodes/IObjectExpressionNode.ts b/src/interfaces/nodes/IObjectExpressionNode.ts new file mode 100644 index 00000000..393f206d --- /dev/null +++ b/src/interfaces/nodes/IObjectExpressionNode.ts @@ -0,0 +1,6 @@ +import { IPropertyNode } from "./IPropertyNode"; +import { ITreeNode } from "./ITreeNode"; + +export interface IObjectExpressionNode extends ITreeNode { + properties: IPropertyNode[]; +} \ No newline at end of file diff --git a/src/interfaces/nodes/IPropertyNode.js b/src/interfaces/nodes/IPropertyNode.js new file mode 100644 index 00000000..3918c74e --- /dev/null +++ b/src/interfaces/nodes/IPropertyNode.js @@ -0,0 +1 @@ +"use strict"; diff --git a/src/interfaces/nodes/IPropertyNode.ts b/src/interfaces/nodes/IPropertyNode.ts new file mode 100644 index 00000000..1ab5914f --- /dev/null +++ b/src/interfaces/nodes/IPropertyNode.ts @@ -0,0 +1,12 @@ +import { IIdentifierNode } from "./IIdentifierNode"; +import { ILiteralNode } from "./ILiteralNode"; +import { ITreeNode } from "./ITreeNode"; + +export interface IPropertyNode extends ITreeNode { + key: IIdentifierNode|ILiteralNode; + computed: boolean; + value: IIdentifierNode|ILiteralNode; + kind: string; + method: boolean; + shorthand: boolean; +} \ No newline at end of file diff --git a/src/interfaces/nodes/IVariableDeclarationNode.js b/src/interfaces/nodes/IVariableDeclarationNode.js new file mode 100644 index 00000000..3918c74e --- /dev/null +++ b/src/interfaces/nodes/IVariableDeclarationNode.js @@ -0,0 +1 @@ +"use strict"; diff --git a/src/interfaces/nodes/IVariableDeclarationNode.ts b/src/interfaces/nodes/IVariableDeclarationNode.ts new file mode 100644 index 00000000..71b29a01 --- /dev/null +++ b/src/interfaces/nodes/IVariableDeclarationNode.ts @@ -0,0 +1,7 @@ +import { ITreeNode } from "./ITreeNode"; +import { IVariableDeclaratorNode } from "./IVariableDeclaratorNode"; + +export interface IVariableDeclarationNode extends ITreeNode { + declarations: IVariableDeclaratorNode[]; + kind: string; +} \ No newline at end of file diff --git a/src/interfaces/nodes/IVariableDeclaratorNode.js b/src/interfaces/nodes/IVariableDeclaratorNode.js new file mode 100644 index 00000000..3918c74e --- /dev/null +++ b/src/interfaces/nodes/IVariableDeclaratorNode.js @@ -0,0 +1 @@ +"use strict"; diff --git a/src/interfaces/nodes/IVariableDeclaratorNode.ts b/src/interfaces/nodes/IVariableDeclaratorNode.ts new file mode 100644 index 00000000..6f4768af --- /dev/null +++ b/src/interfaces/nodes/IVariableDeclaratorNode.ts @@ -0,0 +1,7 @@ +import { IIdentifierNode } from "./IIdentifierNode"; +import { ITreeNode } from "./ITreeNode"; + +export interface IVariableDeclaratorNode extends ITreeNode { + id: IIdentifierNode; + init: any; +} \ No newline at end of file diff --git a/src/node-obfuscators/LiteralObfuscator.js b/src/node-obfuscators/LiteralObfuscator.js index 0c5e6e75..7df1bb75 100644 --- a/src/node-obfuscators/LiteralObfuscator.js +++ b/src/node-obfuscators/LiteralObfuscator.js @@ -1,9 +1,10 @@ "use strict"; const escodegen = require('escodegen'); const NodeObfuscator_1 = require('./NodeObfuscator'); +const NodeUtils_1 = require("../NodeUtils"); class LiteralObfuscator extends NodeObfuscator_1.NodeObfuscator { obfuscateNode(literalNode, parentNode) { - if (parentNode.type === 'Property' && parentNode.key === literalNode) { + if (NodeUtils_1.NodeUtils.isPropertyNode(parentNode) && parentNode.key) { return; } switch (typeof literalNode.value) { diff --git a/src/node-obfuscators/LiteralObfuscator.ts b/src/node-obfuscators/LiteralObfuscator.ts index 238ba433..c13c6429 100644 --- a/src/node-obfuscators/LiteralObfuscator.ts +++ b/src/node-obfuscators/LiteralObfuscator.ts @@ -1,14 +1,18 @@ import * as escodegen from 'escodegen'; +import { ILiteralNode } from "../interfaces/nodes/ILiteralNode"; + +import { ITreeNode } from "../interfaces/nodes/ITreeNode"; import { NodeObfuscator } from './NodeObfuscator'; +import { NodeUtils } from "../NodeUtils"; export class LiteralObfuscator extends NodeObfuscator { /** * @param literalNode * @param parentNode */ - public obfuscateNode (literalNode: any, parentNode: any): void { - if (parentNode.type === 'Property' && parentNode.key === literalNode) { + public obfuscateNode (literalNode: ILiteralNode, parentNode: ITreeNode): void { + if (NodeUtils.isPropertyNode(parentNode) && parentNode.key) { return; } @@ -19,7 +23,7 @@ export class LiteralObfuscator extends NodeObfuscator { } literalNode['x-verbatim-property'] = { - content : this.replaceLiteralStringByArrayElement(literalNode.value), + content : this.replaceLiteralStringByArrayElement(literalNode.value), precedence: escodegen.Precedence.Primary }; diff --git a/src/node-obfuscators/MemberExpressionObfuscator.js b/src/node-obfuscators/MemberExpressionObfuscator.js index 2eec264a..1c421a4e 100644 --- a/src/node-obfuscators/MemberExpressionObfuscator.js +++ b/src/node-obfuscators/MemberExpressionObfuscator.js @@ -2,35 +2,37 @@ const escodegen = require('escodegen'); const estraverse = require('estraverse'); const NodeObfuscator_1 = require('./NodeObfuscator'); +const NodeUtils_1 = require("../NodeUtils"); class MemberExpressionObfuscator extends NodeObfuscator_1.NodeObfuscator { obfuscateNode(memberExpressionNode) { estraverse.replace(memberExpressionNode.property, { leave: (node, parentNode) => { - switch (node.type) { - case 'Literal': - this.literalNodeController(node); - break; - case 'Identifier': - if (memberExpressionNode.computed) { - break; - } - memberExpressionNode.computed = true; - this.identifierNodeController(node); - break; + if (NodeUtils_1.NodeUtils.isLiteralNode(node)) { + this.literalNodeController(node); + return; + } + if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) { + if (memberExpressionNode.computed) { + return; + } + memberExpressionNode.computed = true; + this.identifierNodeController(node); } } }); } identifierNodeController(node) { - let nodeValue = node['name']; - node['type'] = 'Literal'; - node['value'] = nodeValue; - node['raw'] = `'${nodeValue}'`; - node['x-verbatim-property'] = { - content: this.replaceLiteralStringByArrayElement(nodeValue), - precedence: escodegen.Precedence.Primary + let nodeValue = node.name, literalNode = { + type: 'Literal', + value: nodeValue, + raw: `'${nodeValue}'`, + 'x-verbatim-property': { + content: this.replaceLiteralStringByArrayElement(nodeValue), + precedence: escodegen.Precedence.Primary + } }; - delete node['name']; + delete node.name; + Object.assign(node, literalNode); } literalNodeController(node) { switch (typeof node.value) { diff --git a/src/node-obfuscators/MemberExpressionObfuscator.ts b/src/node-obfuscators/MemberExpressionObfuscator.ts index 1672563b..ab1fc145 100644 --- a/src/node-obfuscators/MemberExpressionObfuscator.ts +++ b/src/node-obfuscators/MemberExpressionObfuscator.ts @@ -1,30 +1,34 @@ import * as escodegen from 'escodegen'; import * as estraverse from 'estraverse'; +import { IIdentifierNode } from "../interfaces/nodes/IIdentifierNode"; +import { ILiteralNode } from "../interfaces/nodes/ILiteralNode"; +import { IMemberExpressionNode } from "../interfaces/nodes/IMemberExpressionNode"; +import { ITreeNode } from "../interfaces/nodes/ITreeNode"; + import { NodeObfuscator } from './NodeObfuscator' +import { NodeUtils } from "../NodeUtils"; export class MemberExpressionObfuscator extends NodeObfuscator { /** * @param memberExpressionNode */ - public obfuscateNode (memberExpressionNode: any): void { + public obfuscateNode (memberExpressionNode: IMemberExpressionNode): void { estraverse.replace(memberExpressionNode.property, { - leave: (node, parentNode) => { - switch (node.type) { - case 'Literal': - this.literalNodeController(node); + leave: (node: ITreeNode, parentNode: ITreeNode) => { + if (NodeUtils.isLiteralNode(node)) { + this.literalNodeController(node); - break; + return; + } - case 'Identifier': - if (memberExpressionNode.computed) { - break; - } + if (NodeUtils.isIdentifierNode(node)) { + if (memberExpressionNode.computed) { + return; + } - memberExpressionNode.computed = true; - this.identifierNodeController(node); - - break; + memberExpressionNode.computed = true; + this.identifierNodeController(node); } } }); @@ -42,18 +46,21 @@ export class MemberExpressionObfuscator extends NodeObfuscator { * * @param node */ - private identifierNodeController (node: any): void { - let nodeValue: string = node['name']; + private identifierNodeController (node: IIdentifierNode): void { + let nodeValue: string = node.name, + literalNode: ILiteralNode = { + type: 'Literal', + value: nodeValue, + raw: `'${nodeValue}'`, + 'x-verbatim-property': { + content : this.replaceLiteralStringByArrayElement(nodeValue), + precedence: escodegen.Precedence.Primary + } + }; - node['type'] = 'Literal'; - node['value'] = nodeValue; - node['raw'] = `'${nodeValue}'`; - node['x-verbatim-property'] = { - content : this.replaceLiteralStringByArrayElement(nodeValue), - precedence: escodegen.Precedence.Primary - }; + delete node.name; - delete node['name']; + Object.assign(node, literalNode); } /** @@ -65,7 +72,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator { * * @param node */ - private literalNodeController (node: any): void { + private literalNodeController (node: ILiteralNode): void { switch (typeof node.value) { case 'string': if (node['x-verbatim-property']) { @@ -73,7 +80,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator { } node['x-verbatim-property'] = { - content : this.replaceLiteralStringByArrayElement(node.value), + content : this.replaceLiteralStringByArrayElement(node.value), precedence: escodegen.Precedence.Primary }; diff --git a/src/node-obfuscators/MethodDefinitionObfuscator.js b/src/node-obfuscators/MethodDefinitionObfuscator.js index cf938ddc..1f0523fb 100644 --- a/src/node-obfuscators/MethodDefinitionObfuscator.js +++ b/src/node-obfuscators/MethodDefinitionObfuscator.js @@ -1,10 +1,10 @@ "use strict"; const estraverse = require('estraverse'); const NodeObfuscator_1 = require('./NodeObfuscator'); +const NodeUtils_1 = require("../NodeUtils"); class MethodDefinitionObfuscator extends NodeObfuscator_1.NodeObfuscator { constructor(...args) { super(...args); - this.methodName = new Map(); this.ignoredNames = ['constructor']; } obfuscateNode(methodDefinitionNode, parentNode) { @@ -13,13 +13,13 @@ class MethodDefinitionObfuscator extends NodeObfuscator_1.NodeObfuscator { replaceMethodName(methodDefinitionNode) { estraverse.replace(methodDefinitionNode.key, { leave: (node) => { - if (node.type !== 'Identifier' || - this.ignoredNames.indexOf(node.name) >= 0 || - methodDefinitionNode.computed === true) { - return estraverse.VisitorOption.Skip; + if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && + this.ignoredNames.indexOf(node.name) < 0 && + methodDefinitionNode.computed === false) { + methodDefinitionNode.computed = true; + node.name = this.replaceLiteralStringByArrayElement(node.name); } - methodDefinitionNode.computed = true; - node.name = this.replaceLiteralStringByArrayElement(node.name); + return estraverse.VisitorOption.Skip; } }); } diff --git a/src/node-obfuscators/MethodDefinitionObfuscator.ts b/src/node-obfuscators/MethodDefinitionObfuscator.ts index 787cfe7d..d1d9cc7b 100644 --- a/src/node-obfuscators/MethodDefinitionObfuscator.ts +++ b/src/node-obfuscators/MethodDefinitionObfuscator.ts @@ -1,6 +1,10 @@ import * as estraverse from 'estraverse'; +import { IMethodDefinitionNode } from "../interfaces/nodes/IMethodDefinitionNode"; +import { ITreeNode } from "../interfaces/nodes/ITreeNode"; + import { NodeObfuscator } from './NodeObfuscator'; +import { NodeUtils } from "../NodeUtils"; /** * replaces: @@ -12,11 +16,6 @@ import { NodeObfuscator } from './NodeObfuscator'; * _0x12d45f(); */ export class MethodDefinitionObfuscator extends NodeObfuscator { - /** - * @type {Map} - */ - private methodName: Map = new Map (); - /** * @type {string[]} */ @@ -26,26 +25,26 @@ export class MethodDefinitionObfuscator extends NodeObfuscator { * @param methodDefinitionNode * @param parentNode */ - public obfuscateNode (methodDefinitionNode: any, parentNode: any): void { + public obfuscateNode (methodDefinitionNode: IMethodDefinitionNode, parentNode: ITreeNode): void { this.replaceMethodName(methodDefinitionNode); } /** * @param methodDefinitionNode */ - private replaceMethodName (methodDefinitionNode: any): void { + private replaceMethodName (methodDefinitionNode: IMethodDefinitionNode): void { estraverse.replace(methodDefinitionNode.key, { - leave: (node) => { + leave: (node: ITreeNode) => { if ( - node.type !== 'Identifier' || - this.ignoredNames.indexOf(node.name) >= 0 || - methodDefinitionNode.computed === true + NodeUtils.isIdentifierNode(node) && + this.ignoredNames.indexOf(node.name) < 0 && + methodDefinitionNode.computed === false ) { - return estraverse.VisitorOption.Skip; + methodDefinitionNode.computed = true; + node.name = this.replaceLiteralStringByArrayElement(node.name); } - methodDefinitionNode.computed = true; - node.name = this.replaceLiteralStringByArrayElement(node.name); + return estraverse.VisitorOption.Skip; } }); } diff --git a/src/node-obfuscators/NodeObfuscator.js b/src/node-obfuscators/NodeObfuscator.js index fdb5b8cc..0f586170 100644 --- a/src/node-obfuscators/NodeObfuscator.js +++ b/src/node-obfuscators/NodeObfuscator.js @@ -1,13 +1,14 @@ "use strict"; +const NodeUtils_1 = require("../NodeUtils"); const Utils_1 = require('../Utils'); class NodeObfuscator { constructor(nodes) { this.nodes = nodes; } replaceNodeIdentifierByNewValue(node, parentNode, namesMap) { - if (node.type === 'Identifier' && namesMap.has(node.name)) { - if ((parentNode.type === 'Property' && parentNode.key === node) || - (parentNode.type === 'MemberExpression' && parentNode.computed === false && parentNode.property === node)) { + if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && namesMap.has(node.name)) { + if ((NodeUtils_1.NodeUtils.isPropertyNode(parentNode) && parentNode.key === node) || + (NodeUtils_1.NodeUtils.isMemberExpressionNode(parentNode) && parentNode.computed === false && parentNode.property === node)) { return; } node.name = namesMap.get(node.name); diff --git a/src/node-obfuscators/NodeObfuscator.ts b/src/node-obfuscators/NodeObfuscator.ts index 2d0723d2..03f95f99 100644 --- a/src/node-obfuscators/NodeObfuscator.ts +++ b/src/node-obfuscators/NodeObfuscator.ts @@ -1,6 +1,8 @@ import { INode } from '../interfaces/INode'; import { INodeObfuscator } from '../interfaces/INodeObfuscator'; +import { ITreeNode } from "../interfaces/nodes/ITreeNode"; +import { NodeUtils } from "../NodeUtils"; import { Utils } from '../Utils'; export abstract class NodeObfuscator implements INodeObfuscator { @@ -20,18 +22,18 @@ export abstract class NodeObfuscator implements INodeObfuscator { * @param node * @param parentNode */ - public abstract obfuscateNode (node: any, parentNode?: any): void; + public abstract obfuscateNode (node: ITreeNode, parentNode?: ITreeNode): void; /** * @param node * @param parentNode * @param namesMap */ - protected replaceNodeIdentifierByNewValue (node: any, parentNode: any, namesMap: Map ) { - if (node.type === 'Identifier' && namesMap.has(node.name)) { + protected replaceNodeIdentifierByNewValue (node: ITreeNode, parentNode: ITreeNode, namesMap: Map ) { + if (NodeUtils.isIdentifierNode(node) && namesMap.has(node.name)) { if ( - (parentNode.type === 'Property' && parentNode.key === node) || - (parentNode.type === 'MemberExpression' && parentNode.computed === false && parentNode.property === node) + (NodeUtils.isPropertyNode(parentNode) && parentNode.key === node) || + (NodeUtils.isMemberExpressionNode(parentNode) && parentNode.computed === false && parentNode.property === node ) ) { return; } diff --git a/src/node-obfuscators/ObjectExpressionObfuscator.js b/src/node-obfuscators/ObjectExpressionObfuscator.js index 9713c081..9aa2bdda 100644 --- a/src/node-obfuscators/ObjectExpressionObfuscator.js +++ b/src/node-obfuscators/ObjectExpressionObfuscator.js @@ -2,19 +2,19 @@ const escodegen = require('escodegen'); const estraverse = require('estraverse'); const NodeObfuscator_1 = require('./NodeObfuscator'); +const NodeUtils_1 = require("../NodeUtils"); const Utils_1 = require('../Utils'); class ObjectExpressionObfuscator extends NodeObfuscator_1.NodeObfuscator { obfuscateNode(objectExpressionNode) { objectExpressionNode.properties.forEach((property) => { estraverse.replace(property.key, { leave: (node, parentNode) => { - switch (node.type) { - case 'Literal': - this.literalNodeController(node); - break; - case 'Identifier': - this.identifierNodeController(node); - break; + if (NodeUtils_1.NodeUtils.isLiteralNode(node)) { + this.literalNodeController(node); + return; + } + if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) { + this.identifierNodeController(node); } } }); @@ -34,15 +34,17 @@ class ObjectExpressionObfuscator extends NodeObfuscator_1.NodeObfuscator { } } identifierNodeController(node) { - let nodeValue = node['name']; - node['type'] = 'Literal'; - node['value'] = nodeValue; - node['raw'] = `'${nodeValue}'`; - node['x-verbatim-property'] = { - content: Utils_1.Utils.stringToUnicode(nodeValue), - precedence: escodegen['Precedence']['Primary'] + let nodeValue = node.name, literalNode = { + type: 'Literal', + value: nodeValue, + raw: `'${nodeValue}'`, + 'x-verbatim-property': { + content: Utils_1.Utils.stringToUnicode(nodeValue), + precedence: escodegen.Precedence.Primary + } }; - delete node['name']; + delete node.name; + Object.assign(node, literalNode); } } exports.ObjectExpressionObfuscator = ObjectExpressionObfuscator; diff --git a/src/node-obfuscators/ObjectExpressionObfuscator.ts b/src/node-obfuscators/ObjectExpressionObfuscator.ts index 60f4c951..bb260545 100644 --- a/src/node-obfuscators/ObjectExpressionObfuscator.ts +++ b/src/node-obfuscators/ObjectExpressionObfuscator.ts @@ -1,7 +1,13 @@ import * as escodegen from 'escodegen'; import * as estraverse from 'estraverse'; +import { IIdentifierNode } from "../interfaces/nodes/IIdentifierNode"; +import { ILiteralNode } from "../interfaces/nodes/ILiteralNode"; +import { IObjectExpressionNode } from "../interfaces/nodes/IObjectExpressionNode"; +import { ITreeNode } from "../interfaces/nodes/ITreeNode"; + import { NodeObfuscator } from './NodeObfuscator' +import { NodeUtils } from "../NodeUtils"; import { Utils } from '../Utils'; /** @@ -18,20 +24,18 @@ export class ObjectExpressionObfuscator extends NodeObfuscator { /** * @param objectExpressionNode */ - public obfuscateNode (objectExpressionNode: any): void { + public obfuscateNode (objectExpressionNode: IObjectExpressionNode): void { objectExpressionNode.properties.forEach((property) => { estraverse.replace(property.key, { - leave: (node, parentNode) => { - switch (node.type) { - case 'Literal': - this.literalNodeController(node); + leave: (node: ITreeNode, parentNode: ITreeNode) => { + if (NodeUtils.isLiteralNode(node)) { + this.literalNodeController(node); - break; + return; + } - case 'Identifier': - this.identifierNodeController(node); - - break; + if (NodeUtils.isIdentifierNode(node)) { + this.identifierNodeController(node); } } }); @@ -41,7 +45,7 @@ export class ObjectExpressionObfuscator extends NodeObfuscator { /** * @param node */ - private literalNodeController (node: any): void { + private literalNodeController (node: ILiteralNode): void { switch (typeof node.value) { case 'string': if (node['x-verbatim-property']) { @@ -49,7 +53,7 @@ export class ObjectExpressionObfuscator extends NodeObfuscator { } node['x-verbatim-property'] = { - content : Utils.stringToUnicode(node.value), + content : Utils.stringToUnicode(node.value), precedence: escodegen.Precedence.Primary }; @@ -60,17 +64,20 @@ export class ObjectExpressionObfuscator extends NodeObfuscator { /** * @param node */ - private identifierNodeController (node: any): void { - let nodeValue: string = node['name']; + private identifierNodeController (node: IIdentifierNode): void { + let nodeValue: string = node.name, + literalNode: ILiteralNode = { + type: 'Literal', + value: nodeValue, + raw: `'${nodeValue}'`, + 'x-verbatim-property': { + content : Utils.stringToUnicode(nodeValue), + precedence: escodegen.Precedence.Primary + } + }; - node['type'] = 'Literal'; - node['value'] = nodeValue; - node['raw'] = `'${nodeValue}'`; - node['x-verbatim-property'] = { - content : Utils.stringToUnicode(nodeValue), - precedence: escodegen['Precedence']['Primary'] - }; + delete node.name; - delete node['name']; + Object.assign(node, literalNode); } } \ No newline at end of file diff --git a/src/node-obfuscators/VariableDeclarationObfuscator.js b/src/node-obfuscators/VariableDeclarationObfuscator.js index 7c73e28b..256b67ac 100644 --- a/src/node-obfuscators/VariableDeclarationObfuscator.js +++ b/src/node-obfuscators/VariableDeclarationObfuscator.js @@ -19,15 +19,16 @@ class VariableDeclarationObfuscator extends NodeObfuscator_1.NodeObfuscator { variableDeclarationNode.declarations.forEach((declarationNode) => { estraverse.replace(declarationNode, { enter: (node) => { - if (node.type !== 'VariableDeclarator') { - return estraverse.VisitorOption.Skip; + if (NodeUtils_1.NodeUtils.isVariableDeclaratorNode(node)) { + estraverse.replace(node.id, { + enter: (node) => { + this.variableNames.set(node.name, Utils_1.Utils.getRandomVariableName()); + node.name = this.variableNames.get(node.name); + } + }); + return; } - estraverse.replace(node.id, { - enter: (node) => { - this.variableNames.set(node.name, Utils_1.Utils.getRandomVariableName()); - node.name = this.variableNames.get(node.name); - } - }); + return estraverse.VisitorOption.Skip; } }); }); @@ -47,9 +48,11 @@ class VariableDeclarationObfuscator extends NodeObfuscator_1.NodeObfuscator { node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') { functionParentScope = NodeUtils_1.NodeUtils.getNodeScope(node); - functionIndex = functionParentScope.body.indexOf(node); - if (functionIndex >= 0) { - functionNextNode = functionParentScope.body[functionIndex + 1]; + if (NodeUtils_1.NodeUtils.isBlockStatementNode(functionParentScope)) { + functionIndex = functionParentScope.body.indexOf(node); + if (functionIndex >= 0) { + functionNextNode = functionParentScope.body[functionIndex + 1]; + } } isNodeAfterVariableDeclaratorFlag = true; } diff --git a/src/node-obfuscators/VariableDeclarationObfuscator.ts b/src/node-obfuscators/VariableDeclarationObfuscator.ts index 55f792cb..2c77c0fa 100644 --- a/src/node-obfuscators/VariableDeclarationObfuscator.ts +++ b/src/node-obfuscators/VariableDeclarationObfuscator.ts @@ -1,5 +1,9 @@ import * as estraverse from 'estraverse'; +import { IIdentifierNode } from "../interfaces/nodes/IIdentifierNode"; +import { ITreeNode } from "../interfaces/nodes/ITreeNode"; +import { IVariableDeclarationNode } from "../interfaces/nodes/IVariableDeclarationNode"; + import { NodeObfuscator } from './NodeObfuscator'; import { NodeUtils } from "../NodeUtils"; import { Utils } from '../Utils'; @@ -24,7 +28,7 @@ export class VariableDeclarationObfuscator extends NodeObfuscator { * @param variableDeclarationNode * @param parentNode */ - public obfuscateNode (variableDeclarationNode: any, parentNode: any): void { + public obfuscateNode (variableDeclarationNode: IVariableDeclarationNode, parentNode: ITreeNode): void { if (parentNode.type === 'Program') { return; } @@ -36,20 +40,22 @@ export class VariableDeclarationObfuscator extends NodeObfuscator { /** * @param variableDeclarationNode */ - private replaceVariableName (variableDeclarationNode: any): void { + private replaceVariableName (variableDeclarationNode: IVariableDeclarationNode): void { variableDeclarationNode.declarations.forEach((declarationNode) => { estraverse.replace(declarationNode, { - enter: (node) => { - if (node.type !== 'VariableDeclarator') { - return estraverse.VisitorOption.Skip; + enter: (node: ITreeNode) => { + if (NodeUtils.isVariableDeclaratorNode(node)) { + estraverse.replace(node.id, { + enter: (node: IIdentifierNode) => { + this.variableNames.set(node.name, Utils.getRandomVariableName()); + node.name = this.variableNames.get(node.name); + } + }); + + return; } - estraverse.replace(node.id, { - enter: (node) => { - this.variableNames.set(node.name, Utils.getRandomVariableName()); - node.name = this.variableNames.get(node.name); - } - }); + return estraverse.VisitorOption.Skip; } }); }); @@ -59,8 +65,8 @@ export class VariableDeclarationObfuscator extends NodeObfuscator { * @param variableDeclarationNode * @param variableParentNode */ - private replaceVariableCalls (variableDeclarationNode: any, variableParentNode: any): void { - let scopeNode: any; + private replaceVariableCalls (variableDeclarationNode: IVariableDeclarationNode, variableParentNode: ITreeNode): void { + let scopeNode: ITreeNode; if (variableDeclarationNode.kind === 'var') { scopeNode = NodeUtils.getNodeScope( @@ -72,12 +78,12 @@ export class VariableDeclarationObfuscator extends NodeObfuscator { let isNodeAfterVariableDeclaratorFlag: boolean = false, isNodeBeforeVariableDeclaratorFlag: boolean = true, - functionParentScope: any, - functionNextNode: any, + functionParentScope: ITreeNode, + functionNextNode: ITreeNode, functionIndex: number = -1; estraverse.replace(scopeNode, { - enter: (node, parentNode) => { + enter: (node: ITreeNode, parentNode: ITreeNode) => { if ( node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || @@ -87,10 +93,12 @@ export class VariableDeclarationObfuscator extends NodeObfuscator { node ); - functionIndex = functionParentScope.body.indexOf(node); + if (NodeUtils.isBlockStatementNode(functionParentScope)) { + functionIndex = functionParentScope.body.indexOf(node); - if (functionIndex >= 0) { - functionNextNode = functionParentScope.body[functionIndex + 1]; + if (functionIndex >= 0) { + functionNextNode = functionParentScope.body[functionIndex + 1]; + } } isNodeAfterVariableDeclaratorFlag = true;