Update main.py

main.py

@@ -607,6 +607,331 @@ def get_asn_from_ip(ip):
         logger.error(f"ASN lookup failed: {str(e)}")
         return None
 
+def get_asn_path_locations(asn):
+    try:
+        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 error: {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 (Network Analysis Tool)"}
+        r = requests.get(OSM_NOMINATIM_URL, params=params, headers=headers, timeout=5)
+        r.raise_for_status()
+        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 Error] {country_code}: {str(e)}")
+        return None, 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 get_bgpview_prefix_details(ip):
+    """
+    BGPView API to get detailed prefix information for an IP address
+    """
+    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", {})
+            # Get the most specific prefix (longest)
+            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 details failed: {str(e)}")
+        return None
+
+def get_peeringdb_info(asn):
+    """
+    PeeringDB API to get ASN information
+    """
+    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 info failed: {str(e)}")
+        return None
+
+def run_mtr_analysis(ip):
+    if not ip or not isinstance(ip, str):
+        return {"error": "Invalid IP address or 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"Target hostname could not be resolved: {ip}. Please enter a valid IP or hostname."
+            elif "No such device" in error_msg or "Cannot find device" in error_msg:
+                user_error = "Network interface error: MTR could not find the required network device."
+            elif "Operation not permitted" in error_msg or "Permission denied" in error_msg:
+                user_error = "Permission error: MTR requires 'sudo' privileges."
+            else:
+                user_error = "MTR analysis failed."
+            
+            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 returned empty results. Target may be unreachable."
+            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 output could not be parsed. Format error.",
+                "details": f"JSON parsing error: {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 analysis timed out ({ip})"
+        logger.error(error_msg)
+        result.update({
+            "error": "MTR analysis timed out. Target took too long to reach or network blocked.",
+            "details": "Analysis took longer than 60 seconds.",
+            "raw_output": stdout,
+            "raw_error": stderr
+        })
+        
+    except FileNotFoundError:
+        logger.error("MTR command not found. Please ensure 'mtr' is installed on your system.")
+        result.update({
+            "error": "MTR command not found. 'mtr' is not installed on server.",
+            "details": "Please install MTR with 'sudo apt-get install mtr' or similar command."
+        })
+    except PermissionError as e:
+        logger.error(f"Permission error running MTR: {e}")
+        result.update({
+            "error": "Permission error running MTR.",
+            "details": f"Insufficient permissions to run MTR command. Error: {e}. Check 'sudo' configuration."
+        })
+    except Exception as e:
+        logger.error(f"MTR unexpected error for {ip}: {e}")
+        result.update({
+            "error": "An unexpected error occurred.",
+            "details": str(e)
+        })
+        
+    return result
+
+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", "Unknown"),
+            "target_prefix": entry.get("target_prefix", "Unknown")
+        }
+
+        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_authoritative_rdap_url(query):
     query = query.strip().upper().replace("AS", "")
     is_ip = "." in query or ":" in query
@@ -1083,6 +1408,8 @@ def index():
                         '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)
                     }
                     results = {name: future.result() for name, future in tasks.items()}
@@ -1091,7 +1418,9 @@ def index():
                 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
@@ -1109,6 +1438,9 @@ def index():
                     origin_asn = ipinfo_data['asn'].get('asn', '').replace("AS", "")
                 else:
                     origin_asn = get_asn_from_ip(ip_to_query)
+                
+                # ASN info with PeeringDB (sequential as it depends on ASN)
+                peeringdb_data = get_peeringdb_info(origin_asn)
 
                 # HTTP and SSL analysis
                 target_host = query if is_domain else ip_to_query
@@ -1122,11 +1454,18 @@ def index():
                 else:
                     port_scan = {"error": "Nmap not installed"}
 
+                # ASN map data
+                _, 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
                 )
 
+                # BGP graph data
+                if additional_data and 'BGP State' in additional_data:
+                    bgp_graph_data = process_bgp_data_for_d3(additional_data['BGP State'], origin_asn)
+
         except requests.exceptions.ConnectionError as conn_err:
             error = f"Connection error: {str(conn_err)}"
             logger.error(error)
@@ -1154,10 +1493,15 @@ def index():
         dnsbl_results=dnsbl_results,
         security_report=security_report,
         traceroute_locations=traceroute_locations,
+        asn_map_data=asn_map_data,
+        bgp_graph_data=bgp_graph_data,
         dns_records=dns_records,
         authoritative_dns=authoritative_dns,
         dnssec_status=dnssec_status,
-        origin_asn=origin_asn
+        origin_asn=origin_asn,
+        bgpview_prefix=bgpview_prefix,
+        mtr_data=mtr_data,
+        peeringdb_data=peeringdb_data
     )
 
 # API endpoint for external access