rc4 unicode array encoding wip

test/dev/test.ts

@@ -69,7 +69,7 @@ let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
     `,
     {
         disableConsoleOutput: false,
-        unicodeArrayEncoding: 'base64'
+        unicodeArrayEncoding: true
     }
 ).getObfuscatedCode();
 

test/functional-tests/node-obfuscators/LiteralObfuscator.spec.ts

@@ -8,7 +8,7 @@ const assert: Chai.AssertStatic = require('chai').assert;
 
 describe('LiteralObfuscator', () => {
     describe('obfuscation of literal node with string value', () => {
-        it('should replace literal node value with unicode value without encoding to base64', () => {
+        it('should replace literal node value with unicode value without encoding', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 `var test = 'test';`,
                 Object.assign({}, NO_CUSTOM_NODES_PRESET)
@@ -17,7 +17,7 @@ describe('LiteralObfuscator', () => {
             assert.match(obfuscationResult.getObfuscatedCode(),  /^var *test *= *'\\x74\\x65\\x73\\x74';$/);
         });
 
-        it('should replace literal node value with unicode value encoded to base64', () => {
+        it('should replace literal node value with unicode value encoded using base64', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 `var test = 'test';`,
                 Object.assign({}, NO_CUSTOM_NODES_PRESET, {
@@ -27,9 +27,32 @@ describe('LiteralObfuscator', () => {
                 })
             );
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /^var *_0x([a-z0-9]){4} *= *\['\\x64\\x47\\x56\\x7a\\x64\\x41\\x3d\\x3d'\];/);
+            assert.match(
+                obfuscationResult.getObfuscatedCode(),
+                /^var *_0x([a-z0-9]){4} *= *\['\\x64\\x47\\x56\\x7a\\x64\\x41\\x3d\\x3d'\];/
+            );
             assert.match(obfuscationResult.getObfuscatedCode(),  /var *test *= *_0x([a-z0-9]){4}\('0x0'\);/);
         });
+
+        it('should replace literal node value with unicode value encoded using rc4', () => {
+            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                `var test = 'test';`,
+                Object.assign({}, NO_CUSTOM_NODES_PRESET, {
+                    unicodeArray: true,
+                    unicodeArrayEncoding: 'rc4',
+                    unicodeArrayThreshold: 1
+                })
+            );
+
+            assert.match(
+                obfuscationResult.getObfuscatedCode(),
+                /^var *_0x([a-z0-9]){4} *= *\['(\\x[a-f0-9]*){8}'\];/
+            );
+            assert.match(
+                obfuscationResult.getObfuscatedCode(),
+                /var *test *= *_0x([a-z0-9]){4}\('0x0', '(\\x[a-f0-9]*){4}'\);/
+            );
+        });
     });
 
     it('should obfuscate literal node with boolean value', () => {

test/functional-tests/templates/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapperNodeTemplate.spec.ts

@@ -1,8 +1,10 @@
 import 'format-unicorn';
 
 import { AtobTemplate } from '../../../../../src/templates/custom-nodes/AtobTemplate';
+import { Rc4Template } from '../../../../../src/templates/custom-nodes/Rc4Template';
 import { UnicodeArrayBase64DecodeNodeTemplate } from '../../../../../src/templates/custom-nodes/unicode-array-nodes/unicode-array-calls-wrapper/UnicodeArrayBase64DecodeNodeTemplate';
 import { UnicodeArrayCallsWrapperTemplate } from '../../../../../src/templates/custom-nodes/unicode-array-nodes/unicode-array-calls-wrapper/UnicodeArrayCallsWrapperTemplate';
+import { UnicodeArrayRc4DecodeNodeTemplate } from '../../../../../src/templates/custom-nodes/unicode-array-nodes/unicode-array-calls-wrapper/UnicodeArrayRC4DecodeNodeTemplate';
 
 import { Utils } from '../../../../../src/Utils';
 
@@ -15,7 +17,7 @@ const assert: Chai.AssertStatic = require('chai').assert;
  * @param index
  * @returns {Function}
  */
-function getFunctionFromTemplate (
+function getFunctionFromTemplateBase64Encoding (
     templateData: any,
     unicodeArrayName: string,
     unicodeArrayCallsWrapperName: string,
@@ -32,6 +34,32 @@ function getFunctionFromTemplate (
     `)();
 }
 
+/**
+ * @param templateData
+ * @param unicodeArrayName
+ * @param unicodeArrayCallsWrapperName
+ * @param index
+ * @param key
+ * @returns {Function}
+ */
+function getFunctionFromTemplateRc4Encoding (
+    templateData: any,
+    unicodeArrayName: string,
+    unicodeArrayCallsWrapperName: string,
+    index: string,
+    key: string
+) {
+    let unicodeArrayCallsWrapperTemplate: string = UnicodeArrayCallsWrapperTemplate().formatUnicorn(templateData);
+
+    return Function(`
+        var ${unicodeArrayName} = ['${Utils.btoa(Utils.rc4('test1', key))}'];
+    
+        ${unicodeArrayCallsWrapperTemplate}
+        
+        return ${unicodeArrayCallsWrapperName}('${index}', '${key}');
+    `)();
+}
+
 describe('UnicodeArrayCallsWrapperNodeTemplate (): string', () => {
     let unicodeArrayName: string = 'unicodeArrayName',
         unicodeArrayCallsWrapperName: string = 'unicodeArrayCallsWrapperName',
@@ -39,13 +67,27 @@ describe('UnicodeArrayCallsWrapperNodeTemplate (): string', () => {
             atobPolyfill: AtobTemplate(),
             selfDefendingCode: '',
             unicodeArrayCallsWrapperName
+        }),
+        rc4DecodeNodeTemplate: string = UnicodeArrayRc4DecodeNodeTemplate().formatUnicorn({
+            atobPolyfill: AtobTemplate(),
+            rc4Polyfill: Rc4Template(),
+            selfDefendingCode: '',
+            unicodeArrayCallsWrapperName
         });
 
-    it('should correctly returns decoded value with atob encoding', () => {
-        assert.deepEqual(getFunctionFromTemplate({
+    it('should correctly returns decoded value with base64 encoding', () => {
+        assert.deepEqual(getFunctionFromTemplateBase64Encoding({
             decodeNodeTemplate: atobDecodeNodeTemplate,
             unicodeArrayCallsWrapperName,
             unicodeArrayName
         }, unicodeArrayName, unicodeArrayCallsWrapperName, '0x0'), 'test1');
     });
+
+    it('should correctly returns decoded value with rc4 encoding', () => {
+        assert.deepEqual(getFunctionFromTemplateRc4Encoding({
+            decodeNodeTemplate: rc4DecodeNodeTemplate,
+            unicodeArrayCallsWrapperName,
+            unicodeArrayName
+        }, unicodeArrayName, unicodeArrayCallsWrapperName, '0x0', 'key'), 'test1');
+    });
 });