pycloudedge 0.1.5.dev0__tar.gz → 0.1.6.dev1__tar.gz

{pycloudedge-0.1.5.dev0 → pycloudedge-0.1.6.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycloudedge
-Version: 0.1.5.dev0
+Version: 0.1.6.dev1
 Summary: Python library for CloudEdge cameras
 Home-page: https://github.com/fradaloisio/pycloudedge
 Author: Francesco D'Aloisio

{pycloudedge-0.1.5.dev0 → pycloudedge-0.1.6.dev1}/cloudedge/__init__.py

@@ -16,6 +16,7 @@ from .client import (
     DEVICE_STATUS_OFFLINE,
 )
 from .mqtt import CloudEdgeMqttListener, ALARM_TYPE_NAMES, MOTION_ALARM_TYPES
+from .image_decrypt import decrypt_jpgx3, decrypt_jpgx3_from_url, verify_licence_for_url
 from .exceptions import (
     CloudEdgeError, AuthenticationError, DeviceNotFoundError, 
     ConfigurationError, NetworkError, ValidationError, RateLimitError
@@ -45,5 +46,8 @@ __all__ = [
     'RateLimitError',
     'IOT_PARAMETERS',
     'get_parameter_name',
-    'format_parameter_value'
+    'format_parameter_value',
+    'decrypt_jpgx3',
+    'decrypt_jpgx3_from_url',
+    'verify_licence_for_url',
 ]

{pycloudedge-0.1.5.dev0 → pycloudedge-0.1.6.dev1}/cloudedge/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.5.dev0'
-__version_tuple__ = version_tuple = (0, 1, 5, 'dev0')
+__version__ = version = '0.1.6.dev1'
+__version_tuple__ = version_tuple = (0, 1, 6, 'dev1')
 
-__commit_id__ = commit_id = 'ga05fef1a8'
+__commit_id__ = commit_id = None

{pycloudedge-0.1.5.dev0 → pycloudedge-0.1.6.dev1}/cloudedge/client.py

@@ -562,6 +562,13 @@ class CloudEdgeClient:
         self.session_data = self._load_session_cache()
         if self.session_data:
             self._log("Using cached session")
+            # Fetch MQTT config if not already present in the cached session
+            if not self.session_data.get("mqtt"):
+                try:
+                    self._fetch_iot_config()
+                    self._save_session_cache(self.session_data)
+                except Exception as exc:
+                    self._log(f"IoT config fetch failed (non-fatal): {exc}")
             return True
             
         self._log("Performing CloudEdge login...")

pycloudedge-0.1.6.dev1/cloudedge/image_decrypt.py

@@ -0,0 +1,96 @@
+"""Decrypt Meari/CloudEdge ``.jpgx3`` alarm images.
+
+The CloudEdge MQTT push events include a URL to an encrypted JPEG snapshot
+captured at the moment of the alarm.  The file uses a simple XOR cipher
+derived from the device's serial number (licence ID).
+
+Algorithm (reverse-engineered from ``libmrplayer.so``):
+
+1. Build the seed string ``"{licence_id}|{len(licence_id)}|meari.stream"``.
+2. Compute ``MD5(seed)`` and represent it as a **32-char lowercase hex string**.
+3. XOR the first ``min(len(data), 1024)`` bytes of the encrypted file with
+   the hex string, cycling every 32 bytes.  Bytes beyond 1024 are unchanged.
+
+The companion ``meari.key`` variant (same pattern but with ``"meari.key"``
+instead of ``"meari.stream"``) produces the hash embedded in the filename,
+which can be used to verify that the correct licence ID was used.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Optional
+
+_LOGGER = logging.getLogger(__name__)
+
+_XOR_LIMIT = 1024
+
+
+def _meari_md5(licence_id: str, suffix: str) -> str:
+    """Return ``MD5("{licence_id}|{len}|{suffix}")`` as a 32-char hex string."""
+    seed = f"{licence_id}|{len(licence_id)}|{suffix}"
+    return hashlib.md5(seed.encode("utf-8")).hexdigest()
+
+
+def verify_licence_for_url(url: str, licence_id: str) -> bool:
+    """Check whether *licence_id* matches the hash embedded in *url*."""
+    expected = _meari_md5(licence_id, "meari.key")
+    return expected in url
+
+
+def decrypt_jpgx3(data: bytes, licence_id: str) -> bytes:
+    """Decrypt a ``.jpgx3`` encrypted JPEG image.
+
+    Args:
+        data: Raw (encrypted) bytes downloaded from the alarm URL.
+        licence_id: The device serial number / licence ID
+                    (e.g. ``"ppsl6b9baee1884c4a9b"``).
+
+    Returns:
+        Decrypted JPEG bytes.
+    """
+    key_hex = _meari_md5(licence_id, "meari.stream").encode("ascii")  # 32 bytes
+    xor_len = min(len(data), _XOR_LIMIT)
+
+    out = bytearray(data)
+    for i in range(xor_len):
+        out[i] ^= key_hex[i % 32]
+
+    return bytes(out)
+
+
+def decrypt_jpgx3_from_url(
+    url: str,
+    licence_id: str,
+    *,
+    timeout: int = 15,
+    session=None,
+) -> Optional[bytes]:
+    """Download and decrypt a ``.jpgx3`` alarm image.
+
+    Args:
+        url: The full ``.jpgx3`` URL from the MQTT alarm payload.
+        licence_id: Device serial number / licence ID.
+        timeout: HTTP request timeout in seconds.
+        session: Optional ``requests.Session`` to reuse.
+
+    Returns:
+        Decrypted JPEG bytes, or ``None`` on failure.
+    """
+    import requests
+
+    try:
+        r = (session or requests).get(url, timeout=timeout)
+        r.raise_for_status()
+        if len(r.content) < 100:
+            _LOGGER.debug("Alarm image too small (%d bytes)", len(r.content))
+            return None
+    except Exception as exc:
+        _LOGGER.debug("Failed to download alarm image: %s", exc)
+        return None
+
+    if ".jpgx3" in url or ".jpgx2" in url:
+        return decrypt_jpgx3(r.content, licence_id)
+
+    return r.content

{pycloudedge-0.1.5.dev0 → pycloudedge-0.1.6.dev1}/cloudedge/mqtt.py

@@ -59,6 +59,13 @@ MOTION_ALARM_TYPES: frozenset[int] = frozenset({1, 2, 11, 20})
 OnEventCallback = Callable[[str, str, int, bool], None]
 """Signature: (device_id, event_name, event_type_int, is_motion) -> None"""
 
+OnEventCallbackEx = Callable[[str, str, int, bool, dict], None]
+"""Extended signature: (device_id, event_name, event_type_int, is_motion, extra) -> None
+
+``extra`` contains optional fields from the payload such as
+``url``, ``alert``, ``deviceName``, ``licenseID``, ``msgDate``.
+"""
+
 
 class CloudEdgeMqttListener:
     """Subscribe to the CloudEdge/Meari MQTT broker for push events.
@@ -205,15 +212,37 @@ class CloudEdgeMqttListener:
         except (json.JSONDecodeError, UnicodeDecodeError):
             return
 
-        # Unwrap nested envelope: params → data → msg
-        for key in ("params", "data"):
+        _LOGGER.info("MQTT raw payload: %s", json.dumps(data, default=str)[:2000])
+
+        original = data
+
+        # Unwrap nested envelope — walk into nested dicts looking for the event
+        # Real payload: { "event": "alarm", "params": { "result": { "evt": "1", "deviceID": "...", ... } } }
+        for key in ("params", "result", "data", "state", "reported"):
             if key in data and isinstance(data[key], dict):
                 data = data[key]
         if "msg" in data and isinstance(data["msg"], dict):
             data = data["msg"]
 
-        evt_raw = data.get("evt", data.get("eventType", ""))
-        device_id = str(data.get("deviceID", data.get("deviceId", "")))
+        for key in ("alarm", "alarmInfo"):
+            if key in data and isinstance(data[key], dict):
+                data = data[key]
+
+        evt_raw = (
+            data.get("evt")
+            or data.get("eventType")
+            or data.get("alarmType")
+            or data.get("type")
+            or ""
+        )
+        device_id = str(
+            data.get("deviceID")
+            or data.get("deviceId")
+            or data.get("devID")
+            or data.get("did")
+            or original.get("state", {}).get("reported", {}).get("deviceID", "")
+            or ""
+        )
 
         try:
             evt_int = int(evt_raw)
@@ -223,19 +252,35 @@ class CloudEdgeMqttListener:
         evt_name = ALARM_TYPE_NAMES.get(evt_int, f"type={evt_raw}")
         is_motion = evt_int in MOTION_ALARM_TYPES
 
+        extra: dict = {}
+        for field in ("url", "alert", "deviceName", "licenseID", "msgDate", "title"):
+            val = data.get(field)
+            if val:
+                extra[field] = str(val)
+
         _LOGGER.info(
-            "MQTT event: %s  device=%s  motion=%s",
-            evt_name, device_id, is_motion,
+            "MQTT event: %s  device=%s  motion=%s  url=%s",
+            evt_name, device_id, is_motion, bool(extra.get("url")),
         )
 
         if self.on_event:
             try:
-                self.on_event(device_id, evt_name, evt_int, is_motion)
+                self.on_event(device_id, evt_name, evt_int, is_motion, extra)
+            except TypeError:
+                try:
+                    self.on_event(device_id, evt_name, evt_int, is_motion)
+                except Exception as exc:
+                    _LOGGER.debug("on_event callback error: %s", exc)
             except Exception as exc:
                 _LOGGER.debug("on_event callback error: %s", exc)
 
         if is_motion and self.on_motion:
             try:
-                self.on_motion(device_id, evt_name, evt_int, is_motion)
+                self.on_motion(device_id, evt_name, evt_int, is_motion, extra)
+            except TypeError:
+                try:
+                    self.on_motion(device_id, evt_name, evt_int, is_motion)
+                except Exception as exc:
+                    _LOGGER.debug("on_motion callback error: %s", exc)
             except Exception as exc:
                 _LOGGER.debug("on_motion callback error: %s", exc)

{pycloudedge-0.1.5.dev0 → pycloudedge-0.1.6.dev1}/pycloudedge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycloudedge
-Version: 0.1.5.dev0
+Version: 0.1.6.dev1
 Summary: Python library for CloudEdge cameras
 Home-page: https://github.com/fradaloisio/pycloudedge
 Author: Francesco D'Aloisio

{pycloudedge-0.1.5.dev0 → pycloudedge-0.1.6.dev1}/pycloudedge.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ cloudedge/cli.py
 cloudedge/client.py
 cloudedge/constants.py
 cloudedge/exceptions.py
+cloudedge/image_decrypt.py
 cloudedge/iot_parameters.py
 cloudedge/logging_config.py
 cloudedge/mqtt.py