Update main.py

main.py

@@ -1,14 +1,6 @@
-#!/usr/bin/env python3
-"""
-Luminet - Network Analysis Tool
-===============================
-
-A comprehensive network analysis tool that provides IP and domain reconnaissance
-using only public, free data sources.
-"""
-
-import os, re, time, json, socket, logging, threading, hashlib, ipaddress, subprocess, concurrent.futures, requests, pycountry, ssl
+import os, re, time, json, socket, logging, threading, hashlib, secrets, ipaddress, subprocess, concurrent.futures, requests, pycountry, ssl
 from datetime import datetime, timedelta, timezone
+from functools import wraps
 from collections import defaultdict, Counter
 from flask import Flask, render_template, request, jsonify
 from OpenSSL import crypto
@@ -19,7 +11,7 @@ from dns.resolver import NoAnswer, NXDOMAIN, Timeout, NoNameservers, YXDOMAIN
 from dns.exception import DNSException
 from dns.query import BadResponse
 
-# Optional dependencies
+# Opsiyonel bağımlılıklar için import denemeleri
 try:
     import scapy.all as scapy
     SCAPY_AVAILABLE = True
@@ -29,20 +21,20 @@ except (ImportError, PermissionError):
 try:
     import nmap
     NMAP_AVAILABLE = True
-except (ImportError, OSError):
+except ImportError:
     NMAP_AVAILABLE = False
 
-# Flask application setup
+# Flask uygulaması ve konfigürasyon
 app = Flask(__name__)
-app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'luminet-network-analysis-tool-2024')
+app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', secrets.token_hex(32))
 app.jinja_env.globals.update(json=json)
 app.jinja_env.filters['tojson'] = json.dumps
 
-# Logging configuration
+# Loglama konfigürasyonu
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# API endpoints
+# API endpointleri
 IANA_IP_BOOTSTRAP_URL = "https://rdap.iana.org/ip/"
 IANA_ASN_BOOTSTRAP_URL = "https://rdap.iana.org/autnum/"
 RIPESTAT_DATA_URL = "https://stat.ripe.net/data/"
@@ -50,10 +42,10 @@ IPINFO_URL = "https://ipinfo.io/"
 IP_API_URL = "http://ip-api.com/json/"
 OSM_NOMINATIM_URL = "https://nominatim.openstreetmap.org/search"
 
-# Rate limiting for API requests
+# Traceroute için API rate limitini göz önünde bulundur
 REQUEST_DELAY = 0.1
 
-# DNSBL lists for security checks
+# DNSBL listeleri
 DNS_BL_LISTS = {
     'spam': {
         'zen.spamhaus.org': 'Spamhaus Zen (SBL+XBL+PBL)',
@@ -66,12 +58,14 @@ DNS_BL_LISTS = {
         'rbl.0spam.org': '0Spam Realtime BL',
         'bl.nordspam.com': 'NordSpam IP BL',
     },
+
     'domain': {
         'dbl.0spam.org': '0Spam Domain BL',
         'dbl.nordspam.com': 'NordSpam Domain BL',
         'uribl.spameatingmonkey.net': 'SEM URI BL',
         'urired.spameatingmonkey.net': 'SEM URI Red',
     },
+
     'network': {
         'b.barracudacentral.org': 'Barracuda Reputation Block List',
         'dnsbl.sorbs.net': 'SORBS Aggregate',
@@ -84,6 +78,7 @@ DNS_BL_LISTS = {
         'bl.ipv6.spameatingmonkey.net': 'SEM IPv6 BL',
         'nbl.0spam.org': '0Spam Network BL',
     },
+
     'proxy_bot': {
         'dnsbl.dronebl.org': 'DroneBL',
         'tor.dan.me.uk': 'Tor Exit Nodes',
@@ -94,6 +89,7 @@ DNS_BL_LISTS = {
         'socks.dnsbl.sorbs.net': 'SORBS SOCKS Proxies',
         'zombie.dnsbl.sorbs.net': 'SORBS Zombies',
     },
+
     'misc': {
         'psbl.surriel.com': 'Passive Spam Block List',
         'db.wpbl.info': 'Weighted Private Block List',
@@ -106,7 +102,6 @@ DNS_BL_LISTS = {
 }
 
 def get_dns_records(domain):
-    """Get comprehensive DNS records for a domain."""
     records = {
         "A": [], "AAAA": [], "MX": [], "TXT": [], "NS": [], "CNAME": None, "SOA": None,
         "SRV": [], "CAA": [], "DMARC": [], "SPF": [], "PTR": [], "NAPTR": [], "SSHFP": [],
@@ -117,15 +112,15 @@ def get_dns_records(domain):
     resolver.timeout = 5
     resolver.lifetime = 5
 
-    # A records
+    # A
     for rdata in safe_resolve(resolver, domain, 'A'):
         records["A"].append(rdata.address)
 
-    # AAAA records
+    # AAAA
     for rdata in safe_resolve(resolver, domain, 'AAAA'):
         records["AAAA"].append(rdata.address)
 
-    # PTR records for found IPs
+    # PTR
     for ip_addr in records["A"] + records["AAAA"]:
         try:
             rev_name = dns.reversename.from_address(ip_addr)
@@ -134,11 +129,11 @@ def get_dns_records(domain):
         except Exception:
             pass
 
-    # MX records
+    # MX
     for rdata in safe_resolve(resolver, domain, 'MX'):
         records["MX"].append({"preference": rdata.preference, "exchange": rdata.exchange.to_text()})
 
-    # TXT records / SPF
+    # TXT / SPF
     for rdata in safe_resolve(resolver, domain, 'TXT'):
         for txt_string in rdata.strings:
             txt_record = txt_string.decode('utf-8')
@@ -146,21 +141,21 @@ def get_dns_records(domain):
             if txt_record.lower().startswith('v=spf'):
                 records["SPF"].append(txt_record)
 
-    # DMARC records
+    # DMARC
     for rdata in safe_resolve(resolver, f'_dmarc.{domain}', 'TXT'):
         for txt_string in rdata.strings:
             records["DMARC"].append(txt_string.decode('utf-8'))
 
-    # NS records
+    # NS
     for rdata in safe_resolve(resolver, domain, 'NS'):
         records["NS"].append(rdata.target.to_text())
 
-    # CNAME records
+    # CNAME
     cname_result = safe_resolve(resolver, domain, 'CNAME')
     if cname_result:
         records["CNAME"] = cname_result[0].target.to_text()
 
-    # SOA records
+    # SOA
     soa_result = safe_resolve(resolver, domain, 'SOA')
     if soa_result:
         soa = soa_result[0]
@@ -174,26 +169,43 @@ def get_dns_records(domain):
             "minimum": soa.minimum
         }
 
-    # Additional record types
-    for record_type in ['SRV', 'CAA', 'NAPTR', 'SSHFP', 'TLSA', 'LOC', 'DS', 'DNSKEY']:
-        for rdata in safe_resolve(resolver, domain, record_type):
-            if record_type == 'SRV':
-                records[record_type].append({
-                    "port": rdata.port,
-                    "target": rdata.target.to_text(),
-                    "priority": rdata.priority,
-                    "weight": rdata.weight
-                })
-            elif record_type == 'CAA':
-                records[record_type].append({
-                    "flags": rdata.flags,
-                    "tag": rdata.tag.decode('utf-8'),
-                    "value": rdata.value.decode('utf-8')
-                })
-            else:
-                records[record_type].append(str(rdata))
+    # SRV
+    for rdata in safe_resolve(resolver, domain, 'SRV'):
+        records["SRV"].append({
+            "port": rdata.port,
+            "target": rdata.target.to_text(),
+            "priority": rdata.priority,
+            "weight": rdata.weight
+        })
+
+    # CAA
+    for rdata in safe_resolve(resolver, domain, 'CAA'):
+        records["CAA"].append({
+            "flags": rdata.flags,
+            "tag": rdata.tag.decode('utf-8'),
+            "value": rdata.value.decode('utf-8')
+        })
+
+    # Ek kayıtlar
+    for rdata in safe_resolve(resolver, domain, 'NAPTR'):
+        records["NAPTR"].append(str(rdata))
+
+    for rdata in safe_resolve(resolver, domain, 'SSHFP'):
+        records["SSHFP"].append(str(rdata))
+
+    for rdata in safe_resolve(resolver, domain, 'TLSA'):
+        records["TLSA"].append(str(rdata))
 
-    # WHOIS information
+    for rdata in safe_resolve(resolver, domain, 'LOC'):
+        records["LOC"].append(str(rdata))
+
+    for rdata in safe_resolve(resolver, domain, 'DS'):
+        records["DS"].append(str(rdata))
+
+    for rdata in safe_resolve(resolver, domain, 'DNSKEY'):
+        records["DNSKEY"].append(str(rdata))
+
+    # WHOIS - sadece gerçek domainlerde çalıştır
     try:
         extracted = tldextract.extract(domain)
         real_domain = f"{extracted.domain}.{extracted.suffix}"
@@ -208,17 +220,45 @@ def get_dns_records(domain):
     except Exception as e:
         records["WHOIS"] = {"error": str(e)}
 
+    # Zone transfer testi
+    try:
+        ns_records = safe_resolve(resolver, domain, 'NS')
+        for ns in ns_records:
+            try:
+                ns_ip = safe_resolve(resolver, ns.target, 'A')[0].to_text()
+                xfr = dns.query.xfr(ns_ip, domain, timeout=5)
+                zone = dns.zone.from_xfr(xfr)
+                records["ZONE_TRANSFER"] = list(zone.nodes.keys())
+            except Exception:
+                pass
+    except Exception:
+        pass
+
     return records
 
+def whois_info(domain):
+    try:
+        extracted = tldextract.extract(domain)
+        real_domain = f"{extracted.domain}.{extracted.suffix}"
+        w = whois.whois(real_domain)
+        return {
+            "registrar": w.registrar,
+            "creation_date": str(w.creation_date),
+            "expiration_date": str(w.expiration_date),
+            "name_servers": w.name_servers,
+            "emails": w.emails
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
 def safe_resolve(resolver, qname, rdtype):
-    """Safely resolve DNS queries with error handling."""
     try:
         return resolver.resolve(qname, rdtype, raise_on_no_answer=False)
     except (NoAnswer, NXDOMAIN, Timeout, NoNameservers, DNSException):
         return []
 
 def get_authoritative_dns(domain):
-    """Find the authoritative DNS server for a domain."""
+    """Gerçek alan adının yetkili DNS sunucusunu bulur."""
     try:
         ns_to_query = '198.41.0.4'  # Root server
         parts = domain.split('.')
@@ -239,25 +279,23 @@ def get_authoritative_dns(domain):
     return None
 
 def check_dnssec(domain):
-    """Check DNSSEC status for a domain."""
     try:
         resolver = dns.resolver.Resolver()
         resolver.use_edns(edns=True, payload=4096)
         ds_records = resolver.resolve(domain, 'DS', raise_on_no_answer=False)
         dnskey_records = resolver.resolve(domain, 'DNSKEY', raise_on_no_answer=False)
         if ds_records and dnskey_records:
-            return "DNSSEC Active (DS and DNSKEY records found)"
+            return "DNSSEC Etkin (DS ve DNSKEY kayıtları bulundu)"
         elif ds_records:
-            return "DNSSEC Partially Active (Only DS record found)"
+            return "DNSSEC Kısmen Etkin (Sadece DS kaydı bulundu)"
         else:
-            return "DNSSEC Not Active"
+            return "DNSSEC Etkin Değil"
     except (NoAnswer, NXDOMAIN, Timeout, NoNameservers):
-        return "DNSSEC Status Unknown"
+        return "DNSSEC Durumu Belirlenemedi"
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Hata: {str(e)}"
 
 def check_dnsbl(ip_address):
-    """Check IP address against DNS blacklists."""
     results = defaultdict(list)
     results_lock = threading.Lock()
     
@@ -267,7 +305,7 @@ def check_dnsbl(ip_address):
         else:
             reversed_ip = dns.reversename.from_address(ip_address).to_text(omit_final_dot=True).replace('.ip6.arpa', '')
     except Exception as e:
-        results['error'] = f"IP address reversal error: {str(e)}"
+        results['error'] = f"IP adresi çevrim hatası: {str(e)}"
         return results
 
     def query_worker(dnsbl, description, category):
@@ -309,32 +347,102 @@ def check_dnsbl(ip_address):
                 future.result()
             except Exception as exc:
                 dnsbl_name = future_to_dnsbl[future]
-                logger.error(f'{dnsbl_name} query error: {exc}')
+                logger.error(f'{dnsbl_name} sorgusunda beklenmedik hata oluştu: {exc}')
 
     return results
 
+def process_bgp_data_for_d3(bgp_data, target_asn_str=None):
+    if not bgp_data or 'bgp_state' not in bgp_data or not bgp_data['bgp_state']:
+        return None
+
+    def get_color_for_path(path):
+        key = '-'.join(map(str, path))
+        hash_digest = hashlib.md5(key.encode()).hexdigest()
+        return f"#{hash_digest[:6]}"
+
+    def get_color_for_asn(asn):
+        key = str(asn)
+        hash_digest = hashlib.md5(key.encode()).hexdigest()
+        return f"#{hash_digest[6:12]}"
+
+    nodes = {}
+    raw_links = []
+    source_asns = set()
+    target_asn = int(target_asn_str) if target_asn_str and target_asn_str.isdigit() else None
+
+    for entry in bgp_data.get('bgp_state', []):
+        path = entry.get('path', [])
+        if not path:
+            continue
+
+        source_asns.add(path[0])
+        path_color = get_color_for_path(path) 
+
+        path_details = {
+            "community": entry.get("community", []),
+            "full_path": entry.get("path", []),
+            "source_id": entry.get("source_id", "Bilinmiyor"),
+            "target_prefix": entry.get("target_prefix", "Bilinmiyor")
+        }
+
+        for asn in path:
+            if asn not in nodes:
+                nodes[asn] = {"id": str(asn), "label": f"AS{asn}", "color": get_color_for_asn(asn), "node_type": "transit"}
+
+        for i in range(len(path) - 1):
+            link_data = {
+                "source": str(path[i]),
+                "target": str(path[i+1]),
+                "color": path_color, 
+                **path_details
+            }
+            raw_links.append(link_data)
+
+    for asn, node_data in nodes.items():
+        if asn == target_asn:
+            node_data["type"] = "target" 
+        elif asn in source_asns:
+            node_data["type"] = "source" 
+    if not raw_links:
+        return None
+
+    link_counts = defaultdict(int)
+    for link in raw_links:
+        key = tuple(sorted((link['source'], link['target'])))
+        link_counts[key] += 1
+
+    processed_links = []
+    link_group_indices = defaultdict(int)
+    for link in raw_links:
+        key = tuple(sorted((link['source'], link['target'])))
+        total_links_in_group = link_counts[key]
+        new_link = link.copy()
+        new_link['total_links'] = total_links_in_group
+        new_link['link_index'] = link_group_indices[key]
+        processed_links.append(new_link)
+        link_group_indices[key] += 1
+
+    return {"nodes": list(nodes.values()), "links": processed_links}
+    
 def get_country_name(code: str) -> str:
-    """Get country name from country code."""
     try:
         country = pycountry.countries.get(alpha_2=code.upper())
-        return country.name if country else "Unknown Country"
+        return country.name if country else "Bilinmeyen Ülke"
     except Exception as e:
-        logger.error(f"Country name lookup failed: {str(e)}")
-        return "Invalid Code"
+        logger.error(f"Ülke ismi alınamadı: {str(e)}")
+        return "Geçersiz Kod"
 
 def get_reverse_dns(ip):
-    """Get reverse DNS for an IP address."""
     try:
         hostname, _, _ = socket.gethostbyaddr(ip)
         return hostname
     except socket.herror:
-        return "PTR record not found"
+        return "PTR kaydı bulunamadı"
     except Exception as e:
-        logger.error(f"Reverse DNS error: {str(e)}")
-        return f"Error: {str(e)}"
+        logger.error(f"Reverse DNS hatası: {str(e)}")
+        return f"Hata: {str(e)}"
 
 def get_ping_latency(ip, packet_count=4):
-    """Get ping latency statistics."""
     try:
         command = ["ping", "-c", str(packet_count), ip] if os.name != "nt" else ["ping", "-n", str(packet_count), ip]
         result = subprocess.run(command, capture_output=True, text=True, timeout=10, encoding='utf-8', errors='ignore')
@@ -343,7 +451,7 @@ def get_ping_latency(ip, packet_count=4):
             output = result.stdout
             
             if os.name != "nt": 
-                match = re.search(r"rtt min/avg/max/mdev = ([\d.]+)/([\d.]+)/([\d.]+)/([\d.]+) ms", output)
+                match = re.search(r"rtt en düşük/ortalama/en yüksek/mdev = ([\d.]+)/([\d.]+)/([\d.]+)/([\d.]+) ms", output)
                 if match:
                     return {
                         "min": f"{match.group(1)} ms",
@@ -360,20 +468,19 @@ def get_ping_latency(ip, packet_count=4):
                         "avg": match.group(3)
                     }
             
-            return {"error": "Ping results regex mismatch", "raw": output}
+            return {"error": "Ping sonuçları regex ile eşleşmedi", "raw": output}
         else:
-            return {"error": f"Ping command returned error code ({result.returncode}): {result.stderr or result.stdout}", "raw": result.stdout + result.stderr}
+            return {"error": f"Ping komutu hata kodu döndürdü ({result.returncode}): {result.stderr or result.stdout}", "raw": result.stdout + result.stderr}
     except FileNotFoundError:
-        return {"error": "Ping command not found. Please check your PATH settings."}
+        return {"error": "Ping komutu bulunamadı. PATH ayarınızı veya komutun konumunu kontrol edin."}
     except subprocess.TimeoutExpired:
-        return {"error": "Ping request timed out"}
+        return {"error": "Ping isteği zaman aşımına uğradı"}
     except Exception as e:
-        return {"error": f"Unexpected error: {str(e)}"}
+        return {"error": f"Beklenmedik hata: {str(e)}"}
 
 def scan_ports(ip):
-    """Scan common ports using nmap."""
     if not NMAP_AVAILABLE:
-        return {"error": "Nmap library not installed"}
+        return {"error": "Nmap kütüphanesi kurulu değil"}
     
     try:
         nm = nmap.PortScanner()
@@ -401,21 +508,20 @@ def scan_ports(ip):
                         open_ports.append({
                             'port': port,
                             'state': port_info['state'],
-                            'name': port_info.get('name', 'unknown'),
+                            'name': port_info.get('name', 'bilinmiyor'),
                             'product': port_info.get('product', ''),
                             'version': port_info.get('version', ''),
                         })
         return {"ports": open_ports}
     
     except nmap.PortScannerError as e:
-        logger.error(f"Nmap error: {str(e)}")
-        return {"error": f"Nmap error: {str(e)}"}
+        logger.error(f"Nmap hatası: {str(e)}")
+        return {"error": f"Nmap hatası: {str(e)}"}
     except Exception as e:
-        logger.error(f"Port scan error: {str(e)}")
-        return {"error": f"Port scan error: {str(e)}"}
+        logger.error(f"Port tarama hatası: {str(e)}")
+        return {"error": f"Port tarama hatası: {str(e)}"}
 
 def get_http_headers(host):
-    """Get HTTP headers for a host."""
     urls = [f"https://{host}", f"http://{host}"]
     headers = {'User-Agent': 'Luminet/1.0 (Network Analysis Tool)'}
     last_error = None  
@@ -447,10 +553,10 @@ def get_http_headers(host):
             }
         except requests.exceptions.RequestException as e:
             last_error = e  
-            logger.warning(f"HTTP header error: {str(e)}")
+            logger.warning(f"HTTP başlık hatası: {str(e)}")
             continue
     
-    return {"error": f"HTTP/HTTPS connection failed: {str(last_error)}"}
+    return {"error": f"HTTP/HTTPS bağlantısı kurulamadı: {str(last_error)}"}
 
 def is_public_ip(ip: str) -> bool:
     """Check if an IP address is public/routable."""
@@ -527,6 +633,7 @@ def get_locations_batch(ips: List[str]) -> List[Optional[Dict]]:
         
         if response.status_code == 200:
             results = response.json()
+            # Map results back to original IP list
             result_map = {result["query"]: result for result in results if result.get("status") == "success"}
             locations = []
             for ip in ips:
@@ -550,10 +657,12 @@ def get_locations_batch(ips: List[str]) -> List[Optional[Dict]]:
     except Exception as e:
         logger.error(f"Batch location lookup failed: {str(e)}")
     
+    # Fallback to individual lookups if batch fails
     return [get_location(ip) if is_public_ip(ip) else None for ip in ips]
 
 def system_traceroute(ip: str, max_hops: int = 30, timeout: int = 60) -> List[Dict]:
     """Perform a system traceroute and return hops."""
+    # Determine OS and appropriate command
     if os.name == "nt":
         cmd = ["tracert", "-d", "-h", str(max_hops), "-w", "1000", ip]
     else:
@@ -572,19 +681,24 @@ def system_traceroute(ip: str, max_hops: int = 30, timeout: int = 60) -> List[Di
         ttl = 1
         
         for line in proc.stdout.splitlines():
+            # Skip header lines
             if not line.strip() or line.startswith(("traceroute", "tracert", "Tracing")):
                 continue
                 
+            # Parse line based on OS
             if os.name == "nt":
+                # Windows tracert format
                 parts = line.strip().split()
                 if len(parts) >= 3 and parts[1].replace(".", "").isdigit():
                     hop_ip = parts[1]
                     hops.append({"ip": hop_ip, "ttl": ttl})
                     ttl += 1
             else:
+                # Unix traceroute format
                 parts = line.strip().split()
                 if len(parts) >= 2 and parts[1] != "*":
                     hop_ip = parts[1]
+                    # Handle cases where IP is in parentheses
                     if "(" in hop_ip and ")" in hop_ip:
                         hop_ip = hop_ip[hop_ip.find("(")+1:hop_ip.find(")")]
                     hops.append({"ip": hop_ip, "ttl": ttl})
@@ -604,14 +718,19 @@ def system_traceroute(ip: str, max_hops: int = 30, timeout: int = 60) -> List[Di
 
 def enriched_traceroute(target_ip: str, max_hops: int = 30) -> List[Dict]:
     """Perform traceroute with geolocation information for each hop."""
+    # First get all hops
     hops = system_traceroute(target_ip, max_hops=max_hops)
     
     if not hops:
         return []
     
+    # Extract IPs for batch lookup
     hop_ips = [hop["ip"] for hop in hops]
+    
+    # Get locations in batch if possible
     locations = get_locations_batch(hop_ips)
     
+    # Enrich hop data with location information
     enriched_hops = []
     for hop, location in zip(hops, locations):
         enriched_hop = {
@@ -624,7 +743,6 @@ def enriched_traceroute(target_ip: str, max_hops: int = 30) -> List[Dict]:
     return enriched_hops
 
 def get_asn_from_ip(ip):
-    """Get ASN from IP address using RIPEstat."""
     try:
         r = requests.get(f"{RIPESTAT_DATA_URL}prefix-overview/data.json?resource={ip}", timeout=5)
         if r.status_code == 200:
@@ -634,67 +752,76 @@ def get_asn_from_ip(ip):
                 return str(asns[0]["asn"])
         return None
     except Exception as e:
-        logger.error(f"ASN lookup failed: {str(e)}")
+        logger.error(f"ASN alınamadı: {str(e)}")
         return None
 
-def get_authoritative_rdap_url(query):
-    """Get authoritative RDAP URL for a query."""
-    query = query.strip().upper().replace("AS", "")
-    is_ip = "." in query or ":" in query
-    rdap_type = "ip" if is_ip else "autnum"
-    bootstrap_url = IANA_IP_BOOTSTRAP_URL if is_ip else IANA_ASN_BOOTSTRAP_URL
-
+def get_asn_path_locations(asn):
     try:
-        r = robust_get_request(f"{bootstrap_url}{query}", timeout=10, headers={"Accept": "application/rdap+json"})
-        if r.status_code == 501:
-            raise requests.exceptions.HTTPError("IANA RDAP not implemented", response=r)
+        url = f"https://api.bgpview.io/asn/{asn}/prefixes"
+        r = requests.get(url, timeout=10)
+        if r.status_code == 200:
+            data = r.json()
+            prefixes = data.get("data", {}).get("ipv4_prefixes", []) + data.get("data", {}).get("ipv6_prefixes", [])
+            countries = [p.get("country_code") for p in prefixes if p.get("country_code")]
+            return Counter(countries)
+        return Counter()
+    except Exception as e:
+        logger.error(f"BGPView ASN path hatası: {str(e)}")
+        return Counter()
 
+def lookup_coords_osm(country_code):
+    try:
+        if not country_code:
+            return None, None
+            
+        country_name = get_country_name(country_code)
+        if not country_name:
+            return None, None
+            
+        params = {"q": country_name, "format": "json", "limit": 1}
+        headers = {"User-Agent": "Luminet/1.0"}
+        r = requests.get(OSM_NOMINATIM_URL, params=params, headers=headers, timeout=5)
         r.raise_for_status()
-        iana_data = r.json()
-        for link in iana_data.get("links", []):
-            if link.get("rel") == "related":
-                return link.get("href")
-        logger.warning("IANA RDAP result exists but no redirect link found.")
-    except requests.exceptions.HTTPError as http_err:
-        if http_err.response.status_code == 501:
-            logger.warning(f"IANA RDAP not implemented, trying fallback RIRs")
-        else:
-            logger.warning(f"IANA RDAP URL lookup failed: {str(http_err)}")
-    except requests.exceptions.RequestException as e:
-        logger.warning(f"IANA RDAP connection failed: {str(e)}")
-
-    fallback_rir_urls = {
-        "ripe":    f"https://rdap.db.ripe.net/{rdap_type}/{query}",
-        "apnic":   f"https://rdap.apnic.net/{rdap_type}/{query}",
-        "lacnic":  f"https://rdap.lacnic.net/rdap/{rdap_type}/{query}",
-        "afrinic": f"https://rdap.afrinic.net/rdap/{rdap_type}/{query}",
-        "arin":    f"https://rdap.arin.net/registry/{rdap_type}/{query}"
-    }
-
-    for rir, url in fallback_rir_urls.items():
-        try:
-            r = robust_get_request(url, timeout=10, headers={"Accept": "application/rdap+json"}) 
-            if r.status_code == 200:
-                logger.info(f"{rir.upper()} RDAP source used: {url}")
-                return url
-        except requests.exceptions.RequestException:
-            continue
+        results = r.json()
+        if results:
+            return float(results[0]["lat"]), float(results[0]["lon"])
+        return None, None
+    except Exception as e:
+        logger.error(f"[OSM Lookup Hatası] {country_code}: {str(e)}")
+        return None, None
 
-    logger.warning(f"All RDAP sources failed: {query}")
-    return None
+def get_asn_map_data(ip):
+    asn = get_asn_from_ip(ip)
+    if not asn:
+        return (None, [])
+    
+    location_counts = get_asn_path_locations(asn)
+    map_points = []
+    
+    for country_code, count in location_counts.most_common(15):
+        lat, lon = lookup_coords_osm(country_code)
+        if lat and lon:
+            map_points.append({
+                "loc": country_code, 
+                "count": count, 
+                "lat": lat, 
+                "lon": lon,
+                "country_name": get_country_name(country_code)
+            })
+    
+    return (asn, map_points)
 
 def parse_vcard(vcard_array):
-    """Parse vCard array from RDAP response."""
     if not isinstance(vcard_array, list) or len(vcard_array) < 2:
         return {}
     
     vcard_data = vcard_array[1]
     contact = {
-        "name": "Unknown", 
-        "org": "Unknown", 
-        "email": "Unknown", 
-        "address": "Unknown", 
-        "tel": "Unknown"
+        "name": "Bilinmiyor", 
+        "org": "Bilinmiyor", 
+        "email": "Bilinmiyor", 
+        "address": "Bilinmiyor", 
+        "tel": "Bilinmiyor"
     }
     
     for item in vcard_data:
@@ -719,8 +846,209 @@ def parse_vcard(vcard_array):
     
     return contact
 
+def run_mtr_analysis(ip):
+    if not ip or not isinstance(ip, str):
+        return {"error": "Geçersiz IP adresi veya hostname."}
+    
+    try:
+        ipaddress.ip_address(ip)
+    except ValueError:
+        pass 
+    
+    command = [
+        "mtr", 
+        "-r",           
+        "-c", "10",     
+        "--json",       
+        ip              
+    ]
+    
+    result = {"ip": ip, "timestamp": datetime.now().isoformat()}
+    
+    try:
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1 
+        )
+        
+        stdout, stderr = process.communicate(timeout=60)
+        
+        if process.returncode != 0:
+            error_msg = stderr.strip()
+            if "Name or service not known" in error_msg or "Temporary failure in name resolution" in error_msg:
+                user_error = f"Hedef hostname çözümlenemedi: {ip}. Lütfen doğru bir IP veya hostname girin."
+            elif "No such device" in error_msg or "Cannot find device" in error_msg:
+                user_error = "Ağ arayüzü hatası: MTR gerekli ağ cihazını bulamadı."
+            elif "Operation not permitted" in error_msg or "Permission denied" in error_msg:
+                user_error = "İzin hatası: MTR çalıştırmak için yetki gerekli."
+            else:
+                user_error = "MTR analizi başarısız oldu."
+            
+            logger.error(f"MTR command failed for {ip}: {error_msg} (Exit code: {process.returncode})")
+            result.update({
+                "error": user_error,
+                "details": error_msg,
+                "raw_output": stdout,
+                "raw_error": stderr
+            })
+            return result
+            
+        if not stdout.strip(): 
+            logger.error(f"MTR returned empty output for {ip}.")
+            result["error"] = "MTR boş sonuç döndürdü. Hedef erişilemiyor olabilir veya MTR çıktısı beklenenden farklı."
+            result["raw_output"] = stdout
+            result["raw_error"] = stderr
+            return result
+            
+        try:
+            mtr_data = json.loads(stdout)
+        except json.JSONDecodeError as e:
+            logger.error(f"MTR JSON decoding error for {ip}: {e}. Raw stdout: {stdout}")
+            result.update({
+                "error": "MTR çıktısı çözümlenemedi. Biçim hatası.",
+                "details": f"JSON çözümleme hatası: {e}",
+                "raw_output": stdout,
+                "raw_error": stderr
+            })
+            return result
+
+        report = mtr_data.get('report', {})
+        hubs = report.get('hubs', [])
+        
+        cleaned_hops = []
+        for idx, hop in enumerate(hubs, 1):
+            host = hop.get('host', '???').strip() 
+            
+            is_private = False
+            try:
+                if host != '???':
+                    ip_obj = ipaddress.ip_address(host)
+                    is_private = ip_obj.is_private
+            except ValueError:
+                pass
+            
+            loss = float(hop.get('Loss%', 0.0))
+            avg = float(hop.get('Avg', 0.0))
+            best = float(hop.get('Best', 0.0))
+            worst = float(hop.get('Worst', 0.0))
+            last = float(hop.get('Last', 0.0))
+            snt = int(hop.get('Snt', 0)) 
+
+            cleaned_hops.append({
+                'count': idx,
+                'host': host,
+                'loss': loss,
+                'avg': avg,
+                'best': best,
+                'worst': worst,
+                'last': last,
+                'is_private': is_private,
+                'packets_sent': snt
+            })
+        
+        overall_packet_loss = float(report.get('loss', 0.0))
+        if not hubs and overall_packet_loss == 0.0 and snt == 0: 
+            overall_packet_loss = 100.0 if "No route to host" in stderr or "Host unreachable" in stderr else 0.0
+        
+        result.update({
+            "hops": cleaned_hops,
+            "destination": report.get('dst', ip).strip(),
+            "packet_loss": overall_packet_loss,
+            "total_hops": len(cleaned_hops)
+        })
+        
+    except subprocess.TimeoutExpired:
+        process.kill()
+        stdout, stderr = process.communicate() 
+        error_msg = f"MTR analizi zaman aşımına uğradı ({ip})"
+        logger.error(error_msg)
+        result.update({
+            "error": "MTR analizi zaman aşımına uğradı. Hedefe ulaşmak çok uzun sürdü veya ağ engellendi.",
+            "details": "Analiz 60 saniyeden uzun sürdü.",
+            "raw_output": stdout,
+            "raw_error": stderr
+        })
+        
+    except FileNotFoundError:
+        logger.error("MTR komutu bulunamadı. Lütfen sisteminizde 'mtr' yüklü olduğundan emin olun.")
+        result.update({
+            "error": "MTR komutu bulunamadı. Sunucuda 'mtr' kurulu değil.",
+            "details": "Lütfen sunucunuzda MTR'ı kurun."
+        })
+    except PermissionError as e:
+        logger.error(f"MTR çalıştırmak için izin hatası: {e}")
+        result.update({
+            "error": "MTR çalıştırmak için yetki hatası.",
+            "details": f"MTR komutunu çalıştırmak için gerekli izinler yok. Hata: {e}"
+        })
+    except Exception as e:
+        logger.error(f"MTR beklenmedik hata için {ip}: {e}")
+        result.update({
+            "error": "Beklenmedik bir hata oluştu.",
+            "details": str(e)
+        })
+        
+    return result
+
+def get_bgpview_prefix_details(ip):
+    """
+    BGPView API'sini kullanarak bir IP adresinin ait olduğu prefix hakkında
+    detaylı bilgi alır (prefix, isim, açıklama, ülke).
+    """
+    try:
+        url = f"https://api.bgpview.io/ip/{ip}"
+        response = robust_get_request(url, timeout=5)
+        if response and response.status_code == 200:
+            data = response.json().get("data", {})
+            # Birden fazla prefix olabilir, en spesifik olanı (en uzun) alalım.
+            longest_prefix = max(data.get("prefixes", []), key=lambda p: p.get("prefix", "").split('/')[1], default=None)
+            if longest_prefix:
+                return {
+                    "prefix": longest_prefix.get("prefix"),
+                    "name": longest_prefix.get("name"),
+                    "description": longest_prefix.get("description"),
+                    "country_code": longest_prefix.get("country_code")
+                }
+        return None
+    except Exception as e:
+        logger.error(f"BGPView prefix detayları alınamadı: {str(e)}")
+        return None
+
+def get_peeringdb_info(asn):
+    """
+    PeeringDB API'sini kullanarak bir ASN hakkında temel bilgileri
+    (isim, web sitesi, trafik türü, anons edilen prefix sayısı) alır.
+    """
+    if not asn:
+        return None
+    try:
+        url = f"https://www.peeringdb.com/api/net?asn={asn}"
+        response = robust_get_request(url, timeout=7)
+        if response and response.status_code == 200:
+            data = response.json().get("data", [])
+            if data:
+                net_info = data[0]
+                return {
+                    "name": net_info.get("name"),
+                    "website": net_info.get("website"),
+                    "traffic_type": net_info.get("info_traffic"),
+                    "prefix_count_ipv4": net_info.get("info_prefixes4"),
+                    "prefix_count_ipv6": net_info.get("info_prefixes6"),
+                    "policy": net_info.get("policy_general")
+                }
+        return None
+    except Exception as e:
+        logger.error(f"PeeringDB bilgisi alınamadı: {str(e)}")
+        return None
+
 def parse_rdap_response(data):
-    """Parse RDAP response into structured format."""
+    """
+    Ham RDAP JSON yanıtını ayrıştırarak ön yüzde kullanılacak
+    yapılandırılmış bir sözlük oluşturur.
+    """
     parsed_info = {
         "summary": {},
         "contacts": {
@@ -731,32 +1059,32 @@ def parse_rdap_response(data):
             "other": []
         },
         "details": {},
-        "source_rir": "Unknown",
+        "source_rir": "Bilinmiyor",
     }
     
-    # Determine RIR source
+    # RIR kaynağını (RIPE, ARIN vb.) belirle
     if "port43" in data:
         port43_val = data["port43"].lower()
         rir_mapping = {
             "apnic": "APNIC", "lacnic": "LACNIC", "afrinic": "AfriNIC", 
             "arin": "ARIN", "ripe": "RIPE NCC",
         }
-        parsed_info["source_rir"] = next((v for k, v in rir_mapping.items() if k in port43_val), "Unknown")
+        parsed_info["source_rir"] = next((v for k, v in rir_mapping.items() if k in port43_val), "Bilinmiyor")
 
-    # Basic summary information
+    # Temel özet bilgileri
     summary = {
-        "name": data.get("name", "Unknown"), 
-        "handle": data.get("handle", "Unknown"), 
-        "country": data.get("country", "Unknown"),
+        "name": data.get("name", "Bilinmiyor"), 
+        "handle": data.get("handle", "Bilinmiyor"), 
+        "country": data.get("country", "Bilinmiyor"),
         "ip_range": f"{data.get('startAddress', '')} - {data.get('endAddress', '')}",
         "asn_range": f"{data.get('startAutnum', '')} - {data.get('endAutnum', '')}",
-        "type": data.get("type", "Unknown").title(),
+        "type": data.get("type", "Bilinmiyor").title(),
     }
     if summary["ip_range"] == " - ": summary.pop("ip_range", None)
     if summary["asn_range"] == " - ": summary.pop("asn_range", None)
     parsed_info["summary"] = summary
 
-    # Parse contact information
+    # İletişim bilgilerini ayrıştır
     for entity in data.get("entities", []):
         vcard_array = entity.get("vcardArray")
         if not vcard_array:
@@ -764,6 +1092,7 @@ def parse_rdap_response(data):
         contact_details = parse_vcard(vcard_array)
         roles = entity.get("roles", [])
         
+        # Rolleri uygun kategorilere ata
         assigned = False
         for role in ["registrant", "administrative", "technical", "abuse"]:
             if role in roles:
@@ -772,24 +1101,67 @@ def parse_rdap_response(data):
         if not assigned:
             parsed_info["contacts"]["other"].append(contact_details)
 
-    # Additional details
     parsed_info["details"] = {
         "events": data.get("events", []), 
         "remarks": data.get("remarks", []),
         "links": data.get("links", []), 
         "notices": data.get("notices", []),
-        "object_class_name": data.get("objectClassName", "Unknown"),
+        "object_class_name": data.get("objectClassName", "Bilinmiyor"),
     }
     
     return parsed_info
 
+def get_authoritative_rdap_url(query):
+    query = query.strip().upper().replace("AS", "")
+    is_ip = "." in query or ":" in query
+    rdap_type = "ip" if is_ip else "autnum"
+    bootstrap_url = IANA_IP_BOOTSTRAP_URL if is_ip else IANA_ASN_BOOTSTRAP_URL
+
+    try:
+        r = robust_get_request(f"{bootstrap_url}{query}", timeout=10, headers={"Accept": "application/rdap+json"})
+        if r.status_code == 501:
+            raise requests.exceptions.HTTPError("IANA RDAP not implemented", response=r)
+
+        r.raise_for_status()
+        iana_data = r.json()
+        for link in iana_data.get("links", []):
+            if link.get("rel") == "related":
+                return link.get("href")
+        logger.warning("IANA RDAP sonucu var ama yönlendirme linki bulunamadı.")
+    except requests.exceptions.HTTPError as http_err:
+        if http_err.response.status_code == 501:
+            logger.warning(f"IANA RDAP not implemented, trying fallback RIRs")
+        else:
+            logger.warning(f"IANA RDAP URL alınamadı: {str(http_err)}")
+    except requests.exceptions.RequestException as e:
+        logger.warning(f"IANA RDAP bağlantısı başarısız: {str(e)}")
+
+    fallback_rir_urls = {
+        "ripe":    f"https://rdap.db.ripe.net/{rdap_type}/{query}",
+        "apnic":   f"https://rdap.apnic.net/{rdap_type}/{query}",
+        "lacnic":  f"https://rdap.lacnic.net/rdap/{rdap_type}/{query}",
+        "afrinic": f"https://rdap.afrinic.net/rdap/{rdap_type}/{query}",
+        "arin":    f"https://rdap.arin.net/registry/{rdap_type}/{query}"
+    }
+
+    for rir, url in fallback_rir_urls.items():
+        try:
+            r = robust_get_request(url, timeout=10, headers={"Accept": "application/rdap+json"}) 
+            if r.status_code == 200:
+                logger.info(f"{rir.upper()} RDAP kaynağı kullanıldı: {url}")
+                return url
+        except requests.exceptions.RequestException:
+            continue
+
+    logger.warning(f"Tüm RDAP kaynakları başarısız oldu: {query}")
+    return None
+
 def get_additional_info_from_ripestat(query):
-    """Get additional information from RIPEstat."""
     additional_data = {}
     endpoints = {
-        "announced-prefixes": "Announced Prefixes", 
-        "routing-status": "Routing Status",
-        "bgp-state": "BGP State"
+        "announced-prefixes": "Anons Edilen Prefixler", 
+        "routing-status": "Yönlendirme Durumu",
+        "bgp-state": "BGP Durumu"
     }
     
     for endpoint, title in endpoints.items():
@@ -800,16 +1172,15 @@ def get_additional_info_from_ripestat(query):
             if r.status_code == 200:
                 additional_data[title] = r.json().get("data", {})
             else:
-                additional_data[title] = {"error": f"HTTP {r.status_code}: Data not available"}
+                additional_data[title] = {"error": f"HTTP {r.status_code}: Veri alınamadı"}
         except requests.exceptions.RequestException as e:
-            additional_data[title] = {"error": f"Request error: {str(e)}"}
+            additional_data[title] = {"error": f"İstek hatası: {str(e)}"}
         except Exception as e:
-            additional_data[title] = {"error": f"Unexpected error: {str(e)}"}
+            additional_data[title] = {"error": f"Beklenmedik hata: {str(e)}"}
     
     return additional_data
 
 def get_ipinfo_details(ip):
-    """Get IP information from ipinfo.io."""
     if not re.match(r"^\d{1,3}(?:\.\d{1,3}){3}$", ip) and ":" not in ip:
         return None
     
@@ -822,11 +1193,10 @@ def get_ipinfo_details(ip):
             return data
         return None
     except requests.exceptions.RequestException as e:
-        logger.warning(f"IPinfo lookup failed: {str(e)}")
+        logger.warning(f"IPinfo bilgileri alınamadı: {str(e)}")
         return None
 
 def analyze_ssl(hostname, port=443):
-    """Analyze SSL certificate for a hostname."""
     try:
         context = ssl.create_default_context()
         context.check_hostname = False
@@ -875,17 +1245,16 @@ def analyze_ssl(hostname, port=443):
                 }
                 
     except ssl.SSLError as e:
-        logger.error(f"SSL error ({hostname}:{port}): {str(e)}")
-        return {"error": f"SSL error: {str(e)}"}
+        logger.error(f"SSL hatası ({hostname}:{port}): {str(e)}")
+        return {"error": f"SSL hatası: {str(e)}"}
     except socket.timeout:
-        logger.error(f"Timeout ({hostname}:{port})")
-        return {"error": "Connection timeout"}
+        logger.error(f"Zaman aşımı ({hostname}:{port})")
+        return {"error": "Bağlantı zaman aşımı"}
     except Exception as e:
-        logger.error(f"Unexpected error ({hostname}:{port}): {str(e)}")
-        return {"error": f"Unexpected error: {str(e)}"}
+        logger.error(f"Beklenmedik hata ({hostname}:{port}): {str(e)}")
+        return {"error": f"Beklenmedik hata: {str(e)}"}
 
 def _get_alt_names(x509):
-    """Get alternative names from SSL certificate."""
     alt_names = []
     for i in range(x509.get_extension_count()):
         ext = x509.get_extension(i)
@@ -894,7 +1263,6 @@ def _get_alt_names(x509):
     return alt_names
 
 def generate_security_report(ipinfo_data, http_headers, port_scan, dnsbl_results, ip):
-    """Generate comprehensive security report."""
     report = {
         "proxy_vpn_tor": False,
         "anonymity_services": [], 
@@ -910,7 +1278,7 @@ def generate_security_report(ipinfo_data, http_headers, port_scan, dnsbl_results
         report["proxy_vpn_tor"] = True
         detected_str = ", ".join(report["anonymity_services"])
         report["security_issues"].append(
-            f"Anonymous network usage detected: {detected_str}"
+            f"Anonim ağ kullanımı tespit edildi: {detected_str}"
         )
 
     if ipinfo_data:
@@ -931,7 +1299,7 @@ def generate_security_report(ipinfo_data, http_headers, port_scan, dnsbl_results
                     category_map = {
                         'spam': 'Spam',
                         'proxy_bot': 'Proxy/Bot',
-                        'anonymity': 'Anonymous Service'
+                        'anonymity': 'Anonim Servis'
                     }
                     
                     service_name = category_map.get(category, category.capitalize())
@@ -945,7 +1313,7 @@ def generate_security_report(ipinfo_data, http_headers, port_scan, dnsbl_results
         open_critical = [p for p in report["open_ports"] if p["port"] in critical_ports]
         
         if open_critical:
-            report["security_issues"].append(f"{len(open_critical)} critical ports found open")
+            report["security_issues"].append(f"{len(open_critical)} kritik port açık bulundu")
 
     if http_headers and not http_headers.get("error") and "headers" in http_headers:
         headers = {k.lower(): v for k, v in http_headers["headers"].items()}
@@ -968,12 +1336,11 @@ def generate_security_report(ipinfo_data, http_headers, port_scan, dnsbl_results
             if real_name not in headers
         ]
         if missing_headers:
-            report["security_issues"].append(f"{len(missing_headers)} security headers missing")
+            report["security_issues"].append(f"{len(missing_headers)} güvenlik başlığı eksik")
 
     return report
 
 def check_anonymity_services(ip):
-    """Check for anonymity services like Tor, VPN, proxies."""
     anonymity_services = []
     proxy_lists = [
         'proxy.dnsbl.sorbs.net',
@@ -1011,7 +1378,7 @@ def check_anonymity_services(ip):
                         'tornevall': 'VPN',
                         'efnetrbl': 'IRC Proxy',
                         'spamrats': 'Spam Bot',
-                        'blocklist': 'Hack Attack',
+                        'blocklist': 'Hack Saldırısı',
                         'dronebl': 'Zombie/Botnet'
                     }
                     
@@ -1030,26 +1397,24 @@ def check_anonymity_services(ip):
         return anonymity_services
         
     except Exception as e:
-        logger.error(f"Anonymity check error: {str(e)}")
+        logger.error(f"Anonimlik kontrol hatası: {str(e)}")
         return []
 
 def get_ip_classification(ip):
-    """Classify IP address type."""
     try:
         ip_obj = ipaddress.ip_address(ip)
         if ip_obj.is_private:
-            return "Private", "Private network usage (LAN)"
+            return "Private", "Özel ağ kullanımı (LAN)"
         elif ip_obj.is_multicast:
-            return "Multicast", "Multicast network"
+            return "Multicast", "Çoklu yayın ağı"
         elif ip_obj.is_global:
-            return "Public", "Public internet"
+            return "Public", "Genel internet"
         else:
-            return "Special", "Special use"
+            return "Special", "Özel kullanım"
     except ValueError:
-        return "Invalid", "Invalid IP address"
+        return "Invalid", "Geçersiz IP adresi"
 
 def robust_get_request(url, retries=3, backoff_factor=0.5, **kwargs):
-    """Make robust HTTP request with retries."""
     headers = kwargs.get('headers', {})
     headers.setdefault('User-Agent', 'Luminet/1.0 (Network Analysis Tool)')
     kwargs['headers'] = headers
@@ -1066,22 +1431,23 @@ def robust_get_request(url, retries=3, backoff_factor=0.5, **kwargs):
             time.sleep(wait_time)
     return None
     
-# Routes
+# Rotalar
 @app.route("/", methods=["GET", "POST"])
 def index():
-    """Main analysis route."""
+    # Başlangıç değişkenlerini tanımla
     query = request.form.get("query", "").strip() if request.method == "POST" else ""
     main_data, additional_data, ipinfo_data, raw_json_str, error = None, None, None, None, None
-    traceroute_locations, origin_asn = None, None
+    traceroute_locations, asn_map_data, origin_asn = None, None, None
     reverse_dns, ping_data, port_scan, http_headers, ssl_info = None, None, None, None, None
-    dnsbl_results, security_report = None, None
+    dnsbl_results, security_report, bgp_graph_data = None, None, None
+    bgpview_prefix, mtr_data, peeringdb_data = None, None, None
 
-    # DNS variables
+    # Yeni DNS değişkenleri
     dns_records, authoritative_dns, dnssec_status = None, None, None
 
     if request.method == "POST" and query:
         try:
-            # Resolve domain or IP
+            # Alan adı veya IP'yi çözümle
             ip_to_query = query
             is_domain = False
             try:
@@ -1089,11 +1455,11 @@ def index():
                 ip_to_query = addr_info[0][4][0]
                 is_domain = True
             except socket.gaierror:
-                pass
+                pass  # Bu bir IP adresi olabilir
             except Exception as e:
-                logger.error(f"DNS resolution error: {str(e)}")
+                logger.error(f"DNS çözümleme hatası: {str(e)}")
 
-            # RDAP query
+            # RDAP sorgusu ile başla
             authoritative_url = get_authoritative_rdap_url(ip_to_query)
             if authoritative_url:
                 try:
@@ -1106,78 +1472,92 @@ def index():
                         main_data["summary"]["ip_class_desc"] = ip_class_desc
                     raw_json_str = json.dumps(raw_data, indent=2, ensure_ascii=False)
                 except requests.exceptions.HTTPError as http_err:
-                    error = f"API Error (Code: {http_err.response.status_code}): No record found for '{query}'."
+                    error = f"API Hatası (Kod: {http_err.response.status_code}): '{query}' için kayıt bulunamadı."
                 except Exception as e:
-                    error = f"RDAP data could not be retrieved: {str(e)}"
+                    error = f"RDAP verisi alınamadı: {str(e)}"
             else:
-                error = f"Authoritative RDAP server not found: {query}"
+                error = f"Yetkili RDAP sunucusu bulunamadı: {query}"
             
             if error:
                 logger.error(error)
 
-            # Additional analyses if no RDAP error
+            # RDAP'de hata yoksa, diğer analizleri paralel olarak yap
             if not error:
                 with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+                    # Paralel çalışacak görevleri tanımla
                     tasks = {
                         'ipinfo': executor.submit(get_ipinfo_details, ip_to_query),
                         'ripestat': executor.submit(get_additional_info_from_ripestat, ip_to_query),
                         'reverse_dns': executor.submit(get_reverse_dns, ip_to_query),
                         'ping': executor.submit(get_ping_latency, ip_to_query),
                         'dnsbl': executor.submit(check_dnsbl, ip_to_query),
+                        'mtr': executor.submit(run_mtr_analysis, ip_to_query),
+                        'bgpview': executor.submit(get_bgpview_prefix_details, ip_to_query),
                         'traceroute': executor.submit(enriched_traceroute, ip_to_query)
                     }
+                    # Sonuçları topla
                     results = {name: future.result() for name, future in tasks.items()}
 
                 ipinfo_data = results.get('ipinfo')
                 additional_data = results.get('ripestat')
                 reverse_dns = results.get('reverse_dns')
                 ping_data = results.get('ping')
+                mtr_data = results.get('mtr')
                 dnsbl_results = results.get('dnsbl')
+                bgpview_prefix = results.get('bgpview')
                 traceroute_locations = results.get('traceroute')
 
-                # DNS records for domains
+                # Alan adıysa DNS kayıtlarını al
                 if is_domain:
                     try:
                         dns_records = get_dns_records(query)
                         authoritative_dns = get_authoritative_dns(query)
                         dnssec_status = check_dnssec(query)
                     except Exception as e:
-                        logger.error(f"DNS query error: {str(e)}")
-                        dns_records, authoritative_dns, dnssec_status = {}, None, "Error"
+                        logger.error(f"DNS sorgu hatası: {str(e)}")
+                        # Hata durumunda boş döndür
+                        dns_records, authoritative_dns, dnssec_status = {}, None, "Hata"
 
-                # ASN lookup
-                if ipinfo_data and ipinfo_data.get('as'):
-                    origin_asn = ipinfo_data['as'].replace("AS", "")
+                # ASN'yi ipinfo'dan al, yoksa RIPEstat'tan dene
+                if ipinfo_data and ipinfo_data.get('asn'):
+                    origin_asn = ipinfo_data['asn'].get('asn', '').replace("AS", "")
                 else:
                     origin_asn = get_asn_from_ip(ip_to_query)
+                
+                # ASN bilgisiyle PeeringDB'yi sorgula (bu sıralı olmalı)
+                peeringdb_data = get_peeringdb_info(origin_asn)
 
-                # HTTP and SSL analysis
+                # Sıralı çalışması gereken diğer görevler
                 target_host = query if is_domain else ip_to_query
                 http_headers = get_http_headers(target_host)
                 if http_headers and not http_headers.get("error"):
                     ssl_info = analyze_ssl(target_host)
 
-                # Port scanning
                 if NMAP_AVAILABLE:
                     port_scan = scan_ports(ip_to_query)
                 else:
-                    port_scan = {"error": "Nmap not installed"}
+                    port_scan = {"error": "Nmap kurulu değil"}
+
+                _, asn_map_data = get_asn_map_data(ip_to_query)
 
-                # Security report
                 security_report = generate_security_report(
                     ipinfo_data, http_headers, port_scan, dnsbl_results, ip_to_query
                 )
 
+                if additional_data and 'BGP Durumu' in additional_data:
+                    bgp_graph_data = process_bgp_data_for_d3(additional_data['BGP Durumu'], origin_asn)
+
         except requests.exceptions.ConnectionError as conn_err:
-            error = f"Connection error: {str(conn_err)}"
+            error = f"Bağlantı hatası: {str(conn_err)}"
             logger.error(error)
         except Exception as e:
-            error = f"An unexpected error occurred: {str(e)}"
-            logger.error(f"Main process error: {str(e)}", exc_info=True)
+            error = f"Beklenmedik bir hata oluştu: {str(e)}"
+            logger.error(f"Ana işlem hatası: {str(e)}", exc_info=True)
             
     elif request.method == "POST" and not query:
-        error = "Please enter an IP address or domain name."
+        error = "Lütfen bir IP adresi veya alan adı girin."
     
+    # Tüm toplanan verileri şablona gönder
     return render_template(
         "index.html",
         query=query,
@@ -1192,44 +1572,19 @@ def index():
         port_scan=port_scan,
         http_headers=http_headers,
         ssl_info=ssl_info,
-        dnsbl_results=dnsbl_results,
-        security_report=security_report,
         traceroute_locations=traceroute_locations,
+        asn_map_data=asn_map_data,
+        security_report=security_report,
+        bgp_graph_data=bgp_graph_data,
+        origin_asn=origin_asn,
+        bgpview_prefix=bgpview_prefix,
+        mtr_data=mtr_data,
+        peeringdb_data=peeringdb_data,
         dns_records=dns_records,
         authoritative_dns=authoritative_dns,
-        dnssec_status=dnssec_status,
-        origin_asn=origin_asn
+        dnssec_status=dnssec_status
     )
 
-# API endpoint for external access
-@app.route("/api/analyze", methods=["POST"])
-def api_analyze():
-    """API endpoint for programmatic access."""
-    try:
-        data = request.get_json()
-        if not data or 'ip' not in data:
-            return jsonify({'error': 'IP address is required'}), 400
-        
-        ip = data['ip'].strip()
-        if not ip:
-            return jsonify({'error': 'IP address cannot be empty'}), 400
-
-        # Basic analysis
-        ipinfo_data = get_ipinfo_details(ip)
-        ping_data = get_ping_latency(ip)
-        reverse_dns = get_reverse_dns(ip)
-        
-        return jsonify({
-            'ip': ip,
-            'ipinfo': ipinfo_data,
-            'ping': ping_data,
-            'reverse_dns': reverse_dns,
-        })
-    
-    except Exception as e:
-        logger.error(f"API error: {str(e)}")
-        return jsonify({'error': 'Internal server error'}), 500
-
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     app.run(host="0.0.0.0", port=port, debug=False)