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

Sync with dev

Browse Source
This commit is contained in:
sanex
2021-02-27 21:24:04 +03:00
parent 3c379999a7 c0ac1239e2
commit 29f969a751
14 changed files with 475 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/functional-tests/node-transformers/converting-transformers/numbers-to-numerical-expressions-transformer/NumbersToNumericalExpressionsTransformer.spec.ts
+82 -20
View File
@@ -40,32 +40,94 @@ describe('NumbersToNumericalExpressionsTransformer', function () {
});
describe('Variant #2: float number', () => {
const number: number = 50.5;
const samplesCount: number = 15;
describe('Variant #1: Number `50.5`', () => {
const number: number = 50.5;
const samplesCount: number = 15;
let areValidExpressions: boolean = true;
let areValidExpressions: boolean = true;
before(() => {
for (let i = 0; i < samplesCount; i++) {
const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
`${number};`,
{
...NO_ADDITIONAL_NODES_PRESET,
numbersToExpressions: true
before(() => {
for (let i = 0; i < samplesCount; i++) {
const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
`${number};`,
{
...NO_ADDITIONAL_NODES_PRESET,
numbersToExpressions: true
}
).getObfuscatedCode();
const result: number = eval(obfuscatedCode);
if (result !== number) {
areValidExpressions = false;
break;
}
).getObfuscatedCode();
const result: number = eval(obfuscatedCode);
if (result !== number) {
areValidExpressions = false;
break;
}
}
});
it('should correctly transform numbers to expressions', () => {
assert.isTrue(areValidExpressions);
});
});
it('should correctly transform numbers to expressions', () => {
assert.isTrue(areValidExpressions);
describe('Variant #2: Number `1e-13`', () => {
const number: number = 1e-13;
const samplesCount: number = 15;
let areValidExpressions: boolean = true;
before(() => {
for (let i = 0; i < samplesCount; i++) {
const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
`${number};`,
{
...NO_ADDITIONAL_NODES_PRESET,
numbersToExpressions: true
}
).getObfuscatedCode();
const result: number = eval(obfuscatedCode);
if (result !== number) {
areValidExpressions = false;
break;
}
}
});
it('should correctly transform numbers to expressions', () => {
assert.isTrue(areValidExpressions);
});
});
describe('Variant #3: Number `-1e-100`', () => {
const number: number = -1e-100;
const samplesCount: number = 15;
let areValidExpressions: boolean = true;
before(() => {
for (let i = 0; i < samplesCount; i++) {
const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
`${number};`,
{
...NO_ADDITIONAL_NODES_PRESET,
numbersToExpressions: true
}
).getObfuscatedCode();
const result: number = eval(obfuscatedCode);
if (result !== number) {
areValidExpressions = false;
break;
}
}
});
it('should correctly transform numbers to expressions', () => {
assert.isTrue(areValidExpressions);
});
});
});
test/unit-tests/node/numerical-expression-data-to-node-converter/NumericalExpressionDataToNodeConverter.spec.ts
+92 -36
View File
@@ -10,47 +10,103 @@ import { NodeFactory } from '../../../../src/node/NodeFactory';
import { NumericalExpressionDataToNodeConverter } from '../../../../src/node/NumericalExpressionDataToNodeConverter';
describe('NumericalExpressionDataToNodeConverter', () => {
describe('Variant #1: base', () => {
const expectedExpressionNode: ESTree.Expression = NodeFactory.binaryExpressionNode(
'+',
NodeFactory.binaryExpressionNode(
describe('convertIntegerNumberData', () => {
describe('Variant #1: base', () => {
const numberNumericalExpressionData: TNumberNumericalExpressionData = [
1, [-2, 3], 4
];
const expectedExpressionNode: ESTree.Expression = NodeFactory.binaryExpressionNode(
'+',
NodeFactory.literalNode(1),
NodeFactory.binaryExpressionNode(
'*',
NodeFactory.unaryExpressionNode(
'-',
NodeFactory.literalNode(2),
),
NodeFactory.literalNode(3)
),
),
NodeFactory.literalNode(4)
);
const numberNumericalExpressionData: TNumberNumericalExpressionData = [
1, [-2, 3], 4
];
let expressionNode: ESTree.Expression;
before(() => {
expressionNode = NumericalExpressionDataToNodeConverter.convert(
numberNumericalExpressionData,
(number: number, isPositiveNumber: boolean): ESTree.Expression => {
const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
return isPositiveNumber
? numberLiteralNode
: NodeFactory.unaryExpressionNode(
'+',
NodeFactory.literalNode(1),
NodeFactory.binaryExpressionNode(
'*',
NodeFactory.unaryExpressionNode(
'-',
numberLiteralNode
);
}
NodeFactory.literalNode(2),
),
NodeFactory.literalNode(3)
),
),
NodeFactory.literalNode(4)
);
});
it('should convert number numerical expression data to expression node', () => {
assert.deepEqual(expressionNode, expectedExpressionNode);
let expressionNode: ESTree.Expression;
before(() => {
expressionNode = NumericalExpressionDataToNodeConverter.convertIntegerNumberData(
numberNumericalExpressionData,
(number: number, isPositiveNumber: boolean): ESTree.Expression => {
const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
return isPositiveNumber
? numberLiteralNode
: NodeFactory.unaryExpressionNode(
'-',
numberLiteralNode
);
}
);
});
it('should convert number numerical expression data to expression node', () => {
assert.deepEqual(expressionNode, expectedExpressionNode);
});
});
});
describe('convertFloatNumberData', () => {
describe('Variant #1: base', () => {
const integerNumberNumericalExpressionData: TNumberNumericalExpressionData = [
1, [-2, 3], 4
];
const decimalPart: number = 0.000000001;
const expectedExpressionNode: ESTree.Expression = NodeFactory.binaryExpressionNode(
'+',
NodeFactory.binaryExpressionNode(
'+',
NodeFactory.binaryExpressionNode(
'+',
NodeFactory.literalNode(1),
NodeFactory.binaryExpressionNode(
'*',
NodeFactory.unaryExpressionNode(
'-',
NodeFactory.literalNode(2),
),
NodeFactory.literalNode(3)
),
),
NodeFactory.literalNode(4)
),
NodeFactory.literalNode(decimalPart)
);
let expressionNode: ESTree.Expression;
before(() => {
expressionNode = NumericalExpressionDataToNodeConverter.convertFloatNumberData(
integerNumberNumericalExpressionData,
decimalPart,
(number: number, isPositiveNumber: boolean): ESTree.Expression => {
const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
return isPositiveNumber
? numberLiteralNode
: NodeFactory.unaryExpressionNode(
'-',
numberLiteralNode
);
}
);
});
it('should convert number numerical expression data to expression node', () => {
assert.deepEqual(expressionNode, expectedExpressionNode);
});
});
});
});
test/unit-tests/utils/NumberUtils.spec.ts
+123
View File
@@ -83,6 +83,129 @@ describe('NumberUtils', function () {
});
});
describe('extractIntegerAndDecimalParts', () => {
describe('Variant #1: number `0`', () => {
const number: number = 0;
const expectedParts: [number, number | null] = [0, null];
let parts: [number, number | null];
before(() => {
parts = NumberUtils.extractIntegerAndDecimalParts(number);
});
it('should extract integer and decimal parts', () => {
assert.deepEqual(parts, expectedParts);
});
});
describe('Variant #2: number `10`', () => {
const number: number = 10;
const expectedParts: [number, number | null] = [10, null];
let parts: [number, number | null];
before(() => {
parts = NumberUtils.extractIntegerAndDecimalParts(number);
});
it('should extract integer and decimal parts', () => {
assert.deepEqual(parts, expectedParts);
});
});
describe('Variant #3: number `-17`', () => {
const number: number = -17;
const expectedParts: [number, number | null] = [-17, null];
let parts: [number, number | null];
before(() => {
parts = NumberUtils.extractIntegerAndDecimalParts(number);
});
it('should extract integer and decimal parts', () => {
assert.deepEqual(parts, expectedParts);
});
});
describe('Variant #4: number `0.0000000001`', () => {
const number: number = 0.0000000001;
const expectedParts: [number, number | null] = [0, 0.0000000001];
let parts: [number, number | null];
before(() => {
parts = NumberUtils.extractIntegerAndDecimalParts(number);
});
it('should extract integer and decimal parts', () => {
assert.deepEqual(parts, expectedParts);
});
it('should return an initial number after sum of extracted parts', () => {
assert.equal(number, parts[0] + parts[1]!);
});
});
describe('Variant #5: number `10.0002`', () => {
const number: number = 10.0002;
const expectedParts: [number, number | null] = [10, 0.00019999999999953388];
let parts: [number, number | null];
before(() => {
parts = NumberUtils.extractIntegerAndDecimalParts(number);
});
it('should extract integer and decimal parts (with inaccuracy of float numbers)', () => {
assert.deepEqual(parts, expectedParts);
});
it('should return an initial number after sum of extracted parts', () => {
assert.equal(number, parts[0] + parts[1]!);
});
});
describe('Variant #6: number `1e-13`', () => {
const number: number = 1e-13;
const expectedParts: [number, number | null] = [0, 1e-13];
let parts: [number, number | null];
before(() => {
parts = NumberUtils.extractIntegerAndDecimalParts(number);
});
it('should extract integer and decimal parts', () => {
assert.deepEqual(parts, expectedParts);
});
it('should return an initial number after sum of extracted parts', () => {
assert.equal(number, parts[0] + parts[1]!);
});
});
describe('Variant #7: number `-1e-100`', () => {
const number: number = -1e-100;
const expectedParts: [number, number | null] = [-0, -1e-100];
let parts: [number, number | null];
before(() => {
parts = NumberUtils.extractIntegerAndDecimalParts(number);
});
it('should extract integer and decimal parts', () => {
assert.deepEqual(parts, expectedParts);
});
it('should return an initial number after sum of extracted parts', () => {
assert.equal(number, parts[0] + parts[1]!);
});
});
});
describe('isCeil', () => {
describe('given number is a ceil', () => {
const number: number = 4;