dronecot 2.2.3__tar.gz → 2.2.5__tar.gz

{dronecot-2.2.3/dronecot.egg-info → dronecot-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dronecot
-Version: 2.2.3
+Version: 2.2.5
 Summary: Display Drones in Team Awareness Kit (TAK).
 Home-page: https://github.com/snstac/dronecot
 Maintainer: Greg Albrecht <oss@undef.net>

{dronecot-2.2.3 → dronecot-2.2.5/dronecot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dronecot
-Version: 2.2.3
+Version: 2.2.5
 Summary: Display Drones in Team Awareness Kit (TAK).
 Home-page: https://github.com/snstac/dronecot
 Maintainer: Greg Albrecht <oss@undef.net>

{dronecot-2.2.3 → dronecot-2.2.5}/dronecot.egg-info/SOURCES.txt

@@ -29,4 +29,6 @@ src/dronecot/wifi_capture.py
 src/dronecot/wifi_parse.py
 tests/test_adsb_vehicle.py
 tests/test_functions.py
-tests/test_rid_normalize.py
+tests/test_rid_normalize.py
+tests/test_sensor_detail.py
+tests/test_wifi_parse.py

dronecot-2.2.5/src/dronecot/VERSION

@@ -0,0 +1 @@
+2.2.5

{dronecot-2.2.3 → dronecot-2.2.5}/src/dronecot/__init__.py

@@ -32,6 +32,8 @@ from .constants import (  # NOQA
     DEFAULT_GPS_INFO_CMD,
     DEFAULT_SENSOR_ID,
     DEFAULT_SENSOR_PAYLOAD_TYPE,
+    DEFAULT_SENSOR_MODEL,
+    DEFAULT_SENSOR_TYPE,
     DEFAULT_SENSOR_COT_TYPE,
     DEFAULT_OP_COT_TYPE,
     DEFAULT_HOME_COT_TYPE,

{dronecot-2.2.3 → dronecot-2.2.5}/src/dronecot/constants.py

@@ -41,6 +41,11 @@ DEFAULT_SENSOR_ID: str = f"dronecot_{hostname}"
 
 DEFAULT_SENSOR_PAYLOAD_TYPE: str = "Unknown-Sensor-Payload-Type"
 
+# Receiver hardware model (e.g. "Atheros AR9271") and detection method /
+# capability (e.g. "Wi-Fi Open Drone ID"). Set via SENSOR_MODEL / SENSOR_TYPE.
+DEFAULT_SENSOR_MODEL: str = "Unknown-Sensor"
+DEFAULT_SENSOR_TYPE: str = "Remote ID"
+
 DEFAULT_SENSOR_COT_TYPE: str = "a-f-G-E-S-E"
 DEFAULT_OP_COT_TYPE: str = "a-n-G"
 DEFAULT_UAS_COT_TYPE: str = "a-n-A-M-H-Q"

{dronecot-2.2.3 → dronecot-2.2.5}/src/dronecot/functions.py

@@ -74,6 +74,19 @@ def _pacific_timestamp() -> str:
     return datetime.now(tzinfo).strftime("%Y-%m-%d %H:%M:%S %Z")
 
 
+def _rf_band(channel) -> str:
+    """Map a Wi-Fi channel number to its RF band label (for SIGINT detail)."""
+    try:
+        ch = int(channel)
+    except (TypeError, ValueError):
+        return ""
+    if 1 <= ch <= 14:
+        return "2.4 GHz"
+    if 32 <= ch <= 196:
+        return "5 GHz"
+    return ""
+
+
 def _dji_feed_uses_text(config, feed_url: str, parsed) -> bool:
     """Return True if the configured DJI feed uses AntSDR text CSV format."""
     feed_format = str(config.get("FEED_FORMAT", "")).lower()
@@ -341,10 +354,19 @@ def rid_uas_to_cot_xml(  # NOQA pylint: disable=too-many-locals,too-many-branche
     sensor_type = str(src_data.get("type", dronecot.DEFAULT_SENSOR_PAYLOAD_TYPE))
     rssi = str(src_data.get("RSSI"))
 
+    # Receiver / SIGINT detail: what hardware saw this, how, and on what RF band.
+    sensor_model = str(config.get("SENSOR_MODEL", dronecot.DEFAULT_SENSOR_MODEL))
+    sensor_method = str(config.get("SENSOR_TYPE", dronecot.DEFAULT_SENSOR_TYPE))
+    channel = src_data.get("channel")
+    band = _rf_band(channel)
+
     cuas: ET.Element = ET.Element("__cuas")
     cuas.set("sensor_id", sensor_id)
+    cuas.set("sensor_model", sensor_model)
+    cuas.set("sensor_method", sensor_method)
     cuas.set("rssi", rssi)
-    cuas.set("channel", str(src_data.get("channel")))
+    cuas.set("channel", str(channel))
+    cuas.set("band", band)
     cuas.set("timestamp", str(src_data.get("timestamp")))
     cuas.set("mac_address", mac_address_text)
     cuas.set("type", sensor_type)
@@ -374,6 +396,11 @@ def rid_uas_to_cot_xml(  # NOQA pylint: disable=too-many-locals,too-many-branche
     else:
         callsign = f"{uasid[0:4]}...{uasid[-4:]}"
 
+    if rssi and rssi not in ("None", ""):
+        remarks_fields.append(f"RSSI: {rssi} dBm")
+    if channel is not None:
+        remarks_fields.append(f"Channel: {channel}{f' ({band})' if band else ''}")
+    remarks_fields.append(f"Receiver: {sensor_model} — {sensor_method}")
     remarks_fields.append(f"Sensor: {sensor_id}")
 
     contact: ET.Element = ET.Element("contact")

{dronecot-2.2.3 → dronecot-2.2.5}/src/dronecot/wifi_parse.py

@@ -157,9 +157,16 @@ def extract_odid_from_dot11(frame_bytes: bytes) -> Optional[Tuple[bytes, Dict[st
 
 
 def extract_odid_from_scapy_packet(packet) -> Optional[Tuple[bytes, Dict[str, Any]]]:
-    """Extract ODID from a Scapy packet (Dot11 layer)."""
+    """Extract ODID from a Scapy packet (Dot11 layer).
+
+    Delegates to the byte-level ``extract_odid_from_dot11`` parser on the
+    serialized Dot11 frame. This avoids a class of Scapy field-type bugs — e.g.
+    ``Dot11EltVendorSpecific.oui`` is an int, so ``bytes(elt.oui)`` builds a huge
+    zero buffer instead of the 3 OUI bytes and the ASTM vendor element never
+    matches — and keeps Wi-Fi Beacon and NAN decoding on one proven code path.
+    """
     try:
-        from scapy.layers.dot11 import Dot11, Dot11Beacon, Dot11EltVendorSpecific, RadioTap  # noqa
+        from scapy.layers.dot11 import Dot11, RadioTap  # noqa
     except ImportError:
         return None
 
@@ -167,40 +174,14 @@ def extract_odid_from_scapy_packet(packet) -> Optional[Tuple[bytes, Dict[str, An
         return None
 
     dot11 = packet.getlayer(Dot11)
-    meta: Dict[str, Any] = {"MAC address": dot11.addr2 or dot11.addr3 or ""}
+    result = extract_odid_from_dot11(bytes(dot11))
+    if not result:
+        return None
 
-    if packet.haslayer(RadioTap) and hasattr(packet[RadioTap], "dBm_AntSignal"):
-        rssi = packet[RadioTap].dBm_AntSignal
+    pack, meta = result
+    # Enrich with Scapy-only signal info when present.
+    if packet.haslayer(RadioTap):
+        rssi = getattr(packet[RadioTap], "dBm_AntSignal", None)
         if rssi is not None:
             meta["RSSI"] = int(rssi)
-
-    subtype = dot11.subtype
-
-    if subtype == 8:  # beacon
-        elt = packet.getlayer(Dot11EltVendorSpecific)
-        while elt:
-            if hasattr(elt, "oui") and hasattr(elt, "info"):
-                oui = bytes(elt.oui) if not isinstance(elt.oui, bytes) else elt.oui
-                info = bytes(elt.info) if elt.info else b""
-                ie_data = oui + info
-                pack = parse_beacon_vendor_ie(ie_data)
-                if pack:
-                    meta["type"] = "WiFi beacon"
-                    if dot11.IDinfo:
-                        meta["channel"] = int(getattr(dot11.IDinfo, "channel", 0) or 0)
-                    return pack, meta
-            elt = elt.payload.getlayer(Dot11EltVendorSpecific)
-    elif subtype == 13:  # action
-        raw = bytes(packet[Dot11].payload) if dot11.payload else b""
-        if not raw and packet.haslayer("Raw"):
-            raw = bytes(packet["Raw"].load)
-        frame = bytes(dot11.build()) + raw if raw else bytes(packet.build())
-        # Rebuild full frame for NAN parser
-        full = bytes(packet.build())
-        result = extract_odid_from_dot11(full)
-        if result:
-            pack, nan_meta = result
-            meta.update(nan_meta)
-            return pack, meta
-
-    return None
+    return pack, meta

dronecot-2.2.5/tests/test_sensor_detail.py

@@ -0,0 +1,54 @@
+"""Tests for the enriched sensor / SIGINT detail in the RID CoT payload."""
+
+import xml.etree.ElementTree as ET
+
+from dronecot.functions import _rf_band, rid_uas_to_cot_xml
+
+
+def test_rf_band():
+    assert _rf_band(6) == "2.4 GHz"
+    assert _rf_band("6") == "2.4 GHz"
+    assert _rf_band(44) == "5 GHz"
+    assert _rf_band(None) == ""
+    assert _rf_band("nope") == ""
+
+
+def _rid_data():
+    return {
+        "Latitude": 37.76,
+        "Longitude": -122.49,
+        "BasicID": "1787F04BM24010011195",
+        "SpeedHorizontal": 0,
+        "Direction": 0,
+        "AltitudeGeo": 10.0,
+        "data": {
+            "MAC address": "AA:BB:CC:DD:EE:FF",
+            "RSSI": -42,
+            "channel": 6,
+            "sensor_id": "wifi-rid",
+        },
+    }
+
+
+def test_rid_cot_carries_sensor_detail():
+    config = {
+        "SENSOR_MODEL": "Atheros AR9271",
+        "SENSOR_TYPE": "Wi-Fi Open Drone ID",
+    }
+    event = rid_uas_to_cot_xml(_rid_data(), config)
+    assert event is not None
+    xml = ET.tostring(event, encoding="unicode")
+
+    cuas = event.find(".//__cuas")
+    assert cuas is not None
+    assert cuas.get("sensor_model") == "Atheros AR9271"
+    assert cuas.get("sensor_method") == "Wi-Fi Open Drone ID"
+    assert cuas.get("band") == "2.4 GHz"
+    assert cuas.get("rssi") == "-42"
+    assert cuas.get("channel") == "6"
+
+    remarks = event.find(".//remarks")
+    assert remarks is not None and remarks.text
+    assert "RSSI: -42 dBm" in remarks.text
+    assert "2.4 GHz" in remarks.text
+    assert "Atheros AR9271" in remarks.text

dronecot-2.2.5/tests/test_wifi_parse.py

@@ -0,0 +1,53 @@
+"""Tests for Wi-Fi Open Drone ID frame parsing.
+
+Regression for the Scapy beacon path: ``Dot11EltVendorSpecific.oui`` is an int,
+so the old ``bytes(elt.oui)`` built a huge zero buffer and the ASTM vendor
+element never matched — ``extract_odid_from_scapy_packet`` decoded nothing even
+though ``extract_odid_from_dot11`` decoded the same frame.
+"""
+
+import struct
+
+import pytest
+
+from dronecot import wifi_parse
+
+
+def _astm_beacon_frame(pack_body: bytes) -> bytes:
+    """Build a raw 802.11 beacon carrying an ASTM ODID vendor IE."""
+    fc = struct.pack("<H", 0x0080)  # mgmt, subtype 8 (beacon)
+    dur = b"\x00\x00"
+    dst = b"\xff\xff\xff\xff\xff\xff"
+    src = b"\xaa\xbb\xcc\xdd\xee\xff"
+    bssid = src
+    seq = b"\x00\x00"
+    fixed = b"\x00" * 8 + b"\x64\x00" + b"\x00\x00"  # timestamp + interval + caps
+    # Vendor IE: OUI FA:0B:BC, type 0x0D, msg_counter 0x01, then the pack body.
+    ie_payload = wifi_parse.ASTM_WIFI_OUI + bytes([0x0D, 0x01]) + pack_body
+    ie = bytes([0xDD, len(ie_payload)]) + ie_payload
+    return fc + dur + dst + src + bssid + seq + fixed + ie
+
+
+def test_extract_odid_from_dot11_beacon():
+    body = bytes(range(25))
+    frame = _astm_beacon_frame(body)
+    result = wifi_parse.extract_odid_from_dot11(frame)
+    assert result is not None
+    pack, meta = result
+    assert pack == body
+    assert meta.get("type") == "WiFi beacon"
+
+
+def test_extract_odid_from_scapy_packet_matches_raw():
+    """The Scapy path must decode the same beacon the byte parser does."""
+    scapy_dot11 = pytest.importorskip("scapy.layers.dot11")
+    body = bytes(range(25))
+    frame = _astm_beacon_frame(body)
+    pkt = scapy_dot11.Dot11(frame)
+
+    raw = wifi_parse.extract_odid_from_dot11(frame)
+    viascapy = wifi_parse.extract_odid_from_scapy_packet(pkt)
+
+    assert raw is not None
+    assert viascapy is not None, "scapy path failed on a frame the byte parser decoded"
+    assert viascapy[0] == raw[0] == body

dronecot-2.2.3/src/dronecot/VERSION

@@ -1 +0,0 @@
-2.2.3