ghosttrace-osint 1.0.0__tar.gz

ghosttrace_osint-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benthota Malavi Arachchige Kaveesha Mishen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ghosttrace_osint-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+include requirements.txt

ghosttrace_osint-1.0.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: ghosttrace-osint
+Version: 1.0.0
+Summary: OSINT Recon Engine — IP, Domain, Username Intelligence
+Home-page: https://github.com/YOURUSERNAME/ghosttrace
+Author: YourName
+Author-email: youremail@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+# GhostTrace
+OSINT Recon Engine - IP · Domain · Username Intelligence

ghosttrace_osint-1.0.0/README.md

@@ -0,0 +1,2 @@
+# GhostTrace
+OSINT Recon Engine - IP · Domain · Username Intelligence

ghosttrace_osint-1.0.0/ghosttrace/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "1.0.0"
+__author__ = "Kaveesha Mishen"

ghosttrace_osint-1.0.0/ghosttrace/__main__.py

@@ -0,0 +1,92 @@
+import sys
+import os
+
+if sys.platform == "win32":
+    import io
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+
+import argparse
+from ghosttrace.modules.colors import enable_windows_ansi, GREEN, CYAN, YELLOW, WHITE, GRAY, RED, RESET
+from ghosttrace.modules.banner import print_banner
+from ghosttrace.modules.detector import detect_target_type
+from ghosttrace.modules.ip_lookup import scan_ip
+from ghosttrace.modules.domain_lookup import scan_domain
+from ghosttrace.modules.username_lookup import scan_username
+from ghosttrace.modules.reporter import save_report
+
+enable_windows_ansi()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="GhostTrace - OSINT Recon Engine",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument("target", nargs="?", help="Target: IP, domain, or username")
+    parser.add_argument("-o", "--output", help="Save report (e.g. report.json)", metavar="FILE")
+    parser.add_argument("-t", "--type", choices=["ip", "domain", "username"],
+                        help="Force target type")
+    return parser.parse_args()
+
+
+def interactive_mode():
+    print(f"\n{CYAN}  What do you want to scan?{RESET}")
+    print(f"  {GREEN}[1]{RESET} IP Address")
+    print(f"  {GREEN}[2]{RESET} Domain")
+    print(f"  {GREEN}[3]{RESET} Username")
+    print()
+    choice = input(f"  {YELLOW}Select (1/2/3) or just type your target:{RESET} ").strip()
+
+    type_map = {"1": "ip", "2": "domain", "3": "username"}
+    if choice in type_map:
+        target = input(f"  {YELLOW}Enter target:{RESET} ").strip()
+        return target, type_map[choice]
+    else:
+        return choice, None
+
+
+def main():
+    print_banner()
+    args = parse_args()
+
+    if args.target:
+        target = args.target.strip()
+        target_type = args.type if args.type else detect_target_type(target)
+    else:
+        target, target_type = interactive_mode()
+        if not target_type:
+            target_type = detect_target_type(target)
+
+    if not target:
+        print(f"\n  {RED}[!] No target provided. Exiting.{RESET}\n")
+        sys.exit(1)
+
+    print(f"\n{GRAY}  {'─' * 52}{RESET}")
+    print(f"  {GREEN}[>>]{RESET} Target  : {WHITE}{target}{RESET}")
+    print(f"  {GREEN}[>>]{RESET} Type    : {WHITE}{target_type.upper()}{RESET}")
+    print(f"  {GREEN}[>>]{RESET} Status  : {YELLOW}Initiating scan...{RESET}")
+    print(f"{GRAY}  {'─' * 52}{RESET}\n")
+
+    results = {}
+    if target_type == "ip":
+        results = scan_ip(target)
+    elif target_type == "domain":
+        results = scan_domain(target)
+    elif target_type == "username":
+        results = scan_username(target)
+    else:
+        print(f"\n  {RED}[!] Unknown target type. Use -t ip/domain/username{RESET}\n")
+        sys.exit(1)
+
+    print(f"\n{GRAY}  {'─' * 52}{RESET}")
+
+    if args.output:
+        save_report(target, target_type, results, args.output)
+        print(f"  {GREEN}[✓]{RESET} Report saved → {WHITE}{args.output}{RESET}")
+
+    print(f"\n  {GRAY}[GhostTrace] Scan complete. Stay invisible.{RESET}\n")
+    input(f"  {YELLOW}Press Enter to exit...{RESET}")
+
+
+if __name__ == "__main__":
+    main()

ghosttrace_osint-1.0.0/ghosttrace/modules/__init__.py

@@ -0,0 +1 @@
+# GhostTrace modules

ghosttrace_osint-1.0.0/ghosttrace/modules/banner.py

@@ -0,0 +1,18 @@
+from ghosttrace.modules.colors import enable_windows_ansi, GREEN, GRAY, RESET
+
+enable_windows_ansi()
+
+def print_banner():
+    banner = f"""
+{GREEN}
+  ██████╗ ██╗  ██╗ ██████╗ ███████╗████████╗████████╗██████╗  █████╗  ██████╗███████╗
+ ██╔════╝ ██║  ██║██╔═══██╗██╔════╝╚══██╔══╝╚══██╔══╝██╔══██╗██╔══██╗██╔════╝██╔════╝
+ ██║  ███╗███████║██║   ██║███████╗   ██║      ██║   ██████╔╝███████║██║     █████╗
+ ██║   ██║██╔══██║██║   ██║╚════██║   ██║      ██║   ██╔══██╗██╔══██║██║     ██╔══╝
+ ╚██████╔╝██║  ██║╚██████╔╝███████║   ██║      ██║   ██║  ██║██║  ██║╚██████╗███████╗
+  ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝   ╚═╝      ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚══════╝
+{RESET}
+{GRAY}  [ OSINT Recon Engine v1.0 ]  [ IP • Domain • Username Intelligence ]
+  [ "Leave no trace. Find every trace." ]
+{RESET}"""
+    print(banner)

ghosttrace_osint-1.0.0/ghosttrace/modules/colors.py

@@ -0,0 +1,44 @@
+import sys
+import os
+
+def enable_windows_ansi():
+    if sys.platform == "win32":
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+        except Exception:
+            pass
+        os.environ["PYTHONIOENCODING"] = "utf-8"
+
+enable_windows_ansi()
+
+GREEN  = "\033[92m"
+CYAN   = "\033[96m"
+YELLOW = "\033[93m"
+RED    = "\033[91m"
+WHITE  = "\033[97m"
+GRAY   = "\033[90m"
+RESET  = "\033[0m"
+BOLD   = "\033[1m"
+
+def field(label, value, color=None):
+    if color is None:
+        color = WHITE
+    print(f"  {GREEN}[+]{RESET} {label:<22} {color}{value}{RESET}")
+
+def section(title):
+    print(f"\n{CYAN}  ◈  {title}{RESET}")
+    print(f"{GRAY}  {'─' * 52}{RESET}")
+
+def error(msg):
+    print(f"  {RED}[!]{RESET} {msg}")
+
+def warn(msg):
+    print(f"  {YELLOW}[~]{RESET} {msg}")
+
+def success(msg):
+    print(f"  {GREEN}[✓]{RESET} {msg}")
+
+def info(msg):
+    print(f"  {GRAY}[·]{RESET} {msg}")

ghosttrace_osint-1.0.0/ghosttrace/modules/detector.py

@@ -0,0 +1,14 @@
+import re
+
+def detect_target_type(target: str) -> str:
+    ipv4_pattern   = re.compile(r"^(\d{1,3}\.){3}\d{1,3}$")
+    ipv6_pattern   = re.compile(r"^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$")
+    domain_pattern = re.compile(
+        r"^(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$"
+    )
+    if ipv4_pattern.match(target) or ipv6_pattern.match(target):
+        return "ip"
+    elif domain_pattern.match(target):
+        return "domain"
+    else:
+        return "username"

ghosttrace_osint-1.0.0/ghosttrace/modules/domain_lookup.py

@@ -0,0 +1,135 @@
+import socket
+import ssl
+import datetime
+import subprocess
+import requests
+from ghosttrace.modules.colors import field, section, error, warn, info, GREEN, RED, YELLOW, GRAY, WHITE, RESET
+
+def scan_domain(domain: str) -> dict:
+    results = {"target": domain, "type": "domain"}
+
+    section("IP RESOLUTION")
+    try:
+        ip = socket.gethostbyname(domain)
+        field("Resolved IP", ip)
+        results["resolved_ip"] = ip
+        r = requests.get(f"http://ip-api.com/json/{ip}?fields=country,city,isp,org,as", timeout=5)
+        geo = r.json()
+        field("Country", geo.get("country", "N/A"))
+        field("City",    geo.get("city",    "N/A"))
+        field("ISP",     geo.get("isp",     "N/A"))
+        field("ASN",     geo.get("as",      "N/A"))
+        results["geo"] = geo
+    except Exception as e:
+        error(str(e))
+
+    section("WHOIS / REGISTRATION INFO")
+    try:
+        r = requests.get(f"https://rdap.org/domain/{domain}", timeout=6)
+        rdap = r.json()
+        whois_data = {}
+        for event in rdap.get("events", []):
+            action = event.get("eventAction", "")
+            date   = event.get("eventDate",   "N/A")
+            if action == "registration":
+                field("Registered",   date[:10]); whois_data["registered"]   = date[:10]
+            elif action == "expiration":
+                field("Expires",      date[:10]); whois_data["expires"]      = date[:10]
+            elif action == "last changed":
+                field("Last Updated", date[:10]); whois_data["last_updated"] = date[:10]
+        for entity in rdap.get("entities", []):
+            if "registrar" in entity.get("roles", []):
+                vcard = entity.get("vcardArray", [])
+                if vcard and len(vcard) > 1:
+                    for v in vcard[1]:
+                        if v[0] == "fn":
+                            field("Registrar", v[3])
+                            whois_data["registrar"] = v[3]
+                            break
+        ns_list = [ns.get("ldhName", "") for ns in rdap.get("nameservers", [])]
+        if ns_list:
+            field("Nameservers", ", ".join(ns_list))
+            whois_data["nameservers"] = ns_list
+        status = rdap.get("status", [])
+        if status:
+            field("Domain Status", ", ".join(status))
+        results["whois"] = whois_data
+    except Exception as e:
+        warn(f"WHOIS lookup failed: {e}")
+
+    section("DNS RECORDS")
+    try:
+        dns_records = {}
+        for rtype in ["A", "MX", "TXT", "NS", "CNAME"]:
+            try:
+                result = subprocess.run(
+                    ["nslookup", f"-type={rtype}", domain],
+                    capture_output=True, text=True, timeout=4
+                )
+                lines = [
+                    l.strip() for l in result.stdout.splitlines()
+                    if l.strip()
+                    and "Server:" not in l
+                    and "Address:" not in l
+                    and "#" not in l
+                    and domain.lower() in l.lower()
+                ]
+                if lines:
+                    field(f"{rtype} Record", lines[0][:58])
+                    dns_records[rtype] = lines
+            except Exception:
+                pass
+        results["dns"] = dns_records
+    except Exception as e:
+        error(str(e))
+
+    section("SSL CERTIFICATE")
+    try:
+        ctx  = ssl.create_default_context()
+        conn = ctx.wrap_socket(socket.socket(), server_hostname=domain)
+        conn.settimeout(5)
+        conn.connect((domain, 443))
+        cert = conn.getpeercert()
+        conn.close()
+        subject   = dict(x[0] for x in cert.get("subject",  []))
+        issuer    = dict(x[0] for x in cert.get("issuer",   []))
+        not_after = cert.get("notAfter", "N/A")
+        field("Common Name", subject.get("commonName",      "N/A"))
+        field("Issued By",   issuer.get("organizationName", "N/A"))
+        field("Valid Until", not_after)
+        sans = [v for k, v in cert.get("subjectAltName", []) if k == "DNS"]
+        if sans:
+            field("Alt Names (SANs)", ", ".join(sans[:5]))
+        try:
+            expiry    = datetime.datetime.strptime(not_after, "%b %d %H:%M:%S %Y %Z")
+            days_left = (expiry - datetime.datetime.utcnow()).days
+            color     = RED if days_left < 30 else GREEN
+            field("Days Until Expiry", str(days_left), color)
+        except Exception:
+            pass
+        results["ssl"] = {"subject": subject, "issuer": issuer, "expiry": not_after, "sans": sans}
+    except Exception as e:
+        warn(f"SSL check failed: {e}")
+
+    section("SUBDOMAIN RECON  (Certificate Transparency)")
+    try:
+        r = requests.get(f"https://crt.sh/?q=%.{domain}&output=json", timeout=8)
+        certs = r.json()
+        subdomains = set()
+        for entry in certs:
+            for sub in entry.get("name_value", "").split("\n"):
+                sub = sub.strip().lstrip("*.")
+                if sub.endswith(domain) and sub != domain:
+                    subdomains.add(sub)
+        if subdomains:
+            for sub in sorted(subdomains)[:15]:
+                field("Subdomain", sub, YELLOW)
+            if len(subdomains) > 15:
+                info(f"...and {len(subdomains)-15} more subdomains found")
+        else:
+            info("No subdomains found in certificate transparency logs")
+        results["subdomains"] = list(subdomains)
+    except Exception as e:
+        error(str(e))
+
+    return results

ghosttrace_osint-1.0.0/ghosttrace/modules/ip_lookup.py

@@ -0,0 +1,105 @@
+import socket
+import requests
+from ghosttrace.modules.colors import field, section, error, warn, info, GREEN, RED, YELLOW, GRAY, RESET
+
+def scan_ip(ip: str) -> dict:
+    results = {"target": ip, "type": "ip"}
+
+    section("GEOLOCATION & NETWORK INFO")
+    try:
+        r = requests.get(
+            f"http://ip-api.com/json/{ip}?fields=status,message,country,regionName,city,zip,lat,lon,timezone,isp,org,as,query",
+            timeout=6
+        )
+        geo = r.json()
+        if geo.get("status") == "success":
+            data = {
+                "IP Address":   geo.get("query",      "N/A"),
+                "Country":      geo.get("country",    "N/A"),
+                "Region":       geo.get("regionName", "N/A"),
+                "City":         geo.get("city",       "N/A"),
+                "ZIP Code":     geo.get("zip",        "N/A"),
+                "Latitude":     str(geo.get("lat",    "N/A")),
+                "Longitude":    str(geo.get("lon",    "N/A")),
+                "Timezone":     geo.get("timezone",   "N/A"),
+                "ISP":          geo.get("isp",        "N/A"),
+                "Organization": geo.get("org",        "N/A"),
+                "ASN":          geo.get("as",         "N/A"),
+            }
+            for k, v in data.items():
+                field(k, v)
+            results["geolocation"] = data
+        else:
+            error(f"Geo lookup failed: {geo.get('message', 'unknown error')}")
+    except Exception as e:
+        error(f"Geo lookup failed: {e}")
+
+    section("REVERSE DNS")
+    try:
+        hostname = socket.gethostbyaddr(ip)[0]
+        field("Hostname", hostname)
+        results["reverse_dns"] = hostname
+    except socket.herror:
+        info("No PTR record found for this IP")
+        results["reverse_dns"] = None
+    except Exception as e:
+        error(str(e))
+
+    section("THREAT INTELLIGENCE (AbuseIPDB)")
+    import os
+    from dotenv import load_dotenv
+    load_dotenv()
+    ABUSEIPDB_KEY = os.getenv("ABUSEIPDB_KEY", "YOUR_ABUSEIPDB_API_KEY")
+    if ABUSEIPDB_KEY != "YOUR_ABUSEIPDB_API_KEY":
+        try:
+            headers = {"Key": ABUSEIPDB_KEY, "Accept": "application/json"}
+            r = requests.get(
+                "https://api.abuseipdb.com/api/v2/check",
+                headers=headers,
+                params={"ipAddress": ip, "maxAgeInDays": 90},
+                timeout=6
+            )
+            data = r.json().get("data", {})
+            score = data.get("abuseConfidenceScore", 0)
+            color = RED if score > 50 else GREEN
+            field("Abuse Score",   f"{score}/100", color)
+            field("Total Reports", str(data.get("totalReports", 0)))
+            field("Last Reported", data.get("lastReportedAt") or "Never")
+            field("Tor Node",      str(data.get("isTor", False)))
+            results["threat_intel"] = data
+        except Exception as e:
+            error(str(e))
+    else:
+        warn("AbuseIPDB key not set — create a .env file with ABUSEIPDB_KEY=yourkey")
+        info("Get a free key at: https://www.abuseipdb.com/register")
+
+    section("PORT SCAN  (Top 15 Common Ports)")
+    common_ports = {
+        21:   "FTP",      22:   "SSH",      23:   "Telnet",
+        25:   "SMTP",     53:   "DNS",      80:   "HTTP",
+        110:  "POP3",     143:  "IMAP",     443:  "HTTPS",
+        445:  "SMB",      3306: "MySQL",    3389: "RDP",
+        5900: "VNC",      6379: "Redis",    8080: "HTTP-Alt"
+    }
+    open_ports = []
+    print(f"  {GRAY}Scanning ports", end="", flush=True)
+    for port, service in common_ports.items():
+        print(f"{GRAY}.{RESET}", end="", flush=True)
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.settimeout(0.5)
+            if s.connect_ex((ip, port)) == 0:
+                open_ports.append((port, service))
+            s.close()
+        except Exception:
+            pass
+    print(f" Done{RESET}")
+
+    if open_ports:
+        for port, service in open_ports:
+            field(f"Port {port}/{service}", "OPEN", RED)
+    else:
+        info("No common ports open (or filtered by firewall)")
+    results["open_ports"] = open_ports
+
+    return results

ghosttrace_osint-1.0.0/ghosttrace/modules/reporter.py

@@ -0,0 +1,24 @@
+import json
+import datetime
+
+def save_report(target: str, target_type: str, results: dict, filepath: str):
+    timestamp = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
+    report = {
+        "tool":      "GhostTrace v1.0",
+        "timestamp": timestamp,
+        "target":    target,
+        "type":      target_type,
+        "results":   results
+    }
+    if filepath.endswith(".json"):
+        with open(filepath, "w") as f:
+            json.dump(report, f, indent=4)
+    else:
+        with open(filepath, "w") as f:
+            f.write("=" * 60 + "\n")
+            f.write("  GHOSTTRACE OSINT REPORT\n")
+            f.write(f"  Generated : {timestamp}\n")
+            f.write(f"  Target    : {target} [{target_type.upper()}]\n")
+            f.write("=" * 60 + "\n\n")
+            f.write(json.dumps(results, indent=4))
+            f.write("\n\n[GhostTrace] End of Report\n")

ghosttrace_osint-1.0.0/ghosttrace/modules/username_lookup.py

@@ -0,0 +1,71 @@
+import requests
+import threading
+from ghosttrace.modules.colors import field, section, info, GREEN, GRAY, WHITE, RESET
+
+PLATFORMS = [
+    ("GitHub",       "https://github.com/{u}",                       "status", 200),
+    ("GitLab",       "https://gitlab.com/{u}",                       "status", 200),
+    ("Twitter/X",    "https://x.com/{u}",                            "status", 200),
+    ("Reddit",       "https://www.reddit.com/user/{u}",              "status", 200),
+    ("Instagram",    "https://www.instagram.com/{u}/",               "status", 200),
+    ("TikTok",       "https://www.tiktok.com/@{u}",                  "status", 200),
+    ("YouTube",      "https://www.youtube.com/@{u}",                 "status", 200),
+    ("Pinterest",    "https://www.pinterest.com/{u}/",               "status", 200),
+    ("Tumblr",       "https://{u}.tumblr.com",                       "status", 200),
+    ("Medium",       "https://medium.com/@{u}",                      "status", 200),
+    ("Dev.to",       "https://dev.to/{u}",                           "status", 200),
+    ("Hashnode",     "https://hashnode.com/@{u}",                    "status", 200),
+    ("Twitch",       "https://www.twitch.tv/{u}",                    "status", 200),
+    ("Steam",        "https://steamcommunity.com/id/{u}",            "status", 200),
+    ("Keybase",      "https://keybase.io/{u}",                       "status", 200),
+    ("HackerNews",   "https://news.ycombinator.com/user?id={u}",     "text",   "user?id="),
+    ("Product Hunt", "https://www.producthunt.com/@{u}",             "status", 200),
+    ("Pastebin",     "https://pastebin.com/u/{u}",                   "status", 200),
+    ("DockerHub",    "https://hub.docker.com/u/{u}",                 "status", 200),
+    ("NPM",          "https://www.npmjs.com/~{u}",                   "status", 200),
+    ("PyPI",         "https://pypi.org/user/{u}/",                   "status", 200),
+    ("HackTheBox",   "https://app.hackthebox.com/users/profile/{u}", "status", 200),
+    ("TryHackMe",    "https://tryhackme.com/p/{u}",                  "status", 200),
+]
+
+HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
+
+def _check(username, name, url_tpl, check_type, match, found, lock):
+    url = url_tpl.replace("{u}", username)
+    try:
+        r = requests.get(url, headers=HEADERS, timeout=6, allow_redirects=True)
+        hit = (check_type == "status" and r.status_code == match) or \
+              (check_type == "text"   and match in r.text)
+        if hit:
+            with lock:
+                found[name] = url
+    except Exception:
+        pass
+
+def scan_username(username: str) -> dict:
+    results = {"target": username, "type": "username"}
+    section(f"USERNAME HUNT  —  @{username}")
+    print(f"  {GRAY}Scanning {len(PLATFORMS)} platforms, please wait...{RESET}\n")
+
+    found = {}
+    lock  = threading.Lock()
+    threads = [
+        threading.Thread(target=_check, args=(username, name, url_tpl, ct, match, found, lock))
+        for name, url_tpl, ct, match in PLATFORMS
+    ]
+    for t in threads: t.start()
+    for t in threads: t.join()
+
+    section(f"RESULTS  —  {len(found)} of {len(PLATFORMS)} platforms matched")
+    all_checked = []
+    for name, url_tpl, _, _ in PLATFORMS:
+        if name in found:
+            print(f"  {GREEN}[FOUND]{RESET}  {name:<18} {WHITE}{found[name]}{RESET}")
+            all_checked.append({"platform": name, "url": found[name], "found": True})
+        else:
+            print(f"  {GRAY}[-----]{RESET}  {name:<18} not found")
+            all_checked.append({"platform": name, "found": False})
+
+    results["platforms"]   = all_checked
+    results["found_count"] = len(found)
+    return results

ghosttrace_osint-1.0.0/ghosttrace_osint.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: ghosttrace-osint
+Version: 1.0.0
+Summary: OSINT Recon Engine — IP, Domain, Username Intelligence
+Home-page: https://github.com/YOURUSERNAME/ghosttrace
+Author: YourName
+Author-email: youremail@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+# GhostTrace
+OSINT Recon Engine - IP · Domain · Username Intelligence

ghosttrace_osint-1.0.0/ghosttrace_osint.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.cfg
+setup.py
+ghosttrace/__init__.py
+ghosttrace/__main__.py
+ghosttrace/modules/__init__.py
+ghosttrace/modules/banner.py
+ghosttrace/modules/colors.py
+ghosttrace/modules/detector.py
+ghosttrace/modules/domain_lookup.py
+ghosttrace/modules/ip_lookup.py
+ghosttrace/modules/reporter.py
+ghosttrace/modules/username_lookup.py
+ghosttrace_osint.egg-info/PKG-INFO
+ghosttrace_osint.egg-info/SOURCES.txt
+ghosttrace_osint.egg-info/dependency_links.txt
+ghosttrace_osint.egg-info/entry_points.txt
+ghosttrace_osint.egg-info/requires.txt
+ghosttrace_osint.egg-info/top_level.txt

ghosttrace_osint-1.0.0/ghosttrace_osint.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ghosttrace_osint-1.0.0/ghosttrace_osint.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ghosttrace = ghosttrace.__main__:main

ghosttrace_osint-1.0.0/ghosttrace_osint.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.28.0
+python-dotenv>=1.0.0

ghosttrace_osint-1.0.0/ghosttrace_osint.egg-info/top_level.txt

@@ -0,0 +1 @@
+ghosttrace

ghosttrace_osint-1.0.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"

ghosttrace_osint-1.0.0/requirements.txt

@@ -0,0 +1 @@
+requests>=2.28.0

ghosttrace_osint-1.0.0/setup.cfg

@@ -0,0 +1,31 @@
+[metadata]
+name = ghosttrace-osint
+version = 1.0.0
+author = YourName
+author_email = youremail@gmail.com
+description = OSINT Recon Engine — IP, Domain, Username Intelligence
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/YOURUSERNAME/ghosttrace
+license = MIT
+classifiers = 
+	Programming Language :: Python :: 3
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+	Topic :: Security
+
+[options]
+packages = find:
+python_requires = >=3.7
+install_requires = 
+	requests>=2.28.0
+	python-dotenv>=1.0.0
+
+[options.entry_points]
+console_scripts = 
+	ghosttrace = ghosttrace.__main__:main
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

ghosttrace_osint-1.0.0/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()