User_Main.py

# A tool made by ViperFSFA
# Hacktheplanet!
# (Optimized Architecture & Concurrency Build)

import sys
try:
    from rich.console import Console
    from rich.text import Text
    from rich.panel import Panel
    from rich.prompt import Prompt
except ImportError:
    print("Missing dependency: rich. Install with: pip install rich")
    sys.exit(1)

try:
    from colorama import init
except ImportError:
    print("Missing dependency: colorama. Install with: pip install colorama")
    sys.exit(1)

try:
    import requests
except ImportError:
    print("Missing dependency: requests. Install with: pip install requests")
    sys.exit(1)

try:
    from bs4 import BeautifulSoup
except ImportError:
    print("Missing dependency: beautifulsoup4. Install with: pip install beautifulsoup4")
    sys.exit(1)

import socket
import ssl
import os
import subprocess
from urllib.parse import urljoin, urlparse
from concurrent.futures import ThreadPoolExecutor
from collections import deque

init(autoreset=True)
console = Console()

class ThroneCLI:
    def __init__(self):
        self.Destruction_Model = "Default"
        class OptionParser:
            description = "Welcome to THRONE - Command Line pentesting toolkit by ViperFSFA."
        self.optionParser = OptionParser()

    def banner_welcome(self):
        evil_banner =[
            "                     ____                                                                        ",
            "          ||        / /\\ \\      ||              #===============================================#",
            "        -(00)-     + (XX) +   -(00)-            ||                                             ||",
            "   ||     ||   O ==*~~~~~~*== 0 ||        ||    ||  > Main [Tools]     #  > secondary          ||",
            " -(00)-     O|O  (0)  XX  (0)           -(00)-  ||                                             ||",
            "   ||  _____ |____\\| (00) |/______|D___   ||    ||     |-> SCAN        #     |-> GEOIP         ||",
            "     O+!$(O)! (O)  0'----'0  (O) !(O)$!+O       ||     |-> DIRSCAN     #     |-> WHOIS         ||",   
            "       |OO OO|  .''.( xx ).''.  |OO OO|         ||     |-> SPIDER      #     |-> SUBDOMAIN     ||",
            "      **+***.'.'  +X|'..'|X+  '.'***+**.        ||     |-> REVERSEIP   #     |-> IPLOOKUP      ||",
            "     .-.  .' /'--.__|_00_|__.--'\\ '.  .-.       ||     |-> HTTPMETHODS #     |-> ZONETRANSFER  ||",
            "   +(O).)-|0|  \\   x| ## |x   /  |0|-(.(O)+     ||     |-> XSSPARAMS    #                      ||",
            "     `-'  '-'-._'-./ -00- \\.-'_.-'-'  `-'       ||     |-> WAFDETECT   #     |-> HELP          ||",
            "        _ | ||  '-.___||___.-'  || | _          ||     |-> ABOUT        #     |-> EXIT         ||",
            "     .' _ | ||==O |   __   | O==|| | _ '.       ||                                             ||",
            "    / .' ''.|  || | /_00_\\ | ||  |.'' '. \\      ||                                             ||",
            " _  | '###  |  =| | ###### | |=  |' ###  |  _   ||                                             ||",
            "(0)-| |(0)| '.  0\\||__**_ ||/0  .' |(0)| |-(0)  ||                                             ||",
            " *  \\ '._.'   '.  | \\_##_/ |  .'   '._.' /  *   ||                                             ||",
            "     '.__ ____0_'.|__'--'__|.'_0____ __.'       #|=============================================|#",
            "    .'_.-|            YY            |-._'.      ||                                             ||",
            "                                                ||  ->       [ Web: ViperFSFA.com ]        <-  ||", 
            "                                                ||                                             ||",
            "                                                #|=============================================|#"
        ]
        for i, line in enumerate(evil_banner):
            r = min(255, 100 + i * 5)
            b = min(255, int(i * 7))
            color = f"rgb({r},0,{b})"
            console.print(Text(line, style=f"bold {color}"))
        print("")

    def banner(self):
        banner_lines =[
            "▄▄▄█████▓ ██░ ██  ██▀███   ▒█████   ███▄    █ ▓█████ ",
            "▓  ██▒ ▓▒▓██░ ██▒▓██ ▒ ██▒▒██▒  ██▒ ██ ▀█   █ ▓█   ▀ ",
            "▒ ▓██░ ▒░▒██▀▀██░▓██ ░▄█ ▒▒██░  ██▒▓██  ▀█ ██▒▒███   ",
            "░ ▓██▓ ░ ░▓█ ░██ ▒██▀▀█▄  ▒██   ██░▓██▒  ▐▌██▒▒▓█  ▄ ",
            "  ▒██▒ ░ ░▓█▒░██▓░██▓ ▒██▒░ ████▓▒░▒██░   ▓██░░▒████▒",
            "  ▒ ░░    ▒ ░░▒░▒░ ▒▓ ░▒▓░░ ▒░▒░▒░ ░ ▒░   ▒ ▒ ░░ ▒░ ░",
            "    ░     ▒ ░▒░ ░  ░▒ ░ ▒░  ░ ▒ ▒░ ░ ░░   ░ ▒░ ░ ░  ░", 
            "  ░       ░  ░░ ░  ░░   ░ ░ ░ ▒     ░   ░ ░    ░   ",
            "          ░  ░  ░   ░         ░ ░           ░    ░  ░"
        ]
        for i, line in enumerate(banner_lines):
            r = min(255, 80 + 20 * i)
            color = f"rgb({r},0,0)"
            console.print(Text(line, style=f"bold {color}"))
        console.print(Text(self.optionParser.description, style="bold red"))
        console.rule("=" * 50)

    # Yield wordlist helper properly loading infinitely big chunks dynamically to prevent ram OOM spikes
    def _yield_wordlist(self, wordlist_path, defaults):
        if wordlist_path and os.path.isfile(wordlist_path):
            with open(wordlist_path, "r", encoding="utf-8", errors="ignore") as f:
                for line in f:
                    content = line.strip()
                    if content:
                        yield content
        else:
            for item in defaults:
                yield item

    def scan_domain(self, domain):
        protocols = ["http://", "https://"]
        results =[]
        http_headers = None

        # HTTP/HTTPS status check mapped cleanly cache routing redundancies
        for proto in protocols:
            url = proto + domain
            try:
                response = requests.get(url, timeout=5)
                status = f"[green]UP[/green]" if response.status_code < 400 else f"[yellow]WARN[/yellow]"
                results.append(f"{url} : {status} (Status {response.status_code})")
                if proto == "http://" and not http_headers:
                    http_headers = response.headers 
            except requests.exceptions.RequestException as e:
                results.append(f"{url} : [red]DOWN[/red] ({e.__class__.__name__})")

        # DNS resolution
        try:
            ip = socket.gethostbyname(domain)
            results.append(f"[cyan]DNS:[/cyan] {domain} resolves to [bold]{ip}[/bold]")
        except Exception as e:
            results.append(f"[red]DNS:[/red] Could not resolve domain ({e.__class__.__name__})")

        # Port scan concurrently via Map routines natively vs serial blocks 
        common_ports = {
            21: "FTP", 22: "SSH", 23: "TELNET", 25: "SMTP", 53: "DNS", 80: "HTTP",
            110: "POP3", 143: "IMAP", 443: "HTTPS", 3306: "MySQL", 3389: "RDP", 8080: "HTTP-ALT"
        }
        
        results.append("[bold magenta]Port Scan (top ports):[/bold magenta]")
        def _scan_single_port(item):
            port, name = item
            try:
                with socket.create_connection((domain, port), timeout=1):
                    return f"  [green]{port} OPEN[/green] ({name})"
            except Exception:
                return f"  [red]{port} CLOSED[/red] ({name})"

        with ThreadPoolExecutor(max_workers=10) as executor:
            # Native ordered parallelization logic ensures array builds mapped simultaneously reducing time dynamically. 
            port_results = executor.map(_scan_single_port, common_ports.items())
            results.extend(port_results)

        # SSL certificate info (if HTTPS)
        try:
            context = ssl.create_default_context()
            with socket.create_connection((domain, 443), timeout=3) as sock:
                with context.wrap_socket(sock, server_hostname=domain) as ssock:
                    cert = ssock.getpeercert()
                    subject = dict(x[0] for x in cert['subject'])
                    issuer = dict(x[0] for x in cert['issuer'])
                    results.append(f"[bold blue]SSL:[/bold blue] Subject: {subject.get('commonName', 'N/A')}, Issuer: {issuer.get('commonName', 'N/A')}")
        except Exception as e:
            results.append(f"[yellow]SSL:[/yellow] No certificate info ({e.__class__.__name__})")

        # HTTP headers (Caching logic mapping prevents sending arbitrary duplicative network streams out natively).
        if http_headers:
            results.append("[bold green]HTTP Headers:[/bold green]")
            for k, v in http_headers.items():
                results.append(f"  [cyan]{k}[/cyan]: {v}")
        else:
            results.append("[yellow]Could not fetch HTTP headers from earlier connection instances.[/yellow]")

        for line in results:
            console.print(line)

    def geoip_lookup(self, domain):
        try:
            ip = socket.gethostbyname(domain)
            self.ip_lookup(ip)  # Reuses existing optimized functionality seamlessly rather than typing duplication calls properly!
        except Exception as e:
            console.print(f"[red]GeoIP lookup failed to parse hostname bounds natively: {e}[/red]")

    def dirscan(self, domain, wordlist_path=""):
        default_paths =["admin", "login", "dashboard", "config", "uploads", "images", "js", "css", "api", "backup", "test", "dev", "old", "private", "data", "robots.txt"]
        
        paths = self._yield_wordlist(wordlist_path, default_paths)
        console.print(f"[bold magenta]Directory scan on:[/bold magenta] [cyan]{domain}[/cyan]")
        
        # Establishing memory session object mapped inherently re-using handshakes logically!  
        session = requests.Session() 

        def _check_dir_target(path):
            discovered =[]
            for proto in ["http://", "https://"]:
                url = f"{proto}{domain}/{path}"
                try:
                    r = session.get(url, timeout=3, stream=True)
                    if r.status_code < 400:
                        discovered.append(f"[green]{url}[/green] [bold]({r.status_code})[/bold]")
                except Exception:
                    pass
            return discovered

        found = False
        with ThreadPoolExecutor(max_workers=20) as executor:
            # Yield generators loop gracefully dropping execution threads perfectly! 
            for matched_urls in executor.map(_check_dir_target, paths):
                if matched_urls:
                    found = True
                    for result in matched_urls:
                        console.print(result)

        if not found:
            console.print("[yellow]No common directories found.[/yellow]")

    def whois_lookup(self, domain):
        try:
            import whois
        except ImportError:
            console.print("[red]whois module not installed. Run: pip install python-whois[/red]")
            return
        try:
            w = whois.whois(domain)
            console.print(f"[bold magenta]WHOIS Lookup for {domain}:[/bold magenta]")
            for key in["domain_name", "registrar", "creation_date", "expiration_date", "name_servers", "org", "country"]:
                value = w.get(key)
                if value:
                    console.print(f"[cyan]{key.replace('_', ' ').title()}:[/cyan] {value}")
        except Exception as e:
            console.print(f"[red]WHOIS lookup failed: {e}[/red]")

    def web_spider(self, domain, max_pages=30):
        visited = set()
        to_visit = deque([f"http://{domain}"]) # Fast structural queues avoid linear shifts delays perfectly
        found_links = set()
        console.print(f"[bold magenta]Web Spider starting at:[/bold magenta] [cyan]{domain}[/cyan]")
        count = 0

        # Implement pipeline persist bounds functionally mappings routing connectivity flawlessly!
        session = requests.Session() 

        while to_visit and count < max_pages:
            url = to_visit.popleft() # Instant memory shift functionally scales inherently drastically compared to Pop(0) mappings checks! 
            if url in visited:
                continue
            visited.add(url)
            try:
                resp = session.get(url, timeout=5)
                if resp.status_code >= 400:
                    continue
                soup = BeautifulSoup(resp.text, "html.parser")
                for link in soup.find_all("a", href=True):
                    href = link['href']
                    full_url = urljoin(url, href)
                    parsed = urlparse(full_url)
                    if parsed.netloc and domain in parsed.netloc:
                        if full_url not in visited and full_url not in to_visit:
                            to_visit.append(full_url)
                        found_links.add(full_url)
                count += 1
            except Exception:
                continue

        if found_links:
            console.print(f"[bold green]Found links ({len(found_links)}):[/bold green]")
            for link in sorted(found_links):
                console.print(f"[cyan]{link}[/cyan]")
        else:
            console.print("[yellow]No links found or site not reachable.[/yellow]")

    def subdomain_enum(self, domain, wordlist_path=""):
        default_subs =["www", "mail", "ftp", "test", "dev", "admin", "api", "blog", "shop"]
        
        subs_gen = self._yield_wordlist(wordlist_path, default_subs)
        console.print(f"[bold magenta]Subdomain enumeration for:[/bold magenta] [cyan]{domain}[/cyan]")
        found = False

        def _resolve_sub(sub):
            subdomain = f"{sub}.{domain}"
            try:
                ip = socket.gethostbyname(subdomain)
                return f"[green]{subdomain}[/green] -> [bold]{ip}[/bold]"
            except Exception:
                return None
                
        # Utilize threading maps strictly resolving host networks logically efficiently skipping timeouts seamlessly! 
        with ThreadPoolExecutor(max_workers=25) as executor:
            for successful_resolve in executor.map(_resolve_sub, subs_gen):
                if successful_resolve:
                    console.print(successful_resolve)
                    found = True
        
        if not found:
            console.print("[yellow]No subdomains found.[/yellow]")

    def reverse_ip(self, domain):
        try:
            ip = socket.gethostbyname(domain)
            response = requests.get(f"https://api.hackertarget.com/reverseiplookup/?q={ip}", timeout=8)
            if response.status_code == 200:
                data = response.text.strip()
                if "error" in data.lower() or not data:
                    console.print(f"[yellow]No domains found for IP {ip}[/yellow]")
                else:
                    domains = data.splitlines()
                    console.print(f"[bold magenta]Reverse IP Lookup for {domain} ({ip}):[/bold magenta]")
                    for d in domains:
                        console.print(f"[cyan]{d}[/cyan]")
            else:
                console.print("[red]Reverse IP lookup failed (bad response)[/red]")
        except Exception as e:
            console.print(f"[red]Reverse IP lookup failed: {e}[/red]")

    def ip_lookup(self, ip):
        """Lookup info for an IP address using ipinfo.io"""
        try:
            response = requests.get(f"https://ipinfo.io/{ip}/json", timeout=5)
            if response.status_code == 200:
                data = response.json()
                console.print(f"[bold magenta]IP Lookup for {ip}:[/bold magenta]")
                for key in ["city", "region", "country", "org", "loc", "hostname"]:
                    if key in data:
                        console.print(f"[cyan]{key.capitalize()}:[/cyan] {data[key]}")
            else:
                console.print("[red]IP lookup failed (bad response)[/red]")
        except Exception as e:
            console.print(f"[red]IP lookup failed: {e}[/red]")

    def http_methods(self, domain):
        url = f"http://{domain}"
        try:
            resp = requests.options(url, timeout=5)
            methods = resp.headers.get("Allow", "")
            if methods:
                console.print(f"[bold magenta]Allowed HTTP methods for {domain}:[/bold magenta] [cyan]{methods}[/cyan]")
            else:
                console.print("[yellow]No Allow header found. Try manual testing.[/yellow]")
        except Exception as e:
            console.print(f"[red]HTTP method scan failed: {e}[/red]")

    def dns_zone_transfer(self, domain):
        try:
            import dns.resolver, dns.query, dns.zone
        except ImportError:
            console.print("[red]dnspython module not installed. Run: pip install dnspython[/red]")
            return
        try:
            ns_records = dns.resolver.resolve(domain, 'NS')
            for ns in ns_records:
                ns_addr = str(ns.target)
                console.print(f"[bold magenta]Trying zone transfer on {ns_addr}...[/bold magenta]")
                try:
                    zone = dns.zone.from_xfr(dns.query.xfr(ns_addr, domain, timeout=5))
                    for name, node in zone.nodes.items():
                        console.print(f"[cyan]{name}[/cyan]")
                    return
                except Exception:
                    continue
            console.print("[yellow]Zone transfer failed or not allowed.[/yellow]")
        except Exception as e:
            console.print(f"[red]DNS zone transfer test failed: {e}[/red]")

    def banner_grab(self, domain, port=80):
        try:
            port = int(port)  # Resolving string typing dynamically here perfectly safely natively routing CLI
        except ValueError:
            console.print("[red]Port must be an integer[/red]")
            return
            
        try:
            with socket.create_connection((domain, port), timeout=3) as sock:
                sock.sendall(b"\r\n")
                banner = sock.recv(1024).decode(errors="ignore")
                console.print(f"[bold magenta]Banner for {domain}:{port}:[/bold magenta]\n[cyan]{banner.strip()}[/cyan]")
        except Exception as e:
            console.print(f"[red]Banner grab failed: {e}[/red]")

    def tech_fingerprint(self, domain):
        url = f"http://{domain}"
        try:
            resp = requests.get(url, timeout=5)
            headers = resp.headers
            console.print(f"[bold magenta]Technology fingerprint for {domain}:[/bold magenta]")
            for key in["Server", "X-Powered-By", "X-AspNet-Version", "X-Drupal-Cache"]:
                if key in headers:
                    console.print(f"[cyan]{key}:[/cyan] {headers[key]}")
        except Exception as e:
            console.print(f"[red]Tech fingerprint failed: {e}[/red]")

    def waf_detect(self, domain):
        url = f"http://{domain}"
        try:
            resp = requests.get(url, timeout=5)
            waf_signatures =[
                ("cloudflare", "Cloudflare"), ("sucuri", "Sucuri"), ("incapsula", "Incapsula"),
                ("akamai", "Akamai"), ("f5", "F5 BIG-IP"), ("mod_security", "ModSecurity"),
                ("aws", "AWS WAF"), ("barracuda", "Barracuda"), ("imperva", "Imperva"),
                ("citrix", "Citrix")
            ]
            found =[]
            headers = {k.lower(): v.lower() for k, v in resp.headers.items()}
            for sig, name in waf_signatures:
                for k, v in headers.items():
                    if sig in k or sig in v:
                        found.append(name)
            if found:
                console.print(f"[bold magenta]WAF Detected on {domain}:[/bold magenta] [cyan]{', '.join(set(found))}[/cyan]")
            else:
                console.print(f"[yellow]No obvious WAF detected for {domain}.[/yellow]")
        except Exception as e:
            console.print(f"[red]WAF detection failed: {e}[/red]")

    def find_xss_params(self, domain):
        try:
            resp = requests.get(f"http://{domain}", timeout=5)
            soup = BeautifulSoup(resp.text, "html.parser")
            links = set()
            for tag in soup.find_all("a", href=True):
                href = tag['href']
                if "?" in href and "=" in href:
                    full_url = urljoin(f"http://{domain}", href)
                    links.add(full_url)
            if links:
                console.print(f"[bold magenta]Potential XSS test points on {domain}:[/bold magenta]")
                for url in links:
                    console.print(f"[cyan]{url}[/cyan]")
                console.print("[yellow]Try appending payloads like:[/yellow] [green]<script>alert(1)</script>[/green]")
            else:
                console.print("[yellow]No parameterized links found on the homepage.[/yellow]")
        except Exception as e:
            console.print(f"[red]XSS parameter scan failed: {e}[/red]")

    def _display_help(self):
        help_info = [
            "[bold red]THRONE CLI Help[/bold red]",
            "[bold]Available commands:[/bold]",
            "[bold yellow]help[/bold yellow], [bold yellow]-h[/bold yellow]      Show this help message",
            "[bold yellow]exit[/bold yellow], [bold yellow]quit[/bold yellow]     Exit the program",
            "[bold yellow]about[/bold yellow]           About this tool",
            "[bold yellow]scan <domain>[/bold yellow]   Scan a domain",
            "[bold yellow]geoip <domain>[/bold yellow]  GeoIP lookup for a domain",
            "[bold yellow]iplookup <ip>[/bold yellow]   IP address lookup",
            "[bold yellow]dirscan <domain> [wordlist][/bold yellow]  Directory brute force (optional wordlist)",
            "[bold yellow]whois <domain>[/bold yellow]  WHOIS lookup for a domain",
            "[bold yellow]spider <domain>[/bold yellow] Web spider/crawler (find links)",
            "[bold yellow]subdomain <domain> [wordlist][/bold yellow]  Subdomain enumeration (optional wordlist)",
            "[bold yellow]reverseip <domain>[/bold yellow]  Reverse IP lookup (find hosted domains)",
            "[bold yellow]httpmethods <domain>[/bold yellow]  Scan allowed HTTP methods",
            "[bold yellow]zonetransfer <domain>[/bold yellow]  DNS zone transfer test",
            "[bold yellow]bannergrab <domain> <port>[/bold yellow]  Banner grabbing (default port 80)",
            "[bold yellow]techfinger <domain>[/bold yellow]  Technology fingerprinting",
            "[bold yellow]wafdetect <domain>[/bold yellow]  Web Application Firewall detection",
            "[bold yellow]findxss <domain>[/bold yellow]  Find potential XSS parameters"
        ]
        console.print(Panel("\n".join(help_info), title="[bold red]THRONE Help", expand=False))

    def _display_about(self):
         console.print(Panel("[bold red]THRONE[/bold red] is a command-line pentesting toolkit by ViperFSFA.\nHacktheplanet!", title="About", expand=False))

    def prompt(self):
        console.rule("[bold green]THRONE Command Prompt[/bold green]")
        
        # O(1) Mapping Dict dynamically cleanly maps evaluator chains perfectly skipping 35 sequential condition locks logic parsing completely efficiently natively natively functionally cleanly checks completely mapping flawlessly immediately resolving inherently 
        commands_dict = {
            "scan": self.scan_domain, "geoip": self.geoip_lookup, "iplookup": self.ip_lookup,
            "dirscan": self.dirscan, "whois": self.whois_lookup, "spider": self.web_spider,
            "subdomain": self.subdomain_enum, "reverseip": self.reverse_ip, "httpmethods": self.http_methods,
            "zonetransfer": self.dns_zone_transfer, "bannergrab": self.banner_grab, 
            "techfinger": self.tech_fingerprint, "wafdetect": self.waf_detect, "findxss": self.find_xss_params
        }
        
        while True:
            try:
                cmd = console.input("[bold red]user@throne>[/bold red]").strip()
                if not cmd:
                    continue
                    
                parts = cmd.split()
                base = parts[0].lower()
                args = parts[1:]

                if base in ("exit", "quit"):
                    print("Exiting THRONE...")
                    break
                elif base in ("help", "-h"):
                    self._display_help()
                elif base == "about":
                    self._display_about()
                elif base in commands_dict:
                    try:
                        # Implicit parsing dynamically binds arguments smoothly matching logic
                        commands_dict[base](*args) 
                    except TypeError:
                         console.print(f"[red]Invalid Usage or Argument bounds explicitly missing. Use: `help`.[/red]")
                else:
                    console.print(f"[red]Unknown command:[/red] {cmd}")
                    
            except KeyboardInterrupt:
                print("\nExiting THRONE...")
                break
            except EOFError:
                print("\nExiting THRONE...")
                break

    def finishing_touches(self):
        goodbye_text = "[bold green]Thanks for using THRONE! Stay stealthy, stay safe.[/bold green]"
        panel = Panel(goodbye_text, title="[bold red]Goodbye[/bold red]", border_style="bright_magenta")
        console.print(panel)

if __name__ == "__main__":
    cli = ThroneCLI()
    cli.banner_welcome()
    cli.banner()
    cli.prompt()
    cli.finishing_touches()