Partner MQTT Integration Guide

const mqtt = require('mqtt');

const client = mqtt.connect('mqtts://mqtt.cpi.lovinka.com', {
  port: 8885,
  username: deviceId,
  password: mqttToken,
  protocol: 'mqtts',
  rejectUnauthorized: true,
  clean: true,
  keepalive: 60,
  clientId: deviceId,
  reconnectPeriod: 5000,
});

import paho.mqtt.client as mqtt
import ssl

client = mqtt.Client(client_id=device_id, protocol=mqtt.MQTTv311)
client.username_pw_set(username=device_id, password=mqtt_token)
client.tls_set(cert_reqs=ssl.CERT_REQUIRED, tls_version=ssl.PROTOCOL_TLSv1_2)

client.connect("mqtt.cpi.lovinka.com", port=8885, keepalive=60)
client.loop_start()

struct mosquitto *mosq = mosquitto_new(device_id, true, NULL);
mosquitto_username_pw_set(mosq, device_id, mqtt_token);
mosquitto_tls_set(mosq, NULL, NULL, NULL, NULL, NULL);
mosquitto_tls_opts_set(mosq, 1, "tlsv1.2", NULL);

mosquitto_connect(mosq, "mqtt.cpi.lovinka.com", 8885, 60);
mosquitto_loop_start(mosq);

function verifyCommandSignature(deviceId, cmd, secret) {
  const msg = `${deviceId}|${cmd.cmdId}|${cmd.ts}|${cmd.action}|${JSON.stringify(cmd.payload)}`;
  const expected = crypto.createHmac('sha256', secret).update(msg).digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(expected, 'hex'),
    Buffer.from(cmd.sig, 'hex')
  );
}

def verify_command(device_id: str, cmd: dict, secret: str) -> bool:
    msg = f"{device_id}|{cmd['cmdId']}|{cmd['ts']}|{cmd['action']}|{json.dumps(cmd['payload'], separators=(',', ':'))}"
    expected = hmac.new(secret.encode(), msg.encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, cmd['sig'])

int verify_command(const char *device_id, const char *cmd_id,
                   long long ts, const char *action,
                   const char *payload_json, const char *sig,
                   const char *secret) {
    char message[4096], expected[65];
    snprintf(message, sizeof(message), "%s|%s|%lld|%s|%s",
             device_id, cmd_id, ts, action, payload_json);
    hmac_sign(secret, message, expected, 65);
    return CRYPTO_memcmp(expected, sig, 64) == 0;
}

const crypto = require('crypto');

function signTelemetry(deviceId, ts, nonce, data, secret) {
  const msg = `${deviceId}|${ts}|${nonce}|${JSON.stringify(data)}`;
  return crypto.createHmac('sha256', secret).update(msg).digest('hex');
}

function signAck(deviceId, cmdId, ts, status, secret) {
  const msg = `${deviceId}|${cmdId}|${ts}|${status}`;
  return crypto.createHmac('sha256', secret).update(msg).digest('hex');
}

function signStatus(deviceId, ts, nonce, status, secret) {
  const msg = `${deviceId}|${ts}|${nonce}|${JSON.stringify({ status })}`;
  return crypto.createHmac('sha256', secret).update(msg).digest('hex');
}

import hmac, hashlib, json

def sign_telemetry(device_id, ts, nonce, data, secret):
    msg = f"{device_id}|{ts}|{nonce}|{json.dumps(data, separators=(',', ':'))}"
    return hmac.new(secret.encode(), msg.encode(), hashlib.sha256).hexdigest()

def sign_ack(device_id, cmd_id, ts, status, secret):
    msg = f"{device_id}|{cmd_id}|{ts}|{status}"
    return hmac.new(secret.encode(), msg.encode(), hashlib.sha256).hexdigest()

def sign_status(device_id, ts, nonce, status, secret):
    status_json = json.dumps({"status": status}, separators=(',', ':'))
    msg = f"{device_id}|{ts}|{nonce}|{status_json}"
    return hmac.new(secret.encode(), msg.encode(), hashlib.sha256).hexdigest()

#include <openssl/hmac.h>
#include <stdio.h>
#include <string.h>

int hmac_sign(const char *secret, const char *message,
              char *out, size_t out_len) {
    unsigned char digest[EVP_MAX_MD_SIZE];
    unsigned int digest_len = 0;

    HMAC(EVP_sha256(), secret, (int)strlen(secret),
         (const unsigned char *)message, strlen(message),
         digest, &digest_len);

    if (out_len < digest_len * 2 + 1) return -1;

    for (unsigned int i = 0; i < digest_len; i++)
        snprintf(out + i * 2, 3, "%02x", digest[i]);
    out[digest_len * 2] = '\0';
    return 0;
}

int sign_telemetry(const char *device_id, long long ts,
                   const char *nonce, const char *data_json,
                   const char *secret, char *sig_out) {
    char message[4096];
    snprintf(message, sizeof(message), "%s|%lld|%s|%s",
             device_id, ts, nonce, data_json);
    return hmac_sign(secret, message, sig_out, 65);
}

int sign_ack(const char *device_id, const char *cmd_id,
             long long ts, const char *status,
             const char *secret, char *sig_out) {
    char message[1024];
    snprintf(message, sizeof(message), "%s|%s|%lld|%s",
             device_id, cmd_id, ts, status);
    return hmac_sign(secret, message, sig_out, 65);
}

int sign_status(const char *device_id, long long ts,
                const char *nonce, const char *status,
                const char *secret, char *sig_out) {
    char message[4096];
    snprintf(message, sizeof(message),
             "%s|%lld|%s|{\"status\":\"%s\"}",
             device_id, ts, nonce, status);
    return hmac_sign(secret, message, sig_out, 65);
}