lanscape 1.3.8a1__py3-none-any.whl → 2.4.0a2__py3-none-any.whl

lanscape/core/service_scan.py

@@ -0,0 +1,222 @@
+"""Service scanning module for identifying services running on network ports.
+"""
+
+from typing import Optional, Union
+import asyncio
+import logging
+import traceback
+
+from lanscape.core.app_scope import ResourceManager
+from lanscape.core.scan_config import ServiceScanConfig, ServiceScanStrategy
+
+# asyncio complains more than it needs to
+logging.getLogger("asyncio").setLevel(logging.WARNING)
+
+log = logging.getLogger('ServiceScan')
+SERVICES = ResourceManager('services').get_jsonc('definitions.jsonc')
+
+# skip printer ports because they cause blank pages to be printed
+PRINTER_PORTS = [9100, 631]
+
+
+async def _try_probe(
+    ip: str,
+    port: int,
+    payload: Optional[Union[str, bytes]] = None,
+    *,
+    timeout: float = 5.0,
+    read_len: int = 1024,
+) -> Optional[str]:
+    """
+    Open a connection, optionally send a payload, and read a single response chunk.
+    Returns the decoded response string or None.
+    """
+    try:
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_connection(ip, port), timeout=timeout
+        )
+        try:
+            if payload is not None:
+                data = payload if isinstance(
+                    payload, (bytes, bytearray)) else str(payload).encode(
+                    "utf-8", errors="ignore")
+                writer.write(data)
+                await writer.drain()
+            try:
+                response = await asyncio.wait_for(reader.read(read_len), timeout=timeout / 2)
+            except asyncio.TimeoutError:
+                response = b""
+            resp_str = response.decode("utf-8", errors="ignore") if response else ""
+            return resp_str if resp_str else None
+        finally:
+            # Guarded close to avoid surfacing connection-lost noise
+            try:
+                writer.close()
+            except Exception:
+                pass
+            try:
+                await asyncio.wait_for(writer.wait_closed(), timeout=0.5)
+            except Exception:
+                pass
+    except Exception as e:
+        # Suppress common/expected network errors that simply indicate no useful banner
+        expected_types = (ConnectionResetError, ConnectionRefusedError, TimeoutError, OSError)
+        expected_errnos = {10054, 10061, 10060}  # reset, refused, timeout (Win specific)
+        eno = getattr(e, 'errno', None)
+        if isinstance(e, expected_types) and (eno in expected_errnos or eno is None):
+            return None
+        log.debug(f"Probe error on {ip}:{port} - {repr(e)}")
+        return None
+
+
+async def _multi_probe_generic(
+    ip: str, port: int, cfg: ServiceScanConfig
+) -> Optional[str]:
+    """
+    Run a small set of generic probes in parallel and return the first non-empty response.
+    """
+    probes = get_port_probes(port, cfg.lookup_type)
+
+    semaphore = asyncio.Semaphore(cfg.max_concurrent_probes)
+
+    async def limited_probe(ip, port, payload, timeout_val):
+        async with semaphore:
+            return await _try_probe(
+                ip, port, payload,
+                timeout=timeout_val
+            )
+
+    tasks = [
+        asyncio.create_task(
+            limited_probe(ip, port, p, cfg.timeout)
+        )
+        for p in probes
+    ]
+
+    try:
+        for fut in asyncio.as_completed(tasks, timeout=cfg.timeout):
+            try:
+                resp = await fut
+            except Exception:
+                resp = None
+            if resp and resp.strip():
+                # Cancel remaining tasks
+                for t in tasks:
+                    if not t.done():
+                        t.cancel()
+                return resp
+    except asyncio.TimeoutError:
+        pass
+    finally:
+        # Ensure remaining tasks are cancelled and awaited to suppress warnings
+        for t in tasks:
+            if not t.done():
+                t.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+    return None
+
+
+def get_port_probes(port: int, strategy: ServiceScanStrategy):
+    """
+    Return a list of probe payloads based on the port and strategy.
+    """
+    # For now, we use generic probes for all ports.
+    # This can be extended to use specific probes per port/service.
+
+    probes = [
+        None,  # banner-first protocols (SSH/FTP/SMTP/etc.)
+        b"\r\n",  # nudge for many line-oriented services
+        b"HELP\r\n",  # sometimes yields usage/help (SMTP/POP/IMAP-ish)
+        b"OPTIONS * HTTP/1.0\r\n\r\n",  # elicit Server header without path
+        b"HEAD / HTTP/1.0\r\n\r\n",  # basic HTTP
+        b"QUIT\r\n",  # graceful close if understood
+    ]
+
+    if strategy == ServiceScanStrategy.LAZY:
+        return probes
+
+    if strategy == ServiceScanStrategy.BASIC:
+        for _, detail in SERVICES.items():
+            if port in detail.get("ports", []):
+                if probe := detail.get("probe", ''):
+                    probes.append(probe)
+        return probes
+
+    if strategy == ServiceScanStrategy.AGGRESSIVE:
+        for _, detail in SERVICES.items():
+            if probe := detail.get("probe", ''):
+                probes.append(probe)
+        return probes
+
+    return [None]  # Default to banner grab only
+
+
+def scan_service(ip: str, port: int, cfg: ServiceScanConfig) -> str:
+    """
+    Synchronous function that attempts to identify the service 
+    running on a given port.
+    TODO: This is AI slop and needs to be reworked properly.
+    """
+
+    async def _async_scan_service(
+        ip: str, port: int,
+        cfg: ServiceScanConfig
+    ) -> str:
+        if port in PRINTER_PORTS:
+            return "Printer"
+
+        try:
+            # Run multiple generic probes concurrently and take first useful response
+            response_str = await _multi_probe_generic(ip, port, cfg)
+            if not response_str:
+                return "Unknown"
+
+            log.debug(f"Service scan response from {ip}:{port} - {response_str}")
+
+            # Analyze the response to identify the service
+            for service, config in SERVICES.items():
+                if any(hint.lower() in response_str.lower() for hint in config.get("hints", [])):
+                    return service
+        except asyncio.TimeoutError:
+            log.warning(f"Timeout scanning {ip}:{port}")
+        except Exception as e:
+            log.error(f"Error scanning {ip}:{port}: {str(e)}")
+            log.debug(traceback.format_exc())
+        return "Unknown"
+
+    # Create and properly manage event loop to avoid file descriptor leaks
+    # Using new_event_loop + explicit close is safer in threaded environments
+    # than asyncio.run() which can leave resources open under heavy load
+    loop = None
+    try:
+        try:
+            # Try to get existing loop first (if running in async context)
+            loop = asyncio.get_running_loop()
+            # If we're already in an async context, just await directly
+            return asyncio.run_coroutine_threadsafe(
+                _async_scan_service(ip, port, cfg=cfg), loop
+            ).result(timeout=cfg.timeout + 5)
+        except RuntimeError:
+            # No running loop, create a new one
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                return loop.run_until_complete(_async_scan_service(ip, port, cfg=cfg))
+            finally:
+                # Clean up the loop properly
+                try:
+                    # Cancel all remaining tasks
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+                    # Run loop once more to process cancellations
+                    if pending:
+                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+                except Exception:
+                    pass
+                finally:
+                    loop.close()
+    except Exception as e:
+        log.error(f"Event loop error scanning {ip}:{port}: {e}")
+        return "Unknown"

lanscape/{libraries → core}/subnet_scan.py

@@ -20,11 +20,13 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from tabulate import tabulate
 
 # Local imports
-from lanscape.libraries.scan_config import ScanConfig
-from lanscape.libraries.decorators import job_tracker, terminator, JobStats
-from lanscape.libraries.net_tools import Device
-from lanscape.libraries.errors import SubnetScanTerminationFailure
-from lanscape.libraries.device_alive import is_device_alive
+from lanscape.core.scan_config import ScanConfig
+from lanscape.core.decorators import job_tracker, terminator, JobStats
+from lanscape.core.net_tools import (
+    Device, is_internal_block, scan_config_uses_arp
+)
+from lanscape.core.errors import SubnetScanTerminationFailure
+from lanscape.core.device_alive import is_device_alive
 
 
 class SubnetScanner():
@@ -62,7 +64,10 @@ class SubnetScanner():
         """
         self._set_stage('scanning devices')
         self.running = True
-        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('isalive')) as executor:
+        with ThreadPoolExecutor(
+                max_workers=self.cfg.t_cnt('isalive'),
+                thread_name_prefix="DeviceAlive") as executor:
+
             futures = {executor.submit(self._get_host_details, str(
                 ip)): str(ip) for ip in self.subnet}
             for future in as_completed(futures):
@@ -187,7 +192,7 @@ class SubnetScanner():
         """
         Get the MAC address and open ports of the given host.
         """
-        device = Device(host)
+        device = Device(ip=host)
         device.alive = self._ping(device)
         self.results.scanned()
         if not device.alive:
@@ -199,7 +204,8 @@ class SubnetScanner():
 
     @terminator
     def _scan_network_ports(self):
-        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('port_scan')) as executor:
+        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('port_scan'),
+                                thread_name_prefix="DevicePortScanParent") as executor:
             futures = {executor.submit(
                 self._scan_ports, device): device for device in self.results.devices}
             for future in futures:
@@ -210,7 +216,9 @@ class SubnetScanner():
     def _scan_ports(self, device: Device):
         self.log.debug(f'[{device.ip}] Initiating port scan')
         device.stage = 'scanning'
-        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('port_test')) as executor:
+        with ThreadPoolExecutor(
+                max_workers=self.cfg.t_cnt('port_test'),
+                thread_name_prefix=f"{device.ip}-PortScan") as executor:
             futures = {executor.submit(self._test_port, device, int(
                 port)): port for port in self.ports}
             for future in futures:
@@ -226,9 +234,9 @@ class SubnetScanner():
         If port open, determine service.
         Device class handles tracking open ports.
         """
-        is_alive = host.test_port(port)
+        is_alive = host.test_port(port, self.cfg.port_scan_config)
         if is_alive and self.cfg.task_scan_port_services:
-            host.scan_service(port)
+            host.scan_service(port, self.cfg.service_scan_config)
         return is_alive
 
     @terminator
@@ -264,6 +272,7 @@ class ScannerResults:
         # Scan statistics
         self.devices_total: int = len(list(scan.subnet))
         self.devices_scanned: int = 0
+        self.port_list_length: int = len(scan.ports)
         self.devices: List[Device] = []
 
         # Status tracking
@@ -294,11 +303,11 @@ class ScannerResults:
         Calculate the runtime of the scan in seconds.
 
         Returns:
-            int: Runtime in seconds
+            float: Runtime in seconds
         """
         if self.scan.running:
-            return int(time() - self.start_time)
-        return int(self.end_time - self.start_time)
+            return time() - self.start_time
+        return self.end_time - self.start_time
 
     def export(self, out_type=dict) -> Union[str, dict]:
         """
@@ -378,6 +387,13 @@ class ScanManager:
         Returns:
             SubnetScanner: The newly created scan instance
         """
+        if not is_internal_block(config.subnet) and scan_config_uses_arp(config):
+            self.log.warning(
+                f"ARP scanning detected for external subnet '{config.subnet}'. "
+                "ARP requests typically only work within the local network segment. "
+                "Consider using ICMP scanning for external IP ranges."
+            )
+
         scan = SubnetScanner(config)
         self._start(scan)
         self.log.info(f'Scan started - {config}')

lanscape/{libraries → core}/version_manager.py

@@ -11,16 +11,14 @@ from random import randint
 
 import requests
 
-from .app_scope import is_local_run
+from lanscape.core.app_scope import is_local_run
+from lanscape.core.decorators import run_once
 
 log = logging.getLogger('VersionManager')
 
 PACKAGE = 'lanscape'
 LOCAL_VERSION = '0.0.0'
 
-# Used to cache PyPI version during runtime
-LATEST_VERSION = None
-
 
 def is_update_available(package=PACKAGE) -> bool:
     """
@@ -49,6 +47,7 @@ def is_update_available(package=PACKAGE) -> bool:
     return installed != available
 
 
+@run_once
 def lookup_latest_version(package=PACKAGE):
     """
     Retrieve the latest version of the package from PyPI.
@@ -62,19 +61,18 @@ def lookup_latest_version(package=PACKAGE):
         The latest version string from PyPI or None if retrieval fails
     """
     # Fetch the latest version from PyPI
-    global LATEST_VERSION  # pylint: disable=global-statement
-    if not LATEST_VERSION:
-        no_cache = f'?cachebust={randint(0, 6969)}'
-        url = f"https://pypi.org/pypi/{package}/json{no_cache}"
-        try:
-            response = requests.get(url, timeout=5)
-            response.raise_for_status()  # Raise an exception for HTTP errors
-            LATEST_VERSION = response.json()['info']['version']
-            log.debug(f'Latest pypi version: {LATEST_VERSION}')
-        except BaseException:
-            log.debug(traceback.format_exc())
-            log.warning('Unable to fetch package version from PyPi')
-    return LATEST_VERSION
+    no_cache = f'?cachebust={randint(0, 6969)}'
+    url = f"https://pypi.org/pypi/{package}/json{no_cache}"
+    try:
+        response = requests.get(url, timeout=3)
+        response.raise_for_status()  # Raise an exception for HTTP errors
+        latest_version = response.json()['info']['version']
+        log.debug(f'Latest pypi version: {latest_version}')
+        return latest_version
+    except BaseException:
+        log.debug(traceback.format_exc())
+        log.warning('Unable to fetch package version from PyPi')
+        return None
 
 
 def get_installed_version(package=PACKAGE):

lanscape/resources/ports/test_port_list_scan.json

@@ -0,0 +1,4 @@
+{
+  "443": "https",
+  "80": "http"
+}