casambi-bt-revamped 0.3.12.dev9__tar.gz → 0.3.12.dev10__tar.gz

{casambi_bt_revamped-0.3.12.dev9/src/casambi_bt_revamped.egg-info → casambi_bt_revamped-0.3.12.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev9
+Version: 0.3.12.dev10
 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.dev9 → casambi_bt_revamped-0.3.12.dev10}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = casambi-bt-revamped
-version = 0.3.12.dev9
+version = 0.3.12.dev10
 author = rankjie
 author_email = rankjie@gmail.com
 description = Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt

{casambi_bt_revamped-0.3.12.dev9 → casambi_bt_revamped-0.3.12.dev10}/src/CasambiBt/_casambi.py

@@ -206,16 +206,33 @@ class Casambi:
 
         # 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)
+            # Check if we should use the alternative simple format from BLE captures
+            import os
+            use_simple = os.environ.get("CASAMBI_BT_CLASSIC_FORMAT", "").lower() == "simple"
+
+            if use_simple:
+                # Simple format: [counter][unit_id][param_len][dimmer]
+                # For "all units", use unit_id=0xFF
+                if isinstance(target, Unit):
+                    cmd = self._casaClient.buildClassicCommandSimple(target.deviceId, level)
+                elif isinstance(target, Group):
+                    # Groups in simple format: not fully confirmed, try group ID
+                    cmd = self._casaClient.buildClassicCommandSimple(target.groudId, level)
+                elif target is None:
+                    cmd = self._casaClient.buildClassicCommandSimple(0xFF, level)
+                else:
+                    raise TypeError(f"Unkown target type {type(target)}")
             else:
-                raise TypeError(f"Unkown target type {type(target)}")
+                # 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

casambi_bt_revamped-0.3.12.dev10/src/CasambiBt/_classic_crypto.py

@@ -0,0 +1,146 @@
+"""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.
+
+The CMAC input structure from t1.P.o():
+    kVar.i(rVar.f16699L, 0, 8);  // connection_hash[0:8]
+    kVar.i(b(), this.f16551t + i9, (c() - i9) - this.f16551t);  // payload starting at seq offset
+
+For "conformant" classic (rVar.Z=true):
+    CMAC input = conn_hash[0:8] || seq(2 bytes BE) || command_bytes
+
+For "legacy" classic (rVar.Z=false):
+    CMAC input = conn_hash[0:8] || command_bytes
+
+Test vectors based on community BLE captures (GitHub lkempf/casambi-bt#17):
+
+Capture from sMauldaeschle:
+    Raw packet: 0215db43c40004040200b3
+    - Byte 0: 02 (auth level = visitor)
+    - Bytes 1-4: 15db43c4 (4-byte CMAC signature)
+    - Byte 5: 00 (padding/marker)
+    - Byte 6: 04 (counter/sequence)
+    - Byte 7: 04 (unit id)
+    - Byte 8: 02 (length of parameters)
+    - Byte 9: 00 (dimmer value)
+    - Byte 10: b3 (temperature/vertical value)
+
+Capture from FliegenKLATSCH:
+    Raw packet: 0200 43A2 9600 0203 0254 FF
+    - Bytes 0-1: 0200 (auth 02, then...)
+    - Bytes 2-5: 43A2 9600 (first 4 bytes of CMAC)
+    - The CMAC input was: <8 bytes connection hash> 00 0203 0254 FF
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from cryptography.hazmat.primitives.cmac import CMAC
+from cryptography.hazmat.primitives.ciphers.algorithms import AES
+
+if TYPE_CHECKING:
+    pass
+
+_logger = logging.getLogger(__name__)
+
+
+def classic_cmac(key: bytes, conn_hash8: bytes, payload: bytes, *, debug: bool = False) -> bytes:
+    """Compute the Classic CMAC (16 bytes) over connection hash + payload.
+
+    Args:
+        key: 16-byte AES key (visitor or manager key from cloud)
+        conn_hash8: First 8 bytes of the connection hash read from CA51/auth char
+        payload: The data to sign (for conformant: seq + command; for legacy: command only)
+        debug: If True, log CMAC input/output for debugging
+
+    Returns:
+        16-byte CMAC
+    """
+    if len(conn_hash8) != 8:
+        raise ValueError("conn_hash8 must be 8 bytes")
+
+    cmac_input = conn_hash8 + payload
+    cmac = CMAC(AES(key))
+    cmac.update(cmac_input)
+    result = cmac.finalize()
+
+    if debug:
+        _logger.warning(
+            "[CLASSIC_CMAC_DEBUG] key_len=%d conn_hash8=%s payload_len=%d payload_prefix=%s cmac=%s",
+            len(key),
+            conn_hash8.hex(),
+            len(payload),
+            payload[:16].hex() if len(payload) > 16 else payload.hex(),
+            result.hex(),
+        )
+
+    return result
+
+
+def classic_cmac_prefix(
+    key: bytes, conn_hash8: bytes, payload: bytes, prefix_len: int, *, debug: bool = False
+) -> bytes:
+    """Return the prefix bytes that are embedded into the Classic packet header.
+
+    Args:
+        key: 16-byte AES key
+        conn_hash8: First 8 bytes of connection hash
+        payload: Data to sign
+        prefix_len: Number of CMAC bytes to use (4 for visitor, 16 for manager)
+        debug: If True, log CMAC computation
+
+    Returns:
+        First prefix_len bytes of the CMAC
+    """
+    mac = classic_cmac(key, conn_hash8, payload, debug=debug)
+    return mac[:prefix_len]
+
+
+def verify_classic_cmac(
+    key: bytes, conn_hash8: bytes, payload: bytes, expected_prefix: bytes
+) -> bool:
+    """Verify a Classic CMAC signature prefix.
+
+    Args:
+        key: 16-byte AES key
+        conn_hash8: First 8 bytes of connection hash
+        payload: Data that was signed
+        expected_prefix: The CMAC prefix from the packet header
+
+    Returns:
+        True if the computed CMAC prefix matches expected_prefix
+    """
+    computed = classic_cmac_prefix(key, conn_hash8, payload, len(expected_prefix))
+    return computed == expected_prefix
+
+
+# Test vectors from RFC 4493 (AES-CMAC) - used in test_classic_protocol.py
+# These confirm our CMAC implementation is correct.
+RFC4493_TEST_KEY = bytes.fromhex("2b7e151628aed2a6abf7158809cf4f3c")
+RFC4493_VECTORS = [
+    # (message, expected_cmac)
+    (bytes.fromhex("6bc1bee22e409f96e93d7e117393172a"),
+     bytes.fromhex("070a16b46b4d4144f79bdd9dd04a287c")),
+    (bytes.fromhex("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51"),
+     bytes.fromhex("ce0cbf1738f4df6428b1d93bf12081c9")),
+]
+
+# Placeholder for real Casambi test vectors once we have them from captures
+# Format: (visitor_key, conn_hash8, payload_after_header, expected_cmac_prefix_4, description)
+CASAMBI_CLASSIC_TEST_VECTORS: list[tuple[bytes, bytes, bytes, bytes, str]] = [
+    # These will be populated from real BLE captures
+    # Example structure (not verified yet):
+    # (
+    #     bytes.fromhex("...16 byte key..."),
+    #     bytes.fromhex("...8 byte conn hash..."),
+    #     bytes.fromhex("...payload after auth byte..."),
+    #     bytes.fromhex("...4 byte expected cmac..."),
+    #     "Description of what this packet does"
+    # ),
+]
+

{casambi_bt_revamped-0.3.12.dev9 → casambi_bt_revamped-0.3.12.dev10}/src/CasambiBt/_client.py

@@ -163,6 +163,11 @@ class CasambiClient:
         self._classicRxKindSamples: dict[str, int] = {}
         self._classicRxLastStatsTs = time.monotonic()
 
+        # Classic diagnostic packet history (for dump_classic_diagnostics service)
+        self._classicTxHistory: list[dict[str, Any]] = []
+        self._classicRxHistory: list[dict[str, Any]] = []
+        self._classicDiagMaxHistory = 50  # Keep last 50 TX and RX packets
+
     @property
     def protocolMode(self) -> ProtocolMode | None:
         return self._protocolMode
@@ -1004,6 +1009,39 @@ class CasambiClient:
 
         return bytes(b)
 
+    def buildClassicCommandSimple(
+        self,
+        unit_id: int,
+        dimmer: int,
+        extra: int | None = None,
+    ) -> bytes:
+        """Build a Classic command using the simple format from BLE captures.
+
+        This alternative format was observed in real BLE captures and differs from
+        the Android u1.C1753e command record format. Use with env variable
+        CASAMBI_BT_CLASSIC_FORMAT=simple to experiment.
+
+        Format (before header added by _sendClassic):
+        [counter:1][unit_id:1][param_len:1][dimmer:1][extra:1?]
+
+        The header (added by _sendClassic) is:
+        - Conformant: [auth:1][cmac:4|16][seq:2]
+        - Legacy: [cmac:4]
+
+        Args:
+            unit_id: Target unit ID (0-255, use 0xFF for "all units")
+            dimmer: Dimmer/level value (0-255)
+            extra: Optional extra parameter (e.g., temperature/vertical value)
+
+        Returns:
+            Command bytes to pass to _sendClassic
+        """
+        counter = self._classic_next_div()
+        if extra is not None:
+            return bytes([counter, unit_id & 0xFF, 2, dimmer & 0xFF, extra & 0xFF])
+        else:
+            return bytes([counter, unit_id & 0xFF, 1, dimmer & 0xFF])
+
     async def _sendClassic(self, command_bytes: bytes) -> None:
         self._checkState(ConnectionState.AUTHENTICATED)
         if self._protocolMode != ProtocolMode.CLASSIC:
@@ -1143,7 +1181,46 @@ class CasambiClient:
 
         # 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(tx_uuid, bytes(pkt), response=True)
+        tx_result = "pending"
+        try:
+            await self._gattClient.write_gatt_char(tx_uuid, bytes(pkt), response=True)
+            tx_result = "ok"
+        except Exception as e:
+            tx_result = f"error: {type(e).__name__}: {e}"
+            raise
+        finally:
+            # Record TX in diagnostic history
+            tx_entry = {
+                "timestamp": time.monotonic(),
+                "header_mode": header_mode,
+                "key": key_name,
+                "signed": signed,
+                "tx_uuid": tx_uuid,
+                "auth_level": auth_level if header_mode == "conformant" else None,
+                "sig_len": sig_len,
+                "seq": seq,
+                "cmd_ordinal": cmd_ordinal,
+                "cmd_target": cmd_target,
+                "cmd_div": cmd_div,
+                "cmd_lifetime": cmd_lifetime,
+                "cmd_payload_len": cmd_payload_len,
+                "total_len": len(pkt),
+                "pre_sign_hex": b2a(command_bytes).decode("ascii"),
+                "post_sign_hex": b2a(bytes(pkt)).decode("ascii"),
+                "result": tx_result,
+            }
+            self._classicTxHistory.append(tx_entry)
+            if len(self._classicTxHistory) > self._classicDiagMaxHistory:
+                self._classicTxHistory = self._classicTxHistory[-self._classicDiagMaxHistory:]
+
+            # Enhanced TX diagnostic log
+            self._logger.warning(
+                "[CLASSIC_DIAG_TX_RESULT] result=%s header=%s seq=%s total_len=%d",
+                tx_result,
+                header_mode,
+                None if seq is None else f"0x{seq:04x}",
+                len(pkt),
+            )
 
     def _establishedNofityCallback(
         self, handle: BleakGATTCharacteristic, data: bytes
@@ -1231,10 +1308,26 @@ class CasambiClient:
         """
         self._inPacketCount += 1
         self._classicRxFrames += 1
+        rx_ts = time.monotonic()
         if self._classicFirstRxTs is None:
-            self._classicFirstRxTs = time.monotonic()
+            self._classicFirstRxTs = rx_ts
 
         raw = bytes(data)
+
+        # Enhanced RX diagnostic logging
+        try:
+            handle_uuid = str(getattr(handle, "uuid", "unknown")).lower()
+        except Exception:
+            handle_uuid = "unknown"
+
+        self._logger.warning(
+            "[CLASSIC_DIAG_RX] #%d handle=%s len=%d hex=%s",
+            self._classicRxFrames,
+            handle_uuid,
+            len(raw),
+            b2a(raw[: min(len(raw), 48)]).decode("ascii") + ("..." if len(raw) > 48 else ""),
+        )
+
         if self._logger.isEnabledFor(logging.DEBUG):
             self._logger.debug(
                 "[CASAMBI_CLASSIC_RX_RAW] len=%d hex=%s",
@@ -1424,6 +1517,36 @@ class CasambiClient:
         elif verified is None:
             self._classicRxUnverifiable += 1
 
+        # Record RX in diagnostic history
+        rx_entry = {
+            "timestamp": rx_ts,
+            "handle_uuid": handle_uuid,
+            "header_mode": best["mode"],
+            "verified": verified,
+            "auth_level": best["auth_level"],
+            "sig_len": best["sig_len"],
+            "seq": best["seq"],
+            "payload_len": len(payload),
+            "raw_hex": b2a(raw).decode("ascii"),
+            "payload_hex": b2a(payload).decode("ascii"),
+            "score": best["score"],
+        }
+        self._classicRxHistory.append(rx_entry)
+        if len(self._classicRxHistory) > self._classicDiagMaxHistory:
+            self._classicRxHistory = self._classicRxHistory[-self._classicDiagMaxHistory:]
+
+        # Enhanced RX parse result log
+        self._logger.warning(
+            "[CLASSIC_DIAG_RX_PARSE] mode=%s verified=%s auth=%s sig_len=%d seq=%s score=%d payload_len=%d",
+            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}",
+            best["score"],
+            len(payload),
+        )
+
         # 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).
@@ -1865,3 +1988,39 @@ class CasambiClient:
 
         self._connectionState = ConnectionState.NONE
         self._logger.info("Disconnected.")
+
+    def getClassicDiagnostics(self) -> dict[str, Any]:
+        """Return Classic protocol diagnostic state for external services.
+
+        This method provides a snapshot of Classic protocol state including:
+        - Connection parameters (hash, mode, UUIDs)
+        - RX/TX statistics
+        - Last N TX and RX packets
+        - Any detected errors or anomalies
+
+        Safe to call from HA services for dump_classic_diagnostics.
+        """
+        return {
+            "protocol_mode": self._protocolMode.name if self._protocolMode else None,
+            "classic_header_mode": self._classicHeaderMode,
+            "classic_hash_source": self._classicHashSource,
+            "classic_conn_hash8_hex": b2a(self._classicConnHash8).decode("ascii") if self._classicConnHash8 else None,
+            "classic_tx_uuid": self._classicTxCharUuid,
+            "classic_notify_uuids": sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else [],
+            "classic_first_rx_ts": self._classicFirstRxTs,
+            "classic_rx_stats": {
+                "frames": self._classicRxFrames,
+                "verified": self._classicRxVerified,
+                "unverifiable": self._classicRxUnverifiable,
+                "parse_fail": self._classicRxParseFail,
+                "type6_unitstate": self._classicRxType6,
+                "type7_switch": self._classicRxType7,
+                "type9_netconf": self._classicRxType9,
+                "cmdstream": self._classicRxCmdStream,
+                "unknown": self._classicRxUnknown,
+            },
+            "classic_tx_count": len(self._classicTxHistory),
+            "classic_rx_count": len(self._classicRxHistory),
+            "classic_tx_history": self._classicTxHistory[-20:],  # Last 20
+            "classic_rx_history": self._classicRxHistory[-20:],  # Last 20
+        }

{casambi_bt_revamped-0.3.12.dev9 → casambi_bt_revamped-0.3.12.dev10}/src/CasambiBt/_version.py

@@ -7,4 +7,4 @@ 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.dev9"
+__version__ = "0.3.12.dev10"

{casambi_bt_revamped-0.3.12.dev9 → casambi_bt_revamped-0.3.12.dev10/src/casambi_bt_revamped.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev9
+Version: 0.3.12.dev10
 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.dev10/tests/test_classic_protocol.py

@@ -0,0 +1,385 @@
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+# Allow tests to run without installing the package.
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+from CasambiBt._classic_crypto import (  # noqa: E402
+    classic_cmac,
+    classic_cmac_prefix,
+    verify_classic_cmac,
+    RFC4493_TEST_KEY,
+    RFC4493_VECTORS,
+)
+from CasambiBt._client import (  # noqa: E402
+    CasambiClient,
+    ConnectionState,
+    IncommingPacketType,
+    ProtocolMode,
+)
+
+
+class _DummyNetwork:
+    protocolVersion = 10
+
+    def classicVisitorKey(self) -> bytes | None:  # noqa: D401
+        return None
+
+    def classicManagerKey(self) -> bytes | None:  # noqa: D401
+        return None
+
+    def hasClassicKeys(self) -> bool:  # noqa: D401
+        return False
+
+    def isManager(self) -> bool:  # noqa: D401
+        return False
+
+
+class _DummyNetworkWithKeys:
+    protocolVersion = 5  # Classic protocol version
+
+    def __init__(self, visitor_key: bytes | None = None, manager_key: bytes | None = None) -> None:
+        self._visitor = visitor_key
+        self._manager = manager_key
+
+    def classicVisitorKey(self) -> bytes | None:  # noqa: D401
+        return self._visitor
+
+    def classicManagerKey(self) -> bytes | None:  # noqa: D401
+        return self._manager
+
+    def hasClassicKeys(self) -> bool:  # noqa: D401
+        return bool(self._visitor or self._manager)
+
+    def isManager(self) -> bool:  # noqa: D401
+        return self._manager is not None
+
+
+class _StubGattClient:
+    def __init__(self) -> None:
+        self.writes: list[tuple[str, bytes, bool]] = []
+
+    async def write_gatt_char(self, uuid: str, data: bytes, response: bool = False) -> None:
+        self.writes.append((uuid, bytes(data), bool(response)))
+
+
+class TestClassicProtocolHelpers(unittest.TestCase):
+    def test_classic_cmac_matches_rfc4493_vectors(self) -> None:
+        # RFC 4493 test vectors (AES-CMAC).
+        key = bytes.fromhex("2b7e151628aed2a6abf7158809cf4f3c")
+
+        # Example 2 (16 bytes)
+        msg16 = bytes.fromhex("6bc1bee22e409f96e93d7e117393172a")
+        exp16 = bytes.fromhex("070a16b46b4d4144f79bdd9dd04a287c")
+
+        # Example 3 (32 bytes)
+        msg32 = bytes.fromhex(
+            "6bc1bee22e409f96e93d7e117393172a"
+            "ae2d8a571e03ac9c9eb76fac45af8e51"
+        )
+        exp32 = bytes.fromhex("ce0cbf1738f4df6428b1d93bf12081c9")
+
+        # Example 4 (48 bytes)
+        msg48 = bytes.fromhex(
+            "6bc1bee22e409f96e93d7e117393172a"
+            "ae2d8a571e03ac9c9eb76fac45af8e51"
+            "30c81c46a35ce411e5fbc1191a0a52ef"
+        )
+        exp48 = bytes.fromhex("c47c4d9d64588f67fb9de6fe745d7fbf")
+
+        for msg, expected in ((msg16, exp16), (msg32, exp32), (msg48, exp48)):
+            conn_hash8 = msg[:8]
+            payload = msg[8:]
+            mac = classic_cmac(key, conn_hash8, payload)
+            self.assertEqual(mac, expected)
+            self.assertEqual(classic_cmac_prefix(key, conn_hash8, payload, 4), expected[:4])
+            self.assertEqual(classic_cmac_prefix(key, conn_hash8, payload, 16), expected)
+
+    def test_rfc4493_vectors_from_module(self) -> None:
+        """Test using the vectors exported from _classic_crypto module."""
+        for msg, expected in RFC4493_VECTORS:
+            conn_hash8 = msg[:8]
+            payload = msg[8:]
+            mac = classic_cmac(RFC4493_TEST_KEY, conn_hash8, payload)
+            self.assertEqual(mac, expected)
+
+    def test_verify_classic_cmac(self) -> None:
+        """Test the verify_classic_cmac helper."""
+        key = bytes.fromhex("2b7e151628aed2a6abf7158809cf4f3c")
+        msg = bytes.fromhex("6bc1bee22e409f96e93d7e117393172a")
+        expected = bytes.fromhex("070a16b46b4d4144f79bdd9dd04a287c")
+
+        conn_hash8 = msg[:8]
+        payload = msg[8:]
+
+        # Correct prefix should verify
+        self.assertTrue(verify_classic_cmac(key, conn_hash8, payload, expected[:4]))
+        self.assertTrue(verify_classic_cmac(key, conn_hash8, payload, expected[:16]))
+
+        # Wrong prefix should not verify
+        wrong_prefix = bytes.fromhex("00000000")
+        self.assertFalse(verify_classic_cmac(key, conn_hash8, payload, wrong_prefix))
+
+    def test_classic_command_encoding_matches_android_layout(self) -> None:
+        # Ground truth: casambi-android `u1.C1753e.a(P)`:
+        # [len+239][ordinal|flags][div][target?][lifetime=200][payload...]
+        parsed: list[dict] = []
+
+        def cb(_: IncommingPacketType, data: dict) -> None:
+            parsed.append(data)
+
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
+
+        # Unit level command: ordinal=7, div present, target present, lifetime=200, payload=0x54
+        cmd = c.buildClassicCommand(7, bytes([0x54]), target_id=3, div=0x12, lifetime=200)
+        self.assertEqual(cmd.hex(), "f5c71203c854")
+
+        # All units level: ordinal=4, div present, no target, lifetime=200, payload=0xff
+        cmd2 = c.buildClassicCommand(4, bytes([0xFF]), target_id=None, div=0x01, lifetime=200)
+        self.assertEqual(cmd2.hex(), "f44401c8ff")
+
+        # target_id=0 is treated as "no target" (Android only writes target when > 0).
+        cmd3 = c.buildClassicCommand(4, bytes([0xFF]), target_id=0, div=0x01, lifetime=200)
+        self.assertEqual(cmd3.hex(), "f44401c8ff")
+
+
+class TestClassicSimpleCommandFormat(unittest.TestCase):
+    """Test the alternative simple command format from BLE captures."""
+
+    def test_simple_command_format_all_units(self) -> None:
+        """Test simple command format for all units."""
+        def cb(_: IncommingPacketType, data: dict) -> None:
+            pass
+
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
+        c._classicCmdDiv = 0x03  # Set known counter
+
+        # All units (0xFF), level 128
+        cmd = c.buildClassicCommandSimple(0xFF, 128)
+        # Expected: [counter=4][unit_id=0xFF][param_len=1][dimmer=128]
+        self.assertEqual(cmd.hex(), "04ff0180")
+
+    def test_simple_command_format_single_unit(self) -> None:
+        """Test simple command format for single unit."""
+        def cb(_: IncommingPacketType, data: dict) -> None:
+            pass
+
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
+        c._classicCmdDiv = 0x03
+
+        # Unit 4, level 0
+        cmd = c.buildClassicCommandSimple(4, 0)
+        # Expected: [counter=4][unit_id=4][param_len=1][dimmer=0]
+        self.assertEqual(cmd.hex(), "04040100")
+
+    def test_simple_command_format_with_extra(self) -> None:
+        """Test simple command format with extra parameter (temperature/vertical)."""
+        def cb(_: IncommingPacketType, data: dict) -> None:
+            pass
+
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
+        c._classicCmdDiv = 0x03
+
+        # Unit 4, level 0, extra 0xB3 (temperature)
+        cmd = c.buildClassicCommandSimple(4, 0, extra=0xB3)
+        # Expected: [counter=4][unit_id=4][param_len=2][dimmer=0][extra=0xB3]
+        self.assertEqual(cmd.hex(), "040402" "00b3")
+
+
+class TestClassicSendWithoutKeys(unittest.IsolatedAsyncioTestCase):
+    async def test_classic_send_conformant_without_keys_has_zero_sig_and_seq(self) -> None:
+        sent: list[tuple[str, bytes, bool]] = []
+
+        def cb(_: IncommingPacketType, __: dict) -> None:
+            return
+
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
+        c._gattClient = _StubGattClient()
+        c._connectionState = ConnectionState.AUTHENTICATED
+        c._protocolMode = ProtocolMode.CLASSIC
+        c._dataCharUuid = "dummy"
+        c._classicConnHash8 = b"\x11" * 8
+        c._classicHeaderMode = "conformant"
+        c._classicTxSeq = 0
+
+        cmd = c.buildClassicCommand(4, bytes([0xFF]), div=0x01, lifetime=200)
+        await c.send(cmd)
+
+        stub = c._gattClient
+        assert isinstance(stub, _StubGattClient)
+        self.assertEqual(len(stub.writes), 1)
+        _uuid, pkt, response = stub.writes[0]
+        self.assertTrue(response)
+
+        # [auth=0x02][sig(4x00)][seq=0x0001][cmd...]
+        self.assertEqual(pkt[0], 0x02)
+        self.assertEqual(pkt[1:5], b"\x00" * 4)
+        self.assertEqual(pkt[5:7], b"\x00\x01")
+        self.assertEqual(pkt[7:], cmd)
+
+    async def test_classic_send_legacy_without_keys_has_zero_sig(self) -> None:
+        def cb(_: IncommingPacketType, __: dict) -> None:
+            return
+
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
+        c._gattClient = _StubGattClient()
+        c._connectionState = ConnectionState.AUTHENTICATED
+        c._protocolMode = ProtocolMode.CLASSIC
+        c._dataCharUuid = "dummy"
+        c._classicConnHash8 = b"\x11" * 8
+        c._classicHeaderMode = "legacy"
+
+        cmd = c.buildClassicCommand(4, bytes([0xFF]), div=0x01, lifetime=200)
+        await c.send(cmd)
+
+        stub = c._gattClient
+        assert isinstance(stub, _StubGattClient)
+        self.assertEqual(len(stub.writes), 1)
+        _uuid, pkt, response = stub.writes[0]
+        self.assertTrue(response)
+
+        # [sig(4x00)][cmd...]
+        self.assertEqual(pkt[:4], b"\x00" * 4)
+        self.assertEqual(pkt[4:], cmd)
+
+
+class TestClassicSendWithKeys(unittest.IsolatedAsyncioTestCase):
+    """Test Classic send with actual keys for CMAC signing."""
+
+    async def test_classic_send_conformant_with_visitor_key(self) -> None:
+        """Test conformant mode with visitor key produces signed packet."""
+        visitor_key = bytes.fromhex("2b7e151628aed2a6abf7158809cf4f3c")
+
+        def cb(_: IncommingPacketType, __: dict) -> None:
+            return
+
+        network = _DummyNetworkWithKeys(visitor_key=visitor_key)
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, network)
+        c._gattClient = _StubGattClient()
+        c._connectionState = ConnectionState.AUTHENTICATED
+        c._protocolMode = ProtocolMode.CLASSIC
+        c._dataCharUuid = "dummy"
+        c._classicConnHash8 = bytes.fromhex("1122334455667788")
+        c._classicHeaderMode = "conformant"
+        c._classicTxSeq = 0
+
+        cmd = c.buildClassicCommand(4, bytes([0xFF]), div=0x01, lifetime=200)
+        await c.send(cmd)
+
+        stub = c._gattClient
+        assert isinstance(stub, _StubGattClient)
+        self.assertEqual(len(stub.writes), 1)
+        _uuid, pkt, response = stub.writes[0]
+        self.assertTrue(response)
+
+        # [auth=0x02][sig(4 bytes, NOT zero)][seq=0x0001][cmd...]
+        self.assertEqual(pkt[0], 0x02)
+        # Signature should NOT be all zeros (it's computed with the key)
+        self.assertNotEqual(pkt[1:5], b"\x00" * 4)
+        self.assertEqual(pkt[5:7], b"\x00\x01")  # seq = 1
+        self.assertEqual(pkt[7:], cmd)
+
+        # Verify the CMAC is correct
+        cmac_input = pkt[5:]  # seq + cmd
+        expected_sig = classic_cmac_prefix(visitor_key, c._classicConnHash8, cmac_input, 4)
+        self.assertEqual(pkt[1:5], expected_sig)
+
+    async def test_classic_send_legacy_with_visitor_key(self) -> None:
+        """Test legacy mode with visitor key produces signed packet."""
+        visitor_key = bytes.fromhex("2b7e151628aed2a6abf7158809cf4f3c")
+
+        def cb(_: IncommingPacketType, __: dict) -> None:
+            return
+
+        network = _DummyNetworkWithKeys(visitor_key=visitor_key)
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, network)
+        c._gattClient = _StubGattClient()
+        c._connectionState = ConnectionState.AUTHENTICATED
+        c._protocolMode = ProtocolMode.CLASSIC
+        c._dataCharUuid = "dummy"
+        c._classicConnHash8 = bytes.fromhex("1122334455667788")
+        c._classicHeaderMode = "legacy"
+
+        cmd = c.buildClassicCommand(4, bytes([0xFF]), div=0x01, lifetime=200)
+        await c.send(cmd)
+
+        stub = c._gattClient
+        assert isinstance(stub, _StubGattClient)
+        self.assertEqual(len(stub.writes), 1)
+        _uuid, pkt, response = stub.writes[0]
+        self.assertTrue(response)
+
+        # [sig(4 bytes, NOT zero)][cmd...]
+        self.assertNotEqual(pkt[:4], b"\x00" * 4)
+        self.assertEqual(pkt[4:], cmd)
+
+        # Verify the CMAC is correct
+        expected_sig = classic_cmac_prefix(visitor_key, c._classicConnHash8, cmd, 4)
+        self.assertEqual(pkt[:4], expected_sig)
+
+
+class TestClassicDiagnosticHistory(unittest.IsolatedAsyncioTestCase):
+    """Test that TX/RX packets are recorded in diagnostic history."""
+
+    async def test_tx_history_recorded(self) -> None:
+        """Test that TX packets are recorded in history."""
+        def cb(_: IncommingPacketType, __: dict) -> None:
+            return
+
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
+        c._gattClient = _StubGattClient()
+        c._connectionState = ConnectionState.AUTHENTICATED
+        c._protocolMode = ProtocolMode.CLASSIC
+        c._dataCharUuid = "dummy"
+        c._classicConnHash8 = b"\x11" * 8
+        c._classicHeaderMode = "conformant"
+        c._classicTxSeq = 0
+
+        # Initially empty
+        self.assertEqual(len(c._classicTxHistory), 0)
+
+        # Send a command
+        cmd = c.buildClassicCommand(4, bytes([0xFF]), div=0x01, lifetime=200)
+        await c.send(cmd)
+
+        # Should have one entry in history
+        self.assertEqual(len(c._classicTxHistory), 1)
+        entry = c._classicTxHistory[0]
+        self.assertIn("timestamp", entry)
+        self.assertIn("header_mode", entry)
+        self.assertIn("post_sign_hex", entry)
+        self.assertEqual(entry["result"], "ok")
+
+    async def test_getClassicDiagnostics_returns_data(self) -> None:
+        """Test that getClassicDiagnostics returns structured data."""
+        def cb(_: IncommingPacketType, __: dict) -> None:
+            return
+
+        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
+        c._gattClient = _StubGattClient()
+        c._connectionState = ConnectionState.AUTHENTICATED
+        c._protocolMode = ProtocolMode.CLASSIC
+        c._dataCharUuid = "dummy"
+        c._classicConnHash8 = b"\x11" * 8
+        c._classicHeaderMode = "conformant"
+        c._classicTxSeq = 0
+
+        # Send a command
+        cmd = c.buildClassicCommand(4, bytes([0xFF]), div=0x01, lifetime=200)
+        await c.send(cmd)
+
+        # Get diagnostics
+        diag = c.getClassicDiagnostics()
+        self.assertEqual(diag["protocol_mode"], "CLASSIC")
+        self.assertEqual(diag["classic_header_mode"], "conformant")
+        self.assertEqual(diag["classic_tx_count"], 1)
+        self.assertIn("classic_tx_history", diag)
+        self.assertIn("classic_rx_stats", diag)
+
+
+if __name__ == "__main__":
+    unittest.main()

casambi_bt_revamped-0.3.12.dev9/src/CasambiBt/_classic_crypto.py

@@ -1,31 +0,0 @@
-"""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]
-

casambi_bt_revamped-0.3.12.dev9/tests/test_classic_protocol.py

@@ -1,157 +0,0 @@
-from __future__ import annotations
-
-import sys
-import unittest
-from pathlib import Path
-
-# Allow tests to run without installing the package.
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT / "src"))
-
-from CasambiBt._classic_crypto import classic_cmac, classic_cmac_prefix  # noqa: E402
-from CasambiBt._client import (  # noqa: E402
-    CasambiClient,
-    ConnectionState,
-    IncommingPacketType,
-    ProtocolMode,
-)
-
-
-class _DummyNetwork:
-    protocolVersion = 10
-
-    def classicVisitorKey(self) -> bytes | None:  # noqa: D401
-        return None
-
-    def classicManagerKey(self) -> bytes | None:  # noqa: D401
-        return None
-
-    def hasClassicKeys(self) -> bool:  # noqa: D401
-        return False
-
-    def isManager(self) -> bool:  # noqa: D401
-        return False
-
-
-class _StubGattClient:
-    def __init__(self) -> None:
-        self.writes: list[tuple[str, bytes, bool]] = []
-
-    async def write_gatt_char(self, uuid: str, data: bytes, response: bool = False) -> None:
-        self.writes.append((uuid, bytes(data), bool(response)))
-
-
-class TestClassicProtocolHelpers(unittest.TestCase):
-    def test_classic_cmac_matches_rfc4493_vectors(self) -> None:
-        # RFC 4493 test vectors (AES-CMAC).
-        key = bytes.fromhex("2b7e151628aed2a6abf7158809cf4f3c")
-
-        # Example 2 (16 bytes)
-        msg16 = bytes.fromhex("6bc1bee22e409f96e93d7e117393172a")
-        exp16 = bytes.fromhex("070a16b46b4d4144f79bdd9dd04a287c")
-
-        # Example 3 (32 bytes)
-        msg32 = bytes.fromhex(
-            "6bc1bee22e409f96e93d7e117393172a"
-            "ae2d8a571e03ac9c9eb76fac45af8e51"
-        )
-        exp32 = bytes.fromhex("ce0cbf1738f4df6428b1d93bf12081c9")
-
-        # Example 4 (48 bytes)
-        msg48 = bytes.fromhex(
-            "6bc1bee22e409f96e93d7e117393172a"
-            "ae2d8a571e03ac9c9eb76fac45af8e51"
-            "30c81c46a35ce411e5fbc1191a0a52ef"
-        )
-        exp48 = bytes.fromhex("c47c4d9d64588f67fb9de6fe745d7fbf")
-
-        for msg, expected in ((msg16, exp16), (msg32, exp32), (msg48, exp48)):
-            conn_hash8 = msg[:8]
-            payload = msg[8:]
-            mac = classic_cmac(key, conn_hash8, payload)
-            self.assertEqual(mac, expected)
-            self.assertEqual(classic_cmac_prefix(key, conn_hash8, payload, 4), expected[:4])
-            self.assertEqual(classic_cmac_prefix(key, conn_hash8, payload, 16), expected)
-
-    def test_classic_command_encoding_matches_android_layout(self) -> None:
-        # Ground truth: casambi-android `u1.C1753e.a(P)`:
-        # [len+239][ordinal|flags][div][target?][lifetime=200][payload...]
-        parsed: list[dict] = []
-
-        def cb(_: IncommingPacketType, data: dict) -> None:
-            parsed.append(data)
-
-        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
-
-        # Unit level command: ordinal=7, div present, target present, lifetime=200, payload=0x54
-        cmd = c.buildClassicCommand(7, bytes([0x54]), target_id=3, div=0x12, lifetime=200)
-        self.assertEqual(cmd.hex(), "f5c71203c854")
-
-        # All units level: ordinal=4, div present, no target, lifetime=200, payload=0xff
-        cmd2 = c.buildClassicCommand(4, bytes([0xFF]), target_id=None, div=0x01, lifetime=200)
-        self.assertEqual(cmd2.hex(), "f44401c8ff")
-
-        # target_id=0 is treated as "no target" (Android only writes target when > 0).
-        cmd3 = c.buildClassicCommand(4, bytes([0xFF]), target_id=0, div=0x01, lifetime=200)
-        self.assertEqual(cmd3.hex(), "f44401c8ff")
-
-
-class TestClassicSendWithoutKeys(unittest.IsolatedAsyncioTestCase):
-    async def test_classic_send_conformant_without_keys_has_zero_sig_and_seq(self) -> None:
-        sent: list[tuple[str, bytes, bool]] = []
-
-        def cb(_: IncommingPacketType, __: dict) -> None:
-            return
-
-        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
-        c._gattClient = _StubGattClient()
-        c._connectionState = ConnectionState.AUTHENTICATED
-        c._protocolMode = ProtocolMode.CLASSIC
-        c._dataCharUuid = "dummy"
-        c._classicConnHash8 = b"\x11" * 8
-        c._classicHeaderMode = "conformant"
-        c._classicTxSeq = 0
-
-        cmd = c.buildClassicCommand(4, bytes([0xFF]), div=0x01, lifetime=200)
-        await c.send(cmd)
-
-        stub = c._gattClient
-        assert isinstance(stub, _StubGattClient)
-        self.assertEqual(len(stub.writes), 1)
-        _uuid, pkt, response = stub.writes[0]
-        self.assertTrue(response)
-
-        # [auth=0x02][sig(4x00)][seq=0x0001][cmd...]
-        self.assertEqual(pkt[0], 0x02)
-        self.assertEqual(pkt[1:5], b"\x00" * 4)
-        self.assertEqual(pkt[5:7], b"\x00\x01")
-        self.assertEqual(pkt[7:], cmd)
-
-    async def test_classic_send_legacy_without_keys_has_zero_sig(self) -> None:
-        def cb(_: IncommingPacketType, __: dict) -> None:
-            return
-
-        c = CasambiClient("00:00:00:00:00:00", cb, lambda: None, _DummyNetwork())
-        c._gattClient = _StubGattClient()
-        c._connectionState = ConnectionState.AUTHENTICATED
-        c._protocolMode = ProtocolMode.CLASSIC
-        c._dataCharUuid = "dummy"
-        c._classicConnHash8 = b"\x11" * 8
-        c._classicHeaderMode = "legacy"
-
-        cmd = c.buildClassicCommand(4, bytes([0xFF]), div=0x01, lifetime=200)
-        await c.send(cmd)
-
-        stub = c._gattClient
-        assert isinstance(stub, _StubGattClient)
-        self.assertEqual(len(stub.writes), 1)
-        _uuid, pkt, response = stub.writes[0]
-        self.assertTrue(response)
-
-        # [sig(4x00)][cmd...]
-        self.assertEqual(pkt[:4], b"\x00" * 4)
-        self.assertEqual(pkt[4:], cmd)
-
-
-if __name__ == "__main__":
-    unittest.main()