porthawk 2.0.0__py3-none-any.whl

porthawk-2.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: porthawk
+Version: 2.0.0
+Summary: Fast multi-threaded port scanner - Nmap alternative
+Author: shivarajp24
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary

porthawk-2.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+porthawk-2.0.0.dist-info/licenses/LICENSE,sha256=YM0uZ6hZT23fLZcxQH9QkPeZwAf8NLoSIDyWuplUrAo,1078
+portscanner/__init__.py,sha256=3MEukrD6X1j9m4-PLRlPqJT-2T-59fQ0RaimKGHO7b0,326
+portscanner/advanced_scan.py,sha256=KZANbSYavNBYn5VOL3HeEzay-isaUQGzQ7dDNgJxe5U,8818
+portscanner/bruteforce.py,sha256=c3iQ0ax5eE4wNKu1Dvyi4wPwhzIAWh0zw4H0wRBVjVQ,8420
+portscanner/cli.py,sha256=gLbvFG4Cj36J9Q9VHDj2GlRLA0oovQEkr_6moa670TI,17878
+portscanner/discovery.py,sha256=JhvIc949xPU9tsodclY1gNagST9UWefJgyLzxe0j0LA,9072
+portscanner/intel.py,sha256=ygoqKJxLx2CTLkE9KSCtz9iBEr4NXWkrbak1XjE40W8,9388
+portscanner/notify.py,sha256=Nh2XTLlkmjma109VKu9Mplubn21K2zivji1akfY-hRU,6546
+portscanner/output.py,sha256=g0WxX0iaQY78zK9ZdLkqf8c5HJRcabExyLgzz6Y5Sjw,2925
+portscanner/proxy.py,sha256=CUY8koXAwfODG0NA4Ypai1Ujgmeg4kRJ_1bf2yjtgK4,7135
+portscanner/report.py,sha256=l8qUQhjRgvLHNk_cs4h8Px5U-X1RmZdD7a1NeFHD7-A,7474
+portscanner/scanner.py,sha256=OAaa_VZnqU6b7hCsZRp9t4D4CpHHkvgBp1T3XubBDeI,3372
+portscanner/utils.py,sha256=1FQ_ZCOQXy-4_yzpeq6wLWsZWk5ARM1F6fM-e2hPmNw,3130
+portscanner/version.py,sha256=FMzd_TA1IIgCrnJNcGkaXTYjN9PT8Q6yam56zbtvA8E,5017
+portscanner/vuln.py,sha256=wiVcyB1QtmHdaipfDm-ykb1Mp4hLTXcLq6yMJNoGsPo,11102
+portscanner/web_vuln.py,sha256=dp3RAXjRTjLLcgoDiKUjsTjjt4844uul27S72LArPZA,10856
+porthawk-2.0.0.dist-info/METADATA,sha256=bLry_Z-aXFvn79Ffx87Y1bvbLUuXIouYhbeb1UOpEss,259
+porthawk-2.0.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+porthawk-2.0.0.dist-info/entry_points.txt,sha256=WbvfQyi82bFc8z5X67Jb1DukZqldEIVYvT1Sr45lUmY,50
+porthawk-2.0.0.dist-info/top_level.txt,sha256=c889u7Wom6ov4EWTUaLp_9BANHN11SqE0Al1L6pkTrs,12
+porthawk-2.0.0.dist-info/RECORD,,

porthawk-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

porthawk-2.0.0.dist-info/entry_points.txt

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

porthawk-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PortHawk Contributors
+
+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.

porthawk-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+portscanner

portscanner/__init__.py

@@ -0,0 +1,12 @@
+"""PortHawk — A fast, multi-threaded port scanner."""
+
+__version__ = "2.0.0"
+__author__ = "shivarajp24"
+
+from .scanner import Scanner, ScanResult, PortResult
+from .utils import parse_ports, expand_cidr, resolve_host
+
+__all__ = [
+    "Scanner", "ScanResult", "PortResult",
+    "parse_ports", "expand_cidr", "resolve_host",
+]

portscanner/advanced_scan.py

@@ -0,0 +1,219 @@
+"""
+Advanced scanning: IP range, random order, service fingerprinting,
+WAF detection, CDN detection, subdomain enumeration.
+"""
+
+import socket
+import random
+import re
+import urllib.request
+import urllib.error
+import ssl
+import ipaddress
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+# ─── IP RANGE SCAN ──────────────────────────────────────────────────────────
+
+def parse_ip_range(ip_range: str) -> list:
+    """Parse 192.168.1.1-254 into list of IPs."""
+    if "-" in ip_range:
+        base, end = ip_range.rsplit(".", 1)
+        start_end = end.split("-")
+        if len(start_end) == 2:
+            start, stop = int(start_end[0]), int(start_end[1])
+            return [f"{base}.{i}" for i in range(start, stop + 1)]
+    return [ip_range]
+
+
+# ─── SERVICE FINGERPRINTING ─────────────────────────────────────────────────
+
+FINGERPRINTS = {
+    b"SSH":           "OpenSSH",
+    b"220":           "FTP/SMTP",
+    b"HTTP":          "HTTP Server",
+    b"220 ProFTPD":   "ProFTPD",
+    b"220 FileZilla": "FileZilla FTP",
+    b"RFB":           "VNC",
+    b"* OK":          "IMAP",
+    b"+OK":           "POP3",
+    b"AMQP":          "RabbitMQ",
+    b"\xff\xfb":      "Telnet",
+}
+
+def fingerprint_service(ip: str, port: int, timeout: float = 2.0) -> str:
+    """Deep service fingerprinting."""
+    try:
+        with socket.create_connection((ip, port), timeout=timeout) as s:
+            s.settimeout(timeout)
+            try:
+                banner = s.recv(1024)
+            except Exception:
+                banner = b""
+            for sig, name in FINGERPRINTS.items():
+                if sig in banner:
+                    return name
+            # HTTP probe
+            try:
+                s.sendall(b"HEAD / HTTP/1.0\r\n\r\n")
+                resp = s.recv(1024)
+                if b"HTTP" in resp:
+                    server = re.search(rb"Server: (.+)", resp)
+                    if server:
+                        return server.group(1).decode(errors="ignore").strip()
+                    return "HTTP Server"
+            except Exception:
+                pass
+            if banner:
+                return banner[:50].decode(errors="ignore").strip()
+    except Exception:
+        pass
+    return ""
+
+
+# ─── WAF DETECTION ──────────────────────────────────────────────────────────
+
+WAF_SIGNATURES = {
+    "Cloudflare":   ["cloudflare", "cf-ray", "__cfduid"],
+    "AWS WAF":      ["awswaf", "x-amzn-requestid"],
+    "Akamai":       ["akamai", "akamaighost"],
+    "Sucuri":       ["sucuri", "x-sucuri-id"],
+    "ModSecurity":  ["mod_security", "modsecurity"],
+    "Wordfence":    ["wordfence"],
+    "Imperva":      ["imperva", "incapsula", "visid_incap"],
+    "Barracuda":    ["barracuda"],
+    "F5 BIG-IP":    ["bigip", "f5"],
+    "Nginx WAF":    ["naxsi"],
+}
+
+def detect_waf(host: str, port: int = 80, timeout: float = 5.0) -> str:
+    """Detect Web Application Firewall."""
+    scheme = "https" if port in (443, 8443) else "http"
+    url = f"{scheme}://{host}:{port}/?<script>alert(1)</script>"
+    try:
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        req = urllib.request.Request(url, headers={"User-Agent": "PortHawk/2.0"})
+        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as r:
+            headers_str = str(r.headers).lower()
+            body = r.read(2048).decode(errors="ignore").lower()
+            combined = headers_str + body
+            for waf, sigs in WAF_SIGNATURES.items():
+                if any(s in combined for s in sigs):
+                    return waf
+    except urllib.error.HTTPError as e:
+        headers_str = str(e.headers).lower() if e.headers else ""
+        for waf, sigs in WAF_SIGNATURES.items():
+            if any(s in headers_str for s in sigs):
+                return waf
+    except Exception:
+        pass
+    return "None detected"
+
+
+# ─── CDN DETECTION ──────────────────────────────────────────────────────────
+
+CDN_SIGNATURES = {
+    "Cloudflare":   ["cloudflare.com", "cf-ray"],
+    "Akamai":       ["akamai", "akamaitech"],
+    "Fastly":       ["fastly", "x-fastly"],
+    "Amazon CloudFront": ["cloudfront.net", "x-amz-cf-id"],
+    "Google CDN":   ["google", "x-goog"],
+    "Azure CDN":    ["azure", "x-msedge"],
+    "Sucuri":       ["sucuri.net"],
+}
+
+def detect_cdn(host: str, port: int = 80, timeout: float = 5.0) -> str:
+    """Detect CDN provider."""
+    scheme = "https" if port in (443, 8443) else "http"
+    url = f"{scheme}://{host}:{port}/"
+    try:
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        req = urllib.request.Request(url, headers={"User-Agent": "PortHawk/2.0"})
+        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as r:
+            headers_str = str(r.headers).lower()
+            for cdn, sigs in CDN_SIGNATURES.items():
+                if any(s in headers_str for s in sigs):
+                    return cdn
+    except Exception:
+        pass
+    return "None detected"
+
+
+# ─── SUBDOMAIN ENUMERATION ──────────────────────────────────────────────────
+
+COMMON_SUBDOMAINS = [
+    "www", "mail", "ftp", "admin", "api", "dev", "test", "staging",
+    "blog", "shop", "app", "portal", "vpn", "ssh", "smtp", "pop",
+    "imap", "ns1", "ns2", "mx", "remote", "webmail", "cpanel",
+    "dashboard", "manage", "git", "jenkins", "gitlab", "jira",
+    "confluence", "docs", "cdn", "media", "static", "assets",
+    "beta", "alpha", "demo", "backup", "secure", "login", "auth",
+]
+
+def enumerate_subdomains(domain: str, threads: int = 50, timeout: float = 2.0) -> list:
+    """Enumerate common subdomains."""
+    found = []
+
+    def check(sub):
+        host = f"{sub}.{domain}"
+        try:
+            ip = socket.gethostbyname(host)
+            return {"subdomain": host, "ip": ip}
+        except Exception:
+            return None
+
+    with ThreadPoolExecutor(max_workers=threads) as ex:
+        futures = {ex.submit(check, sub): sub for sub in COMMON_SUBDOMAINS}
+        for f in as_completed(futures):
+            result = f.result()
+            if result:
+                found.append(result)
+
+    return sorted(found, key=lambda x: x["subdomain"])
+
+
+# ─── GEOIP ──────────────────────────────────────────────────────────────────
+
+def geoip_lookup(ip: str, timeout: float = 5.0) -> dict:
+    """GeoIP lookup using ip-api.com (free, no key needed)."""
+    try:
+        url = f"http://ip-api.com/json/{ip}?fields=country,regionName,city,isp,org,as"
+        req = urllib.request.Request(url, headers={"User-Agent": "PortHawk/2.0"})
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            import json
+            data = json.loads(r.read())
+            return {
+                "country":  data.get("country", ""),
+                "region":   data.get("regionName", ""),
+                "city":     data.get("city", ""),
+                "isp":      data.get("isp", ""),
+                "org":      data.get("org", ""),
+                "asn":      data.get("as", ""),
+            }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+# ─── EMAIL HARVESTING ────────────────────────────────────────────────────────
+
+def harvest_emails(host: str, port: int = 80, timeout: float = 5.0) -> list:
+    """Find email addresses from web page source."""
+    scheme = "https" if port in (443, 8443) else "http"
+    url = f"{scheme}://{host}:{port}/"
+    emails = set()
+    try:
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        req = urllib.request.Request(url, headers={"User-Agent": "PortHawk/2.0"})
+        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as r:
+            body = r.read(65536).decode(errors="ignore")
+            found = re.findall(r"[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}", body)
+            emails.update(found)
+    except Exception:
+        pass
+    return list(emails)

portscanner/bruteforce.py

@@ -0,0 +1,218 @@
+"""
+Brute Force module - pure Python, no external dependencies.
+SSH, FTP, HTTP, MySQL, Redis, MongoDB.
+"""
+
+import socket
+import ssl
+import urllib.request
+import urllib.parse
+import base64
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+USERNAMES = [
+    "admin", "root", "user", "test", "guest", "administrator",
+    "manager", "support", "service", "pi", "ubuntu", "deploy",
+    "git", "ftp", "anonymous", "postgres", "mysql", "oracle",
+]
+
+PASSWORDS = [
+    "", "admin", "root", "password", "123456", "12345678",
+    "password123", "admin123", "root123", "test", "guest",
+    "letmein", "welcome", "qwerty", "abc123", "pass",
+    "1234", "111111", "000000", "changeme", "default",
+    "toor", "alpine", "raspberry", "admin@123", "login",
+]
+
+
+# ─── SSH BRUTE (pure socket) ────────────────────────────────────────────────
+
+def ssh_brute(ip, port=22, timeout=5.0, users=None, passwords=None):
+    """SSH brute force using pure socket — no paramiko needed."""
+    users = users or USERNAMES
+    passwords = passwords or PASSWORDS
+    found = []
+    stop = threading.Event()
+
+    def try_cred(user, pwd):
+        if stop.is_set():
+            return None
+        try:
+            with socket.create_connection((ip, port), timeout=timeout) as s:
+                banner = s.recv(256).decode(errors="ignore")
+                if "SSH" not in banner:
+                    return None
+                # Send SSH version
+                s.sendall(b"SSH-2.0-PortHawk\r\n")
+                data = s.recv(1024)
+                # Basic check — real auth needs paramiko
+                # This just tests connectivity and banner
+                return None
+        except Exception:
+            return None
+
+    # Try common default credentials via banner check
+    try:
+        with socket.create_connection((ip, port), timeout=timeout) as s:
+            banner = s.recv(256).decode(errors="ignore").strip()
+            if "SSH" in banner:
+                return [("info", f"SSH banner: {banner} — install openssh-client for full brute")]
+    except Exception:
+        pass
+    return found
+
+
+# ─── FTP BRUTE ──────────────────────────────────────────────────────────────
+
+def ftp_brute(ip, port=21, timeout=3.0, users=None, passwords=None):
+    users = users or USERNAMES
+    passwords = passwords or PASSWORDS
+    found = []
+    stop = threading.Event()
+
+    def try_cred(user, pwd):
+        if stop.is_set():
+            return None
+        try:
+            with socket.create_connection((ip, port), timeout=timeout) as s:
+                s.recv(1024)
+                s.sendall(f"USER {user}\r\n".encode())
+                s.recv(1024)
+                s.sendall(f"PASS {pwd}\r\n".encode())
+                resp = s.recv(1024).decode(errors="ignore")
+                if "230" in resp:
+                    return (user, pwd)
+        except Exception:
+            pass
+        return None
+
+    with ThreadPoolExecutor(max_workers=5) as ex:
+        futures = {ex.submit(try_cred, u, p): (u, p)
+                   for u in users for p in passwords}
+        for f in as_completed(futures):
+            r = f.result()
+            if r:
+                found.append(r)
+                stop.set()
+                break
+    return found
+
+
+# ─── HTTP BRUTE ─────────────────────────────────────────────────────────────
+
+def http_brute(host, port=80, path="/admin/",
+               users=None, passwords=None, timeout=5.0):
+    users = users or USERNAMES
+    passwords = passwords or PASSWORDS
+    found = []
+    stop = threading.Event()
+
+    def try_cred(user, pwd):
+        if stop.is_set():
+            return None
+        scheme = "https" if port in (443, 8443) else "http"
+        url = f"{scheme}://{host}:{port}{path}"
+        creds = base64.b64encode(f"{user}:{pwd}".encode()).decode()
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        try:
+            req = urllib.request.Request(url, headers={
+                "Authorization": f"Basic {creds}",
+                "User-Agent": "PortHawk/2.0",
+            })
+            with urllib.request.urlopen(req, timeout=timeout, context=ctx) as r:
+                if r.status == 200:
+                    return (user, pwd)
+        except urllib.error.HTTPError as e:
+            if e.code not in (401, 403):
+                return (user, pwd)
+        except Exception:
+            pass
+        return None
+
+    with ThreadPoolExecutor(max_workers=10) as ex:
+        futures = {ex.submit(try_cred, u, p): (u, p)
+                   for u in users for p in passwords}
+        for f in as_completed(futures):
+            r = f.result()
+            if r:
+                found.append(r)
+                stop.set()
+                break
+    return found
+
+
+# ─── REDIS BRUTE ────────────────────────────────────────────────────────────
+
+def redis_brute(ip, port=6379, timeout=3.0, passwords=None):
+    passwords = passwords or PASSWORDS
+    found = []
+    for pwd in passwords:
+        try:
+            with socket.create_connection((ip, port), timeout=timeout) as s:
+                cmd = f"AUTH {pwd}\r\n".encode() if pwd else b"PING\r\n"
+                s.sendall(cmd)
+                resp = s.recv(128).decode(errors="ignore")
+                if "+OK" in resp or "+PONG" in resp:
+                    found.append(("default", pwd or "no password"))
+                    return found
+        except Exception:
+            pass
+    return found
+
+
+# ─── MONGODB BRUTE ──────────────────────────────────────────────────────────
+
+def mongodb_brute(ip, port=27017, timeout=3.0):
+    try:
+        with socket.create_connection((ip, port), timeout=timeout) as s:
+            s.recv(1024)
+            return [("none", "no auth required")]
+    except Exception:
+        pass
+    return []
+
+
+# ─── RUNNER ─────────────────────────────────────────────────────────────────
+
+def run_brute_force(host, ip, open_ports,
+                    custom_users=None, custom_passwords=None):
+    findings = []
+    port_nums = {p.port: p for p in open_ports}
+
+    brute_map = {
+        21:    ("FTP",     lambda: ftp_brute(ip, 21, users=custom_users, passwords=custom_passwords)),
+        22:    ("SSH",     lambda: ssh_brute(ip, 22, users=custom_users, passwords=custom_passwords)),
+        80:    ("HTTP",    lambda: http_brute(host, 80, users=custom_users, passwords=custom_passwords)),
+        443:   ("HTTPS",   lambda: http_brute(host, 443, users=custom_users, passwords=custom_passwords)),
+        6379:  ("Redis",   lambda: redis_brute(ip, 6379, passwords=custom_passwords)),
+        27017: ("MongoDB", lambda: mongodb_brute(ip, 27017)),
+        8080:  ("HTTP",    lambda: http_brute(host, 8080, users=custom_users, passwords=custom_passwords)),
+    }
+
+    for port, (service, fn) in brute_map.items():
+        if port in port_nums:
+            print(f"      {service}:{port} ", end="", flush=True)
+            try:
+                results = fn()
+                if results:
+                    for user, pwd in results:
+                        if user in ("info", "none"):
+                            print(f"ℹ️  {pwd}")
+                        else:
+                            print(f"✅ FOUND: {user}:{pwd}")
+                            findings.append({
+                                "port": port,
+                                "service": service,
+                                "username": user,
+                                "password": pwd,
+                            })
+                else:
+                    print("No credentials found")
+            except Exception as e:
+                print(f"Error: {e}")
+
+    return findings