nmaping 1.9__tar.gz → 2.1__tar.gz

{nmaping-1.9 → nmaping-2.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: nmaping
-Version: 1.9
+Version: 2.1
 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.13
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: requests
 

nmaping-2.1/nmaping/__init__.py

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

nmaping-2.1/nmaping/nmap.py

@@ -0,0 +1,288 @@
+#!/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)
+
+def main():
+    if len(sys.argv) > 1:
+        cli_main()
+    else:
+        menu()
+
+if __name__ == "__main__":
+    main()

{nmaping-1.9 → nmaping-2.1}/nmaping.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: nmaping
-Version: 1.9
+Version: 2.1
 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.13
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: requests
 

{nmaping-1.9 → nmaping-2.1}/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.1/nmaping.egg-info/entry_points.txt

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

{nmaping-1.9 → nmaping-2.1}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nmaping"
-version = "1.9"
+version = "2.1"
 authors = [
     { 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",
 ]
@@ -28,8 +28,5 @@ Homepage = "https://github.com/Mr74nX/nmaping"
 where = ["."]
 include = ["nmaping*"]
 
-[tool.setuptools.package-data]
-nmaping = ["*.so"]
-
 [project.scripts]
-nmaping = "nmaping.nmap:menu"
+nmaping = "nmaping.nmap:main"

nmaping-1.9/nmaping/__init__.py

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

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

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