mirror of
https://github.com/smittix/intercept.git
synced 2026-04-24 22:59:59 -07:00
84b424b02e
Add support for connecting to Meshtastic LoRa mesh devices via USB/Serial. Includes routes for device connection, channel configuration with encryption, and SSE streaming of received messages. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
477 lines
16 KiB
Python
477 lines
16 KiB
Python
"""Meshtastic device management and message handling.
|
|
|
|
This module provides integration with Meshtastic mesh networking devices,
|
|
allowing INTERCEPT to receive and decode messages from LoRa mesh networks.
|
|
|
|
Requires a physical Meshtastic device connected via USB/Serial.
|
|
Install SDK with: pip install meshtastic
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import hashlib
|
|
import secrets
|
|
import threading
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime, timezone
|
|
from typing import Callable
|
|
|
|
from utils.logging import get_logger
|
|
|
|
logger = get_logger('intercept.meshtastic')
|
|
|
|
# Meshtastic SDK import (optional dependency)
|
|
try:
|
|
import meshtastic
|
|
import meshtastic.serial_interface
|
|
from pubsub import pub
|
|
HAS_MESHTASTIC = True
|
|
except ImportError:
|
|
HAS_MESHTASTIC = False
|
|
logger.warning("Meshtastic SDK not installed. Install with: pip install meshtastic")
|
|
|
|
|
|
@dataclass
|
|
class MeshtasticMessage:
|
|
"""Decoded Meshtastic message."""
|
|
from_id: str
|
|
to_id: str
|
|
message: str | None
|
|
portnum: str
|
|
channel: int
|
|
rssi: int | None
|
|
snr: float | None
|
|
hop_limit: int | None
|
|
timestamp: datetime
|
|
raw_packet: dict = field(default_factory=dict)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
'type': 'meshtastic',
|
|
'from': self.from_id,
|
|
'to': self.to_id,
|
|
'message': self.message,
|
|
'portnum': self.portnum,
|
|
'channel': self.channel,
|
|
'rssi': self.rssi,
|
|
'snr': self.snr,
|
|
'hop_limit': self.hop_limit,
|
|
'timestamp': self.timestamp.isoformat(),
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class ChannelConfig:
|
|
"""Meshtastic channel configuration."""
|
|
index: int
|
|
name: str
|
|
psk: bytes
|
|
role: int # 0=DISABLED, 1=PRIMARY, 2=SECONDARY
|
|
|
|
def to_dict(self) -> dict:
|
|
"""Convert to dict for API response (hides raw PSK)."""
|
|
role_names = ['DISABLED', 'PRIMARY', 'SECONDARY']
|
|
# Default key is 1 byte (0x01) or the well-known AQ== base64
|
|
is_default = self.psk in (b'\x01', b'')
|
|
return {
|
|
'index': self.index,
|
|
'name': self.name,
|
|
'role': role_names[self.role] if self.role < len(role_names) else 'UNKNOWN',
|
|
'encrypted': len(self.psk) > 1,
|
|
'key_type': self._get_key_type(),
|
|
'is_default_key': is_default,
|
|
}
|
|
|
|
def _get_key_type(self) -> str:
|
|
"""Determine encryption type from key length."""
|
|
if len(self.psk) == 0:
|
|
return 'none'
|
|
elif len(self.psk) == 1:
|
|
return 'default'
|
|
elif len(self.psk) == 16:
|
|
return 'AES-128'
|
|
elif len(self.psk) == 32:
|
|
return 'AES-256'
|
|
else:
|
|
return 'unknown'
|
|
|
|
|
|
@dataclass
|
|
class NodeInfo:
|
|
"""Meshtastic node information."""
|
|
num: int
|
|
user_id: str
|
|
long_name: str
|
|
short_name: str
|
|
hw_model: str
|
|
latitude: float | None
|
|
longitude: float | None
|
|
altitude: int | None
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
'num': self.num,
|
|
'user_id': self.user_id,
|
|
'long_name': self.long_name,
|
|
'short_name': self.short_name,
|
|
'hw_model': self.hw_model,
|
|
'position': {
|
|
'latitude': self.latitude,
|
|
'longitude': self.longitude,
|
|
'altitude': self.altitude,
|
|
} if self.latitude is not None else None,
|
|
}
|
|
|
|
|
|
class MeshtasticClient:
|
|
"""Client for connecting to Meshtastic devices."""
|
|
|
|
def __init__(self):
|
|
self._interface = None
|
|
self._running = False
|
|
self._callback: Callable[[MeshtasticMessage], None] | None = None
|
|
self._lock = threading.Lock()
|
|
self._device_path: str | None = None
|
|
self._error: str | None = None
|
|
|
|
@property
|
|
def is_running(self) -> bool:
|
|
return self._running
|
|
|
|
@property
|
|
def device_path(self) -> str | None:
|
|
return self._device_path
|
|
|
|
@property
|
|
def error(self) -> str | None:
|
|
return self._error
|
|
|
|
def set_callback(self, callback: Callable[[MeshtasticMessage], None]) -> None:
|
|
"""Set callback for received messages."""
|
|
self._callback = callback
|
|
|
|
def connect(self, device: str | None = None) -> bool:
|
|
"""
|
|
Connect to a Meshtastic device.
|
|
|
|
Args:
|
|
device: Serial port path (e.g., /dev/ttyUSB0, /dev/ttyACM0).
|
|
If None, auto-discovers first available device.
|
|
|
|
Returns:
|
|
True if connected successfully.
|
|
"""
|
|
if not HAS_MESHTASTIC:
|
|
self._error = "Meshtastic SDK not installed. Install with: pip install meshtastic"
|
|
return False
|
|
|
|
with self._lock:
|
|
if self._running:
|
|
return True
|
|
|
|
try:
|
|
# Subscribe to message events before connecting
|
|
pub.subscribe(self._on_receive, "meshtastic.receive")
|
|
pub.subscribe(self._on_connection, "meshtastic.connection.established")
|
|
pub.subscribe(self._on_disconnect, "meshtastic.connection.lost")
|
|
|
|
# Connect to device
|
|
if device:
|
|
self._interface = meshtastic.serial_interface.SerialInterface(device)
|
|
self._device_path = device
|
|
else:
|
|
# Auto-discover
|
|
self._interface = meshtastic.serial_interface.SerialInterface()
|
|
self._device_path = "auto"
|
|
|
|
self._running = True
|
|
self._error = None
|
|
logger.info(f"Connected to Meshtastic device: {self._device_path}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
self._error = str(e)
|
|
logger.error(f"Failed to connect to Meshtastic: {e}")
|
|
self._cleanup_subscriptions()
|
|
return False
|
|
|
|
def disconnect(self) -> None:
|
|
"""Disconnect from the Meshtastic device."""
|
|
with self._lock:
|
|
if self._interface:
|
|
try:
|
|
self._interface.close()
|
|
except Exception as e:
|
|
logger.warning(f"Error closing Meshtastic interface: {e}")
|
|
self._interface = None
|
|
|
|
self._cleanup_subscriptions()
|
|
self._running = False
|
|
self._device_path = None
|
|
logger.info("Disconnected from Meshtastic device")
|
|
|
|
def _cleanup_subscriptions(self) -> None:
|
|
"""Unsubscribe from pubsub topics."""
|
|
if HAS_MESHTASTIC:
|
|
try:
|
|
pub.unsubscribe(self._on_receive, "meshtastic.receive")
|
|
except Exception:
|
|
pass
|
|
try:
|
|
pub.unsubscribe(self._on_connection, "meshtastic.connection.established")
|
|
except Exception:
|
|
pass
|
|
try:
|
|
pub.unsubscribe(self._on_disconnect, "meshtastic.connection.lost")
|
|
except Exception:
|
|
pass
|
|
|
|
def _on_connection(self, interface, topic=None) -> None:
|
|
"""Handle connection established event."""
|
|
logger.info("Meshtastic connection established")
|
|
|
|
def _on_disconnect(self, interface, topic=None) -> None:
|
|
"""Handle connection lost event."""
|
|
logger.warning("Meshtastic connection lost")
|
|
self._running = False
|
|
|
|
def _on_receive(self, packet: dict, interface) -> None:
|
|
"""Handle received packet from Meshtastic device."""
|
|
if not self._callback:
|
|
return
|
|
|
|
try:
|
|
decoded = packet.get('decoded', {})
|
|
|
|
# Extract text message if present
|
|
message = None
|
|
portnum = decoded.get('portnum', 'UNKNOWN')
|
|
if portnum == 'TEXT_MESSAGE_APP':
|
|
message = decoded.get('text')
|
|
elif 'payload' in decoded:
|
|
# For other message types, include payload info
|
|
message = f"[{portnum}]"
|
|
|
|
msg = MeshtasticMessage(
|
|
from_id=self._format_node_id(packet.get('from', 0)),
|
|
to_id=self._format_node_id(packet.get('to', 0)),
|
|
message=message,
|
|
portnum=portnum,
|
|
channel=packet.get('channel', 0),
|
|
rssi=packet.get('rxRssi'),
|
|
snr=packet.get('rxSnr'),
|
|
hop_limit=packet.get('hopLimit'),
|
|
timestamp=datetime.now(timezone.utc),
|
|
raw_packet=packet,
|
|
)
|
|
|
|
self._callback(msg)
|
|
logger.debug(f"Received: {msg.from_id} -> {msg.to_id}: {msg.portnum}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error processing Meshtastic packet: {e}")
|
|
|
|
@staticmethod
|
|
def _format_node_id(node_num: int) -> str:
|
|
"""Format node number as hex string."""
|
|
if node_num == 0xFFFFFFFF:
|
|
return "^all"
|
|
return f"!{node_num:08x}"
|
|
|
|
def get_node_info(self) -> NodeInfo | None:
|
|
"""Get local node information."""
|
|
if not self._interface:
|
|
return None
|
|
try:
|
|
node = self._interface.getMyNodeInfo()
|
|
user = node.get('user', {})
|
|
position = node.get('position', {})
|
|
|
|
return NodeInfo(
|
|
num=node.get('num', 0),
|
|
user_id=user.get('id', ''),
|
|
long_name=user.get('longName', ''),
|
|
short_name=user.get('shortName', ''),
|
|
hw_model=user.get('hwModel', 'UNKNOWN'),
|
|
latitude=position.get('latitude'),
|
|
longitude=position.get('longitude'),
|
|
altitude=position.get('altitude'),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"Error getting node info: {e}")
|
|
return None
|
|
|
|
def get_channels(self) -> list[ChannelConfig]:
|
|
"""Get all configured channels."""
|
|
if not self._interface:
|
|
return []
|
|
|
|
channels = []
|
|
try:
|
|
for i, ch in enumerate(self._interface.localNode.channels):
|
|
if ch.role != 0: # 0 = DISABLED
|
|
channels.append(ChannelConfig(
|
|
index=i,
|
|
name=ch.settings.name or f"Channel {i}",
|
|
psk=bytes(ch.settings.psk) if ch.settings.psk else b'',
|
|
role=ch.role,
|
|
))
|
|
except Exception as e:
|
|
logger.error(f"Error getting channels: {e}")
|
|
return channels
|
|
|
|
def set_channel(self, index: int, name: str | None = None,
|
|
psk: str | None = None) -> tuple[bool, str]:
|
|
"""
|
|
Configure a channel with encryption key.
|
|
|
|
Args:
|
|
index: Channel index (0-7)
|
|
name: Channel name (optional)
|
|
psk: Pre-shared key in one of these formats:
|
|
- "none" - disable encryption
|
|
- "default" - use default (public) key
|
|
- "random" - generate new AES-256 key
|
|
- "base64:..." - base64-encoded key (16 or 32 bytes)
|
|
- "0x..." - hex-encoded key (16 or 32 bytes)
|
|
- "simple:passphrase" - derive key from passphrase (AES-256)
|
|
|
|
Returns:
|
|
Tuple of (success, message)
|
|
"""
|
|
if not self._interface:
|
|
return False, "Not connected to device"
|
|
|
|
if not 0 <= index <= 7:
|
|
return False, f"Invalid channel index: {index}. Must be 0-7."
|
|
|
|
try:
|
|
ch = self._interface.localNode.channels[index]
|
|
|
|
if name is not None:
|
|
ch.settings.name = name
|
|
|
|
if psk is not None:
|
|
psk_bytes = self._parse_psk(psk)
|
|
if psk_bytes is None:
|
|
return False, f"Invalid PSK format: {psk}"
|
|
ch.settings.psk = psk_bytes
|
|
|
|
# Enable channel if it was disabled
|
|
if ch.role == 0:
|
|
ch.role = 2 # SECONDARY (1 = PRIMARY, only one allowed)
|
|
|
|
# Write config to device
|
|
self._interface.localNode.writeChannel(index)
|
|
logger.info(f"Channel {index} configured: {name or ch.settings.name}")
|
|
return True, f"Channel {index} configured successfully"
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error setting channel: {e}")
|
|
return False, str(e)
|
|
|
|
def _parse_psk(self, psk: str) -> bytes | None:
|
|
"""
|
|
Parse PSK string into bytes.
|
|
|
|
Supported formats:
|
|
- "none" - no encryption (empty key)
|
|
- "default" - use default public key (1 byte)
|
|
- "random" - generate random 32-byte AES-256 key
|
|
- "base64:..." - base64-encoded key
|
|
- "0x..." - hex-encoded key
|
|
- "simple:passphrase" - SHA-256 hash of passphrase
|
|
"""
|
|
psk = psk.strip()
|
|
|
|
if psk.lower() == 'none':
|
|
return b''
|
|
|
|
if psk.lower() == 'default':
|
|
# Default key (1 byte = use default)
|
|
return b'\x01'
|
|
|
|
if psk.lower() == 'random':
|
|
# Generate random 32-byte key
|
|
return secrets.token_bytes(32)
|
|
|
|
if psk.startswith('base64:'):
|
|
try:
|
|
decoded = base64.b64decode(psk[7:])
|
|
if len(decoded) not in (0, 1, 16, 32):
|
|
logger.warning(f"PSK length {len(decoded)} is non-standard")
|
|
return decoded
|
|
except Exception:
|
|
return None
|
|
|
|
if psk.startswith('0x'):
|
|
try:
|
|
decoded = bytes.fromhex(psk[2:])
|
|
if len(decoded) not in (0, 1, 16, 32):
|
|
logger.warning(f"PSK length {len(decoded)} is non-standard")
|
|
return decoded
|
|
except Exception:
|
|
return None
|
|
|
|
if psk.startswith('simple:'):
|
|
# Hash passphrase to create 32-byte AES-256 key
|
|
passphrase = psk[7:].encode('utf-8')
|
|
return hashlib.sha256(passphrase).digest()
|
|
|
|
# Try as raw base64 (for compatibility)
|
|
try:
|
|
decoded = base64.b64decode(psk)
|
|
if len(decoded) in (0, 1, 16, 32):
|
|
return decoded
|
|
except Exception:
|
|
pass
|
|
|
|
return None
|
|
|
|
|
|
# Global client instance
|
|
_client: MeshtasticClient | None = None
|
|
|
|
|
|
def get_meshtastic_client() -> MeshtasticClient | None:
|
|
"""Get the global Meshtastic client instance."""
|
|
return _client
|
|
|
|
|
|
def start_meshtastic(device: str | None = None,
|
|
callback: Callable[[MeshtasticMessage], None] | None = None) -> bool:
|
|
"""
|
|
Start the Meshtastic client.
|
|
|
|
Args:
|
|
device: Serial port path (optional, auto-discovers if not provided)
|
|
callback: Function to call when messages are received
|
|
|
|
Returns:
|
|
True if started successfully
|
|
"""
|
|
global _client
|
|
|
|
if _client and _client.is_running:
|
|
return True
|
|
|
|
_client = MeshtasticClient()
|
|
if callback:
|
|
_client.set_callback(callback)
|
|
|
|
return _client.connect(device)
|
|
|
|
|
|
def stop_meshtastic() -> None:
|
|
"""Stop the Meshtastic client."""
|
|
global _client
|
|
if _client:
|
|
_client.disconnect()
|
|
_client = None
|
|
|
|
|
|
def is_meshtastic_available() -> bool:
|
|
"""Check if Meshtastic SDK is installed."""
|
|
return HAS_MESHTASTIC
|