Obfuscated prototype symbols

src/templates/string-array-nodes/string-array-calls-wrapper/SelfDefendingTemplate.ts

@@ -1,46 +1,59 @@
 import { IEscapeSequenceEncoder } from '../../../interfaces/utils/IEscapeSequenceEncoder';
+import { Utils } from '../../../utils/Utils';
 
 /**
  * @param {IEscapeSequenceEncoder} escapeSequenceEncoder
  * @returns {string}
  */
 export function SelfDefendingTemplate (escapeSequenceEncoder: IEscapeSequenceEncoder): string {
+    const symTbl: { [key: string]: string } = {
+        'rc4Bytes': Utils.generateIden(),
+        'states': Utils.generateIden(),
+        'newState': Utils.generateIden(),
+        'firstState': Utils.generateIden(),
+        'secondState': Utils.generateIden(),
+        'checkState': Utils.generateIden(),
+        'runState': Utils.generateIden(),
+        'getState': Utils.generateIden(),
+        'stateResult': Utils.generateIden()
+    };
+    
     return `
-        var StatesClass = function (rc4Bytes) {
-            this.rc4Bytes = rc4Bytes;
-            this.states = [1, 0, 0];
-            this.newState = function(){return 'newState';};
-            this.firstState = '${
+        var StatesClass = function (${symTbl.rc4Bytes}) {
+            this.${symTbl.rc4Bytes} = ${symTbl.rc4Bytes};
+            this.${symTbl.states} = [1, 0, 0];
+            this.${symTbl.newState} = function(){return 'newState';};
+            this.${symTbl.firstState} = '${
                 escapeSequenceEncoder.encode(`\\w+ *\\(\\) *{\\w+ *`, true)
             }';
-            this.secondState = '${
+            this.${symTbl.secondState} = '${
                 escapeSequenceEncoder.encode(`['|"].+['|"];? *}`, true)
             }';
         };
         
-        StatesClass.prototype.checkState = function () {
-            var regExp = new RegExp(this.firstState + this.secondState);
+        StatesClass.prototype.${symTbl.checkState} = function () {
+            var regExp = new RegExp(this.${symTbl.firstState} + this.${symTbl.secondState});
 
-            return this.runState(regExp.test(this.newState.toString()) ? --this.states[1] : --this.states[0]);
+            return this.${symTbl.runState}(regExp.test(this.${symTbl.newState}.toString()) ? --this.${symTbl.states}[1] : --this.${symTbl.states}[0]);
         };
         
-        StatesClass.prototype.runState = function (stateResult) {
-            if (!Boolean(~stateResult)) {
-                return stateResult;
+        StatesClass.prototype.${symTbl.runState} = function (${symTbl.stateResult}) {
+            if (!Boolean(~${symTbl.stateResult})) {
+                return ${symTbl.stateResult};
             }
             
-            return this.getState(this.rc4Bytes);
+            return this.${symTbl.getState}(this.${symTbl.rc4Bytes});
         };
 
-        StatesClass.prototype.getState = function (rc4Bytes) {
-            for (var i = 0, len = this.states.length; i < len; i++) {
-                this.states.push(Math.round(Math.random()));
-                len = this.states.length;
+        StatesClass.prototype.${symTbl.getState} = function (${symTbl.rc4Bytes}) {
+            for (var i = 0, len = this.${symTbl.states}.length; i < len; i++) {
+                this.${symTbl.states}.push(Math.round(Math.random()));
+                len = this.${symTbl.states}.length;
             }
             
-            return rc4Bytes(this.states[0]);
+            return ${symTbl.rc4Bytes}(this.${symTbl.states}[0]);
         };
 
-        new StatesClass({stringArrayCallsWrapperName}).checkState();
+        new StatesClass({stringArrayCallsWrapperName}).${symTbl.checkState}();
     `;
 }

src/templates/string-array-nodes/string-array-calls-wrapper/StringArrayRC4DecodeNodeTemplate.ts

@@ -1,30 +1,39 @@
+import { Utils } from '../../../utils/Utils';
+
 /**
  * @returns {string}
  */
 export function StringArrayRc4DecodeNodeTemplate (): string {
+    const symTbl: { [key: string]: string } = {
+        'initialized': Utils.generateIden(),
+        'rc4': Utils.generateIden(),
+        'data': Utils.generateIden(),
+        'once': Utils.generateIden()
+    };
+  
     return `
-        if ({stringArrayCallsWrapperName}.initialized === undefined) {
+        if ({stringArrayCallsWrapperName}.${symTbl.initialized} === undefined) {
             {atobPolyfill}
             
             {rc4Polyfill}
-            {stringArrayCallsWrapperName}.rc4 = rc4;
+            {stringArrayCallsWrapperName}.${symTbl.rc4} = rc4;
             
-            {stringArrayCallsWrapperName}.data = {};
+            {stringArrayCallsWrapperName}.${symTbl.data} = {};
             
-            {stringArrayCallsWrapperName}.initialized = true;
+            {stringArrayCallsWrapperName}.${symTbl.initialized} = true;
         }
   
-        var cachedValue = {stringArrayCallsWrapperName}.data[index];
+        var cachedValue = {stringArrayCallsWrapperName}.${symTbl.data}[index];
 
         if (cachedValue === undefined) {
-            if ({stringArrayCallsWrapperName}.once === undefined) {
+            if ({stringArrayCallsWrapperName}.${symTbl.once} === undefined) {
                 {selfDefendingCode}
                 
-                {stringArrayCallsWrapperName}.once = true;
+                {stringArrayCallsWrapperName}.${symTbl.once} = true;
             }
             
-            value = {stringArrayCallsWrapperName}.rc4(value, key);
-            {stringArrayCallsWrapperName}.data[index] = value;
+            value = {stringArrayCallsWrapperName}.${symTbl.rc4}(value, key);
+            {stringArrayCallsWrapperName}.${symTbl.data}[index] = value;
         } else {
             value = cachedValue;
         }

src/utils/Utils.ts

@@ -71,4 +71,22 @@ export class Utils {
             })
             .join(' + ');
     }
+    
+    /**
+     * @returns {string}
+     */
+    public static generateIden (): string {
+        let validIden: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_';
+        let ret: string = '';
+
+        ret += validIden[Math.floor(Math.random() * validIden.length) % validIden.length];
+        validIden += '0123456789';
+        
+        const len: number = Math.floor((Math.random() * 10) + 3);
+        for (let i: number = 0; i < len; i++) {
+            ret += validIden[Math.floor(Math.random() * validIden.length) % validIden.length];
+        }
+        
+        return ret;
+    }
 }