yougotmapped 1.0.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

yougotmapped/utils/ingress.py

@@ -0,0 +1,67 @@
+# Ingress Geography Finder
+
+from yougotmapped.utils.network import get_hop_location
+
+
+def find_ingress_geography(trace_result: dict, target_asn: int | None) -> dict:
+    
+    if not trace_result or not target_asn:
+        return {
+            "available": False,
+            "reason": "missing_data",
+        }
+
+    hops = trace_result.get("hops", [])
+    previous_asn = None
+
+    for hop in hops:
+        if hop.get("private"):
+            continue
+
+        hop_asn = hop.get("asn")
+        hop_ip = hop.get("ip")
+
+        if hop_asn is None:
+            previous_asn = hop_asn
+            continue
+
+        if previous_asn != hop_asn and hop_asn == target_asn:
+            loc = get_hop_location(hop_ip)
+            if not loc:
+                return {
+                    "available": False,
+                    "reason": "geo_lookup_failed",
+                }
+
+            lat, lon = loc
+
+            return {
+                "available": True,
+                "ingress_hop": hop["hop"],
+                "ip": hop_ip,
+                "asn": hop_asn,
+                "latitude": lat,
+                "longitude": lon,
+            }
+
+        previous_asn = hop_asn
+
+    return {
+        "available": False,
+        "reason": "ingress_not_detected",
+    }
+
+
+def format_ingress_result(result: dict) -> None:
+    
+    if not result.get("available"):
+        print("Ingress geography could not be determined.")
+        return
+
+    print("Ingress Geography:")
+    print(f"  Hop:        {result['ingress_hop']}")
+    print(f"  IP:         {result['ip']}")
+    print(f"  ASN:        AS{result['asn']}")
+    print(
+        f"  Coordinates:{result['latitude']:.3f}, {result['longitude']:.3f}"
+    )

yougotmapped/utils/jitter.py

@@ -0,0 +1,78 @@
+# Jitter Utilities
+
+from ping3 import ping
+import statistics
+
+
+def jitter_test(host: str, count: int = 20, timeout: float = 1.0) -> dict:
+
+    rtts = []
+
+    for _ in range(count):
+        try:
+            delay = ping(host, timeout=timeout)
+            if delay is not None:
+                rtts.append(delay * 1000)  # ms
+        except Exception:
+            continue
+
+    sent = count
+    received = len(rtts)
+    lost = sent - received
+
+    if received < 2:
+        return {
+            "reachable": False,
+            "sent": sent,
+            "received": received,
+            "packet_loss_percent": round((lost / sent) * 100, 1),
+        }
+
+    median_rtt = statistics.median(rtts)
+
+    jitter_ms = statistics.mean(abs(rtt - median_rtt) for rtt in rtts)
+
+    min_rtt = round(min(rtts), 2)
+    max_rtt = round(max(rtts), 2)
+    median_rtt = round(median_rtt, 2)
+    jitter_ms = round(jitter_ms, 2)
+
+    if jitter_ms < 3:
+        stability = "stable"
+    elif jitter_ms < 10:
+        stability = "moderate"
+    else:
+        stability = "unstable"
+
+    return {
+        "reachable": True,
+        "sent": sent,
+        "received": received,
+        "packet_loss_percent": round((lost / sent) * 100, 1),
+        "rtt_ms": {
+            "min": min_rtt,
+            "median": median_rtt,
+            "max": max_rtt,
+        },
+        "jitter_ms": jitter_ms,
+        "stability": stability,
+    }
+
+
+def format_jitter_result(result: dict) -> None:
+    
+    if not result.get("reachable"):
+        print("Jitter test failed (insufficient replies).")
+        return
+
+    print(f"Packets: sent={result['sent']} received={result['received']}")
+    print(f"Packet loss: {result['packet_loss_percent']}%")
+
+    rtt = result["rtt_ms"]
+    print(
+        f"RTT (ms): min={rtt['min']} "
+        f"median={rtt['median']} max={rtt['max']}"
+    )
+
+    print(f"Jitter: {result['jitter_ms']} ms")
+    print(f"Stability: {result['stability'].upper()}")

yougotmapped/utils/mapping.py

@@ -1,66 +1,117 @@
-# utils/mapping.py
+from pathlib import Path
 import folium
 
-def plot_ip_location(ip_data, color='red', map_object=None):
-    if 'loc' not in ip_data:
-        print("Location data not available.")
-        return
+DEFAULT_GEO_RADIUS_KM = 40  # IP geolocation uncertainty radius
 
-    latitude, longitude = map(float, ip_data['loc'].split(','))
 
-    m = map_object if map_object else folium.Map(location=[latitude, longitude], zoom_start=12)
+def plot_ip_location(geo: dict):
 
+    lat = geo.get("latitude")
+    lon = geo.get("longitude")
+
+    if lat is None or lon is None:
+        return None
+
+    m = folium.Map(location=[lat, lon], zoom_start=6)
+
+    # Destination marker
     folium.Marker(
-        [latitude, longitude],
-        popup=f"IP: {ip_data.get('ip', 'N/A')}\nCity: {ip_data.get('city', 'N/A')}\nRegion: {ip_data.get('region', 'N/A')}\nCountry: {ip_data.get('country', 'N/A')}",
-        icon=folium.Icon(color=color)
+        location=[lat, lon],
+        popup=f"IP: {geo.get('ip')}",
+        icon=folium.Icon(color="red", icon="info-sign"),
     ).add_to(m)
 
+    # Uncertainty circle 
     folium.Circle(
-        radius=10000,
-        location=[latitude, longitude],
-        color=color,
+        location=[lat, lon],
+        radius=DEFAULT_GEO_RADIUS_KM * 1000,  # meters
+        color="red",
         fill=True,
-        fill_color=color,
-        fill_opacity=0.2,
-        popup="Approximate Area"
+        fill_color="red",
+        fill_opacity=0.15,
+        popup="Approximate IP geolocation",
     ).add_to(m)
 
     return m
 
 
-def plot_multiple_ip_locations(ip_data_list):
-    if not ip_data_list:
-        print("No valid IP data to plot.")
-        return
+def plot_multiple_ip_locations(geos: list[dict]):
 
-    center_data = next((d for d in ip_data_list if 'loc' in d), None)
-    if not center_data:
-        print("No valid location data found in input list.")
-        return
+    coords = [
+        (g.get("latitude"), g.get("longitude"))
+        for g in geos
+        if g.get("latitude") is not None and g.get("longitude") is not None
+    ]
 
-    latitude, longitude = map(float, center_data['loc'].split(','))
-    m = folium.Map(location=[latitude, longitude], zoom_start=2)
+    if not coords:
+        return None
 
-    for data in ip_data_list:
-        if 'loc' not in data:
+    avg_lat = sum(lat for lat, _ in coords) / len(coords)
+    avg_lon = sum(lon for _, lon in coords) / len(coords)
+
+    m = folium.Map(location=[avg_lat, avg_lon], zoom_start=3)
+
+    for geo in geos:
+        lat = geo.get("latitude")
+        lon = geo.get("longitude")
+        if lat is None or lon is None:
             continue
-        lat, lon = map(float, data['loc'].split(','))
+
         folium.Marker(
-            [lat, lon],
-            popup=f"IP: {data.get('ip', 'N/A')}\nCity: {data.get('city', 'N/A')}\nRegion: {data.get('region', 'N/A')}\nCountry: {data.get('country', 'N/A')}",
-            icon=folium.Icon(color='red')
+            location=[lat, lon],
+            popup=f"IP: {geo.get('ip')}",
+            icon=folium.Icon(color="red", icon="info-sign"),
         ).add_to(m)
 
         folium.Circle(
-            radius=10000,
             location=[lat, lon],
-            color='red',
+            radius=DEFAULT_GEO_RADIUS_KM * 1000,
+            color="red",
+            fill=True,
+            fill_color="red",
+            fill_opacity=0.15,
+        ).add_to(m)
+
+    return m
+
+
+def plot_traceroute_path(trace_result: dict, m):
+
+    hops = trace_result.get("hops", [])
+    prev = None
+
+    for hop in hops:
+        lat = hop.get("latitude")
+        lon = hop.get("longitude")
+
+        if lat is None or lon is None:
+            continue
+
+        point = [lat, lon]
+
+        # Hop marker (no circle)
+        folium.CircleMarker(
+            location=point,
+            radius=4,
+            color="blue",
             fill=True,
-            fill_color='red',
-            fill_opacity=0.2,
-            popup="Approximate Area"
+            fill_opacity=0.9,
+            popup=f"Hop {hop.get('hop')} ({hop.get('ip')})",
         ).add_to(m)
 
-    m.save('ip_geolocation_map.html')
-    print("Map saved with multiple IPs as 'ip_geolocation_map.html'")
+        if prev:
+            folium.PolyLine(
+                locations=[prev, point],
+                color="blue",
+                weight=2,
+                opacity=0.6,
+            ).add_to(m)
+
+        prev = point
+
+
+def save_map(m, filename: str) -> str:
+    
+    path = Path(filename).resolve()
+    m.save(str(path))
+    return str(path)

yougotmapped/utils/mss.py

@@ -0,0 +1,132 @@
+import random
+import time
+from typing import Dict, Optional
+
+try:
+    from scapy.all import IP, TCP, sr1, conf
+    SCAPY_AVAILABLE = True
+    conf.verb = 0
+except Exception:
+    SCAPY_AVAILABLE = False
+
+def _probe_mss(
+    host: str,
+    port: int,
+    mss: int,
+    timeout: float = 1.0,
+) -> bool:
+    sport = random.randint(1024, 65535)
+
+    pkt = (
+        IP(dst=host, flags="DF")
+        / TCP(
+            sport=sport,
+            dport=port,
+            flags="S",
+            seq=1000,
+            options=[("MSS", mss)],
+        )
+    )
+
+    resp = sr1(pkt, timeout=timeout)
+    if resp is None:
+        return False
+
+    if resp.haslayer(TCP):
+        flags = resp[TCP].flags
+        return (flags & 0x12) == 0x12  # SYN+ACK
+
+    return False
+
+
+def _estimate_mss(
+    rtt_ms: Optional[float],
+    traceroute_ok: bool,
+) -> Dict:
+    if rtt_ms is None or not traceroute_ok:
+        return {
+            "mss": 1360,
+            "confidence": "low",
+            "reason": "mobile_or_cgnat_likely",
+        }
+
+    if rtt_ms > 40:
+        return {
+            "mss": 1360,
+            "confidence": "low",
+            "reason": "high_rtt_path",
+        }
+
+    if rtt_ms > 20:
+        return {
+            "mss": 1420,
+            "confidence": "medium",
+            "reason": "possible_tunneling",
+        }
+
+    return {
+        "mss": 1460,
+        "confidence": "medium",
+        "reason": "standard_ethernet_assumed",
+    }
+
+def discover_mss(
+    host: str,
+    port: int = 443,
+    *,
+    median_rtt_ms: Optional[float] = None,
+    traceroute_ok: bool = True,
+) -> Dict:
+    MIN_MSS = 536
+    MAX_MSS = 1460
+
+    if SCAPY_AVAILABLE:
+        try:
+            if _probe_mss(host, port, MIN_MSS):
+                low = MIN_MSS
+                high = MAX_MSS
+                best = MIN_MSS
+
+                while low <= high:
+                    mid = (low + high) // 2
+                    if _probe_mss(host, port, mid):
+                        best = mid
+                        low = mid + 1
+                    else:
+                        high = mid - 1
+                    time.sleep(0.05)
+
+                return {
+                    "reachable": True,
+                    "method": "tcp-mss",
+                    "mss": best,
+                    "confidence": "high",
+                }
+
+        except PermissionError:
+            pass
+        except Exception:
+            pass
+
+    est = _estimate_mss(median_rtt_ms, traceroute_ok)
+
+    return {
+        "reachable": True,
+        "method": "estimated",
+        "mss": est["mss"],
+        "confidence": est["confidence"],
+        "reason": est["reason"],
+    }
+
+
+def format_mss_result(result: Dict) -> None:
+    if not result.get("reachable"):
+        print("MSS unavailable.")
+        return
+
+    print(f"TCP MSS:  {result['mss']} bytes")
+    print(f"Method:   {result['method'].upper()}")
+    print(f"Confidence: {result.get('confidence', 'unknown').upper()}")
+
+    if result.get("method") == "estimated":
+        print(f"Reason:   {result.get('reason')}")

yougotmapped/utils/mtu.py

@@ -0,0 +1,81 @@
+import platform
+import subprocess
+
+
+def _ping_df(host: str, payload_size: int, timeout: int = 1) -> bool:
+
+    system = platform.system()
+
+    if system == "Windows":
+        cmd = [
+            "ping",
+            "-n", "1",
+            "-f",
+            "-l", str(payload_size),
+            host,
+        ]
+    else:
+        cmd = [
+            "ping",
+            "-c", "1",
+            "-M", "do",
+            "-s", str(payload_size),
+            host,
+        ]
+
+    try:
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=timeout,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def discover_mtu(host: str) -> dict:
+    low = 1200
+    high = 1472  # Ethernet MTU (1500)
+    best = None
+
+    while low <= high:
+        mid = (low + high) // 2
+
+        if _ping_df(host, mid):
+            best = mid
+            low = mid + 1
+        else:
+            high = mid - 1
+
+    if best is None:
+        return {
+            "reachable": False,
+        }
+
+    mtu = best + 28  # add IP (20) + ICMP (8)
+
+    if mtu >= 1500:
+        path_type = "standard"
+    elif mtu >= 1400:
+        path_type = "pppoe / light tunneling"
+    else:
+        path_type = "vpn / heavy tunneling"
+
+    return {
+        "reachable": True,
+        "mtu": mtu,
+        "payload_size": best,
+        "path_type": path_type,
+    }
+
+
+def format_mtu_result(result: dict) -> None:
+    if not result.get("reachable"):
+        print("MTU discovery failed (host unreachable or blocked).")
+        return
+
+    print(f"Path MTU: {result['mtu']} bytes")
+    print(f"Payload Size: {result['payload_size']} bytes")
+    print(f"Inference: {result['path_type'].upper()}")

yougotmapped/utils/network.py

@@ -1,34 +1,95 @@
-# utils/network.py
 import requests
-import ipaddress
 import socket
+import ipaddress
+
+def is_private_ip(ip: str) -> bool:
+    try:
+        return ipaddress.ip_address(ip).is_private
+    except ValueError:
+        return False
+
+
+def is_valid_ip(value: str) -> bool:
+    try:
+        ipaddress.ip_address(value)
+        return True
+    except ValueError:
+        return False
 
+def get_public_ip() -> str | None:
+    try:
+        r = requests.get("https://api.ipify.org", timeout=5)
+        r.raise_for_status()
+        return r.text.strip()
+    except Exception:
+        return None
 
-def get_public_ip():
+def resolve_domain_to_ip(domain: str) -> str | None:
     try:
-        response = requests.get('https://api.ipify.org')
-        response.raise_for_status()
-        return response.text
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching public IP: {e}")
+        return socket.gethostbyname(domain)
+    except socket.gaierror:
         return None
 
 
-def get_geolocation(ip_or_domain, api_token):
-    url = f"https://ipinfo.io/{ip_or_domain}/json"
-    params = {'token': api_token} if api_token else {}
+def get_geolocation(target: str) -> dict | None:
+    ip = target
+
+    if not is_valid_ip(target):
+        ip = resolve_domain_to_ip(target)
+        if not ip:
+            return None
+
+    if is_private_ip(ip):
+        return {
+            "ip": ip,
+            "private": True,
+            "note": "Private / non-routable address",
+        }
+
     try:
-        response = requests.get(url, params=params)
-        response.raise_for_status()
-        return response.json()
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching geolocation data: {e}")
+        r = requests.get(
+            f"https://ipwho.is/{ip}",
+            timeout=6,
+        )
+        data = r.json()
+    except Exception:
+        return None
+
+    if not data.get("success", False):
         return None
 
+    return {
+        "ip": ip,
+        "hostname": data.get("hostname"),
+        "org": data.get("connection", {}).get("isp"),
+        "country": data.get("country"),
+        "region": data.get("region"),
+        "city": data.get("city"),
+        "postal": data.get("postal"),
+        "latitude": data.get("latitude"),
+        "longitude": data.get("longitude"),
+        "timezone": data.get("timezone", {}).get("id"),
+        "raw": data,
+    }
+
+
+def get_hop_location(ip: str) -> dict | None:
+    if is_private_ip(ip):
+        return None
 
-def resolve_domain_to_ip(domain):
     try:
-        return socket.gethostbyname(domain)
-    except socket.gaierror:
-        print(f"Could not resolve domain: {domain}")
+        r = requests.get(
+            f"http://ip-api.com/json/{ip}?fields=status,lat,lon",
+            timeout=4,
+        )
+        data = r.json()
+    except Exception:
         return None
+
+    if data.get("status") != "success":
+        return None
+
+    return {
+        "latitude": data.get("lat"),
+        "longitude": data.get("lon"),
+    }