mirror of
https://github.com/smittix/intercept.git
synced 2026-04-24 06:40:00 -07:00
430 lines
14 KiB
Python
430 lines
14 KiB
Python
"""SubGHz transceiver routes.
|
|
|
|
Provides endpoints for HackRF-based SubGHz signal capture, protocol decoding,
|
|
signal replay/transmit, and wideband spectrum analysis.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import queue
|
|
|
|
from flask import Blueprint, jsonify, request, Response, send_file
|
|
|
|
from utils.logging import get_logger
|
|
from utils.sse import sse_stream
|
|
from utils.subghz import get_subghz_manager
|
|
from utils.event_pipeline import process_event
|
|
from utils.constants import (
|
|
SUBGHZ_FREQ_MIN_MHZ,
|
|
SUBGHZ_FREQ_MAX_MHZ,
|
|
SUBGHZ_LNA_GAIN_MAX,
|
|
SUBGHZ_VGA_GAIN_MAX,
|
|
SUBGHZ_TX_VGA_GAIN_MAX,
|
|
SUBGHZ_TX_MAX_DURATION,
|
|
SUBGHZ_SAMPLE_RATES,
|
|
SUBGHZ_PRESETS,
|
|
)
|
|
|
|
logger = get_logger('intercept.subghz')
|
|
|
|
subghz_bp = Blueprint('subghz', __name__, url_prefix='/subghz')
|
|
|
|
# SSE queue for streaming events to frontend
|
|
_subghz_queue: queue.Queue = queue.Queue(maxsize=200)
|
|
|
|
|
|
def _event_callback(event: dict) -> None:
|
|
"""Forward SubGhzManager events to the SSE queue."""
|
|
try:
|
|
process_event('subghz', event, event.get('type'))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
_subghz_queue.put_nowait(event)
|
|
except queue.Full:
|
|
try:
|
|
_subghz_queue.get_nowait()
|
|
_subghz_queue.put_nowait(event)
|
|
except queue.Empty:
|
|
pass
|
|
|
|
|
|
def _validate_frequency_hz(data: dict, key: str = 'frequency_hz') -> tuple[int | None, str | None]:
|
|
"""Validate frequency in Hz from request data. Returns (freq_hz, error_msg)."""
|
|
raw = data.get(key)
|
|
if raw is None:
|
|
return None, f'{key} is required'
|
|
try:
|
|
freq_hz = int(raw)
|
|
freq_mhz = freq_hz / 1_000_000
|
|
if not (SUBGHZ_FREQ_MIN_MHZ <= freq_mhz <= SUBGHZ_FREQ_MAX_MHZ):
|
|
return None, f'Frequency must be between {SUBGHZ_FREQ_MIN_MHZ}-{SUBGHZ_FREQ_MAX_MHZ} MHz'
|
|
return freq_hz, None
|
|
except (ValueError, TypeError):
|
|
return None, f'Invalid {key}'
|
|
|
|
|
|
def _validate_serial(data: dict) -> str | None:
|
|
"""Extract and validate optional HackRF device serial."""
|
|
serial = data.get('device_serial', '')
|
|
if not serial or not isinstance(serial, str):
|
|
return None
|
|
# HackRF serials are hex strings
|
|
serial = serial.strip()
|
|
if serial and all(c in '0123456789abcdefABCDEF' for c in serial):
|
|
return serial
|
|
return None
|
|
|
|
|
|
def _validate_int(data: dict, key: str, default: int, min_val: int, max_val: int) -> int:
|
|
"""Validate integer parameter with bounds clamping."""
|
|
try:
|
|
val = int(data.get(key, default))
|
|
return max(min_val, min(max_val, val))
|
|
except (ValueError, TypeError):
|
|
return default
|
|
|
|
|
|
def _validate_decode_profile(data: dict, default: str = 'weather') -> str:
|
|
profile = data.get('decode_profile', default)
|
|
if not isinstance(profile, str):
|
|
return default
|
|
profile = profile.strip().lower()
|
|
if profile in {'weather', 'all'}:
|
|
return profile
|
|
return default
|
|
|
|
|
|
def _validate_optional_float(data: dict, key: str) -> tuple[float | None, str | None]:
|
|
raw = data.get(key)
|
|
if raw is None or raw == '':
|
|
return None, None
|
|
try:
|
|
return float(raw), None
|
|
except (ValueError, TypeError):
|
|
return None, f'Invalid {key}'
|
|
|
|
|
|
def _validate_bool(data: dict, key: str, default: bool = False) -> bool:
|
|
raw = data.get(key, default)
|
|
if isinstance(raw, bool):
|
|
return raw
|
|
if isinstance(raw, (int, float)):
|
|
return bool(raw)
|
|
if isinstance(raw, str):
|
|
return raw.strip().lower() in {'1', 'true', 'yes', 'on', 'enabled'}
|
|
return default
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# STATUS
|
|
# ------------------------------------------------------------------
|
|
|
|
@subghz_bp.route('/status')
|
|
def get_status():
|
|
manager = get_subghz_manager()
|
|
return jsonify(manager.get_status())
|
|
|
|
|
|
@subghz_bp.route('/presets')
|
|
def get_presets():
|
|
return jsonify({'presets': SUBGHZ_PRESETS, 'sample_rates': SUBGHZ_SAMPLE_RATES})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# RECEIVE
|
|
# ------------------------------------------------------------------
|
|
|
|
@subghz_bp.route('/receive/start', methods=['POST'])
|
|
def start_receive():
|
|
data = request.get_json(silent=True) or {}
|
|
|
|
freq_hz, err = _validate_frequency_hz(data)
|
|
if err:
|
|
return jsonify({'status': 'error', 'message': err}), 400
|
|
|
|
sample_rate = _validate_int(data, 'sample_rate', 2000000, 2000000, 20000000)
|
|
lna_gain = _validate_int(data, 'lna_gain', 32, 0, SUBGHZ_LNA_GAIN_MAX)
|
|
vga_gain = _validate_int(data, 'vga_gain', 20, 0, SUBGHZ_VGA_GAIN_MAX)
|
|
trigger_enabled = _validate_bool(data, 'trigger_enabled', False)
|
|
trigger_pre_ms = _validate_int(data, 'trigger_pre_ms', 350, 50, 5000)
|
|
trigger_post_ms = _validate_int(data, 'trigger_post_ms', 700, 100, 10000)
|
|
device_serial = _validate_serial(data)
|
|
|
|
manager = get_subghz_manager()
|
|
manager.set_callback(_event_callback)
|
|
|
|
result = manager.start_receive(
|
|
frequency_hz=freq_hz,
|
|
sample_rate=sample_rate,
|
|
lna_gain=lna_gain,
|
|
vga_gain=vga_gain,
|
|
trigger_enabled=trigger_enabled,
|
|
trigger_pre_ms=trigger_pre_ms,
|
|
trigger_post_ms=trigger_post_ms,
|
|
device_serial=device_serial,
|
|
)
|
|
|
|
status_code = 200 if result.get('status') != 'error' else 409
|
|
return jsonify(result), status_code
|
|
|
|
|
|
@subghz_bp.route('/receive/stop', methods=['POST'])
|
|
def stop_receive():
|
|
manager = get_subghz_manager()
|
|
result = manager.stop_receive()
|
|
return jsonify(result)
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# DECODE
|
|
# ------------------------------------------------------------------
|
|
|
|
@subghz_bp.route('/decode/start', methods=['POST'])
|
|
def start_decode():
|
|
data = request.get_json(silent=True) or {}
|
|
|
|
freq_hz, err = _validate_frequency_hz(data)
|
|
if err:
|
|
return jsonify({'status': 'error', 'message': err}), 400
|
|
|
|
sample_rate = _validate_int(data, 'sample_rate', 2000000, 2000000, 20000000)
|
|
lna_gain = _validate_int(data, 'lna_gain', 32, 0, SUBGHZ_LNA_GAIN_MAX)
|
|
vga_gain = _validate_int(data, 'vga_gain', 20, 0, SUBGHZ_VGA_GAIN_MAX)
|
|
decode_profile = _validate_decode_profile(data)
|
|
device_serial = _validate_serial(data)
|
|
|
|
manager = get_subghz_manager()
|
|
manager.set_callback(_event_callback)
|
|
|
|
result = manager.start_decode(
|
|
frequency_hz=freq_hz,
|
|
sample_rate=sample_rate,
|
|
lna_gain=lna_gain,
|
|
vga_gain=vga_gain,
|
|
decode_profile=decode_profile,
|
|
device_serial=device_serial,
|
|
)
|
|
|
|
status_code = 200 if result.get('status') != 'error' else 409
|
|
return jsonify(result), status_code
|
|
|
|
|
|
@subghz_bp.route('/decode/stop', methods=['POST'])
|
|
def stop_decode():
|
|
manager = get_subghz_manager()
|
|
result = manager.stop_decode()
|
|
return jsonify(result)
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# TRANSMIT
|
|
# ------------------------------------------------------------------
|
|
|
|
@subghz_bp.route('/transmit', methods=['POST'])
|
|
def start_transmit():
|
|
data = request.get_json(silent=True) or {}
|
|
|
|
capture_id = data.get('capture_id')
|
|
if not capture_id or not isinstance(capture_id, str):
|
|
return jsonify({'status': 'error', 'message': 'capture_id is required'}), 400
|
|
|
|
# Sanitize capture_id
|
|
if not capture_id.isalnum():
|
|
return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
|
|
|
|
tx_gain = _validate_int(data, 'tx_gain', 20, 0, SUBGHZ_TX_VGA_GAIN_MAX)
|
|
max_duration = _validate_int(data, 'max_duration', 10, 1, SUBGHZ_TX_MAX_DURATION)
|
|
start_seconds, start_err = _validate_optional_float(data, 'start_seconds')
|
|
if start_err:
|
|
return jsonify({'status': 'error', 'message': start_err}), 400
|
|
duration_seconds, duration_err = _validate_optional_float(data, 'duration_seconds')
|
|
if duration_err:
|
|
return jsonify({'status': 'error', 'message': duration_err}), 400
|
|
device_serial = _validate_serial(data)
|
|
|
|
manager = get_subghz_manager()
|
|
manager.set_callback(_event_callback)
|
|
|
|
result = manager.transmit(
|
|
capture_id=capture_id,
|
|
tx_gain=tx_gain,
|
|
max_duration=max_duration,
|
|
start_seconds=start_seconds,
|
|
duration_seconds=duration_seconds,
|
|
device_serial=device_serial,
|
|
)
|
|
|
|
status_code = 200 if result.get('status') != 'error' else 400
|
|
return jsonify(result), status_code
|
|
|
|
|
|
@subghz_bp.route('/transmit/stop', methods=['POST'])
|
|
def stop_transmit():
|
|
manager = get_subghz_manager()
|
|
result = manager.stop_transmit()
|
|
return jsonify(result)
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# SWEEP
|
|
# ------------------------------------------------------------------
|
|
|
|
@subghz_bp.route('/sweep/start', methods=['POST'])
|
|
def start_sweep():
|
|
data = request.get_json(silent=True) or {}
|
|
|
|
try:
|
|
freq_start = float(data.get('freq_start_mhz', 300))
|
|
freq_end = float(data.get('freq_end_mhz', 928))
|
|
if freq_start >= freq_end:
|
|
return jsonify({'status': 'error', 'message': 'freq_start must be less than freq_end'}), 400
|
|
if freq_start < SUBGHZ_FREQ_MIN_MHZ or freq_end > SUBGHZ_FREQ_MAX_MHZ:
|
|
return jsonify({'status': 'error', 'message': f'Frequency range: {SUBGHZ_FREQ_MIN_MHZ}-{SUBGHZ_FREQ_MAX_MHZ} MHz'}), 400
|
|
except (ValueError, TypeError):
|
|
return jsonify({'status': 'error', 'message': 'Invalid frequency range'}), 400
|
|
|
|
bin_width = _validate_int(data, 'bin_width', 100000, 10000, 5000000)
|
|
device_serial = _validate_serial(data)
|
|
|
|
manager = get_subghz_manager()
|
|
manager.set_callback(_event_callback)
|
|
|
|
result = manager.start_sweep(
|
|
freq_start_mhz=freq_start,
|
|
freq_end_mhz=freq_end,
|
|
bin_width=bin_width,
|
|
device_serial=device_serial,
|
|
)
|
|
|
|
status_code = 200 if result.get('status') != 'error' else 409
|
|
return jsonify(result), status_code
|
|
|
|
|
|
@subghz_bp.route('/sweep/stop', methods=['POST'])
|
|
def stop_sweep():
|
|
manager = get_subghz_manager()
|
|
result = manager.stop_sweep()
|
|
return jsonify(result)
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# CAPTURES LIBRARY
|
|
# ------------------------------------------------------------------
|
|
|
|
@subghz_bp.route('/captures')
|
|
def list_captures():
|
|
manager = get_subghz_manager()
|
|
captures = manager.list_captures()
|
|
return jsonify({
|
|
'status': 'ok',
|
|
'captures': [c.to_dict() for c in captures],
|
|
'count': len(captures),
|
|
})
|
|
|
|
|
|
@subghz_bp.route('/captures/<capture_id>')
|
|
def get_capture(capture_id: str):
|
|
if not capture_id.isalnum():
|
|
return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
|
|
|
|
manager = get_subghz_manager()
|
|
capture = manager.get_capture(capture_id)
|
|
if not capture:
|
|
return jsonify({'status': 'error', 'message': 'Capture not found'}), 404
|
|
|
|
return jsonify({'status': 'ok', 'capture': capture.to_dict()})
|
|
|
|
|
|
@subghz_bp.route('/captures/<capture_id>/download')
|
|
def download_capture(capture_id: str):
|
|
if not capture_id.isalnum():
|
|
return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
|
|
|
|
manager = get_subghz_manager()
|
|
path = manager.get_capture_path(capture_id)
|
|
if not path:
|
|
return jsonify({'status': 'error', 'message': 'Capture not found'}), 404
|
|
|
|
return send_file(
|
|
path,
|
|
mimetype='application/octet-stream',
|
|
as_attachment=True,
|
|
download_name=path.name,
|
|
)
|
|
|
|
|
|
@subghz_bp.route('/captures/<capture_id>/trim', methods=['POST'])
|
|
def trim_capture(capture_id: str):
|
|
if not capture_id.isalnum():
|
|
return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
start_seconds, start_err = _validate_optional_float(data, 'start_seconds')
|
|
if start_err:
|
|
return jsonify({'status': 'error', 'message': start_err}), 400
|
|
duration_seconds, duration_err = _validate_optional_float(data, 'duration_seconds')
|
|
if duration_err:
|
|
return jsonify({'status': 'error', 'message': duration_err}), 400
|
|
|
|
label = data.get('label', '')
|
|
if label is None:
|
|
label = ''
|
|
if not isinstance(label, str) or len(label) > 100:
|
|
return jsonify({'status': 'error', 'message': 'Label must be a string (max 100 chars)'}), 400
|
|
|
|
manager = get_subghz_manager()
|
|
result = manager.trim_capture(
|
|
capture_id=capture_id,
|
|
start_seconds=start_seconds,
|
|
duration_seconds=duration_seconds,
|
|
label=label,
|
|
)
|
|
|
|
if result.get('status') == 'ok':
|
|
return jsonify(result), 200
|
|
message = str(result.get('message') or 'Trim failed')
|
|
status_code = 404 if 'not found' in message.lower() else 400
|
|
return jsonify(result), status_code
|
|
|
|
|
|
@subghz_bp.route('/captures/<capture_id>', methods=['DELETE'])
|
|
def delete_capture(capture_id: str):
|
|
if not capture_id.isalnum():
|
|
return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
|
|
|
|
manager = get_subghz_manager()
|
|
if manager.delete_capture(capture_id):
|
|
return jsonify({'status': 'deleted', 'id': capture_id})
|
|
return jsonify({'status': 'error', 'message': 'Capture not found'}), 404
|
|
|
|
|
|
@subghz_bp.route('/captures/<capture_id>', methods=['PATCH'])
|
|
def update_capture(capture_id: str):
|
|
if not capture_id.isalnum():
|
|
return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
label = data.get('label', '')
|
|
|
|
if not isinstance(label, str) or len(label) > 100:
|
|
return jsonify({'status': 'error', 'message': 'Label must be a string (max 100 chars)'}), 400
|
|
|
|
manager = get_subghz_manager()
|
|
if manager.update_capture_label(capture_id, label):
|
|
return jsonify({'status': 'updated', 'id': capture_id, 'label': label})
|
|
return jsonify({'status': 'error', 'message': 'Capture not found'}), 404
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# SSE STREAM
|
|
# ------------------------------------------------------------------
|
|
|
|
@subghz_bp.route('/stream')
|
|
def stream():
|
|
response = Response(sse_stream(_subghz_queue), mimetype='text/event-stream')
|
|
response.headers['Cache-Control'] = 'no-cache'
|
|
response.headers['X-Accel-Buffering'] = 'no'
|
|
response.headers['Connection'] = 'keep-alive'
|
|
return response
|