pyezvizapi 1.0.0.0__py3-none-any.whl

pyezvizapi/mqtt.py

@@ -0,0 +1,259 @@
+"""Ezviz cloud MQTT client for push messages."""
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import threading
+import time
+from typing import Any
+
+import paho.mqtt.client as mqtt
+import requests
+
+from .api_endpoints import (
+    API_ENDPOINT_REGISTER_MQTT,
+    API_ENDPOINT_START_MQTT,
+    API_ENDPOINT_STOP_MQTT,
+)
+from .constants import (
+    APP_SECRET,
+    DEFAULT_TIMEOUT,
+    FEATURE_CODE,
+    MQTT_APP_KEY,
+    REQUEST_HEADER,
+)
+from .exceptions import HTTPError, InvalidURL, PyEzvizError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MQTTClient(threading.Thread):
+    """Open MQTT connection to ezviz cloud."""
+
+    def __init__(
+        self,
+        token: dict,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> None:
+        """Initialize the client object."""
+        threading.Thread.__init__(self)
+        self._session = requests.session()
+        self._session.headers.update(REQUEST_HEADER)
+        self._token = token or {
+            "session_id": None,
+            "rf_session_id": None,
+            "username": None,
+            "api_url": "apiieu.ezvizlife.com",
+        }
+        self._timeout = timeout
+        self._stop_event = threading.Event()
+        self._mqtt_data = {
+            "mqtt_clientid": None,
+            "ticket": None,
+            "push_url": token["service_urls"]["pushAddr"],
+        }
+        self.mqtt_client = None
+        self.rcv_message: dict[Any, Any] = {}
+
+    def on_subscribe(
+        self, client: Any, userdata: Any, mid: Any, granted_qos: Any
+    ) -> None:
+        """On MQTT message subscribe."""
+        # pylint: disable=unused-argument
+        _LOGGER.info("Subscribed: %s %s", mid, granted_qos)
+
+    def on_connect(
+        self, client: Any, userdata: Any, flags: Any, return_code: Any
+    ) -> None:
+        """On MQTT connect."""
+        # pylint: disable=unused-argument
+        if return_code == 0:
+            _LOGGER.info("Connected OK with return code %s", return_code)
+        else:
+            _LOGGER.info("Connection Error with Return code %s", return_code)
+            client.reconnect()
+
+    def on_message(self, client: Any, userdata: Any, msg: Any) -> None:
+        """On MQTT message receive."""
+        # pylint: disable=unused-argument
+        try:
+            mqtt_message = json.loads(msg.payload)
+
+        except ValueError as err:
+            self.stop()
+            raise PyEzvizError(
+                "Impossible to decode mqtt message: " + str(err)
+            ) from err
+
+        mqtt_message["ext"] = mqtt_message["ext"].split(",")
+
+        # Format payload message and keep latest device message.
+        self.rcv_message[mqtt_message["ext"][2]] = {
+            "id": mqtt_message["id"],
+            "alert": mqtt_message["alert"],
+            "time": mqtt_message["ext"][1],
+            "alert type": mqtt_message["ext"][4],
+            "image": mqtt_message["ext"][16] if len(mqtt_message["ext"]) > 16 else None,
+        }
+
+        _LOGGER.debug(self.rcv_message, exc_info=True)
+
+    def _mqtt(self) -> mqtt.Client:
+        """Receive MQTT messages from ezviz server."""
+
+        ezviz_mqtt_client = mqtt.Client(
+            client_id=self._mqtt_data["mqtt_clientid"], protocol=4, transport="tcp"
+        )
+        ezviz_mqtt_client.on_connect = self.on_connect
+        ezviz_mqtt_client.on_subscribe = self.on_subscribe
+        ezviz_mqtt_client.on_message = self.on_message
+        ezviz_mqtt_client.username_pw_set(MQTT_APP_KEY, APP_SECRET)
+
+        ezviz_mqtt_client.connect(self._mqtt_data["push_url"], 1882, 60)
+        ezviz_mqtt_client.subscribe(
+            f"{MQTT_APP_KEY}/ticket/{self._mqtt_data['ticket']}", qos=2
+        )
+
+        ezviz_mqtt_client.loop_start()
+        return ezviz_mqtt_client
+
+    def _register_ezviz_push(self) -> None:
+        """Register for push messages."""
+
+        auth_seq = (
+            "Basic "
+            + base64.b64encode(f"{MQTT_APP_KEY}:{APP_SECRET}".encode("ascii")).decode()
+        )
+
+        payload = {
+            "appKey": MQTT_APP_KEY,
+            "clientType": "5",
+            "mac": FEATURE_CODE,
+            "token": "123456",
+            "version": "v1.3.0",
+        }
+
+        try:
+            req = self._session.post(
+                f"https://{self._mqtt_data['push_url']}{API_ENDPOINT_REGISTER_MQTT}",
+                allow_redirects=False,
+                headers={"Authorization": auth_seq},
+                data=payload,
+                timeout=self._timeout,
+            )
+
+            req.raise_for_status()
+
+        except requests.ConnectionError as err:
+            raise InvalidURL("A Invalid URL or Proxy error occured") from err
+
+        except requests.HTTPError as err:
+            raise HTTPError from err
+
+        try:
+            json_result = req.json()
+
+        except ValueError as err:
+            raise PyEzvizError(
+                "Impossible to decode response: "
+                + str(err)
+                + "\nResponse was: "
+                + str(req.text)
+            ) from err
+
+        self._mqtt_data["mqtt_clientid"] = json_result["data"]["clientId"]
+
+    def run(self) -> None:
+        """Start mqtt thread."""
+
+        if self._token.get("username") is None:
+            self._stop_event.set()
+            raise PyEzvizError(
+                "Ezviz internal username is required. Call EzvizClient login without token."
+            )
+
+        self._register_ezviz_push()
+        self._start_ezviz_push()
+        self.mqtt_client = self._mqtt()
+
+    def start(self) -> None:
+        """Start mqtt thread as application. Set logging first to see messages."""
+        self.run()
+
+        try:
+            while not self._stop_event.is_set():
+                time.sleep(1)
+        except KeyboardInterrupt:
+            self.stop()
+
+    def stop(self) -> None:
+        """Stop push notifications."""
+
+        payload = {
+            "appKey": MQTT_APP_KEY,
+            "clientId": self._mqtt_data["mqtt_clientid"],
+            "clientType": 5,
+            "sessionId": self._token["session_id"],
+            "username": self._token["username"],
+        }
+
+        try:
+            req = self._session.post(
+                f"https://{self._mqtt_data['push_url']}{API_ENDPOINT_STOP_MQTT}",
+                data=payload,
+                timeout=self._timeout,
+            )
+
+            req.raise_for_status()
+
+        except requests.ConnectionError as err:
+            raise InvalidURL("A Invalid URL or Proxy error occured") from err
+
+        except requests.HTTPError as err:
+            raise HTTPError from err
+
+        finally:
+            self._stop_event.set()
+            self.mqtt_client.loop_stop()
+
+    def _start_ezviz_push(self) -> None:
+        """Send start for push messages to ezviz api."""
+
+        payload = {
+            "appKey": MQTT_APP_KEY,
+            "clientId": self._mqtt_data["mqtt_clientid"],
+            "clientType": 5,
+            "sessionId": self._token["session_id"],
+            "username": self._token["username"],
+            "token": "123456",
+        }
+
+        try:
+            req = self._session.post(
+                f"https://{self._mqtt_data['push_url']}{API_ENDPOINT_START_MQTT}",
+                allow_redirects=False,
+                data=payload,
+                timeout=self._timeout,
+            )
+
+            req.raise_for_status()
+
+        except requests.ConnectionError as err:
+            raise InvalidURL("A Invalid URL or Proxy error occured") from err
+
+        except requests.HTTPError as err:
+            raise HTTPError from err
+
+        try:
+            json_result = req.json()
+
+        except ValueError as err:
+            raise PyEzvizError(
+                "Impossible to decode response: "
+                + str(err)
+                + "\nResponse was: "
+                + str(req.text)
+            ) from err
+
+        self._mqtt_data["ticket"] = json_result["ticket"]

pyezvizapi/test_cam_rtsp.py

@@ -0,0 +1,149 @@
+"""Test camera RTSP authentication."""
+import base64
+import hashlib
+import socket
+
+from .exceptions import AuthTestResultFailed, InvalidHost
+
+
+def genmsg_describe(url, seq, user_agent, auth_seq):
+    """Generate RTSP describe message."""
+    msg_ret = "DESCRIBE " + url + " RTSP/1.0\r\n"
+    msg_ret += "CSeq: " + str(seq) + "\r\n"
+    msg_ret += "Authorization: " + auth_seq + "\r\n"
+    msg_ret += "User-Agent: " + user_agent + "\r\n"
+    msg_ret += "Accept: application/sdp\r\n"
+    msg_ret += "\r\n"
+    return msg_ret
+
+
+class TestRTSPAuth:
+    """Test RTSP credentials."""
+
+    def __init__(
+        self,
+        ip_addr,
+        username=None,
+        password=None,
+        test_uri="",
+    ) -> None:
+        """Initialize RTSP credential test."""
+        self._rtsp_details = {
+            "bufLen": 1024,
+            "defaultServerIp": ip_addr,
+            "defaultServerPort": 554,
+            "defaultTestUri": test_uri,
+            "defaultUserAgent": "RTSP Client",
+            "defaultUsername": username,
+            "defaultPassword": password,
+        }
+
+    def generate_auth_string(self, realm, method, uri, nonce):
+        """Generate digest auth string."""
+        map_return_info = {}
+        m_1 = hashlib.md5(
+            f"{self._rtsp_details['defaultUsername']}:"
+            f"{realm.decode()}:"
+            f"{self._rtsp_details['defaultPassword']}".encode()
+        ).hexdigest()
+        m_2 = hashlib.md5(f"{method}:{uri}".encode()).hexdigest()
+        response = hashlib.md5(f"{m_1}:{nonce}:{m_2}".encode()).hexdigest()
+
+        map_return_info = (
+            f"Digest "
+            f"username=\"{self._rtsp_details['defaultUsername']}\", "
+            f'realm="{realm.decode()}", '
+            f'algorithm="MD5", '
+            f'nonce="{nonce.decode()}", '
+            f'uri="{uri}", '
+            f'response="{response}"'
+        )
+        return map_return_info
+
+    def main(self):
+        """Start main method."""
+        session = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        try:
+            session.connect(
+                (
+                    self._rtsp_details["defaultServerIp"],
+                    self._rtsp_details["defaultServerPort"],
+                )
+            )
+
+        except TimeoutError as err:
+            raise AuthTestResultFailed("Invalid ip or camera hibernating") from err
+
+        except (socket.gaierror, ConnectionRefusedError) as err:
+            raise InvalidHost("Invalid IP or Hostname") from err
+
+        seq = 1
+
+        url = (
+            "rtsp://"
+            + self._rtsp_details["defaultServerIp"]
+            + self._rtsp_details["defaultTestUri"]
+        )
+
+        auth_seq = base64.b64encode(
+            f"{self._rtsp_details['defaultUsername']}:"
+            f"{self._rtsp_details['defaultPassword']}".encode("ascii")
+        )
+        auth_seq = "Basic " + auth_seq.decode()
+
+        print(
+            genmsg_describe(url, seq, self._rtsp_details["defaultUserAgent"], auth_seq)
+        )
+        session.send(
+            genmsg_describe(
+                url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
+            ).encode()
+        )
+        msg1 = session.recv(self._rtsp_details["bufLen"])
+        seq = seq + 1
+
+        if msg1.decode().find("200 OK") > 1:
+            print(f"Basic auth result: {msg1.decode()}")
+            return print("Basic Auth test passed. Credentials Valid!")
+
+        if msg1.decode().find("Unauthorized") > 1:
+            # Basic failed, doing new DESCRIBE with digest authentication.
+            start = msg1.decode().find("realm")
+            begin = msg1.decode().find('"', start)
+            end = msg1.decode().find('"', begin + 1)
+            realm = msg1[begin + 1 : end]
+
+            start = msg1.decode().find("nonce")
+            begin = msg1.decode().find('"', start)
+            end = msg1.decode().find('"', begin + 1)
+            nonce = msg1[begin + 1 : end]
+
+            auth_seq = self.generate_auth_string(
+                realm,
+                "DESCRIBE",
+                self._rtsp_details["defaultTestUri"],
+                nonce,
+            )
+
+            print(
+                genmsg_describe(
+                    url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
+                )
+            )
+
+            session.send(
+                genmsg_describe(
+                    url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
+                ).encode()
+            )
+            msg1 = session.recv(self._rtsp_details["bufLen"])
+            print(f"Digest auth result: {msg1.decode()}")
+
+            if msg1.decode().find("200 OK") > 1:
+                return print("Digest Auth test Passed. Credentials Valid!")
+
+            if msg1.decode().find("401 Unauthorized") > 1:
+                raise AuthTestResultFailed("Credentials not valid!!")
+
+        return print("Basic Auth test passed. Credentials Valid!")

pyezvizapi/utils.py

@@ -0,0 +1,160 @@
+"""Decrypt camera images."""
+from __future__ import annotations
+
+from hashlib import md5
+import json
+import logging
+from typing import Any
+
+from Crypto.Cipher import AES
+
+from .exceptions import PyEzvizError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def convert_to_dict(data: Any) -> Any:
+    """Recursively convert a string representation of a dictionary to a dictionary."""
+    if isinstance(data, dict):
+        for key, value in data.items():
+            if isinstance(value, str):
+                try:
+                    # Attempt to convert the string back into a dictionary
+                    data[key] = json.loads(value)
+
+                except ValueError:
+                    continue
+            continue
+
+    return data
+
+
+def string_to_list(data: Any, separator: str = ",") -> Any:
+    """Convert a string representation of a list to a list."""
+    if isinstance(data, str):
+        if separator in data:
+            try:
+                # Attempt to convert the string into a list
+                return data.split(separator)
+
+            except AttributeError:
+                return data
+
+    return data
+
+
+def fetch_nested_value(data: Any, keys: list, default_value: Any = None) -> Any:
+    """Fetch the value corresponding to the given nested keys in a dictionary.
+
+    If any of the keys in the path doesn't exist, the default value is returned.
+
+    Args:
+        data (dict): The nested dictionary to search for keys.
+        keys (list): A list of keys representing the path to the desired value.
+        default_value (optional): The value to return if any of the keys doesn't exist.
+
+    Returns:
+        The value corresponding to the nested keys or the default value.
+
+    """
+    try:
+        for key in keys:
+            data = data[key]
+        return data
+    except (KeyError, TypeError):
+        return default_value
+
+
+def decrypt_image(input_data: bytes, password: str) -> bytes:
+    """Decrypts image data with provided password.
+
+    Args:
+        input_data (bytes): Encrypted image data
+        password (string): Verification code
+
+    Raises:
+        PyEzvizError
+
+    Returns:
+        bytes: Decrypted image data
+
+    """
+
+    if len(input_data) < 48:
+        raise PyEzvizError("Invalid image data")
+
+    # check header
+    if input_data[:16] != b"hikencodepicture":
+        _LOGGER.warning("Image header doesn't contain 'hikencodepicture'")
+        return input_data
+
+    file_hash = input_data[16:48]
+    passwd_hash = (
+        md5(str.encode(md5(str.encode(password)).digest().hex())).digest().hex()
+    )
+    if file_hash != str.encode(passwd_hash):
+        raise PyEzvizError("Invalid password")
+
+    key = str.encode(password.ljust(16, "\u0000")[:16])
+    iv_code = bytes([48, 49, 50, 51, 52, 53, 54, 55, 0, 0, 0, 0, 0, 0, 0, 0])
+    cipher = AES.new(key, AES.MODE_CBC, iv_code)
+
+    next_chunk = b""
+    output_data = b""
+    finished = False
+    i = 48  # offset hikencodepicture + hash
+    chunk_size = 1024 * AES.block_size
+    while not finished:
+        chunk, next_chunk = next_chunk, cipher.decrypt(input_data[i : i + chunk_size])
+        if len(next_chunk) == 0:
+            padding_length = chunk[-1]
+            chunk = chunk[:-padding_length]
+            finished = True
+        output_data += chunk
+        i += chunk_size
+    return output_data
+
+def deep_merge(dict1, dict2):
+    """Recursively merges two dictionaries, handling lists as well.
+
+    Args:
+    dict1 (dict): The first dictionary.
+    dict2 (dict): The second dictionary.
+
+    Returns:
+    dict: The merged dictionary.
+
+    """
+    # If one of the dictionaries is None, return the other one
+    if dict1 is None:
+        return dict2
+    if dict2 is None:
+        return dict1
+
+    if not isinstance(dict1, dict) or not isinstance(dict2, dict):
+        if isinstance(dict1, list) and isinstance(dict2, list):
+            return dict1 + dict2
+        return dict2
+
+    # Create a new dictionary to store the merged result
+    merged = {}
+
+    # Merge keys from both dictionaries
+    for key in set(dict1.keys()) | set(dict2.keys()):
+        if key in dict1 and key in dict2:
+            if isinstance(dict1[key], dict) and isinstance(dict2[key], dict):
+                merged[key] = deep_merge(dict1[key], dict2[key])
+            elif isinstance(dict1[key], list) and isinstance(dict2[key], list):
+                merged[key] = dict1[key] + dict2[key]
+            else:
+                # If both values are not dictionaries or lists, keep the value from dict2
+                merged[key] = dict2[key]
+        elif key in dict1:
+            # If the key is only in dict1, keep its value
+            merged[key] = dict1[key]
+        else:
+            # If the key is only in dict2, keep its value
+            merged[key] = dict2[key]
+
+    return merged
+