casambi-bt-revamped 0.3.12.dev4__py3-none-any.whl → 0.3.12.dev6__py3-none-any.whl

CasambiBt/__init__.py

@@ -3,6 +3,7 @@
 # Import everything that should be public
 # ruff: noqa: F401
 
+from ._version import __version__
 from ._casambi import Casambi
 from ._discover import discover
 from ._unit import (

CasambiBt/_client.py

@@ -4,6 +4,7 @@ import logging
 import os
 import platform
 import struct
+import time
 from binascii import b2a_hex as b2a
 from collections.abc import Callable
 from enum import Enum, IntEnum, auto, unique
@@ -54,6 +55,28 @@ class ProtocolMode(Enum):
     CLASSIC = auto()
 
 
+class _LogBurstLimiter:
+    """Simple in-process log rate limiter (per key).
+
+    Home Assistant warns if a logger emits too many messages. We keep some high-signal
+    WARNING logs for Classic reverse engineering but avoid spamming.
+    """
+
+    def __init__(self) -> None:
+        self._state: dict[str, tuple[float, int]] = {}
+
+    def allow(self, key: str, *, burst: int, window_s: float) -> bool:
+        now = time.monotonic()
+        start, count = self._state.get(key, (now, 0))
+        if (now - start) > window_s:
+            start, count = now, 0
+        if count >= burst:
+            self._state[key] = (start, count)
+            return False
+        self._state[key] = (start, count + 1)
+        return True
+
+
 MIN_VERSION: Final[int] = 10
 MAX_VERSION: Final[int] = 11
 
@@ -100,33 +123,45 @@ class CasambiClient:
         # Determined at runtime by inspecting GATT services/characteristics.
         self._protocolMode: ProtocolMode | None = None
         self._dataCharUuid: str | None = None
+        # EVO only: protocolVersion from the device-provided NodeInfo (byte1).
+        self._deviceProtocolVersion: int | None = None
 
         # Classic protocol state
         self._classicConnHash8: bytes | None = None
         self._classicTxSeq: int = 0  # 16-bit sequence number (big endian on the wire)
         self._classicCmdDiv: int = 0  # 8-bit per-command divider/id (matches u1.C1751c.b0)
-
-        # Avoid log spam in Home Assistant: raw notify hexdumps are opt-in.
-        self._logRawNotifies: bool = os.getenv("CASAMBI_BT_LOG_RAW_NOTIFIES", "").strip() in {
-            "1",
-            "true",
-            "TRUE",
-            "yes",
-            "YES",
-        }
+        # Classic header framing mode:
+        # - "conformant": [auth][sig][seq16][payload]
+        # - "legacy":     [sig][payload]
+        # Ground truth: casambi-android `t1.P.n(...)` and `t1.P.o(...)`.
+        self._classicHeaderMode: str | None = None  # "conformant" | "legacy"
+
+        # Rate limit WARNING logs (especially Classic RX) to keep HA usable.
+        self._logLimiter = _LogBurstLimiter()
+        self._classicRxFrames = 0
+        self._classicRxVerified = 0
+        self._classicRxUnverifiable = 0
+        self._classicRxParseFail = 0
+        self._classicRxLastStatsTs = time.monotonic()
 
     @property
     def protocolMode(self) -> ProtocolMode | None:
         return self._protocolMode
 
-    def _checkProtocolVersion(self, version: int) -> None:
+    def _checkProtocolVersion(self, version: int, *, source: str = "unknown") -> None:
         if version < MIN_VERSION:
-            raise UnsupportedProtocolVersion(
-                f"Legacy version aren't supported currently. Your network version is {version}. Minimum version is {MIN_VERSION}."
+            # Legacy protocol versions are intentionally allowed. We keep this check as a warning
+            # because packet layouts/handshakes may differ and we want actionable tester logs.
+            msg = (
+                f"Legacy protocol version detected ({source}={version}). "
+                f"Versions < {MIN_VERSION} are not fully verified; attempting to continue."
             )
+            self._logger.warning(msg)
+            return
         if version > MAX_VERSION:
             self._logger.warning(
-                "Version too new. Your network version is %i. Highest supported version is %i. Continue at your own risk.",
+                "Version too new (%s=%i). Highest supported version is %i. Continue at your own risk.",
+                source,
                 version,
                 MAX_VERSION,
             )
@@ -217,23 +252,50 @@ class CasambiClient:
         #  2) EVO: auth char read starts with 0x01 (NodeInfo)
         #  3) Classic "conformant": auth char read returns connection hash (first 8 bytes used)
 
+        cloud_protocol = getattr(self._network, "protocolVersion", None)
+        ca51_prefix: bytes | None = None
+        ca51_err: str | None = None
+        auth_prefix: bytes | None = None
+        auth_err: str | None = None
+        device_nodeinfo_protocol: int | None = None
+
+        def _log_probe_summary(mode: str) -> None:
+            # One stable, high-signal line for testers.
+            self._logger.warning(
+                "[CASAMBI_PROTOCOL_PROBE] address=%s mode=%s cloud_protocol=%s nodeinfo_b1=%s "
+                "data_uuid=%s classic_hash8_present=%s auth_read_prefix=%s ca51_read_prefix=%s ca51_read_error=%s auth_read_error=%s",
+                self.address,
+                mode,
+                cloud_protocol,
+                device_nodeinfo_protocol,
+                self._dataCharUuid,
+                bool(classic_hash and len(classic_hash) >= 8),
+                auth_prefix,
+                ca51_prefix,
+                ca51_err,
+                auth_err,
+            )
+
         classic_hash: bytes | None = None
         try:
             classic_hash = await self._gattClient.read_gatt_char(CASA_CLASSIC_HASH_CHAR_UUID)
-        except Exception:
+            ca51_prefix = b2a(classic_hash[:10]) if classic_hash else None
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_GATT_PROBE] read ca51 ok len=%d prefix=%s",
+                    0 if classic_hash is None else len(classic_hash),
+                    ca51_prefix,
+                )
+        except Exception as e:
             classic_hash = None
+            ca51_err = type(e).__name__
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug("[CASAMBI_GATT_PROBE] read ca51 fail err=%s", ca51_err)
 
         if classic_hash and len(classic_hash) >= 8:
-            if os.getenv("CASAMBI_BT_DISABLE_CLASSIC", "").strip() in {"1", "true", "TRUE", "yes", "YES"}:
-                raise ProtocolError("Classic protocol detected but disabled via CASAMBI_BT_DISABLE_CLASSIC=1")
-
-            if not self._network.hasClassicKeys():
-                raise ClassicKeysMissingError(
-                    "Classic protocol detected but network has no visitorKey/managerKey."
-                )
-
             self._protocolMode = ProtocolMode.CLASSIC
             self._dataCharUuid = CASA_CLASSIC_DATA_CHAR_UUID
+            self._classicHeaderMode = "legacy"
 
             # Read connection hash (first 8 bytes are used for CMAC signing).
             raw_hash = classic_hash
@@ -260,7 +322,12 @@ class CasambiClient:
             except Exception as e:
                 # Some firmwares may expose Classic signing on the EVO UUID instead.
                 # Fall through to auth-char probing if CA52 isn't available.
-                self._logger.debug("Classic CA52 notify failed; trying auth UUID probing.", exc_info=True)
+                if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug(
+                        "[CASAMBI_GATT_PROBE] start_notify ca52 fail err=%s; trying auth UUID probing.",
+                        type(e).__name__,
+                        exc_info=True,
+                    )
                 self._protocolMode = None
                 self._dataCharUuid = None
                 self._classicConnHash8 = None
@@ -270,36 +337,76 @@ class CasambiClient:
                 self._connectionState = ConnectionState.AUTHENTICATED
                 self._logger.info("Protocol mode selected: CLASSIC")
                 if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug("[CASAMBI_GATT_PROBE] start_notify ca52 ok")
                     self._logger.debug(
                         "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
                         len(self._classicConnHash8),
                         b2a(self._classicConnHash8),
                     )
+                _log_probe_summary("CLASSIC")
                 return
 
         # Conformant devices can expose the Classic signed channel on the EVO-style UUID too.
         first: bytes | None = None
         try:
             first = await self._gattClient.read_gatt_char(CASA_AUTH_CHAR_UUID)
-        except Exception:
+            auth_prefix = b2a(first[:10]) if first else None
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_GATT_PROBE] read auth ok len=%d first_byte=%s prefix=%s",
+                    0 if first is None else len(first),
+                    None if not first else f"0x{first[0]:02x}",
+                    auth_prefix,
+                )
+        except Exception as e:
             first = None
+            auth_err = type(e).__name__
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug("[CASAMBI_GATT_PROBE] read auth fail err=%s", auth_err)
 
         if first and len(first) >= 2 and first[0] == 0x01:
             # EVO NodeInfo packet starts with 0x01.
+            device_nodeinfo_protocol = first[1]
+            self._deviceProtocolVersion = device_nodeinfo_protocol
+            mtu = unit = flags = None
+            nonce_prefix = None
+            if len(first) >= 23:
+                try:
+                    mtu, unit, flags, nonce = struct.unpack_from(">BHH16s", first, 2)
+                    nonce_prefix = b2a(nonce[:8])
+                except Exception:
+                    if self._logger.isEnabledFor(logging.DEBUG):
+                        self._logger.debug("Failed to parse NodeInfo fields for logging.", exc_info=True)
+
+            self._logger.info(
+                "[CASAMBI_EVO_NODEINFO] cloud_protocol=%s nodeinfo_b1=%s mtu=%s unit=%s flags=%s nonce_prefix=%s len=%d prefix=%s",
+                cloud_protocol,
+                device_nodeinfo_protocol,
+                mtu,
+                unit,
+                None if flags is None else f"0x{flags:04x}",
+                nonce_prefix,
+                len(first),
+                b2a(first[: min(len(first), 32)]),
+            )
+            if len(first) < 23:
+                self._logger.warning(
+                    "[CASAMBI_EVO_NODEINFO_SHORT] len=%d cloud_protocol=%s nodeinfo_b1=%s prefix=%s",
+                    len(first),
+                    cloud_protocol,
+                    device_nodeinfo_protocol,
+                    b2a(first[: min(len(first), 32)]),
+                )
+
             self._protocolMode = ProtocolMode.EVO
             self._dataCharUuid = CASA_AUTH_CHAR_UUID
-            self._checkProtocolVersion(self._network.protocolVersion)
+            self._classicHeaderMode = None
             self._logger.info("Protocol mode selected: EVO")
+            _log_probe_summary("EVO")
             return
 
         if first is not None:
             # Otherwise, treat as Classic conformant: read provides connection hash.
-            if os.getenv("CASAMBI_BT_DISABLE_CLASSIC", "").strip() in {"1", "true", "TRUE", "yes", "YES"}:
-                raise ProtocolError("Classic protocol detected but disabled via CASAMBI_BT_DISABLE_CLASSIC=1")
-            if not self._network.hasClassicKeys():
-                raise ClassicKeysMissingError(
-                    "Classic protocol detected but network has no visitorKey/managerKey."
-                )
             if len(first) < 8:
                 raise ClassicHandshakeError(
                     f"Classic connection hash read failed/too short (len={len(first)})."
@@ -307,6 +414,7 @@ class CasambiClient:
 
             self._protocolMode = ProtocolMode.CLASSIC
             self._dataCharUuid = CASA_AUTH_CHAR_UUID
+            self._classicHeaderMode = "conformant"
             self._classicConnHash8 = bytes(first[:8])
             self._classicCmdDiv = int.from_bytes(os.urandom(1), "big") or 1
             self._classicTxSeq = 0
@@ -323,13 +431,16 @@ class CasambiClient:
             self._connectionState = ConnectionState.AUTHENTICATED
             self._logger.info("Protocol mode selected: CLASSIC")
             if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug("[CASAMBI_GATT_PROBE] start_notify auth ok (classic conformant)")
                 self._logger.debug(
                     "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
                     len(self._classicConnHash8),
                     b2a(self._classicConnHash8),
                 )
+            _log_probe_summary("CLASSIC")
             return
 
+        _log_probe_summary("UNKNOWN")
         raise ProtocolError(
             "No supported Casambi characteristics found (Classic ca51/ca52 or EVO/Classic-conformant auth char)."
         )
@@ -351,15 +462,38 @@ class CasambiClient:
         try:
             # Initiate communication with device
             firstResp = await self._gattClient.read_gatt_char(CASA_AUTH_CHAR_UUID)
-            self._logger.debug(f"Got {b2a(firstResp)}")
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_EVO_NODEINFO_RAW] len=%d prefix=%s",
+                    len(firstResp),
+                    b2a(firstResp[: min(len(firstResp), 32)]),
+                )
 
-            # Check type and protocol version
-            if not (
-                firstResp[0] == 0x1 and firstResp[1] == self._network.protocolVersion
-            ):
+            cloud_protocol = getattr(self._network, "protocolVersion", None)
+
+            # EVO key exchange expects the NodeInfo packet (0x01 ...).
+            if len(firstResp) < 2 or firstResp[0] != 0x01:
+                self._logger.error(
+                    "[CASAMBI_EVO_NODEINFO_UNEXPECTED] expected_prefix=01 len=%d prefix=%s",
+                    len(firstResp),
+                    b2a(firstResp[: min(len(firstResp), 32)]),
+                )
+                raise ProtocolError("Unexpected NodeInfo response while starting key exchange.")
+
+            device_protocol = firstResp[1]
+            self._deviceProtocolVersion = device_protocol
+            # Do not interpret NodeInfo byte1 as "cloud protocolVersion".
+            # Some firmwares use a different numbering scheme, so mismatch warnings are misleading.
+
+            if len(firstResp) < 23:
                 self._logger.error(
-                    "Unexpected answer from device! Wrong device or protocol version? Trying to continue."
+                    "[CASAMBI_EVO_NODEINFO_SHORT] len=%d cloud_protocol=%s nodeinfo_b1=%s prefix=%s",
+                    len(firstResp),
+                    cloud_protocol,
+                    device_protocol,
+                    b2a(firstResp[: min(len(firstResp), 32)]),
                 )
+                raise ProtocolError("NodeInfo response too short while starting key exchange.")
 
             # Parse device info
             self._mtu, self._unit, self._flags, self._nonce = struct.unpack_from(
@@ -449,14 +583,6 @@ class CasambiClient:
     def _callbackMulitplexer(
         self, handle: BleakGATTCharacteristic, data: bytes
     ) -> None:
-        if self._logRawNotifies and self._logger.isEnabledFor(logging.DEBUG):
-            self._logger.debug(
-                "Callback on handle %s (%s): %s",
-                getattr(handle, "handle", "?"),
-                getattr(handle, "uuid", "?"),
-                b2a(data),
-            )
-
         if self._connectionState == ConnectionState.CONNECTED:
             self._exchNofityCallback(handle, data)
         elif self._connectionState == ConnectionState.KEY_EXCHANGED:
@@ -598,7 +724,7 @@ class CasambiClient:
         # EVO sends INVOCATION operations (packet type=0x07) inside the encrypted channel.
         # Classic sends signed command frames on the CA52 channel.
         if self._protocolMode == ProtocolMode.CLASSIC:
-            await self._sendClassicSigned(packet)
+            await self._sendClassic(packet)
             return
 
         self._checkState(ConnectionState.AUTHENTICATED)
@@ -694,7 +820,7 @@ class CasambiClient:
 
         return bytes(b)
 
-    async def _sendClassicSigned(self, command_bytes: bytes, *, use_manager: bool | None = None) -> None:
+    async def _sendClassic(self, command_bytes: bytes) -> None:
         self._checkState(ConnectionState.AUTHENTICATED)
         if self._protocolMode != ProtocolMode.CLASSIC:
             raise ProtocolError("Classic send called while not in Classic protocol mode.")
@@ -703,72 +829,85 @@ class CasambiClient:
         if self._classicConnHash8 is None:
             raise ClassicHandshakeError("Classic connection hash not available.")
 
-        # Decide whether to use visitor or manager key.
-        if use_manager is None:
-            use_manager = os.getenv("CASAMBI_BT_CLASSIC_USE_MANAGER", "").strip() in {
-                "1",
-                "true",
-                "TRUE",
-                "yes",
-                "YES",
-            }
-
         visitor_key = self._network.classicVisitorKey()
         manager_key = self._network.classicManagerKey()
 
-        key_name = "visitor"
-        auth_level = 0x02
-        sig_len = 4
-        key = visitor_key
-
-        if use_manager or key is None:
-            if manager_key is None:
-                # If we were forced to use manager but don't have one, fall back to visitor if present.
-                if visitor_key is None:
-                    raise ClassicKeysMissingError(
-                        "Classic network has no visitorKey/managerKey available."
-                    )
-                key = visitor_key
-            else:
-                key_name = "manager"
-                auth_level = 0x03
-                sig_len = 16
-                key = manager_key
-
-        seq = self._classic_next_seq()
-
-        # Header layout (rVar.Z=true / "conformant" classic):
-        #   [0] auth_level (2 visitor / 3 manager)
-        #   [1..sig_len] CMAC prefix placeholder (filled after CMAC computation)
-        #   [1+sig_len .. 1+sig_len+1] 16-bit sequence, big endian (included in CMAC input)
-        #   [..] command bytes
+        # Key selection mirrors Android's intent:
+        # - Use manager key if our cloud session is manager and a managerKey exists.
+        # - Else use visitor key if present.
+        # - Else fall back to manager key if present.
+        # - Else send an unsigned frame (signature bytes remain zeros), which Android does when keys are null.
+        key_name = "none"
+        auth_level = 0x02  # visitor by default
+        key = None
+        if manager_key is not None and getattr(self._network, "isManager", lambda: False)():
+            key_name = "manager"
+            auth_level = 0x03
+            key = manager_key
+        elif visitor_key is not None:
+            key_name = "visitor"
+            auth_level = 0x02
+            key = visitor_key
+        elif manager_key is not None:
+            key_name = "manager"
+            auth_level = 0x03
+            key = manager_key
+
+        header_mode = self._classicHeaderMode or "conformant"
+
+        seq: int | None = None
+        sig_len: int
         pkt = bytearray()
-        pkt.append(auth_level)
-        pkt.extend(b"\x00" * sig_len)
-        pkt.extend(b"\x00\x00")
-        pkt.extend(command_bytes)
-
-        seq_off = 1 + sig_len
-        pkt[seq_off] = (seq >> 8) & 0xFF
-        pkt[seq_off + 1] = seq & 0xFF
 
-        cmac_input = bytes(pkt[seq_off:])  # includes seq + command bytes
-        prefix = classic_cmac_prefix(key, self._classicConnHash8, cmac_input, sig_len)
-        pkt[1 : 1 + sig_len] = prefix
+        if header_mode == "conformant":
+            sig_len = 16 if auth_level == 0x03 else 4
+            seq = self._classic_next_seq()
+
+            # Header layout (rVar.Z=true / "conformant" classic):
+            #   [0] auth_level (2 visitor / 3 manager)
+            #   [1..sig_len] CMAC prefix placeholder (filled after CMAC computation)
+            #   [1+sig_len .. 1+sig_len+1] 16-bit sequence, big endian (included in CMAC input)
+            #   [..] command bytes
+            pkt.append(auth_level)
+            pkt.extend(b"\x00" * sig_len)
+            pkt.extend(b"\x00\x00")
+            pkt.extend(command_bytes)
+
+            seq_off = 1 + sig_len
+            pkt[seq_off] = (seq >> 8) & 0xFF
+            pkt[seq_off + 1] = seq & 0xFF
+
+            if key is not None:
+                cmac_input = bytes(pkt[seq_off:])  # includes seq + command bytes
+                prefix = classic_cmac_prefix(key, self._classicConnHash8, cmac_input, sig_len)
+                pkt[1 : 1 + sig_len] = prefix
+
+        elif header_mode == "legacy":
+            # Legacy/non-conformant classic: only a 4-byte CMAC prefix, no auth byte, no seq.
+            sig_len = 4
+            pkt.extend(b"\x00" * sig_len)
+            pkt.extend(command_bytes)
+
+            if key is not None:
+                cmac_input = bytes(command_bytes)
+                prefix = classic_cmac_prefix(key, self._classicConnHash8, cmac_input, sig_len)
+                pkt[0:sig_len] = prefix
+        else:
+            raise ProtocolError(f"Unknown Classic header mode: {header_mode}")
 
-        if self._logger.isEnabledFor(logging.DEBUG):
-            self._logger.debug(
-                "[CASAMBI_CLASSIC_TX] key=%s auth=0x%02x sig_len=%d seq=0x%04x cmd_len=%d total_len=%d",
+        # WARNING-level TX logs are intentional: they are needed for Classic reverse engineering.
+        # Keep payload logging minimal (prefix only).
+        if self._logLimiter.allow("classic_tx", burst=50, window_s=60.0):
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_TX] header=%s key=%s auth=0x%02x sig_len=%d seq=%s cmd_len=%d total_len=%d prefix=%s",
+                header_mode,
                 key_name,
                 auth_level,
                 sig_len,
-                seq,
+                None if seq is None else f"0x{seq:04x}",
                 len(command_bytes),
                 len(pkt),
-            )
-            self._logger.debug(
-                "[CASAMBI_CLASSIC_TX_RAW] %s",
-                b2a(bytes(pkt[: min(len(pkt), 64)])) + (b"..." if len(pkt) > 64 else b""),
+                b2a(bytes(pkt[: min(len(pkt), 24)])),
             )
 
         # Classic packets can exceed 20 bytes when using a 16-byte manager signature.
@@ -851,6 +990,7 @@ class CasambiClient:
         Ground truth: casambi-android `t1.P.o(...)`.
         """
         self._inPacketCount += 1
+        self._classicRxFrames += 1
 
         raw = bytes(data)
         if self._logger.isEnabledFor(logging.DEBUG):
@@ -861,69 +1001,226 @@ class CasambiClient:
             )
 
         if self._classicConnHash8 is None:
-            self._logger.debug("[CASAMBI_CLASSIC_RX] Missing connection hash; cannot verify CMAC.")
+            if self._logLimiter.allow("classic_rx_no_hash", burst=5, window_s=60.0):
+                self._logger.warning("[CASAMBI_CLASSIC_RX] missing_connection_hash len=%d", len(raw))
             return
 
         visitor_key = self._network.classicVisitorKey()
         manager_key = self._network.classicManagerKey()
 
-        verified = False
-        key_name: str | None = None
-        sig_len: int | None = None
-        payload_with_seq: bytes | None = None
+        def _plausible_payload(payload: bytes) -> bool:
+            if not payload:
+                return False
+            if payload[0] in (
+                IncommingPacketType.UnitState,
+                IncommingPacketType.SwitchEvent,
+                IncommingPacketType.NetworkConfig,
+            ):
+                return True
+            # Classic command record stream: record[0] = (len+239) mod 256
+            if len(payload) >= 2:
+                rec_len = (payload[0] - 239) & 0xFF
+                if 2 <= rec_len <= len(payload):
+                    return True
+            return False
+
+        def _score(verified: bool | None, payload: bytes) -> int:
+            plausible = _plausible_payload(payload)
+            if verified is True:
+                return 100
+            if plausible and verified is None:
+                return 50
+            if plausible and verified is False:
+                return 20
+            return 0
+
+        def _parse_conformant(raw_bytes: bytes) -> dict[str, Any] | None:
+            if len(raw_bytes) < 1 + 4 + 2:
+                return None
+            auth_level = raw_bytes[0]
+            if auth_level == 0x02:
+                sig_len = 4
+                key_name = "visitor"
+                key = visitor_key
+            elif auth_level == 0x03:
+                sig_len = 16
+                key_name = "manager"
+                key = manager_key
+            else:
+                return None
+
+            header_len = 1 + sig_len + 2
+            if len(raw_bytes) < header_len:
+                return None
 
-        # Try visitor (4-byte prefix) first, then manager (16-byte prefix).
-        # Some frames may be unsigned; in that case verification will fail and we'll fall back.
-        candidates: list[tuple[str, bytes | None, int]] = [
-            ("visitor", visitor_key, 4),
-            ("manager", manager_key, 16),
-        ]
+            sig = raw_bytes[1 : 1 + sig_len]
+            cmac_input = raw_bytes[1 + sig_len :]  # seq(2) + payload
+            seq = int.from_bytes(cmac_input[:2], byteorder="big", signed=False)
+            payload = cmac_input[2:]
 
-        for name, key, slen in candidates:
+            verified: bool | None
             if key is None:
-                continue
-            header_len = 1 + slen + 2
-            if len(raw) < header_len:
-                continue
-
-            auth_level = raw[0]
-            sig = raw[1 : 1 + slen]
-            cmac_input = raw[1 + slen :]  # seq(2) + payload
+                verified = None
+            else:
+                try:
+                    expected = classic_cmac_prefix(key, self._classicConnHash8, cmac_input, sig_len)
+                except Exception:
+                    verified = False
+                else:
+                    verified = expected == sig
+
+            return {
+                "mode": "conformant",
+                "auth_level": auth_level,
+                "sig_len": sig_len,
+                "seq": seq,
+                "key_name": key_name if key is not None else None,
+                "verified": verified,
+                "payload": payload,
+            }
 
-            try:
-                expected = classic_cmac_prefix(key, self._classicConnHash8, cmac_input, slen)
-            except Exception:
-                continue
+        def _parse_legacy(raw_bytes: bytes, *, sig_len: int) -> dict[str, Any] | None:
+            if len(raw_bytes) < sig_len + 1:
+                return None
+            sig = raw_bytes[:sig_len]
+            payload = raw_bytes[sig_len:]
+
+            # In non-conformant mode Android still selects visitor/manager key for CMAC,
+            # but the header contains only the CMAC prefix (typically 4 bytes).
+            verified: bool | None = None
+            key_name: str | None = None
+
+            keys_to_try: list[tuple[str, bytes | None]] = [
+                ("visitor", visitor_key),
+                ("manager", manager_key),
+            ]
+            any_key = any(k is not None for _, k in keys_to_try)
+            if any_key:
+                verified = False
+                for nm, key in keys_to_try:
+                    if key is None:
+                        continue
+                    try:
+                        expected = classic_cmac_prefix(key, self._classicConnHash8, payload, sig_len)
+                    except Exception:
+                        continue
+                    if expected == sig:
+                        verified = True
+                        key_name = nm
+                        break
 
-            if expected == sig:
-                verified = True
-                key_name = name
-                sig_len = slen
-                payload_with_seq = cmac_input
-                if self._logger.isEnabledFor(logging.DEBUG):
-                    seq = int.from_bytes(cmac_input[:2], byteorder="big", signed=False)
-                    self._logger.debug(
-                        "[CASAMBI_CLASSIC_RX_VERIFY] ok key=%s auth=0x%02x sig_len=%d seq=0x%04x",
-                        name,
-                        auth_level,
-                        slen,
-                        seq,
-                    )
-                break
+            return {
+                "mode": "legacy",
+                "auth_level": None,
+                "sig_len": sig_len,
+                "seq": None,
+                "key_name": key_name,
+                "verified": verified,
+                "payload": payload,
+            }
 
-        if not verified:
-            if self._logger.isEnabledFor(logging.DEBUG):
-                self._logger.debug("[CASAMBI_CLASSIC_RX_VERIFY] failed (no matching CMAC prefix)")
-            # Best-effort: treat raw bytes as payload.
-            payload = raw
+        # Try the currently selected header mode first, then fall back.
+        # Some mixed/legacy setups differ between CA52 (legacy) and auth-UUID (conformant).
+        parsed_candidates: list[dict[str, Any]] = []
+        preferred = self._classicHeaderMode or "conformant"
+        if preferred == "legacy":
+            for sl in (4, 16):
+                r = _parse_legacy(raw, sig_len=sl)
+                if r is not None:
+                    parsed_candidates.append(r)
+            r = _parse_conformant(raw)
+            if r is not None:
+                parsed_candidates.append(r)
         else:
-            assert payload_with_seq is not None
-            # Drop the 16-bit sequence from the payload for higher-level parsing.
-            payload = payload_with_seq[2:]
+            r = _parse_conformant(raw)
+            if r is not None:
+                parsed_candidates.append(r)
+            for sl in (4, 16):
+                r = _parse_legacy(raw, sig_len=sl)
+                if r is not None:
+                    parsed_candidates.append(r)
+
+        if not parsed_candidates:
+            self._classicRxParseFail += 1
+            if self._logLimiter.allow("classic_rx_parse_fail", burst=5, window_s=60.0):
+                self._logger.warning(
+                    "[CASAMBI_CLASSIC_RX_PARSE_FAIL] len=%d prefix=%s",
+                    len(raw),
+                    b2a(raw[: min(len(raw), 32)]),
+                )
+            return
 
-        if not payload:
+        # Choose best candidate by score; tie-breaker prefers current mode.
+        for c in parsed_candidates:
+            c["score"] = _score(c["verified"], c["payload"])
+
+        parsed_candidates.sort(
+            key=lambda c: (
+                c["score"],
+                1 if c["mode"] == preferred else 0,
+                -c["sig_len"],
+            ),
+            reverse=True,
+        )
+        best = parsed_candidates[0]
+
+        if best["score"] == 0:
+            self._classicRxParseFail += 1
+            if self._logLimiter.allow("classic_rx_unplausible", burst=5, window_s=60.0):
+                self._logger.warning(
+                    "[CASAMBI_CLASSIC_RX_UNPLAUSIBLE] preferred=%s len=%d prefix=%s",
+                    preferred,
+                    len(raw),
+                    b2a(raw[: min(len(raw), 32)]),
+                )
             return
 
+        payload = best["payload"]
+        verified = best["verified"]
+        if verified is True:
+            self._classicRxVerified += 1
+        elif verified is None:
+            self._classicRxUnverifiable += 1
+
+        # Auto-correct header mode if the other format parses much better.
+        if best["mode"] != preferred:
+            # Only switch if we got a stronger signal (verified or plausible payload with fewer assumptions).
+            if best["score"] >= 50 and self._logLimiter.allow("classic_rx_mode_switch", burst=3, window_s=3600.0):
+                self._logger.warning(
+                    "[CASAMBI_CLASSIC_RX_MODE] switching %s -> %s (score=%d verified=%s sig_len=%d)",
+                    preferred,
+                    best["mode"],
+                    best["score"],
+                    verified,
+                    best["sig_len"],
+                )
+            self._classicHeaderMode = best["mode"]
+
+        # Sample RX logs (limited) + periodic stats (limited).
+        if self._logLimiter.allow("classic_rx_sample", burst=10, window_s=60.0):
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_RX] header=%s verified=%s auth=%s sig_len=%d seq=%s payload_prefix=%s",
+                best["mode"],
+                verified,
+                None if best["auth_level"] is None else f"0x{best['auth_level']:02x}",
+                best["sig_len"],
+                None if best["seq"] is None else f"0x{best['seq']:04x}",
+                b2a(payload[: min(len(payload), 32)]),
+            )
+        now = time.monotonic()
+        if (now - self._classicRxLastStatsTs) > 60.0 and self._logLimiter.allow(
+            "classic_rx_stats", burst=2, window_s=60.0
+        ):
+            self._classicRxLastStatsTs = now
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_RX_STATS] frames=%d verified=%d unverifiable=%d parse_fail=%d header=%s",
+                self._classicRxFrames,
+                self._classicRxVerified,
+                self._classicRxUnverifiable,
+                self._classicRxParseFail,
+                self._classicHeaderMode,
+            )
+
         # If the payload starts with a known EVO packet type, reuse existing parsers.
         packet_type = payload[0]
         if packet_type in (IncommingPacketType.UnitState, IncommingPacketType.SwitchEvent, IncommingPacketType.NetworkConfig):

CasambiBt/_network.py

@@ -1,9 +1,10 @@
 import json
 import logging
+import platform
 import pickle
 from dataclasses import dataclass
 from datetime import datetime, timedelta
-from typing import Final, cast
+from typing import Any, Final, cast
 
 import httpx
 from httpx import AsyncClient, RequestError
@@ -12,6 +13,7 @@ from ._cache import Cache
 from ._constants import DEVICE_NAME
 from ._keystore import KeyStore
 from ._unit import Group, Scene, Unit, UnitControl, UnitControlType, UnitType
+from ._version import __version__
 from .errors import (
     AuthenticationError,
     NetworkNotFoundError,
@@ -64,6 +66,30 @@ class Network:
 
         self._cache = cache
 
+        # Android always includes a "token" (and typically "clientInfo") in cloud requests.
+        # We keep these stable for the process lifetime to make tester logs comparable.
+        self._token: str = self._make_token()
+        self._clientInfo: dict[str, Any] = self._make_client_info()
+
+    @staticmethod
+    def _make_token() -> str:
+        # Ground truth: casambi-android `w1.o.p(...)` sends `token` for session requests.
+        #
+        # Keep this structured (Android uses "brand/model/device/cpu/unknown") but avoid hostnames/PII.
+        sys = platform.system().lower() or "unknown"
+        machine = platform.machine().lower() or "unknown"
+        return f"python/{sys}/{machine}/unknown/unknown"
+
+    @staticmethod
+    def _make_client_info() -> dict[str, Any]:
+        # Ground truth: casambi-android `w1.o.g(...)` includes `clientInfo`.
+        return {
+            "name": "casambi-bt-revamped",
+            "version": __version__,
+            "python": platform.python_version(),
+            "platform": platform.platform(),
+        }
+
     async def load(self) -> None:
         self._keystore = KeyStore(self._cache)
         await self._keystore.load()
@@ -150,6 +176,10 @@ class Network:
             return False
         return not self._session.expired()
 
+    def isManager(self) -> bool:
+        """Whether the current cloud session has manager privileges."""
+        return bool(self._session and self._session.manager)
+
     @property
     def keyStore(self) -> KeyStore:
         return self._keystore
@@ -186,7 +216,12 @@ class Network:
         getSessionUrl = f"https://api.casambi.com/network/{self._id}/session"
 
         res = await self._httpClient.post(
-            getSessionUrl, json={"password": password, "deviceName": DEVICE_NAME}
+            getSessionUrl,
+            json={
+                "token": self._token,
+                "password": password,
+                "deviceName": DEVICE_NAME,
+            },
         )
         if res.status_code == httpx.codes.OK:
             # Parse session
@@ -232,7 +267,9 @@ class Network:
                     getNetworkUrl,
                     json={
                         "formatVersion": 1,
+                        "token": self._token,
                         "deviceName": DEVICE_NAME,
+                        "clientInfo": self._clientInfo,
                         "revision": self._networkRevision,
                     },
                     headers={"X-Casambi-Session": self._session.session},  # type: ignore[union-attr]
@@ -302,15 +339,23 @@ class Network:
 
             self._classicVisitorKey = _parse_hex_key(visitor_hex)
             self._classicManagerKey = _parse_hex_key(manager_hex)
-            self._logger.info(
-                "Classic keys present: visitor=%s manager=%s",
-                bool(self._classicVisitorKey),
-                bool(self._classicManagerKey),
-            )
+            if not (self._classicVisitorKey or self._classicManagerKey):
+                # Android still sends Classic frames even when keys are null (signature bytes remain zeros).
+                # We need this as a loud hint for testers when Classic control doesn't work yet.
+                self._logger.warning(
+                    "[CASAMBI_CLASSIC_KEYS_MISSING] visitorKey=false managerKey=false"
+                )
+            else:
+                self._logger.info(
+                    "Classic keys present: visitor=%s manager=%s",
+                    bool(self._classicVisitorKey),
+                    bool(self._classicManagerKey),
+                )
 
         # Parse units
         self.units = []
         units = network["network"]["units"]
+        units_with_security_key = 0
         for u in units:
             uType = await self._fetchUnitInfo(u["type"])
             if uType is None:
@@ -318,6 +363,23 @@ class Network:
                     "Failed to fetch type for unit %i. Skipping.", u["type"]
                 )
                 continue
+
+            security_key: bytes | None = None
+            sec_hex = u.get("securityKey")
+            if isinstance(sec_hex, str):
+                sec_hex = sec_hex.strip()
+                if sec_hex:
+                    try:
+                        security_key = bytes.fromhex(sec_hex)
+                    except ValueError:
+                        self._logger.debug(
+                            "Invalid unit securityKey hex for unit %s (len=%d).",
+                            u.get("deviceID"),
+                            len(sec_hex),
+                        )
+            if security_key is not None:
+                units_with_security_key += 1
+
             uObj = Unit(
                 u["type"],
                 u["deviceID"],
@@ -326,9 +388,24 @@ class Network:
                 u["name"],
                 str(u["firmware"]),
                 uType,
+                securityKey=security_key,
             )
             self.units.append(uObj)
 
+        # One compact profile line to help interpret mixed/legacy networks from tester logs.
+        # Keep EVO networks at INFO to avoid noisy HA warnings; elevate legacy (<10) to WARNING.
+        level = logging.WARNING if self._protocolVersion < 10 else logging.INFO
+        self._logger.log(
+            level,
+            "[CASAMBI_NETWORK_PROFILE] uuid=%s id=%s protocolVersion=%s units=%d units_with_securityKey=%d keyStore=%s",
+            self._uuid,
+            self._id,
+            self._protocolVersion,
+            len(self.units),
+            units_with_security_key,
+            "keyStore" in network["network"],
+        )
+
         # Parse cells
         self.groups = []
         cells = network["network"]["grid"]["cells"]

CasambiBt/_unit.py

@@ -330,6 +330,7 @@ class Unit:
     :ivar firmwareVersion: Firmware version of the unit.
 
     :ivar unitType: Type of the unit. Determines the capabilities.
+    :ivar securityKey: Optional per-unit key (seen on some legacy/mixed networks). Not used yet.
     """
 
     _typeId: int
@@ -340,6 +341,7 @@ class Unit:
     firmwareVersion: str
 
     unitType: UnitType
+    securityKey: bytes | None = None
 
     _state: UnitState | None = None
     _on: bool = False

CasambiBt/_version.py

@@ -0,0 +1,10 @@
+"""Package version (kept in-sync with setup.cfg).
+
+Home Assistant integrations sometimes run with strict event-loop blocking checks.
+Avoid using importlib.metadata in hot paths by providing a static version string.
+"""
+
+__all__ = ["__version__"]
+
+# NOTE: Must match `casambi-bt/setup.cfg` [metadata] version.
+__version__ = "0.3.12.dev6"

{casambi_bt_revamped-0.3.12.dev4.dist-info → casambi_bt_revamped-0.3.12.dev6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev4
+Version: 0.3.12.dev6
 Summary: Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie

{casambi_bt_revamped-0.3.12.dev4.dist-info → casambi_bt_revamped-0.3.12.dev6.dist-info}/RECORD

@@ -1,21 +1,22 @@
-CasambiBt/__init__.py,sha256=TW445xSu5PV3TyMjJfwaA1JoWvQQ8LXhZgGdDTfWf3s,302
+CasambiBt/__init__.py,sha256=iJdTF4oeXfj5d5gfGxQkacqUjtnQo0IW-zFPJvFjWWk,336
 CasambiBt/_cache.py,sha256=3bQil8vhSy4f4sf9JusMfEdQC7d3cJuva9qHhyKro-0,3808
 CasambiBt/_casambi.py,sha256=TN4ecgjm95nSJ4h9TsKayNn577Y82fdsGK4IGUZF23Q,40666
 CasambiBt/_classic_crypto.py,sha256=6DcCOdjLQo7k2cOOutNdUKupykOG_E2TDDwg6fH-ODM,998
-CasambiBt/_client.py,sha256=yTSuAeJhBXp5Zs3jU-RvHFEpI-quRNwlB3HWGl7q_yY,50730
+CasambiBt/_client.py,sha256=PNYBwMdehh-YvSdxf8I-74bpn008VjNvwZyru5H_LuM,63618
 CasambiBt/_constants.py,sha256=sbElg5W8eeQvvL1rHn_E0jhP1wOrrabc7dFLLnlDMsU,810
 CasambiBt/_discover.py,sha256=jLc6H69JddrCURgtANZEjws6_UbSzXJtvJkbKTaIUHY,1849
 CasambiBt/_encryption.py,sha256=CLcoOOrggQqhJbnr_emBnEnkizpWDvb_0yFnitq4_FM,3831
 CasambiBt/_invocation.py,sha256=fkG4R0Gv5_amFfD_P6DKuIEe3oKWZW0v8RSU8zDjPdI,2985
 CasambiBt/_keystore.py,sha256=Jdiq0zMPDmhfpheSojKY6sTUpmVrvX_qOyO7yCYd3kw,2788
-CasambiBt/_network.py,sha256=DdUSWWFgifc-PhjGbBxSzBntu8CJrsbp6aMYuD1D-Gg,16465
+CasambiBt/_network.py,sha256=UMGpB-seAXtfwPS7pvXTieLf9ekFXgvy57tAfcc_cno,19779
 CasambiBt/_operation.py,sha256=Q5UccsrtNp_B_wWqwH_3eLFW_yF6A55FMmfUKDk2WrI,1059
 CasambiBt/_switch_events.py,sha256=S8OD0dBcw5T4J2C7qfmOQMnTJ7omIXRUYv4PqDOB87E,13137
-CasambiBt/_unit.py,sha256=KIpvUT_Wm-O2Lmb1JVnNO625-j5j7GqufmZzfTR-jW0,18587
+CasambiBt/_unit.py,sha256=nxbg_8UCCVB9WI8dUS21g2JrGyPKcefqKMSusMOhLOo,18721
+CasambiBt/_version.py,sha256=spRApATilqicOYCOi-3PEHxfpK9lOYP1fW1ufdiSN5Q,337
 CasambiBt/errors.py,sha256=1L_Q8og_N_BRYEKizghAQXr6tihlHykFgtcCHUDcBas,1961
 CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casambi_bt_revamped-0.3.12.dev4.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
-casambi_bt_revamped-0.3.12.dev4.dist-info/METADATA,sha256=DKE1xb6Jg8lORTpoWyiM8qaSBOXOb5V_l7phDqWHGBA,5877
-casambi_bt_revamped-0.3.12.dev4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-casambi_bt_revamped-0.3.12.dev4.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
-casambi_bt_revamped-0.3.12.dev4.dist-info/RECORD,,
+casambi_bt_revamped-0.3.12.dev6.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.12.dev6.dist-info/METADATA,sha256=mwWxQMdafeUx5y1uwhn-n_CegEkuzS9uJ4hODJJ0RI8,5877
+casambi_bt_revamped-0.3.12.dev6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+casambi_bt_revamped-0.3.12.dev6.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.12.dev6.dist-info/RECORD,,