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

ArrayStorage refactoring

Browse Source
This commit is contained in:
sanex3339
2017-01-17 02:03:39 +03:00
parent 1df16519e2
commit a18e5445d9
22 changed files with 969 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dist/index.js
Vendored
+628 -437
View File
File diff suppressed because it is too large Load Diff
package.json
+1
View File
@@ -30,6 +30,7 @@
"estraverse": "4.2.0",
"inversify": "3.0.0",
"lodash": "4.17.4",
"merge-estraverse-visitors": "^1.0.0",
"mkdirp": "0.5.1",
"reflect-metadata": "0.1.9",
"source-map-support": "0.4.9",
src/Obfuscator.ts
+107 -54
View File
@@ -5,21 +5,17 @@ import * as estraverse from 'estraverse';
import * as ESTree from 'estree';
import { TNodeTransformersFactory } from './types/container/TNodeTransformersFactory';
import { TVisitorDirection } from './types/TVisitorDirection';
import { ICustomNodeGroup } from './interfaces/custom-nodes/ICustomNodeGroup';
import { IObfuscationEventEmitter } from './interfaces/event-emitters/IObfuscationEventEmitter';
import { IObfuscator } from './interfaces/IObfuscator';
import { IOptions } from './interfaces/options/IOptions';
import { INodeTransformer } from './interfaces/node-transformers/INodeTransformer';
import { IStackTraceAnalyzer } from './interfaces/stack-trace-analyzer/IStackTraceAnalyzer';
import { IStackTraceData } from './interfaces/stack-trace-analyzer/IStackTraceData';
import { IStorage } from './interfaces/storages/IStorage';
import { NodeTransformers } from './enums/container/NodeTransformers';
import { NodeType } from './enums/NodeType';
import { ObfuscationEvents } from './enums/ObfuscationEvents';
import { VisitorDirection } from './enums/VisitorDirection';
import { Node } from './node/Node';
import { NodeUtils } from './node/NodeUtils';
@@ -27,40 +23,47 @@ import { NodeUtils } from './node/NodeUtils';
@injectable()
export class Obfuscator implements IObfuscator {
/**
* @type {Map<string, NodeTransformers[]>}
* @type {NodeTransformers[]}
*/
private static readonly controlFlowTransformersMap: Map <string, NodeTransformers[]> = new Map([
[NodeType.BlockStatement, [NodeTransformers.BlockStatementControlFlowTransformer]],
[NodeType.FunctionDeclaration, [NodeTransformers.FunctionControlFlowTransformer]],
[NodeType.FunctionExpression, [NodeTransformers.FunctionControlFlowTransformer]]
]);
private static readonly controlFlowTransformersList: NodeTransformers[] = [
NodeTransformers.BlockStatementControlFlowTransformer,
NodeTransformers.FunctionControlFlowTransformer,
NodeTransformers.FunctionControlFlowTransformer
];
/**
* @type {Map<string, NodeTransformers[]>}
* @type {NodeTransformers[]}
*/
private static readonly convertingTransformersMap: Map <string, NodeTransformers[]> = new Map([
[NodeType.MemberExpression, [NodeTransformers.MemberExpressionTransformer]],
[NodeType.MethodDefinition, [NodeTransformers.MethodDefinitionTransformer]],
[NodeType.TemplateLiteral, [NodeTransformers.TemplateLiteralTransformer]],
]);
private static readonly convertingTransformersList: NodeTransformers[] = [
NodeTransformers.MemberExpressionTransformer,
NodeTransformers.MethodDefinitionTransformer,
NodeTransformers.TemplateLiteralTransformer
];
/**
* @type {Map<string, NodeTransformers[]>}
* @type {NodeTransformers[]}
*/
private static readonly obfuscatingTransformersMap: Map <string, NodeTransformers[]> = new Map([
[NodeType.ArrowFunctionExpression, [NodeTransformers.FunctionTransformer]],
[NodeType.ClassDeclaration, [NodeTransformers.FunctionDeclarationTransformer]],
[NodeType.CatchClause, [NodeTransformers.CatchClauseTransformer]],
[NodeType.FunctionDeclaration, [
NodeTransformers.FunctionDeclarationTransformer,
NodeTransformers.FunctionTransformer
]],
[NodeType.FunctionExpression, [NodeTransformers.FunctionTransformer]],
[NodeType.ObjectExpression, [NodeTransformers.ObjectExpressionTransformer]],
[NodeType.VariableDeclaration, [NodeTransformers.VariableDeclarationTransformer]],
[NodeType.LabeledStatement, [NodeTransformers.LabeledStatementTransformer]],
[NodeType.Literal, [NodeTransformers.LiteralTransformer]]
]);
private static readonly obfuscatingTransformersList: NodeTransformers[] = [
NodeTransformers.FunctionTransformer,
NodeTransformers.FunctionDeclarationTransformer,
NodeTransformers.CatchClauseTransformer,
NodeTransformers.FunctionDeclarationTransformer,
NodeTransformers.FunctionTransformer,
NodeTransformers.FunctionTransformer,
NodeTransformers.ObjectExpressionTransformer,
NodeTransformers.VariableDeclarationTransformer,
NodeTransformers.LiteralTransformer
];
/**
* @type {Map<string, estraverse.Visitor[]>}
*/
private readonly cachedEnterVisitors: Map<string, estraverse.Visitor[]> = new Map();
/**
* @type {Map<string, estraverse.Visitor[]>}
*/
private readonly cachedLeaveVisitors: Map<string, estraverse.Visitor[]> = new Map();
/**
* @type {IStorage<ICustomNodeGroup>}
@@ -139,22 +142,20 @@ export class Obfuscator implements IObfuscator {
if (this.options.controlFlowFlattening) {
astTree = this.transformAstTree(
astTree,
VisitorDirection.leave,
this.nodeTransformersFactory(Obfuscator.controlFlowTransformersMap)
Obfuscator.controlFlowTransformersList
);
}
// second pass: nodes obfuscation
console.time();
astTree = this.transformAstTree(
astTree,
VisitorDirection.enter,
this.nodeTransformersFactory(
new Map([
...Obfuscator.convertingTransformersMap,
...Obfuscator.obfuscatingTransformersMap
])
)
[
...Obfuscator.convertingTransformersList,
...Obfuscator.obfuscatingTransformersList
]
);
console.timeEnd();
this.obfuscationEventEmitter.emit(ObfuscationEvents.AfterObfuscation, astTree, stackTraceData);
@@ -163,26 +164,78 @@ export class Obfuscator implements IObfuscator {
/**
* @param astTree
* @param direction
* @param nodeTransformersConcreteFactory
* @param nodeTransformers
*/
private transformAstTree (
astTree: ESTree.Program,
direction: TVisitorDirection,
nodeTransformersConcreteFactory: (nodeType: string) => INodeTransformer[]
nodeTransformers: NodeTransformers[]
): ESTree.Program {
estraverse.replace(astTree, {
[direction]: (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node => {
const nodeTransformers: INodeTransformer[] = nodeTransformersConcreteFactory(node.type);
const mergedVisitors: estraverse.Visitor = this.mergeTransformerVisitors(
nodeTransformers.map((nodeTransformer: NodeTransformers): estraverse.Visitor => {
return this.nodeTransformersFactory(nodeTransformer).getVisitor();
})
);
nodeTransformers.forEach((nodeTransformer: INodeTransformer) => {
node = nodeTransformer.transformNode(node, parentNode);
});
return node;
}
});
estraverse.replace(astTree, mergedVisitors);
return astTree;
}
/**
* @param visitors
* @return {estraverse.Visitor}
*/
private mergeTransformerVisitors (visitors: estraverse.Visitor[]): estraverse.Visitor {
const enterVisitors: any[] = visitors.filter((visitor: estraverse.Visitor) => {
return visitor.enter !== undefined;
}).map((visitor: estraverse.Visitor) => {
return visitor.enter;
});
const leaveVisitors: any[] = visitors.filter((visitor: estraverse.Visitor) => {
return visitor.leave !== undefined;
}).map((visitor: estraverse.Visitor) => {
return visitor.leave;
});
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
let nodeVisitors: estraverse.Visitor[];
let saveToCache: boolean = true;
if (this.cachedEnterVisitors.has(node.type)) {
nodeVisitors = <estraverse.Visitor[]>this.cachedEnterVisitors.get(node.type);
saveToCache = false;
} else {
nodeVisitors = enterVisitors;
}
nodeVisitors.forEach((visitor: any) => {
visitor.call(this, node, parentNode);
});
if (saveToCache) {
this.cachedEnterVisitors.set(node.type, nodeVisitors);
}
},
leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
let nodeVisitors: estraverse.Visitor[];
let saveToCache: boolean = true;
if (this.cachedLeaveVisitors.has(node.type)) {
nodeVisitors = <estraverse.Visitor[]>this.cachedLeaveVisitors.get(node.type);
saveToCache = false;
} else {
nodeVisitors = leaveVisitors;
}
nodeVisitors.forEach((visitor: any) => {
visitor.call(this, node, parentNode);
});
if (saveToCache) {
this.cachedLeaveVisitors.set(node.type, nodeVisitors);
}
}
};
}
}
src/container/modules/node-transformers/NodeTransformersModule.ts
+13 -20
View File
@@ -72,31 +72,24 @@ export const nodeTransformersModule: interfaces.ContainerModule = new ContainerM
.whenTargetNamed(NodeTransformers.VariableDeclarationTransformer);
// node transformers factory
bind<INodeTransformer[]>(ServiceIdentifiers.Factory__INodeTransformer)
.toFactory<INodeTransformer[]>((context: interfaces.Context) => {
bind<INodeTransformer>(ServiceIdentifiers.Factory__INodeTransformer)
.toFactory<INodeTransformer>((context: interfaces.Context) => {
const cache: Map <NodeTransformers, INodeTransformer> = new Map();
return (nodeTransformersMap: Map<string, NodeTransformers[]>) => (nodeType: string) => {
const nodeTransformers: NodeTransformers[] = nodeTransformersMap.get(nodeType) || [];
const instancesArray: INodeTransformer[] = [];
return (nodeTransformerName: NodeTransformers) => {
if (cache.has(nodeTransformerName)) {
return <INodeTransformer>cache.get(nodeTransformerName);
}
nodeTransformers.forEach((transformer: NodeTransformers) => {
let nodeTransformer: INodeTransformer;
const nodeTransformer: INodeTransformer = context.container
.getNamed<INodeTransformer>(
ServiceIdentifiers.INodeTransformer,
nodeTransformerName
);
if (cache.has(transformer)) {
nodeTransformer = <INodeTransformer>cache.get(transformer);
} else {
nodeTransformer = context.container.getNamed<INodeTransformer>(
ServiceIdentifiers.INodeTransformer,
transformer
);
cache.set(transformer, nodeTransformer);
}
cache.set(nodeTransformerName, nodeTransformer);
instancesArray.push(nodeTransformer);
});
return instancesArray;
return nodeTransformer;
};
});
});
src/enums/VisitorDirection.ts
-6
View File
@@ -1,6 +0,0 @@
import { Utils } from '../utils/Utils';
export const VisitorDirection: any = Utils.strEnumify({
enter: 'enter',
leave: 'leave'
});
src/interfaces/node-transformers/INodeTransformer.d.ts
Vendored
+3 -5
View File
@@ -1,10 +1,8 @@
import * as ESTree from 'estree';
import * as estraverse from 'estraverse';
export interface INodeTransformer {
/**
* @param node
* @param parentNode
* @returns {ESTree.Node}
* @returns {estraverse.Visitor}
*/
transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node;
getVisitor (): estraverse.Visitor;
}
src/node-transformers/AbstractNodeTransformer.ts
+3 -5
View File
@@ -1,7 +1,7 @@
import { injectable, inject } from 'inversify';
import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
import * as ESTree from 'estree';
import * as estraverse from 'estraverse';
import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
import { IOptions } from '../interfaces/options/IOptions';
@@ -30,9 +30,7 @@ export abstract class AbstractNodeTransformer implements INodeTransformer {
}
/**
* @param node
* @param parentNode
* @returns {ESTree.Node}
* @returns {estraverse.Visitor}
*/
public abstract transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node;
public abstract getVisitor (): estraverse.Visitor;
}
src/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.ts
+16 -1
View File
@@ -1,6 +1,7 @@
import { injectable, inject } from 'inversify';
import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
import * as estraverse from 'estraverse';
import * as ESTree from 'estree';
import { TCustomNodeFactory } from '../../types/container/TCustomNodeFactory';
@@ -49,11 +50,25 @@ export class BlockStatementControlFlowTransformer extends AbstractNodeTransforme
});
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isBlockStatementNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param blockStatementNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (blockStatementNode: ESTree.BlockStatement): ESTree.Node {
private transformNode (blockStatementNode: ESTree.BlockStatement, parentNode: ESTree.Node): ESTree.Node {
if (
RandomGeneratorUtils.getRandomFloat(0, 1) > this.options.controlFlowFlatteningThreshold ||
BlockStatementControlFlowTransformer.blockStatementHasProhibitedStatements(blockStatementNode)
src/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.ts
+15 -1
View File
@@ -112,11 +112,25 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
return RandomGeneratorUtils.getRandomGenerator().pickone(blockScopesOfNode);
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isFunctionDeclarationNode(node) || Node.isFunctionExpressionNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param functionNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (functionNode: ESTree.Function): ESTree.Node {
private transformNode (functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Node {
if (Node.isArrowFunctionExpressionNode(functionNode)) {
return functionNode;
}
src/node-transformers/converting-transformers/MemberExpressionTransformer.ts
+16 -1
View File
@@ -1,6 +1,7 @@
import { injectable, inject } from 'inversify';
import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
import * as estraverse from 'estraverse';
import * as ESTree from 'estree';
import { IOptions } from '../../interfaces/options/IOptions';
@@ -21,6 +22,19 @@ export class MemberExpressionTransformer extends AbstractNodeTransformer {
super(options);
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isMemberExpressionNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* replaces:
* object.identifier = 1;
@@ -34,9 +48,10 @@ export class MemberExpressionTransformer extends AbstractNodeTransformer {
* Literal node will be obfuscated by LiteralTransformer
*
* @param memberExpressionNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (memberExpressionNode: ESTree.MemberExpression): ESTree.Node {
private transformNode (memberExpressionNode: ESTree.MemberExpression, parentNode: ESTree.Node): ESTree.Node {
if (Node.isIdentifierNode(memberExpressionNode.property)) {
if (memberExpressionNode.computed) {
return memberExpressionNode;
src/node-transformers/converting-transformers/MethodDefinitionTransformer.ts
+15 -1
View File
@@ -1,6 +1,7 @@
import { injectable, inject } from 'inversify';
import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
import * as estraverse from 'estraverse';
import * as ESTree from 'estree';
import { IOptions } from '../../interfaces/options/IOptions';
@@ -35,6 +36,19 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
super(options);
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isMethodDefinitionNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* replaces:
* object.identifier = 1;
@@ -50,7 +64,7 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
private transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
if (
Node.isIdentifierNode(methodDefinitionNode.key) &&
!MethodDefinitionTransformer.ignoredNames.includes(methodDefinitionNode.key.name) &&
src/node-transformers/converting-transformers/TemplateLiteralTransformer.ts
+15 -1
View File
@@ -1,6 +1,7 @@
import { injectable, inject } from 'inversify';
import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
import * as estraverse from 'estraverse';
import * as ESTree from 'estree';
import { IOptions } from '../../interfaces/options/IOptions';
@@ -32,12 +33,25 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
return node && Node.isLiteralNode(node) && typeof node.value === 'string';
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isTemplateLiteralNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param templateLiteralNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
private transformNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
const templateLiteralExpressions: ESTree.Expression[] = templateLiteralNode.expressions;
let nodes: (ESTree.Literal | ESTree.Expression)[] = [];
src/node-transformers/obfuscating-transformers/CatchClauseTransformer.ts
+15 -1
View File
@@ -41,11 +41,25 @@ export class CatchClauseTransformer extends AbstractNodeTransformer {
this.identifierReplacer = <IObfuscationReplacerWithStorage>replacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isCatchClauseNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param catchClauseNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (catchClauseNode: ESTree.CatchClause): ESTree.Node {
private transformNode (catchClauseNode: ESTree.CatchClause, parentNode: ESTree.Node): ESTree.Node {
const nodeIdentifier: number = this.nodeIdentifier++;
this.storeCatchClauseParam(catchClauseNode, nodeIdentifier);
src/node-transformers/obfuscating-transformers/FunctionDeclarationTransformer.ts
+14 -1
View File
@@ -51,12 +51,25 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isFunctionDeclarationNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param functionDeclarationNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (functionDeclarationNode: ESTree.FunctionDeclaration, parentNode: ESTree.Node): ESTree.Node {
private transformNode (functionDeclarationNode: ESTree.FunctionDeclaration, parentNode: ESTree.Node): ESTree.Node {
const nodeIdentifier: number = this.nodeIdentifier++;
const blockScopeOfFunctionDeclarationNode: TNodeWithBlockStatement = NodeUtils
.getBlockScopesOfNode(functionDeclarationNode)[0];
src/node-transformers/obfuscating-transformers/FunctionTransformer.ts
+19 -1
View File
@@ -41,11 +41,29 @@ export class FunctionTransformer extends AbstractNodeTransformer {
this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (
Node.isFunctionDeclarationNode(node) ||
Node.isFunctionExpressionNode(node) ||
Node.isArrowFunctionExpressionNode(node)
) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param functionNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (functionNode: ESTree.Function): ESTree.Node {
private transformNode (functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Node {
const nodeIdentifier: number = this.nodeIdentifier++;
this.storeFunctionParams(functionNode, nodeIdentifier);
src/node-transformers/obfuscating-transformers/LabeledStatementTransformer.ts
+15 -1
View File
@@ -49,11 +49,25 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isLabeledStatementNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param labeledStatementNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (labeledStatementNode: ESTree.LabeledStatement): ESTree.Node {
private transformNode (labeledStatementNode: ESTree.LabeledStatement, parentNode: ESTree.Node): ESTree.Node {
const nodeIdentifier: number = this.nodeIdentifier++;
this.storeLabeledStatementName(labeledStatementNode, nodeIdentifier);
src/node-transformers/obfuscating-transformers/LiteralTransformer.ts
+15 -1
View File
@@ -2,6 +2,7 @@ import { injectable, inject } from 'inversify';
import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
import * as escodegen from 'escodegen';
import * as estraverse from 'estraverse';
import * as ESTree from 'estree';
import { IOptions } from '../../interfaces/options/IOptions';
@@ -32,12 +33,25 @@ export class LiteralTransformer extends AbstractNodeTransformer {
this.replacersFactory = replacersFactory;
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isLiteralNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param literalNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
private transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
if (Node.isPropertyNode(parentNode) && parentNode.key === literalNode) {
return literalNode;
}
src/node-transformers/obfuscating-transformers/ObjectExpressionTransformer.ts
+16 -1
View File
@@ -2,6 +2,7 @@ import { injectable, inject } from 'inversify';
import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
import * as escodegen from 'escodegen';
import * as estraverse from 'estraverse';
import * as ESTree from 'estree';
import { IOptions } from '../../interfaces/options/IOptions';
@@ -64,11 +65,25 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
};
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isObjectExpressionNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param objectExpressionNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (objectExpressionNode: ESTree.ObjectExpression): ESTree.Node {
private transformNode (objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node {
objectExpressionNode.properties
.forEach((property: ESTree.Property) => {
if (property.shorthand) {
src/node-transformers/obfuscating-transformers/VariableDeclarationTransformer.ts
+14 -1
View File
@@ -52,12 +52,25 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
this.identifierReplacer = <IObfuscationReplacerWithStorage>replacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
}
/**
* @return {estraverse.Visitor}
*/
public getVisitor (): estraverse.Visitor {
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
if (Node.isVariableDeclarationNode(node)) {
this.transformNode(node, parentNode);
}
}
};
}
/**
* @param variableDeclarationNode
* @param parentNode
* @returns {ESTree.Node}
*/
public transformNode (variableDeclarationNode: ESTree.VariableDeclaration, parentNode: ESTree.Node): ESTree.Node {
private transformNode (variableDeclarationNode: ESTree.VariableDeclaration, parentNode: ESTree.Node): ESTree.Node {
const blockScopeOfVariableDeclarationNode: TNodeWithBlockStatement = NodeUtils
.getBlockScopesOfNode(variableDeclarationNode)[0];
src/node-transformers/obfuscating-transformers/replacers/StringLiteralReplacer.ts
+3 -3
View File
@@ -102,10 +102,10 @@ export class StringLiteralReplacer extends AbstractReplacer {
return <string>this.stringLiteralHexadecimalIndexCache.get(value);
}
const indexOfValue: number = this.stringArrayStorage.getLength();
const hexadecimalIndex: string = `${Utils.hexadecimalPrefix}${Utils.decToHex(indexOfValue)}`;
const stringArrayStorageLength: number = this.stringArrayStorage.getLength();
const hexadecimalIndex: string = `${Utils.hexadecimalPrefix}${Utils.decToHex(stringArrayStorageLength)}`;
this.stringArrayStorage.set(this.stringArrayStorage.getLength(), value);
this.stringArrayStorage.set(stringArrayStorageLength, value);
this.stringLiteralHexadecimalIndexCache.set(value, hexadecimalIndex);
return hexadecimalIndex;
src/node/Node.ts
+25
View File
@@ -45,6 +45,14 @@ export class Node {
return node.type === NodeType.CallExpression;
}
/**
* @param node
* @returns {boolean}
*/
public static isCatchClauseNode (node: ESTree.Node): node is ESTree.CatchClause {
return node.type === NodeType.CatchClause;
}
/**
* @param node
* @returns {boolean}
@@ -130,6 +138,14 @@ export class Node {
return node.type === NodeType.MemberExpression;
}
/**
* @param node
* @returns {boolean}
*/
public static isMethodDefinitionNode (node: ESTree.Node): node is ESTree.MethodDefinition {
return node.type === NodeType.MethodDefinition;
}
/**
* @param node
* @returns {boolean}
@@ -184,6 +200,15 @@ export class Node {
return !parentNodeIsPropertyNode && !parentNodeIsMemberExpressionNode && !Node.isLabelIdentifierNode(node, parentNode);
}
/**
*
* @param node
* @returns {boolean}
*/
public static isTemplateLiteralNode (node: ESTree.Node): node is ESTree.TemplateLiteral {
return node.type === NodeType.TemplateLiteral;
}
/**
*
* @param node
src/types/container/TNodeTransformersFactory.d.ts
Vendored
+1 -1
View File
@@ -2,4 +2,4 @@ import { INodeTransformer } from '../../interfaces/node-transformers/INodeTransf
import { NodeTransformers } from '../../enums/container/NodeTransformers';
export type TNodeTransformersFactory = (nodeTransformersMap: Map<string, NodeTransformers[]>) => (nodeType: string) => INodeTransformer[];
export type TNodeTransformersFactory = (nodeTransformerName: NodeTransformers) => INodeTransformer;