nolimit-x 1.0.0

package/bin/nolimit

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../src/cli");

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "nolimit-x",
+  "version": "1.0.0",
+  "description": "Advanced email sender for red team operations",
+  "main": "src/cli.js",
+  "bin": {
+    "nolimit": "./src/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["email", "sender", "red-team", "smtp"],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^11.0.0"
+  }
+}

package/src/attachment-handler.js

@@ -0,0 +1,253 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const MessageEncryption = require('./encryption');
+
+class AttachmentHandler {
+    constructor() {
+        this.encryption = new MessageEncryption();
+    }
+
+    // Process attachment based on configuration
+    async processAttachment(attachmentConfig, messageContent = '') {
+        try {
+            if (!attachmentConfig.active) {
+                return null;
+            }
+
+            let content = '';
+            let filename = attachmentConfig.filename;
+
+            // Read attachment content
+            if (fs.existsSync(attachmentConfig.path)) {
+                content = fs.readFileSync(attachmentConfig.path, 'utf8');
+            } else {
+                console.warn(`Attachment file not found: ${attachmentConfig.path}`);
+                return null;
+            }
+
+            // Process filename placeholders
+            filename = await this.processFilenamePlaceholders(filename);
+
+            // Apply obfuscation if enabled
+            if (attachmentConfig.obfuscate) {
+                content = this.obfuscateContent(content);
+            }
+
+            // Apply encryption if enabled
+            if (attachmentConfig.encrypted) {
+                const encryptedAttachment = this.encryption.createEncryptedAttachment(content, filename);
+                if (encryptedAttachment) {
+                    return {
+                        filename: encryptedAttachment.filename,
+                        content: encryptedAttachment.content,
+                        contentType: 'application/octet-stream',
+                        encrypted: true,
+                        metadata: encryptedAttachment.metadata
+                    };
+                }
+            }
+
+            // Apply scripter if enabled
+            if (attachmentConfig.scripter) {
+                content = this.addScriptingCapabilities(content);
+            }
+
+            // Determine content type
+            const contentType = this.getContentType(filename);
+
+            return {
+                filename: filename,
+                content: content,
+                contentType: contentType,
+                encrypted: false
+            };
+
+        } catch (error) {
+            console.error(`Failed to process attachment ${attachmentConfig.filename}:`, error.message);
+            return null;
+        }
+    }
+
+    // Process filename placeholders
+    async processFilenamePlaceholders(filename) {
+        // Replace RANDOM_NUM placeholders
+        filename = filename.replace(/\[\[-RANDOM_NUM\((\d+)\)-\]\]/g, (match, digits) => {
+            const min = Math.pow(10, digits - 1);
+            const max = Math.pow(10, digits) - 1;
+            return Math.floor(Math.random() * (max - min + 1)) + min;
+        });
+
+        // Replace RANDOM_STR placeholders
+        filename = filename.replace(/\[\[-RANDOM_STR\((\d+),'([a-zA-Z]*)'\)-\]\]/g, (match, length, type) => {
+            return this.generateRandomString(parseInt(length), type);
+        });
+
+        return filename;
+    }
+
+    // Generate random string
+    generateRandomString(length, type = '') {
+        let characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        
+        if (type === 'alpha') {
+            characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        } else if (type === 'numeric') {
+            characters = '0123456789';
+        } else if (type === 'uppercase') {
+            characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        } else if (type === 'lowercase') {
+            characters = 'abcdefghijklmnopqrstuvwxyz';
+        }
+        
+        let result = '';
+        const charactersLength = characters.length;
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        }
+        return result;
+    }
+
+    // Obfuscate content
+    obfuscateContent(content) {
+        // Simple obfuscation techniques
+        let obfuscated = content;
+        
+        // Replace common words with similar looking characters
+        const obfuscationMap = {
+            'a': '@',
+            'e': '3',
+            'i': '1',
+            'o': '0',
+            's': '$',
+            't': '7'
+        };
+
+        // Apply character substitution
+        for (const [original, replacement] of Object.entries(obfuscationMap)) {
+            obfuscated = obfuscated.replace(new RegExp(original, 'gi'), replacement);
+        }
+
+        // Add random whitespace
+        obfuscated = obfuscated.replace(/\s+/g, ' ').trim();
+
+        return obfuscated;
+    }
+
+    // Add scripting capabilities
+    addScriptingCapabilities(content) {
+        // Add JavaScript execution capabilities
+        const scriptWrapper = `
+<script>
+// Auto-execute on load
+(function() {
+    try {
+        // Add any custom scripting here
+        console.log('Script executed successfully');
+        
+        // Example: Track opening
+        if (typeof window !== 'undefined') {
+            window.addEventListener('load', function() {
+                // Track that the attachment was opened
+                console.log('Attachment opened at:', new Date().toISOString());
+            });
+        }
+    } catch (error) {
+        console.error('Script execution failed:', error);
+    }
+})();
+</script>
+${content}`;
+
+        return scriptWrapper;
+    }
+
+    // Get content type based on file extension
+    getContentType(filename) {
+        const ext = path.extname(filename).toLowerCase();
+        
+        const mimeTypes = {
+            '.html': 'text/html',
+            '.htm': 'text/html',
+            '.txt': 'text/plain',
+            '.pdf': 'application/pdf',
+            '.doc': 'application/msword',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            '.rtf': 'application/rtf',
+            '.epub': 'application/epub+zip',
+            '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            '.svg': 'image/svg+xml',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.zip': 'application/zip',
+            '.rar': 'application/x-rar-compressed',
+            '.7z': 'application/x-7z-compressed'
+        };
+
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+
+    // Create EML attachment
+    createEMLAttachment(fromEmail, toEmail, subject, messageContent, attachmentName = 'message.eml') {
+        const emlContent = `From: ${fromEmail}
+To: ${toEmail}
+Subject: ${subject}
+Date: ${new Date().toUTCString()}
+MIME-Version: 1.0
+Content-Type: text/html; charset=UTF-8
+
+${messageContent}`;
+
+        return {
+            filename: attachmentName,
+            content: emlContent,
+            contentType: 'message/rfc822'
+        };
+    }
+
+    // Validate attachment configuration
+    validateAttachmentConfig(attachmentConfig) {
+        const requiredFields = ['filename', 'path', 'active'];
+        
+        for (const field of requiredFields) {
+            if (!(field in attachmentConfig)) {
+                console.error(`Missing required field in attachment config: ${field}`);
+                return false;
+            }
+        }
+
+        if (attachmentConfig.active && !fs.existsSync(attachmentConfig.path)) {
+            console.warn(`Active attachment file not found: ${attachmentConfig.path}`);
+            return false;
+        }
+
+        return true;
+    }
+
+    // Get attachment statistics
+    getAttachmentStats(attachments) {
+        const stats = {
+            total: attachments.length,
+            active: 0,
+            encrypted: 0,
+            obfuscated: 0,
+            scripted: 0,
+            valid: 0
+        };
+
+        for (const attachment of attachments) {
+            if (attachment.active) stats.active++;
+            if (attachment.encrypted) stats.encrypted++;
+            if (attachment.obfuscate) stats.obfuscated++;
+            if (attachment.scripter) stats.scripted++;
+            if (this.validateAttachmentConfig(attachment)) stats.valid++;
+        }
+
+        return stats;
+    }
+}
+
+module.exports = AttachmentHandler; 

package/src/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+const { Command } = require("commander");
+const init = require("./init");
+const { send } = require("./sender");
+
+const program = new Command();
+
+program
+  .name("nolimit")
+  .version("1.0.0")
+  .description("Advanced email sender for red team operations");
+
+program
+  .command("init")
+  .argument("<projectName>", "Name of the project to create")
+  .description("Initialize a new email campaign project")
+  .action((projectName) => {
+    console.log("Init command called with:", projectName);
+    init(projectName);
+  });
+
+program
+  .command("send")
+  .description("Send emails using current configuration")
+  .option("-c, --config <path>", "Config file path", "templates/config.json")
+  .action((options) => {
+    console.log("Send command called with options:", options);
+    send(options);
+  });
+
+program.parse();

package/src/document-generator.js

@@ -0,0 +1,275 @@
+const fs = require('fs');
+const path = require('path');
+const puppeteer = require('puppeteer');
+const { execSync } = require('child_process');
+
+class DocumentGenerator {
+    constructor() {
+        this.browser = null;
+    }
+
+    // Initialize browser for PDF generation
+    async initBrowser() {
+        if (!this.browser) {
+            this.browser = await puppeteer.launch({
+                headless: true,
+                args: ['--no-sandbox', '--disable-setuid-sandbox']
+            });
+        }
+        return this.browser;
+    }
+
+    // Close browser
+    async closeBrowser() {
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+        }
+    }
+
+    // Convert HTML to PDF
+    async htmlToPdf(htmlContent, options = {}) {
+        try {
+            const browser = await this.initBrowser();
+            const page = await browser.newPage();
+            
+            // Set content
+            await page.setContent(htmlContent, { waitUntil: 'networkidle0' });
+            
+            // PDF options
+            const pdfOptions = {
+                format: options.format || 'A4',
+                printBackground: true,
+                margin: {
+                    top: options.marginTop || '1cm',
+                    right: options.marginRight || '1cm',
+                    bottom: options.marginBottom || '1cm',
+                    left: options.marginLeft || '1cm'
+                },
+                ...options
+            };
+            
+            const pdfBuffer = await page.pdf(pdfOptions);
+            await page.close();
+            
+            return pdfBuffer;
+        } catch (error) {
+            console.error('PDF generation failed:', error.message);
+            return null;
+        }
+    }
+
+    // Convert HTML to DOC/DOCX using pandoc
+    async htmlToDoc(htmlContent, format = 'docx', options = {}) {
+        try {
+            // Create temporary HTML file
+            const tempHtmlPath = path.join(process.cwd(), 'temp_message.html');
+            fs.writeFileSync(tempHtmlPath, htmlContent);
+            
+            // Create output filename
+            const outputPath = path.join(process.cwd(), `temp_output.${format}`);
+            
+            // Build pandoc command
+            let command = `pandoc "${tempHtmlPath}" -o "${outputPath}"`;
+            
+            // Add format-specific options
+            if (format === 'docx') {
+                command += ' --reference-doc=template.docx' // if template exists
+            } else if (format === 'rtf') {
+                command += ' --standalone'
+            }
+            
+            // Execute pandoc
+            execSync(command, { stdio: 'pipe' });
+            
+            // Read the generated file
+            const docBuffer = fs.readFileSync(outputPath);
+            
+            // Cleanup temporary files
+            fs.unlinkSync(tempHtmlPath);
+            fs.unlinkSync(outputPath);
+            
+            return docBuffer;
+        } catch (error) {
+            console.error(`${format.toUpperCase()} generation failed:`, error.message);
+            return null;
+        }
+    }
+
+    // Convert HTML to EPUB
+    async htmlToEpub(htmlContent, metadata = {}) {
+        try {
+            // Create EPUB structure
+            const epubContent = this.createEpubStructure(htmlContent, metadata);
+            
+            // For now, return a simple EPUB-like structure
+            // In a full implementation, you'd use a proper EPUB library
+            return Buffer.from(epubContent, 'utf8');
+        } catch (error) {
+            console.error('EPUB generation failed:', error.message);
+            return null;
+        }
+    }
+
+    // Create EPUB structure
+    createEpubStructure(htmlContent, metadata) {
+        const title = metadata.title || 'Document';
+        const author = metadata.author || 'NoLimit';
+        const publisher = metadata.publisher || 'HTML to EPUB Converter';
+        
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="uid">
+    <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
+        <dc:title>${title}</dc:title>
+        <dc:creator>${author}</dc:creator>
+        <dc:publisher>${publisher}</dc:publisher>
+        <dc:language>en</dc:language>
+        <dc:identifier id="uid">urn:uuid:${this.generateUUID()}</dc:identifier>
+    </metadata>
+    <manifest>
+        <item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>
+        <item id="content" href="content.xhtml" media-type="application/xhtml+xml"/>
+    </manifest>
+    <spine>
+        <itemref idref="nav"/>
+        <itemref idref="content"/>
+    </spine>
+</package>
+
+<!-- content.xhtml -->
+<?xml version="1.0" encoding="UTF-8"?>
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+    <title>${title}</title>
+</head>
+<body>
+    ${htmlContent}
+</body>
+</html>`;
+    }
+
+    // Convert HTML to XLSX (simple table extraction)
+    async htmlToXlsx(htmlContent) {
+        try {
+            // Extract tables from HTML and convert to XLSX format
+            // This is a simplified implementation
+            const xlsxContent = this.extractTablesToXlsx(htmlContent);
+            return Buffer.from(xlsxContent, 'utf8');
+        } catch (error) {
+            console.error('XLSX generation failed:', error.message);
+            return null;
+        }
+    }
+
+    // Extract tables from HTML
+    extractTablesToXlsx(htmlContent) {
+        // Simple table extraction - in a real implementation, you'd use a proper library
+        const tableRegex = /<table[^>]*>([\s\S]*?)<\/table>/gi;
+        const tables = [];
+        let match;
+        
+        while ((match = tableRegex.exec(htmlContent)) !== null) {
+            tables.push(match[1]);
+        }
+        
+        // Convert to CSV-like format (simplified XLSX)
+        let xlsxContent = '<?xml version="1.0" encoding="UTF-8"?>\n';
+        xlsxContent += '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">\n';
+        xlsxContent += '<sheets>\n';
+        xlsxContent += '<sheet name="Sheet1" sheetId="1" r:id="rId1"/>\n';
+        xlsxContent += '</sheets>\n';
+        xlsxContent += '</workbook>\n';
+        
+        return xlsxContent;
+    }
+
+    // Convert HTML to PPTX (simple slide generation)
+    async htmlToPptx(htmlContent, metadata = {}) {
+        try {
+            const title = metadata.title || 'Document';
+            const author = metadata.author || 'NoLimit';
+            
+            // Create simple PPTX structure
+            const pptxContent = this.createPptxStructure(htmlContent, title, author);
+            return Buffer.from(pptxContent, 'utf8');
+        } catch (error) {
+            console.error('PPTX generation failed:', error.message);
+            return null;
+        }
+    }
+
+    // Create PPTX structure
+    createPptxStructure(htmlContent, title, author) {
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<p:presentation xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+    <p:sldMasters>
+        <p:sldMaster>
+            <p:cSld>
+                <p:spTree>
+                    <p:sp>
+                        <p:txBody>
+                            <a:p>
+                                <a:r>
+                                    <a:t>${title}</a:t>
+                                </a:r>
+                            </a:p>
+                        </p:txBody>
+                    </p:sp>
+                </p:spTree>
+            </p:cSld>
+        </p:sldMaster>
+    </p:sldMasters>
+    <p:sldIdLst>
+        <p:sld>
+            <p:cSld>
+                <p:spTree>
+                    <p:sp>
+                        <p:txBody>
+                            <a:p>
+                                <a:r>
+                                    <a:t>${htmlContent.replace(/<[^>]*>/g, '')}</a:t>
+                                </a:r>
+                            </a:p>
+                        </p:txBody>
+                    </p:sp>
+                </p:spTree>
+            </p:cSld>
+        </p:sld>
+    </p:sldIdLst>
+</p:presentation>`;
+    }
+
+    // Generate UUID for EPUB
+    generateUUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+
+    // Check if pandoc is available
+    isPandocAvailable() {
+        try {
+            execSync('pandoc --version', { stdio: 'pipe' });
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    // Get supported formats
+    getSupportedFormats() {
+        const formats = ['pdf'];
+        
+        if (this.isPandocAvailable()) {
+            formats.push('docx', 'doc', 'rtf');
+        }
+        
+        formats.push('epub', 'xlsx', 'pptx');
+        
+        return formats;
+    }
+}
+
+module.exports = DocumentGenerator;