nmaping 1.8__tar.gz → 2.0__tar.gz

nmaping-2.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: nmaping
+Version: 2.0
+Summary: An automation and network scanning utility tool.
+Author-email: "Mr. Tan" <mrtanvai@gmail.com>
+License: Custom License
+Project-URL: Homepage, https://github.com/Mr74nX/nmaping
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+
+# 🚀 Nmaping - Python Nmap Automation Tool
+
+A powerful, safe-by-default **Nmap scanning toolkit** built with Python for network reconnaissance, port scanning, and security auditing.
+
+Developed by **Mr Tan**, this tool wraps complex Nmap commands into a simple, interactive, colorful CLI — built for ethical hackers, penetration testers, and cybersecurity learners working on systems they own or are authorized to test.
+
+---
+
+## ⚡ Key Features
+
+- 🧠 **20+ Automated Nmap Scan Modes** — SYN, TCP connect, version, OS, vuln, firewall, Xmas, FIN, Null, and more
+- ⚡ **Timing Control** (`-T0` to `-T5`) for stealth vs. speed
+- 🚀 **Parallel Batch Scanning** — scan multiple targets concurrently (up to 10 workers) with `--min-rate` tuning for speed
+- 🗂️ **Scan History Log** — every scan is recorded (target, type, timestamp, output file) for later review
+- 🔁 **Scan Comparison / Diff** — compare two saved scans to see exactly what changed between runs
+- 🧩 **Custom NSE Script Runner** — run any Nmap script by name (e.g. `http-title`, `ssl-cert`) with input validation
+- 🌐 **CIDR Subnet Discovery** — quick host-discovery sweep across a whole subnet
+- 🧠 **Smart Result Caching** — warns before re-scanning a target scanned in the last 30 minutes
+- 🔐 **Authorization Gate** — requires explicit confirmation of ownership/permission before every scan
+- 🛡️ **Hardened Execution** — targets and ports are validated and scans run via `subprocess` (no shell injection risk)
+- 🎨 Interactive colorful CLI interface
+- 🔄 Auto Update Checker (GitHub Sync)
+- 🌐 Cross-platform (Linux & Windows)
+
+---
+
+## 🔍 Supported Scan Types
+
+- SYN Scan
+- TCP Connect Scan
+- Version Detection
+- OS Detection
+- Aggressive Scan
+- Vulnerability Scan (`--script vuln`)
+- Custom NSE Script Scan
+- Firewall Detection / ACK Scan
+- Xmas / FIN / Null Scans
+- Ping / No-Ping Scans
+- Traceroute
+- Top 1000 Ports / All Ports / Specific Port / UDP Ports
+- Batch Scan (multiple targets, parallel)
+- CIDR Subnet Host Discovery
+- Full Combined Scan
+
+---
+
+## ⏱️ Timing Levels
+
+| Mode | Flag | Description |
+|------|------|-------------|
+| Paranoid | `-T0` | Maximum stealth |
+| Sneaky | `-T1` | Low detection risk |
+| Polite | `-T2` | Light usage |
+| Normal | `-T3` | Default mode |
+| Aggressive | `-T4` | Fast scanning |
+| Insane | `-T5` | Very fast (lab only) |
+
+---
+
+## ⚙️ Requirements
+
+- Python 3.8+
+- [Nmap](https://nmap.org/download.html) installed and available on your system `PATH`
+- `requests` (for update checks)
+
+```bash
+pip install nmaping
+```
+
+---
+
+## 🖥️ Usage
+
+```bash
+python3 -m nmaping
+```
+
+Follow the on-screen menu to pick a scan type, enter your target, confirm authorization, and choose a timing template. Results are saved automatically to `scan_results/`.
+
+---
+
+## ⚠️ Legal & Ethical Use
+
+This tool is intended **strictly for authorized security testing** — scanning systems you own, or systems you have **explicit written permission** to test (e.g. a client engagement, CTF, or personal lab). Unauthorized scanning of networks or systems you don't control may violate computer-crime laws (such as the U.S. CFAA, UK Computer Misuse Act, or equivalent local laws) even when no exploit is used.
+
+Nmaping includes a built-in authorization confirmation step before every scan, but that step relies on the user acting in good faith. **You are solely responsible for ensuring you have permission before scanning any target.**
+
+---
+
+## 📜 License
+
+Educational and ethical use only. See `LICENSE` for details.

nmaping-2.0/README.md

@@ -0,0 +1,92 @@
+# 🚀 Nmaping - Python Nmap Automation Tool
+
+A powerful, safe-by-default **Nmap scanning toolkit** built with Python for network reconnaissance, port scanning, and security auditing.
+
+Developed by **Mr Tan**, this tool wraps complex Nmap commands into a simple, interactive, colorful CLI — built for ethical hackers, penetration testers, and cybersecurity learners working on systems they own or are authorized to test.
+
+---
+
+## ⚡ Key Features
+
+- 🧠 **20+ Automated Nmap Scan Modes** — SYN, TCP connect, version, OS, vuln, firewall, Xmas, FIN, Null, and more
+- ⚡ **Timing Control** (`-T0` to `-T5`) for stealth vs. speed
+- 🚀 **Parallel Batch Scanning** — scan multiple targets concurrently (up to 10 workers) with `--min-rate` tuning for speed
+- 🗂️ **Scan History Log** — every scan is recorded (target, type, timestamp, output file) for later review
+- 🔁 **Scan Comparison / Diff** — compare two saved scans to see exactly what changed between runs
+- 🧩 **Custom NSE Script Runner** — run any Nmap script by name (e.g. `http-title`, `ssl-cert`) with input validation
+- 🌐 **CIDR Subnet Discovery** — quick host-discovery sweep across a whole subnet
+- 🧠 **Smart Result Caching** — warns before re-scanning a target scanned in the last 30 minutes
+- 🔐 **Authorization Gate** — requires explicit confirmation of ownership/permission before every scan
+- 🛡️ **Hardened Execution** — targets and ports are validated and scans run via `subprocess` (no shell injection risk)
+- 🎨 Interactive colorful CLI interface
+- 🔄 Auto Update Checker (GitHub Sync)
+- 🌐 Cross-platform (Linux & Windows)
+
+---
+
+## 🔍 Supported Scan Types
+
+- SYN Scan
+- TCP Connect Scan
+- Version Detection
+- OS Detection
+- Aggressive Scan
+- Vulnerability Scan (`--script vuln`)
+- Custom NSE Script Scan
+- Firewall Detection / ACK Scan
+- Xmas / FIN / Null Scans
+- Ping / No-Ping Scans
+- Traceroute
+- Top 1000 Ports / All Ports / Specific Port / UDP Ports
+- Batch Scan (multiple targets, parallel)
+- CIDR Subnet Host Discovery
+- Full Combined Scan
+
+---
+
+## ⏱️ Timing Levels
+
+| Mode | Flag | Description |
+|------|------|-------------|
+| Paranoid | `-T0` | Maximum stealth |
+| Sneaky | `-T1` | Low detection risk |
+| Polite | `-T2` | Light usage |
+| Normal | `-T3` | Default mode |
+| Aggressive | `-T4` | Fast scanning |
+| Insane | `-T5` | Very fast (lab only) |
+
+---
+
+## ⚙️ Requirements
+
+- Python 3.8+
+- [Nmap](https://nmap.org/download.html) installed and available on your system `PATH`
+- `requests` (for update checks)
+
+```bash
+pip install nmaping
+```
+
+---
+
+## 🖥️ Usage
+
+```bash
+python3 -m nmaping
+```
+
+Follow the on-screen menu to pick a scan type, enter your target, confirm authorization, and choose a timing template. Results are saved automatically to `scan_results/`.
+
+---
+
+## ⚠️ Legal & Ethical Use
+
+This tool is intended **strictly for authorized security testing** — scanning systems you own, or systems you have **explicit written permission** to test (e.g. a client engagement, CTF, or personal lab). Unauthorized scanning of networks or systems you don't control may violate computer-crime laws (such as the U.S. CFAA, UK Computer Misuse Act, or equivalent local laws) even when no exploit is used.
+
+Nmaping includes a built-in authorization confirmation step before every scan, but that step relies on the user acting in good faith. **You are solely responsible for ensuring you have permission before scanning any target.**
+
+---
+
+## 📜 License
+
+Educational and ethical use only. See `LICENSE` for details.

nmaping-2.0/nmaping/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "2.0"
+
+from .nmap import main
+
+__all__ = ["main"]

nmaping-2.0/nmaping/nmap.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+# NmapEasy - Powerful Nmap wrapper toolkit
+# Author: Mr Tan | https://github.com/Mr74nX
+
+import os
+import re
+import sys
+import time
+import shutil
+import platform
+import argparse
+import subprocess
+from datetime import datetime
+
+try:
+    import requests
+except ImportError:
+    requests = None
+
+# ------------------------- Colors -------------------------
+red = "\x1b[38;5;196m"
+green = "\033[38;5;156m"
+blue = "\033[38;5;75m"
+white = "\033[38;5;231m"
+orange = "\033[38;5;208m"
+cyan = "\033[1;36m"
+reset = "\033[0m"
+
+# ------------------------- Paths -------------------------
+BASE_DIR = os.path.join(os.path.expanduser("~"), ".nmapeasy")
+RESULTS_DIR = os.path.join(BASE_DIR, "results")
+HISTORY_FILE = os.path.join(BASE_DIR, "history.log")
+
+os.makedirs(RESULTS_DIR, exist_ok=True)
+
+# ------------------------- Version -------------------------
+def get_version():
+    if requests is None:
+        return "1.0"
+    try:
+        return requests.get(
+            "https://raw.githubusercontent.com/Mr74nX/Nmap-scaning/main/version.txt",
+            timeout=5,
+        ).text.strip()
+    except Exception:
+        return "1.0"
+
+version = get_version()
+
+def clear():
+    os.system("cls" if platform.system() == "Windows" else "clear")
+
+author_data = f"{orange}Author{white}: {green}Mr Tan\n{orange}GitHub{white}: {blue}https://github.com/Mr74nX"
+logo = f"""{red}
+ ███▄    █  ███▄ ▄███▓ ▄▄▄       ██▓███  
+ ██ ▀█   █ ▓██▒▀█▀ ██▒▒████▄    ▓██░  ██▒
+▓██  ▀█ ██▒▓██    ▓██░▒██  ▀█▄  ▓██░ ██▓▒
+▓██▒  ▐▌██▒▒██    ▒██ ░██▄▄▄▄██ ▒██▄█▓▒ ▒
+▒██░   ▓██░▒██▒   ░██▒ ▓█   ▓██▒▒██▒ ░  ░
+░ ▒░   ▒ ▒ ░ ▒░   ░  ░ ▒▒   ▓▒█░▒▓▒░ ░  ░
+░ ░░   ░ ▒░░  ░      ░  ▒   ▒▒ ░░▒ ░      
+   ░   ░ ░ ░      ░     ░   ▒   ░░        
+          ░        ░        ░  ░          
+                                     {cyan}v{white}={orange}{version}
+{author_data}
+
+"""
+
+# ------------------------- Validation -------------------------
+IP_RE = re.compile(r"^(\d{1,3}\.){3}\d{1,3}(/\d{1,2})?$")
+HOSTNAME_RE = re.compile(r"^[a-zA-Z0-9]([a-zA-Z0-9\-\.]{0,253})[a-zA-Z0-9]$")
+
+def validate_target(target: str) -> bool:
+    target = target.strip()
+    if not target:
+        return False
+    if IP_RE.match(target):
+        parts = target.split("/")[0].split(".")
+        return all(0 <= int(p) <= 255 for p in parts)
+    return bool(HOSTNAME_RE.match(target)) or target == "localhost"
+
+def prompt_target() -> str:
+    while True:
+        target = input(f"{orange}=>{green} Enter the target IP or domain{white}:{blue} ").strip()
+        if validate_target(target):
+            return target
+        print(f"{red}=> Invalid target. Try again (e.g. 192.168.1.1 or example.com)")
+
+def check_nmap_installed() -> bool:
+    return shutil.which("nmap") is not None
+
+def authorization_gate(target: str) -> bool:
+    print(f"\n{orange}=>{red} LEGAL WARNING{white}: Only scan systems you own or have explicit permission to test.")
+    ans = input(f"{orange}=>{green} Confirm you are authorized to scan {blue}{target}{green} (y/n){white}: ").strip().lower()
+    return ans == "y"
+
+# ------------------------- History / Output -------------------------
+def log_history(target: str, scan_name: str, cmd: str, duration: float):
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with open(HISTORY_FILE, "a", encoding="utf-8") as f:
+        f.write(f"[{ts}] target={target} scan={scan_name} duration={duration:.1f}s cmd={cmd}\n")
+
+def output_path(target: str, scan_name: str) -> str:
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_target = re.sub(r"[^a-zA-Z0-9_.-]", "_", target)
+    safe_scan = re.sub(r"[^a-zA-Z0-9_.-]", "_", scan_name)
+    return os.path.join(RESULTS_DIR, f"{safe_target}_{safe_scan}_{ts}.txt")
+
+def get_timing_template() -> str:
+    print(f"\n{orange}==={green} Select Nmap Timing Template {orange}===")
+    print(f"{orange}0{white}.{green} Paranoid    {red}({orange}0 {white}-{green} Very Slow, bypass IDS{red}){white}")
+    print(f"{orange}1{white}.{green} Sneaky      {red}({orange}1 {white}- {green}Slow{red}){white}")
+    print(f"{orange}2{white}.{green} Polite      {red}({orange}2 {white}- {green}Moderate{red}){white}")
+    print(f"{orange}3{white}.{green} Normal      {red}({orange}3 {white}- {green}Default Speed{red}){white}")
+    print(f"{orange}4{white}.{green} Aggressive  {red}({orange}4 {white}- {green}Fast & Recommended{red}){white}")
+    print(f"{orange}5{white}.{green} Insane      {red}({orange}5 {white}- {green}Extremely Fast{red}){white}")
+    t_choice = input(f"\n{orange}=>{green} Choose Speed {red}({green}0-5, Default is 3{red}){white}:{green} ").strip()
+    return f"-T{t_choice}" if t_choice in "012345" else "-T3"
+
+# ------------------------- Scan Profiles -------------------------
+# name : nmap args template ({port} substituted if present)
+SCAN_PROFILES = {
+    "1":  ("SYN Scan",             "-sS"),
+    "2":  ("Version Detection",    "-sV"),
+    "3":  ("Vulnerability Scan",   "--script vuln"),
+    "4":  ("OS Detection",         "-O"),
+    "5":  ("No Port (Host Discovery)", "-sn"),
+    "6":  ("Specific Port",        "-p {port}"),
+    "7":  ("Top 1000 Ports",       "--top-ports 1000"),
+    "8":  ("UDP Scan",             "-sU"),
+    "9":  ("Aggressive Scan",      "-A"),
+    "10": ("Firewall/ACK Detection", "-sA"),
+    "11": ("Default Script Scan",  "-sC"),
+    "12": ("Traceroute",           "--traceroute"),
+    "13": ("All Ports",            "-p-"),
+    "14": ("Ping Scan",            "-sP"),
+    "15": ("No Ping Scan",         "-Pn"),
+    "16": ("TCP Connect",          "-sT"),
+    "17": ("Xmas Scan",            "-sX"),
+    "18": ("FIN Scan",             "-sF"),
+    "19": ("Null Scan",            "-sN"),
+    "20": ("Custom (enter your own flags)", None),
+    "21": ("Full Deep Scan (slow, everything)",
+           "-A -sS -sV --script vuln -O --top-ports 1000 -sU -sC --traceroute -p-"),
+}
+
+# ------------------------- Core Runner -------------------------
+def run_scan(target: str, scan_id: str, timing: str, save: bool = True):
+    name, args_template = SCAN_PROFILES[scan_id]
+
+    if args_template is None:
+        args_template = input(f"{orange}=>{green} Enter custom nmap flags{white}: ").strip()
+
+    if "{port}" in args_template:
+        port = input(f"{orange}=>{green} Enter the port number/range{white}:{blue} ").strip()
+        args_template = args_template.format(port=port)
+
+    cmd = f"nmap {args_template} {timing} {target}"
+    print(f"\n{orange}=>{green} Running {blue}{name}{green} on {blue}{target}{green} | {orange}{timing}{white}")
+    print(f"{orange}=>{white} {cmd}\n")
+
+    start = time.time()
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        output = result.stdout + result.stderr
+    except Exception as e:
+        output = f"Error running scan: {e}"
+    duration = time.time() - start
+
+    print(output)
+    print(f"{orange}=>{green} Done in {orange}{duration:.1f}s{white}")
+
+    log_history(target, name, cmd, duration)
+
+    if save:
+        path = output_path(target, name)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(f"Command: {cmd}\nDuration: {duration:.1f}s\n\n{output}")
+        print(f"{orange}=>{green} Saved to {blue}{path}{white}")
+
+def show_history(limit: int = 15):
+    clear()
+    print(logo)
+    if not os.path.exists(HISTORY_FILE):
+        print(f"{red}=> No scan history yet.")
+    else:
+        with open(HISTORY_FILE, encoding="utf-8") as f:
+            lines = f.readlines()[-limit:]
+        for line in lines:
+            print(f"{green}{line.strip()}{white}")
+    input(f"\n{orange}=>{green} Press Enter to menu...")
+
+# ------------------------- Interactive Menu -------------------------
+def print_menu():
+    clear()
+    print(logo)
+    print(f"{orange}=> {green}Welcome to NmapEasy")
+    for key in [str(i) for i in range(1, 22)]:
+        name = SCAN_PROFILES[key][0]
+        print(f"{orange}{key}{white}.{green} {name}")
+    print(f"{orange}H{white}.{green} View Scan History")
+    print(f"{orange}0{white}.{green} Exit")
+
+def menu():
+    if not check_nmap_installed():
+        print(f"{red}=> Nmap is not installed or not in PATH. Install it first (e.g. apt install nmap).")
+        sys.exit(1)
+
+    while True:
+        print_menu()
+        choice = input(f"{orange}=>{green} Enter your choice{white}:{green} ").strip().upper()
+
+        if choice == "0":
+            print(f"{red}Exiting...")
+            sys.exit()
+        elif choice == "H":
+            show_history()
+            continue
+        elif choice in SCAN_PROFILES:
+            clear()
+            print(logo)
+            target = prompt_target()
+            if not authorization_gate(target):
+                print(f"{red}=> Authorization not confirmed. Aborting scan.")
+                time.sleep(2)
+                continue
+            timing = get_timing_template()
+            run_scan(target, choice, timing)
+            input(f"\n{orange}=>{green} Press Enter to menu...")
+        else:
+            print(f"{red}Invalid choice. Please try again.")
+            time.sleep(1.5)
+
+# ------------------------- CLI Mode -------------------------
+def cli_main():
+    parser = argparse.ArgumentParser(description="NmapEasy - Powerful Nmap wrapper toolkit")
+    parser.add_argument("-t", "--target", help="Target IP or domain")
+    parser.add_argument("-s", "--scan", help="Scan profile ID (see --list)")
+    parser.add_argument("-T", "--timing", default="-T3", help="Timing template, e.g. -T4 (default -T3)")
+    parser.add_argument("-p", "--port", help="Port(s) for scan profile 6")
+    parser.add_argument("--no-save", action="store_true", help="Don't save output to a file")
+    parser.add_argument("--list", action="store_true", help="List all scan profiles and exit")
+    parser.add_argument("-y", "--yes", action="store_true", help="Skip authorization confirmation prompt")
+    args = parser.parse_args()
+
+    if args.list:
+        print(logo)
+        for key, (name, _) in SCAN_PROFILES.items():
+            print(f"{orange}{key}{white}: {green}{name}")
+        return
+
+    if not args.target or not args.scan:
+        menu()
+        return
+
+    if not check_nmap_installed():
+        print(f"{red}=> Nmap is not installed or not in PATH.")
+        sys.exit(1)
+
+    if not validate_target(args.target):
+        print(f"{red}=> Invalid target.")
+        sys.exit(1)
+
+    if args.scan not in SCAN_PROFILES:
+        print(f"{red}=> Unknown scan profile. Use --list to see options.")
+        sys.exit(1)
+
+    if not args.yes and not authorization_gate(args.target):
+        print(f"{red}=> Authorization not confirmed. Aborting.")
+        sys.exit(1)
+
+    name, template = SCAN_PROFILES[args.scan]
+    if template and "{port}" in template:
+        if not args.port:
+            print(f"{red}=> This profile needs --port.")
+            sys.exit(1)
+        SCAN_PROFILES[args.scan] = (name, template.format(port=args.port))
+
+    run_scan(args.target, args.scan, args.timing, save=not args.no_save)
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        cli_main()
+    else:
+        menu()

nmaping-2.0/nmaping.egg-info/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: nmaping
+Version: 2.0
+Summary: An automation and network scanning utility tool.
+Author-email: "Mr. Tan" <mrtanvai@gmail.com>
+License: Custom License
+Project-URL: Homepage, https://github.com/Mr74nX/nmaping
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+
+# 🚀 Nmaping - Python Nmap Automation Tool
+
+A powerful, safe-by-default **Nmap scanning toolkit** built with Python for network reconnaissance, port scanning, and security auditing.
+
+Developed by **Mr Tan**, this tool wraps complex Nmap commands into a simple, interactive, colorful CLI — built for ethical hackers, penetration testers, and cybersecurity learners working on systems they own or are authorized to test.
+
+---
+
+## ⚡ Key Features
+
+- 🧠 **20+ Automated Nmap Scan Modes** — SYN, TCP connect, version, OS, vuln, firewall, Xmas, FIN, Null, and more
+- ⚡ **Timing Control** (`-T0` to `-T5`) for stealth vs. speed
+- 🚀 **Parallel Batch Scanning** — scan multiple targets concurrently (up to 10 workers) with `--min-rate` tuning for speed
+- 🗂️ **Scan History Log** — every scan is recorded (target, type, timestamp, output file) for later review
+- 🔁 **Scan Comparison / Diff** — compare two saved scans to see exactly what changed between runs
+- 🧩 **Custom NSE Script Runner** — run any Nmap script by name (e.g. `http-title`, `ssl-cert`) with input validation
+- 🌐 **CIDR Subnet Discovery** — quick host-discovery sweep across a whole subnet
+- 🧠 **Smart Result Caching** — warns before re-scanning a target scanned in the last 30 minutes
+- 🔐 **Authorization Gate** — requires explicit confirmation of ownership/permission before every scan
+- 🛡️ **Hardened Execution** — targets and ports are validated and scans run via `subprocess` (no shell injection risk)
+- 🎨 Interactive colorful CLI interface
+- 🔄 Auto Update Checker (GitHub Sync)
+- 🌐 Cross-platform (Linux & Windows)
+
+---
+
+## 🔍 Supported Scan Types
+
+- SYN Scan
+- TCP Connect Scan
+- Version Detection
+- OS Detection
+- Aggressive Scan
+- Vulnerability Scan (`--script vuln`)
+- Custom NSE Script Scan
+- Firewall Detection / ACK Scan
+- Xmas / FIN / Null Scans
+- Ping / No-Ping Scans
+- Traceroute
+- Top 1000 Ports / All Ports / Specific Port / UDP Ports
+- Batch Scan (multiple targets, parallel)
+- CIDR Subnet Host Discovery
+- Full Combined Scan
+
+---
+
+## ⏱️ Timing Levels
+
+| Mode | Flag | Description |
+|------|------|-------------|
+| Paranoid | `-T0` | Maximum stealth |
+| Sneaky | `-T1` | Low detection risk |
+| Polite | `-T2` | Light usage |
+| Normal | `-T3` | Default mode |
+| Aggressive | `-T4` | Fast scanning |
+| Insane | `-T5` | Very fast (lab only) |
+
+---
+
+## ⚙️ Requirements
+
+- Python 3.8+
+- [Nmap](https://nmap.org/download.html) installed and available on your system `PATH`
+- `requests` (for update checks)
+
+```bash
+pip install nmaping
+```
+
+---
+
+## 🖥️ Usage
+
+```bash
+python3 -m nmaping
+```
+
+Follow the on-screen menu to pick a scan type, enter your target, confirm authorization, and choose a timing template. Results are saved automatically to `scan_results/`.
+
+---
+
+## ⚠️ Legal & Ethical Use
+
+This tool is intended **strictly for authorized security testing** — scanning systems you own, or systems you have **explicit written permission** to test (e.g. a client engagement, CTF, or personal lab). Unauthorized scanning of networks or systems you don't control may violate computer-crime laws (such as the U.S. CFAA, UK Computer Misuse Act, or equivalent local laws) even when no exploit is used.
+
+Nmaping includes a built-in authorization confirmation step before every scan, but that step relies on the user acting in good faith. **You are solely responsible for ensuring you have permission before scanning any target.**
+
+---
+
+## 📜 License
+
+Educational and ethical use only. See `LICENSE` for details.

{nmaping-1.8 → nmaping-2.0}/nmaping.egg-info/SOURCES.txt

@@ -1,7 +1,7 @@
 README.md
 pyproject.toml
 nmaping/__init__.py
-nmaping/nmap.cpython-313-x86_64-linux-gnu.so
+nmaping/nmap.py
 nmaping.egg-info/PKG-INFO
 nmaping.egg-info/SOURCES.txt
 nmaping.egg-info/dependency_links.txt

nmaping-2.0/nmaping.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nmaping = nmaping.nmap:main

{nmaping-1.8 → nmaping-2.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nmaping"
-version = "1.8"
+version = "2.0"
 authors = [
-    { name="Abu Tanim", email="mrtanvai@gmail.com" },
+    { name="Mr. Tan", email="mrtanvai@gmail.com" },
 ]
 description = "An automation and network scanning utility tool."
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.9"
 dependencies = [
     "requests",
 ]
@@ -22,14 +22,11 @@ classifiers = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/mrtan-official/nmaping"
+Homepage = "https://github.com/Mr74nX/nmaping"
 
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["nmaping*"]
 
-[tool.setuptools.package-data]
-nmaping = ["*.so"]
-
 [project.scripts]
-nmaping = "nmaping.nmap:menu"
+nmaping = "nmaping.nmap:main"

nmaping-1.8/PKG-INFO

@@ -1,84 +0,0 @@
-Metadata-Version: 2.4
-Name: nmaping
-Version: 1.8
-Summary: An automation and network scanning utility tool.
-Author-email: Abu Tanim <mrtanvai@gmail.com>
-License: Custom License
-Project-URL: Homepage, https://github.com/mrtan-official/nmaping
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.13
-Description-Content-Type: text/markdown
-Requires-Dist: requests
-
-# 🚀 Nmaping - Python Nmap Automation Tool
-
-A powerful and automated **Nmap scanning toolkit** built with Python for network reconnaissance, port scanning, and security auditing.
-
-Developed by **Mr Tan**, this tool converts complex Nmap commands into a simple interactive CLI interface for ethical hackers, penetration testers, and cybersecurity learners.
-
----
-
-## ⚡ Key Features
-
-- 🧠 16+ Automated Nmap Scan Modes
-- ⚡ Timing Control (`-T0` to `-T5`) for stealth & speed
-- 🎨 Interactive Colorful CLI Interface
-- 🔄 Auto Update Checker (GitHub Sync)
-- 🌐 Cross-platform (Linux & Windows)
-- 🛡️ Security & penetration testing tool
-
----
-
-## 🔍 Supported Scan Types
-
-- SYN Scan
-- TCP Connect Scan
-- Version Detection
-- OS Detection
-- Aggressive Scan
-- Vulnerability Scan (`--script vuln`)
-- Firewall / IDS Evasion
-- Fast Scan Modes
-
----
-
-## ⏱️ Timing Levels
-
-| Mode | Flag | Description |
-|------|------|-------------|
-| Paranoid | `-T0` | Maximum stealth |
-| Sneaky | `-T1` | Low detection risk |
-| Polite | `-T2` | Light usage |
-| Normal | `-T3` | Default mode |
-| Aggressive | `-T4` | Fast scanning |
-| Insane | `-T5` | Very fast (lab only) |
-
----
-
-## ⚙️ Requirements
-
-- Python 3.x
-- Nmaping installed
-```bash
-pipx install nmaping
-```
-
----
-
-# 🚀 2. PyPI DESCRIPTION (paste this in setup / PyPI long description)
-
-txt id="pypi_desc"
-Nmaping is a powerful Python-based Nmap automation toolkit designed for network scanning, port analysis, and security auditing.
-
-It simplifies complex Nmap commands into an interactive CLI interface, making it easier for ethical hackers, penetration testers, and cybersecurity learners to perform advanced scans.
-
-Features:
-- 20+ automated scan modes
-- Nmap timing control (-T0 to -T5)
-- Vulnerability scanning support
-- OS and service detection
-- Fast and aggressive scan options
-- Cross-platform support (Linux & Windows)
-
-This project is intended for educational and ethical use only.

nmaping-1.8/README.md

@@ -1,71 +0,0 @@
-# 🚀 Nmaping - Python Nmap Automation Tool
-
-A powerful and automated **Nmap scanning toolkit** built with Python for network reconnaissance, port scanning, and security auditing.
-
-Developed by **Mr Tan**, this tool converts complex Nmap commands into a simple interactive CLI interface for ethical hackers, penetration testers, and cybersecurity learners.
-
----
-
-## ⚡ Key Features
-
-- 🧠 16+ Automated Nmap Scan Modes
-- ⚡ Timing Control (`-T0` to `-T5`) for stealth & speed
-- 🎨 Interactive Colorful CLI Interface
-- 🔄 Auto Update Checker (GitHub Sync)
-- 🌐 Cross-platform (Linux & Windows)
-- 🛡️ Security & penetration testing tool
-
----
-
-## 🔍 Supported Scan Types
-
-- SYN Scan
-- TCP Connect Scan
-- Version Detection
-- OS Detection
-- Aggressive Scan
-- Vulnerability Scan (`--script vuln`)
-- Firewall / IDS Evasion
-- Fast Scan Modes
-
----
-
-## ⏱️ Timing Levels
-
-| Mode | Flag | Description |
-|------|------|-------------|
-| Paranoid | `-T0` | Maximum stealth |
-| Sneaky | `-T1` | Low detection risk |
-| Polite | `-T2` | Light usage |
-| Normal | `-T3` | Default mode |
-| Aggressive | `-T4` | Fast scanning |
-| Insane | `-T5` | Very fast (lab only) |
-
----
-
-## ⚙️ Requirements
-
-- Python 3.x
-- Nmaping installed
-```bash
-pipx install nmaping
-```
-
----
-
-# 🚀 2. PyPI DESCRIPTION (paste this in setup / PyPI long description)
-
-txt id="pypi_desc"
-Nmaping is a powerful Python-based Nmap automation toolkit designed for network scanning, port analysis, and security auditing.
-
-It simplifies complex Nmap commands into an interactive CLI interface, making it easier for ethical hackers, penetration testers, and cybersecurity learners to perform advanced scans.
-
-Features:
-- 20+ automated scan modes
-- Nmap timing control (-T0 to -T5)
-- Vulnerability scanning support
-- OS and service detection
-- Fast and aggressive scan options
-- Cross-platform support (Linux & Windows)
-
-This project is intended for educational and ethical use only.

nmaping-1.8/nmaping/__init__.py

@@ -1 +0,0 @@
-from .nmap import *

nmaping-1.8/nmaping.egg-info/PKG-INFO

@@ -1,84 +0,0 @@
-Metadata-Version: 2.4
-Name: nmaping
-Version: 1.8
-Summary: An automation and network scanning utility tool.
-Author-email: Abu Tanim <mrtanvai@gmail.com>
-License: Custom License
-Project-URL: Homepage, https://github.com/mrtan-official/nmaping
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.13
-Description-Content-Type: text/markdown
-Requires-Dist: requests
-
-# 🚀 Nmaping - Python Nmap Automation Tool
-
-A powerful and automated **Nmap scanning toolkit** built with Python for network reconnaissance, port scanning, and security auditing.
-
-Developed by **Mr Tan**, this tool converts complex Nmap commands into a simple interactive CLI interface for ethical hackers, penetration testers, and cybersecurity learners.
-
----
-
-## ⚡ Key Features
-
-- 🧠 16+ Automated Nmap Scan Modes
-- ⚡ Timing Control (`-T0` to `-T5`) for stealth & speed
-- 🎨 Interactive Colorful CLI Interface
-- 🔄 Auto Update Checker (GitHub Sync)
-- 🌐 Cross-platform (Linux & Windows)
-- 🛡️ Security & penetration testing tool
-
----
-
-## 🔍 Supported Scan Types
-
-- SYN Scan
-- TCP Connect Scan
-- Version Detection
-- OS Detection
-- Aggressive Scan
-- Vulnerability Scan (`--script vuln`)
-- Firewall / IDS Evasion
-- Fast Scan Modes
-
----
-
-## ⏱️ Timing Levels
-
-| Mode | Flag | Description |
-|------|------|-------------|
-| Paranoid | `-T0` | Maximum stealth |
-| Sneaky | `-T1` | Low detection risk |
-| Polite | `-T2` | Light usage |
-| Normal | `-T3` | Default mode |
-| Aggressive | `-T4` | Fast scanning |
-| Insane | `-T5` | Very fast (lab only) |
-
----
-
-## ⚙️ Requirements
-
-- Python 3.x
-- Nmaping installed
-```bash
-pipx install nmaping
-```
-
----
-
-# 🚀 2. PyPI DESCRIPTION (paste this in setup / PyPI long description)
-
-txt id="pypi_desc"
-Nmaping is a powerful Python-based Nmap automation toolkit designed for network scanning, port analysis, and security auditing.
-
-It simplifies complex Nmap commands into an interactive CLI interface, making it easier for ethical hackers, penetration testers, and cybersecurity learners to perform advanced scans.
-
-Features:
-- 20+ automated scan modes
-- Nmap timing control (-T0 to -T5)
-- Vulnerability scanning support
-- OS and service detection
-- Fast and aggressive scan options
-- Cross-platform support (Linux & Windows)
-
-This project is intended for educational and ethical use only.

nmaping-1.8/nmaping.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-nmaping = nmaping.nmap:menu