npm - nolimit-x - Versions diffs - 1.0.0 - Mend

nolimit-x 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/bin/nolimit +3 -0
package/package.json +18 -0
package/src/attachment-handler.js +253 -0
package/src/cli.js +31 -0
package/src/document-generator.js +275 -0
package/src/encryption.js +125 -0
package/src/init.js +79 -0
package/src/multi-handler.js +184 -0
package/src/obfuscator.js +350 -0
package/src/placeholders.js +230 -0
package/src/processor.js +542 -0
package/src/qr-generator.js +222 -0
package/src/sender.js +41 -0
package/src/utils.js +374 -0
package/templates/config.json +54 -0
package/templates/emails.txt +3 -0
package/templates/messages.html +5 -0
package/templates/senders.txt +3 -0
package/test-campaign/config.json +35 -0
package/test-campaign/emails.txt +3 -0
package/test-campaign/messages.html +5 -0
package/test-campaign/senders.txt +3 -0
package/test-raw-smtp/config.json +56 -0
package/test-raw-smtp/emails.txt +7 -0
package/test-raw-smtp/messages.html +5 -0
package/test-raw-smtp/senders.txt +7 -0

package/src/encryption.js ADDED Viewed

@@ -0,0 +1,125 @@
+const crypto = require('crypto');
+class MessageEncryption {
+    constructor() {
+        this.algorithm = 'aes-256-cbc';
+        this.keyLength = 32;
+        this.ivLength = 16;
+    }
+    // Generate a random encryption key
+    generateKey() {
+        return crypto.randomBytes(this.keyLength);
+    }
+    // Generate a random IV
+    generateIV() {
+        return crypto.randomBytes(this.ivLength);
+    }
+    // Encrypt message content
+    encryptMessage(message, key = null) {
+        try {
+            const encryptionKey = key || this.generateKey();
+            const iv = this.generateIV();
+            const cipher = crypto.createCipheriv(this.algorithm, encryptionKey, iv);
+            let encrypted = cipher.update(message, 'utf8', 'hex');
+            encrypted += cipher.final('hex');
+            return {
+                encrypted: encrypted,
+                key: encryptionKey.toString('hex'),
+                iv: iv.toString('hex'),
+                algorithm: this.algorithm
+            };
+        } catch (error) {
+            console.error('Encryption failed:', error.message);
+            return null;
+        }
+    }
+    // Decrypt message content
+    decryptMessage(encryptedData) {
+        try {
+            const { encrypted, key, iv, algorithm } = encryptedData;
+            const decipher = crypto.createDecipheriv(algorithm, Buffer.from(key, 'hex'), Buffer.from(iv, 'hex'));
+            let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+            decrypted += decipher.final('utf8');
+            return decrypted;
+        } catch (error) {
+            console.error('Decryption failed:', error.message);
+            return null;
+        }
+    }
+    // Encrypt file content
+    encryptFile(fileContent, key = null) {
+        return this.encryptMessage(fileContent, key);
+    }
+    // Generate encrypted attachment wrapper
+    createEncryptedAttachment(originalContent, filename) {
+        const encrypted = this.encryptMessage(originalContent);
+        if (!encrypted) return null;
+        return {
+            filename: `${filename}.encrypted`,
+            content: encrypted.encrypted,
+            metadata: {
+                originalName: filename,
+                key: encrypted.key,
+                iv: encrypted.iv,
+                algorithm: encrypted.algorithm
+            }
+        };
+    }
+    // Create self-decrypting HTML wrapper
+    createSelfDecryptingWrapper(encryptedData, originalFilename) {
+        const { encrypted, key, iv, algorithm } = encryptedData;
+        return `
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Encrypted Message - ${originalFilename}</title>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js"></script>
+</head>
+<body>
+    <div id="encrypted-content" style="display:none;">${encrypted}</div>
+    <div id="decrypted-content"></div>
+    <script>
+        function decryptContent() {
+            try {
+                const encrypted = document.getElementById('encrypted-content').textContent;
+                const key = '${key}';
+                const iv = '${iv}';
+                const decrypted = CryptoJS.AES.decrypt(encrypted, key, {
+                    iv: CryptoJS.enc.Hex.parse(iv),
+                    mode: CryptoJS.mode.CBC,
+                    padding: CryptoJS.pad.Pkcs7
+                });
+                const decryptedText = decrypted.toString(CryptoJS.enc.Utf8);
+                document.getElementById('decrypted-content').innerHTML = decryptedText;
+            } catch (error) {
+                document.getElementById('decrypted-content').innerHTML =
+                    '<p style="color: red;">Decryption failed. Please contact the sender.</p>';
+            }
+        }
+        // Auto-decrypt on page load
+        window.onload = decryptContent;
+    </script>
+</body>
+</html>`;
+    }
+}
+module.exports = MessageEncryption;

package/src/init.js ADDED Viewed

@@ -0,0 +1,79 @@
+const fs = require("fs");
+const path = require("path");
+function printBanner() {
+  console.log(`\n\x1b[36m` +
+` _   _       _ _     _ _     _   \n| \ | | ___ | | | __| (_)___| |_ \n|  \| |/ _ \| | |/ _ | / __| __|\n| |\  | (_) | | | (_| | \__ \ |_ \n|_| \_|\___/|_|_|\__,_|_|___/\__|\n` + '\x1b[0m');
+}
+function copyTemplate(src, dest) {
+  try {
+    const srcPath = path.join(__dirname, "../templates", src);
+    const destPath = path.join(dest, src);
+    console.log(`Copying from ${srcPath} to ${destPath}`);
+    fs.copyFileSync(srcPath, destPath);
+  } catch (err) {
+    console.error(`Failed to copy template ${src}:`, err);
+    throw err;
+  }
+}
+function fixConfigPaths(configPath, workspace) {
+  // Read config, update all file paths to be relative to workspace
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  if (config.emails_list) config.emails_list.path = "emails.txt";
+  if (config.senders_list) config.senders_list.path = "senders.txt";
+  if (config.messages_body) config.messages_body.path = "messages.html";
+  if (Array.isArray(config.attachments)) {
+    config.attachments.forEach(att => {
+      if (att.path) att.path = path.join("attachments", path.basename(att.path));
+    });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+async function init(projectName) {
+  printBanner();
+  process.stdout.write('Setting up workspace...');
+  const projectPath = path.resolve(process.cwd(), projectName);
+  console.log("Project path:", projectPath);
+  if (fs.existsSync(projectPath)) {
+    console.error(`\nDirectory ${projectName} already exists.`);
+    process.exit(1);
+  }
+  try {
+    fs.mkdirSync(projectPath);
+    console.log("Created directory:", projectPath);
+    // Create attachments dir if needed
+    const attachmentsDir = path.join(projectPath, "attachments");
+    if (!fs.existsSync(attachmentsDir)) fs.mkdirSync(attachmentsDir);
+    ["config.json", "emails.txt", "senders.txt", "messages.html"].forEach(file => {
+      copyTemplate(file, projectPath);
+      console.log("Copied template:", file);
+    });
+    // Fix config paths
+    fixConfigPaths(path.join(projectPath, "config.json"), projectPath);
+    // Simulate progress
+    await new Promise(res => setTimeout(res, 800));
+    process.stdout.clearLine();
+    process.stdout.cursorTo(0);
+    console.log("\x1b[32mWorkspace ready!\x1b[0m\n");
+    console.log("Template files created:");
+    ["config.json", "emails.txt", "senders.txt", "messages.html"].forEach(file => {
+      console.log(`  - ${file}`);
+    });
+    console.log("  - attachments/ (directory)");
+    console.log(`\nInitialized new campaign in ${projectPath}`);
+  } catch (error) {
+    console.error("Error during initialization:", error);
+    process.exit(1);
+  }
+}
+module.exports = init;

package/src/multi-handler.js ADDED Viewed

@@ -0,0 +1,184 @@
+const fs = require('fs');
+const utils = require('./utils');
+class MultiHandler {
+    constructor() {
+        this.senders = [];
+        this.subjects = [];
+        this.fromNames = [];
+        this.links = [];
+        this.currentIndexes = {
+            sender: 0,
+            subject: 0,
+            fromName: 0,
+            link: 0
+        };
+    }
+    // Load multiple senders from file
+    loadSenders(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                console.warn(`Senders file not found: ${filePath}`);
+                return false;
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            this.senders = content.split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#') && utils.isValidEmail(line));
+            console.log(`Loaded ${this.senders.length} senders from ${filePath}`);
+            return true;
+        } catch (error) {
+            console.error(`Failed to load senders: ${error.message}`);
+            return false;
+        }
+    }
+    // Load multiple subjects from file
+    loadSubjects(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                console.warn(`Subjects file not found: ${filePath}`);
+                return false;
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            this.subjects = content.split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#'));
+            console.log(`Loaded ${this.subjects.length} subjects from ${filePath}`);
+            return true;
+        } catch (error) {
+            console.error(`Failed to load subjects: ${error.message}`);
+            return false;
+        }
+    }
+    // Load multiple from names from file
+    loadFromNames(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                console.warn(`From names file not found: ${filePath}`);
+                return false;
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            this.fromNames = content.split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#'));
+            console.log(`Loaded ${this.fromNames.length} from names from ${filePath}`);
+            return true;
+        } catch (error) {
+            console.error(`Failed to load from names: ${error.message}`);
+            return false;
+        }
+    }
+    // Load multiple links from file
+    loadLinks(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                console.warn(`Links file not found: ${filePath}`);
+                return false;
+            }
+            const content = fs.readFileSync(filePath, 'utf8');
+            this.links = content.split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#'));
+            console.log(`Loaded ${this.links.length} links from ${filePath}`);
+            return true;
+        } catch (error) {
+            console.error(`Failed to load links: ${error.message}`);
+            return false;
+        }
+    }
+    // Get next sender (round-robin)
+    getNextSender() {
+        if (this.senders.length === 0) return null;
+        const sender = this.senders[this.currentIndexes.sender];
+        this.currentIndexes.sender = (this.currentIndexes.sender + 1) % this.senders.length;
+        return sender;
+    }
+    // Get next subject (round-robin)
+    getNextSubject() {
+        if (this.subjects.length === 0) return null;
+        const subject = this.subjects[this.currentIndexes.subject];
+        this.currentIndexes.subject = (this.currentIndexes.subject + 1) % this.subjects.length;
+        return subject;
+    }
+    // Get next from name (round-robin)
+    getNextFromName() {
+        if (this.fromNames.length === 0) return null;
+        const fromName = this.fromNames[this.currentIndexes.fromName];
+        this.currentIndexes.fromName = (this.currentIndexes.fromName + 1) % this.fromNames.length;
+        return fromName;
+    }
+    // Get next link (round-robin)
+    getNextLink() {
+        if (this.links.length === 0) return null;
+        const link = this.links[this.currentIndexes.link];
+        this.currentIndexes.link = (this.currentIndexes.link + 1) % this.links.length;
+        return link;
+    }
+    // Get random sender
+    getRandomSender() {
+        if (this.senders.length === 0) return null;
+        return this.senders[Math.floor(Math.random() * this.senders.length)];
+    }
+    // Get random subject
+    getRandomSubject() {
+        if (this.subjects.length === 0) return null;
+        return this.subjects[Math.floor(Math.random() * this.subjects.length)];
+    }
+    // Get random from name
+    getRandomFromName() {
+        if (this.fromNames.length === 0) return null;
+        return this.fromNames[Math.floor(Math.random() * this.fromNames.length)];
+    }
+    // Get random link
+    getRandomLink() {
+        if (this.links.length === 0) return null;
+        return this.links[Math.floor(Math.random() * this.links.length)];
+    }
+    // Reset all indexes
+    resetIndexes() {
+        this.currentIndexes = {
+            sender: 0,
+            subject: 0,
+            fromName: 0,
+            link: 0
+        };
+    }
+    // Get statistics
+    getStats() {
+        return {
+            senders: this.senders.length,
+            subjects: this.subjects.length,
+            fromNames: this.fromNames.length,
+            links: this.links.length,
+            currentIndexes: { ...this.currentIndexes }
+        };
+    }
+}
+module.exports = MultiHandler;