nexus-scan 1.0.0__tar.gz

nexus_scan-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: nexus-scan
+Version: 1.0.0
+Summary: Advanced Recon & Network Audit Suite
+Author: NEXUS GOAT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: urllib3
+
+# Nexus Scanner Tool

nexus_scan-1.0.0/README.md

@@ -0,0 +1 @@
+# Nexus Scanner Tool

nexus_scan-1.0.0/nexus/cli.py

@@ -0,0 +1,499 @@
+import os
+import sys
+import socket
+import ssl
+import time
+import http.client
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import requests
+import ipaddress
+import urllib3
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# High Quality 24-bit TrueColor RGB Palette
+def rgb(r, g, b):
+    return f"\033[38;2;{r};{g};{b}m"
+
+RESET       = "\033[0m"
+BOLD        = "\033[1m"
+UNDERLINE   = "\033[4m"
+
+# Premium Neon Visuals
+COLOR_BANNER = rgb(255, 35, 80)     # Neon Deep Red
+COLOR_CYAN   = rgb(0, 255, 255)     # Electric Cyan
+COLOR_GREEN  = rgb(50, 255, 70)     # Lime Green
+COLOR_YELLOW = rgb(255, 230, 0)     # Bright Yellow
+COLOR_PURPLE = rgb(190, 80, 255)    # Neon Purple
+COLOR_BLUE   = rgb(60, 160, 255)    # Sky Blue
+COLOR_ORANGE = rgb(255, 140, 20)    # Neon Orange
+COLOR_PINK   = rgb(255, 105, 180)   # Hot Pink
+COLOR_WHITE  = rgb(245, 245, 255)   # Ultra Ice White
+COLOR_LINE   = rgb(90, 90, 110)     # Matrix Gray Border
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
+}
+
+def clean_host(target):
+    target = target.strip()
+    return target.replace("http://", "").replace("https://", "").split("/")[0]
+
+def clear():
+    os.system('clear' if os.name != 'nt' else 'cls')
+
+def banner():
+    clear()
+    print(f"""{COLOR_BANNER}{BOLD}
+ ███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗
+ ████╗  ██║██╔════╝╚██╗██╔╝██║   ██║██╔════╝
+ ██╔██╗ ██║█████╗   ╚███╔╝ ██║   ██║███████╗
+ ██║╚██╗██║██╔══╝   ██╔██╗ ██║   ██║╚════██║
+ ██║ ╚████║███████╗██╔╝ ██╗╚██████╔╝███████║
+ ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝{RESET}""")
+    print(f"{COLOR_LINE}──────────────────────────────────────────────────────────{RESET}")
+    print(f" {COLOR_PURPLE}{BOLD}CHANNEL{RESET}   : {COLOR_CYAN}{UNDERLINE}https://t.me/DARKGLOBALNET{RESET}")
+    print(f" {COLOR_PURPLE}{BOLD}DEVELOPER{RESET} : {COLOR_WHITE}{BOLD}NEXUS GOAT{RESET}")
+    print(f" {COLOR_PURPLE}{BOLD}USERNAME{RESET}  : {COLOR_GREEN}{BOLD}@V2NEXUSPRIME{RESET}")
+    print(f"{COLOR_LINE}──────────────────────────────────────────────────────────{RESET}\n")
+
+# ==================== ADVANCED HOST PROFILER ENGINE ====================
+class AdvancedHostEngine:
+    CDN_PROVIDERS = {
+        "Cloudflare": {
+            "headers": ["cf-ray", "cf-cache-status", "cf-request-id", "cf-visitor", "cf-connecting-ip", "cf-ipcountry", "cf-railgun", "cf-polished", "cf-apo-via"],
+            "cname": ["cloudflare.net", "cloudflare.com", "cloudflare-dns.com"]
+        },
+        "Amazon CloudFront": {
+            "headers": ["x-amz-cf-id", "x-amz-cf-pop", "x-amz-request-id"],
+            "cname": ["cloudfront.net", "amazonaws.com"]
+        },
+        "Google Cloud CDN": {
+            "headers": ["x-goog-cache-status", "x-goog-generation", "x-goog-metageneration", "x-guploader-uploadid"],
+            "cname": ["googleusercontent.com", "googlevideo.com", "google.com", "gstatic.com", "googleapis.com"]
+        },
+        "Akamai": {
+            "headers": ["x-akamai-transformed", "akamai-cache-status", "akamai-origin-hop", "x-akamai-request-id", "x-akamai-ssl-client-sid", "akamai-grn", "x-akamai-config-log-detail"],
+            "cname": ["akamai.net", "edgekey.net", "edgesuite.net", "akamaized.net", "akamaiedge.net", "akamaitechnologies.com", "akamaihd.net"]
+        },
+        "Fastly": {
+            "headers": ["fastly-debug", "x-served-by", "x-cache-hits", "x-timer", "fastly-ff", "x-fastly-request-id"],
+            "cname": ["fastly.net", "fastlylb.net"]
+        },
+        "Microsoft Azure": {
+            "headers": ["x-azure-ref", "x-azure-requestid", "x-msedge-ref", "x-ec-custom-error", "x-azure-fdid"],
+            "cname": ["azureedge.net", "msedge.net", "azure-edge.net", "trafficmanager.net", "azurefd.net"]
+        },
+        "BunnyCDN": {
+            "headers": ["cdn-pullzone", "cdn-uid", "cdn-requestid", "cdn-cache", "cdn-zone", "bunnycdn-cache-tag"],
+            "cname": ["b-cdn.net"]
+        },
+        "Sucuri": {
+            "headers": ["x-sucuri-id", "x-sucuri-cache", "x-sucuri-block", "server-sucuri"],
+            "cname": ["sucuri.net"]
+        },
+        "Imperva": {
+            "headers": ["x-iinfo", "incap-ses", "visid-incap"],
+            "cname": ["incapdns.net", "imperva.com", "impervadns.net"]
+        },
+        "Cachefly": {
+            "headers": ["x-cf-", "server-cachefly"],
+            "cname": ["cachefly.net"]
+        },
+        "Alibaba": {
+            "headers": ["ali-cdn-", "x-oss-", "server-tengine"],
+            "cname": ["alikunlun.com", "alicdn.com"]
+        },
+        "Tencent": {
+            "headers": ["x-nws-", "x-daa-tunnel"],
+            "cname": ["qcloudcdn.com", "myqcloud.com"]
+        }
+    }
+
+    def __init__(self, host, protocol="https", method_list=None):
+        self.host = clean_host(host)
+        self.protocol = protocol.lower()
+        self.url = f"{self.protocol}://{self.host}"
+        self.method_list = method_list or ["GET", "HEAD"]
+        self.http_headers = {}
+
+    def get_ips(self):
+        try:
+            ips = socket.getaddrinfo(self.host, None)
+            unique_ips = list(set(ip[4][0] for ip in ips))
+            print(f"\n{COLOR_CYAN}{BOLD}Resolved Network IPs:{RESET}")
+            for ip in unique_ips:
+                print(f"  {COLOR_GREEN}• {COLOR_WHITE}{ip}")
+            return True
+        except socket.gaierror as e:
+            print(f"{COLOR_BANNER}[!] Error resolving hostname: {e}{RESET}")
+            return False
+
+    def get_cname_records(self):
+        result = []
+        try:
+            answers = socket.getaddrinfo(self.host, None)
+            for answer in answers:
+                try:
+                    cname = socket.gethostbyaddr(answer[4][0])[0]
+                    result.append(cname.lower())
+                except (socket.herror, socket.gaierror):
+                    continue
+        except (socket.herror, socket.gaierror):
+            pass
+        return result
+
+    def get_cdn(self):
+        try:
+            detected_cdns = set()
+            headers = {}
+            if self.http_headers:
+                headers = {k.lower(): str(v).lower() for k, v in self.http_headers.items()}
+            else:
+                try:
+                    response = requests.get(self.url, headers=HEADERS, timeout=5, verify=False)
+                    headers = {k.lower(): str(v).lower() for k, v in response.headers.items()}
+                except Exception:
+                    pass
+
+            cnames = self.get_cname_records()
+
+            for provider, indicators in self.CDN_PROVIDERS.items():
+                if any(h.lower() in headers.keys() for h in indicators['headers']):
+                    detected_cdns.add(provider)
+                    continue
+
+                if any(cname_pattern in cname for cname in cnames for cname_pattern in indicators['cname']):
+                    detected_cdns.add(provider)
+
+            print(f"\n{COLOR_CYAN}{BOLD}CDN & Shield Detection:{RESET}")
+            if detected_cdns:
+                for cdn in detected_cdns:
+                    print(f"  {COLOR_PINK}• {BOLD}{cdn}{RESET}")
+            else:
+                print(f"  {COLOR_YELLOW}• No known CDN detected{RESET}")
+        except Exception as e:
+            print(f"{COLOR_BANNER}[!] Error checking CDN: {e}{RESET}")
+
+    def get_http_info(self):
+        def check_method(method):
+            try:
+                response = requests.request(method, self.url, headers=HEADERS, timeout=5, verify=False, allow_redirects=False)
+                return method, response.status_code, dict(response.headers)
+            except requests.exceptions.RequestException as e:
+                return method, 0, {'error': str(e)}
+
+        print(f"\n{COLOR_CYAN}{BOLD}HTTP Methods & Header Probe:{RESET}")
+        with ThreadPoolExecutor(max_workers=min(len(self.method_list), 10)) as executor:
+            futures = {executor.submit(check_method, m): m for m in self.method_list}
+            for future in as_completed(futures):
+                method, status_code, headers = future.result()
+
+                if method == "GET" and status_code > 0 and 'error' not in headers:
+                    self.http_headers = headers
+
+                status_desc = http.client.responses.get(status_code, 'Unknown Code')
+                color_stat = COLOR_GREEN if status_code == 200 else (COLOR_YELLOW if status_code < 400 else COLOR_BANNER)
+                print(f"\n  {COLOR_YELLOW}{BOLD}Method: {method:<7}{RESET} | {color_stat}{BOLD}Status: {status_code} {status_desc}{RESET}")
+
+                if 'error' in headers:
+                    print(f"    {COLOR_BANNER}Error: {headers['error']}{RESET}")
+                else:
+                    for h_name in ["server", "content-type", "x-powered-by", "location"]:
+                        for real_name, val in headers.items():
+                            if real_name.lower() == h_name:
+                                print(f"    {COLOR_BLUE}{real_name}: {COLOR_WHITE}{val}{RESET}")
+
+    def get_sni_info(self):
+        if self.protocol != "https":
+            return
+
+        print(f"\n{COLOR_CYAN}{BOLD}SSL / SNI Handshake Details:{RESET}")
+        try:
+            context = ssl.create_default_context()
+            context.check_hostname = False
+            context.verify_mode = ssl.CERT_NONE
+
+            with socket.create_connection((self.host, 443), timeout=5) as sock:
+                with context.wrap_socket(sock, server_hostname=self.host) as ssock:
+                    cipher = ssock.cipher()
+                    print(f"  {COLOR_PURPLE}• SSL Protocol :{RESET} {COLOR_WHITE}{ssock.version()}")
+                    if cipher:
+                        print(f"  {COLOR_PURPLE}• Cipher Suite :{RESET} {COLOR_WHITE}{cipher[0]} ({cipher[1]} bits)")
+                    print(f"  {COLOR_PURPLE}• SNI Match    :{RESET} {COLOR_GREEN}Valid ({self.host})")
+        except Exception as e:
+            print(f"  {COLOR_BANNER}[!] SSL Probe Error: {e}{RESET}")
+
+    def scan(self):
+        if not self.get_ips():
+            return
+        self.get_http_info()
+        self.get_cdn()
+        self.get_sni_info()
+
+# ==================== MAIN FUNCTIONS ====================
+
+# [1] HOST SCANNER -> ADVANCED HOST PROBE
+def host_scanner():
+    banner()
+    print(f"{COLOR_YELLOW}{BOLD}[*] EXECUTING: ADVANCED HOST PROBE{RESET}\n")
+    print(f" {COLOR_CYAN}[1]{RESET} {COLOR_WHITE}Single Host/Domain{RESET}")
+    print(f" {COLOR_CYAN}[2]{RESET} {COLOR_WHITE}Host List File (.txt){RESET}")
+    print(f" {COLOR_CYAN}[3]{RESET} {COLOR_WHITE}CIDR Subnet Block{RESET}\n")
+
+    choice = input(f"{COLOR_YELLOW}[?] Select Target Type (1/2/3): {COLOR_WHITE}").strip()
+    targets = []
+
+    if choice == "1":
+        h = input(f"{COLOR_CYAN}[?] Enter Host/IP: {COLOR_WHITE}").strip()
+        if h:
+            targets = [h]
+    elif choice == "2":
+        path = input(f"{COLOR_CYAN}[?] Enter Host File Path: {COLOR_WHITE}").strip()
+        if path.startswith("~/"):
+            path = os.path.expanduser(path)
+        try:
+            with open(path, "r", encoding="utf-8", errors="ignore") as f:
+                targets = [l.strip() for l in f if l.strip()]
+        except Exception as e:
+            print(f"\n{COLOR_BANNER}[!] File Error: {e}{RESET}")
+            input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+            return
+    elif choice == "3":
+        cidr = input(f"{COLOR_CYAN}[?] Enter CIDR (e.g. 192.168.1.0/28): {COLOR_WHITE}").strip()
+        try:
+            net = ipaddress.ip_network(cidr, strict=False)
+            targets = [str(ip) for ip in net.hosts()]
+        except Exception:
+            print(f"\n{COLOR_BANNER}[!] Invalid CIDR format.{RESET}")
+            input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+            return
+    else:
+        print(f"\n{COLOR_BANNER}[!] Invalid Option!{RESET}")
+        input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+        return
+
+    ports_in = input(f"{COLOR_CYAN}[?] Enter Port(s) [Default: 80,443]: {COLOR_WHITE}").strip()
+    ports = [p.strip() for p in ports_in.split(",")] if ports_in else ["80", "443"]
+
+    method = input(f"{COLOR_CYAN}[?] HTTP Method [GET/HEAD - Default: GET]: {COLOR_WHITE}").strip().upper()
+    if method not in ["GET", "HEAD"]:
+        method = "GET"
+
+    th_in = input(f"{COLOR_CYAN}[?] Threads [Default: 30]: {COLOR_WHITE}").strip()
+    threads = int(th_in) if th_in.isdigit() else 30
+
+    out_file = input(f"{COLOR_CYAN}[?] Output File [Default: results.txt]: {COLOR_WHITE}").strip()
+    if not out_file:
+        out_file = "results.txt"
+
+    def probe_single(h, p):
+        h = clean_host(h)
+        proto = "https" if str(p) in ["443", "8443"] else "http"
+        try:
+            res = requests.request(method, f"{proto}://{h}:{p}", headers=HEADERS, timeout=4, verify=False, allow_redirects=False)
+            return {"host": h, "port": p, "status": res.status_code, "server": res.headers.get("Server", "Hidden"), "alive": True}
+        except:
+            return None
+
+    print(f"\n{COLOR_BLUE}[*] Scanning {len(targets)} host(s)...{RESET}\n")
+    valid_results = []
+    with ThreadPoolExecutor(max_workers=threads) as executor:
+        futures = [executor.submit(probe_single, h, p) for h in targets for p in ports]
+        for f in as_completed(futures):
+            res = f.result()
+            if res and res["alive"]:
+                print(f" {COLOR_GREEN}[✔] {COLOR_WHITE}{res['host']}:{res['port']:<5} {COLOR_LINE}| {COLOR_CYAN}Status: {res['status']:<8} {COLOR_LINE}| {COLOR_YELLOW}Server: {res['server']}{RESET}")
+                valid_results.append(f"{res['host']}:{res['port']} | Status: {res['status']} | Server: {res['server']}")
+
+    if valid_results:
+        with open(out_file, "w", encoding="utf-8") as out:
+            out.write("\n".join(valid_results) + "\n")
+        print(f"\n{COLOR_GREEN}[✔] Saved {len(valid_results)} active host(s) in '{out_file}'.{RESET}")
+    else:
+        print(f"\n{COLOR_BANNER}[-] No active responses.{RESET}")
+
+    input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+
+# [2] SUB HUNTER -> SUB-ASSET RADAR
+def sub_hunter():
+    banner()
+    print(f"{COLOR_YELLOW}{BOLD}[*] EXECUTING: SUB-ASSET RADAR{RESET}\n")
+    domain = clean_host(input(f"{COLOR_CYAN}[?] Enter Target Domain: {COLOR_WHITE}"))
+    print(f"\n{COLOR_BLUE}[*] Querying Certificate Logs & Multi-APIs...{RESET}")
+    subs = set()
+
+    try:
+        r = requests.get(f"https://api.hackertarget.com/hostsearch/?q={domain}", headers=HEADERS, timeout=8).text
+        for line in r.splitlines():
+            if "," in line:
+                s = line.split(",")[0].strip()
+                if domain in s:
+                    subs.add(s)
+    except:
+        pass
+
+    if len(subs) < 5:
+        try:
+            r = requests.get(f"https://crt.sh/?q=%25.{domain}&output=json", headers=HEADERS, timeout=8).json()
+            for itm in r:
+                nv = itm.get("name_value")
+                if nv:
+                    for s in nv.split("\n"):
+                        s = s.strip().replace("*.", "")
+                        if domain in s:
+                            subs.add(s)
+        except:
+            pass
+
+    if subs:
+        print(f"\n{COLOR_GREEN}[+] Sub-Assets Discovered: {COLOR_WHITE}{len(subs)}\n")
+        for s in list(subs)[:30]:
+            print(f" {COLOR_PURPLE}❯ {COLOR_WHITE}{s}{RESET}")
+        if len(subs) > 30:
+            print(f"{COLOR_YELLOW}\n...and {len(subs) - 30} more found.{RESET}")
+    else:
+        print(f"\n{COLOR_BANNER}[✖] No subdomains discovered.{RESET}")
+
+    input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+
+# [3] DNS RECORD -> CLOUD DNS RESOLVER
+def dns_record():
+    banner()
+    print(f"{COLOR_YELLOW}{BOLD}[*] EXECUTING: CLOUD DNS RESOLVER{RESET}\n")
+    domain = clean_host(input(f"{COLOR_CYAN}[?] Enter Target Domain: {COLOR_WHITE}"))
+    types = ["A", "AAAA", "MX", "NS", "TXT"]
+    print(f"\n{COLOR_BLUE}[*] Resolving DNS mapping via Cloudflare & Google...{RESET}\n")
+
+    found = False
+    for t in types:
+        try:
+            res = requests.get(
+                f"https://cloudflare-dns.com/dns-query?name={domain}&type={t}",
+                headers={"Accept": "application/dns-json"},
+                timeout=4
+            ).json()
+            for r in res.get("Answer", []):
+                print(f" {COLOR_ORANGE}[{t:<4}] {COLOR_WHITE}{r.get('data')}{RESET}")
+                found = True
+        except:
+            pass
+
+    if not found:
+        print(f"{COLOR_BANNER}[✖] DNS records not found.{RESET}")
+
+    input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+
+# [4] HOST INFO -> DEEP HOST INTEL
+def host_info():
+    banner()
+    print(f"{COLOR_YELLOW}{BOLD}[*] EXECUTING: DEEP HOST INTEL & PROFILER{RESET}\n")
+    raw_host = input(f"{COLOR_CYAN}[?] Enter Target Host (e.g. example.com): {COLOR_WHITE}").strip()
+    target = clean_host(raw_host)
+
+    if not target:
+        print(f"{COLOR_BANNER}[!] Input empty!{RESET}")
+        input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+        return
+
+    proto = input(f"{COLOR_CYAN}[?] Protocol (http/https) [Default: https]: {COLOR_WHITE}").strip().lower()
+    if proto not in ["http", "https"]:
+        proto = "https"
+
+    methods_in = input(f"{COLOR_CYAN}[?] HTTP Methods [Default: GET,HEAD,OPTIONS]: {COLOR_WHITE}").strip()
+    methods = [m.strip().upper() for m in methods_in.split(",")] if methods_in else ["GET", "HEAD", "OPTIONS"]
+
+    scanner = AdvancedHostEngine(target, protocol=proto, method_list=methods)
+    scanner.scan()
+
+    input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+
+# [5] IP LOOKUP -> IP & GEO TRACER
+def ip_lookup():
+    banner()
+    print(f"{COLOR_YELLOW}{BOLD}[*] EXECUTING: IP & GEO TRACER{RESET}\n")
+    target = clean_host(input(f"{COLOR_CYAN}[?] Enter Host/IP: {COLOR_WHITE}"))
+
+    try:
+        ip = socket.gethostbyname(target)
+        res = requests.get(f"http://ip-api.com/json/{ip}", headers=HEADERS, timeout=6).json()
+        print(f"\n{COLOR_GREEN}[✔] Resolved IP  : {COLOR_WHITE}{ip}")
+        print(f"{COLOR_GREEN}[✔] Location     : {COLOR_WHITE}{res.get('country', 'N/A')}, {res.get('city', 'N/A')}")
+        print(f"{COLOR_GREEN}[✔] ISP Provider : {COLOR_WHITE}{res.get('isp', 'N/A')}")
+        print(f"{COLOR_GREEN}[✔] ASN Route    : {COLOR_WHITE}{res.get('as', 'N/A')}")
+        print(f"{COLOR_GREEN}[✔] Timezone     : {COLOR_WHITE}{res.get('timezone', 'N/A')}")
+    except Exception:
+        print(f"{COLOR_BANNER}[!] IP lookup failed.{RESET}")
+
+    input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+
+# [11] CIDR TO IP -> SUBNET TO IP EXTRACTOR
+def cidr_to_ip():
+    banner()
+    print(f"{COLOR_YELLOW}{BOLD}[*] EXECUTING: SUBNET TO IP EXTRACTOR{RESET}\n")
+    cidr = input(f"{COLOR_CYAN}[?] Enter Subnet Block (e.g. 192.168.1.0/28): {COLOR_WHITE}").strip()
+    try:
+        net = ipaddress.ip_network(cidr, strict=False)
+        with open("cidr_ips.txt", "w") as f:
+            for ip in net.hosts():
+                f.write(str(ip) + "\n")
+        print(f"\n{COLOR_GREEN}[✔] Extracted host IPs saved to: {COLOR_WHITE}cidr_ips.txt{RESET}")
+    except:
+        print(f"{COLOR_BANNER}[!] Invalid Subnet mask.{RESET}")
+    input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+
+# [12] DOMAIN TO IP -> BULK DOMAIN RESOLVER
+def domain_to_ip():
+    banner()
+    print(f"{COLOR_YELLOW}{BOLD}[*] EXECUTING: BULK DOMAIN RESOLVER{RESET}\n")
+    fname = input(f"{COLOR_CYAN}[?] Domain List File: {COLOR_WHITE}").strip()
+    if fname.startswith("~/"):
+        fname = os.path.expanduser(fname)
+    if os.path.exists(fname):
+        print(f"\n{COLOR_BLUE}[*] Resolving names to IPs...{RESET}\n")
+        out_name = f"resolved_{os.path.basename(fname)}"
+        with open(fname, 'r', encoding='utf-8', errors='ignore') as f, open(out_name, 'w') as out:
+            for line in f:
+                d = clean_host(line)
+                if d:
+                    try:
+                        ip = socket.gethostbyname(d)
+                        out.write(f"{d} -> {ip}\n")
+                        print(f" {COLOR_GREEN}[✔] {COLOR_WHITE}{d:<25} {COLOR_CYAN}-> {COLOR_GREEN}{ip}{RESET}")
+                    except:
+                        print(f" {COLOR_BANNER}[✖] {COLOR_WHITE}{d:<25} {COLOR_BANNER}-> Failed{RESET}")
+        print(f"\n{COLOR_GREEN}[✔] Batch complete! Output: {COLOR_WHITE}{out_name}{RESET}")
+    else:
+        print(f"{COLOR_BANNER}[!] File not found.{RESET}")
+    input(f"\n{COLOR_YELLOW}Press Enter to return...{RESET}")
+
+# MAIN MENU CONTROLLER (CUSTOMIZED TITLES WITH HD COLOR)
+def main():
+    while True:
+        banner()
+        print(f" {COLOR_CYAN}[1]{RESET}  {COLOR_WHITE}{BOLD}ADVANCED HOST PROBE{RESET}")
+        print(f" {COLOR_PURPLE}[2]{RESET}  {COLOR_WHITE}{BOLD}SUB-ASSET RADAR{RESET}")
+        print(f" {COLOR_CYAN}[3]{RESET}  {COLOR_WHITE}{BOLD}CLOUD DNS RESOLVER{RESET}")
+        print(f" {COLOR_GREEN}[4]{RESET}  {COLOR_WHITE}{BOLD}DEEP HOST INTEL{RESET}")
+        print(f" {COLOR_YELLOW}[5]{RESET}  {COLOR_WHITE}{BOLD}IP & GEO TRACER{RESET}")
+        print(f" {COLOR_BLUE}[6]{RESET} {COLOR_WHITE}{BOLD}SUBNET TO IP EXTRACTOR{RESET}")
+        print(f" {COLOR_ORANGE}[7]{RESET} {COLOR_WHITE}{BOLD}BULK DOMAIN RESOLVER{RESET}")
+        print(f" {COLOR_BANNER}[8]{RESET} {COLOR_BANNER}{BOLD}TERMINATE / EXIT{RESET}\n")
+
+        ch = input(f"{COLOR_YELLOW}[-] Your Choice: {COLOR_WHITE}").strip()
+
+        if ch == '1': host_scanner()
+        elif ch == '2': sub_hunter()
+        elif ch == '3': dns_record()
+        elif ch == '4': host_info()
+        elif ch == '5': ip_lookup()
+        elif ch == '6': cidr_to_ip()
+        elif ch == '7': domain_to_ip()
+        elif ch == '8':
+            print(f"\n{COLOR_BANNER}[!] Session terminated. Bye!{RESET}\n")
+            sys.exit()
+        else:
+            time.sleep(0.4)
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: nexus-scan
+Version: 1.0.0
+Summary: Advanced Recon & Network Audit Suite
+Author: NEXUS GOAT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: urllib3
+
+# Nexus Scanner Tool

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

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.py
+nexus/__init__.py
+nexus/cli.py
+nexus_scan.egg-info/PKG-INFO
+nexus_scan.egg-info/SOURCES.txt
+nexus_scan.egg-info/dependency_links.txt
+nexus_scan.egg-info/entry_points.txt
+nexus_scan.egg-info/requires.txt
+nexus_scan.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+nexus = nexus.cli:main

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

@@ -0,0 +1,2 @@
+requests
+urllib3

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

@@ -0,0 +1 @@
+nexus

nexus_scan-1.0.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nexus-scan"
+version = "1.0.0"
+authors = [{ name="NEXUS GOAT" }]
+description = "Advanced Recon & Network Audit Suite"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "requests",
+    "urllib3"
+]
+
+[project.scripts]
+nexus = "nexus.cli:main"

nexus_scan-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nexus_scan-1.0.0/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="nexus-scan",
+    version="1.0.0",
+    author="NEXUS GOAT",
+    description="Nexus Recon and Scanning Suite",
+    long_description="Advanced Network Scanning Suite",
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    install_requires=["requests", "urllib3"],
+    entry_points={
+        "console_scripts": [
+            "nexus=nexus.cli:main",
+        ],
+    },
+)