310 lines
13 KiB
Python
310 lines
13 KiB
Python
|
import ipaddress
|
|||
|
|
import socket
|
|||
|
|
import subprocess
|
|||
|
|
import threading
|
|||
|
|
import concurrent.futures
|
|||
|
|
from typing import List, Set, Union, Dict
|
|||
|
|
import time
|
|||
|
|
import os
|
|||
|
|
from urllib.parse import urlparse
|
|||
|
|
from collections import defaultdict # 导入 defaultdict 以简化camera_lock下的操作
|
|||
|
|
|
|||
|
|
# --- Global Variables for thread-safe access ---
|
|||
|
|
active_ips: Set[str] = set()
|
|||
|
|
found_cameras: Dict[str, Dict[str, str]] = defaultdict(dict) # 使用defaultdict，简化内层字典的初始化
|
|||
|
|
ip_lock = threading.Lock()
|
|||
|
|
camera_lock = threading.Lock()
|
|||
|
|
|
|||
|
|
# --- Configuration ---
|
|||
|
|
MAX_WORKERS = 100 # Number of concurrent threads for scanning
|
|||
|
|
COMMON_CAMERA_PORTS = [
|
|||
|
|
80, # HTTP (web interface)
|
|||
|
|
443, # HTTPS (secure web interface)
|
|||
|
|
554, # RTSP (Real Time Streaming Protocol)
|
|||
|
|
8000, # Often used by Hikvision (SDK/HTTP)
|
|||
|
|
8080, # Alternative HTTP/RTSP
|
|||
|
|
8001, # Hikvision stream port
|
|||
|
|
37777, # Dahua primary port
|
|||
|
|
37778, # Dahua secondary port
|
|||
|
|
8002, # Often used for camera APIs or secondary streams
|
|||
|
|
# Add more ports if you know specific ones for your camera brands
|
|||
|
|
]
|
|||
|
|
|
|||
|
|
SSH_PORTS = [22] # Potential SSH access for some cameras
|
|||
|
|
|
|||
|
|
# --- Imports for ONVIF Discovery ---
|
|||
|
|
ONVIF_AVAILABLE = False
|
|||
|
|
try:
|
|||
|
|
import psutil # For getting all network interfaces
|
|||
|
|
import onvif # The package 'onvif-zeep' installs the 'onvif' module
|
|||
|
|
# Attempt to import specific discovery module first, as it's the intended way.
|
|||
|
|
# If this fails, the ONVIF_AVAILABLE flag will be set to False.
|
|||
|
|
try:
|
|||
|
|
from onvif import discovery
|
|||
|
|
_discovery_method = discovery.find_device
|
|||
|
|
print("ONVIF: Using onvif.discovery.find_device for discovery.")
|
|||
|
|
except (ImportError, AttributeError):
|
|||
|
|
# Fallback: check if the top-level 'onvif' module has a discover method
|
|||
|
|
if hasattr(onvif, 'discover') and callable(onvif.discover):
|
|||
|
|
_discovery_method = onvif.discover
|
|||
|
|
print("ONVIF: Using top-level onvif.discover() for discovery.")
|
|||
|
|
else:
|
|||
|
|
_discovery_method = None
|
|||
|
|
print("ONVIF: No suitable ONVIF discovery method found in 'onvif' module.")
|
|||
|
|
raise ImportError("No ONVIF discovery method.") # Force into the outer except block
|
|||
|
|
|
|||
|
|
ONVIF_AVAILABLE = True
|
|||
|
|
except ImportError as e:
|
|||
|
|
print(f"Warning: Required libraries for full ONVIF functionality could not be imported.")
|
|||
|
|
print(f" Error: {e}")
|
|||
|
|
print(f" Please ensure 'psutil' and 'onvif-zeep' are installed:")
|
|||
|
|
print(f" pip install psutil onvif-zeep")
|
|||
|
|
print(f" ONVIF discovery will be skipped.")
|
|||
|
|
# If psutil is not available, we can still do single network scanning later
|
|||
|
|
try:
|
|||
|
|
import psutil
|
|||
|
|
except ImportError:
|
|||
|
|
psutil = None # Mark psutil as not available
|
|||
|
|
_discovery_method = None # Ensure it's None if ONVIF is unavailable
|
|||
|
|
|
|||
|
|
|
|||
|
|
# --- Imports for SSH service detection ---
|
|||
|
|
PARAMIKO_AVAILABLE = False
|
|||
|
|
try:
|
|||
|
|
import paramiko
|
|||
|
|
PARAMIKO_AVAILABLE = True
|
|||
|
|
except ImportError:
|
|||
|
|
print("Warning: 'paramiko' not installed. SSH service detection will be skipped. "
|
|||
|
|
"Install with 'pip install paramiko' for full functionality.")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def get_local_ip() -> str:
|
|||
|
|
"""Gets the local IP address of the machine."""
|
|||
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|||
|
|
try:
|
|||
|
|
# Connect to a dummy address. Doesn't actually send data.
|
|||
|
|
s.connect(('10.255.255.255', 1))
|
|||
|
|
IP = s.getsockname()[0]
|
|||
|
|
except Exception:
|
|||
|
|
IP = '127.0.0.1'
|
|||
|
|
finally:
|
|||
|
|
s.close()
|
|||
|
|
return IP
|
|||
|
|
|
|||
|
|
def get_all_local_networks() -> List[str]:
|
|||
|
|
"""
|
|||
|
|
Uses psutil to find all active network interfaces and their associated network ranges.
|
|||
|
|
Returns a list of network CIDR strings (e.g., '192.168.1.0/24').
|
|||
|
|
"""
|
|||
|
|
if not psutil:
|
|||
|
|
print("Warning: 'psutil' not available. Only scanning the /24 subnet of the local IP address.")
|
|||
|
|
local_ip = get_local_ip()
|
|||
|
|
if local_ip == '127.0.0.1':
|
|||
|
|
return [] # Cannot determine external network from localhost
|
|||
|
|
return [str(ipaddress.IPv4Network(f"{local_ip}/24", strict=False))]
|
|||
|
|
|
|||
|
|
networks = set()
|
|||
|
|
try:
|
|||
|
|
for interface, snics in psutil.net_if_addrs().items():
|
|||
|
|
for snic in snics:
|
|||
|
|
if snic.family == socket.AF_INET: # IPv4 address
|
|||
|
|
ip_address = snic.address
|
|||
|
|
netmask = snic.netmask
|
|||
|
|
if ip_address and netmask and ip_address != '127.0.0.1':
|
|||
|
|
try:
|
|||
|
|
# Calculate the network address using the IP and netmask
|
|||
|
|
# ipaddress module can handle this directly from address and netmask
|
|||
|
|
network_obj = ipaddress.IPv4Network(f"{ip_address}/{netmask}", strict=False)
|
|||
|
|
networks.add(str(network_obj))
|
|||
|
|
except ipaddress.AddressValueError as e:
|
|||
|
|
print(f"Warning: Could not parse IP address or netmask for {interface}: {ip_address}, {netmask}. Error: {e}")
|
|||
|
|
return list(networks)
|
|||
|
|
except Exception as e:
|
|||
|
|
print(f"Error getting network interfaces with psutil: {e}")
|
|||
|
|
print("Falling back to scanning only the /24 subnet of the local IP address.")
|
|||
|
|
local_ip = get_local_ip()
|
|||
|
|
if local_ip == '127.0.0.1':
|
|||
|
|
return []
|
|||
|
|
return [str(ipaddress.IPv4Network(f"{local_ip}/24", strict=False))]
|
|||
|
|
|
|||
|
|
def onvif_discovery_task() -> None:
|
|||
|
|
"""Performs ONVIF WS-Discovery to find compatible devices."""
|
|||
|
|
global ONVIF_AVAILABLE, _discovery_method
|
|||
|
|
if not ONVIF_AVAILABLE or _discovery_method is None:
|
|||
|
|
print("ONVIF: Skipping discovery due to 'psutil' or 'onvif-zeep' not being available or no suitable discovery method.")
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
print("ONVIF: Starting discovery. This may take a few seconds...")
|
|||
|
|
try:
|
|||
|
|
# Use the determined discovery method
|
|||
|
|
discovered_device_xaddrs: List[str] = _discovery_method(timeout=5)
|
|||
|
|
|
|||
|
|
# Ensure raw_xaddrs is a list before iteration
|
|||
|
|
if not isinstance(discovered_device_xaddrs, list):
|
|||
|
|
discovered_device_xaddrs = [discovered_device_xaddrs] if discovered_device_xaddrs else []
|
|||
|
|
|
|||
|
|
discovered_ips_via_onvif = []
|
|||
|
|
for xaddr in discovered_device_xaddrs:
|
|||
|
|
try:
|
|||
|
|
# Extract IP from the XAddr URL
|
|||
|
|
parsed_url = urlparse(xaddr)
|
|||
|
|
device_ip = parsed_url.hostname
|
|||
|
|
if device_ip and device_ip not in discovered_ips_via_onvif:
|
|||
|
|
discovered_ips_via_onvif.append(device_ip)
|
|||
|
|
except Exception as url_e:
|
|||
|
|
print(f"ONVIF: Warning: Could not parse IP from device XAddr '{xaddr}': {url_e}")
|
|||
|
|
|
|||
|
|
if discovered_ips_via_onvif:
|
|||
|
|
print(f"ONVIF: Found {len(discovered_ips_via_onvif)} potential ONVIF devices via WS-Discovery.")
|
|||
|
|
for device_ip in discovered_ips_via_onvif:
|
|||
|
|
with ip_lock:
|
|||
|
|
active_ips.add(device_ip)
|
|||
|
|
with camera_lock:
|
|||
|
|
found_cameras[device_ip]['ONVIF_Discovery'] = "ONVIF Device (WS-Discovery)"
|
|||
|
|
else:
|
|||
|
|
print("ONVIF: No ONVIF devices found via WS-Discovery.")
|
|||
|
|
|
|||
|
|
except Exception as e:
|
|||
|
|
print(f"ONVIF: Error during ONVIF discovery (using _discovery_method): {e}")
|
|||
|
|
|
|||
|
|
def check_socket(ip: str, port: int, timeout: float = 0.5) -> bool:
|
|||
|
|
"""Attempts to connect to a specific port on an IP address."""
|
|||
|
|
try:
|
|||
|
|
with socket.create_connection((ip, port), timeout) as sock:
|
|||
|
|
sock.shutdown(socket.SHUT_RDWR) # Gracefully close connection
|
|||
|
|
return True
|
|||
|
|
except (socket.timeout, ConnectionRefusedError, OSError):
|
|||
|
|
return False
|
|||
|
|
except Exception as e:
|
|||
|
|
# print(f"Error checking {ip}:{port}: {e}") # Uncomment for debugging
|
|||
|
|
return False
|
|||
|
|
|
|||
|
|
def check_ssh_banner(ip: str, port: int, timeout: float = 0.5) -> Union[str, bool]:
|
|||
|
|
"""Attempts to get SSH banner to verify SSH service."""
|
|||
|
|
if not PARAMIKO_AVAILABLE:
|
|||
|
|
return False
|
|||
|
|
|
|||
|
|
try:
|
|||
|
|
transport = paramiko.Transport((ip, port))
|
|||
|
|
transport.connect(timeout=timeout)
|
|||
|
|
banner = transport.get_banner()
|
|||
|
|
transport.close()
|
|||
|
|
return banner.strip()
|
|||
|
|
except (paramiko.SSHException, socket.error, socket.timeout):
|
|||
|
|
return False
|
|||
|
|
except Exception as e:
|
|||
|
|
# print(f"Error getting SSH banner from {ip}:{port}: {e}") # Uncomment for debugging
|
|||
|
|
return False
|
|||
|
|
|
|||
|
|
|
|||
|
|
def service_scan_task(ip: str) -> None:
|
|||
|
|
"""Scans common camera ports and SSH ports on a given IP and updates found_cameras."""
|
|||
|
|
|
|||
|
|
# Try ONVIF specific ports (80, 554, 8000, 8080) for detailed service if available
|
|||
|
|
for port in COMMON_CAMERA_PORTS:
|
|||
|
|
if check_socket(ip, port):
|
|||
|
|
with camera_lock:
|
|||
|
|
if port == 80:
|
|||
|
|
found_cameras[ip]['HTTP'] = f"Open on port {port}"
|
|||
|
|
elif port == 443:
|
|||
|
|
found_cameras[ip]['HTTPS'] = f"Open on port {port}"
|
|||
|
|
elif port == 554:
|
|||
|
|
found_cameras[ip]['RTSP'] = f"Open on port {port}"
|
|||
|
|
elif port == 8000 or port == 8001: # Common for Hikvision
|
|||
|
|
found_cameras[ip]['Hikvision_Service'] = f"Open on port {port}"
|
|||
|
|
elif port == 37777 or port == 37778: # Common for Dahua
|
|||
|
|
found_cameras[ip]['Dahua_Service'] = f"Open on port {port}"
|
|||
|
|
else:
|
|||
|
|
found_cameras[ip][f'TCP_{port}'] = f"Open on port {port}"
|
|||
|
|
|
|||
|
|
for port in SSH_PORTS:
|
|||
|
|
banner = check_ssh_banner(ip, port)
|
|||
|
|
if banner:
|
|||
|
|
with camera_lock:
|
|||
|
|
found_cameras[ip]['SSH'] = f"Open on port {port} (Banner: {banner})"
|
|||
|
|
|
|||
|
|
|
|||
|
|
def main():
|
|||
|
|
start_time = time.time()
|
|||
|
|
print("--- Starting Network Camera Discovery on RK3588 ---")
|
|||
|
|
|
|||
|
|
# Get local IP address (for display)
|
|||
|
|
local_ip = get_local_ip()
|
|||
|
|
print(f"Local IP Address: {local_ip}")
|
|||
|
|
|
|||
|
|
# Get all local networks for scanning
|
|||
|
|
all_local_networks = get_all_local_networks()
|
|||
|
|
if not all_local_networks:
|
|||
|
|
print("No local networks detected for scanning. Exiting.")
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
print("Detected local networks for scanning:")
|
|||
|
|
for net in all_local_networks:
|
|||
|
|
print(f" - {net}")
|
|||
|
|
# --- EXCLUDE Docker internal networks ---
|
|||
|
|
# If running inside a Docker container, often these are internal.
|
|||
|
|
# Adjust these prefixes based on your Docker network configuration if different.
|
|||
|
|
all_local_networks_filtered = []
|
|||
|
|
DOCKER_NETWORK_PREFIXES = ["172.17.", "172.18.", "172.19.", "172.20."] # Add more if your Docker uses other 172.x ranges
|
|||
|
|
|
|||
|
|
for net_cidr in all_local_networks:
|
|||
|
|
is_docker_internal = False
|
|||
|
|
for prefix in DOCKER_NETWORK_PREFIXES:
|
|||
|
|
if net_cidr.startswith(prefix):
|
|||
|
|
is_docker_internal = True
|
|||
|
|
break
|
|||
|
|
|
|||
|
|
if not is_docker_internal:
|
|||
|
|
all_local_networks_filtered.append(net_cidr)
|
|||
|
|
else:
|
|||
|
|
print(f" - Excluding Docker internal network: {net_cidr}")
|
|||
|
|
if not all_local_networks_filtered:
|
|||
|
|
print("No external local networks found for scanning after filtering Docker networks. Exiting.")
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
print("\nFiltered local networks for scanning:")
|
|||
|
|
for net in all_local_networks_filtered:
|
|||
|
|
print(f" - {net}")
|
|||
|
|
# --- ONVIF Discovery (runs independently) ---
|
|||
|
|
onvif_discovery_task()
|
|||
|
|
# --- Prepare IPs for Service Scan (without relying on 'ping') ---
|
|||
|
|
all_ips_for_service_scan = set()
|
|||
|
|
# Use the filtered list of networks
|
|||
|
|
for network_str in all_local_networks_filtered:
|
|||
|
|
try:
|
|||
|
|
network = ipaddress.IPv4Network(network_str, strict=False)
|
|||
|
|
for ip_obj in network.hosts():
|
|||
|
|
all_ips_for_service_scan.add(str(ip_obj))
|
|||
|
|
except Exception as e:
|
|||
|
|
print(f"Error processing network {network_str}: {e}")
|
|||
|
|
continue
|
|||
|
|
total_ips_for_service_scan = len(all_ips_for_service_scan)
|
|||
|
|
print(f"Proceeding directly to service scan of {total_ips_for_service_scan} IPs on common camera ports.")
|
|||
|
|
|
|||
|
|
# --- Service Scan for common camera ports ---
|
|||
|
|
if total_ips_for_service_scan > 0:
|
|||
|
|
with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
|
|||
|
|
# Map the service scan task to all IPs identified by local networks
|
|||
|
|
executor.map(service_scan_task, list(all_ips_for_service_scan))
|
|||
|
|
|
|||
|
|
# Wait for service scan to complete using concurrent.futures
|
|||
|
|
# (executor.map is blocking here, which is fine)
|
|||
|
|
|
|||
|
|
|
|||
|
|
# --- Discovery Results ---
|
|||
|
|
print("\n--- Discovery Results ---")
|
|||
|
|
if found_cameras:
|
|||
|
|
print(f"Found {len(found_cameras)} potential camera devices and services:")
|
|||
|
|
for ip, services in found_cameras.items():
|
|||
|
|
print(f" IP: {ip}")
|
|||
|
|
# Sort services for consistent output
|
|||
|
|
for service, details in sorted(services.items()):
|
|||
|
|
print(f" - {service}: {details}")
|
|||
|
|
else:
|
|||
|
|
print("No network cameras or detectable services found based on ONVIF or port scanning.")
|
|||
|
|
|
|||
|
|
print(f"\n--- Discovery Finished in {time.time() - start_time:.2f} seconds ---")
|
|||
|
|
|
|||
|
|
if __name__ == "__main__":
|
|||
|
|
main()
|