SnakeScan 1.7.9__tar.gz → 1.8.3__tar.gz

snakescan-1.8.3/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: SnakeScan
+Version: 1.8.3
+Summary: Unlock the potential of your network with this powerful IPv4 address scanner. Easily scan IP address ranges, identify active hosts, and even extract IPv4 addresses from IPv6 environments. Enhance your network monitoring, troubleshooting, and security analysis!
+Author: Den*Ram
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: art
+Requires-Dist: tqdm
+Requires-Dist: termcolor
+
+<!--
+This documentation was created with the assistance of the GeekBot language model and Den*Ram
+-->
+# 🐍 SnakeScan: Reliable Port Scanner in Python
+
+A versatile and efficient Python library designed for comprehensive network port scanning.
+
+[![PyPI](https://img.shields.io/pypi/v/SnakeScan?color=blue&label=PyPI)](https://pypi.org/project/SnakeScan/)
+
+[![MIT License](https://img.shields.io/badge/License-MIT-green)](https://opensource.org/licenses/MIT)
+
+[![Python 3.7+](https://img.shields.io/badge/Python-3.7+-brightgreen)](https://www.python.org/)
+
+[![Status: Stable](https://img.shields.io/badge/Status-Stable-green)](https://img.shields.io/badge/Status-Stable-green)
+
+**SnakeScan** provides a flexible and powerful solution for network administrators, security professionals, and developers who need robust port scanning capabilities. From basic port checking to advanced, multi-threaded subnet analysis, SnakeScan provides the tools you need for effective network assessment.
+
+**Important Note:** *The following documentation describes potential features that are **partially implemented** in SnakeScan. Functionality related to custom port dictionaries is available, but has **narrowly specialized** implementations in its current state. Descriptions here are intended to demonstrate a more complete implementation and **may not fully match the library's current narrowly specialized capabilities**.*
+
+## ⚙️ Key features:
+
+*   **Flexible port specification:** Define target ports as individual values, ranges, or via pre-configured sets.
+
+*   **Multi-threaded architecture:** Accelerate scanning operations with parallel processing for rapid analysis.
+
+*   **IP address information retrieval:** Obtain detailed information about target IP addresses, supporting both IPv4 and IPv6.
+
+*   **Real-time port monitoring:** Use the `Watcher` class to continuously monitor the status of important ports.
+
+*   **Concise command-line interface and API:** Easily integrate SnakeScan into workflows via command-line or programmatic access.
+
+*   **UDP port scanning:** Built-in support for scanning UDP ports.
+
+*   **Customizable port dictionaries:** Add your own port descriptions from JSON files and easily revert to the default set. *(Functionality is present, has narrowly specialized implementations. See details below).*
+
+## ⬇️ Installation:
+
+Install SnakeScan using pip:
+
+            
+
+bash
+
+pip install SnakeScan
+
+## ⌨️ Command-line usage:
+
+### 💡 Attribute reference:
+
+*   **-p**: Specify target ports to scan (single port or range). Note: Range excludes the lower bound in the first entry. For example: To scan from port 80 to 443 specify the range as `79-443`. Examples: `snake -p 80,443` or `snake -p 80,3437,8080,20-30,79-443`
+
+*   **-u**: Enable UDP port scanning. Example: `snake -p 53 -u`
+
+*   **-h**: Show the full list of available command-line attributes and their descriptions. Example: `snake -h` or `snake -help`
+
+*   **-sp**: Start scanning using the predefined common port set with `ProcessPoolExecutor`. Example: `snake -sp`
+
+*   **-v**: Display the current version of the SnakeScan library. Example: `snake -v`
+
+*   **-gs**: Retrieve the SSL/TLS certificate from the specified web server. Example: `snake www.google.com -gs` (Requires a valid hostname to avoid connection errors.)
+
+*   **-t**: Enable multi-threading to improve scanning performance. Example: `snake -t`
+
+*   **-ch**: Scan a subnet to discover active IP addresses on the network. Example: `snake -ch`
+
+*   **-l**: Display your public IP address (requires active internet connection). Example: `snake -l`
+
+*   **-i**: Show detailed information about a specific IP address (supports both IPv4 and IPv6). Example: `snake www.google.com -i`
+
+*   **-d**: Specify the path to a JSON file containing TCP port definitions, and optionally a path to a second JSON file containing UDP port definitions. **Note:** When using this argument *for the first* time, the paths to the JSON files must be specified with each command execution, separated by a comma. After the first use, SnakeScan *may* remember these paths for subsequent scans. Functionality is present, has narrowly specialized implementations. See details below.
+
+    Example: `snake -d /путь/к/tcp_ports.json,/путь/к/udp_ports.json` (if you want to specify both TCP and UDP, if TCP only: `snake -d /путь/к/tcp_ports.json`)
+
+    **Subsequent Use**: After initial use, you can simply use the `-d` flag *without* file paths and SnakeScan *may* use previously defined JSON files. Functionality is present, has narrowly specialized implementations. See details below.
+
+    Example (after initial setup): `snake -d` (may use previously saved paths)
+
+    **JSON file format:** The JSON file must be formatted as a dictionary where the keys are port numbers (as strings) and the values are the corresponding service names or descriptions.
+
+    ```json
+
+    {
+
+        "53": "DNS",
+
+        "80": "HTTP",
+
+        "443": "HTTPS"
+
+    }
+
+    ```
+
+*   **-dr**: Reset custom port dictionaries to their default state and revert to the standard SnakeScan port definitions. This functionality relies on internal mechanisms that are still under development. Functionality is present, has narrowly specialized implementations. See details below. Example: `snake -dr`
+
+## 💻 Python Code Integration:
+
+### ⏱️ Watcher class: Real-time port status
+
+The `Watcher` class allows you to continuously monitor the specified port.
+
+python
+
+from SnakeScan import Watcher
+
+watcher = Watcher("localhost", 53, 2)  # Host, port, check interval (in seconds)
+
+watcher.start()  # Start monitoring!
+
+#### `Watcher` Methods:
+
+*   `Watcher.start()` - Start the port monitoring process.
+
+*   `Watcher.stop()` - End the port monitoring process.
+
+---
+
+**Last updated:** 1.8.1 (Added initial support for custom port dictionaries and standard SnakeScan ports. Note: This functionality is still under development and may exhibit unexpected behavior.) *Functionality is present, has narrowly specialized implementations. See details below.*
+
+***
+
+**Details on the narrowly specialized functionality of custom port dictionaries:**
+
+*   The `-d` flag can load port definitions from a JSON file.
+
+*   The `-dr` flag attempts to revert to the default port definitions.
+
+

snakescan-1.8.3/README.md

@@ -0,0 +1,127 @@
+<!--
+This documentation was created with the assistance of the GeekBot language model and Den*Ram
+-->
+# 🐍 SnakeScan: Reliable Port Scanner in Python
+
+A versatile and efficient Python library designed for comprehensive network port scanning.
+
+[![PyPI](https://img.shields.io/pypi/v/SnakeScan?color=blue&label=PyPI)](https://pypi.org/project/SnakeScan/)
+
+[![MIT License](https://img.shields.io/badge/License-MIT-green)](https://opensource.org/licenses/MIT)
+
+[![Python 3.7+](https://img.shields.io/badge/Python-3.7+-brightgreen)](https://www.python.org/)
+
+[![Status: Stable](https://img.shields.io/badge/Status-Stable-green)](https://img.shields.io/badge/Status-Stable-green)
+
+**SnakeScan** provides a flexible and powerful solution for network administrators, security professionals, and developers who need robust port scanning capabilities. From basic port checking to advanced, multi-threaded subnet analysis, SnakeScan provides the tools you need for effective network assessment.
+
+**Important Note:** *The following documentation describes potential features that are **partially implemented** in SnakeScan. Functionality related to custom port dictionaries is available, but has **narrowly specialized** implementations in its current state. Descriptions here are intended to demonstrate a more complete implementation and **may not fully match the library's current narrowly specialized capabilities**.*
+
+## ⚙️ Key features:
+
+*   **Flexible port specification:** Define target ports as individual values, ranges, or via pre-configured sets.
+
+*   **Multi-threaded architecture:** Accelerate scanning operations with parallel processing for rapid analysis.
+
+*   **IP address information retrieval:** Obtain detailed information about target IP addresses, supporting both IPv4 and IPv6.
+
+*   **Real-time port monitoring:** Use the `Watcher` class to continuously monitor the status of important ports.
+
+*   **Concise command-line interface and API:** Easily integrate SnakeScan into workflows via command-line or programmatic access.
+
+*   **UDP port scanning:** Built-in support for scanning UDP ports.
+
+*   **Customizable port dictionaries:** Add your own port descriptions from JSON files and easily revert to the default set. *(Functionality is present, has narrowly specialized implementations. See details below).*
+
+## ⬇️ Installation:
+
+Install SnakeScan using pip:
+
+            
+
+bash
+
+pip install SnakeScan
+
+## ⌨️ Command-line usage:
+
+### 💡 Attribute reference:
+
+*   **-p**: Specify target ports to scan (single port or range). Note: Range excludes the lower bound in the first entry. For example: To scan from port 80 to 443 specify the range as `79-443`. Examples: `snake -p 80,443` or `snake -p 80,3437,8080,20-30,79-443`
+
+*   **-u**: Enable UDP port scanning. Example: `snake -p 53 -u`
+
+*   **-h**: Show the full list of available command-line attributes and their descriptions. Example: `snake -h` or `snake -help`
+
+*   **-sp**: Start scanning using the predefined common port set with `ProcessPoolExecutor`. Example: `snake -sp`
+
+*   **-v**: Display the current version of the SnakeScan library. Example: `snake -v`
+
+*   **-gs**: Retrieve the SSL/TLS certificate from the specified web server. Example: `snake www.google.com -gs` (Requires a valid hostname to avoid connection errors.)
+
+*   **-t**: Enable multi-threading to improve scanning performance. Example: `snake -t`
+
+*   **-ch**: Scan a subnet to discover active IP addresses on the network. Example: `snake -ch`
+
+*   **-l**: Display your public IP address (requires active internet connection). Example: `snake -l`
+
+*   **-i**: Show detailed information about a specific IP address (supports both IPv4 and IPv6). Example: `snake www.google.com -i`
+
+*   **-d**: Specify the path to a JSON file containing TCP port definitions, and optionally a path to a second JSON file containing UDP port definitions. **Note:** When using this argument *for the first* time, the paths to the JSON files must be specified with each command execution, separated by a comma. After the first use, SnakeScan *may* remember these paths for subsequent scans. Functionality is present, has narrowly specialized implementations. See details below.
+
+    Example: `snake -d /путь/к/tcp_ports.json,/путь/к/udp_ports.json` (if you want to specify both TCP and UDP, if TCP only: `snake -d /путь/к/tcp_ports.json`)
+
+    **Subsequent Use**: After initial use, you can simply use the `-d` flag *without* file paths and SnakeScan *may* use previously defined JSON files. Functionality is present, has narrowly specialized implementations. See details below.
+
+    Example (after initial setup): `snake -d` (may use previously saved paths)
+
+    **JSON file format:** The JSON file must be formatted as a dictionary where the keys are port numbers (as strings) and the values are the corresponding service names or descriptions.
+
+    ```json
+
+    {
+
+        "53": "DNS",
+
+        "80": "HTTP",
+
+        "443": "HTTPS"
+
+    }
+
+    ```
+
+*   **-dr**: Reset custom port dictionaries to their default state and revert to the standard SnakeScan port definitions. This functionality relies on internal mechanisms that are still under development. Functionality is present, has narrowly specialized implementations. See details below. Example: `snake -dr`
+
+## 💻 Python Code Integration:
+
+### ⏱️ Watcher class: Real-time port status
+
+The `Watcher` class allows you to continuously monitor the specified port.
+
+python
+
+from SnakeScan import Watcher
+
+watcher = Watcher("localhost", 53, 2)  # Host, port, check interval (in seconds)
+
+watcher.start()  # Start monitoring!
+
+#### `Watcher` Methods:
+
+*   `Watcher.start()` - Start the port monitoring process.
+
+*   `Watcher.stop()` - End the port monitoring process.
+
+---
+
+**Last updated:** 1.8.1 (Added initial support for custom port dictionaries and standard SnakeScan ports. Note: This functionality is still under development and may exhibit unexpected behavior.) *Functionality is present, has narrowly specialized implementations. See details below.*
+
+***
+
+**Details on the narrowly specialized functionality of custom port dictionaries:**
+
+*   The `-d` flag can load port definitions from a JSON file.
+
+*   The `-dr` flag attempts to revert to the default port definitions.
+

{snakescan-1.7.9 → snakescan-1.8.3}/SnakeScan/CLI.py

@@ -1,3 +1,6 @@
+import os
+import configparser
+import json
 import sys
 import string
 import argparse
@@ -13,13 +16,6 @@ from SnakeScan.PoolExecutor import PoolProcessExecutor
 from SnakeScan.Get_ssl import Get_ssl
 from SnakeScan.Pool_UDP_Executor import PoolExecutorUDP
 
-
-def main():
-    pass
-
-
-if __name__ == "__main__":
-    main()
 OpenPorts = []
 threads = []
 portsopen = 0
@@ -74,7 +70,101 @@ ports = {
 }
 
 
-version = "1.7.9"
+def Load_config(ports):
+    try:
+        config = configparser.ConfigParser()
+        package_dir = os.path.dirname(__file__)
+
+        config_path = os.path.join(package_dir, "config.ini")
+
+        config.read(config_path)
+
+        if "Settings" in config and ports in config["Settings"]:
+            return config["Settings"][ports]
+    except Exception as e:
+        print(e)
+        sys.exit()
+
+
+def Save_config(path_tcp, path_udp):
+    if path_tcp:
+        if os.path.exists(path_tcp):
+            pass
+        else:
+            print(f"Error: File not found: {path_tcp}")
+            sys.exit()
+    else:
+        path_tcp = ""
+    if path_udp:
+        if os.path.exists(path_udp):
+            pass
+        else:
+            print(f"Error: File not found: {path_udp}")
+            sys.exit()
+    else:
+        path_udp = ""
+    try:
+        config = configparser.ConfigParser()
+        package_dir = os.path.dirname(__file__)
+
+        config_path = os.path.join(package_dir, "config.ini")
+        config["Settings"] = {"path_tcp": path_tcp, "path_udp": path_udp}
+        with open(config_path, "w") as configfile:
+            config.write(configfile)
+
+    except Exception as e:
+        print(e)
+        sys.exit()
+
+
+def load_json_config(filepath):
+    try:
+        if not os.path.isabs(filepath):
+            filepath = os.path.abspath(filepath)
+
+        with open(filepath, "r", encoding="utf-8") as f:
+            ports = json.load(f)
+        return {int(k): v for k, v in ports.items()}
+    except FileNotFoundError:
+        if filepath:
+            pass
+        else:
+            print(f"Error: File not found: {filepath}")
+            sys.exit()
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON format in file: {filepath} - {e}")
+        sys.exit()
+    except Exception as e:
+        print(f"Error loading file: {e}")
+        sys.exit()
+
+
+def main():
+    pass
+
+
+path_tcp = Load_config("path_tcp")
+path_udp = Load_config("path_udp")
+if path_tcp and path_udp:
+    ports_tcp = load_json_config(path_tcp)
+    ports_udp = load_json_config(path_udp)
+else:
+    ports_tcp = False
+    ports_udp = False
+if path_tcp:
+    ports_tcp = load_json_config(path_tcp)
+else:
+    ports_tcp = False
+if path_udp:
+    ports_udp = load_json_config(path_udp)
+else:
+    path_udp = False
+
+
+if __name__ == "__main__":
+    main()
+
+version = "1.8.3"
 
 
 def is_port_open(host, port):
@@ -138,9 +228,22 @@ def SnakeArgs():
         description="SnakeScan - It's a command line library for scan and get information about ip."
     )
     parser.add_argument("host", nargs="?", default="None")
+    parser.add_argument(
+        "-d",
+        "--dictonary",
+        required=False,
+        default="None",
+        help="Use custom port dictionaries",
+    )
     parser.add_argument(
         "-u", "--udp", action="store_true", help="Use UDP ports for scanning"
     )
+    parser.add_argument(
+        "-dr",
+        "--dictremove",
+        action="store_true",
+        help="Removes user port dictionaries",
+    )
     parser.add_argument(
         "-gs", "--getssl", action="store_true", help="Get official ssl certificate"
     )
@@ -170,8 +273,8 @@ def SnakeArgs():
 
 
 port_user = SnakeArgs().ports
-host = SnakeArgs().host
-host = host.split(",")
+host = SnakeArgs().host.split(",")
+filepath = SnakeArgs().dictonary.split(",")
 for n in range(len(host)):
     if host[n].startswith("http://"):
         host[n] = host[n].strip()
@@ -194,6 +297,14 @@ for n in range(len(host)):
                 host[n] = host[n][0:i]
 if host[0] == "None":
     host[0] = "localhost"
+if filepath[0] != "None":
+    if len(filepath) >= 2:
+        ports_tcp = load_json_config(filepath[0])
+        ports_udp = load_json_config(filepath[1])
+        Save_config(filepath[0], filepath[1])
+    else:
+        ports_tcp = load_json_config(filepath[0])
+        Save_config(filepath[0], "")
 if SnakeArgs().udp:
 
     def is_port_open(host, port, timeout=1):
@@ -218,10 +329,8 @@ if SnakeArgs().udp:
             return is_open
 
         except socket.gaierror:
-            print("Error: Unable to resolve host name.")
             return None
         except socket.error as e:
-            print(f"Socket error: {e}")
             return False
 
     def is_port_open_threads(host, port, timeout=1):
@@ -237,113 +346,129 @@ if SnakeArgs().udp:
                 data, server = sock.recvfrom(4096)
                 print(f"Response received: {data.decode()} from {server}")
                 print(
-                    f"Open{colored('[√]','green')}-->{colored(ports.get(port),'light_green')}{colored(f'|{port}|','green')} may be listening on host"
+                    f"Open{colored('[√]','green')}-->{colored(ports.get(port),'light_green')}{colored(f'|{port}|','green')}"
                 )
             except socket.timeout:
                 print(
-                    f"Closed{colored('[X]','red')}-->{colored(ports.get(port),'light_red')}{colored(f'|{port}|','red')} is likely closed on host"
+                    f"Closed{colored('[X]','red')}-->{colored(ports.get(port),'light_red')}{colored(f'|{port}|','red')}"
                 )
             except ConnectionRefusedError:
-                print("An error occurred while scanning.")
-            sock.close()
+                sock.close()
         except socket.gaierror:
-            print("Error: Unable to resolve host name.")
+            pass
         except socket.error as e:
-            print(f"Socket error: {e}")
-
-    ports = {
-        7: "ECHO",
-        9: "DISCARD",
-        13: "DAYTIME",
-        17: "QOTD (Quote of the Day)",
-        19: "CHARGEN (Character Generator)",
-        53: "DNS (Domain Name System)",
-        67: "DHCP Server",
-        68: "DHCP Client",
-        69: "TFTP (Trivial File Transfer Protocol)",
-        111: "RPC (Remote Procedure Call)",
-        123: "NTP (Network Time Protocol)",
-        137: "NetBIOS Name Service",
-        138: "NetBIOS Datagram Service",
-        161: "SNMP (Simple Network Management Protocol)",
-        162: "SNMP Trap",
-        443: "QUIC (Quick UDP Internet Connections)",
-        500: "ISAKMP (Internet Security Association and Key Management Protocol)",
-        520: "RIP (Routing Information Protocol)",
-        1434: "Microsoft SQL Server Dynamic Port Allocation",
-        4500: "IPsec NAT-Traversal (NAT-T)",
-        5353: "mDNS (Multicast DNS)",
-        5355: "LLMNR (Link-Local Multicast Name Resolution)",
-        1900: "SSDP (Simple Service Discovery Protocol)",
-        3478: "STUN (Session Traversal Utilities for NAT)",
-        5060: "SIP (Session Initiation Protocol)",
-        5061: "SIP (Session Initiation Protocol) (TLS)",
-        20777: "Garmin Training Center",
-        3074: "Xbox Live",
-        3479: "TURN (Traversal Using Relays around NAT)",
-        4126: "Muon",
-        50000: "Drone (Drone Protocol)",
-        60000: "RDP (Remote Desktop Protocol) over UDP",
-        5000: "fCoE (Fibre Channel over Ethernet)",
-        5001: "HP OpenView Operations Agent",
-        1719: "H.323 Gatekeeper RAS",
-        1720: "H.323 Call Signaling",
-        1812: "RADIUS authentication",
-        1813: "RADIUS accounting",
-        5222: "XMPP client connection",
-        5269: "XMPP server connection",
-    }
+            pass
+
+    if ports_udp:
+        ports = ports_udp
+    else:
+        ports = {
+            7: "ECHO",
+            9: "DISCARD",
+            13: "DAYTIME",
+            17: "QOTD (Quote of the Day)",
+            19: "CHARGEN (Character Generator)",
+            53: "DNS (Domain Name System)",
+            67: "DHCP Server",
+            68: "DHCP Client",
+            69: "TFTP (Trivial File Transfer Protocol)",
+            111: "RPC (Remote Procedure Call)",
+            123: "NTP (Network Time Protocol)",
+            137: "NetBIOS Name Service",
+            138: "NetBIOS Datagram Service",
+            161: "SNMP (Simple Network Management Protocol)",
+            162: "SNMP Trap",
+            443: "QUIC (Quick UDP Internet Connections)",
+            500: "ISAKMP (Internet Security Association and Key Management Protocol)",
+            520: "RIP (Routing Information Protocol)",
+            1434: "Microsoft SQL Server Dynamic Port Allocation",
+            4500: "IPsec NAT-Traversal (NAT-T)",
+            5353: "mDNS (Multicast DNS)",
+            5355: "LLMNR (Link-Local Multicast Name Resolution)",
+            1900: "SSDP (Simple Service Discovery Protocol)",
+            3478: "STUN (Session Traversal Utilities for NAT)",
+            5060: "SIP (Session Initiation Protocol)",
+            5061: "SIP (Session Initiation Protocol) (TLS)",
+            20777: "Garmin Training Center",
+            3074: "Xbox Live",
+            3479: "TURN (Traversal Using Relays around NAT)",
+            4126: "Muon",
+            50000: "Drone (Drone Protocol)",
+            60000: "RDP (Remote Desktop Protocol) over UDP",
+            5000: "fCoE (Fibre Channel over Ethernet)",
+            5001: "HP OpenView Operations Agent",
+            1719: "H.323 Gatekeeper RAS",
+            1720: "H.323 Call Signaling",
+            1812: "RADIUS authentication",
+            1813: "RADIUS accounting",
+            5222: "XMPP client connection",
+            5269: "XMPP server connection",
+        }
 
 else:
-    ports = {
-        20: "FTP-Data",
-        21: "FTP-Control",
-        22: "SSH",
-        23: "Telnet",
-        25: "SMTP",
-        43: "Whois",
-        53: "DNS",
-        70: "Gopher",
-        79: "FINGER",
-        80: "HTTP",
-        110: "POP3",
-        111: "RPC",
-        113: "ident",
-        115: "SFTP",
-        135: "MSRPC",
-        139: "NetBIOS-SSN",
-        143: "IMAP",
-        179: "BGP",
-        194: "IRC",
-        389: "LDAP",
-        443: "HTTPS",
-        445: "SMB",
-        465: "SMTPS",
-        587: "SMTP Submission",
-        631: "IPP",
-        636: "LDAPS",
-        873: "RSYNC",
-        993: "IMAPS",
-        995: "POP3S",
-        1080: "SOCKS",
-        1433: "SQL Server",
-        1521: "Oracle",
-        2082: "CPanel",
-        2083: "CPanel",
-        2222: "SSH",
-        3128: "HTTP Proxy",
-        3306: "MySQL",
-        3389: "RDP",
-        5432: "PostgreSQL",
-        5900: "VNC",
-        8000: "HTTP Alternate",
-        8080: "HTTP Alternate",
-        8443: "HTTPS Alternate",
-        8888: "HTTP Alternate",
-        10000: "Webmin",
-        27017: "MongoDB",
-    }
-
+    if ports_tcp:
+        ports = ports_tcp
+    else:
+        ports = {
+            20: "FTP-Data",
+            21: "FTP-Control",
+            22: "SSH",
+            23: "Telnet",
+            25: "SMTP",
+            43: "Whois",
+            53: "DNS",
+            70: "Gopher",
+            79: "FINGER",
+            80: "HTTP",
+            110: "POP3",
+            111: "RPC",
+            113: "ident",
+            115: "SFTP",
+            135: "MSRPC",
+            139: "NetBIOS-SSN",
+            143: "IMAP",
+            179: "BGP",
+            194: "IRC",
+            389: "LDAP",
+            443: "HTTPS",
+            445: "SMB",
+            465: "SMTPS",
+            587: "SMTP Submission",
+            631: "IPP",
+            636: "LDAPS",
+            873: "RSYNC",
+            993: "IMAPS",
+            995: "POP3S",
+            1080: "SOCKS",
+            1433: "SQL Server",
+            1521: "Oracle",
+            2082: "CPanel",
+            2083: "CPanel",
+            2222: "SSH",
+            3128: "HTTP Proxy",
+            3306: "MySQL",
+            3389: "RDP",
+            5432: "PostgreSQL",
+            5900: "VNC",
+            8000: "HTTP Alternate",
+            8080: "HTTP Alternate",
+            8443: "HTTPS Alternate",
+            8888: "HTTP Alternate",
+            10000: "Webmin",
+            27017: "MongoDB",
+        }
+
+if SnakeArgs().dictremove:
+    try:
+        config = configparser.ConfigParser()
+        package_dir = os.path.dirname(__file__)
+        config_path = os.path.join(package_dir, "config.ini")
+        config["Settings"] = {"path_tcp": "", "path_udp": ""}
+        with open(config_path, "w") as configfile:
+            config.write(configfile)
+    except Exception as e:
+        print(e)
+        sys.exit()
 if SnakeArgs().ports:
     rangeports, port_user = Ports(port_user)
     for i in range(len(port_user)):
@@ -388,14 +513,14 @@ if SnakeArgs().ports:
                 if OpenPorts:
                     for i in OpenPorts:
                         print(f"Open{colored('|√|','green')}-->{ports[i]}|{i}|")
-                    print(f"{colored(f'{host[n]}','light_cyan')}".center(69, "—"))
+                    print(f"|{host[n]}|".center(60, "—"))
                     print(f"Closed{colored('|X|','red')}:{portsclosed}")
                     portsclosed = 0
                     print(f"Open{colored('|√|','green')}:{portsopen}")
                     portsopen = 0
                     print("—" * 60)
                 else:
-                    print(f"{colored(f'{host[n]}','light_cyan')}".center(69, "—"))
+                    print(f"|{host[n]}|".center(60, "—"))
                     print(f"Closed{colored('|X|','red')}:{portsclosed}")
                     portsclosed = 0
                     print(f"Open{colored('|√|','green')}:{portsopen}")
@@ -414,15 +539,17 @@ if SnakeArgs().local:
         s.connect(("10.255.255.255", 1))
         local = s.getsockname()[0]
     except Exception as e:
-        local = f"127.0.0.1:{e}"
+        local = f"{e}"
     finally:
         s.close()
-        print(local)
+        print("|localhost|".center(60, "—"))
+        print(f"Public IP:{local}")
+        print(f"".center(60, "—"))
 if SnakeArgs().info:
     if host[0] == "None":
         host[0] = "localhost"
     for n in range(len(host)):
-        print(f"{colored(f'{host[n]}','light_cyan')}".center(69, "—"))
+        print(f"|{host[n]}|".center(60, "—"))
         try:
             host[n] = socket.gethostbyname(host[n])
         except Exception as e:
@@ -498,8 +625,16 @@ if SnakeArgs().info:
 
 
 if SnakeArgs().thread:
+    if SnakeArgs().udp:
+        try:
+            host[n] = socket.gethostbyname(host[n])
+        except Exception as e:
+            print(f"|{host[n]}|".center(60, "—"))
+            print(e)
+            sys.exit()
+
     for n in range(len(host)):
-        print(f"{colored(f'{host[n]}','light_cyan')}".center(69, "—"))
+        print(f"|{host[n]}|".center(60, "—"))
 
         for port in ports.keys():
             t = Thread(
@@ -514,15 +649,21 @@ if SnakeArgs().version:
     print(f"SnakeScan_Build_{version}")
 if SnakeArgs().speed:
     if SnakeArgs().udp:
+        try:
+            host[n] = socket.gethostbyname(host[n])
+        except Exception as e:
+            print(f"|{host[n]}|".center(60, "—"))
+            print(e)
+            sys.exit()
         for n in range(len(host)):
-            print(f"{colored(f'{host[n]}','light_cyan')}".center(69, "—"))
-            PoolExecutorUDP(host[n])
+            print(f"|{host[n]}|".center(60, "—"))
+            PoolExecutorUDP(host[n], ports)
         sys.exit()
     for n in range(len(host)):
-        print(f"{colored(f'{host[n]}','light_cyan')}".center(69, "—"))
-        PoolProcessExecutor(host[n])
+        print(f"|{host[n]}|".center(60, "—"))
+        PoolProcessExecutor(host[n], ports)
 if SnakeArgs().getssl:
     for n in range(len(host)):
-        print(f"{colored(f'{host[n]}','light_cyan')}".center(69, "—"))
+        print(f"|{host[n]}|".center(60, "—"))
         Get_ssl(host[n])
         print("".center(60, "—"))

{snakescan-1.7.9 → snakescan-1.8.3}/SnakeScan/Check_subnet.py

@@ -30,7 +30,7 @@ def Check_network(host):
             return False
 
     try:
-        print(f"{colored(f'{host}','light_cyan')}".center(69, "—"))
+        print(f"|{host}|".center(60, "—"))
         try:
             host = socket.gethostbyname(host)
         except Exception as e:

snakescan-1.8.3/SnakeScan/PoolExecutor.py

@@ -0,0 +1,31 @@
+import socket
+from termcolor import colored
+from concurrent.futures import ProcessPoolExecutor
+
+
+def is_port_open_threads(host, port, ports):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.settimeout(1)
+            s.connect((host, port))
+        except (OSError, socket.timeout):
+            try:
+                print(
+                    f"Closed{colored('|X|','red')}-->{colored(ports.get(port),'light_red')}{colored(f'|{port}|','red')}"
+                )
+            except:
+                print(f"Closed{colored('|X|','red')}-->{colored(f'|{port}|','red')}")
+        else:
+            print(
+                f"Open{colored('|√|','green')}-->{colored(ports.get(port),'light_green')}{colored(f'|{port}|','green')}"
+            )
+
+
+def PoolProcessExecutor(host, ports):
+    with ProcessPoolExecutor(max_workers=None) as executor:
+        try:
+            for port in ports.keys():
+                future = executor.submit(is_port_open_threads, host, port, ports)
+
+        except Exception as e:
+            print(e)

snakescan-1.8.3/SnakeScan/Pool_UDP_Executor.py

@@ -0,0 +1,40 @@
+import socket
+from termcolor import colored
+from concurrent.futures import ProcessPoolExecutor
+
+
+def is_port_open_threads(host, port, ports, timeout=1):
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.settimeout(timeout)
+        message = b"Test UDP packet"
+        address = (host, port)
+
+        sock.sendto(message, address)
+
+        try:
+            data, server = sock.recvfrom(4096)
+            print(f"Response received: {data.decode()} from {server}")
+            print(
+                f"Open{colored('[√]','green')}-->{colored(ports.get(port),'light_green')}{colored(f'|{port}|','green')}"
+            )
+        except socket.timeout:
+            print(
+                f"Closed{colored('[X]','red')}-->{colored(ports.get(port),'light_red')}{colored(f'|{port}|','red')}"
+            )
+        except ConnectionRefusedError:
+            sock.close()
+    except socket.gaierror:
+        pass
+    except socket.error as e:
+        pass
+
+
+def PoolExecutorUDP(host, ports):
+    with ProcessPoolExecutor(max_workers=None) as executor:
+        try:
+            for port in ports.keys():
+                future = executor.submit(is_port_open_threads, host, port, ports)
+
+        except Exception as e:
+            print(e)

{snakescan-1.7.9 → snakescan-1.8.3}/SnakeScan/__init__.py

@@ -1,6 +1,6 @@
-"""IPv4 address scanner for collecting address information.Scan or get the IPv4 address from the IPv6 host"""
+"""Unlock the potential of your network with this powerful IPv4 address scanner. Easily scan IP address ranges, identify active hosts, and even extract IPv4 addresses from IPv6 environments. Enhance your network monitoring, troubleshooting, and security analysis!"""
 
-__version__ = "1.7.9"
+__version__ = "1.8.3"
 import socket
 from time import sleep
 from termcolor import colored
@@ -24,9 +24,13 @@ class Watcher:
                     connection = sock.connect_ex((self.host, self.port_user))
                 if previous != connection:
                     if connection == 0:
-                        print(f"{colored(f'Service is up {self.host}-->|{self.port_user}|','light_green')}")
+                        print(
+                            f"{colored(f'Service is up {self.host}-->|{self.port_user}|','light_green')}"
+                        )
                     else:
-                        print(f"{colored(f'Service is down {self.host}-->|{self.port_user}|','light_red')}")
+                        print(
+                            f"{colored(f'Service is down {self.host}-->|{self.port_user}|','light_red')}"
+                        )
                     previous = connection
             except Exception as e:
                 print(f"Unable to create scanner object:{e}")

snakescan-1.8.3/SnakeScan/config.ini

@@ -0,0 +1,3 @@
+[Settings]
+path_tcp = ""
+path_udp = ""

{snakescan-1.7.9 → snakescan-1.8.3}/pyproject.toml

@@ -17,6 +17,12 @@ dependencies = [
         "termcolor",
     ]
 [project.scripts]
-SnakeScan = "SnakeScan:run"
 Snake = "SnakeScan.CLI:main"
-snake = "SnakeScan.CLI:main"
+snake = "SnakeScan.CLI:main"
+[tool.flit.module]
+
+name = "SnakeScan"
+
+[tool.flit.sdist]
+
+include = ["SnakeScan/config.ini"]

snakescan-1.7.9/PKG-INFO

@@ -1,98 +0,0 @@
-Metadata-Version: 2.4
-Name: SnakeScan
-Version: 1.7.9
-Summary: IPv4 address scanner for collecting address information.Scan or get the IPv4 address from the IPv6 host
-Author: Den*Ram
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-Expression: MIT
-License-File: LICENSE
-Requires-Dist: art
-Requires-Dist: tqdm
-Requires-Dist: termcolor
-
-<!--
-
-This documentation was created with the assistance of the GeekBot language model and Den*Ram
-
--->
-
-# 🐍 SnakeScan: A Robust Python Port Scanner
-
-A versatile and efficient Python library designed for comprehensive network port scanning.
-[![PyPI](https://img.shields.io/pypi/v/SnakeScan?color=blue&label=PyPI)](https://pypi.org/project/SnakeScan/)
-[![MIT License](https://img.shields.io/badge/License-MIT-green)](https://opensource.org/licenses/MIT)
-[![Python 3.7+](https://img.shields.io/badge/Python-3.7+-brightgreen)](https://www.python.org/)
-[![Status: Stable](https://img.shields.io/badge/Status-Stable-green)](https://img.shields.io/badge/Status-Stable-green)
-
-**SnakeScan** provides a flexible and powerful solution for network administrators, security professionals, and developers requiring reliable port scanning capabilities. From basic port verification to advanced, multi-threaded subnet analysis, SnakeScan delivers the tools necessary for effective network assessment.
-
-## ⚙️ Key Features:
-
-*   **Flexible Port Specification:** Define target ports as single values, ranges, or through pre-configured sets.
-
-*   **Multi-Threaded Architecture:** Accelerate scanning operations with parallel processing for rapid analysis.
-
-*   **IP Information Retrieval:** Obtain detailed information about target IP addresses, supporting both IPv4 and IPv6.
-
-*   **Real-time Port Monitoring:** Utilize the `Watcher` class for continuous monitoring of critical port statuses.
-
-*   **Concise Command-Line Interface & API:** Integrate SnakeScan seamlessly into workflows via CLI or programmatic access.
-
-*   **UDP Port Scanning:** Native support for scanning UDP ports.
-
-## ⬇️ Installation:
-
-Install SnakeScan using pip:
-
-bash
-
-pip install SnakeScan
-
-## ⌨️ Command Line Usage:
-
-### 💡 Attribute Reference:
-
-*   **-p**: Specify target ports for scanning (single port or range). Note: Range specifications exclude the lower bound on the first entry. Example: To scan from port 80 to 443, define the range as `79-443`. Examples: `snake -p 80,443` or `snake -p 80,3437,8080,20-30,79-443`
-
-*   **-u**: Enable UDP port scanning. Example: `snake -p 53 -u`
-
-*   **-h**: Display the complete list of available command-line attributes and their descriptions. Example: `snake -h` or `snake -help`
-
-*   **-sp**: Initiate a scan using a predefined set of common ports with `ProcessPoolExecutor`. Example: `snake -sp`
-
-*   **-v**: Display the current version of the SnakeScan library. Example: `snake -v`
-
-*   **-gs**: Retrieve the SSL/TLS certificate from a specified web server. Example: `snake www.google.com -gs` (Requires a valid hostname to avoid connection errors.)
-
-*   **-t**: Enable multi-threading for enhanced scan performance. Example: `snake -t`
-
-*   **-ch**: Scan a subnet to discover active IP addresses on the network. Example: `snake -ch`
-
-*   **-l**: Display your public IP address (requires an active internet connection). Example: `snake -l`
-
-*   **-i**: Show detailed information about a specific IP address (supports both IPv4 and IPv6). Example: `snake www.google.com -i`
-
-## 💻 Python Code Integration:
-
-### ⏱️  Watcher Class: Real-Time Port Status
-
-The `Watcher` class facilitates continuous monitoring of a specified port.
-
-python
-
-from SnakeScan import Watcher
-
-watcher = Watcher("localhost", 53, 2)  # Host, port, check interval (in seconds)
-
-watcher.start()  # Begin monitoring!
-
-#### `Watcher` Methods:
-
-*   `Watcher.start()` - Initiate the port monitoring process.
-
-*   `Watcher.stop()` - Terminate the port monitoring process.
-
----
-
-**Latest Update:** 1.7.9 (Added full color output)

snakescan-1.7.9/README.md

@@ -1,85 +0,0 @@
-<!--
-
-This documentation was created with the assistance of the GeekBot language model and Den*Ram
-
--->
-
-# 🐍 SnakeScan: A Robust Python Port Scanner
-
-A versatile and efficient Python library designed for comprehensive network port scanning.
-[![PyPI](https://img.shields.io/pypi/v/SnakeScan?color=blue&label=PyPI)](https://pypi.org/project/SnakeScan/)
-[![MIT License](https://img.shields.io/badge/License-MIT-green)](https://opensource.org/licenses/MIT)
-[![Python 3.7+](https://img.shields.io/badge/Python-3.7+-brightgreen)](https://www.python.org/)
-[![Status: Stable](https://img.shields.io/badge/Status-Stable-green)](https://img.shields.io/badge/Status-Stable-green)
-
-**SnakeScan** provides a flexible and powerful solution for network administrators, security professionals, and developers requiring reliable port scanning capabilities. From basic port verification to advanced, multi-threaded subnet analysis, SnakeScan delivers the tools necessary for effective network assessment.
-
-## ⚙️ Key Features:
-
-*   **Flexible Port Specification:** Define target ports as single values, ranges, or through pre-configured sets.
-
-*   **Multi-Threaded Architecture:** Accelerate scanning operations with parallel processing for rapid analysis.
-
-*   **IP Information Retrieval:** Obtain detailed information about target IP addresses, supporting both IPv4 and IPv6.
-
-*   **Real-time Port Monitoring:** Utilize the `Watcher` class for continuous monitoring of critical port statuses.
-
-*   **Concise Command-Line Interface & API:** Integrate SnakeScan seamlessly into workflows via CLI or programmatic access.
-
-*   **UDP Port Scanning:** Native support for scanning UDP ports.
-
-## ⬇️ Installation:
-
-Install SnakeScan using pip:
-
-bash
-
-pip install SnakeScan
-
-## ⌨️ Command Line Usage:
-
-### 💡 Attribute Reference:
-
-*   **-p**: Specify target ports for scanning (single port or range). Note: Range specifications exclude the lower bound on the first entry. Example: To scan from port 80 to 443, define the range as `79-443`. Examples: `snake -p 80,443` or `snake -p 80,3437,8080,20-30,79-443`
-
-*   **-u**: Enable UDP port scanning. Example: `snake -p 53 -u`
-
-*   **-h**: Display the complete list of available command-line attributes and their descriptions. Example: `snake -h` or `snake -help`
-
-*   **-sp**: Initiate a scan using a predefined set of common ports with `ProcessPoolExecutor`. Example: `snake -sp`
-
-*   **-v**: Display the current version of the SnakeScan library. Example: `snake -v`
-
-*   **-gs**: Retrieve the SSL/TLS certificate from a specified web server. Example: `snake www.google.com -gs` (Requires a valid hostname to avoid connection errors.)
-
-*   **-t**: Enable multi-threading for enhanced scan performance. Example: `snake -t`
-
-*   **-ch**: Scan a subnet to discover active IP addresses on the network. Example: `snake -ch`
-
-*   **-l**: Display your public IP address (requires an active internet connection). Example: `snake -l`
-
-*   **-i**: Show detailed information about a specific IP address (supports both IPv4 and IPv6). Example: `snake www.google.com -i`
-
-## 💻 Python Code Integration:
-
-### ⏱️  Watcher Class: Real-Time Port Status
-
-The `Watcher` class facilitates continuous monitoring of a specified port.
-
-python
-
-from SnakeScan import Watcher
-
-watcher = Watcher("localhost", 53, 2)  # Host, port, check interval (in seconds)
-
-watcher.start()  # Begin monitoring!
-
-#### `Watcher` Methods:
-
-*   `Watcher.start()` - Initiate the port monitoring process.
-
-*   `Watcher.stop()` - Terminate the port monitoring process.
-
----
-
-**Latest Update:** 1.7.9 (Added full color output)

snakescan-1.7.9/SnakeScan/PoolExecutor.py

@@ -1,80 +0,0 @@
-import socket
-from termcolor import colored
-from concurrent.futures import ProcessPoolExecutor
-
-ports = {
-    20: "FTP-Data",
-    21: "FTP-Control",
-    22: "SSH",
-    23: "Telnet",
-    25: "SMTP",
-    43: "Whois",
-    53: "DNS",
-    70: "Gopher",
-    79: "FINGER",
-    80: "HTTP",
-    110: "POP3",
-    111: "RPC",
-    113: "ident",
-    115: "SFTP",
-    135: "MSRPC",
-    139: "NetBIOS-SSN",
-    143: "IMAP",
-    179: "BGP",
-    194: "IRC",
-    389: "LDAP",
-    443: "HTTPS",
-    445: "SMB",
-    465: "SMTPS",
-    587: "SMTP Submission",
-    631: "IPP",
-    636: "LDAPS",
-    873: "RSYNC",
-    993: "IMAPS",
-    995: "POP3S",
-    1080: "SOCKS",
-    1433: "SQL Server",
-    1521: "Oracle",
-    2082: "CPanel",
-    2083: "CPanel",
-    2222: "SSH",
-    3128: "HTTP Proxy",
-    3306: "MySQL",
-    3389: "RDP",
-    5432: "PostgreSQL",
-    5900: "VNC",
-    8000: "HTTP Alternate",
-    8080: "HTTP Alternate",
-    8443: "HTTPS Alternate",
-    8888: "HTTP Alternate",
-    10000: "Webmin",
-    27017: "MongoDB",
-}
-
-
-def is_port_open_threads(host, port):
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        try:
-            s.settimeout(1)
-            s.connect((host, port))
-        except (OSError, socket.timeout):
-            try:
-                print(
-                    f"Closed{colored('|X|','red')}-->{colored(ports.get(port),'light_red')}{colored(f'|{port}|','red')}"
-                )
-            except:
-                print(f"Closed{colored('|X|','red')}-->{colored(f'|{port}|','red')}")
-        else:
-            print(
-                f"Open{colored('|√|','green')}-->{colored(ports.get(port),'light_green')}{colored(f'|{port}|','green')}"
-            )
-
-
-def PoolProcessExecutor(host):
-    with ProcessPoolExecutor(max_workers=None) as executor:
-        try:
-            for port in ports.keys():
-                future = executor.submit(is_port_open_threads, host, port)
-
-        except Exception as e:
-            print(e)

snakescan-1.7.9/SnakeScan/Pool_UDP_Executor.py

@@ -1,84 +0,0 @@
-import socket
-from termcolor import colored
-from concurrent.futures import ProcessPoolExecutor
-
-ports = {
-    7: "ECHO",
-    9: "DISCARD",
-    13: "DAYTIME",
-    17: "QOTD (Quote of the Day)",
-    19: "CHARGEN (Character Generator)",
-    53: "DNS (Domain Name System)",
-    67: "DHCP Server",
-    68: "DHCP Client",
-    69: "TFTP (Trivial File Transfer Protocol)",
-    111: "RPC (Remote Procedure Call)",
-    123: "NTP (Network Time Protocol)",
-    137: "NetBIOS Name Service",
-    138: "NetBIOS Datagram Service",
-    161: "SNMP (Simple Network Management Protocol)",
-    162: "SNMP Trap",
-    443: "QUIC (Quick UDP Internet Connections)",
-    500: "ISAKMP (Internet Security Association and Key Management Protocol)",
-    520: "RIP (Routing Information Protocol)",
-    1434: "Microsoft SQL Server Dynamic Port Allocation",
-    4500: "IPsec NAT-Traversal (NAT-T)",
-    5353: "mDNS (Multicast DNS)",
-    5355: "LLMNR (Link-Local Multicast Name Resolution)",
-    1900: "SSDP (Simple Service Discovery Protocol)",
-    3478: "STUN (Session Traversal Utilities for NAT)",
-    5060: "SIP (Session Initiation Protocol)",
-    5061: "SIP (Session Initiation Protocol) (TLS)",
-    20777: "Garmin Training Center",
-    3074: "Xbox Live",
-    3479: "TURN (Traversal Using Relays around NAT)",
-    4126: "Muon",
-    50000: "Drone (Drone Protocol)",
-    60000: "RDP (Remote Desktop Protocol) over UDP",
-    5000: "fCoE (Fibre Channel over Ethernet)",
-    5001: "HP OpenView Operations Agent",
-    1719: "H.323 Gatekeeper RAS",
-    1720: "H.323 Call Signaling",
-    1812: "RADIUS authentication",
-    1813: "RADIUS accounting",
-    5222: "XMPP client connection",
-    5269: "XMPP server connection",
-}
-
-
-def is_port_open_threads(host, port, timeout=1):
-    try:
-        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        sock.settimeout(timeout)
-        message = b"Test UDP packet"
-        address = (host, port)
-
-        sock.sendto(message, address)
-
-        try:
-            data, server = sock.recvfrom(4096)
-            print(f"Response received: {data.decode()} from {server}")
-            print(
-                f"Open{colored('[√]','green')}-->{colored(ports.get(port),'light_green')}{colored(f'|{port}|','green')} may be listening on host"
-            )
-        except socket.timeout:
-            print(
-                f"Closed{colored('[X]','red')}-->{colored(ports.get(port),'light_red')}{colored(f'|{port}|','red')} is likely closed on host"
-            )
-        except ConnectionRefusedError:
-            print("An error occurred while scanning.")
-        sock.close()
-    except socket.gaierror:
-        print("Error: Unable to resolve host name.")
-    except socket.error as e:
-        print(f"Socket error: {e}")
-
-
-def PoolExecutorUDP(host):
-    with ProcessPoolExecutor(max_workers=None) as executor:
-        try:
-            for port in ports.keys():
-                future = executor.submit(is_port_open_threads, host, port)
-
-        except Exception as e:
-            print(e)