homelink-integration-api 0.0.1__tar.gz

homelink_integration_api-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Gentex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

homelink_integration_api-0.0.1/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: homelink-integration-api
+Version: 0.0.1
+Summary: API to interact with Homelink cloud for MQTT-enabled smart home platforms
+Author-email: Nicholas Aelick <niaexa@syntronic.com>, Ryan Jones <ryan.jones@gentex.com>, Evgeniy Burbyga <evbuxa@syntronic.com>
+Project-URL: Homepage, https://www.homelink.com/
+Project-URL: Issues, https://www.homelink.com/support
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-decouple>=3.8
+Requires-Dist: boto3
+Dynamic: license-file
+
+# HomeLink smart home integration API
+
+This project contains a python API to connect MQTT-enabled smart home platforms to HomeLink smarthome cloud
+
+## Setup
+
+This repo utilizes VS Code [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) so you don't need to alter your global python environment.
+
+## Installing dependencies
+
+Use `pip` to install required dependencies by running `pip install -r requirements.txt` from the project root.
+
+## Updating dependencies
+
+During the course of development, if new packages are added, it's recommended to update [`requirements.txt`](./requirements.txt) by running `pip freeze > requirements.txt`.

homelink_integration_api-0.0.1/README.md

@@ -0,0 +1,15 @@
+# HomeLink smart home integration API
+
+This project contains a python API to connect MQTT-enabled smart home platforms to HomeLink smarthome cloud
+
+## Setup
+
+This repo utilizes VS Code [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) so you don't need to alter your global python environment.
+
+## Installing dependencies
+
+Use `pip` to install required dependencies by running `pip install -r requirements.txt` from the project root.
+
+## Updating dependencies
+
+During the course of development, if new packages are added, it's recommended to update [`requirements.txt`](./requirements.txt) by running `pip freeze > requirements.txt`.

homelink_integration_api-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "homelink-integration-api"
+version = "0.0.1"
+authors = [
+  { name="Nicholas Aelick", email="niaexa@syntronic.com" },
+  { name="Ryan Jones", email="ryan.jones@gentex.com" },
+  { name="Evgeniy Burbyga", email="evbuxa@syntronic.com" },
+]
+description = "API to interact with Homelink cloud for MQTT-enabled smart home platforms"
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = ["python-decouple>=3.8", "boto3"]
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "src"
+]
+asyncio_default_fixture_loop_scope = "function"
+
+[project.urls]
+Homepage = "https://www.homelink.com/"
+Issues = "https://www.homelink.com/support"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

homelink_integration_api-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

homelink_integration_api-0.0.1/src/homelink/auth/abstract_auth.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+from aiohttp import ClientSession, ClientResponse
+
+
+class AbstractAuth(ABC):
+    """Abstract class to make authenticated requests."""
+
+    def __init__(self, websession: ClientSession) -> None:
+        """Initialize the auth."""
+        self.websession = websession
+
+    @abstractmethod
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+
+    async def request(self, method, url, **kwargs) -> ClientResponse:
+        """Make a request."""
+        headers = kwargs.get("headers")
+
+        if headers is None:
+            headers = {}
+        else:
+            headers = dict(headers)
+
+        access_token = await self.async_get_access_token()
+        headers["authorization"] = f"Bearer {access_token}"
+
+        return await self.websession.request(
+            method,
+            url,
+            **kwargs,
+            headers=headers,
+        )

homelink_integration_api-0.0.1/src/homelink/auth/aws_srp.py

@@ -0,0 +1,311 @@
+# Taken from https://github.com/capless/warrant/blob/master/warrant/aws_srp.py
+import base64
+import binascii
+import datetime
+import hashlib
+import hmac
+import re
+
+import boto3
+import os
+import six
+
+
+class WarrantException(Exception):
+    """Base class for all Warrant exceptions"""
+
+
+class ForceChangePasswordException(WarrantException):
+    """Raised when the user is forced to change their password"""
+
+
+# https://github.com/aws/amazon-cognito-identity-js/blob/master/src/AuthenticationHelper.js#L22
+n_hex = (
+    "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
+    + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+    + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+    + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+    + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+    + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+    + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+    + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+    + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+    + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+    + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+    + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+    + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+    + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+    + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+    + "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF"
+)
+# https://github.com/aws/amazon-cognito-identity-js/blob/master/src/AuthenticationHelper.js#L49
+g_hex = "2"
+info_bits = bytearray("Caldera Derived Key", "utf-8")
+
+
+def hash_sha256(buf):
+    """AuthenticationHelper.hash"""
+    a = hashlib.sha256(buf).hexdigest()
+    return (64 - len(a)) * "0" + a
+
+
+def hex_hash(hex_string):
+    return hash_sha256(bytearray.fromhex(hex_string))
+
+
+def hex_to_long(hex_string):
+    return int(hex_string, 16)
+
+
+def long_to_hex(long_num):
+    return "%x" % long_num
+
+
+def get_random(nbytes):
+    random_hex = binascii.hexlify(os.urandom(nbytes))
+    return hex_to_long(random_hex)
+
+
+def pad_hex(long_int):
+    """
+    Converts a Long integer (or hex string) to hex format padded with zeroes for hashing
+    :param {Long integer|String} long_int Number or string to pad.
+    :return {String} Padded hex string.
+    """
+    if not isinstance(long_int, six.string_types):
+        hash_str = long_to_hex(long_int)
+    else:
+        hash_str = long_int
+    if len(hash_str) % 2 == 1:
+        hash_str = "0%s" % hash_str
+    elif hash_str[0] in "89ABCDEFabcdef":
+        hash_str = "00%s" % hash_str
+    return hash_str
+
+
+def compute_hkdf(ikm, salt):
+    """
+    Standard hkdf algorithm
+    :param {Buffer} ikm Input key material.
+    :param {Buffer} salt Salt value.
+    :return {Buffer} Strong key material.
+    @private
+    """
+    prk = hmac.new(salt, ikm, hashlib.sha256).digest()
+    info_bits_update = info_bits + bytearray(chr(1), "utf-8")
+    hmac_hash = hmac.new(prk, info_bits_update, hashlib.sha256).digest()
+    return hmac_hash[:16]
+
+
+def calculate_u(big_a, big_b):
+    """
+    Calculate the client's value U which is the hash of A and B
+    :param {Long integer} big_a Large A value.
+    :param {Long integer} big_b Server B value.
+    :return {Long integer} Computed U value.
+    """
+    u_hex_hash = hex_hash(pad_hex(big_a) + pad_hex(big_b))
+    return hex_to_long(u_hex_hash)
+
+
+class AWSSRP(object):
+
+    NEW_PASSWORD_REQUIRED_CHALLENGE = "NEW_PASSWORD_REQUIRED"
+    PASSWORD_VERIFIER_CHALLENGE = "PASSWORD_VERIFIER"
+
+    def __init__(
+        self,
+        username,
+        password,
+        pool_id,
+        client_id,
+        pool_region=None,
+        client=None,
+        client_secret=None,
+    ):
+        if pool_region is not None and client is not None:
+            raise ValueError(
+                "pool_region and client should not both be specified "
+                "(region should be passed to the boto3 client instead)"
+            )
+
+        self.username = username
+        self.password = password
+        self.pool_id = pool_id
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.client = (
+            client if client else boto3.client("cognito-idp", region_name=pool_region)
+        )
+        self.big_n = hex_to_long(n_hex)
+        self.g = hex_to_long(g_hex)
+        self.k = hex_to_long(hex_hash("00" + n_hex + "0" + g_hex))
+        self.small_a_value = self.generate_random_small_a()
+        self.large_a_value = self.calculate_a()
+
+    def generate_random_small_a(self):
+        """
+        helper function to generate a random big integer
+        :return {Long integer} a random value.
+        """
+        random_long_int = get_random(128)
+        return random_long_int % self.big_n
+
+    def calculate_a(self):
+        """
+        Calculate the client's public value A = g^a%N
+        with the generated random number a
+        :param {Long integer} a Randomly generated small A.
+        :return {Long integer} Computed large A.
+        """
+        big_a = pow(self.g, self.small_a_value, self.big_n)
+        # safety check
+        if (big_a % self.big_n) == 0:
+            raise ValueError("Safety check for A failed")
+        return big_a
+
+    def get_password_authentication_key(self, username, password, server_b_value, salt):
+        """
+        Calculates the final hkdf based on computed S value, and computed U value and the key
+        :param {String} username Username.
+        :param {String} password Password.
+        :param {Long integer} server_b_value Server B value.
+        :param {Long integer} salt Generated salt.
+        :return {Buffer} Computed HKDF value.
+        """
+        u_value = calculate_u(self.large_a_value, server_b_value)
+        if u_value == 0:
+            raise ValueError("U cannot be zero.")
+        username_password = "%s%s:%s" % (self.pool_id.split("_")[1], username, password)
+        username_password_hash = hash_sha256(username_password.encode("utf-8"))
+
+        x_value = hex_to_long(hex_hash(pad_hex(salt) + username_password_hash))
+        g_mod_pow_xn = pow(self.g, x_value, self.big_n)
+        int_value2 = server_b_value - self.k * g_mod_pow_xn
+        s_value = pow(int_value2, self.small_a_value + u_value * x_value, self.big_n)
+        hkdf = compute_hkdf(
+            bytearray.fromhex(pad_hex(s_value)),
+            bytearray.fromhex(pad_hex(long_to_hex(u_value))),
+        )
+        return hkdf
+
+    def get_auth_params(self):
+        auth_params = {
+            "USERNAME": self.username,
+            "SRP_A": long_to_hex(self.large_a_value),
+        }
+        if self.client_secret is not None:
+            auth_params.update(
+                {
+                    "SECRET_HASH": self.get_secret_hash(
+                        self.username, self.client_id, self.client_secret
+                    )
+                }
+            )
+        return auth_params
+
+    @staticmethod
+    def get_secret_hash(username, client_id, client_secret):
+        message = bytearray(username + client_id, "utf-8")
+        hmac_obj = hmac.new(bytearray(client_secret, "utf-8"), message, hashlib.sha256)
+        return base64.standard_b64encode(hmac_obj.digest()).decode("utf-8")
+
+    def process_challenge(self, challenge_parameters):
+        user_id_for_srp = challenge_parameters["USER_ID_FOR_SRP"]
+        salt_hex = challenge_parameters["SALT"]
+        srp_b_hex = challenge_parameters["SRP_B"]
+        secret_block_b64 = challenge_parameters["SECRET_BLOCK"]
+        # re strips leading zero from a day number (required by AWS Cognito)
+        timestamp = re.sub(
+            r" 0(\d) ",
+            r" \1 ",
+            datetime.datetime.utcnow().strftime("%a %b %d %H:%M:%S UTC %Y"),
+        )
+        hkdf = self.get_password_authentication_key(
+            user_id_for_srp, self.password, hex_to_long(srp_b_hex), salt_hex
+        )
+        secret_block_bytes = base64.standard_b64decode(secret_block_b64)
+        msg = (
+            bytearray(self.pool_id.split("_")[1], "utf-8")
+            + bytearray(user_id_for_srp, "utf-8")
+            + bytearray(secret_block_bytes)
+            + bytearray(timestamp, "utf-8")
+        )
+        hmac_obj = hmac.new(hkdf, msg, digestmod=hashlib.sha256)
+        signature_string = base64.standard_b64encode(hmac_obj.digest())
+        response = {
+            "TIMESTAMP": timestamp,
+            "USERNAME": user_id_for_srp,
+            "PASSWORD_CLAIM_SECRET_BLOCK": secret_block_b64,
+            "PASSWORD_CLAIM_SIGNATURE": signature_string.decode("utf-8"),
+        }
+        if self.client_secret is not None:
+            response.update(
+                {
+                    "SECRET_HASH": self.get_secret_hash(
+                        self.username, self.client_id, self.client_secret
+                    )
+                }
+            )
+        return response
+
+    def authenticate_user(self, client=None):
+        boto_client = self.client or client
+        auth_params = self.get_auth_params()
+        response = boto_client.initiate_auth(
+            AuthFlow="USER_SRP_AUTH",
+            AuthParameters=auth_params,
+            ClientId=self.client_id,
+        )
+        if response["ChallengeName"] == self.PASSWORD_VERIFIER_CHALLENGE:
+            challenge_response = self.process_challenge(response["ChallengeParameters"])
+            tokens = boto_client.respond_to_auth_challenge(
+                ClientId=self.client_id,
+                ChallengeName=self.PASSWORD_VERIFIER_CHALLENGE,
+                ChallengeResponses=challenge_response,
+            )
+
+            if tokens.get("ChallengeName") == self.NEW_PASSWORD_REQUIRED_CHALLENGE:
+                raise ForceChangePasswordException(
+                    "Change password before authenticating"
+                )
+
+            return tokens
+        else:
+            raise NotImplementedError(
+                "The %s challenge is not supported" % response["ChallengeName"]
+            )
+
+    def set_new_password_challenge(self, new_password, client=None):
+        boto_client = self.client or client
+        auth_params = self.get_auth_params()
+        response = boto_client.initiate_auth(
+            AuthFlow="USER_SRP_AUTH",
+            AuthParameters=auth_params,
+            ClientId=self.client_id,
+        )
+        if response["ChallengeName"] == self.PASSWORD_VERIFIER_CHALLENGE:
+            challenge_response = self.process_challenge(response["ChallengeParameters"])
+            tokens = boto_client.respond_to_auth_challenge(
+                ClientId=self.client_id,
+                ChallengeName=self.PASSWORD_VERIFIER_CHALLENGE,
+                ChallengeResponses=challenge_response,
+            )
+
+            if tokens["ChallengeName"] == self.NEW_PASSWORD_REQUIRED_CHALLENGE:
+                challenge_response = {
+                    "USERNAME": auth_params["USERNAME"],
+                    "NEW_PASSWORD": new_password,
+                }
+                new_password_response = boto_client.respond_to_auth_challenge(
+                    ClientId=self.client_id,
+                    ChallengeName=self.NEW_PASSWORD_REQUIRED_CHALLENGE,
+                    Session=tokens["Session"],
+                    ChallengeResponses=challenge_response,
+                )
+                return new_password_response
+            return tokens
+        else:
+            raise NotImplementedError(
+                "The %s challenge is not supported" % response["ChallengeName"]
+            )

homelink_integration_api-0.0.1/src/homelink/auth/srp_auth.py

@@ -0,0 +1,30 @@
+import boto3
+from homelink.auth.aws_srp import AWSSRP
+from homelink.auth.abstract_auth import AbstractAuth
+from homelink.settings import COGNITO_POOL_ID, COGNITO_CLIENT_ID
+import hmac
+import hashlib
+import base64
+
+
+# Function used to calculate SecretHash value for a given client
+def calculateSecretHash(client_id, client_secret, username):
+    key = bytes(client_secret, "utf-8")
+    message = bytes(f"{username}{client_id}", "utf-8")
+    return base64.b64encode(
+        hmac.new(key, message, digestmod=hashlib.sha256).digest()
+    ).decode()
+
+
+class SRPAuth:
+
+    def async_get_access_token(self, username, password):
+        client = boto3.client("cognito-idp", region_name="us-east-2")
+        aws = AWSSRP(
+            username=username,
+            password=password,
+            pool_id=COGNITO_POOL_ID,
+            client_id=COGNITO_CLIENT_ID,
+            client=client,
+        )
+        return aws.authenticate_user()

homelink_integration_api-0.0.1/src/homelink/model/button.py

@@ -0,0 +1,5 @@
+class Button:
+    def __init__(self, id, name, device):
+        self.id = id
+        self.name = name
+        self.device = device

homelink_integration_api-0.0.1/src/homelink/model/device.py

@@ -0,0 +1,9 @@
+from homelink.model.button import Button
+
+
+class Device:
+
+    def __init__(self, id, name):
+        self.id = id
+        self.name = name
+        self.buttons = []

homelink_integration_api-0.0.1/src/homelink/mqtt_provider.py

@@ -0,0 +1,142 @@
+import logging
+
+from homelink.model.button import Button
+from homelink.model.device import Device
+from homelink.settings import DISCOVER_URL, ENABLE_URL, MQTT_IOT_ENDPOINT, MQTT_IOT_PORT
+
+import paho.mqtt.client as mqtt
+import homelink.mqtt_util as mqtt_util
+import ssl
+import json
+import tempfile
+import os
+import aiofiles
+import asyncio
+
+
+class MQTTProvider:
+    def __init__(self, authorized_session):
+        self.authorized_session = authorized_session
+        self.mqtt_client = None
+        self.listeners = []
+
+    async def discover(self):
+        resp = await self.authorized_session.request(
+            "POST",
+            DISCOVER_URL,
+            json={"command": "DISCOVER"},
+        )
+        device_data = await resp.json()
+        logging.info(device_data)
+        devices = []
+
+        for raw_device in device_data["data"]["devices"]:
+            d = Device(raw_device["id"], raw_device["name"])
+            for raw_button in raw_device["buttons"]:
+                d.buttons.append(Button(raw_button["id"], raw_button["name"], d))
+            devices.append(d)
+
+        return devices
+
+    async def enable(self, sslContext=None):
+        asyncio_loop = asyncio.get_running_loop()
+        pkey, csr = await mqtt_util.generate_csr()
+        _, pk_file_path = tempfile.mkstemp()
+        async with aiofiles.open(pk_file_path, "wb") as f:
+            await f.write(pkey)
+        enable_resp = await self.authorized_session.request(
+            "POST",
+            ENABLE_URL,
+            json={"command": "ENABLE", "data": {"csr": csr}},
+        )
+
+        resp_json = await enable_resp.json()
+        f, cert_file_path = tempfile.mkstemp(text=True)
+        async with aiofiles.open(cert_file_path, "w") as f:
+            await f.write(resp_json["data"]["certificatePem"])
+
+        topic = None
+        topics = []
+        try:
+            topic = resp_json["data"]["topic"]
+        except KeyError:
+            pass
+
+        try:
+            topics = resp_json["data"]["topics"]
+        except KeyError:
+            pass
+
+        self.mqtt_client = mqtt.Client(client_id="TODO", protocol=mqtt.MQTTv5)
+        self.mqtt_client.user_data_set(
+            {"topics": list(dict.fromkeys(topics, topic)), "listeners": self.listeners}
+        )
+
+        if sslContext:
+            await asyncio_loop.run_in_executor(
+                None, sslContext.load_cert_chain, cert_file_path, pk_file_path, None
+            )
+            await asyncio_loop.run_in_executor(
+                None, sslContext.load_verify_locations, cert_file_path
+            )
+            self.mqtt_client.tls_set_context(sslContext)
+        else:
+            self.mqtt_client.tls_set(
+                certfile=cert_file_path,
+                keyfile=pk_file_path,
+                cert_reqs=ssl.CERT_REQUIRED,
+                tls_version=ssl.PROTOCOL_TLSv1_2,
+                ciphers=None,
+            )
+        self.mqtt_client.on_connect = self._on_connect
+        self.mqtt_client.on_message = self._on_message
+        self.mqtt_client.on_connect_fail = self._on_connect_fail
+        self.mqtt_client.on_disconnect = self._on_disconnect
+
+        self.mqtt_client.connect(MQTT_IOT_ENDPOINT, MQTT_IOT_PORT, keepalive=60)
+        self.mqtt_client.loop_start()
+
+        os.remove(cert_file_path)
+        os.remove(pk_file_path)
+
+        return resp_json
+
+    async def disable(self):
+        self.mqtt_client.loop_stop()
+        self.mqtt_client.disconnect()
+        enable_resp = await self.authorized_session.request(
+            "POST", ENABLE_URL, json={"command": "DISABLE"}
+        )
+        return await enable_resp.json()
+
+    def listen(self, cb):
+        self.listeners.append(cb)
+
+    def _on_connect(self, client, userdata, flags, rc, properties=None):
+        if rc == 0:
+            for topic in userdata["topics"]:
+                client.subscribe(topic, qos=1)
+        else:
+            raise ConnectionError("Failed to connect")
+
+    def _on_message(self, client, userdata, msg):
+        res = {}
+        json_msg = json.loads(msg.payload.decode("utf-8"))
+        if "state" in json_msg:
+            res = {"type": "state", "data": json_msg["state"]}
+        elif "requestSync" in json_msg:
+            res = {"type": "requestSync", "data": json_msg["requestSync"]}
+        else:
+            raise ConnectionError("Unidentified message type recieved")
+        for listener in userdata["listeners"]:
+            listener(msg.topic, res)
+
+    def _on_connect_fail(self, client, userdata):
+        res = {"type": "connect_fail", "data": {}}
+        for listener in userdata["listeners"]:
+            listener("connect_fail", res)
+
+    def _on_disconnect(self, client, userdata, reason_code, properties):
+        res = {"type": "disconnect", "data": {"code": reason_code}}
+        for listener in userdata["listeners"]:
+            listener("disconnect", res)

homelink_integration_api-0.0.1/src/homelink/mqtt_util.py

@@ -0,0 +1,45 @@
+from OpenSSL import crypto
+import re
+from homelink.settings import (
+    MQTT_ROOT_CA,
+    MQTT_ROOT_CA_REPOSITORY,
+    MQTT_PRIVATE_KEY_SIZE,
+)
+from aiohttp import ClientTimeout, request
+
+
+def format_csr(csr_pem):
+    return (
+        re.search(
+            r"-+BEGIN CERTIFICATE REQUEST-+\s+(.*?)\s+-+END CERTIFICATE REQUEST-+",
+            csr_pem,
+            flags=re.DOTALL,
+        )
+        .group(1)
+        .strip()
+        .replace("\n", "")
+    )
+
+
+async def generate_csr():
+    url = f"{MQTT_ROOT_CA_REPOSITORY}/{MQTT_ROOT_CA}"
+    client_timeout = ClientTimeout(total=60)
+    async with request("GET", url=url, timeout=client_timeout) as response:
+        cert_data = await response.text()
+        if response.status != 200 or "error" in cert_data:
+            raise Exception("Failed to get root certificate")
+    key = crypto.PKey()
+    key.generate_key(crypto.TYPE_RSA, MQTT_PRIVATE_KEY_SIZE)
+    key_pem = crypto.dump_privatekey(crypto.FILETYPE_PEM, key).decode("utf-8")
+    bytes_private_key = key_pem.encode("utf-8")
+
+    csr = crypto.X509Req()
+    csr.get_subject().CN = "gentex"
+    csr.set_pubkey(key)
+    csr.sign(key, "sha512")
+
+    csr_pem = crypto.dump_certificate_request(crypto.FILETYPE_PEM, csr).decode(
+        encoding="utf-8"
+    )
+
+    return bytes_private_key, format_csr(csr_pem)

homelink_integration_api-0.0.1/src/homelink/provider.py

@@ -0,0 +1,52 @@
+import json
+import logging
+
+from homelink.auth.abstract_auth import AbstractAuth
+from homelink.model.button import Button
+from homelink.model.device import Device
+from homelink.settings import DISCOVER_URL, STATE_URL, ENABLE_URL
+
+
+class Provider:
+    def __init__(self, authorized_session):
+        self.authorized_session = authorized_session
+
+    async def discover(self):
+        resp = await self.authorized_session.request(
+            "POST",
+            DISCOVER_URL,
+            json={"command": "DISCOVER"},
+        )
+        device_data = await resp.json()
+        logging.info(device_data)
+        devices = []
+
+        for raw_device in device_data["data"]["devices"]:
+            d = Device(raw_device["id"], raw_device["name"])
+            for raw_button in raw_device["buttons"]:
+                d.buttons.append(Button(raw_button["id"], raw_button["name"], d))
+            devices.append(d)
+
+        return devices
+
+    async def enable(self):
+        enable_resp = await self.authorized_session.request(
+            "POST",
+            ENABLE_URL,
+            json={"command": "ENABLE"},
+        )
+        return await enable_resp.json()
+
+    async def get_state(self):
+        resp = await self.authorized_session.request("GET", STATE_URL)
+        resp_data = await resp.json()
+        if "data" not in resp_data or resp_data["data"] is None:
+            return None, {}
+
+        if "requestSync" in resp_data["data"]:
+            should_sync = resp_data["data"]["requestSync"]
+        else:
+            should_sync = None
+        return should_sync, (
+            resp_data["data"]["state"] if "state" in resp_data["data"] else {}
+        )

homelink_integration_api-0.0.1/src/homelink/samples/mqtt_sample.py

@@ -0,0 +1,42 @@
+from homelink.auth.abstract_auth import AbstractAuth
+from homelink.auth.srp_auth import SRPAuth
+from homelink.mqtt_provider import MQTTProvider
+import asyncio
+from aiohttp import ClientSession
+
+
+USERNAME = ""
+PASSWORD = ""
+
+
+class AuthorizedSession(AbstractAuth):
+
+    def __init__(self, session, srp_auth):
+        super().__init__(session)
+        self.srp_auth = srp_auth
+
+    async def async_get_access_token(self):
+        tokens = self.srp_auth.async_get_access_token(USERNAME, PASSWORD)
+        return tokens["AuthenticationResult"]["AccessToken"]
+
+
+def on_message(topic, message):
+    print(topic, message)
+
+
+async def main():
+    async with ClientSession() as client:
+        srp_auth = SRPAuth()
+        auth_session = AuthorizedSession(client, srp_auth)
+        provider = MQTTProvider(auth_session)
+
+        provider.listen(on_message)
+        print(await provider.enable())
+        print(await provider.discover())
+
+        while True:
+            pass
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

homelink_integration_api-0.0.1/src/homelink/settings.py

@@ -0,0 +1,25 @@
+from decouple import config
+
+HOST_URL = config("HOMELINK_HOST_URL", default="homelinkcloud.com")
+PLATFORM = config("HOMELINK_SMART_HOME_PLATFORM", default="home-assistant")
+DISCOVER_URL = config(
+    "HOMELINK_DISCOVER_URL",
+    default=f"https://{HOST_URL}/services/v2/{PLATFORM}/fulfillment",
+)
+ENABLE_URL = config(
+    "HOMELINK_ENABLE_URL",
+    default=f"https://{HOST_URL}/services/v2/{PLATFORM}/fulfillment",
+)
+STATE_URL = config(
+    "HOMELINK_STATE_URL", default=f"https://state.{HOST_URL}/services/v2/{PLATFORM}"
+)
+
+COGNITO_POOL_ID = config("COGNITO_POOL_ID", default="us-east-2_sBYr2OD1J")
+COGNITO_CLIENT_ID = config("COGNITO_CLIENT_ID", default="701cln3h6bgqfldh61rcf21ko0")
+MQTT_ROOT_CA = config("MQTT_ROOT_CA", "AmazonRootCA1.pem")
+MQTT_ROOT_CA_REPOSITORY = config(
+    "MQTT_ROOT_CA_REPOSITORY", "https://www.amazontrust.com/repository"
+)
+MQTT_PRIVATE_KEY_SIZE = config("MQTT_PRIVATE_KEY_SIZE", 2048)
+MQTT_IOT_ENDPOINT = config("MQTT_IOT_ENDPOINT", "iot.homelinkcloud.com")
+MQTT_IOT_PORT = config("MQTT_IOT_PORT", 8883)

homelink_integration_api-0.0.1/src/homelink_integration_api.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: homelink-integration-api
+Version: 0.0.1
+Summary: API to interact with Homelink cloud for MQTT-enabled smart home platforms
+Author-email: Nicholas Aelick <niaexa@syntronic.com>, Ryan Jones <ryan.jones@gentex.com>, Evgeniy Burbyga <evbuxa@syntronic.com>
+Project-URL: Homepage, https://www.homelink.com/
+Project-URL: Issues, https://www.homelink.com/support
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-decouple>=3.8
+Requires-Dist: boto3
+Dynamic: license-file
+
+# HomeLink smart home integration API
+
+This project contains a python API to connect MQTT-enabled smart home platforms to HomeLink smarthome cloud
+
+## Setup
+
+This repo utilizes VS Code [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) so you don't need to alter your global python environment.
+
+## Installing dependencies
+
+Use `pip` to install required dependencies by running `pip install -r requirements.txt` from the project root.
+
+## Updating dependencies
+
+During the course of development, if new packages are added, it's recommended to update [`requirements.txt`](./requirements.txt) by running `pip freeze > requirements.txt`.

homelink_integration_api-0.0.1/src/homelink_integration_api.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/homelink/__init__.py
+src/homelink/mqtt_provider.py
+src/homelink/mqtt_util.py
+src/homelink/provider.py
+src/homelink/settings.py
+src/homelink/auth/abstract_auth.py
+src/homelink/auth/aws_srp.py
+src/homelink/auth/srp_auth.py
+src/homelink/model/__init__.py
+src/homelink/model/button.py
+src/homelink/model/device.py
+src/homelink/samples/__init__.py
+src/homelink/samples/mqtt_sample.py
+src/homelink_integration_api.egg-info/PKG-INFO
+src/homelink_integration_api.egg-info/SOURCES.txt
+src/homelink_integration_api.egg-info/dependency_links.txt
+src/homelink_integration_api.egg-info/requires.txt
+src/homelink_integration_api.egg-info/top_level.txt
+tests/test_provider.py

homelink_integration_api-0.0.1/src/homelink_integration_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

homelink_integration_api-0.0.1/src/homelink_integration_api.egg-info/requires.txt

@@ -0,0 +1,2 @@
+python-decouple>=3.8
+boto3

homelink_integration_api-0.0.1/src/homelink_integration_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+homelink

homelink_integration_api-0.0.1/tests/test_provider.py

@@ -0,0 +1,52 @@
+import pytest
+import json
+from .auth_mock import AuthMock
+from homelink.provider import Provider
+from homelink.settings import DISCOVER_URL, ENABLE_URL, STATE_URL
+
+
+@pytest.fixture
+def authorized_provider():
+    with (
+        open("tests/fixtures/discover_post.json") as discover_post_json,
+        open("tests/fixtures/enable_post.json") as enable_post_json,
+        open("tests/fixtures/state_get.json") as state_get_json,
+    ):
+        auth = AuthMock(
+            {
+                DISCOVER_URL: {
+                    "POST": {
+                        "DISCOVER": json.load(discover_post_json),
+                        "ENABLE": json.load(enable_post_json),
+                    }
+                },
+                STATE_URL: {"GET": json.load(state_get_json)},
+            }
+        )
+    provider = Provider(auth)
+    return provider
+
+
+@pytest.mark.asyncio
+async def test_discover(authorized_provider):
+    devices = await authorized_provider.discover()
+    assert len(devices) == 1
+    assert devices[0].name == "PhiDevice"
+    assert len(devices[0].buttons) == 3
+    assert [b.name for b in devices[0].buttons] == ["Button 1", "Button 2", "Button 3"]
+
+
+@pytest.mark.asyncio
+async def test_enable(authorized_provider):
+    enable_data = await authorized_provider.enable()
+    assert enable_data["success"] == True
+
+
+@pytest.mark.asyncio
+async def test_get_state(authorized_provider):
+    request_sync, state = await authorized_provider.get_state()
+    assert request_sync
+    assert request_sync["requestId"]
+    assert request_sync["timestamp"]
+    assert state
+    assert state["9084ba1f-5f4c-4ccf-a168-13aabefc32a4"]