Fixed runtime errors in large obfuscated code when both rc4 and base64 encodings are enabled

test/runtime-tests/JavaScriptObfuscatorRuntime.spec.ts

@@ -34,7 +34,7 @@ describe('JavaScriptObfuscator runtime eval', function () {
         rotateStringArray: true,
         selfDefending: true,
         splitStrings: true,
-        splitStringsChunkLength: 1,
+        splitStringsChunkLength: 3,
         stringArray: true,
         stringArrayEncoding: [
             StringArrayEncoding.None,

test/unit-tests/storages/string-array-transformers/string-array/StringArrayStorage.spec.ts

@@ -8,6 +8,7 @@ import { TInputOptions } from '../../../../../src/types/options/TInputOptions';
 
 import { IInversifyContainerFacade } from '../../../../../src/interfaces/container/IInversifyContainerFacade';
 import { IStringArrayStorage } from '../../../../../src/interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { IStringArrayStorageItemData } from '../../../../../src/interfaces/storages/string-array-transformers/IStringArrayStorageItem';
 
 import { StringArrayEncoding } from '../../../../../src/enums/node-transformers/string-array-transformers/StringArrayEncoding';
 
@@ -35,21 +36,23 @@ const getStorageInstance = (options: TInputOptions = {}): IStringArrayStorage =>
     return storage;
 };
 
-const getEncodedValue = (stringArrayStorage: IStringArrayStorage, value: string, decodeKey: string): string => {
+const getStringArrayStorageItemData = (
+    stringArrayStorage: IStringArrayStorage,
+    value: string,
+    decodeKeys: string[]
+): IStringArrayStorageItemData | undefined => {
     (<any>stringArrayStorage).rc4Keys = [
         'foo',
-        decodeKey
+        ...decodeKeys
     ];
 
-    return stringArrayStorage.get(value)?.encodedValue ?? '';
+    return stringArrayStorage.get(value);
 };
 
 describe('StringArrayStorage', () => {
     describe('rc4 encoded value collision fix', () => {
         const samplesCount: number = 100;
 
-        let firstEncodedValue: string;
-        let secondEncodedValue: string;
         let isCollisionHappened: boolean = false;
 
         before(() => {
@@ -58,8 +61,8 @@ describe('StringArrayStorage', () => {
             });
 
             for (let i = 0; i < samplesCount; i++) {
-                firstEncodedValue = getEncodedValue(stringArrayStorage, '_15', 'CRDL');
-                secondEncodedValue = getEncodedValue(stringArrayStorage, '_12', 'q9mB');
+                const {encodedValue: firstEncodedValue} = getStringArrayStorageItemData(stringArrayStorage, '_15', ['CRDL']) || {};
+                const {encodedValue: secondEncodedValue} = getStringArrayStorageItemData(stringArrayStorage, '_12', ['q9mB']) || {};
 
                 if (firstEncodedValue === secondEncodedValue) {
                     isCollisionHappened = true;
@@ -72,4 +75,42 @@ describe('StringArrayStorage', () => {
             assert.equal(isCollisionHappened, false);
         });
     });
+
+    describe('Cache key collision when rc4 and base64 encoded values for different input strings are the same', () => {
+        const samplesCount: number = 100;
+
+        let isCollisionHappened: boolean = false;
+
+        before(() => {
+            const stringArrayStorage: IStringArrayStorage = getStorageInstance({
+                stringArrayEncoding: [
+                    StringArrayEncoding.Base64,
+                    StringArrayEncoding.Rc4
+                ]
+            });
+
+            for (let i = 0; i < samplesCount; i++) {
+                const {
+                    encodedValue: firstEncodedValue,
+                    encoding: firstEncodedValueEncoding
+                } = getStringArrayStorageItemData(stringArrayStorage, 'zxL', ['&Jfx', '[lR4']) || {};
+                const {
+                    encodedValue: secondEncodedValue,
+                    encoding: secondEncodedValueEncoding
+                } = getStringArrayStorageItemData(stringArrayStorage, 'omC', ['&Jfx', '[lR4']) || {};
+
+                if (
+                    firstEncodedValue === secondEncodedValue
+                    && firstEncodedValueEncoding === secondEncodedValueEncoding
+                ) {
+                    isCollisionHappened = true;
+                    break;
+                }
+            }
+        });
+
+        it('should not make a cache key collision between different encoded input strings', () => {
+            assert.equal(isCollisionHappened, false);
+        });
+    });
 });