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

yougotmapped/cli.py

@@ -1,174 +1,217 @@
-import os
-import sys
 import argparse
-import ipaddress
-from datetime import datetime
 from pathlib import Path
+from datetime import datetime
 
 from yougotmapped.utils.dependencies import check_dependencies
-from yougotmapped.utils.network import get_public_ip, get_geolocation, resolve_domain_to_ip
-from yougotmapped.utils.mapping import plot_ip_location, plot_multiple_ip_locations
-from yougotmapped.utils.token import get_api_token
-from yougotmapped.utils.ping import ping_target
-from yougotmapped.utils.trace import run_traceroute
+from yougotmapped.utils.network import get_public_ip, get_geolocation
+from yougotmapped.utils.ping import ping_target, format_ping_result
+from yougotmapped.utils.jitter import jitter_test, format_jitter_result
+from yougotmapped.utils.mss import discover_mss, format_mss_result
+from yougotmapped.utils.bandwidth import estimate_bandwidth, format_bandwidth_result
+from yougotmapped.utils.trace import run_traceroute, format_traceroute
 from yougotmapped.utils.anonymity import detect_anonymity, format_anonymity_result
-from yougotmapped.utils.output import write_formatted_output
+from yougotmapped.utils.mapping import (
+    plot_ip_location,
+    plot_multiple_ip_locations,
+    plot_traceroute_path,
+    save_map,
+)
+from yougotmapped.utils.output import write_output
 
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Geolocate IPs/domains, analyze network paths, and visualize routing."
+    )
 
-def main():
-    parser = argparse.ArgumentParser(description="Geolocate one or more IPs/domains and generate an interactive map.")
-    parser.add_argument('-i', '--ip', nargs='*', help="One or more IPs/domains separated by space")
-    parser.add_argument('-f', '--file', type=str, help="Path to a file containing IPs/domains (one per line)")
-    parser.add_argument('-p', '--ping', action='store_true', help="Ping each IP or domain and show latency")
-    parser.add_argument('-t', '--trace', action='store_true', help="Show traceroute to each IP or domain")
-    parser.add_argument('-c', '--hidecheck', action='store_true', help="Check if the IP is a Tor exit node or VPN")
-    parser.add_argument('-o', '--output', type=str, help="Specify output file or use format shorthand (e.g., f:csv, f:json, f:normal)")
-    parser.add_argument('--no-map', action='store_true', help="Do not generate a map")
-    parser.add_argument('--delete-map', action='store_true', help="Delete the map after generating")
-    args = parser.parse_args()
+    parser.add_argument("-i", "--ip", nargs="*", help="IP addresses or domains")
+    parser.add_argument("-f", "--file", help="File with IPs/domains (one per line)")
 
-    check_dependencies()
+    parser.add_argument("-p", "--ping", action="store_true", help="Ping test")
+    parser.add_argument("-j", "--jitter", action="store_true", help="Jitter analysis")
+    parser.add_argument("-m", "--mtu", action="store_true", help="MTU/MSS discovery")
+    parser.add_argument("-b", "--bandwidth", action="store_true", help="Bandwidth estimate")
+    parser.add_argument("-t", "--trace", action="store_true", help="Traceroute")
+
+    parser.add_argument("-c", "--hidecheck", action="store_true", help="Anonymity detection")
+    parser.add_argument("-a", "--all", action="store_true", help="Run all modules")
+
+    parser.add_argument("--no-map", action="store_true", help="Disable map output")
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Output file or shorthand (f:json, f:csv, f:normal)",
+    )
+
+    return parser.parse_args()
 
-    API_TOKEN = get_api_token()
-    if not API_TOKEN:
-        return
 
-    targets = []
+def collect_targets(args) -> list[str]:
+    targets: list[str] = []
 
     if args.ip:
         targets.extend(args.ip)
 
     if args.file:
         try:
-            with open(args.file, 'r') as f:
+            with open(args.file, "r") as f:
                 targets.extend(line.strip() for line in f if line.strip())
         except FileNotFoundError:
             print(f"File not found: {args.file}")
-            return
 
     if not targets:
-        print("No IP or file input provided. Defaulting to public IP lookup.")
-        ip_or_domain = get_public_ip()
-        if not ip_or_domain:
-            print("Could not determine your public IP.")
-            return
-        targets = [ip_or_domain]
+        print("No input provided. Defaulting to public IP.")
+        public_ip = get_public_ip()
+        if public_ip:
+            targets.append(public_ip)
+
+    return targets
+
+
+def print_geo_rich(geo: dict) -> None:
+    raw = geo.get("raw", {})
+    connection = raw.get("connection", {})
+    timezone = raw.get("timezone", {})
+
+    print("\n[ GEOLOCATION ]")
+    print(f"IP:            {raw.get('ip')}")
+    print(f"Type:          {raw.get('type')}")
+    print(f"ASN:           AS{connection.get('asn')}" if connection.get("asn") else "ASN:           N/A")
+    print(f"ISP / Org:     {connection.get('org') or connection.get('isp') or 'N/A'}")
+    print(f"Domain:        {connection.get('domain') or 'N/A'}")
+
+    print("\n[ LOCATION ]")
+    print(f"Continent:     {raw.get('continent')} ({raw.get('continent_code')})")
+    print(f"Country:       {raw.get('country')} ({raw.get('country_code')})")
+    print(f"Region:        {raw.get('region')} ({raw.get('region_code')})")
+    print(f"City:          {raw.get('city')}")
+    print(f"Postal Code:   {raw.get('postal') or ''}")
+    print(f"Latitude:      {raw.get('latitude')}")
+    print(f"Longitude:     {raw.get('longitude')}")
+    print(f"Capital:       {raw.get('capital')}")
+    print(f"Borders:       {raw.get('borders')}")
+
+    print("\n[ TIMEZONE ]")
+    print(f"Zone:          {timezone.get('id')}")
+    print(f"Abbreviation:  {timezone.get('abbr')}")
+    print(f"UTC Offset:    {timezone.get('utc')}")
+    print(f"DST Active:    {timezone.get('is_dst')}")
+    print(f"Local Time:    {timezone.get('current_time')}")
 
-    geolocated = []  
-    full_results = [] 
+
+def main():
+    args = parse_args()
+    check_dependencies()
+
+    if args.all:
+        args.ping = True
+        args.jitter = True
+        args.mtu = True
+        args.bandwidth = True
+        args.trace = True
+        args.hidecheck = True
+
+    targets = collect_targets(args)
+    if not targets:
+        print("No valid targets to process.")
+        return
+
+    results = []
+    geos_for_map = []
+    last_trace_result = None
 
     for target in targets:
-        target_result = {}
-        try:
-            ipaddress.ip_address(target)
-            ip_or_domain = target
-        except ValueError:
-            resolved_ip = resolve_domain_to_ip(target)
-            if resolved_ip:
-                ip_or_domain = resolved_ip
-            else:
-                print(f"Skipping unresolved domain: {target}")
+        print(f"\nTarget: {target}")
+
+        geo = get_geolocation(target)
+        if not geo:
+            print("Failed to retrieve geolocation data.")
+            continue
+
+        results.append(geo)
+        geos_for_map.append(geo)
+
+        print_geo_rich(geo)
+
+        ping_result = None
+        trace_result = None
+
+        if args.ping:
+            print("\n[ PING ]")
+            ping_result = ping_target(target)
+            format_ping_result(ping_result)
+            geo["ping"] = ping_result
+
+            if not ping_result.get("reachable"):
+                print("Stopping analysis: host unreachable.")
                 continue
 
-        print(f"Looking up location for {target}...")
-        data = get_geolocation(ip_or_domain, API_TOKEN)
-        if data:
-            geolocated.append(data)
-            target_result.update(data)
-            print("---")
-            for key in ['ip', 'hostname', 'city', 'region', 'country', 'loc', 'org', 'postal', 'timezone']:
-                print(f"{key.title()}: {data.get(key, 'N/A')}")
-
-            if args.ping:
-                print("\n[ PING RESULT ]")
-                ping_result = ping_target(target)
-                print(ping_result)
-                target_result["ping"] = ping_result
-
-            if args.trace:
-                print("\n[ TRACEROUTE RESULT ]")
-                trace_output = run_traceroute(target)
-                print(trace_output)
-                target_result["traceroute"] = trace_output
-            
-            if args.hidecheck:
-                print("\n[ ANONYMITY CHECK ]")
-                anonymity = detect_anonymity(data)
-                format_anonymity_result(anonymity)
-                target_result["anonymity"] = anonymity
-
-            print("---")
-            full_results.append(target_result)
+        if args.jitter:
+            print("\n[ JITTER ]")
+            jitter_result = jitter_test(target)
+            format_jitter_result(jitter_result)
+            geo["jitter"] = jitter_result
+
+        if args.mtu:
+            print("\n[ MSS ]")
+            mss_result = discover_mss(target)
+            format_mss_result(mss_result)
+            geo["mss"] = mss_result
+
+        if args.bandwidth:
+            print("\n[ BANDWIDTH ]")
+            bandwidth_result = estimate_bandwidth(ping_result)
+            format_bandwidth_result(bandwidth_result)
+            geo["bandwidth"] = bandwidth_result
+
+        if args.trace:
+            print("\n[ TRACEROUTE ]")
+            trace_result = run_traceroute(target)
+            format_traceroute(trace_result)
+            geo["traceroute"] = trace_result
+            last_trace_result = trace_result
+
+        if args.hidecheck:
+            print("\n[ ANONYMITY ]")
+            anonymity = detect_anonymity(geo)
+            format_anonymity_result(anonymity)
+            geo["anonymity"] = anonymity
+
+
+    map_path = None
+    if geos_for_map and not args.no_map:
+        if len(geos_for_map) == 1:
+            m = plot_ip_location(geos_for_map[0])
+            if m and args.trace and last_trace_result:
+                plot_traceroute_path(last_trace_result, m)
         else:
-            print(f"Failed to get location data for {target}.")
-
-    # --- Output & Summary ---
-    map_saved = False
-    map_path = Path("ip_geolocation_map.html").resolve()
-    log_path = None
-
-    if not args.no_map and geolocated:
-        if len(geolocated) == 1:
-            m = plot_ip_location(geolocated[0], color="red")
-
-            if args.trace and isinstance(trace_output, str):
-                lines = trace_output.strip().split("\n")
-                for line in reversed(lines):
-                    if "(" in line and ")" in line:
-                        last_ip = line.split()[1]
-                        try:
-                            ipaddress.ip_address(last_ip)
-                            last_data = get_geolocation(last_ip, API_TOKEN)
-                            if last_data:
-                                plot_ip_location(last_data, color="blue", map_object=m)
-                        except Exception:
-                            pass
-                        break
-            if m:
-                m.save(str(map_path))
-                map_saved = True
-
-        elif len(geolocated) > 1:
-            plot_multiple_ip_locations(geolocated)
-            map_saved = True
-
-    if args.delete_map:
-        try:
-            os.remove(map_path)
-            map_saved = False
-        except FileNotFoundError:
-            pass
+            m = plot_multiple_ip_locations(geos_for_map)
+
+        if m:
+            map_path = save_map(m, "ip_geolocation_map.html")
 
+
+    output_path = None
     if args.output:
-        os.makedirs("logs", exist_ok=True)
-        now = datetime.now()
-        date_str = now.strftime("%m-%d-%y")
-        time_str = now.strftime("%H-%M")
+        Path("logs").mkdir(exist_ok=True)
+        timestamp = datetime.now().strftime("%m-%d-%y--%H-%M")
 
         if args.output.startswith("f:"):
-            fmt_type = args.output[2:].lower()
-            ext = {"json": "json", "csv": "csv"}.get(fmt_type, "txt")
-            target_name = targets[0].replace(":", "-").replace("/", "-")
-            filename = f"{target_name}--{date_str}--{time_str}--YouGotMapped.{ext}"
+            fmt = args.output[2:].lower()
+            ext = "json" if fmt == "json" else "csv" if fmt == "csv" else "txt"
+            name = targets[0].replace(":", "-").replace("/", "-")
+            filename = f"{name}--{timestamp}--YouGotMapped.{ext}"
         else:
             filename = args.output
-            fmt_type = filename.split('.')[-1].lower()
-            if fmt_type not in ["json", "csv", "txt"]:
-                fmt_type = "normal"
-
-        log_path = Path("logs") / filename
-        write_formatted_output(full_results, str(log_path), fmt_type=fmt_type)
-        log_path = log_path.resolve()
-
-    # Final summary
-    if map_saved or log_path:
-        print("\n----- OUTPUT SUMMARY -----")
-        if map_saved:
-            print(f"Map Location: {map_path}")
-            print(f"Map URL: file://{map_path}")
-        if log_path:
-            print(f"Log File: {log_path}")
-            print(f"Log URL: file://{log_path}")
+            fmt = filename.split(".")[-1].lower()
+
+        output_path = write_output(results, Path("logs") / filename, fmt=fmt)
+
+    if map_path or output_path:
+        print("\nOutput Summary")
+        if map_path:
+            print(f"  Map: file://{map_path}")
+        if output_path:
+            print(f"  Log: file://{output_path}")
 
 
 if __name__ == "__main__":

yougotmapped/utils/anonymity.py

@@ -1,53 +1,87 @@
-# utils/anonymity.py
-import requests
-import socket
+# yougotmapped/utils/anonymity.py
 
-TOR_EXIT_LIST = "https://check.torproject.org/torbulkexitlist"
+import requests
+from functools import lru_cache
 
-VPN_KEYWORDS = [
-    "vpn", "m247", "nord", "express", "ovh", "digitalocean", "linode",
-    "datacamp", "host", "colo", "server", "vultr", "heficed", "leaseweb"
-]
+TOR_EXIT_LIST_URL = "https://check.torproject.org/torbulkexitlist"
 
+VPN_KEYWORDS = {
+    "vpn", "proxy", "tor", "hosting", "cloud", "server", "colo",
+    "digitalocean", "linode", "ovh", "vultr", "hetzner", "leaseweb",
+    "m247", "nord", "express", "surfshark", "proton", "fastly",
+    "akamai", "cloudflare", "google", "amazon", "aws", "azure"
+}
 
-def is_tor_exit_node(ip):
+@lru_cache(maxsize=1)
+def _get_tor_exit_nodes() -> set[str]:
     try:
-        response = requests.get(TOR_EXIT_LIST, timeout=5)
-        exit_nodes = response.text.strip().splitlines()
-        return ip in exit_nodes
+        resp = requests.get(TOR_EXIT_LIST_URL, timeout=10)
+        resp.raise_for_status()
+        return set(
+            line.strip()
+            for line in resp.text.splitlines()
+            if line and not line.startswith("#")
+        )
     except Exception:
+        return set()
+
+
+def is_tor_exit_node(ip: str) -> bool:
+    if not ip:
         return False
+    return ip in _get_tor_exit_nodes()
 
+def _contains_vpn_keyword(value: str | None) -> bool:
+    if not value:
+        return False
+    value = value.lower()
+    return any(keyword in value for keyword in VPN_KEYWORDS)
 
-def detect_anonymity(ip_data):
-    org = ip_data.get("org", "").lower()
-    hostname = ip_data.get("hostname", "").lower()
+def detect_anonymity(ip_data: dict) -> dict:
     ip = ip_data.get("ip")
+    hostname = ip_data.get("hostname")
+    org = ip_data.get("org")
+    raw = ip_data.get("raw", {})
 
     tor = is_tor_exit_node(ip)
-    vpn = any(keyword in org or keyword in hostname for keyword in VPN_KEYWORDS)
 
-    result = {
+    # ipwho.is connection hints
+    connection = raw.get("connection", {})
+    isp = connection.get("isp")
+    domain = connection.get("domain")
+    asn = connection.get("asn")
+
+    vpn = any([
+        _contains_vpn_keyword(org),
+        _contains_vpn_keyword(hostname),
+        _contains_vpn_keyword(isp),
+        _contains_vpn_keyword(domain),
+    ])
+
+    return {
         "ip": ip,
         "tor": tor,
         "vpn": vpn,
-        "org": org,
         "hostname": hostname,
+        "org": org,
+        "isp": isp,
+        "asn": asn,
+        "confidence": _confidence_score(tor, vpn),
     }
 
-    return result
-
-
-def format_anonymity_result(result):
-    ip = result["ip"]
-    print(f"IP: {ip}")
-    print(f"Org: {result['org'] or 'N/A'}")
-    print(f"Hostname: {result['hostname'] or 'N/A'}")
-    if result['tor']:
-        print("Tor Exit Node: YES")
-    else:
-        print("Tor Exit Node: No")
-    if result['vpn']:
-        print("VPN / Proxy Suspected: YES")
-    else:
-        print("VPN / Proxy Suspected: No")
+def _confidence_score(tor: bool, vpn: bool) -> str:
+    if tor:
+        return "very high"
+    if vpn:
+        return "high"
+    return "low"
+
+
+def format_anonymity_result(result: dict) -> None:
+    print(f"IP: {result.get('ip')}")
+    print(f"Hostname: {result.get('hostname') or 'N/A'}")
+    print(f"Org / ISP: {result.get('org') or result.get('isp') or 'N/A'}")
+
+    print(f"Tor Exit Node: {'YES' if result['tor'] else 'No'}")
+    print(f"VPN / Proxy Suspected: {'YES' if result['vpn'] else 'No'}")
+    print(f"Confidence: {result.get('confidence', 'unknown').upper()}")

yougotmapped/utils/bandwidth.py

@@ -0,0 +1,54 @@
+# yougotmapped/utils/bandwidth.py
+
+import math
+
+
+DEFAULT_MSS_BYTES = 1460  # Ethernet MTU 1500 - IP/TCP headers
+
+
+def estimate_bandwidth(ping_result: dict, mss_bytes: int = DEFAULT_MSS_BYTES) -> dict:
+    if not ping_result or not ping_result.get("reachable"):
+        return {
+            "available": False,
+            "reason": "no_ping_data",
+        }
+
+    rtt_ms = ping_result["rtt_ms"]["median"]
+    loss_percent = ping_result.get("packet_loss_percent", 0.0)
+
+    rtt_sec = rtt_ms / 1000.0
+    loss = loss_percent / 100.0
+
+    if rtt_sec <= 0:
+        return {
+            "available": False,
+            "reason": "invalid_rtt",
+        }
+
+    if loss == 0:
+        throughput_bps = (mss_bytes * 8) / rtt_sec
+        limiting_factor = "latency"
+    else:
+        throughput_bps = (mss_bytes * 8) / (rtt_sec * math.sqrt(loss))
+        limiting_factor = "packet_loss"
+
+    throughput_mbps = round(throughput_bps / 1_000_000, 2)
+
+    return {
+        "available": True,
+        "estimated_mbps": throughput_mbps,
+        "rtt_ms": rtt_ms,
+        "packet_loss_percent": loss_percent,
+        "limiting_factor": limiting_factor,
+        "model": "tcp_mathis",
+    }
+
+
+def format_bandwidth_result(result: dict) -> None:
+    if not result.get("available"):
+        print("Bandwidth estimation unavailable.")
+        return
+
+    print(f"Estimated Throughput: ~{result['estimated_mbps']} Mbps")
+    print(f"Limiting Factor: {result['limiting_factor'].replace('_', ' ').title()}")
+    print("Model: TCP Mathis approximation")

yougotmapped/utils/dependencies.py

@@ -1,33 +1,55 @@
-# utils/dependencies.py
+# Dependency Definitions
+
 import importlib.util
 import subprocess
 import sys
 
 
-def check_dependencies():
-    required = {
-        "requests": "requests",
-        "folium": "folium",
-        "ping3": "ping3",
-        "python-dotenv": "dotenv"
-    }
+REQUIRED_PACKAGES = {
+    "requests": "requests",
+    "folium": "folium",
+    "ping3": "ping3",
+    "scapy": "scapy"
+}
+
+
+def _is_installed(module_name: str) -> bool:
+    return importlib.util.find_spec(module_name) is not None
+
+
+def _install_package(package_name: str) -> bool:
+    try:
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", package_name],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
 
+
+def check_dependencies(interactive: bool = True) -> None:
     print("\nChecking dependencies:\n")
 
-    for package_name, module_name in required.items():
-        spec = importlib.util.find_spec(module_name)
-        if spec is not None:
-            print(f"   [OK] {package_name} found")
+    for package, module in REQUIRED_PACKAGES.items():
+        if _is_installed(module):
+            print(f"   [OK] {package} found")
+            continue
+
+        print(f"   [MISSING] {package} not found")
+
+        if not interactive:
+            print(f"   Install '{package}' manually and try again.")
+            sys.exit(1)
+
+        choice = input(f"   Install '{package}' now? (yes/no): ").strip().lower()
+        if choice not in ("yes", "y"):
+            print(f"   Cannot continue without '{package}'. Exiting.")
+            sys.exit(1)
+
+        if _install_package(package):
+            print(f"   '{package}' successfully installed")
         else:
-            print(f"   [MISSING] {package_name} not found")
-            choice = input(f"   Install '{package_name}' now? (yes/no): ").strip().lower()
-            if choice in ['yes', 'y']:
-                try:
-                    subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
-                    print(f"   '{package_name}' successfully installed\n")
-                except subprocess.CalledProcessError:
-                    print(f"    Failed to install '{package_name}'. Please install manually.")
-                    sys.exit(1)
-            else:
-                print(f"   Cannot continue without '{package_name}'. Exiting.")
-                sys.exit(1)
+            print(f"   Failed to install '{package}'. Install manually.")
+            sys.exit(1)