nolimit-x 1.0.0

package/src/obfuscator.js

@@ -0,0 +1,350 @@
+const crypto = require('crypto');
+
+class Obfuscator {
+    constructor() {
+        this.encodingMethods = {
+            base64: 'base64',
+            hex: 'hex',
+            rot13: 'rot13',
+            caesar: 'caesar',
+            binary: 'binary',
+            url: 'url',
+            html: 'html',
+            unicode: 'unicode'
+        };
+    }
+
+    // Main obfuscation method
+    obfuscate(text, method = 'base64', options = {}) {
+        switch (method) {
+            case 'base64':
+                return this.base64Encode(text);
+            case 'hex':
+                return this.hexEncode(text);
+            case 'rot13':
+                return this.rot13Encode(text);
+            case 'caesar':
+                return this.caesarCipher(text, options.shift || 3);
+            case 'binary':
+                return this.binaryEncode(text);
+            case 'url':
+                return this.urlEncode(text);
+            case 'html':
+                return this.htmlEncode(text);
+            case 'unicode':
+                return this.unicodeEncode(text);
+            case 'custom':
+                return this.customObfuscate(text, options);
+            default:
+                return this.base64Encode(text);
+        }
+    }
+
+    // Deobfuscation method
+    deobfuscate(text, method = 'base64', options = {}) {
+        switch (method) {
+            case 'base64':
+                return this.base64Decode(text);
+            case 'hex':
+                return this.hexDecode(text);
+            case 'rot13':
+                return this.rot13Decode(text);
+            case 'caesar':
+                return this.caesarCipher(text, -(options.shift || 3));
+            case 'binary':
+                return this.binaryDecode(text);
+            case 'url':
+                return this.urlDecode(text);
+            case 'html':
+                return this.htmlDecode(text);
+            case 'unicode':
+                return this.unicodeDecode(text);
+            case 'custom':
+                return this.customDeobfuscate(text, options);
+            default:
+                return this.base64Decode(text);
+        }
+    }
+
+    // Base64 encoding/decoding
+    base64Encode(text) {
+        return Buffer.from(text, 'utf8').toString('base64');
+    }
+
+    base64Decode(text) {
+        return Buffer.from(text, 'base64').toString('utf8');
+    }
+
+    // Hex encoding/decoding
+    hexEncode(text) {
+        return Buffer.from(text, 'utf8').toString('hex');
+    }
+
+    hexDecode(text) {
+        return Buffer.from(text, 'hex').toString('utf8');
+    }
+
+    // ROT13 encoding/decoding
+    rot13Encode(text) {
+        return text.replace(/[a-zA-Z]/g, function(char) {
+            return String.fromCharCode((char <= 'Z' ? 90 : 122) >= (char = char.charCodeAt(0) + 13) ? char : char - 26);
+        });
+    }
+
+    rot13Decode(text) {
+        return this.rot13Encode(text); // ROT13 is symmetric
+    }
+
+    // Caesar cipher
+    caesarCipher(text, shift) {
+        return text.replace(/[a-zA-Z]/g, function(char) {
+            const code = char.charCodeAt(0);
+            const isUpperCase = code >= 65 && code <= 90;
+            const base = isUpperCase ? 65 : 97;
+            const shifted = ((code - base + shift) % 26 + 26) % 26 + base;
+            return String.fromCharCode(shifted);
+        });
+    }
+
+    // Binary encoding/decoding
+    binaryEncode(text) {
+        return text.split('').map(char => char.charCodeAt(0).toString(2).padStart(8, '0')).join(' ');
+    }
+
+    binaryDecode(text) {
+        return text.split(' ').map(binary => String.fromCharCode(parseInt(binary, 2))).join('');
+    }
+
+    // URL encoding/decoding
+    urlEncode(text) {
+        return encodeURIComponent(text);
+    }
+
+    urlDecode(text) {
+        return decodeURIComponent(text);
+    }
+
+    // HTML encoding/decoding
+    htmlEncode(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+    }
+
+    htmlDecode(text) {
+        return text
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+    }
+
+    // Unicode encoding/decoding
+    unicodeEncode(text) {
+        return text.split('').map(char => '\\u' + char.charCodeAt(0).toString(16).padStart(4, '0')).join('');
+    }
+
+    unicodeDecode(text) {
+        return text.replace(/\\u([0-9a-fA-F]{4})/g, (match, hex) => String.fromCharCode(parseInt(hex, 16)));
+    }
+
+    // Custom obfuscation
+    customObfuscate(text, options = {}) {
+        let result = text;
+        
+        // Apply multiple layers of obfuscation
+        if (options.layers) {
+            for (const layer of options.layers) {
+                result = this.obfuscate(result, layer.method, layer.options);
+            }
+        }
+        
+        return result;
+    }
+
+    // Custom deobfuscation
+    customDeobfuscate(text, options = {}) {
+        let result = text;
+        
+        // Apply multiple layers of deobfuscation in reverse order
+        if (options.layers) {
+            for (let i = options.layers.length - 1; i >= 0; i--) {
+                const layer = options.layers[i];
+                result = this.deobfuscate(result, layer.method, layer.options);
+            }
+        }
+        
+        return result;
+    }
+
+    // Obfuscate URLs
+    obfuscateURL(url, method = 'base64') {
+        const obfuscated = this.obfuscate(url, method);
+        return `https://redirect.example.com/${obfuscated}`;
+    }
+
+    // Obfuscate email addresses
+    obfuscateEmail(email, method = 'base64') {
+        const [local, domain] = email.split('@');
+        const obfuscatedLocal = this.obfuscate(local, method);
+        const obfuscatedDomain = this.obfuscate(domain, method);
+        return `${obfuscatedLocal}@${obfuscatedDomain}`;
+    }
+
+    // Obfuscate payloads
+    obfuscatePayload(payload, method = 'base64', options = {}) {
+        // Add random padding
+        const padding = options.padding ? this.generateRandomString(options.padding) : '';
+        const fullPayload = padding + payload + padding;
+        
+        return this.obfuscate(fullPayload, method, options);
+    }
+
+    // Generate random string for padding
+    generateRandomString(length = 10) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return result;
+    }
+
+    // Obfuscate JavaScript code
+    obfuscateJavaScript(code, options = {}) {
+        let obfuscated = code;
+        
+        // Variable name obfuscation
+        if (options.obfuscateVariables) {
+            obfuscated = this.obfuscateVariableNames(obfuscated);
+        }
+        
+        // String obfuscation
+        if (options.obfuscateStrings) {
+            obfuscated = this.obfuscateStrings(obfuscated);
+        }
+        
+        // Add junk code
+        if (options.addJunkCode) {
+            obfuscated = this.addJunkCode(obfuscated);
+        }
+        
+        return obfuscated;
+    }
+
+    // Obfuscate variable names
+    obfuscateVariableNames(code) {
+        // Simple variable name obfuscation
+        const varRegex = /\b(var|let|const)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
+        let counter = 0;
+        
+        return code.replace(varRegex, (match, keyword, varName) => {
+            const obfuscatedName = `_${counter++}`;
+            // Replace all occurrences of the variable name
+            const varNameRegex = new RegExp(`\\b${varName}\\b`, 'g');
+            code = code.replace(varNameRegex, obfuscatedName);
+            return `${keyword} ${obfuscatedName}`;
+        });
+    }
+
+    // Obfuscate strings
+    obfuscateStrings(code) {
+        const stringRegex = /"([^"]*)"|'([^']*)'/g;
+        
+        return code.replace(stringRegex, (match, doubleQuote, singleQuote) => {
+            const string = doubleQuote || singleQuote;
+            const obfuscated = this.base64Encode(string);
+            return `atob("${obfuscated}")`;
+        });
+    }
+
+    // Add junk code
+    addJunkCode(code) {
+        const junkCode = `
+            (function(){var _0x${Math.random().toString(36).substring(2, 8)}=${Math.floor(Math.random() * 1000)};})();
+        `;
+        
+        return junkCode + code;
+    }
+
+    // Obfuscate HTML content
+    obfuscateHTML(html, options = {}) {
+        let obfuscated = html;
+        
+        // Obfuscate text content
+        if (options.obfuscateText) {
+            obfuscated = this.obfuscateTextContent(obfuscated);
+        }
+        
+        // Obfuscate attributes
+        if (options.obfuscateAttributes) {
+            obfuscated = this.obfuscateAttributes(obfuscated);
+        }
+        
+        return obfuscated;
+    }
+
+    // Obfuscate text content in HTML
+    obfuscateTextContent(html) {
+        return html.replace(/>([^<]+)</g, (match, text) => {
+            const obfuscated = this.base64Encode(text.trim());
+            return `><script>document.write(atob("${obfuscated}"));</script><`;
+        });
+    }
+
+    // Obfuscate HTML attributes
+    obfuscateAttributes(html) {
+        return html.replace(/(\w+)="([^"]*)"/g, (match, attr, value) => {
+            const obfuscated = this.base64Encode(value);
+            return `${attr}="${obfuscated}"`;
+        });
+    }
+
+    // Generate obfuscation key
+    generateKey(length = 32) {
+        return crypto.randomBytes(length).toString('hex');
+    }
+
+    // XOR encryption/decryption
+    xorEncrypt(text, key) {
+        let result = '';
+        for (let i = 0; i < text.length; i++) {
+            result += String.fromCharCode(text.charCodeAt(i) ^ key.charCodeAt(i % key.length));
+        }
+        return this.base64Encode(result);
+    }
+
+    xorDecrypt(encryptedText, key) {
+        const decoded = this.base64Decode(encryptedText);
+        let result = '';
+        for (let i = 0; i < decoded.length; i++) {
+            result += String.fromCharCode(decoded.charCodeAt(i) ^ key.charCodeAt(i % key.length));
+        }
+        return result;
+    }
+
+    // Get available encoding methods
+    getAvailableMethods() {
+        return Object.keys(this.encodingMethods);
+    }
+
+    // Test obfuscation/deobfuscation
+    testObfuscation(text, method = 'base64') {
+        const obfuscated = this.obfuscate(text, method);
+        const deobfuscated = this.deobfuscate(obfuscated, method);
+        
+        return {
+            original: text,
+            obfuscated: obfuscated,
+            deobfuscated: deobfuscated,
+            success: text === deobfuscated,
+            method: method
+        };
+    }
+}
+
+module.exports = Obfuscator; 

package/src/placeholders.js

@@ -0,0 +1,230 @@
+const utils = require('./utils');
+
+// Dynamic placeholder patterns and handlers
+const dynamicPlaceholders = [
+    // Email placeholders
+    { 
+        pattern: /\[\[-\s*EMAIL\s*-\]\]/g, 
+        handler: async (email) => email 
+    },
+    { 
+        pattern: /\[\[-\s*EMAIL_NAME\s*-\]\]/g, 
+        handler: async (email) => {
+            const emailName = utils.getEmailName(email);
+            const cleanedName = emailName.replace(/[^a-zA-Z]/g, '');
+            return utils.detectAndFormatNames(cleanedName);
+        }
+    },
+    { 
+        pattern: /\[\[-\s*EMAIL_DOMAIN\s*-\]\]/g, 
+        handler: async (email) => utils.getDomainFromEmail(email) 
+    },
+    { 
+        pattern: /\[\[-\s*COMPANY_NAME\s*-\]\]/g, 
+        handler: async (email) => utils.getCompanyName(email) 
+    },
+    
+    // Date and Time placeholders
+    { 
+        pattern: /\[\[-\s*TIME\s*-\]\]/g, 
+        handler: async () => utils.getCurrentDate().toLocaleTimeString('en-US', { hour12: false }) 
+    },
+    { 
+        pattern: /\[\[-\s*SECOND\s*-\]\]/g, 
+        handler: async () => utils.getCurrentDate().getSeconds() 
+    },
+    { 
+        pattern: /\[\[-\s*MINUTE\s*-\]\]/g, 
+        handler: async () => utils.getCurrentDate().getMinutes() 
+    },
+    { 
+        pattern: /\[\[-\s*HOUR\s*-\]\]/g, 
+        handler: async () => utils.getCurrentDate().getHours() 
+    },
+    { 
+        pattern: /\[\[-\s*DATE\s*-\]\]/g, 
+        handler: async () => utils.getCurrentDate().toISOString().split('T')[0] 
+    },
+    { 
+        pattern: /\[\[-\s*DATE_LONG\s*-\]\]/g, 
+        handler: async () => utils.getCurrentDate().toLocaleDateString('en-US', { 
+            weekday: 'long', 
+            year: 'numeric', 
+            month: 'long', 
+            day: 'numeric' 
+        }) 
+    },
+    { 
+        pattern: /\[\[-\s*DATE_PLUS_TIME\s*-\]\]/g, 
+        handler: async () => utils.getCurrentDate().toLocaleString('en-US') 
+    },
+    
+    // Future/Past date placeholders
+    { 
+        pattern: /\[\[-\s*DATE_FUTURE_PAST\('future',(\d+),'days'\)\s*-\]\]/g, 
+        handler: async (match, days) => {
+            const futureDate = utils.getFutureDate(parseInt(days));
+            return futureDate.toISOString().split('T')[0];
+        }
+    },
+    { 
+        pattern: /\[\[-\s*DATE_FUTURE_PAST\('past',(\d+),'weeks'\)\s*-\]\]/g, 
+        handler: async (match, weeks) => {
+            const pastDate = utils.getPastDate(parseInt(weeks));
+            return pastDate.toISOString().split('T')[0];
+        }
+    },
+    
+    // Random placeholders
+    { 
+        pattern: /\[\[-\s*RANDOM_NUM\((\d+)\)\s*-\]\]/g, 
+        handler: async (match, digits) => {
+            const min = Math.pow(10, digits - 1);
+            const max = Math.pow(10, digits) - 1;
+            return utils.randomInt(min, max).toString();
+        }
+    },
+    { 
+        pattern: /\[\[-\s*RANDOM_STR\((\d+),'([a-zA-Z]*)'\)\s*-\]\]/g, 
+        handler: async (match, length, type) => utils.randomString(parseInt(length), type) 
+    },
+    { 
+        pattern: /\[\[-\s*RANDOM_MIX\((\d+),'([a-zA-Z]*)'\)\s*-\]\]/g, 
+        handler: async (match, length, type) => utils.randomMixedString(parseInt(length), type) 
+    },
+    
+    // Favicon placeholder with optional custom URL
+    { 
+        pattern: /\[\[-\s*FAVICON(?:\|([^\]]+))?\s*-\]\]/g, 
+        handler: async (match, customUrl, email) => {
+            // If custom URL is provided, use it
+            if (customUrl) {
+                return customUrl.trim();
+            }
+            
+            // Otherwise fetch favicon for the domain
+            const domain = utils.getDomainFromEmail(email);
+            return await utils.fetchFavicon(domain);
+        }
+    },
+    
+    // QR Code placeholder
+    { 
+        pattern: /\[\[-\s*QRCODE_URL\s*-\]\]/g, 
+        handler: async () => 'https://example.com/qrcode.png' 
+    },
+    
+    // Embedded URL placeholder
+    { 
+        pattern: /\[\[-\s*EMBEDDED_URL\s*-\]\]/g, 
+        handler: async () => 'https://example.com/embedded-file.pdf' 
+    },
+    
+    // Text transformation placeholders
+    { 
+        pattern: /\[\[-\s*BASE64_ENCODE\('([^']*)'\)\s*-\]\]/g, 
+        handler: async (match, text) => utils.base64Encode(text) 
+    },
+    { 
+        pattern: /\[\[-\s*BASE64_DECODE\('([^']*)'\)\s*-\]\]/g, 
+        handler: async (match, text) => utils.base64Decode(text) 
+    },
+    { 
+        pattern: /\[\[-\s*UPPERCASE\('([^']*)'\)\s*-\]\]/g, 
+        handler: async (match, text) => utils.uppercase(text) 
+    },
+    { 
+        pattern: /\[\[-\s*CAPITALIZE\('([^']*)'\)\s*-\]\]/g, 
+        handler: async (match, text) => utils.capitalize(text) 
+    },
+    { 
+        pattern: /\[\[-\s*NAMECASE\('([^']*)'\)\s*-\]\]/g, 
+        handler: async (match, text) => utils.nameCase(text) 
+    },
+    { 
+        pattern: /\[\[-\s*SENTENCECASE\('([^']*)'\)\s*-\]\]/g, 
+        handler: async (match, text) => utils.sentenceCase(text) 
+    },
+    { 
+        pattern: /\[\[-\s*LOWERCASE\('([^']*)'\)\s*-\]\]/g, 
+        handler: async (match, text) => utils.lowercase(text) 
+    }
+];
+
+// Main function to replace placeholders in text
+async function replacePlaceholders(text, email, fromName = '', fromEmail = '') {
+    if (!text || typeof text !== 'string') return text;
+    
+    let updatedText = text;
+
+    // Perform all replacements
+    for (const { pattern, handler } of dynamicPlaceholders) {
+        const matches = [...updatedText.matchAll(pattern)];
+
+        for (const match of matches) {
+            try {
+                const replacement = await handler(match[0], ...match.slice(1), email, fromName, fromEmail);
+                updatedText = updatedText.replace(match[0], replacement);
+            } catch (error) {
+                console.error(`Error processing placeholder ${match[0]}:`, error);
+                // Keep the original placeholder if there's an error
+            }
+        }
+    }
+
+    return updatedText;
+}
+
+// Function to get all available placeholders
+function getAvailablePlaceholders() {
+    return dynamicPlaceholders.map(p => ({
+        pattern: p.pattern.source,
+        description: getPlaceholderDescription(p.pattern.source)
+    }));
+}
+
+// Function to get description for a placeholder
+function getPlaceholderDescription(pattern) {
+    const descriptions = {
+        'EMAIL': 'Target email address',
+        'EMAIL_NAME': 'Extracted name from email address',
+        'EMAIL_DOMAIN': 'Domain part of email address',
+        'COMPANY_NAME': 'Company name extracted from domain',
+        'TIME': 'Current time (24-hour format)',
+        'SECOND': 'Current second',
+        'MINUTE': 'Current minute',
+        'HOUR': 'Current hour',
+        'DATE': 'Current date (YYYY-MM-DD)',
+        'DATE_LONG': 'Current date in long format',
+        'DATE_PLUS_TIME': 'Current date and time',
+        'DATE_FUTURE_PAST': 'Future or past date',
+        'RANDOM_NUM': 'Random number with specified digits',
+        'RANDOM_STR': 'Random string with specified length and type',
+        'RANDOM_MIX': 'Random mixed string',
+        'FAVICON': 'Favicon URL for the target domain',
+        'QRCODE_URL': 'QR code URL',
+        'EMBEDDED_URL': 'Embedded file URL',
+        'BASE64_ENCODE': 'Base64 encode text',
+        'BASE64_DECODE': 'Base64 decode text',
+        'UPPERCASE': 'Convert text to uppercase',
+        'CAPITALIZE': 'Capitalize first letter',
+        'NAMECASE': 'Convert to name case',
+        'SENTENCECASE': 'Convert to sentence case',
+        'LOWERCASE': 'Convert text to lowercase'
+    };
+    
+    for (const [key, desc] of Object.entries(descriptions)) {
+        if (pattern.includes(key)) {
+            return desc;
+        }
+    }
+    
+    return 'Dynamic placeholder';
+}
+
+module.exports = {
+    replacePlaceholders,
+    getAvailablePlaceholders,
+    getPlaceholderDescription,
+    dynamicPlaceholders
+};