homebridge-roborock-vacuum 0.1.0

package/roborockLib/lib/message.js

@@ -0,0 +1,223 @@
+"use strict";
+
+const crypto = require("crypto");
+const CRC32 = require("crc-32");
+const Parser = require("binary-parser").Parser;
+const forge = require("node-forge");
+
+let seq = 1;
+let random = 4711; // Should be initialized with a number 0 - 1999?
+
+// This value is stored hardcoded in librrcodec.so, encrypted by the value of "com.roborock.iotsdk.appsecret" from AndroidManifest.xml.
+const salt = "TXdfu$jyZ#TZHsg4";
+
+const messageParser = new Parser()
+	.endianess("big")
+	.string("version", {
+		length: 3,
+	})
+	.uint32("seq")
+	.uint32("random")
+	.uint32("timestamp")
+	.uint16("protocol")
+	.uint16("payloadLen")
+	.buffer("payload", {
+		length: "payloadLen",
+	})
+	.uint32("crc32");
+
+class message {
+	constructor(adapter) {
+		this.adapter = adapter;
+
+		const keypair = forge.pki.rsa.generateKeyPair(2048);
+		this.keys = {
+			public: { n: null, e: null },
+			private: {
+				n: null,
+				e: null,
+				d: null,
+				p: null,
+				q: null,
+				dmp1: null,
+				dmq1: null,
+				coeff: null,
+			},
+		};
+
+		// Convert the keys to the desired format
+		this.keys.public.n = keypair.publicKey.n.toString(16);
+		this.keys.public.e = keypair.publicKey.e.toString(16);
+		this.keys.private.n = keypair.privateKey.n.toString(16);
+		this.keys.private.e = keypair.privateKey.e.toString(16);
+		this.keys.private.d = keypair.privateKey.d.toString(16);
+		this.keys.private.p = keypair.privateKey.p.toString(16);
+		this.keys.private.q = keypair.privateKey.q.toString(16);
+		this.keys.private.dmp1 = keypair.privateKey.dP.toString(16);
+		this.keys.private.dmq1 = keypair.privateKey.dQ.toString(16);
+		this.keys.private.coeff = keypair.privateKey.qInv.toString(16);
+	}
+
+	buildPayload(protocol, messageID, method, params, secure = false, photo = false) {
+		const timestamp = Math.floor(Date.now() / 1000);
+		const endpoint = this.adapter.rr_mqtt_connector.getEndpoint();
+		// this.adapter.log.debug("sendRequest started with: " + requestId);
+
+		if (photo) {
+			params.endpoint = endpoint;
+			params.security = {
+				cipher_suite: 0,
+				pub_key: this.keys.public,
+			};
+		}
+
+		const inner = {
+			id: messageID,
+			method: method,
+			params: params,
+		};
+		if (secure) {
+			if (!photo) {
+				inner.security = {
+					endpoint: endpoint,
+					nonce: this.adapter.nonce.toString("hex").toUpperCase(),
+				};
+			}
+		}
+
+		const payload = JSON.stringify({
+			dps: {
+				[protocol]: JSON.stringify(inner),
+			},
+			t: timestamp,
+		});
+
+		return payload;
+	}
+
+	async buildRoborockMessage(duid, protocol, timestamp, payload) {
+		const version = await this.adapter.getRobotVersion(duid);
+
+		let encrypted;
+
+		if (version == "1.0") {
+			const localKey = this.adapter.localKeys.get(duid);
+			const aesKey = this.md5bin(this._encodeTimestamp(timestamp) + localKey + salt);
+			const cipher = crypto.createCipheriv("aes-128-ecb", aesKey, null);
+			encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+
+		}
+		else if (version == "A01") {
+			const localKey = this.adapter.localKeys.get(duid);
+
+			const iv = this.md5hex(payload.random.toString(16).padStart(8, "0") + "726f626f726f636b2d67a6d6da").substring(8, 24); // 726f626f726f636b2d67a6d6da can be found in librrcodec.so of version 4.0 of the roborock app
+			const cipher = crypto.createCipheriv("aes-128-cbc", localKey, iv);
+			encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+		}
+
+		if (encrypted) {
+			const msg = Buffer.alloc(23 + encrypted.length);
+			msg.write(version);
+			msg.writeUint32BE(seq++ & 0xffffffff, 3);
+			msg.writeUint32BE(random++ & 0xffffffff, 7);
+			msg.writeUint32BE(timestamp, 11);
+			msg.writeUint16BE(protocol, 15);
+			msg.writeUint16BE(encrypted.length, 17);
+			encrypted.copy(msg, 19);
+			const crc32 = CRC32.buf(msg.subarray(0, msg.length - 4)) >>> 0;
+			msg.writeUint32BE(crc32, msg.length - 4);
+
+			return msg;
+		}
+
+		return false;
+	}
+
+	_decodeMsg(message, duid) {
+		try {
+			// Do some checks before trying to decode the message.
+			const version = message.toString("latin1", 0, 3);
+
+			if (version !== "1.0" && version !== "A01") {
+				this.adapter.log.error(`_decodeMsg error: ${message.toString("latin1", 0, 3)}`);
+				// throw new Error(`Unknown protocol version ${msg} localKey: ${localKey}`);
+			}
+			const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
+			const expectedCrc32 = message.readUint32BE(message.length - 4);
+			if (crc32 != expectedCrc32) {
+				throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
+			}
+
+			const data = this.getParsedData(message);
+			delete data.payloadLen;
+
+			const localKey = this.adapter.localKeys.get(duid);
+			if(version == "1.0") {
+				const aesKey = this.md5bin(this._encodeTimestamp(data.timestamp) + localKey + salt);
+				const decipher = crypto.createDecipheriv("aes-128-ecb", aesKey, null);
+				data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+			}
+			else if  (version == "A01") {
+				const iv = this.md5hex(data.random.toString(16).padStart(8, "0") + "726f626f726f636b2d67a6d6da").substring(8, 24);
+				const decipher = crypto.createDecipheriv("aes-128-cbc", localKey, iv);
+				data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+			}
+
+			return data;
+		} catch (error) {
+			this.adapter.log.error(`failed to _decodeMsg: ${error} local binary data: ${message.toString("hex")}`, null, duid);
+			// this.adapter.catchError(error, "_decodeMessage", "none");
+		}
+	}
+
+	getParsedData(data) {
+		return messageParser.parse(data);
+	}
+
+	resolve102Message(messageID, message, secure = false) {
+		return new Promise((resolve, reject) => {
+			if (message?.code) {
+				reject(new Error(`There was an error processing the request with id ${messageID} error: ${JSON.stringify(message)}`));
+			} else {
+				if (secure) {
+					if (message[0] !== "ok") {
+						reject(message);
+					}
+				} else {
+					resolve(message);
+				}
+			}
+		});
+	}
+
+	resolve301Message(messageID, message) {
+		return new Promise((resolve, reject) => {
+			this.adapter.clearTimeout(this.adapter.messageQueue.get(messageID)?.timeout301);
+			(this.adapter.messageQueue.get(messageID) || {}).timeout301 = null;
+			this.adapter.checkAndClearRequest(messageID);
+
+			if (message?.code) {
+				reject(new Error(`There was an error processing the request with id ${messageID} error: ${JSON.stringify(message)}`));
+			} else {
+				resolve(message);
+			}
+		});
+	}
+
+	_encodeTimestamp(timestamp) {
+		const hex = timestamp.toString(16).padStart(8, "0").split("");
+		return [5, 6, 3, 7, 1, 2, 0, 4].map((idx) => hex[idx]).join("");
+	}
+
+	md5bin(str) {
+		return crypto.createHash("md5").update(str).digest();
+	}
+
+	md5hex(str) {
+		return crypto.createHash("md5").update(str).digest("hex");
+	}
+}
+
+module.exports = {
+	message,
+};

package/roborockLib/lib/messageQueueHandler.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const requestTimeout = 10000; // 10s
+
+class messageQueueHandler {
+	constructor(adapter) {
+		this.adapter = adapter;
+	}
+
+	async sendRequest(duid, method, params, secure = false, photo = false) {
+		const remoteConnection = await this.adapter.isRemoteDevice(duid);
+
+		let messageID = this.adapter.getRequestId();
+		if (photo) messageID = messageID % 256; // this is a special case. Otherwise photo requests will not have the correct ID in the response.
+		const timestamp = Math.floor(Date.now() / 1000);
+
+		let protocol;
+		if (remoteConnection || secure || photo || method == "get_network_info") {
+			protocol = 101;
+		} else {
+			protocol = 4;
+		}
+		const payload = this.adapter.message.buildPayload(protocol, messageID, method, params, secure, photo);
+		const roborockMessage = await this.adapter.message.buildRoborockMessage(duid, protocol, timestamp, payload);
+
+		const deviceOnline = await this.adapter.onlineChecker(duid);
+		const mqttConnectionState = this.adapter.rr_mqtt_connector.isConnected();
+		const localConnectionState = this.adapter.localConnector.isConnected(duid);
+
+		if (roborockMessage) {
+			return new Promise((resolve, reject) => {
+				if (!deviceOnline) {
+					this.adapter.pendingRequests.delete(messageID);
+					this.adapter.log.debug(`Device ${duid} offline. Not sending for method ${method} request!`);
+					reject();
+				}
+				else if (!mqttConnectionState && remoteConnection) {
+					this.adapter.pendingRequests.delete(messageID);
+					this.adapter.log.debug(`Cloud connection not available. Not sending for method ${method} request!`);
+					reject();
+				}
+				else if (!localConnectionState && !remoteConnection) {
+					this.adapter.pendingRequests.delete(messageID);
+					this.adapter.log.debug(`Adapter not connect locally to robot ${duid}. Not sending for method ${method} request!`);
+					reject();
+				} else {
+					// setup Timeout
+					const timeout = this.adapter.setTimeout(() => {
+						this.adapter.pendingRequests.delete(messageID);
+						this.adapter.localConnector.clearChunkBuffer(duid);
+						if (remoteConnection) {
+							reject(new Error(`Cloud request with id ${messageID} with method ${method} timed out after 10 seconds. MQTT connection state: ${mqttConnectionState}`));
+						} else {
+							reject(new Error(`Local request with id ${messageID} with method ${method} timed out after 10 seconds Local connect state: ${localConnectionState}`));
+						}
+					}, requestTimeout);
+
+					// Store request with resolve and reject functions
+					this.adapter.pendingRequests.set(messageID, { resolve, reject, timeout });
+
+					if (remoteConnection || secure || photo || method == "get_network_info") {
+						this.adapter.rr_mqtt_connector.sendMessage(duid, roborockMessage);
+						this.adapter.log.debug(`Sent payload for ${duid} with ${payload} using cloud connection`);
+						//client.publish(`rr/m/i/${rriot.u}/${mqttUser}/${duid}`, roborockMessage, { qos: 1 });
+						// this.adapter.log.debug(`Promise for messageID ${messageID} created. ${this.adapter.message._decodeMsg(roborockMessage, duid).payload}`);
+					} else {
+						const lengthBuffer = Buffer.alloc(4);
+						lengthBuffer.writeUInt32BE(roborockMessage.length, 0);
+
+						const fullMessage = Buffer.concat([lengthBuffer, roborockMessage]);
+						this.adapter.localConnector.sendMessage(duid, fullMessage);
+						// this.adapter.log.debug(`sent fullMessage: ${fullMessage.toString("hex")}`);
+						this.adapter.log.debug(`Sent payload for ${duid} with ${payload} using local connection`);
+					}
+				}
+			}).finally(() => {
+				this.adapter.log.debug(`Size of message queue: ${this.adapter.pendingRequests.size}`);
+			});
+		} else {
+			this.adapter.catchError("Failed to build buildRoborockMessage!", "function sendRequest", duid);
+		}
+	}
+}
+
+module.exports = {
+	messageQueueHandler,
+};

package/roborockLib/lib/roborockPackageHelper.js

@@ -0,0 +1,116 @@
+const fs = require("fs");
+const JSZip = require("jszip");
+
+class roborockPackageHelper {
+	constructor(adapter) {
+		this.adapter = adapter;
+	}
+
+	async updateProduct(loginApi, productID, duid) {
+		const products = await loginApi.get("api/v3/product");
+		const list = products.data.data.categoryDetailList;
+
+		let appPluginRequest = {};
+		appPluginRequest = {
+			apilevel: 99999, // sniffed 10016 and 10019 from the app but it's subject to change so we use a high number
+			productids: [],
+			type: 2,
+		};
+
+		const vacuumIDs = {};
+		for (const array in list) {
+			for (const product in list[array]["productList"]) {
+				const vacuum = list[array]["productList"][product];
+				const productIDinPackage = this.findProductIDinPackage(productID, vacuum);
+
+				if (productIDinPackage) {
+					appPluginRequest.productids.push(vacuum.id);
+					vacuumIDs[vacuum.id] = vacuum.model;
+				}
+			}
+		}
+
+		const packageData = await loginApi.post("api/v1/appplugin", appPluginRequest);
+
+		const packages = packageData.data.data;
+		for (const rr_package in packages) {
+			const vacuum = vacuumIDs[packages[rr_package].productid];
+			const zipUrl = packages[rr_package].url;
+			const version = packages[rr_package].version;
+			const imagePath = `./images/products/${vacuum}`;
+			const objectPath = `Devices.${duid}.images`;
+			const versionFilePath = imagePath + "/version";
+
+			if (!fs.existsSync("./lib/roborockPackage/")) fs.mkdirSync("./lib/roborockPackage/");
+
+			try {
+				// Create missing vacuum folders
+				if (!fs.existsSync(`./images/products/`)) fs.mkdirSync(`./images/products/`);
+				if (!fs.existsSync(imagePath)) fs.mkdirSync(imagePath);
+
+				this.adapter.setObjectAsync(objectPath, {
+					type: "folder",
+					common: {
+						name: "images",
+					},
+					native: {},
+				});
+
+				if (!fs.existsSync(versionFilePath)) {
+					fs.writeFileSync(versionFilePath, "0");
+				}
+				const currentVersion = fs.readFileSync(versionFilePath, "utf8");
+
+				if (packages[rr_package].version > currentVersion) {
+					this.adapter.log.debug(`New version roborock package available: ${version}`);
+
+					const response = await loginApi.get(zipUrl, { responseType: "arraybuffer" });
+					const zip = await JSZip.loadAsync(response.data);
+					const folder = zip.folder("drawable-mdpi");
+
+					if (folder) {
+						let i = 0;
+						folder.forEach(async (relativePath, file) => {
+							if (!file.dir) {
+								const fileContent = await file.async("nodebuffer");
+								if (fileContent) {
+									fs.writeFileSync(`${imagePath}/${relativePath}`, fileContent);
+
+									const fileContentBase64 = fileContent.toString("base64");
+									const fileNameWithoutExtension = relativePath.slice(0, relativePath.lastIndexOf("."));
+									const formattedNumber = (i).toString().padStart(3, "0"); // "001", "002", "003", etc.
+
+									this.adapter.setObjectAsync(`${objectPath}.${formattedNumber}`, {
+										type: "state",
+										common: {
+											name: fileNameWithoutExtension,
+											type: "string",
+											role: "value",
+											read: true,
+											write: false
+										},
+										native: {},
+									});
+									this.adapter.setStateAsync(`${objectPath}.${formattedNumber}`, { val: fileContentBase64, ack: true });
+								}
+								i++;
+							}
+						});
+					}
+
+					fs.writeFileSync(versionFilePath, version.toString());
+				}
+			} catch (err) {
+				this.adapter.catchError(err, "roborockPackageHelper.updateProduct", null, productID);
+			}
+		}
+	}
+
+	findProductIDinPackage(productID, list) {
+		if (list.model === productID) {
+			return list.id;
+		}
+	}
+}
+
+exports.roborockPackageHelper = roborockPackageHelper;