lanscape 2.1.0b1__tar.gz → 2.2.0a1__tar.gz

{lanscape-2.1.0b1/lanscape.egg-info → lanscape-2.2.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 2.1.0b1
+Version: 2.2.0a1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -25,9 +25,12 @@ Requires-Dist: scapy<3.0,>=2.3.2
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pydantic
 Requires-Dist: icmplib
+Requires-Dist: pwa-launcher
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
+Requires-Dist: openai>=1.0.0; extra == "dev"
 Dynamic: license-file
 
 # LANscape

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/lanscape/core/device_alive.py

@@ -12,8 +12,9 @@ import psutil
 from scapy.sendrecv import srp
 from scapy.layers.l2 import ARP, Ether
 from icmplib import ping
+from icmplib.exceptions import SocketPermissionError
 
-from lanscape.core.net_tools import Device
+from lanscape.core.net_tools import Device, DeviceError
 from lanscape.core.scan_config import (
     ScanConfig, ScanType, PingConfig,
     ArpConfig, PokeConfig, ArpCacheConfig
@@ -72,18 +73,84 @@ class IcmpLookup():
         Returns:
             bool: True if the device is reachable via ICMP, False otherwise.
         """
-        # Perform up to cfg.attempts rounds of ping(count=cfg.ping_count)
-        for _ in range(cfg.attempts):
-            result = ping(
-                device.ip,
-                count=cfg.ping_count,
-                interval=cfg.retry_delay,
-                timeout=cfg.timeout,
-                privileged=psutil.WINDOWS  # Use privileged mode on Windows
-            )
-            if result.is_alive:
-                device.alive = True
-                break
+        try:
+            # Try using icmplib first
+            for _ in range(cfg.attempts):
+                result = ping(
+                    device.ip,
+                    count=cfg.ping_count,
+                    interval=cfg.retry_delay,
+                    timeout=cfg.timeout,
+                    privileged=psutil.WINDOWS  # Use privileged mode on Windows
+                )
+                if result.is_alive:
+                    device.alive = True
+                    break
+            return device.alive is True
+        except SocketPermissionError:
+            # Fallback to system ping command when raw sockets aren't available
+            return cls._ping_fallback(device, cfg)
+
+    @classmethod
+    def _ping_fallback(cls, device: Device, cfg: PingConfig) -> bool:
+        """Fallback ping using system ping command via subprocess.
+
+        Args:
+            device (Device): The device to ping.
+            cfg (PingConfig): The ping configuration.
+
+        Returns:
+            bool: True if the device responds to ping, False otherwise.
+        """
+        cmd = []
+
+        if psutil.WINDOWS:
+            # -n count, -w timeout in ms
+            cmd = ['ping', '-n', str(cfg.ping_count), '-w', str(int(cfg.timeout * 1000)), device.ip]
+        else:  # Linux, macOS, and other Unix-like systems
+            # -c count, -W timeout in s
+            cmd = ['ping', '-c', str(cfg.ping_count), '-W', str(int(cfg.timeout)), device.ip]
+
+        for r in range(cfg.attempts):
+            try:
+                # Remove check=True to handle return codes manually
+                # Add timeout to prevent hanging
+                timeout_val = cfg.timeout * cfg.ping_count + 5
+                proc = subprocess.run(
+                    cmd,
+                    text=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    timeout=timeout_val,
+                    check=False  # Handle return codes manually
+                )
+
+                # Check if ping was successful
+                if proc.returncode == 0:
+                    output = proc.stdout.lower()
+
+                    # Windows/Linux both include "TTL" on a successful reply
+                    if psutil.WINDOWS or psutil.LINUX:
+                        if 'ttl' in output:
+                            device.alive = True
+                            return True  # Early return on success
+
+                    # some distributions of Linux and macOS
+                    if psutil.MACOS or psutil.LINUX:
+                        bad = '100.0% packet loss'
+                        good = 'ping statistics'
+                        # mac doesnt include TTL, so we check good is there, and bad is not
+                        if good in output and bad not in output:
+                            device.alive = True
+                            return True  # Early return on success
+
+            except (subprocess.CalledProcessError, subprocess.TimeoutExpired,
+                    FileNotFoundError) as e:
+                device.caught_errors.append(DeviceError(e))
+
+            if r < cfg.attempts - 1:
+                time.sleep(cfg.retry_delay)
+
         return device.alive is True
 
 

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/lanscape/core/net_tools.py

@@ -31,10 +31,10 @@ else:
 
 from lanscape.core.service_scan import scan_service
 from lanscape.core.mac_lookup import MacLookup, get_macs
-from lanscape.core.ip_parser import get_address_count, MAX_IPS_ALLOWED
+from lanscape.core.ip_parser import get_address_count, MAX_IPS_ALLOWED, parse_ip_input
 from lanscape.core.errors import DeviceError
 from lanscape.core.decorators import job_tracker, run_once, timeout_enforcer
-from lanscape.core.scan_config import ServiceScanConfig, PortScanConfig
+from lanscape.core.scan_config import ServiceScanConfig, PortScanConfig, ScanType
 
 log = logging.getLogger('NetTools')
 mac_lookup = MacLookup()
@@ -552,6 +552,56 @@ def smart_select_primary_subnet(subnets: List[dict] = None) -> str:
     return selected.get("subnet", "")
 
 
+def is_internal_block(subnet: str) -> bool:
+    """
+    Check if a subnet contains only internal/private IP addresses.
+
+    Supports CIDR notation, IP ranges, comma-separated lists, and single IPs.
+    For ranges and complex inputs, samples representative IPs for efficiency.
+
+    Args:
+        subnet: IP subnet string in various formats
+
+    Returns:
+        bool: True if all sampled IPs are private/internal, False otherwise
+    """
+    try:
+        # Handle comma-separated subnets recursively
+        if ',' in subnet:
+            return all(is_internal_block(part.strip()) for part in subnet.split(','))
+
+        # Handle CIDR notation directly
+        if '/' in subnet:
+            return ipaddress.IPv4Network(subnet, strict=False).is_private
+
+        # Handle ranges and single IPs by parsing and sampling
+        ip_list = parse_ip_input(subnet)
+        sample_ips = ([ip_list[0], ip_list[-1]] if len(ip_list) > 1 else ip_list)
+        return all(ipaddress.IPv4Address(ip).is_private for ip in sample_ips)
+
+    except (ValueError, ipaddress.AddressValueError):
+        return False  # Assume external for unparseable input
+
+
+def scan_config_uses_arp(config) -> bool:
+    """
+    Check if a scan configuration uses ARP-based scanning methods.
+
+    Args:
+        config: ScanConfig instance
+
+    Returns:
+        bool: True if the configuration uses ARP scanning, False otherwise
+    """
+    arp_scan_types = {
+        ScanType.ARP_LOOKUP,
+        ScanType.POKE_THEN_ARP,
+        ScanType.ICMP_THEN_ARP
+    }
+
+    return any(scan_type in arp_scan_types for scan_type in config.lookup_type)
+
+
 @run_once
 def is_arp_supported():
     """

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/lanscape/core/subnet_scan.py

@@ -22,7 +22,9 @@ from tabulate import tabulate
 # Local imports
 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.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
 
@@ -301,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]:
         """
@@ -385,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-2.1.0b1 → lanscape-2.2.0a1}/lanscape/ui/main.py

@@ -8,6 +8,9 @@ import logging
 import traceback
 import os
 import requests
+from subprocess import Popen
+
+from pwa_launcher import open_pwa
 
 from lanscape.core.logger import configure_logging
 from lanscape.core.runtime_args import parse_args
@@ -70,7 +73,7 @@ def try_check_update():
         log.warning('Unable to check for updates.')
 
 
-def open_browser(url: str, wait=2) -> bool:
+def open_browser(url: str, wait=2) -> Popen:
     """
     Open a browser window to the specified
     url after waiting for the server to start
@@ -78,12 +81,12 @@ def open_browser(url: str, wait=2) -> bool:
     try:
         time.sleep(wait)
         log.info(f'Starting UI - http://127.0.0.1:{args.port}')
-        return open_webapp(url)
+        return open_pwa(url)
 
     except BaseException:
         log.debug(traceback.format_exc())
         log.info(f'Unable to open web browser, server running on {url}')
-    return False
+    return None
 
 
 def start_webserver_ui():
@@ -97,19 +100,17 @@ def start_webserver_ui():
         # if it was, dont open the browser again
         log.info('Opening UI as daemon')
         if not IS_FLASK_RELOAD:
-            threading.Thread(
-                target=open_browser,
-                args=(uri,),
-                daemon=True
-            ).start()
+            open_browser(uri)
         start_webserver(args)
     else:
         flask_thread = start_webserver_daemon(args)
-        app_closed = open_browser(uri)
+        proc = open_browser(uri)
+        
+        if proc:
+            app_closed = proc.wait()
+        else:
+            app_closed = False
 
-        # depending on env, open_browser may or
-        # may not be coupled with the closure of UI
-        # (if in browser tab, it's uncoupled)
         if not app_closed or args.persistent:
             # not doing a direct join so i can still
             # terminate the app with ctrl+c

{lanscape-2.1.0b1 → lanscape-2.2.0a1/lanscape.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 2.1.0b1
+Version: 2.2.0a1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -25,9 +25,12 @@ Requires-Dist: scapy<3.0,>=2.3.2
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pydantic
 Requires-Dist: icmplib
+Requires-Dist: pwa-launcher
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
+Requires-Dist: openai>=1.0.0; extra == "dev"
 Dynamic: license-file
 
 # LANscape

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/lanscape.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ lanscape/ui/templates/scan/scan-error.html
 tests/test_api.py
 tests/test_decorators.py
 tests/test_env.py
+tests/test_globals.py
 tests/test_library.py
 tests/test_logging.py
 tests/test_port_scan.py

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/lanscape.egg-info/requires.txt

@@ -6,7 +6,10 @@ scapy<3.0,>=2.3.2
 tabulate==0.9.0
 pydantic
 icmplib
+pwa-launcher
 
 [dev]
 pytest>=8.0
 pytest-cov>=5.0
+pytest-xdist>=3.0
+openai>=1.0.0

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lanscape"
-version = "2.1.0b1"
+version = "2.2.0a1"
 authors = [
   { name="Michael Dennis", email="michael@dipduo.com" },
 ]
@@ -27,13 +27,16 @@ dependencies = [
     "scapy>=2.3.2,<3.0",
     "tabulate==0.9.0",
     "pydantic",
-    "icmplib"
+    "icmplib",
+    "pwa-launcher"
 ]
 
 [project.optional-dependencies]
 dev = [
     "pytest>=8.0",
-    "pytest-cov>=5.0"
+    "pytest-cov>=5.0",
+    "pytest-xdist>=3.0",
+    "openai>=1.0.0"
 ]
 [project.urls]
 Homepage = "https://github.com/mdennis281/py-lanscape"

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/tests/test_api.py

@@ -8,10 +8,13 @@ from unittest.mock import patch
 
 import pytest
 
-from lanscape.ui.app import app
-from lanscape.core.net_tools import get_network_subnet
 
-from tests._helpers import right_size_subnet
+from tests.test_globals import (
+    TEST_SUBNET,
+    MIN_EXPECTED_RUNTIME,
+    MIN_EXPECTED_ALIVE_DEVICES
+)
+from lanscape.ui.app import app
 
 
 @pytest.fixture
@@ -36,9 +39,10 @@ def updated_port_list():
 def test_scan_config():
     """Create a test scan configuration."""
     return {
-        'subnet': right_size_subnet(get_network_subnet()),
+        'subnet': TEST_SUBNET,
         'port_list': 'test_port_list_scan',
-        'lookup_type': ['POKE_THEN_ARP']
+        'lookup_type': ['ICMP','POKE_THEN_ARP'],  # Use ICMP for reliable external IP detection
+        'ping_config': {'timeout': 0.8, 'attempts': 2}  # Reasonable timeout for external IPs
     }
 
 # API Port Management Tests
@@ -236,6 +240,13 @@ def test_scan_api_async(api_client, test_scan_config):
     """
     Test the full scan API lifecycle with progress monitoring
     """
+
+    def _get_scan_response(scan_id):
+        """Consolidated method to get scan response."""
+        response = api_client.get(f'/api/scan/{scan_id}/summary')
+        assert response.status_code == 200
+        return json.loads(response.data)
+
     # Create the port list first (since test_scan_config references it)
     sample_port_list = {'80': 'http', '443': 'https'}
     api_client.post('/api/port/list/test_port_list_scan', json=sample_port_list)
@@ -255,9 +266,7 @@ def test_scan_api_async(api_client, test_scan_config):
 
     while percent_complete < 100 and iteration < max_iterations:
         # Get scan summary
-        response = api_client.get(f'/api/scan/{scan_id}/summary')
-        assert response.status_code == 200
-        summary = json.loads(response.data)
+        summary = _get_scan_response(scan_id)
         assert summary['running'] or summary['stage'] == 'complete'
 
         percent_complete = summary['percent_complete']
@@ -270,12 +279,15 @@ def test_scan_api_async(api_client, test_scan_config):
             time.sleep(2)
         iteration += 1
 
+    time.sleep(1)
+    summary = _get_scan_response(scan_id)
+
     # Verify final scan state
     assert not summary['running']
     assert summary['stage'] == 'complete'
-    assert summary['runtime'] > 0
+    assert summary['runtime'] >= MIN_EXPECTED_RUNTIME  # Should take measurable time for network ops
 
     # Validate device counts
     devices = summary['devices']
     assert devices['scanned'] == devices['total']
-    assert devices['alive'] > 0
+    assert MIN_EXPECTED_ALIVE_DEVICES <= devices['alive']

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/tests/test_decorators.py

@@ -287,12 +287,12 @@ def test_job_tracker_multiple_different_functions():
 
     @job_tracker
     def function_a():
-        time.sleep(0.01)
+        time.sleep(0.1)
         return "a"
 
     @job_tracker
     def function_b():
-        time.sleep(0.02)
+        time.sleep(0.3)
         return "b"
 
     function_a()

lanscape-2.2.0a1/tests/test_globals.py

@@ -0,0 +1,10 @@
+"""
+Globals for tests in the LANscape project.
+Provides shared configuration values used across multiple test files.
+"""
+
+from tests._helpers import right_size_subnet
+
+TEST_SUBNET = f"1.1.1.1/28, {right_size_subnet()}"
+MIN_EXPECTED_RUNTIME = 0.2
+MIN_EXPECTED_ALIVE_DEVICES = 5

{lanscape-2.1.0b1 → lanscape-2.2.0a1}/tests/test_library.py

@@ -9,7 +9,11 @@ from lanscape.core.net_tools import smart_select_primary_subnet
 from lanscape.core.subnet_scan import ScanManager
 from lanscape.core.scan_config import ScanConfig, ScanType
 
-from tests._helpers import right_size_subnet
+from tests.test_globals import (
+    TEST_SUBNET,
+    MIN_EXPECTED_RUNTIME,
+    MIN_EXPECTED_ALIVE_DEVICES
+)
 
 
 @pytest.fixture
@@ -57,21 +61,33 @@ def test_scan_config():
     assert cfg2.lookup_type == [ScanType.POKE_THEN_ARP]
 
 
-@pytest.mark.integration
-@pytest.mark.slow
-def test_scan(scan_manager):
+def test_smart_select_primary_subnet():
     """
-    Test the network scanning functionality with a dynamically selected subnet.
-    Verifies that devices can be discovered and that scan results are valid.
+    Test the smart_select_primary_subnet functionality without running actual scans.
+    Verifies that the subnet detection works on the current system.
     """
     subnet = smart_select_primary_subnet()
     assert subnet is not None
+    assert '/' in subnet  # Should be in CIDR format
+    # Verify it's a valid subnet format
+    parts = subnet.split('/')
+    assert len(parts) == 2
+    assert int(parts[1]) <= 32  # Valid CIDR mask
 
+
+@pytest.mark.integration
+@pytest.mark.slow
+def test_scan(scan_manager):
+    """
+    Test the network scanning functionality with a fixed external subnet.
+    Verifies that the scan engine works correctly with external public IPs.
+    """
     cfg = ScanConfig(
-        subnet=right_size_subnet(subnet),
-        t_multiplier=1.0,
+        subnet=TEST_SUBNET,
         port_list='small',
-        lookup_type=[ScanType.POKE_THEN_ARP]
+        lookup_type=[ScanType.ICMP, ScanType.POKE_THEN_ARP],
+        t_cnt_isalive=2,   # Limit threads to extend runtime
+        ping_config={'timeout': 0.8, 'attempts': 2}  # Reasonable timeout for external IPs
     )
     scan = scan_manager.new_scan(cfg)
     assert scan.running
@@ -101,8 +117,13 @@ def test_scan(scan_manager):
         # device must be alive to be in this list
         assert d.alive
 
-    # find at least one device
-    assert len(scan.results.devices) > 0
-
-    # ensure everything got scanned
+    # For external IPs, we may not find responsive devices but scan should complete
+    # The main goal is to test that the scan engine works correctly
     assert scan.results.devices_scanned == scan.results.devices_total
+
+    # Verify scan took measurable time (should be > 0 for real network operations)
+    assert scan.results.get_runtime() >= MIN_EXPECTED_RUNTIME
+
+    # For external ranges, alive device count should be within expected bounds
+    alive_count = len([d for d in scan.results.devices if d.alive])
+    assert MIN_EXPECTED_ALIVE_DEVICES <= alive_count