pycloudedge 0.1.6.dev0__tar.gz → 0.1.6.dev2__tar.gz

{pycloudedge-0.1.6.dev0 → pycloudedge-0.1.6.dev2}/.gitignore

@@ -94,6 +94,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+.env_*
 
 # Spyder project settings
 .spyderproject

{pycloudedge-0.1.6.dev0 → pycloudedge-0.1.6.dev2}/PKG-INFO

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

{pycloudedge-0.1.6.dev0 → pycloudedge-0.1.6.dev2}/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.6.dev0 → pycloudedge-0.1.6.dev2}/cloudedge/_version.py

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

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

@@ -36,8 +36,9 @@ from .iot_parameters import (
     format_parameter_value
 )
 from .constants import (
-    CA_KEY, DEFAULT_HEADERS, DEFAULT_TIMEOUT,
-    REGION_ENDPOINTS, REGION_EU, REGION_US,
+    CA_KEY, CA_SECRET, DEFAULT_HEADERS, DEFAULT_TIMEOUT,
+    REGION_ENDPOINTS, REGION_EU, REGION_US, REGION_AP,
+    REDIRECT_URL,
     region_for_country,
 )
 from .validators import validate_email, validate_country_code, validate_phone_code
@@ -145,9 +146,10 @@ class CloudEdgeClient:
             session_cache_file (str): Path to session cache file
             enable_network_ping (bool): Enable ping-based online status when on same network
             ping_timeout (float): Ping timeout in seconds
-            region (str, optional): Force a specific region ("eu" or "us").
+            region (str, optional): Force a specific region ("eu", "us", or "ap").
                 When *None* the region is derived automatically from *country_code*:
-                European countries use the EU endpoints, everything else uses US.
+                European countries → EU, Asia-Pacific/Oceania/ME/Africa → AP
+                (Singapore), everything else → US.
             
         Raises:
             ValidationError: If input validation fails
@@ -547,6 +549,95 @@ class CloudEdgeClient:
         except Exception as e:
             self._log(f"Failed to save session cache: {e}")
             
+    def _discover_endpoints(self) -> None:
+        """Call the global redirect API to discover the correct regional server.
+
+        The CloudEdge mobile app calls ``/ppstrongs/redirect`` on the global
+        gateway (``apis.cloudedge360.com``) **before** login.  The response
+        contains the regional ``apiServer`` and ``openapi`` domain that must be
+        used for the given account/country.
+
+        On success, ``self.BASE_URL`` and ``self.OPENAPI_BASE_URL`` are updated.
+        On failure the previously configured (static) endpoints are kept.
+        """
+        import random
+
+        timestamp = int(time.time() * 1000)
+        encrypted_account = self._aes_encode_param(
+            self.username, "/ppstrongs/redirect", timestamp=timestamp,
+        )
+        query_nonce = "".join(
+            [str(random.randint(0, 9)) for _ in range(8)]
+        )
+        header_nonce = str(random.randint(100000, 999999))
+
+        phone_code_bare = self.phone_code.lstrip("+")
+        params = {
+            "phoneType": "a",
+            "sourceApp": "8",
+            "appVer": "5.5.1",
+            "appVerCode": "551",
+            "localTime": str(timestamp),
+            "t": str(timestamp),
+            "lngType": "en",
+            "countryCode": self.country_code,
+            "userAccount": encrypted_account,
+            "phoneCode": phone_code_bare,
+            "partnerId": "8",
+            "nonce": query_nonce,
+        }
+
+        # sign = MD5("GET|/ppstrongs/redirect|{timestamp}|apis.meari.com.cn")
+        params["sign"] = hashlib.md5(
+            f"GET|/ppstrongs/redirect|{timestamp}|apis.meari.com.cn".encode()
+        ).hexdigest()
+
+        # X-Ca-Sign: HMAC-SHA1 with CA_SECRET as key
+        # The app builds: "api=/ppstrongs/" + getRealUrl(path) + "|X-Ca-Key=...|..."
+        # getRealUrl("/ppstrongs/redirect") returns "/ppstrongs/redirect" unchanged,
+        # so the full string is "api=/ppstrongs//ppstrongs/redirect|..."
+        ca_sign_data = (
+            f"api=/ppstrongs//ppstrongs/redirect"
+            f"|X-Ca-Key={CA_KEY}"
+            f"|X-Ca-Timestamp={timestamp}"
+            f"|X-Ca-Nonce={header_nonce}"
+        )
+        ca_signature = base64.b64encode(
+            hmac.new(CA_SECRET.encode(), ca_sign_data.encode(), hashlib.sha1).digest()
+        ).decode()
+
+        headers = {
+            **DEFAULT_HEADERS,
+            "X-Ca-Timestamp": str(timestamp),
+            "X-Ca-Sign": ca_signature,
+            "X-Ca-Key": CA_KEY,
+            "X-Ca-Nonce": header_nonce,
+        }
+
+        try:
+            resp = self._session.get(
+                REDIRECT_URL, params=params, headers=headers, timeout=DEFAULT_TIMEOUT,
+            )
+            data = resp.json()
+            if data.get("resultCode") != "1001":
+                self._log(f"Redirect discovery returned {data.get('resultCode')}")
+                return
+
+            result = data.get("result", {})
+            api_server = result.get("apiServer") or result.get("gwUrl") or ""
+            if api_server:
+                self.BASE_URL = api_server.rstrip("/")
+                self._log(f"Discovered API server: {self.BASE_URL}")
+
+            pf_api = result.get("pfApi", {})
+            openapi_domain = pf_api.get("openapi", {}).get("domain", "")
+            if openapi_domain:
+                self.OPENAPI_BASE_URL = openapi_domain.rstrip("/")
+                self._log(f"Discovered OpenAPI server: {self.OPENAPI_BASE_URL}")
+
+        except Exception as exc:
+            self._log(f"Endpoint discovery failed (will use static endpoints): {exc}")
+
     def authenticate(self) -> bool:
         """
         Authenticate with CloudEdge API.
@@ -562,6 +653,11 @@ class CloudEdgeClient:
         self.session_data = self._load_session_cache()
         if self.session_data:
             self._log("Using cached session")
+            # Restore discovered endpoints from cache if present
+            if self.session_data.get("apiServer"):
+                self.BASE_URL = self.session_data["apiServer"]
+            if self.session_data.get("openapiServer"):
+                self.OPENAPI_BASE_URL = self.session_data["openapiServer"]
             # Fetch MQTT config if not already present in the cached session
             if not self.session_data.get("mqtt"):
                 try:
@@ -570,7 +666,10 @@ class CloudEdgeClient:
                 except Exception as exc:
                     self._log(f"IoT config fetch failed (non-fatal): {exc}")
             return True
-            
+
+        # Discover the correct regional endpoints before login
+        self._discover_endpoints()
+
         self._log("Performing CloudEdge login...")
         
         # Encrypt credentials
@@ -660,6 +759,7 @@ class CloudEdgeClient:
                     "caKey": ca_key,
                     "loginTime": int(time.time()),
                     "apiServer": self.BASE_URL,
+                    "openapiServer": self.OPENAPI_BASE_URL,
                     "iotPlatformKeys": iot_platform_keys,
                 }
 

{pycloudedge-0.1.6.dev0 → pycloudedge-0.1.6.dev2}/cloudedge/constants.py

@@ -5,8 +5,9 @@ Configuration constants for CloudEdge API
 # Region identifiers
 REGION_EU = "eu"
 REGION_US = "us"
+REGION_AP = "ap"
 
-# Per-region API endpoints
+# Per-region API endpoints (static fallback when redirect discovery fails)
 REGION_ENDPOINTS = {
     REGION_EU: {
         "base_url": "https://apis-eu-frankfurt.cloudedge360.com",
@@ -16,8 +17,15 @@ REGION_ENDPOINTS = {
         "base_url": "https://apis-us-west.cloudedge360.com",
         "openapi_base_url": "https://openapi-uswe.mearicloud.com",
     },
+    REGION_AP: {
+        "base_url": "https://apis-as-singapore.cloudedge360.com",
+        "openapi_base_url": "https://openapi-usce.mearicloud.com",
+    },
 }
 
+# Global redirect endpoint — used to discover the correct regional server
+REDIRECT_URL = "https://apis.cloudedge360.com/ppstrongs/redirect"
+
 # Default endpoints (EU) – kept for backward compatibility
 BASE_URL = REGION_ENDPOINTS[REGION_EU]["base_url"]
 OPENAPI_BASE_URL = REGION_ENDPOINTS[REGION_EU]["openapi_base_url"]
@@ -35,14 +43,39 @@ EU_COUNTRY_CODES = {
 }
 
 
+# Asia-Pacific / Oceania / Middle East / Africa country codes
+# These are routed through the Singapore gateway
+AP_COUNTRY_CODES = {
+    # East Asia
+    "JP", "KR", "TW", "HK", "MO",
+    # Southeast Asia
+    "SG", "MY", "TH", "VN", "PH", "ID", "MM", "KH", "LA", "BN", "TL",
+    # South Asia
+    "IN", "PK", "BD", "LK", "NP", "BT", "MV",
+    # Oceania
+    "AU", "NZ", "FJ", "PG", "WS", "TO", "VU", "SB", "KI", "MH", "FM",
+    "PW", "NR", "TV", "CK", "NU",
+    # Middle East
+    "AE", "SA", "QA", "KW", "BH", "OM", "JO", "LB", "IQ", "IR", "YE",
+    "SY", "PS", "IL",
+    # Africa
+    "ZA", "EG", "NG", "KE", "GH", "TZ", "UG", "ET", "MA", "DZ", "TN",
+    "SN", "CI", "CM", "AO", "MZ", "ZW", "BW", "NA", "MU", "MG", "RW",
+}
+
+
 def region_for_country(country_code: str) -> str:
     """Return the region key for a given ISO 3166-1 alpha-2 country code."""
-    if country_code.upper() in EU_COUNTRY_CODES:
+    cc = country_code.upper()
+    if cc in EU_COUNTRY_CODES:
         return REGION_EU
+    if cc in AP_COUNTRY_CODES:
+        return REGION_AP
     return REGION_US
 
 # API Keys (these are public keys from the mobile app)
 CA_KEY = "bc29be30292a4309877807e101afbd51"
+CA_SECRET = "35a69fd1-6527-4566-b190-921f9a651488"
 
 # Default Headers
 DEFAULT_HEADERS = {

pycloudedge-0.1.6.dev2/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.6.dev0 → pycloudedge-0.1.6.dev2}/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.6.dev0 → pycloudedge-0.1.6.dev2}/pycloudedge.egg-info/PKG-INFO

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

{pycloudedge-0.1.6.dev0 → pycloudedge-0.1.6.dev2}/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