admin/javascript-obfuscator-javascript-obfuscator
1
0
Fork 0
mirror of https://github.com/javascript-obfuscator/javascript-obfuscator synced 2026-08-09 12:42:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added new types and interfaces for Nodes, tests fixes

Browse Source
This commit is contained in:
sanex3339
2016-07-04 13:47:22 +03:00
parent c6b943dfe5
commit ab7bbd2b9e
16 changed files with 229 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/NodeUtils.spec.ts
+60 -62
View File
@@ -1,8 +1,7 @@
import { IBlockStatementNode } from "../src/interfaces/nodes/IBlockStatementNode";
import { IExpressionStatementNode } from "../src/interfaces/nodes/IExpressionStatementNode";
import { IFunctionDeclarationNode } from "../src/interfaces/nodes/IFunctionDeclarationNode";
import { IIdentifierNode } from "../src/interfaces/nodes/IIdentifierNode";
import { IIfStatementNode } from "../src/interfaces/nodes/IIfStatementNode";
import { ILiteralNode } from "../src/interfaces/nodes/ILiteralNode";
import { INode } from "../src/interfaces/nodes/INode";
import { IProgramNode } from "../src/interfaces/nodes/IProgramNode";
@@ -33,17 +32,17 @@ describe('NodeUtils', () => {
describe('appendNode (blockScopeBody: INode[], node: INode): void', () => {
let blockStatementNode: IBlockStatementNode,
expectedBlockStatementNode: IBlockStatementNode,
identifierNode: IIdentifierNode;
expressionStatementNode: IExpressionStatementNode;
beforeEach(() => {
identifierNode = NodeMocks.getIdentifierNode();
expressionStatementNode = NodeMocks.getExpressionStatementNode();
blockStatementNode = NodeMocks.getBlockStatementNode();
expectedBlockStatementNode = Object.assign({}, blockStatementNode);
expectedBlockStatementNode.body.push(identifierNode);
expectedBlockStatementNode.body.push(expressionStatementNode);
NodeUtils.appendNode(blockStatementNode.body, identifierNode);
NodeUtils.appendNode(blockStatementNode.body, expressionStatementNode);
});
it('should append given node to a `BlockStatement` node body', () => {
@@ -67,23 +66,22 @@ describe('NodeUtils', () => {
describe('getBlockStatementNodeByIndex (node: INode, index: number = 0): INode', () => {
let blockStatementNode: IBlockStatementNode,
identifierNode: IIdentifierNode,
literalNode: ILiteralNode;
expressionStatementNode1: IExpressionStatementNode,
expressionStatementNode2: IExpressionStatementNode;
beforeEach(() => {
identifierNode = NodeMocks.getIdentifierNode();
literalNode = NodeMocks.getLiteralNode();
expressionStatementNode1 = NodeMocks.getExpressionStatementNode();
expressionStatementNode2 = NodeMocks.getExpressionStatementNode();
blockStatementNode = NodeMocks.getBlockStatementNode([
identifierNode,
literalNode
expressionStatementNode1,
expressionStatementNode2
]);
});
it('should return block-statement child node of given node if that node has block-statement', () => {
assert.deepEqual(NodeUtils.getBlockStatementNodeByIndex(blockStatementNode), identifierNode);
assert.deepEqual(NodeUtils.getBlockStatementNodeByIndex(blockStatementNode, 1), literalNode);
assert.deepEqual(NodeUtils.getBlockStatementNodeByIndex(blockStatementNode), expressionStatementNode1);
assert.deepEqual(NodeUtils.getBlockStatementNodeByIndex(blockStatementNode, 1), expressionStatementNode2);
});
it('should throw a `ReferenceError` if index is out of boundaries', () => {
@@ -91,7 +89,7 @@ describe('NodeUtils', () => {
});
it('should throw a `TypeError` if node have no a block-statement', () => {
assert.throws(() => NodeUtils.getBlockStatementNodeByIndex(identifierNode, 1), TypeError);
assert.throws(() => NodeUtils.getBlockStatementNodeByIndex(expressionStatementNode1, 1), TypeError);
});
});
@@ -101,21 +99,20 @@ describe('NodeUtils', () => {
ifStatementBlockStatementNode2: IBlockStatementNode,
ifStatementNode1: IIfStatementNode,
ifStatementNode2: IIfStatementNode,
identifierNode: IIdentifierNode,
expressionStatementNode1: IExpressionStatementNode,
expressionStatementNode2: IExpressionStatementNode,
expressionStatementNode3: IExpressionStatementNode,
functionDeclarationNode: IFunctionDeclarationNode,
literalNode1: ILiteralNode,
literalNode2: ILiteralNode,
programNode: IProgramNode;
beforeEach(() => {
identifierNode = NodeMocks.getIdentifierNode();
literalNode1 = NodeMocks.getLiteralNode();
literalNode2 = NodeMocks.getLiteralNode();
expressionStatementNode1 = NodeMocks.getExpressionStatementNode();
expressionStatementNode2 = NodeMocks.getExpressionStatementNode();
expressionStatementNode3 = NodeMocks.getExpressionStatementNode();
ifStatementBlockStatementNode2 = NodeMocks.getBlockStatementNode([
literalNode1,
literalNode2
expressionStatementNode1,
expressionStatementNode2
]);
ifStatementNode2 = NodeMocks.getIfStatementNode(ifStatementBlockStatementNode2);
@@ -127,7 +124,7 @@ describe('NodeUtils', () => {
ifStatementNode1 = NodeMocks.getIfStatementNode(ifStatementBlockStatementNode1);
functionDeclarationBlockStatementNode = NodeMocks.getBlockStatementNode([
identifierNode,
expressionStatementNode3,
ifStatementNode1
]);
@@ -140,47 +137,46 @@ describe('NodeUtils', () => {
programNode['parentNode'] = programNode;
functionDeclarationNode['parentNode'] = programNode;
functionDeclarationBlockStatementNode['parentNode'] = functionDeclarationNode;
identifierNode['parentNode'] = functionDeclarationBlockStatementNode;
expressionStatementNode3['parentNode'] = functionDeclarationBlockStatementNode;
ifStatementNode1['parentNode'] = functionDeclarationBlockStatementNode;
ifStatementBlockStatementNode1['parentNode'] = ifStatementNode1;
ifStatementNode2['parentNode'] = ifStatementBlockStatementNode1;
ifStatementBlockStatementNode2['parentNode'] = ifStatementNode2;
literalNode1['parentNode'] = ifStatementBlockStatementNode2;
expressionStatementNode1['parentNode'] = ifStatementBlockStatementNode2;
});
it('should return block-scope node for given node', () => {
assert.deepEqual(NodeUtils.getBlockScopeOfNode(identifierNode), functionDeclarationBlockStatementNode);
assert.deepEqual(NodeUtils.getBlockScopeOfNode(identifierNode, 1), programNode);
assert.deepEqual(NodeUtils.getBlockScopeOfNode(expressionStatementNode3), functionDeclarationBlockStatementNode);
assert.deepEqual(NodeUtils.getBlockScopeOfNode(expressionStatementNode3, 1), programNode);
assert.deepEqual(NodeUtils.getBlockScopeOfNode(functionDeclarationNode), programNode);
assert.deepEqual(NodeUtils.getBlockScopeOfNode(functionDeclarationBlockStatementNode), programNode);
assert.deepEqual(NodeUtils.getBlockScopeOfNode(programNode), programNode);
assert.deepEqual(NodeUtils.getBlockScopeOfNode(literalNode1), functionDeclarationBlockStatementNode);
assert.deepEqual(NodeUtils.getBlockScopeOfNode(expressionStatementNode1), functionDeclarationBlockStatementNode);
});
it('should throw a `ReferenceError` if node has no `parentNode` property', () => {
assert.throws(() => NodeUtils.getBlockScopeOfNode(literalNode2), ReferenceError);
assert.throws(() => NodeUtils.getBlockScopeOfNode(expressionStatementNode2), ReferenceError);
});
});
describe('insertNodeAtIndex (blockScopeBody: INode[], node: INode, index: number): void', () => {
let blockStatementNode: IBlockStatementNode,
expectedBlockStatementNode: IBlockStatementNode,
identifierNode: IIdentifierNode,
literalNode: ILiteralNode;
expressionStatementNode1: IExpressionStatementNode,
expressionStatementNode2: IExpressionStatementNode;
beforeEach(() => {
identifierNode = NodeMocks.getIdentifierNode();
literalNode = NodeMocks.getLiteralNode();
expressionStatementNode1 = NodeMocks.getExpressionStatementNode();
expressionStatementNode2 = NodeMocks.getExpressionStatementNode();
blockStatementNode = NodeMocks.getBlockStatementNode([
identifierNode
expressionStatementNode1
]);
expectedBlockStatementNode = Object.assign({}, blockStatementNode);
expectedBlockStatementNode['body'].push(literalNode);
expectedBlockStatementNode['body'].push(expressionStatementNode2);
NodeUtils.insertNodeAtIndex(blockStatementNode.body, literalNode, 1);
NodeUtils.insertNodeAtIndex(blockStatementNode.body, expressionStatementNode2, 1);
});
it('should insert given node in `BlockStatement` node body at index', () => {
@@ -203,54 +199,56 @@ describe('NodeUtils', () => {
});
describe('parentize (node: INode): void', () => {
let blockStatementNode: IBlockStatementNode,
identifierNode: IIdentifierNode,
literalNode: ILiteralNode,
let ifStatementNode: IIfStatementNode,
ifStatementBlockStatementNode: IBlockStatementNode,
expressionStatementNode1: IExpressionStatementNode,
expressionStatementNode2: IExpressionStatementNode,
programNode: IProgramNode;
beforeEach(() => {
identifierNode = NodeMocks.getIdentifierNode();
expressionStatementNode1 = NodeMocks.getExpressionStatementNode();
expressionStatementNode2 = NodeMocks.getExpressionStatementNode();
literalNode = NodeMocks.getLiteralNode();
blockStatementNode = NodeMocks.getBlockStatementNode([
identifierNode,
literalNode
ifStatementBlockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode1,
expressionStatementNode2
]);
ifStatementNode = NodeMocks.getIfStatementNode(ifStatementBlockStatementNode);
programNode = NodeMocks.getProgramNode([
blockStatementNode
ifStatementNode
]);
NodeUtils.parentize(blockStatementNode);
NodeUtils.parentize(ifStatementNode);
});
it('should parentize given AST-tree', () => {
assert.deepEqual(blockStatementNode['parentNode'], programNode);
assert.deepEqual(identifierNode['parentNode'], blockStatementNode);
assert.deepEqual(literalNode['parentNode'], blockStatementNode);
assert.deepEqual(ifStatementNode['parentNode'], programNode);
assert.deepEqual(ifStatementBlockStatementNode['parentNode'], ifStatementNode);
assert.deepEqual(expressionStatementNode1['parentNode'], ifStatementBlockStatementNode);
assert.deepEqual(expressionStatementNode2['parentNode'], ifStatementBlockStatementNode);
});
});
describe('prependNode (blockScopeBody: INode[], node: INode): void', () => {
let blockStatementNode: IBlockStatementNode,
expectedBlockStatementNode: IBlockStatementNode,
identifierNode: IIdentifierNode,
literalNode: ILiteralNode;
expressionStatementNode1: IExpressionStatementNode,
expressionStatementNode2: IExpressionStatementNode;
beforeEach(() => {
identifierNode = NodeMocks.getIdentifierNode();
literalNode = NodeMocks.getLiteralNode();
expressionStatementNode1 = NodeMocks.getExpressionStatementNode();
expressionStatementNode2 = NodeMocks.getExpressionStatementNode();
blockStatementNode = NodeMocks.getBlockStatementNode([
identifierNode
expressionStatementNode1
]);
expectedBlockStatementNode = Object.assign({}, blockStatementNode);
expectedBlockStatementNode['body'].unshift(literalNode);
expectedBlockStatementNode['body'].unshift(expressionStatementNode2);
NodeUtils.prependNode(blockStatementNode.body, literalNode);
NodeUtils.prependNode(blockStatementNode.body, expressionStatementNode2);
});
it('should prepend given node to a `BlockStatement` node body', () => {
test/mocks/NodeMocks.ts
+17 -5
View File
@@ -1,10 +1,12 @@
import { TStatement } from "../../src/types/TStatement";
import { IBlockStatementNode } from "../../src/interfaces/nodes/IBlockStatementNode";
import { ICatchClauseNode } from "../../src/interfaces/nodes/ICatchClauseNode";
import { IExpressionStatementNode } from "../../src/interfaces/nodes/IExpressionStatementNode";
import { IFunctionDeclarationNode } from "../../src/interfaces/nodes/IFunctionDeclarationNode";
import { IIdentifierNode } from "../../src/interfaces/nodes/IIdentifierNode";
import { IIfStatementNode } from "../../src/interfaces/nodes/IIfStatementNode";
import { ILiteralNode } from "../../src/interfaces/nodes/ILiteralNode";
import { INode } from "../../src/interfaces/nodes/INode";
import { IProgramNode } from "../../src/interfaces/nodes/IProgramNode";
import { NodeType } from "../../src/enums/NodeType";
@@ -14,7 +16,7 @@ export class NodeMocks {
* @param bodyNodes
* @returns {IProgramNode}
*/
public static getProgramNode (bodyNodes: INode[] = []): IProgramNode {
public static getProgramNode (bodyNodes: TStatement[] = []): IProgramNode {
return {
type: NodeType.Program,
body: bodyNodes
@@ -25,7 +27,7 @@ export class NodeMocks {
* @param bodyNodes
* @returns {IBlockStatementNode}
*/
public static getBlockStatementNode (bodyNodes: INode[] = []): IBlockStatementNode {
public static getBlockStatementNode (bodyNodes: TStatement[] = []): IBlockStatementNode {
return {
type: NodeType.BlockStatement,
body: bodyNodes
@@ -36,7 +38,7 @@ export class NodeMocks {
* @param bodyNodes
* @returns {ICatchClauseNode}
*/
public static getCatchClauseNode (bodyNodes: INode[] = []): ICatchClauseNode {
public static getCatchClauseNode (bodyNodes: TStatement[] = []): ICatchClauseNode {
return {
type: NodeType.CatchClause,
param: NodeMocks.getIdentifierNode('err'),
@@ -44,6 +46,16 @@ export class NodeMocks {
};
}
/**
* @returns {IExpressionStatementNode}
*/
public static getExpressionStatementNode (): IExpressionStatementNode {
return {
type: NodeType.ExpressionStatement,
expression: NodeMocks.getIdentifierNode()
};
}
/**
* @param functionName
* @param blockStatementNode
@@ -99,4 +111,4 @@ export class NodeMocks {
'x-verbatim-property': `'string'`
};
}
}
}
test/node-obfuscators/CatchClauseObfuscator.spec.ts
+27 -25
View File
@@ -1,6 +1,6 @@
import { ICatchClauseNode } from "../../src/interfaces/nodes/ICatchClauseNode";
import { ICustomNode } from "../../src/interfaces/ICustomNode";
import { INode } from "../../src/interfaces/nodes/INode";
import { IExpressionStatementNode } from "../../src/interfaces/nodes/IExpressionStatementNode";
import { DEFAULT_PRESET } from "../../src/preset-options/DefaultPreset";
@@ -18,36 +18,38 @@ describe('CatchClauseObfuscator', () => {
catchClauseNode: ICatchClauseNode;
beforeEach(() => {
let expressionStatementNode: IExpressionStatementNode = {
type: NodeType.ExpressionStatement,
expression: {
type: NodeType.CallExpression,
callee: {
type: NodeType.MemberExpression,
computed: false,
object: {
type: NodeType.Identifier,
name: 'console'
},
property: {
type: NodeType.Identifier,
name: 'log'
}
},
arguments: [
{
type: NodeType.Identifier,
'name': 'err'
}
]
}
};
catchClauseObfuscator = new CatchClauseObfuscator(
new Map<string, ICustomNode>(),
new Options(DEFAULT_PRESET)
);
catchClauseNode = NodeMocks.getCatchClauseNode([
<INode>{
type: NodeType.ExpressionStatement,
expression: {
type: NodeType.CallExpression,
callee: {
type: NodeType.MemberExpression,
computed: false,
object: {
type: NodeType.Identifier,
name: 'console'
},
property: {
type: NodeType.Identifier,
name: 'log'
}
},
arguments: [
{
type: NodeType.Identifier,
'name': 'err'
}
]
}
}
expressionStatementNode
]);
catchClauseObfuscator.obfuscateNode(catchClauseNode);
test/node-obfuscators/FunctionDeclarationObfuscator.spec.ts
+3 -3
View File
@@ -1,7 +1,7 @@
import { IBlockStatementNode } from "../../src/interfaces/nodes/IBlockStatementNode";
import { ICustomNode } from "../../src/interfaces/ICustomNode";
import { IExpressionStatementNode } from "../../src/interfaces/nodes/IExpressionStatementNode";
import { IFunctionDeclarationNode } from "../../src/interfaces/nodes/IFunctionDeclarationNode";
import { INode } from "../../src/interfaces/nodes/INode";
import { IProgramNode } from "../../src/interfaces/nodes/IProgramNode";
import { NodeType } from "../../src/enums/NodeType";
@@ -16,14 +16,14 @@ const assert: Chai.AssertStatic = require('chai').assert;
describe('FunctionDeclarationObfuscator', () => {
describe('obfuscateNode (functionDeclarationNode: IFunctionDeclarationNode, parentNode: INode): void', () => {
let expressionStatementNode: INode,
let expressionStatementNode: IExpressionStatementNode,
functionDeclarationObfuscator: FunctionDeclarationObfuscator,
functionDeclarationNode: IFunctionDeclarationNode,
functionName: string = 'functionDeclaration',
programNode: IProgramNode;
beforeEach(() => {
expressionStatementNode = <INode>{
expressionStatementNode = {
type: NodeType.ExpressionStatement,
expression: {
type: NodeType.CallExpression,