Domain Varyasyon ve Durum Kontrol Aracı

import socket
import whois
import pyfiglet
import csv
import json
import ssl
import time
import argparse
import os
from concurrent.futures import ThreadPoolExecutor
from tenacity import retry, stop_after_attempt
from tqdm import tqdm
from colorama import init, Fore
import dns.resolver
import asyncio
import aiohttp
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

init(autoreset=True)

socket.setdefaulttimeout(10)

LEET_MAP = {
    'o': '0',
    'i': '1',
    'l': '1',
    's': '5'
}

TLD_LIST = ['.com.tr', '.com', '.net', '.tr']

dns_cache = {}
whois_cache = {}

def load_common_typos(file_path="common_typos.txt"):
    typos = set()
    if os.path.exists(file_path):
        with open(file_path, "r") as f:
            for line in f:
                typo = line.strip()
                if typo:
                    typos.add(typo)
    return typos

def apply_leetspeak(domain):
    for tld in TLD_LIST:
        if domain.endswith(tld):
            name = domain[:-len(tld)]
            ext = tld
            break
    else:
        name = domain
        ext = ""
    new_name = name
    for char, replacement in LEET_MAP.items():
        new_name = new_name.replace(char, replacement)
    return new_name + ext

def generate_variations(domain):
    variations = set()
    variations.add(domain)
    if '.' in domain:
        name, tld = domain.rsplit('.', 1)
        base_tld = '.' + tld
    else:
        name = domain
        base_tld = ''
    if len(name) > 1:
        variations.add(name[1:] + base_tld)
        variations.add(name[:-1] + base_tld)
    for i in range(1, len(name)):
        lst = list(name)
        lst[i - 1], lst[i] = lst[i], lst[i - 1]
        variations.add("".join(lst) + base_tld)
    if len(name) > 3:
        mid = len(name) // 2
        variations.add(name[:mid] + '-' + name[mid:] + base_tld)
    common_typos = load_common_typos()
    for typo in common_typos:
        if name in typo or typo in name:
            variations.add(typo + base_tld)
    for tld_variant in TLD_LIST:
        variations.add(name + tld_variant)
    leet_variations = set()
    for var in list(variations):
        leet_var = apply_leetspeak(var)
        if leet_var != var:
            leet_variations.add(leet_var)
    variations.update(leet_variations)
    return list(variations)

@retry(stop=stop_after_attempt(3))
def check_whois(domain):
    if domain in whois_cache:
        return whois_cache[domain]
    try:
        w = whois.whois(domain)
        whois_cache[domain] = w
        return w
    except Exception:
        whois_cache[domain] = None
        return None

@retry(stop=stop_after_attempt(3))
def check_dns(domain):
    if domain in dns_cache:
        return dns_cache[domain]
    result = {}
    try:
        ip = socket.gethostbyname(domain)
        result['A'] = ip
    except Exception:
        result['A'] = None
    try:
        answers = dns.resolver.resolve(domain, 'MX')
        result['MX'] = [r.exchange.to_text() for r in answers]
    except Exception:
        result['MX'] = []
    try:
        answers = dns.resolver.resolve(domain, 'NS')
        result['NS'] = [r.target.to_text() for r in answers]
    except Exception:
        result['NS'] = []
    try:
        answers = dns.resolver.resolve(domain, 'TXT')
        result['TXT'] = [r.to_text() for r in answers]
    except Exception:
        result['TXT'] = []
    dns_cache[domain] = result
    return result

def check_ssl_certificate(domain):
    context = ssl.create_default_context()
    try:
        with socket.create_connection((domain, 443)) as sock:
            with context.wrap_socket(sock, server_hostname=domain) as ssock:
                cert = ssock.getpeercert()
                return cert.get('notAfter', None)
    except Exception:
        return None

def take_screenshot(domain):
    try:
        from selenium.webdriver.chrome.service import Service as ChromeService
        from webdriver_manager.chrome import ChromeDriverManager
        chrome_options = Options()
        chrome_options.add_argument("--headless")
        chrome_options.add_argument("--no-sandbox")
        driver = webdriver.Chrome(service=ChromeService(ChromeDriverManager().install()), options=chrome_options)
        url = "http://" + domain
        driver.get(url)
        screenshot_path = f"{domain.replace('.', '_')}.png"
        driver.save_screenshot(screenshot_path)
        driver.quit()
        return screenshot_path
    except Exception:
        return None

def check_phishing(domain):
    return False

def check_domain(domain):
    time.sleep(1)
    result = {"domain": domain}
    dns_result = check_dns(domain)
    result['dns'] = dns_result
    whois_result = check_whois(domain)
    result['whois'] = whois_result
    result['ssl'] = check_ssl_certificate(domain)
    result['phishing'] = check_phishing(domain)
    result['screenshot'] = take_screenshot(domain)
    is_taken = False
    if dns_result.get('A'):
        is_taken = True
    elif whois_result and (
         (isinstance(whois_result, dict) and whois_result.get('domain_name')) or
         (hasattr(whois_result, 'domain_name') and whois_result.domain_name)
    ):
        is_taken = True
    result['taken'] = is_taken
    return result

def export_to_csv(results, filename="results.csv"):
    with open(filename, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["Domain", "Taken", "IP", "MX", "NS", "TXT", "SSL Expiry", "Phishing", "Screenshot"])
        for res in results:
            writer.writerow([
                res['domain'],
                res['taken'],
                res['dns'].get('A'),
                ";".join(res['dns'].get('MX', [])),
                ";".join(res['dns'].get('NS', [])),
                ";".join(res['dns'].get('TXT', [])),
                res['ssl'],
                res['phishing'],
                res['screenshot'] if res['screenshot'] else ""
            ])

def export_to_json(results, filename="results.json"):
    with open(filename, "w") as f:
        json.dump(results, f, indent=4, default=str)

def export_to_html(results, filename="report.html"):
    try:
        from jinja2 import Template
    except ImportError:
        print("Jinja2 yüklü değil. HTML raporu oluşturulamıyor.")
        return
    template_str = """
    <html>
      <head>
        <title>Domain Check Report</title>
        <meta charset="utf-8">
      </head>
      <body>
        <h1>Domain Check Report</h1>
        <table border="1" cellspacing="0" cellpadding="5">
          <tr>
            <th>Domain</th><th>Taken</th><th>IP</th><th>MX</th><th>NS</th><th>TXT</th><th>SSL Expiry</th><th>Phishing</th><th>Screenshot</th>
          </tr>
          {% for res in results %}
          <tr>
            <td>{{ res.domain }}</td>
            <td>{{ res.taken }}</td>
            <td>{{ res.dns.A }}</td>
            <td>{{ res.dns.MX|join('; ') }}</td>
            <td>{{ res.dns.NS|join('; ') }}</td>
            <td>{{ res.dns.TXT|join('; ') }}</td>
            <td>{{ res.ssl }}</td>
            <td>{{ res.phishing }}</td>
            <td>{% if res.screenshot %}<a href="{{ res.screenshot }}">View</a>{% endif %}</td>
          </tr>
          {% endfor %}
        </table>
      </body>
    </html>
    """
    template = Template(template_str)
    html_content = template.render(results=results)
    with open(filename, "w") as f:
        f.write(html_content)

def interactive_mode():
    banner = pyfiglet.figlet_format("Mariently", font="ansi_shadow")
    print(Fore.GREEN + banner)
    print(Fore.YELLOW + "Hoşgeldiniz! Domain varyasyon ve durum kontrol aracına hoşgeldiniz.\n")
    mode = input("Domain girişi için 'd', dosya yüklemek için 'f' giriniz: ").strip().lower()
    domains = []
    if mode == 'f':
        file_path = input("Dosya yolunu giriniz: ").strip()
        if os.path.exists(file_path):
            with open(file_path, "r") as f:
                for line in f:
                    domain_line = line.strip()
                    if domain_line:
                        domains.append(domain_line)
        else:
            print("Dosya bulunamadı. Çıkılıyor.")
            return
    else:
        domain_input = input("Varyasyonlarını oluşturmak istediğiniz domaini giriniz (örn: ornek.com): ").strip()
        domains = generate_variations(domain_input)
    results = []
    print("\nKontroller başlatılıyor...\n")
    with ThreadPoolExecutor(max_workers=10) as executor:
        for res in tqdm(executor.map(check_domain, domains), total=len(domains)):
            results.append(res)
    for res in results:
        print(Fore.BLUE + f"Kontrol ediliyor: {res['domain']}")
        if res['taken']:
            print(Fore.RED + "Sonuç: Bu domain dolu!")
        else:
            print(Fore.WHITE + "Sonuç: Bu domain uygun!")
        print("-" * 50)
    export_to_csv(results)
    export_to_json(results)
    export_to_html(results)
    print("Sonuçlar 'results.csv', 'results.json' ve 'report.html' dosyalarına kaydedildi.")

def main():
    parser = argparse.ArgumentParser(description="Gelişmiş Domain Varyasyon ve Durum Kontrol Aracı")
    parser.add_argument("--file", help="Domain listesinin bulunduğu dosya yolu", default=None)
    parser.add_argument("--domain", help="Tek bir domain (örn: ornek.com)", default=None)
    args = parser.parse_args()
    if args.file:
        domains = []
        file_path = args.file
        if os.path.exists(file_path):
            with open(file_path, "r") as f:
                for line in f:
                    domain_line = line.strip()
                    if domain_line:
                        domains.append(domain_line)
        else:
            print("Dosya bulunamadı. Çıkılıyor.")
            return
    elif args.domain:
        domains = generate_variations(args.domain)
    else:
        interactive_mode()
        return
    results = []
    print("\nKontroller başlatılıyor...\n")
    with ThreadPoolExecutor(max_workers=10) as executor:
        for res in tqdm(executor.map(check_domain, domains), total=len(domains)):
            results.append(res)
    for res in results:
        print(Fore.BLUE + f"Kontrol ediliyor: {res['domain']}")
        if res['taken']:
            print(Fore.RED + "Sonuç: Bu domain dolu!")
        else:
            print(Fore.WHITE + "Sonuç: Bu domain uygun!")
        print("-" * 50)
    export_to_csv(results)
    export_to_json(results)
    export_to_html(results)
    print("Sonuçlar 'results.csv', 'results.json' ve 'report.html' dosyalarına kaydedildi.")

if __name__ == "__main__":
    main()