casambi-bt-revamped 0.3.12.dev2__py3-none-any.whl → 0.3.12.dev3__py3-none-any.whl

CasambiBt/_casambi.py

@@ -10,7 +10,7 @@ from bleak.backends.device import BLEDevice
 from httpx import AsyncClient, RequestError
 
 from ._cache import Cache
-from ._client import CasambiClient, ConnectionState, IncommingPacketType
+from ._client import CasambiClient, ConnectionState, IncommingPacketType, ProtocolMode
 from ._network import Network
 from ._operation import OpCode, OperationsContext
 from ._unit import Group, Scene, Unit, UnitControlType, UnitState
@@ -169,8 +169,10 @@ class Casambi:
         self._casaClient = cast(CasambiClient, self._casaClient)
         await self._casaClient.connect()
         try:
-            await self._casaClient.exchangeKey()
-            await self._casaClient.authenticate()
+            # EVO requires key exchange + authenticate; Classic is ready after `connect()`.
+            if self._casaClient.protocolMode == ProtocolMode.EVO:
+                await self._casaClient.exchangeKey()
+                await self._casaClient.authenticate()
         except ProtocolError as e:
             await self._casaClient.disconnect()
             raise e
@@ -201,6 +203,23 @@ class Casambi:
             raise ValueError()
 
         payload = level.to_bytes(1, byteorder="big", signed=False)
+
+        # Classic protocol uses signed command frames (u1.C1753e / u1.EnumC1754f).
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals (ground truth: casambi-android u1.EnumC1754f):
+            # - AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(4, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetLevel)
 
     async def setVertical(self, target: Unit | Group | None, vertical: int) -> None:
@@ -219,6 +238,21 @@ class Casambi:
             raise ValueError()
 
         payload = vertical.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsVertical=22, UnitVertical=24, GroupVertical=29
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(24, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(29, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(22, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetVertical)
 
     async def setSlider(self, target: Unit | Group | None, value: int) -> None:
@@ -255,6 +289,21 @@ class Casambi:
             raise ValueError()
 
         payload = level.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsWhite=23, UnitWhite=25, GroupWhite=30
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(25, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(30, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(23, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetWhite)
 
     async def setColor(
@@ -272,6 +321,27 @@ class Casambi:
         :raises ValueError: The supplied rgbColor isn't in range
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses RGB payload (3 bytes) directly.
+            r, g, b = rgbColor
+            if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255):
+                raise ValueError("rgbColor out of range.")
+            payload = bytes([r & 0xFF, g & 0xFF, b & 0xFF])
+
+            # EnumC1754f ordinals: AllUnitsColor=6, UnitColor=9, GroupColor=28
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(9, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(28, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(6, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
+        # Evolution uses HS payload (hue 10-bit + sat 8-bit) for SetColor.
         state = UnitState()
         state.rgb = rgbColor
         hs: tuple[float, float] = state.hs  # type: ignore[assignment]
@@ -300,6 +370,21 @@ class Casambi:
 
         temperature = int(temperature / 50)
         payload = temperature.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsTemperature=5, UnitTemperature=8, GroupTemperature=27
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(8, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(27, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(5, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetTemperature)
 
     async def setColorXY(
@@ -317,6 +402,10 @@ class Casambi:
         :raises ValueError: The supplied XYColor isn't in range or not supported by the supplied unit.
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic command set (u1.EnumC1754f) only exposes RGB color control.
+            raise ValueError("XY color control is not supported on Classic networks.")
+
         if xyColor[0] < 0.0 or xyColor[0] > 1.0 or xyColor[1] < 0.0 or xyColor[1] > 1.0:
             raise ValueError("Color out of range.")
 
@@ -345,6 +434,22 @@ class Casambi:
         :return: Nothing is returned by this function. To get the new state register a change handler.
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses a longer payload for "restore last level" (ground truth: casambi-android u1.C1751c.o()).
+            payload = bytes([0xFF, 0x01, 0x00, 0x00, 0x01])
+            # EnumC1754f ordinals: AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(4, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         # Use -1 to indicate special packet format
         # Use RestoreLastLevel flag (1) and UseFullTimeFlag (4).
         # Not sure what UseFullTime does but this is what the app uses.
@@ -367,6 +472,11 @@ class Casambi:
                 ConnectionState.AUTHENTICATED,
                 ConnectionState.NONE,
             )
+        if self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses a completely different command encoding (u1.C1753e/u1.EnumC1754f).
+            # Public APIs that support Classic handle it explicitly; anything reaching here would
+            # send an EVO INVOCATION packet which is not valid on Classic.
+            raise ProtocolError(f"Operation {opcode.name} is not supported on Classic networks via INVOCATION.")
 
         targetCode = 0
         if isinstance(target, Unit):

CasambiBt/_classic_crypto.py

@@ -0,0 +1,31 @@
+"""Classic Casambi protocol helpers (CMAC signing/verification).
+
+Ground truth:
+- casambi-android `t1.P.o(...)` calculates a CMAC over:
+    connection_hash[0:8] + payload
+  and stores the CMAC (prefix) into the packet header.
+"""
+
+from __future__ import annotations
+
+from cryptography.hazmat.primitives.cmac import CMAC
+from cryptography.hazmat.primitives.ciphers.algorithms import AES
+
+
+def classic_cmac(key: bytes, conn_hash8: bytes, payload: bytes) -> bytes:
+    """Compute the Classic CMAC (16 bytes) over connection hash + payload."""
+    if len(conn_hash8) != 8:
+        raise ValueError("conn_hash8 must be 8 bytes")
+    cmac = CMAC(AES(key))
+    cmac.update(conn_hash8)
+    cmac.update(payload)
+    return cmac.finalize()
+
+
+def classic_cmac_prefix(
+    key: bytes, conn_hash8: bytes, payload: bytes, prefix_len: int
+) -> bytes:
+    """Return the prefix bytes that are embedded into the Classic packet header."""
+    mac = classic_cmac(key, conn_hash8, payload)
+    return mac[:prefix_len]
+

CasambiBt/_client.py

@@ -1,11 +1,12 @@
 import asyncio
 import inspect
 import logging
+import os
 import platform
 import struct
 from binascii import b2a_hex as b2a
 from collections.abc import Callable
-from enum import IntEnum, unique
+from enum import Enum, IntEnum, auto, unique
 from hashlib import sha256
 from typing import Any, Final
 
@@ -23,6 +24,8 @@ from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives.asymmetric import ec
 
 from ._constants import CASA_AUTH_CHAR_UUID, ConnectionState
+from ._constants import CASA_CLASSIC_DATA_CHAR_UUID, CASA_CLASSIC_HASH_CHAR_UUID
+from ._classic_crypto import classic_cmac_prefix
 from ._encryption import Encryptor
 from ._network import Network
 from ._switch_events import SwitchEventStreamDecoder
@@ -31,6 +34,8 @@ from ._switch_events import SwitchEventStreamDecoder
 from .errors import (  # noqa: E402
     BluetoothError,
     ConnectionStateError,
+    ClassicHandshakeError,
+    ClassicKeysMissingError,
     NetworkNotFoundError,
     ProtocolError,
     UnsupportedProtocolVersion,
@@ -44,6 +49,11 @@ class IncommingPacketType(IntEnum):
     NetworkConfig = 9
 
 
+class ProtocolMode(Enum):
+    EVO = auto()
+    CLASSIC = auto()
+
+
 MIN_VERSION: Final[int] = 10
 MAX_VERSION: Final[int] = 11
 
@@ -87,7 +97,27 @@ class CasambiClient:
         self._disconnectedCallback = disonnectedCallback
         self._activityLock = asyncio.Lock()
 
-        self._checkProtocolVersion(network.protocolVersion)
+        # Determined at runtime by inspecting GATT services/characteristics.
+        self._protocolMode: ProtocolMode | None = None
+        self._dataCharUuid: str | 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",
+        }
+
+    @property
+    def protocolMode(self) -> ProtocolMode | None:
+        return self._protocolMode
 
     def _checkProtocolVersion(self, version: int) -> None:
         if version < MIN_VERSION:
@@ -177,6 +207,115 @@ class CasambiClient:
         self._logger.info(f"Connected to {self.address}")
         self._connectionState = ConnectionState.CONNECTED
 
+        # Detect protocol mode by available characteristics.
+        services = await self._gattClient.get_services()
+
+        def _has_char(uuid: str) -> bool:
+            uuid_l = uuid.lower()
+            for s in services:
+                for c in s.characteristics:
+                    if c.uuid.lower() == uuid_l:
+                        return True
+            return False
+
+        # Classic (non-conformant) uses CA51 (connection hash) + CA52 (data channel).
+        if _has_char(CASA_CLASSIC_HASH_CHAR_UUID) and _has_char(CASA_CLASSIC_DATA_CHAR_UUID):
+            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
+
+            # Read connection hash (first 8 bytes are used for CMAC signing).
+            raw_hash = await self._gattClient.read_gatt_char(CASA_CLASSIC_HASH_CHAR_UUID)
+            if raw_hash is None or len(raw_hash) < 8:
+                raise ClassicHandshakeError(
+                    f"Classic connection hash read failed/too short (len={0 if raw_hash is None else len(raw_hash)})."
+                )
+            self._classicConnHash8 = bytes(raw_hash[:8])
+            # Android seeds the command divider with a random byte on startup (u1.C1751c).
+            self._classicCmdDiv = int.from_bytes(os.urandom(1), "big") or 1
+            self._classicTxSeq = 0
+
+            # Start notify on the data channel.
+            notify_kwargs: dict[str, Any] = {}
+            notify_params = inspect.signature(self._gattClient.start_notify).parameters
+            if "bluez" in notify_params:
+                notify_kwargs["bluez"] = {"use_start_notify": True}
+            await self._gattClient.start_notify(
+                CASA_CLASSIC_DATA_CHAR_UUID,
+                self._queueCallback,
+                **notify_kwargs,
+            )
+
+            # Classic has no EVO-style key exchange/auth; we can send immediately.
+            self._connectionState = ConnectionState.AUTHENTICATED
+            self._logger.info("Protocol mode selected: CLASSIC")
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
+                    len(self._classicConnHash8),
+                    b2a(self._classicConnHash8),
+                )
+            return
+
+        # Conformant devices can expose the Classic signed channel on the EVO-style UUID too.
+        if _has_char(CASA_AUTH_CHAR_UUID):
+            first = await self._gattClient.read_gatt_char(CASA_AUTH_CHAR_UUID)
+            if first and len(first) >= 2 and first[0] == 0x01:
+                # EVO NodeInfo packet starts with 0x01.
+                self._protocolMode = ProtocolMode.EVO
+                self._dataCharUuid = CASA_AUTH_CHAR_UUID
+                self._checkProtocolVersion(self._network.protocolVersion)
+                self._logger.info("Protocol mode selected: EVO")
+                return
+
+            # 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 first is None or len(first) < 8:
+                raise ClassicHandshakeError(
+                    f"Classic connection hash read failed/too short (len={0 if first is None else len(first)})."
+                )
+
+            self._protocolMode = ProtocolMode.CLASSIC
+            self._dataCharUuid = CASA_AUTH_CHAR_UUID
+            self._classicConnHash8 = bytes(first[:8])
+            self._classicCmdDiv = int.from_bytes(os.urandom(1), "big") or 1
+            self._classicTxSeq = 0
+
+            notify_kwargs: dict[str, Any] = {}
+            notify_params = inspect.signature(self._gattClient.start_notify).parameters
+            if "bluez" in notify_params:
+                notify_kwargs["bluez"] = {"use_start_notify": True}
+            await self._gattClient.start_notify(
+                CASA_AUTH_CHAR_UUID,
+                self._queueCallback,
+                **notify_kwargs,
+            )
+            self._connectionState = ConnectionState.AUTHENTICATED
+            self._logger.info("Protocol mode selected: CLASSIC")
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
+                    len(self._classicConnHash8),
+                    b2a(self._classicConnHash8),
+                )
+            return
+
+        raise ProtocolError(
+            "No supported Casambi characteristics found (Classic ca51/ca52 or EVO/Classic conformant auth char)."
+        )
+
     def _on_disconnect(self, client: BleakClient) -> None:
         if self._connectionState != ConnectionState.NONE:
             self._logger.info(f"Received disconnect callback from {self.address}")
@@ -292,7 +431,13 @@ class CasambiClient:
     def _callbackMulitplexer(
         self, handle: BleakGATTCharacteristic, data: bytes
     ) -> None:
-        self._logger.debug(f"Callback on handle {handle}: {b2a(data)}")
+        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)
@@ -432,6 +577,12 @@ class CasambiClient:
         return self._nonce[:4] + id + self._nonce[8:]
 
     async def send(self, packet: bytes) -> None:
+        # 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)
+            return
+
         self._checkState(ConnectionState.AUTHENTICATED)
 
         await self._activityLock.acquire()
@@ -452,9 +603,167 @@ class CasambiClient:
         finally:
             self._activityLock.release()
 
+    def _classic_next_seq(self) -> int:
+        # 16-bit sequence inserted in the header (big endian) and included in CMAC input.
+        self._classicTxSeq = (self._classicTxSeq + 1) & 0xFFFF
+        if self._classicTxSeq == 0:
+            self._classicTxSeq = 1
+        return self._classicTxSeq
+
+    def _classic_next_div(self) -> int:
+        # 8-bit command divider/id. Android uses a random start and increments 1..255.
+        self._classicCmdDiv += 1
+        if self._classicCmdDiv == 0 or self._classicCmdDiv > 255:
+            self._classicCmdDiv = 1
+        return self._classicCmdDiv
+
+    def buildClassicCommand(
+        self,
+        command_ordinal: int,
+        payload: bytes,
+        *,
+        target_id: int | None = None,
+        lifetime: int = 200,
+        div: int | None = None,
+    ) -> bytes:
+        """Build one Classic command record (u1.C1753e export format).
+
+        This is the message that follows the Classic signed header and 16-bit sequence.
+        """
+        if div is None:
+            div = self._classic_next_div()
+        if div < 0 or div > 255:
+            raise ValueError("div must fit in one byte")
+        if lifetime < 0 or lifetime > 255:
+            raise ValueError("lifetime must fit in one byte")
+        if target_id is not None and (target_id < 0 or target_id > 255):
+            raise ValueError("target_id must fit in one byte")
+
+        # Two leading bytes are patched after we know the final length:
+        # - byte0 = (len + 239) mod 256
+        # - byte1 = ordinal | 0x40 (div present) | 0x80 (target present)
+        b = bytearray()
+        b.append(0)
+        b.append(0)
+
+        type_flags = command_ordinal & 0x3F
+
+        # div present
+        b.append(div & 0xFF)
+        type_flags |= 0x40
+
+        if target_id is not None and target_id > 0:
+            b.append(target_id & 0xFF)
+            type_flags |= 0x80
+
+        b.append(lifetime & 0xFF)
+        b.extend(payload)
+
+        msg_len = len(b)
+        b[0] = (msg_len + 239) & 0xFF
+        b[1] = type_flags & 0xFF
+
+        if self._logger.isEnabledFor(logging.DEBUG):
+            self._logger.debug(
+                "[CASAMBI_CLASSIC_CMD_BUILD] ord=%d target=%s div=%d lifetime=%d len=%d payload=%s",
+                command_ordinal,
+                target_id,
+                div,
+                lifetime,
+                msg_len,
+                b2a(payload),
+            )
+
+        return bytes(b)
+
+    async def _sendClassicSigned(self, command_bytes: bytes, *, use_manager: bool | None = None) -> None:
+        self._checkState(ConnectionState.AUTHENTICATED)
+        if self._protocolMode != ProtocolMode.CLASSIC:
+            raise ProtocolError("Classic send called while not in Classic protocol mode.")
+        if not self._dataCharUuid:
+            raise ProtocolError("Classic data characteristic UUID not set.")
+        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
+        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 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",
+                key_name,
+                auth_level,
+                sig_len,
+                seq,
+                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""),
+            )
+
+        # Classic packets can exceed 20 bytes when using a 16-byte manager signature.
+        # Bleak needs a write-with-response for long writes on most backends.
+        await self._gattClient.write_gatt_char(self._dataCharUuid, bytes(pkt), response=True)
+
     def _establishedNofityCallback(
         self, handle: BleakGATTCharacteristic, data: bytes
     ) -> None:
+        if self._protocolMode == ProtocolMode.CLASSIC:
+            self._classicEstablishedNotifyCallback(handle, data)
+            return
+
         # TODO: Check incoming counter and direction flag
         self._inPacketCount += 1
 
@@ -515,6 +824,153 @@ class CasambiClient:
         else:
             self._logger.debug("Packet type %d not implemented. Ignoring!", packetType)
 
+    def _classicEstablishedNotifyCallback(
+        self, handle: BleakGATTCharacteristic, data: bytes
+    ) -> None:
+        """Parse Classic notifications from the CA52 channel.
+
+        Classic packets are CMAC-signed (prefix embedded into the header).
+        Ground truth: casambi-android `t1.P.o(...)`.
+        """
+        self._inPacketCount += 1
+
+        raw = bytes(data)
+        if self._logger.isEnabledFor(logging.DEBUG):
+            self._logger.debug(
+                "[CASAMBI_CLASSIC_RX_RAW] len=%d hex=%s",
+                len(raw),
+                b2a(raw[: min(len(raw), 64)]) + (b"..." if len(raw) > 64 else b""),
+            )
+
+        if self._classicConnHash8 is None:
+            self._logger.debug("[CASAMBI_CLASSIC_RX] Missing connection hash; cannot verify CMAC.")
+            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
+
+        # 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),
+        ]
+
+        for name, key, slen in candidates:
+            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
+
+            try:
+                expected = classic_cmac_prefix(key, self._classicConnHash8, cmac_input, slen)
+            except Exception:
+                continue
+
+            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
+
+        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
+        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:]
+
+        if not payload:
+            return
+
+        # 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):
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_CLASSIC_RX_PAYLOAD] type=%d len=%d hex=%s",
+                    packet_type,
+                    len(payload),
+                    b2a(payload[: min(len(payload), 64)])
+                    + (b"..." if len(payload) > 64 else b""),
+                )
+            if packet_type == IncommingPacketType.UnitState:
+                self._parseUnitStates(payload[1:])
+            elif packet_type == IncommingPacketType.SwitchEvent:
+                self._parseSwitchEvent(payload[1:], None, raw)
+            else:
+                # ignore network config
+                pass
+            return
+
+        # Otherwise, attempt to parse a stream of Classic "command" records:
+        # record[0] = (len + 239) mod 256, so len = (b0 - 239) & 0xFF.
+        pos = 0
+        while pos + 2 <= len(payload):
+            enc_len = payload[pos]
+            rec_len = (enc_len - 239) & 0xFF
+            if rec_len < 2 or pos + rec_len > len(payload):
+                break
+            rec = payload[pos : pos + rec_len]
+            pos += rec_len
+
+            typ = rec[1]
+            ordinal = typ & 0x3F
+            has_div = (typ & 0x40) != 0
+            has_target = (typ & 0x80) != 0
+            p = 2
+            div = rec[p] if has_div and p < len(rec) else None
+            if has_div:
+                p += 1
+            target = rec[p] if has_target and p < len(rec) else None
+            if has_target:
+                p += 1
+            lifetime = rec[p] if p < len(rec) else None
+            if lifetime is not None:
+                p += 1
+            rec_payload = rec[p:] if p <= len(rec) else b""
+
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_CLASSIC_CMD] ord=%d div=%s target=%s lifetime=%s payload=%s",
+                    ordinal,
+                    div,
+                    target,
+                    lifetime,
+                    b2a(rec_payload),
+                )
+
+        # Any trailing bytes that don't form a full record are logged for analysis.
+        if self._logger.isEnabledFor(logging.DEBUG) and pos < len(payload):
+            self._logger.debug(
+                "[CASAMBI_CLASSIC_CMD_TRAILING] len=%d hex=%s",
+                len(payload) - pos,
+                b2a(payload[pos:]),
+            )
+
     def _parseUnitStates(self, data: bytes) -> None:
         # Ground truth: casambi-android `v1.C1775b.V(Q2.h)` parses decrypted packet type=6
         # as a stream of unit state records. Records have optional bytes depending on flags.

CasambiBt/_constants.py

@@ -6,6 +6,13 @@ DEVICE_NAME: Final = "Casambi BT Python"
 CASA_UUID: Final = "0000fe4d-0000-1000-8000-00805f9b34fb"
 CASA_AUTH_CHAR_UUID: Final = "c9ffde48-ca5a-0001-ab83-8f519b482f77"
 
+# Classic firmware/protocol uses different GATT characteristics (see casambi-android t1.C1713d):
+# - 0000ca51-...: connection hash (first 8 bytes are used as CMAC input prefix)
+# - 0000ca52-...: signed data channel (write + notify)
+CASA_UUID_CLASSIC: Final = "0000ca5a-0000-1000-8000-00805f9b34fb"
+CASA_CLASSIC_HASH_CHAR_UUID: Final = "0000ca51-0000-1000-8000-00805f9b34fb"
+CASA_CLASSIC_DATA_CHAR_UUID: Final = "0000ca52-0000-1000-8000-00805f9b34fb"
+
 
 @unique
 class ConnectionState(IntEnum):

CasambiBt/_discover.py

@@ -5,7 +5,7 @@ from bleak import BleakScanner
 from bleak.backends.client import BLEDevice
 from bleak.exc import BleakDBusError, BleakError
 
-from ._constants import CASA_UUID
+from ._constants import CASA_UUID, CASA_UUID_CLASSIC
 from .errors import BluetoothError
 
 _LOGGER = logging.getLogger(__name__)
@@ -39,7 +39,8 @@ async def discover() -> list[BLEDevice]:
     discovered = []
     for _, (d, advertisement) in devices_and_advertisements.items():
         if 963 in advertisement.manufacturer_data:
-            if CASA_UUID in advertisement.service_uuids:
+            # Evolution networks advertise FE4D; Classic networks advertise CA5A.
+            if CASA_UUID in advertisement.service_uuids or CASA_UUID_CLASSIC in advertisement.service_uuids:
                 _LOGGER.debug(f"Discovered network at {d.address}")
                 discovered.append(d)
 

CasambiBt/_network.py

@@ -44,6 +44,10 @@ class Network:
         self._networkName: str | None = None
         self._networkRevision: int | None = None
         self._protocolVersion: int = -1
+        # Classic networks do not have a `keyStore`; instead they expose visitor/manager keys.
+        # Ground truth: casambi-android `D1.Z0` exports `visitorKey`/`managerKey`.
+        self._classicVisitorKey: bytes | None = None
+        self._classicManagerKey: bytes | None = None
         self._rawNetworkData: dict | None = None
 
         self._unitTypes: dict[int, tuple[UnitType | None, datetime]] = {}
@@ -154,6 +158,19 @@ class Network:
     def protocolVersion(self) -> int:
         return self._protocolVersion
 
+    def classicVisitorKey(self) -> bytes | None:
+        return self._classicVisitorKey
+
+    def classicManagerKey(self) -> bytes | None:
+        return self._classicManagerKey
+
+    def classicBestKey(self) -> bytes | None:
+        # Prefer manager key if present, otherwise visitor key.
+        return self._classicManagerKey or self._classicVisitorKey
+
+    def hasClassicKeys(self) -> bool:
+        return bool(self._classicVisitorKey or self._classicManagerKey)
+
     @property
     def rawNetworkData(self) -> dict | None:
         return self._rawNetworkData
@@ -263,8 +280,33 @@ class Network:
             keys = network["network"]["keyStore"]["keys"]
             for k in keys:
                 await self._keystore.addKey(k)
-
-        # TODO: Parse managerKey and visitorKey for classic networks.
+            # Evolution network: classic keys not used
+            self._classicVisitorKey = None
+            self._classicManagerKey = None
+        else:
+            # Classic network: parse visitorKey / managerKey (hex strings).
+            # Ground truth: casambi-android `D1.Z0` exports these fields.
+            visitor_hex = network["network"].get("visitorKey")
+            manager_hex = network["network"].get("managerKey")
+
+            def _parse_hex_key(v: object) -> bytes | None:
+                if not isinstance(v, str):
+                    return None
+                v = v.strip()
+                if not v:
+                    return None
+                try:
+                    return bytes.fromhex(v)
+                except ValueError:
+                    return None
+
+            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),
+            )
 
         # Parse units
         self.units = []

CasambiBt/errors.py

@@ -69,3 +69,15 @@ class UnsupportedProtocolVersion(CasambiBtError):
     """Exception that is raised when the network has an unsupported version."""
 
     pass
+
+
+class ClassicKeysMissingError(ProtocolError):
+    """Classic network is missing visitorKey/managerKey required for signing packets."""
+
+    pass
+
+
+class ClassicHandshakeError(ProtocolError):
+    """Classic network handshake/initialization failed (e.g. connection hash unavailable)."""
+
+    pass

{casambi_bt_revamped-0.3.12.dev2.dist-info → casambi_bt_revamped-0.3.12.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev2
+Version: 0.3.12.dev3
 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
@@ -28,6 +28,7 @@ This is a customized fork of the original [casambi-bt](https://github.com/lkempf
 
 - **Switch event support** - Receive button press/release/hold events from Casambi switches (wired + wireless)
 - **Improved relay status handling** - Better support for relay units
+- **Classic protocol (experimental)** - Basic unit control for Classic (legacy) firmware networks
 - **Bug fixes and improvements** - Various fixes based on real-world usage
 
 This library provides a bluetooth interface to Casambi-based lights. It is not associated with Casambi.
@@ -95,6 +96,20 @@ Notes:
 
 For the parsing details and field layout, see `doc/PROTOCOL_PARSING.md`.
 
+### Classic (Legacy Firmware) Support (Experimental)
+
+This library can also connect to **Classic** Casambi networks and send **unit control** commands.
+
+How it works (ground truth: the bundled Android app sources):
+- Classic devices expose a CMAC-signed data channel (`ca51`/`ca52`) or a "Classic conformant" signed channel on the EVO UUID.
+- The cloud network JSON exposes `visitorKey` / `managerKey` (hex strings) instead of an EVO `keyStore`.
+- Commands are signed with AES-CMAC and sent as Classic "command records" (see `doc/PROTOCOL_PARSING.md`).
+
+Environment flags:
+- `CASAMBI_BT_DISABLE_CLASSIC=1` to refuse Classic connections (fail fast)
+- `CASAMBI_BT_CLASSIC_USE_MANAGER=1` to sign with the 16-byte manager signature (default is visitor/4-byte prefix)
+- `CASAMBI_BT_LOG_RAW_NOTIFIES=1` to enable very verbose per-notify hexdumps (mainly for Classic debugging)
+
 ### MacOS
 
 MacOS [does not expose the Bluetooth MAC address via their official API](https://github.com/hbldh/bleak/issues/140),

casambi_bt_revamped-0.3.12.dev3.dist-info/RECORD

@@ -0,0 +1,21 @@
+CasambiBt/__init__.py,sha256=TW445xSu5PV3TyMjJfwaA1JoWvQQ8LXhZgGdDTfWf3s,302
+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=nOOvs9qyQdc8D37DRejOY-15iTcSolK2EAlOOvpg_Xo,49990
+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/_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/errors.py,sha256=1L_Q8og_N_BRYEKizghAQXr6tihlHykFgtcCHUDcBas,1961
+CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+casambi_bt_revamped-0.3.12.dev3.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.12.dev3.dist-info/METADATA,sha256=6oEPqnaAaaI5RZpDRNoquX7c9uHW742-J81FmPe1zNI,5877
+casambi_bt_revamped-0.3.12.dev3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+casambi_bt_revamped-0.3.12.dev3.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.12.dev3.dist-info/RECORD,,

casambi_bt_revamped-0.3.12.dev2.dist-info/RECORD

@@ -1,20 +0,0 @@
-CasambiBt/__init__.py,sha256=TW445xSu5PV3TyMjJfwaA1JoWvQQ8LXhZgGdDTfWf3s,302
-CasambiBt/_cache.py,sha256=3bQil8vhSy4f4sf9JusMfEdQC7d3cJuva9qHhyKro-0,3808
-CasambiBt/_casambi.py,sha256=i-60A7zDblZwOVb4UfXz9EEwsbWEFPnrMvVkKMl6amY,34752
-CasambiBt/_client.py,sha256=z3AnTQrZMVLkQTXdyLOZyNkNonU3arMFtEHMxUF59Ig,31581
-CasambiBt/_constants.py,sha256=_AxkG7Btxl4VeS6mO7GJW5Kc9dFs3s9sDmtJ83ZEKNw,359
-CasambiBt/_discover.py,sha256=H7HpiFYIy9ELvmPXXd_ck-5O5invJf15dDIRk-vO5IE,1696
-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=Gh0n3FEcOUHUMuBXALwcb3tws-AofpYLegKIquqtZl4,14665
-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/errors.py,sha256=0JgDjaKlAKDes0poWzA8nrTUYQ8qdNfBb8dfaqqzCRA,1664
-CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casambi_bt_revamped-0.3.12.dev2.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
-casambi_bt_revamped-0.3.12.dev2.dist-info/METADATA,sha256=nMUsaWF7HLmwMjYQFq_uJM3N_CGyP7SPmUKaGjKWdQk,4907
-casambi_bt_revamped-0.3.12.dev2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-casambi_bt_revamped-0.3.12.dev2.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
-casambi_bt_revamped-0.3.12.dev2.dist-info/RECORD,,