lanscape 1.4.4__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

lanscape/{libraries → core}/scan_config.py

@@ -11,8 +11,8 @@ from enum import Enum
 
 from pydantic import BaseModel, Field
 
-from lanscape.libraries.port_manager import PortManager
-from lanscape.libraries.ip_parser import parse_ip_input
+from lanscape.core.port_manager import PortManager
+from lanscape.core.ip_parser import parse_ip_input
 
 
 class PingConfig(BaseModel):
@@ -154,6 +154,87 @@ class PokeConfig(BaseModel):
         return self.model_dump()
 
 
+class ServiceScanStrategy(Enum):
+    """
+    Enumeration of strategies for service scanning on open ports.
+
+    LAZY: Several common probes to see if we can identify the service.
+    BASIC: Common probes plus probes correlated to the port number.
+    AGGRESSIVE: All known probes in parallel to try to elicit a response.
+    """
+    LAZY = 'LAZY'
+    BASIC = 'BASIC'
+    AGGRESSIVE = 'AGGRESSIVE'
+
+
+class ServiceScanConfig(BaseModel):
+    """
+    Configuration for service scanning on open ports.
+    """
+    timeout: float = 5.0
+    lookup_type: ServiceScanStrategy = ServiceScanStrategy.BASIC
+    max_concurrent_probes: int = 10
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ServiceScanConfig':
+        """
+        Create a ServiceScanConfig instance from a dictionary.
+
+        Args:
+            data: Dictionary containing ServiceScanConfig parameters
+
+        Returns:
+            A new ServiceScanConfig instance with the provided settings
+        """
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the ServiceScanConfig instance to a dictionary.
+
+        Returns:
+            Dictionary representation of the ServiceScanConfig
+        """
+        return self.model_dump()
+
+    def __str__(self):
+        return f'ServiceScanCfg(timeout={self.timeout})'
+
+
+class PortScanConfig(BaseModel):
+    """
+    Configuration for port scanning.
+    """
+    timeout: float = 1.0
+    retries: int = 0
+    retry_delay: float = 0.1
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'PortScanConfig':
+        """
+        Create a PortScanConfig instance from a dictionary.
+
+        Args:
+            data: Dictionary containing PortScanConfig parameters
+
+        Returns:
+            A new PortScanConfig instance with the provided settings
+        """
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the PortScanConfig instance to a dictionary.
+
+        Returns:
+            Dictionary representation of the PortScanConfig
+        """
+        return self.model_dump()
+
+    def __str__(self):
+        return f'PortScanCfg(timeout={self.timeout}, retry_delay={self.retry_delay})'
+
+
 class ScanType(Enum):
     """
     Enumeration of supported network scan types.
@@ -184,7 +265,7 @@ class ScanConfig(BaseModel):
 
     task_scan_ports: bool = True
     # below wont run if above false
-    task_scan_port_services: bool = False  # disabling until more stable
+    task_scan_port_services: bool = True
 
     lookup_type: List[ScanType] = [ScanType.ICMP_THEN_ARP]
 
@@ -192,6 +273,8 @@ class ScanConfig(BaseModel):
     arp_config: ArpConfig = Field(default_factory=ArpConfig)
     poke_config: PokeConfig = Field(default_factory=PokeConfig)
     arp_cache_config: ArpCacheConfig = Field(default_factory=ArpCacheConfig)
+    port_scan_config: PortScanConfig = Field(default_factory=PortScanConfig)
+    service_scan_config: ServiceScanConfig = Field(default_factory=ServiceScanConfig)
 
     def t_cnt(self, thread_id: str) -> int:
         """
@@ -259,7 +342,7 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
         t_cnt_port_test=64,
         t_cnt_isalive=64,
         task_scan_ports=True,
-        task_scan_port_services=False,
+        task_scan_port_services=True,
         lookup_type=[ScanType.ICMP_THEN_ARP, ScanType.ARP_LOOKUP],
         arp_config=ArpConfig(
             attempts=3,
@@ -274,6 +357,16 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
         arp_cache_config=ArpCacheConfig(
             attempts=2,
             wait_before=0.3
+        ),
+        port_scan_config=PortScanConfig(
+            timeout=2.5,
+            retries=1,
+            retry_delay=0.2
+        ),
+        service_scan_config=ServiceScanConfig(
+            timeout=8.0,
+            lookup_type=ServiceScanStrategy.AGGRESSIVE,
+            max_concurrent_probes=5
         )
     ),
     'fast': ScanConfig(
@@ -283,7 +376,7 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
         t_cnt_port_test=256,
         t_cnt_isalive=512,
         task_scan_ports=True,
-        task_scan_port_services=False,
+        task_scan_port_services=True,
         lookup_type=[ScanType.POKE_THEN_ARP],
         arp_config=ArpConfig(
             attempts=1,
@@ -294,6 +387,12 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
             ping_count=1,
             timeout=0.5,
             retry_delay=0.25
+        ),
+        service_scan_config=ServiceScanConfig(
+            timeout=2.0,
+            lookup_type=ServiceScanStrategy.LAZY,
+            max_concurrent_probes=15
         )
     )
 }
+

lanscape/core/service_scan.py

@@ -0,0 +1,205 @@
+"""Service scanning module for identifying services running on network ports.
+"""
+
+from typing import Optional, Union
+import sys
+import asyncio
+import logging
+import traceback
+
+from lanscape.core.app_scope import ResourceManager
+from lanscape.core.scan_config import ServiceScanConfig, ServiceScanStrategy
+
+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.
+    """
+
+    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"
+
+    # Use asyncio.run to execute the asynchronous logic synchronously
+    return asyncio.run(_async_scan_service(ip, port, cfg=cfg))
+
+
+def asyncio_logger_suppression():
+    """Suppress the noisy asyncio transport errors since they are expected in service scanning."""
+
+    # Reduce noisy asyncio transport errors on Windows by switching to Selector policy
+    if sys.platform.startswith("win"):
+        try:
+            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+        except Exception:
+            pass
+    # Also tone down asyncio logger noise from transport callbacks
+    try:
+        logging.getLogger("asyncio").setLevel(logging.WARNING)
+    except Exception:
+        pass
+
+
+asyncio_logger_suppression()
+

lanscape/{libraries → core}/subnet_scan.py

@@ -20,11 +20,11 @@ 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
+from lanscape.core.errors import SubnetScanTerminationFailure
+from lanscape.core.device_alive import is_device_alive
 
 
 class SubnetScanner():
@@ -62,7 +62,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 +190,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 +202,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 +214,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 +232,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 +270,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
@@ -421,3 +428,4 @@ class ScanManager:
         t = threading.Thread(target=scan.start)
         t.start()
         return t
+

lanscape/{libraries → core}/version_manager.py

@@ -11,8 +11,8 @@ from random import randint
 
 import requests
 
-from lanscape.libraries.app_scope import is_local_run
-from lanscape.libraries.decorators import run_once
+from lanscape.core.app_scope import is_local_run
+from lanscape.core.decorators import run_once
 
 log = logging.getLogger('VersionManager')
 
@@ -95,3 +95,4 @@ def get_installed_version(package=PACKAGE):
             log.debug(traceback.format_exc())
             log.warning(f'Cannot find {package} installation')
     return LOCAL_VERSION
+

lanscape/{libraries → core}/web_browser.py

@@ -208,3 +208,4 @@ def windows_get_browser_from_registry() -> Optional[str]:
     system_browser = get_system_default_browser()
     if system_browser:
         return extract_executable(system_browser)
+

lanscape/resources/mac_addresses/convert_csv.py

@@ -39,3 +39,4 @@ def csv_to_dict(data):
 
 
 main()
+

lanscape/resources/ports/convert_csv.py

@@ -38,3 +38,4 @@ def csv_to_dict(data):
 
 
 main()
+