Python Detaylı Web Site Keşif Toolu

voidsec.exe' Alıntı:

Herkese selamlar TurkHackTeam ailesi,

Bugün sizlere Python ile kendi yazdığım web site keşif aracını paylaşmak istiyorum. Bu araçta birçok şeyi tek seferde yapabiliyorsunuz. Kodu aşağıda vereceğim. Siz kendiniz istediğiniz şekilde düzenleyip kendi projelerinizde kullanabilirsiniz. Kod satırı çok fazla olduğundan parçalar şeklinde vereceğim siz birleştirme işlemini yaparsınız.

Kod 1. Kısım:

Python:

import socket
import ssl
import whois
import requests
import geocoder
import subprocess
import dns.resolver
import dns.query
import time
from datetime import datetime
from pyfiglet import Figlet
from urllib.parse import urljoin
from bs4 import BeautifulSoup

SIFIRLA = "\033[0m"; KALIN = "\033[1m"; CAMGOBEGI = "\033[96m"; YESIL = "\033[92m"
SARI = "\033[93m"; KIRMIZI = "\033[91m"; MOR = "\033[95m"; CIZGI = f"{MOR}" + "─" * 50 + f"{SIFIRLA}"

def ascii_baslik_yazdir():
    fig = Figlet(font="slant")
    print(CAMGOBEGI + fig.renderText("voidsecexe") + SIFIRLA)
    print(f"{MOR}THT | Siber Güvenlik Keşif Aracı\n{CIZGI}")

def tarih_bicimlendir(tarih):
    try:
        if isinstance(tarih, list): tarih = tarih[0]
        return tarih.strftime('%Y-%m-%d %H:%M:%S') if tarih else "Bilinmiyor"
    except: return "Geçersiz"

def gelismis_dns_kayitlari_al(domain):
    print(f"\n{SARI}[+] Gelişmiş DNS kayıtları alınıyor...{SIFIRLA}")
    kayit_turleri = ["A", "AAAA", "MX", "NS", "TXT", "CNAME", "SOA", "SRV"]
    kayıtlar = {}

    for tur in kayit_turleri:
        try:
            cevaplar = dns.resolver.resolve(domain, tur, lifetime=5)
            kayıtlar[tur] = []
            for r in cevaplar:
                if tur == "MX":
                    kayıtlar[tur].append(f"{r.preference} {r.exchange}")
                elif tur == "SRV":
                    kayıtlar[tur].append(f"{r.priority} {r.weight} {r.port} {r.target}")
                else:
                    kayıtlar[tur].append(r.to_text())
        except dns.resolver.NoAnswer:
            kayıtlar[tur] = ["Kayıt bulunamadı"]
        except dns.resolver.NXDOMAIN:
            kayıtlar[tur] = ["Domain bulunamadı"]
        except dns.exception.Timeout:
            kayıtlar[tur] = ["Sorgu zaman aşımı"]
        except Exception as e:
            kayıtlar[tur] = [f"Hata: {e}"]

    try:
        dnssec = dns.resolver.resolve(domain, 'DNSKEY', lifetime=5)
        kayıtlar['DNSSEC'] = ["DNSSEC aktif"]
    except:
        kayıtlar['DNSSEC'] = ["DNSSEC aktif değil veya desteklenmiyor"]

    kayıtlar['ZoneTransfer'] = []
    try:
        ns_records = dns.resolver.resolve(domain, 'NS', lifetime=5)
        for ns in ns_records:
            ns_name = ns.to_text()
            try:
                zone = dns.query.xfr(ns_name, domain, lifetime=5)
                records = list(zone)
                if records:
                    kayıtlar['ZoneTransfer'].append(f"Zone transfer başarılı: {ns_name}")
                else:
                    kayıtlar['ZoneTransfer'].append(f"Zone transfer izin verilmedi: {ns_name}")
            except Exception as e:
                kayıtlar['ZoneTransfer'].append(f"Zone transfer başarısız ({ns_name}): {e}")
    except Exception as e:
        kayıtlar['ZoneTransfer'].append(f"NS kayıtları alınamadı veya zone transfer testi yapılamadı: {e}")

    for tur, degerler in kayıtlar.items():
        print(f"\n{MOR}- {tur} kayıtları:{SIFIRLA}")
        for d in degerler:
            print(f"  • {d}")

    print()
    return kayıtlar

def ssl_bilgisi_al(domain):
    try:
        ctx = ssl.create_default_context()
        with ctx.wrap_socket(socket.socket(), server_hostname=domain) as s:
            s.settimeout(5)
            s.connect((domain, 443))
            cert = s.getpeercert()
            return {
                "gecerli_baslangic": cert.get("notBefore", "Yok"),
                "gecerli_bitis": cert.get("notAfter", "Yok"),
                "veren": dict(x[0] for x in cert.get("issuer", [])).get("organizationName", "Bilinmiyor")
            }
    except Exception as e:
        return {"hata": str(e)}

def site_bilgilerini_goster(domain):
    print(f"{CIZGI}\n{CAMGOBEGI}[1] Alan Adı Bilgisi Analizi Başlatılıyor...{SIFIRLA}")
    try:
        who = whois.whois(domain)
        print(f"\n{MOR}WHOIS Bilgileri:{SIFIRLA}")
        print(f"{YESIL}- Sahibi     : {who.get('name', 'Bilinmiyor')}")
        print(f"- Oluşturma  : {tarih_bicimlendir(who.creation_date)}")
        print(f"- Bitiş      : {tarih_bicimlendir(who.expiration_date)}")
        print(f"- Registrar  : {who.get('registrar', 'Bilinmiyor')}{SIFIRLA}")
    except:
        print(f"{KIRMIZI}WHOIS bilgisi alınamadı.{SIFIRLA}")

    try:
        ip = socket.gethostbyname(domain)
        konum = geocoder.ip(ip)
        print(f"\n{MOR}IP ve Konum:{SIFIRLA}")
        print(f"{YESIL}- IP    : {ip}")
        print(f"- Konum : {konum.city or 'Bilinmiyor'}, {konum.country or 'Bilinmiyor'}{SIFIRLA}")
    except:
        print(f"{KIRMIZI}IP/Konum alınamadı.{SIFIRLA}")

    try:
        yanit = requests.get("https://" + domain, timeout=5)
        print(f"\n{MOR}HTTP Durumu:{SIFIRLA}")
        print(f"{SARI}- HTTPS Durum: {yanit.status_code}{SIFIRLA}")
        print(f"{MOR}  Başlıklar:")
        for k, v in yanit.headers.items():
            print(f"- {k}: {v}")
    except:
        print(f"{KIRMIZI}HTTPS bağlantısı başarısız.{SIFIRLA}")

    ssl_bilgi = ssl_bilgisi_al(domain)
    print(f"\n{MOR}SSL Sertifikası:{SIFIRLA}")
    if "hata" not in ssl_bilgi:
        print(f"{YESIL}- Başlangıç : {ssl_bilgi['gecerli_baslangic']}")
        print(f"- Bitiş      : {ssl_bilgi['gecerli_bitis']}")
        print(f"- Veren Kurum: {ssl_bilgi['veren']}{SIFIRLA}")
    else:
        print(f"{KIRMIZI}{ssl_bilgi['hata']}{SIFIRLA}")

    dns = gelismis_dns_kayitlari_al(domain)
    print(f"\n{MOR}DNS Kayıtları:{SIFIRLA}")
    for tur, degerler in dns.items():
        print(f"{MOR}- {tur} kayıtları:{SIFIRLA}")
        for d in degerler:
            print(f"  • {d}")
    print(f"\n{YESIL}[✓] Alan adı analizi tamamlandı.{SIFIRLA}\n{CIZGI}")

def gelismis_waf_tespiti(domain):
    print(f"\n{CAMGOBEGI}[2] Gelişmiş WAF Tespiti Başlatılıyor...{SIFIRLA}")
    test_url = f"http://{domain}/?id=1' OR '1'='1"
    try:
        response = requests.get(test_url, timeout=5)
        headers = response.headers
        waf_listesi = ["cloudflare", "sucuri", "f5", "akamai", "imperva", "modsecurity"]

        found = False
        for header in headers.values():
            for waf in waf_listesi:
                if waf in header.lower():
                    print(f"{SARI}- WAF Header İle Tespit Edildi: {waf}{SIFIRLA}")
                    found = True

       
        waf_signature = ["access denied", "error 403", "request blocked", "forbidden"]
        content = response.text.lower()
        for sig in waf_signature:
            if sig in content:
                print(f"{SARI}- WAF İçerik İle Tespit Edildi: '{sig}' ifadesi bulundu.{SIFIRLA}")
                found = True

        if not found:
            print(f"{YESIL}- WAF Tespit Edilemedi.{SIFIRLA}")

    except Exception as e:
        print(f"{KIRMIZI}WAF tespiti sırasında hata: {e}{SIFIRLA}")

    print(CIZGI)

def port_tarama(domain):
    print(f"\n{CAMGOBEGI}[3] Açık Port Taraması ve Banner Alma Başlatılıyor...{SIFIRLA}")
    try:
        ip = socket.gethostbyname(domain)
        portlar = [21, 22, 80, 443, 3306, 8080]
        for p in portlar:
            try:
                s = socket.socket()
                s.settimeout(1)
                s.connect((ip, p))
                print(f"{YESIL}- Port {p} AÇIK{SIFIRLA}")
               
                try:
                    s.sendall(b'HEAD / HTTP/1.0\r\n\r\n')
                    banner = s.recv(1024).decode(errors='ignore').strip()
                    if banner:
                        print(f"  Banner: {banner.splitlines()[0]}")
                except:
                    pass
                s.close()
            except:
                pass
    except:
        print(f"{KIRMIZI}IP çözümlenemedi.{SIFIRLA}")
    print(CIZGI)
   
def gelismis_veri_cekilebilirlik_kontrol(domain):
    print(f"\n{CAMGOBEGI}[16] Gelişmiş Site Veri Erişim ve Koruma Durumu Kontrolü Başlatılıyor...{SIFIRLA}")
    try:
        base_url_http = f"http://{domain}"
        base_url_https = f"https://{domain}"

       
        for base_url in [base_url_http, base_url_https]:
            robots_url = urljoin(base_url, "/robots.txt")
            try:
                r = requests.get(robots_url, timeout=6)
                if r.status_code == 200:
                    print(f"{YESIL}- Robots.txt bulundu: {robots_url}{SIFIRLA}")
                    disallow_list = []
                    for line in r.text.splitlines():
                        line = line.strip()
                        if line.lower().startswith("disallow"):
                            parca = line.split(":")
                            if len(parca) > 1:
                                disallow_path = parca[1].strip()
                                disallow_list.append(disallow_path)
                    if disallow_list:
                        print(f"  • Robots.txt tarafından engellenen yollar:")
                        for d in disallow_list:
                            print(f"    - {d}")
                    else:
                        print(f"  • Robots.txt içinde engellenen yol yok.")
                    if "disallow: /" in r.text.lower():
                        print(f"{KIRMIZI}  !!! Tüm site robots.txt ile engellenmiş! Veri çekmek zorlaşabilir.{SIFIRLA}")
                else:
                    print(f"{SARI}- Robots.txt bulunamadı veya erişilemedi: HTTP {r.status_code}")
            except Exception as e:
                print(f"{SARI}- Robots.txt erişim hatası: {e}")

       
        for base_url in [base_url_http, base_url_https]:
            sitemap_url = urljoin(base_url, "/sitemap.xml")
            try:
                r = requests.get(sitemap_url, timeout=6)
                if r.status_code == 200:
                    print(f"{YESIL}- Sitemap.xml bulundu: {sitemap_url}{SIFIRLA}")
                    url_sayisi = r.text.lower().count("<url>")
                    print(f"  • Sitemap içerisinde yaklaşık {url_sayisi} URL listelenmiş.")
                else:
                    print(f"{SARI}- Sitemap.xml bulunamadı veya erişilemedi: HTTP {r.status_code}")
            except Exception as e:
                print(f"{SARI}- Sitemap.xml erişim hatası: {e}")

Kod 2. Kısım:

Python:

hassas_yollar = [
            "/admin", "/administrator", "/backup.zip", "/config.php", "/db_backup.sql", "/.git/", "/.env",
            "/phpinfo.php", "/server-status", "/login", "/user/login", "/wp-login.php", "/wp-admin/"
        ]
        print("\n- Hassas dosya/dizin erişim testleri:")
        for yol in hassas_yollar:
            for base_url in [base_url_http, base_url_https]:
                test_url = urljoin(base_url, yol)
                try:
                    r = requests.get(test_url, timeout=6)
                    durum = r.status_code
                    if durum == 200:
                        print(f"{KIRMIZI}  [Açık] Erişilebilir hassas dosya/dizin: {test_url}{SIFIRLA}")
                    elif durum in [301, 302]:
                        print(f"{SARI}  [Yönlendirme] {test_url} HTTP {durum} döndü.{SIFIRLA}")
                    elif durum in [403, 401]:
                        print(f"{YESIL}  [Engellenmiş] Erişim kısıtlanmış: {test_url}{SIFIRLA}")
                    elif durum == 404:
                        print(f"  [Bulunamadı] {test_url} HTTP 404 döndü.")
                    else:
                        print(f"  [HTTP {durum}] {test_url}")
                except Exception as e:
                    print(f"  [Hata] {test_url} erişim hatası: {e}")

       
        print("\n- Ana sayfa erişim ve içerik kontrolü:")
        for base_url in [base_url_http, base_url_https]:
            try:
                r = requests.get(base_url, timeout=6)
                if r.status_code == 200:
                    print(f"{YESIL}  Ana sayfa {base_url} başarılı şekilde yüklendi.{SIFIRLA}")
                   
                    yasakli_ifadeler = [
                        "erişim reddedildi", "yetkisiz", "erişim engellendi", "forbidden",
                        "authentication required", "giriş yapmalısınız", "unauthorized"
                    ]
                    icerik = r.text.lower()
                    if any(x in icerik for x in yasakli_ifadeler):
                        print(f"{KIRMIZI}  !!! Ana sayfa erişim sınırlaması ya da uyarı mesajı tespit edildi.{SIFIRLA}")
                    else:
                        print(f"  İçerik erişilebilir ve sınırlama görünmüyor.")
                else:
                    print(f"{SARI}  Ana sayfa HTTP {r.status_code} döndü: {base_url}")
            except Exception as e:
                print(f"{KIRMIZI}  Ana sayfa erişim hatası: {e}{SIFIRLA}")

       
        print("\n- Scraping engeli ve koruma göstergeleri:")
        for base_url in [base_url_http, base_url_https]:
            try:
                r = requests.get(base_url, timeout=6)
                headers = r.headers
               
                x_robots = headers.get("X-Robots-Tag", "").lower()
                if x_robots:
                    print(f"  • X-Robots-Tag header'ı mevcut: {x_robots}")
                    if "noindex" in x_robots or "nofollow" in x_robots:
                        print(f"    → Sayfa arama motorları tarafından indekslenmiyor veya takip edilmiyor.")
                else:
                    print(f"  • X-Robots-Tag header'ı bulunamadı.")
               
                if "cf-ray" in headers:
                    print(f"  • Cloudflare koruması aktif.")
                if "server" in headers and "cloudflare" in headers["server"].lower():
                    print(f"  • Cloudflare sunucu olarak kullanılıyor.")
            except Exception as e:
                print(f"  • Header kontrolü hatası: {e}")

    except Exception as e:
        print(f"{KIRMIZI}Gelişmiş veri çekilebilirlik kontrolü hatası: {e}{SIFIRLA}")
    print(CIZGI)

def ssl_zafiyet_taramasi(domain):
    print(f"\n{CAMGOBEGI}[4] SSL Zafiyet Tespiti Başlatılıyor...{SIFIRLA}")
    protokoller = {
        "TLSv1": ssl.PROTOCOL_TLSv1,
        "TLSv1_1": ssl.PROTOCOL_TLSv1_1,
        "TLSv1_2": ssl.PROTOCOL_TLSv1_2
    }
    for isim, proto in protokoller.items():
        try:
            ctx = ssl.SSLContext(proto)
            with ctx.wrap_socket(socket.socket(), server_hostname=domain) as s:
                s.settimeout(2)
                s.connect((domain, 443))
                print(f"{YESIL}- {isim} destekleniyor{SIFIRLA}")
        except:
            continue
    print(CIZGI)
   
def guvenlik_header_kontrol(domain):
    print(f"\n{CAMGOBEGI}[6] HTTP Güvenlik Header Kontrolü...{SIFIRLA}")
    try:
        yanit = requests.get("https://" + domain, timeout=5)
        headers = yanit.headers

        guvenlik_headerlari = {
            "Content-Security-Policy": False,
            "X-Frame-Options": False,
            "Strict-Transport-Security": False,
            "X-Content-Type-Options": False,
            "Referrer-Policy": False,
            "Permissions-Policy": False
        }

        for h in guvenlik_headerlari.keys():
            if h in headers:
                guvenlik_headerlari[h] = True

        for h, var in guvenlik_headerlari.items():
            if var:
                print(f"{YESIL}- {h} header'ı mevcut.{SIFIRLA}")
            else:
                print(f"{KIRMIZI}- {h} header'ı eksik! Güvenlik açığı riski.{SIFIRLA}")
    except Exception as e:
        print(f"{KIRMIZI}Header kontrolü sırasında hata: {e}{SIFIRLA}")
    print(CIZGI)

def tum_teknolojileri_tespit_et(domain):
    print(f"\n{CAMGOBEGI}[5] Tüm Web Teknolojileri Tespiti Başlatılıyor...{SIFIRLA}")
    import re

    try:
        url = "http://" + domain
        yanit = requests.get(url, timeout=10)
        headers = yanit.headers
        icerik = yanit.text.lower()
        cookies = yanit.cookies

        tech = set()

       
        if "x-powered-by" in headers:
            tech.add(f"X-Powered-By Header: {headers['x-powered-by']}")
        if "server" in headers:
            tech.add(f"Server Header: {headers['server']}")

       
        cookie_map = {
            "wordpress": "WordPress (Cookie)",
            "joomla": "Joomla (Cookie)",
            "phpbb": "phpBB (Cookie)",
            "drupal": "Drupal (Cookie)",
            "shopify": "Shopify (Cookie)",
            "sessionid": "Django (Cookie)",
            "laravel_session": "Laravel (Cookie)",
            "ci_session": "CodeIgniter (Cookie)",
            "asp.net_sessionid": "ASP.NET (Cookie)",
            "dotcms": "DotCMS (Cookie)",
            "magento": "Magento (Cookie)",
        }
        for c in cookies:
            for key, val in cookie_map.items():
                if key in c.name.lower():
                    tech.add(val)

       
        html_map = {
            "wp-content": "WordPress",
            "wp-includes": "WordPress",
            'content="joomla!': "Joomla",
            "drupal-settings-json": "Drupal",
            "shopify": "Shopify",
            "react": "React.js",
            "angular": "Angular",
            "vue": "Vue.js",
            "gatsbyjs": "GatsbyJS",
            "nextjs": "Next.js",
            "ember": "Ember.js",
            "backbone": "Backbone.js",
            "squarespace": "Squarespace",
            "wix.com": "Wix",
            "google-analytics": "Google Analytics",
            "gtag/js": "Google Analytics",
            "segment.com": "Segment",
            "hotjar": "Hotjar",
            "cloudflare": "Cloudflare (CDN/WAF)",
            "akamai": "Akamai (CDN)",
            "varnish": "Varnish Cache",
            "fastly": "Fastly (CDN)",
            "nginx": "Nginx (Web Server)",
            "apache": "Apache (Web Server)",
            "iis": "Microsoft IIS (Web Server)",
            "express": "Express.js (Node.js Framework)",
            "gunicorn": "Gunicorn (Python WSGI Server)",
            "tomcat": "Apache Tomcat (Java Server)",
            "php": "PHP",
            "python": "Python",
            "ruby on rails": "Ruby on Rails",
            "java": "Java",
            "asp.net": "ASP.NET",
            "perl": "Perl",
            "coldfusion": "ColdFusion",
        }
        for key, val in html_map.items():
            if key in icerik:
                tech.add(val)

       
        dosyalar = re.findall(r'(?:src|href)="([^"]+)"', yanit.text)
        asset_map = {
            "wp-": "WordPress",
            "joomla": "Joomla",
            "drupal": "Drupal",
            "shopify": "Shopify",
            "jquery": "jQuery",
            "react": "React.js",
            "angular": "Angular",
            "vue": "Vue.js",
            "bootstrap": "Bootstrap",
            "foundation": "Foundation",
            "materialize": "Materialize CSS",
            "microsoftajax": "Microsoft ASP.NET AJAX",
            "semantic": "Semantic UI",
            "tailwind": "Tailwind CSS",
            "bulma": "Bulma CSS",
        }
        for dosya in dosyalar:
            d = dosya.lower()
            for key, val in asset_map.items():
                if key in d:
                    tech.add(val)

       
        path_map = {
            "/administrator": "Joomla (Admin Panel)",
            "/wp-admin": "WordPress (Admin Panel)",
            "/user/login": "Drupal (Login Page)",
            "/sites/default/files": "Drupal (Public Files)",
            "/system/themes": "Magento (Theme)",
            "/static/version": "Magento (Static Assets)",
            "/bin/magento": "Magento (CLI)",
            "/shopify_assets": "Shopify (Assets)",
            "/api": "API Endpoint (Genel)",
            "/ajax": "AJAX Kullanımı",
        }
        for path, val in path_map.items():
            if path in icerik:
                tech.add(val)

Kod 3. Kısım:

Python:

lang_map = {
            "php": "PHP",
            "python": "Python",
            "ruby": "Ruby",
            "java": "Java",
            "node.js": "Node.js",
            "asp.net": "ASP.NET",
            "perl": "Perl",
            "coldfusion": "ColdFusion",
        }
        for key, val in lang_map.items():
            if key in icerik:
                tech.add(val)

       
        if tech:
            print(f"{YESIL}- Tespit Edilen Teknolojiler ve İmzalar:{SIFIRLA}")
            for t in sorted(tech):
                print(f"  • {t}")
        else:
            print(f"{SARI}- Teknoloji tespiti yapılamadı.{SIFIRLA}")

    except Exception as e:
        print(f"{KIRMIZI}Teknoloji tespiti sırasında hata: {e}{SIFIRLA}")
    print(CIZGI)
   
def subdomain_tespiti(domain):
    print(f"\n{CAMGOBEGI}[7] Subdomain Tespiti Başlatılıyor...{SIFIRLA}")
    try:
        url = f"https://crt.sh/?q=%25.{domain}&output=json"
        yanit = requests.get(url, timeout=10)
        subdomainler = set()
        if yanit.status_code == 200:
            veriler = yanit.json()
            for kayit in veriler:
                isim = kayit.get("name_value")
                if isim:
                    for subd in isim.split("\n"):
                        if subd.endswith(domain):
                            subdomainler.add(subd.strip())
            if subdomainler:
                print(f"{YESIL}- Bulunan subdomainler:{SIFIRLA}")
                for sd in sorted(subdomainler):
                    print(f"  • {sd}")
            else:
                print(f"{SARI}- Subdomain bulunamadı.{SIFIRLA}")
        else:
            print(f"{KIRMIZI}crt.sh sorgusu başarısız.{SIFIRLA}")
    except Exception as e:
        print(f"{KIRMIZI}Subdomain tespiti sırasında hata: {e}{SIFIRLA}")
    print(CIZGI)
   
def ip_konum_isp_bilgisi(domain):
    print(f"\n{CAMGOBEGI}[11] IP Konum ve ISP Bilgisi Alınıyor...{SIFIRLA}")
    try:
        ip = socket.gethostbyname(domain)
        print(f"{YESIL}- IP Adresi: {ip}{SIFIRLA}")

        response = requests.get(f"https://ipinfo.io/{ip}/json", timeout=7)
        if response.status_code == 200:
            data = response.json()
            print(f"- Şehir  : {data.get('city', 'Bilinmiyor')}")
            print(f"- Bölge  : {data.get('region', 'Bilinmiyor')}")
            print(f"- Ülke   : {data.get('country', 'Bilinmiyor')}")
            print(f"- ISP    : {data.get('org', 'Bilinmiyor')}")
            print(f"- Zaman Dilimi: {data.get('timezone', 'Bilinmiyor')}")
        else:
            print(f"{KIRMIZI}IP bilgisi alınamadı: {response.status_code}{SIFIRLA}")
    except Exception as e:
        print(f"{KIRMIZI}Hata: {e}{SIFIRLA}")
    print(CIZGI)
   
def ssl_labs_analiz(domain):
    print(f"\n{CAMGOBEGI}[6] SSL Labs API ile SSL Detaylı Analiz Başlatılıyor...{SIFIRLA}")
    import time

    api_url = f"https://api.ssllabs.com/api/v3/analyze?host={domain}&publish=off&all=done"
    try:
        response = requests.get(api_url)
        if response.status_code != 200:
            print(f"{KIRMIZI}API çağrısı başarısız: {response.status_code}{SIFIRLA}")
            return
        data = response.json()

       
        while data.get('status') in ['IN_PROGRESS', 'DNS', 'READY']:
            if data['status'] == 'READY':
                break
            print(f"{SARI}Analiz yapılıyor, lütfen bekleyin...{SIFIRLA}")
            time.sleep(10)
            response = requests.get(api_url)
            data = response.json()

        if data.get('status') == 'READY':
            endpoints = data.get('endpoints', [])
            for ep in endpoints:
                print(f"IP: {ep.get('ipAddress')}")
                print(f"Grade: {ep.get('grade')}")
                details = ep.get('details', {})
                protokoller = details.get('protocols', [])
                protokol_listesi = ', '.join([p.get('name', '') for p in protokoller])
                print(f"Desteklenen Protokoller: {protokol_listesi}")
                print("-----")
        else:
            print(f"{KIRMIZI}Analiz tamamlanamadı: {data.get('status')}{SIFIRLA}")
    except Exception as e:
        print(f"{KIRMIZI}Hata: {e}{SIFIRLA}")
    print(CIZGI)
   
def subdomain_takeover_tespiti(domain):
    print(f"\n{CAMGOBEGI}[12] Subdomain Takeover Tespiti Başlatılıyor...{SIFIRLA}")
    try:
     
        url = f"https://crt.sh/?q=%25.{domain}&output=json"
        yanit = requests.get(url, timeout=10)
        subdomainler = set()
        if yanit.status_code == 200:
            veriler = yanit.json()
            for kayit in veriler:
                isim = kayit.get("name_value")
                if isim:
                    for subd in isim.split("\n"):
                        if subd.endswith(domain):
                            subdomainler.add(subd.strip())
        else:
            print(f"{KIRMIZI}crt.sh sorgusu başarısız.{SIFIRLA}")
            return

        takeover_riski = []
        for subd in subdomainler:
            try:
               
                socket.gethostbyname(subd)
               
                try:
                    r = requests.get("https://" + subd, timeout=5)
                except:
                    r = requests.get("http://" + subd, timeout=5)
                if r.status_code in [404, 502, 503] or any(x in r.text.lower() for x in [
                    "no such app", "there isn't a github pages site here", "heroku",
                    "project not found", "unavailable", "page not found", "no such site"
                ]):
                    takeover_riski.append(subd)
            except:
                takeover_riski.append(subd)

        if takeover_riski:
            print(f"{KIRMIZI}- Potansiyel Subdomain Takeover Riski Olanlar:{SIFIRLA}")
            for t in takeover_riski:
                print(f"  • {t}")
        else:
            print(f"{YESIL}- Subdomain Takeover riski görünmüyor.{SIFIRLA}")

    except Exception as e:
        print(f"{KIRMIZI}Subdomain Takeover testi hatası: {e}{SIFIRLA}")
    print(CIZGI)
   
def ssl_revocation_kontrol(domain):
    print(f"\n{CAMGOBEGI}[13] SSL Sertifika Revocation (İptal) Kontrolü Başlatılıyor...{SIFIRLA}")
    try:
        cmd = f"echo | openssl s_client -connect {domain}:443 -status 2>/dev/null"
        output = subprocess.check_output(cmd, shell=True, universal_newlines=True)

        if "OCSP Response Status: successful" in output:
            if "Cert Status: revoked" in output:
                print(f"{KIRMIZI}- Sertifika İptal Edilmiş!{SIFIRLA}")
            elif "Cert Status: good" in output:
                print(f"{YESIL}- Sertifika Geçerli ve İptal Edilmemiş.{SIFIRLA}")
            else:
                print(f"{SARI}- Sertifika Durumu Belirsiz veya Bilgi Yok.{SIFIRLA}")
        else:
            print(f"{SARI}- OCSP Yanıtı Alınamadı veya Desteklenmiyor.{SIFIRLA}")
    except Exception as e:
        print(f"{KIRMIZI}OCSP kontrolü sırasında hata: {e}{SIFIRLA}")
    print(CIZGI)
   
def sitemap_robots_inceleme(domain):
    print(f"\n{CAMGOBEGI}[14] Sitemap.xml ve Robots.txt İncelemesi Başlatılıyor...{SIFIRLA}")
    try:
        sitemap_url = f"http://{domain}/sitemap.xml"
        robots_url = f"http://{domain}/robots.txt"
        sitemap_icerik = ""
        try:
            r = requests.get(sitemap_url, timeout=5)
            if r.status_code == 200:
                sitemap_icerik = r.text
                print(f"{YESIL}- Sitemap.xml bulundu.{SIFIRLA}")
               
                url_sayisi = sitemap_icerik.lower().count("<url>")
                print(f"  • Sitemap içinde yaklaşık {url_sayisi} URL var.")
            else:
                print(f"{SARI}- Sitemap.xml bulunamadı veya erişilemedi.")
        except:
            print(f"{SARI}- Sitemap.xml erişim hatası.")

       
        try:
            r = requests.get(robots_url, timeout=5)
            if r.status_code == 200:
                print(f"{YESIL}- Robots.txt bulundu.{SIFIRLA}")
                lines = r.text.splitlines()
                disallowed = [line.split(":")[1].strip() for line in lines if line.lower().startswith("disallow")]
                if disallowed:
                    print("  • Robots.txt tarafından engellenen dizinler:")
                    for d in disallowed:
                        print(f"    - {d}")
                else:
                    print("  • Robots.txt içinde engellenmiş dizin yok.")
            else:
                print(f"{SARI}- Robots.txt bulunamadı veya erişilemedi.")
        except:
            print(f"{SARI}- Robots.txt erişim hatası.")

    except Exception as e:
        print(f"{KIRMIZI}Sitemap/Robots inceleme hatası: {e}{SIFIRLA}")
    print(CIZGI)

Kod 4. Kısım:

Python:

def detayli_veri_cekilebilirlik_analizi(domain):
    print(f"\n{CAMGOBEGI}[17] Detaylı Veri Çekilebilirlik HTTP Durum Analizi Başlatılıyor...{SIFIRLA}")
    try:
        base_urls = [f"http://{domain}", f"https://{domain}"]
        test_yollar = [
            "/", "/robots.txt", "/sitemap.xml", "/admin", "/login", "/backup.zip",
            "/config.php", "/.git/", "/wp-admin/", "/user/login", "/api", "/api/user"
        ]

        toplam = 0
        basarili = 0
        hatali = 0

        erisebilenler = []
        erisilemeyenler = []

        def kod_aciklama(kod):
            if 100 <= kod < 200: return "Bilgi (1xx)"
            elif 200 <= kod < 300: return "Başarılı (2xx)"
            elif 300 <= kod < 400: return "Yönlendirme (3xx)"
            elif 400 <= kod < 500: return "İstemci Hatası (4xx)"
            elif 500 <= kod < 600: return "Sunucu Hatası (5xx)"
            else: return "Bilinmeyen HTTP Durumu"

        for base_url in base_urls:
            print(f"\n{MOR}-- {base_url} üzerinde testler --{SIFIRLA}")
            for yol in test_yollar:
                url = base_url.rstrip('/') + yol
                toplam += 1
                try:
                    start = time.time()
                    r = requests.get(url, timeout=8, allow_redirects=True)
                    sure = time.time() - start
                    code = r.status_code
                    aciklama = kod_aciklama(code)
                    content_type = r.headers.get('Content-Type', 'Bilinmiyor').split(';')[0]
                    icerik_boyu = len(r.content)
                    icerik_kb = icerik_boyu / 1024

                    yorumlar = []

                    if 200 <= code < 300:
                        basarili += 1
                        erisebilenler.append(url)
                        if icerik_boyu == 0:
                            yorumlar.append("Boş içerik döndü.")
                        if content_type not in ['text/html', 'application/json', 'text/plain']:
                            yorumlar.append(f"Beklenmeyen içerik tipi: {content_type}")
                        if sure > 3:
                            yorumlar.append(f"Yüklenme süresi yüksek: {sure:.2f} saniye")
                    else:
                        hatali += 1
                        erisilemeyenler.append(url)
                        if 300 <= code < 400:
                            yorumlar.append(f"Yönlendirme (HTTP {code})")
                        elif 400 <= code < 500:
                            if code == 401 or code == 403:
                                yorumlar.append("Erişim engellendi veya yetki gerektiriyor.")
                            elif code == 404:
                                yorumlar.append("Sayfa bulunamadı.")
                            else:
                                yorumlar.append(f"İstek reddedildi (HTTP {code})")
                        elif 500 <= code < 600:
                            yorumlar.append("Sunucu hatası.")
                        else:
                            yorumlar.append(f"HTTP {code}")

                    print(f"  {url}: HTTP {code} ({aciklama}), İçerik Tipi: {content_type}, Boyut: {icerik_kb:.1f} KB, Süre: {sure:.2f}s")
                    if yorumlar:
                        for y in yorumlar:
                            print(f"    → Uyarı: {y}")

                except requests.exceptions.Timeout:
                    hatali += 1
                    erisilemeyenler.append(url)
                    print(f"  {url}: {KIRMIZI}Zaman aşımı!{SIFIRLA}")
                except requests.exceptions.ConnectionError:
                    hatali += 1
                    erisilemeyenler.append(url)
                    print(f"  {url}: {KIRMIZI}Bağlantı hatası!{SIFIRLA}")
                except Exception as e:
                    hatali += 1
                    erisilemeyenler.append(url)
                    print(f"  {url}: {KIRMIZI}Bilinmeyen hata: {e}{SIFIRLA}")

        # Özet
        print(f"\n{CAMGOBEGI}Toplam test edilen URL: {toplam}")
        print(f"Başarılı erişilen URL sayısı: {basarili}")
        print(f"Erişilemeyen URL sayısı: {hatali}{SIFIRLA}")

        # Detaylı liste
        print(f"\n{YESIL}Erişilebilen URL'ler:{SIFIRLA}")
        for url in erisebilenler:
            print(f"  • {url}")

        print(f"\n{KIRMIZI}Erişilemeyen URL'ler:{SIFIRLA}")
        for url in erisilemeyenler:
            print(f"  • {url}")

    except Exception as e:
        print(f"{KIRMIZI}Detaylı veri çekilebilirlik analizi hatası: {e}{SIFIRLA}")
    print(CIZGI)

def ana_menu():
    ascii_baslik_yazdir()
    while True:
        print(f"""{KALIN}
[1] Alan Adı Bilgisi
[2] Gelişmiş WAF Tespiti
[3] Açık Port Taraması ve Banner
[4] SSL Zafiyet Tespiti
[5] Gelişmiş Web Teknolojisi Tanıma
[6] HTTP Güvenlik Header Kontrolü
[7] Subdomain Tespiti
[8] SSL Chiper Bilgisi
[9] IP Konum ve ISP Bilgisi
[10] Subdomain Takeover Tespiti
[11] SSL Sertifika Revocation Tespiti
[12] Sitemap.xml ve Robots.txt Detaylı İnceleme
[13] Site Veri Zaafiyet ve Durum Analizi
[14] Detaylı Statü ve HTTP Durum Analizi
[0] Çıkış{SIFIRLA}""")
        print("")
        print(CIZGI)
        secim = input(f"{CAMGOBEGI}Seçiminiz: {SIFIRLA}").strip()
        if secim == "0":
            print(f"{SARI}Program kapatılıyor...{SIFIRLA}")
            break
        alan_adi = input(f"{KALIN}Alan adını girin (örnek: example.com): {SIFIRLA}").strip()
        if not alan_adi:
            print(f"{KIRMIZI}Alan adı boş olamaz.{SIFIRLA}"); continue
        if secim == "1": site_bilgilerini_goster(alan_adi)
        elif secim == "2": gelismis_waf_tespiti(alan_adi)
        elif secim == "3": port_tarama(alan_adi)
        elif secim == "4": ssl_zafiyet_taramasi(alan_adi)
        elif secim == "5": tum_teknolojileri_tespit_et(alan_adi)
        elif secim == "6": guvenlik_header_kontrol(alan_adi)
        elif secim == "7": subdomain_tespiti(alan_adi)
        elif secim == "8": ssl_labs_analiz(alan_adi)
        elif secim == "9": ip_konum_isp_bilgisi(alan_adi)
        elif secim == "10": subdomain_takeover_tespiti(alan_adi)
        elif secim == "11": ssl_revocation_kontrol(alan_adi)
        elif secim == "12": sitemap_robots_inceleme(alan_adi)
        elif secim == "13": gelismis_veri_cekilebilirlik_kontrol(alan_adi)
        elif secim == "14": detayli_veri_cekilebilirlik_analizi(alan_adi)
        else: print(f"{KIRMIZI}Geçersiz seçim!{SIFIRLA}")

if __name__ == "__main__":
    try: ana_menu()
    except KeyboardInterrupt:
        print(f"\n{SARI}Kullanıcı iptali.{SIFIRLA}")

- voidsec.exe - TurkHackTeam

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

Kryzlo' Alıntı:

Ellerine sağlık mükemmel olmuş

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

DarkNode' Alıntı:

Elinize Sağlık

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

sametghack' Alıntı:

Eline saglik

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