hb-recon 1.0.0__tar.gz

hb_recon-1.0.0/LICENSE

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

hb_recon-1.0.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: hb-recon
+Version: 1.0.0
+Summary: Automated reconnaissance tool with AI report generation. Subdomain enumeration, endpoint crawling, and vulnerability pattern detection.
+Author-email: Hlaing Bwar <infohlaingbwar@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/infohlaingbwar/hb-recon
+Project-URL: Repository, https://github.com/infohlaingbwar/hb-recon
+Project-URL: Bug Tracker, https://github.com/infohlaingbwar/hb-recon/issues
+Keywords: recon,reconnaissance,osint,bug-bounty,pentesting,subdomain,enumeration,security,ethical-hacking
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Dynamic: license-file
+
+# HB-Recon
+
+**Automated reconnaissance tool with AI-ready report generation.**
+
+Perfect for bug bounty hunters, pentesters, and security researchers.
+
+## Features
+
+✅ **Subdomain Enumeration** — subfinder integration  
+✅ **Live Host Detection** — httpx for alive checks  
+✅ **Technology Stack Scan** — WhatWeb detection  
+✅ **Endpoint Crawling** — Katana deep crawl  
+✅ **Vulnerability Patterns** — gf (XSS, SQLi, IDOR detection)  
+✅ **AI Report Generation** — Structured JSON output  
+
+## Requirements
+
+**External Tools (must be installed):**
+- [subfinder](https://github.com/projectdiscovery/subfinder)
+- [httpx](https://github.com/projectdiscovery/httpx)
+- [katana](https://github.com/projectdiscovery/katana)
+- [gf](https://github.com/tomnomnom/gf)
+- [whatweb](https://github.com/urbanadventurer/WhatWeb)
+
+**Install tools:**
+
+
+## Install
+
+Defaulting to user installation because normal site-packages is not writeable
+
+## Usage
+
+
+
+**Example:**
+
+
+**Output Structure:**
+
+
+## AI Report
+
+The tool generates  with:
+- Target info
+- Discovered subdomains & endpoints
+- Technology stack
+- Risk-scored vulnerabilities
+- Attack surface summary
+
+Perfect for feeding into AI tools like ChatGPT, Claude for analysis.
+
+## Example Workflow
+
+Defaulting to user installation because normal site-packages is not writeable
+
+## Security Notice
+
+⚠️ **Only use on authorized targets.** Unauthorized scanning is illegal.
+
+## License
+
+MIT License - See [LICENSE](LICENSE)
+
+## Author
+
+**Hlaing Bwar**  
+- GitHub: [@infohlaingbwar](https://github.com/infohlaingbwar)
+- Website: [hlaingbwar.com](https://www.hlaingbwar.com)
+
+---
+
+**Made with ❤️ for the bug bounty community**

hb_recon-1.0.0/README.md

@@ -0,0 +1,73 @@
+# HB-Recon
+
+**Automated reconnaissance tool with AI-ready report generation.**
+
+Perfect for bug bounty hunters, pentesters, and security researchers.
+
+## Features
+
+✅ **Subdomain Enumeration** — subfinder integration  
+✅ **Live Host Detection** — httpx for alive checks  
+✅ **Technology Stack Scan** — WhatWeb detection  
+✅ **Endpoint Crawling** — Katana deep crawl  
+✅ **Vulnerability Patterns** — gf (XSS, SQLi, IDOR detection)  
+✅ **AI Report Generation** — Structured JSON output  
+
+## Requirements
+
+**External Tools (must be installed):**
+- [subfinder](https://github.com/projectdiscovery/subfinder)
+- [httpx](https://github.com/projectdiscovery/httpx)
+- [katana](https://github.com/projectdiscovery/katana)
+- [gf](https://github.com/tomnomnom/gf)
+- [whatweb](https://github.com/urbanadventurer/WhatWeb)
+
+**Install tools:**
+
+
+## Install
+
+Defaulting to user installation because normal site-packages is not writeable
+
+## Usage
+
+
+
+**Example:**
+
+
+**Output Structure:**
+
+
+## AI Report
+
+The tool generates  with:
+- Target info
+- Discovered subdomains & endpoints
+- Technology stack
+- Risk-scored vulnerabilities
+- Attack surface summary
+
+Perfect for feeding into AI tools like ChatGPT, Claude for analysis.
+
+## Example Workflow
+
+Defaulting to user installation because normal site-packages is not writeable
+
+## Security Notice
+
+⚠️ **Only use on authorized targets.** Unauthorized scanning is illegal.
+
+## License
+
+MIT License - See [LICENSE](LICENSE)
+
+## Author
+
+**Hlaing Bwar**  
+- GitHub: [@infohlaingbwar](https://github.com/infohlaingbwar)
+- Website: [hlaingbwar.com](https://www.hlaingbwar.com)
+
+---
+
+**Made with ❤️ for the bug bounty community**

hb_recon-1.0.0/hb_recon/__init__.py

@@ -0,0 +1,13 @@
+"""
+HB-Recon - Automated reconnaissance tool with AI report generation
+Author: Hlaing Bwar (https://github.com/infohlaingbwar)
+"""
+
+__version__ = "1.0.0"
+__author__ = "Hlaing Bwar"
+__email__ = "infohlaingbwar@gmail.com"
+__license__ = "MIT"
+
+from .cli import main
+
+__all__ = ["main"]

hb_recon-1.0.0/hb_recon/__main__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+"""
+HB-Recon - Entry point for python -m hb_recon
+"""
+from .cli import main
+
+if __name__ == "__main__":
+    main()

hb_recon-1.0.0/hb_recon/cli.py

@@ -0,0 +1,395 @@
+import os
+import re
+import json
+import subprocess
+import time
+import concurrent.futures
+from urllib.parse import urlparse, parse_qs
+
+GO = os.path.expanduser("~/go/bin")
+
+
+# ---------------------------------------------------------------------------
+def run(cmd, step="", timeout=300, outfile=None):
+    print(f"\n[+] {step}" if step else "")
+    st = time.time()
+    try:
+        if outfile:
+            with open(outfile, "w") as f:
+                p = subprocess.Popen(cmd, shell=True, executable="/bin/bash",
+                                     stdout=f, stderr=subprocess.PIPE, text=True)
+                for ln in p.stderr:
+                    if s := ln.strip():
+                        print(f"    {s}")
+                p.wait(timeout=timeout)
+        else:
+            subprocess.run(cmd, shell=True, executable="/bin/bash",
+                           timeout=timeout)
+        print(f"[v] Done ({round(time.time()-st,1)}s)")
+    except subprocess.TimeoutExpired:
+        print(f"[x] Timeout after {timeout}s")
+
+
+# ---------------------------------------------------------------------------
+def extract_params(urls):
+    """Break URLs into endpoint + params + file_type"""
+    endpoints, params_map, file_types, post_params, js_files = [], {}, set(), {}, []
+    for u in urls:
+        u = u.strip()
+        if not u or not u.startswith("http"):
+            continue
+        parsed = urlparse(u)
+        path = parsed.path
+
+        # track JS files separately
+        if path.endswith(".js") and "/_next/" not in path:
+            js_files.append(u)
+
+        # detect file types (before filtering)
+        if "." in path:
+            ext = path.rsplit(".", 1)[-1].lower()
+            if ext in ("js","json","xml","yml","env","bak","sql","php","aspx","jsp"):
+                file_types.add(ext)
+
+        # skip static assets and CDN clutter
+        if re.search(r"/_next/|/static/|/cdn-cgi/|\.(css|png|jpg|ico|svg|woff|woff2|ttf|map|webp)$", path, re.I):
+            continue
+        base = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
+        endpoints.append(base)
+
+        # query params
+        qp = parse_qs(parsed.query)
+        for k in qp:
+            params_map.setdefault(k, []).append(u)
+
+        # detect POST params from common patterns
+        if any(w in u.lower() for w in ["login","signup","register","upload","reset","search"]):
+            post_params.setdefault("_suspected_post", []).append(u)
+
+    return {
+        "endpoints": sorted(set(endpoints)),
+        "params": {k: sorted(set(v)) for k, v in params_map.items()},
+        "file_types": sorted(file_types),
+        "suspected_post_forms": sorted(set(post_params.get("_suspected_post", []))),
+        "js_files": sorted(set(js_files))
+    }
+
+
+def categorize(endpoints):
+    """Group endpoints by type"""
+    cats = {
+        "login": [], "api": [], "admin": [], "upload": [],
+        "redirect": [], "search": [], "config": [], "other": []
+    }
+    patterns = {
+        "login":    r"(login|signin|auth|sso|oauth)",
+        "api":      r"(/api/|/graphql|/v\d+/|/rest/)",
+        "admin":    r"(admin|dashboard|panel|wp-admin|cpanel)",
+        "upload":   r"(upload|import|attachment)",
+        "redirect": r"(redirect|callback|return_to|url=|dest=|next=)",
+        "search":   r"[/?](search|find)[/?]|search\?",
+        "config":   r"(\.env|\.git|\.bak|config|debug|phpinfo)",
+    }
+    for ep in endpoints:
+        matched = False
+        for cat, pat in patterns.items():
+            if re.search(pat, ep, re.I):
+                cats[cat].append(ep)
+                matched = True
+                break
+        if not matched:
+            cats["other"].append(ep)
+    return {k: sorted(v) for k, v in cats.items() if v}
+
+
+def risk_score(ep):
+    """0-10 based on vulnerability surface"""
+    # skip static assets
+    if re.search(r"/_next/|/static/|\.(css|js|png|jpg|ico|svg|woff|woff2|ttf|map)$", ep, re.I):
+        return 0
+    score = 1
+    if any(w in ep.lower() for w in ["login","auth","admin","dashboard","api","upload"]):
+        score += 3
+    if "?" in ep:
+        score += 2
+    if any(w in ep.lower() for w in ["id=","user=","file=","page=","redirect=","url="]):
+        score += 3
+    return min(score, 10)
+
+
+# ---------------------------------------------------------------------------
+def parse_katana_output(url_file):
+    """Katana output format: URL [status] [method] ..."""
+    urls, meta = [], []
+    with open(url_file, errors="ignore") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            urls.append(line.split()[0] if " " in line else line)
+            meta.append(line)
+    return urls, meta
+
+
+# ---------------------------------------------------------------------------
+def parse_whatweb(raw):
+    """Parse whatweb output into tech stack dict"""
+    ansi = re.compile(r'\x1b\[[0-9;]*[a-zA-Z]')
+    raw_clean = ansi.sub('', raw)
+    result = {}
+    for line in raw_clean.strip().splitlines():
+        # split: URL [status] tag1, tag2[val], ...
+        if " [" not in line:
+            continue
+        # get URL and rest
+        parts = line.split(" [", 1)
+        url = parts[0].strip()
+        rest = parts[1].split("]", 1)  # first ] after status code
+        if len(rest) < 2:
+            continue
+        # rest[1] contains all the tags
+        tags_raw = rest[1].strip().rstrip(",")
+
+        # parse tags manually: split on ", " but respect brackets
+        tech = {"server": "", "cms": "", "cdn": "", "lang": "", "headers": []}
+        current = ""
+        depth = 0
+        tags = []
+        for ch in tags_raw:
+            if ch == "[":
+                depth += 1
+                current += ch
+            elif ch == "]":
+                depth -= 1
+                current += ch
+            elif ch == "," and depth == 0:
+                tags.append(current.strip())
+                current = ""
+            else:
+                current += ch
+        if current.strip():
+            tags.append(current.strip())
+
+        for tag in tags:
+            tag = tag.strip()
+            if not tag:
+                continue
+            if "[" in tag:
+                key, val = tag.split("[", 1)
+                val = val.rstrip("]")
+            else:
+                key, val = tag, ""
+
+            k = key.lower()
+            if "httpserver" in k:
+                tech["server"] = val
+            elif "x-powered-by" in k:
+                tech["cms"] = val
+            elif k in ("cloudflare", "cloudfront"):
+                tech["cdn"] = key
+            elif k in ("next.js", "php", "asp_net", "laravel", "django", "ruby"):
+                tech["lang"] = val or key
+            elif any(h in k for h in ("x-", "strict-transport", "content-security")):
+                tech["headers"].append(key)
+
+        result[url] = {k: v for k, v in tech.items() if v}
+        if "server" not in result[url] and "cms" not in result[url]:
+            result[url]["server"] = "unknown"
+    return result
+
+
+def scan_tech(alive_file, outdir):
+    """Use whatweb to detect tech stack"""
+    if not os.path.exists(alive_file):
+        return {}
+    hosts = [l.strip() for l in open(alive_file) if l.strip().startswith("http")]
+    if not hosts:
+        return {}
+    print("\n[*] WhatWeb (tech detection)...")
+    outfile = f"{outdir}/whatweb.txt"
+    cmd = f"whatweb --color=never --no-errors {' '.join(hosts)} > {outfile}"
+    run(cmd, f"WhatWeb ({len(hosts)} hosts)")
+    if os.path.exists(outfile):
+        return parse_whatweb(open(outfile).read())
+    return {}
+
+
+# ---------------------------------------------------------------------------
+def build_ai_report(target, d):
+    report = {"target": target, "scan_date": time.strftime("%Y-%m-%d %H:%M")}
+
+    # --- subdomains + alive ---
+    subs = open(f"{d}/subdomains.txt","r").read().splitlines() if os.path.exists(f"{d}/subdomains.txt") else []
+    alive = []
+    if os.path.exists(f"{d}/alive.txt"):
+        for ln in open(f"{d}/alive.txt"):
+            ln = ln.strip()
+            if ln.startswith("http"):
+                alive.append({"url": ln, "status": "alive"})
+
+    # --- katana output ---
+    raw_urls, _ = parse_katana_output(f"{d}/urls.txt") if os.path.exists(f"{d}/urls.txt") else ([], [])
+    ep_info = extract_params(raw_urls)
+    cat = categorize(ep_info["endpoints"])
+
+    # risk scoring
+    risky = sorted([e for e in ep_info["endpoints"] if risk_score(e) > 0],
+                    key=lambda x: -risk_score(x))[:20]
+
+    # --- whatweb tech stack ---
+    tech_stack = scan_tech(f"{d}/alive.txt", d)
+
+    # --- gf patterns ---
+    gf_data = {}
+    for name in ["xss","sqli","idor"]:
+        fp = f"{d}/{name}.txt"
+        if os.path.exists(fp):
+            gf_data[name] = [l.strip() for l in open(fp) if l.strip()][:30]
+
+    # --- assemble ---
+    report["summary"] = {
+        "subdomains": len(subs),
+        "alive_hosts": len(alive),
+        "endpoints": len(ep_info["endpoints"]),
+        "params_with_input": list(ep_info["params"].keys()),
+        "file_types": ep_info["file_types"],
+        "tech_detected": {u: t.get("cms") or t.get("cdn") or t.get("server") or "unknown" for u, t in tech_stack.items()},
+        "gf_matches": {k: len(v) for k, v in gf_data.items()},
+    }
+
+    report["subdomains"] = subs
+    report["alive_hosts"] = alive
+
+    report["attack_surface"] = {
+        "tech_stack": tech_stack,
+        "by_category": cat,
+        "top_risky_endpoints": [{"url": u, "score": risk_score(u)} for u in risky],
+        "query_params": ep_info["params"],
+        "suspected_post_forms": ep_info["suspected_post_forms"],
+        "interesting_files": ep_info["file_types"],
+        "js_files": ep_info["js_files"][:30],
+    }
+
+    report["vulnerabilities"] = {
+        "gf_pattern_matches": gf_data,
+    }
+
+    report["suggestions"] = generate_suggestions(report, target)
+
+    with open(f"{d}/ai_ready.json", "w") as f:
+        json.dump(report, f, indent=2, ensure_ascii=False)
+
+    print(f"\n[+] AI Report saved: {d}/ai_ready.json")
+    print_summary(report)
+
+
+def generate_suggestions(r, t):
+    s = []
+    ps = r["attack_surface"]["query_params"]
+    cat = r["attack_surface"]["by_category"]
+
+    if cat.get("login"):
+        s.append("Brute-force / default creds on login endpoints")
+    if cat.get("api"):
+        s.append("Test API endpoints for auth bypass, IDOR, rate-limit")
+    if cat.get("upload"):
+        s.append("Test file upload for RCE, XSS, unrestricted upload")
+    if cat.get("redirect"):
+        s.append("Check for open redirect via redirect parameters")
+    if cat.get("search"):
+        s.append("Test search endpoints for reflected XSS")
+    if cat.get("admin"):
+        s.append("Check admin access controls, try /admin, /wp-admin")
+    if any(k in ps for k in ["id","user","uid","order","pid"]):
+        s.append("IDOR: try incrementing/decrementing id parameters")
+    if any(k in ps for k in ["q","s","query","search","keyword"]):
+        s.append("XSS: inject <script>alert(1)</script> in search/query params")
+    if any(k in ps for k in ["redirect","url","return","next","dest"]):
+        s.append("Open redirect: try //evil.com in redirect params")
+    if any(k in ps for k in ["file","path","include","template"]):
+        s.append("LFI/Path Traversal: try ../../etc/passwd in file params")
+    if r["attack_surface"]["js_files"]:
+        s.append("Check JS files for hidden endpoints, API keys, secrets")
+    if "bak" in r["attack_surface"]["interesting_files"] or ".env" in str(r["attack_surface"]):
+        s.append("Check backup/config files for exposed credentials")
+    if any(w in str(r["subdomains"]).lower() for w in ["dev","staging","test","beta","uat"]):
+        s.append("Dev/Staging environments often have weaker security")
+
+    # tech-specific suggestions
+    ts = r["attack_surface"]["tech_stack"]
+    for host, info in ts.items():
+        cms = info.get("cms","").lower()
+        svr = info.get("server","").lower()
+        if "next.js" in cms or "next.js" in info.get("lang","").lower():
+            s.append(f"{host}: Next.js — check /api/, /_next/, source maps, SSR params")
+        if "wordpress" in cms:
+            s.append(f"{host}: WordPress — check /wp-json/, /wp-admin/, xmlrpc.php")
+        if "php" in cms or "php" in svr or "php" in info.get("lang",""):
+            s.append(f"{host}: PHP detected — test for LFI, PHPInfo, file upload bypass")
+
+    return s if s else ["Analyze all endpoints for common OWASP Top 10 vulnerabilities"]
+
+
+def print_summary(r):
+    s = r["summary"]
+    print("\n" + "=" * 55)
+    print(f"  Target: {r['target']}")
+    print(f"  Subdomains: {s['subdomains']} | Alive: {s['alive_hosts']} | Endpoints: {s['endpoints']}")
+    print(f"  Params: {s['params_with_input']}")
+    print(f"  File types: {s['file_types']}")
+    print(f"  Tech: {s.get('tech_detected', {})}")
+    print(f"  GF matches: {s['gf_matches']}")
+    print(f"  Suggestions: {len(r['suggestions'])} tips")
+    print("=" * 55)
+
+
+# ---------------------------------------------------------------------------
+def main():
+    print("=" * 55)
+    print("  Auto Recon -> AI Ready")
+    print("=" * 55)
+
+    target = input("\n[>] Domain: ").strip()
+    if not target:
+        return
+
+    # clean input: strip https://, http://, trailing /
+    target = re.sub(r'^https?://', '', target).rstrip('/')
+
+    d = f"recon_{target}"
+    os.makedirs(d, exist_ok=True)
+    start = time.time()
+
+    # Phase 1 — subfinder + httpx
+    run(
+        f"{GO}/subfinder -d {target} -s hackertarget,waybackarchive -silent | "
+        f"tee {d}/subdomains.txt | "
+        f"httpx-toolkit -mc 200,301,403 -silent > {d}/alive.txt",
+        "Subfinder + Httpx"
+    )
+
+    # Phase 2 — whatweb + katana (parallel)
+    print("\n[*] WhatWeb + Katana (parallel)...")
+    # whatweb is already called inside build_ai_report via scan_tech()
+    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as ex:
+        f1 = ex.submit(run, f"{GO}/katana -list {d}/alive.txt -d 3 -c 15 -silent > {d}/urls.txt",
+                       "Katana (crawl)")
+        concurrent.futures.wait([f1])
+
+    # Phase 3 — gf patterns
+    if os.path.exists(f"{d}/urls.txt"):
+        run(
+            f"cat {d}/urls.txt | {GO}/gf xss > {d}/xss.txt && "
+            f"cat {d}/urls.txt | {GO}/gf sqli > {d}/sqli.txt && "
+            f"cat {d}/urls.txt | {GO}/gf idor > {d}/idor.txt",
+            "gf (XSS/SQLi/IDOR patterns)"
+        )
+
+    # Phase 4 — build AI report
+    build_ai_report(target, d)
+
+    print(f"\n[√] Total: {round(time.time()-start,1)}s")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: hb-recon
+Version: 1.0.0
+Summary: Automated reconnaissance tool with AI report generation. Subdomain enumeration, endpoint crawling, and vulnerability pattern detection.
+Author-email: Hlaing Bwar <infohlaingbwar@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/infohlaingbwar/hb-recon
+Project-URL: Repository, https://github.com/infohlaingbwar/hb-recon
+Project-URL: Bug Tracker, https://github.com/infohlaingbwar/hb-recon/issues
+Keywords: recon,reconnaissance,osint,bug-bounty,pentesting,subdomain,enumeration,security,ethical-hacking
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Dynamic: license-file
+
+# HB-Recon
+
+**Automated reconnaissance tool with AI-ready report generation.**
+
+Perfect for bug bounty hunters, pentesters, and security researchers.
+
+## Features
+
+✅ **Subdomain Enumeration** — subfinder integration  
+✅ **Live Host Detection** — httpx for alive checks  
+✅ **Technology Stack Scan** — WhatWeb detection  
+✅ **Endpoint Crawling** — Katana deep crawl  
+✅ **Vulnerability Patterns** — gf (XSS, SQLi, IDOR detection)  
+✅ **AI Report Generation** — Structured JSON output  
+
+## Requirements
+
+**External Tools (must be installed):**
+- [subfinder](https://github.com/projectdiscovery/subfinder)
+- [httpx](https://github.com/projectdiscovery/httpx)
+- [katana](https://github.com/projectdiscovery/katana)
+- [gf](https://github.com/tomnomnom/gf)
+- [whatweb](https://github.com/urbanadventurer/WhatWeb)
+
+**Install tools:**
+
+
+## Install
+
+Defaulting to user installation because normal site-packages is not writeable
+
+## Usage
+
+
+
+**Example:**
+
+
+**Output Structure:**
+
+
+## AI Report
+
+The tool generates  with:
+- Target info
+- Discovered subdomains & endpoints
+- Technology stack
+- Risk-scored vulnerabilities
+- Attack surface summary
+
+Perfect for feeding into AI tools like ChatGPT, Claude for analysis.
+
+## Example Workflow
+
+Defaulting to user installation because normal site-packages is not writeable
+
+## Security Notice
+
+⚠️ **Only use on authorized targets.** Unauthorized scanning is illegal.
+
+## License
+
+MIT License - See [LICENSE](LICENSE)
+
+## Author
+
+**Hlaing Bwar**  
+- GitHub: [@infohlaingbwar](https://github.com/infohlaingbwar)
+- Website: [hlaingbwar.com](https://www.hlaingbwar.com)
+
+---
+
+**Made with ❤️ for the bug bounty community**

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

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+hb_recon/__init__.py
+hb_recon/__main__.py
+hb_recon/cli.py
+hb_recon.egg-info/PKG-INFO
+hb_recon.egg-info/SOURCES.txt
+hb_recon.egg-info/dependency_links.txt
+hb_recon.egg-info/entry_points.txt
+hb_recon.egg-info/requires.txt
+hb_recon.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+hb-recon = hb_recon.cli:main

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

@@ -0,0 +1,4 @@
+
+[dev]
+pytest>=7.0
+black>=22.0

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

@@ -0,0 +1 @@
+hb_recon

hb_recon-1.0.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hb-recon"
+version = "1.0.0"
+description = "Automated reconnaissance tool with AI report generation. Subdomain enumeration, endpoint crawling, and vulnerability pattern detection."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Hlaing Bwar", email = "infohlaingbwar@gmail.com"}
+]
+keywords = ["recon", "reconnaissance", "osint", "bug-bounty", "pentesting", "subdomain", "enumeration", "security", "ethical-hacking"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+]
+
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "black>=22.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/infohlaingbwar/hb-recon"
+Repository = "https://github.com/infohlaingbwar/hb-recon"
+"Bug Tracker" = "https://github.com/infohlaingbwar/hb-recon/issues"
+
+[project.scripts]
+hb-recon = "hb_recon.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["hb_recon*"]
+exclude = ["tests*", "docs*"]

hb_recon-1.0.0/setup.cfg

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