matterbridge-roborock-vacuum-plugin-regions 1.1.1-jb.1

package/src/roborockCommunication/helper/messageSerializer.ts

@@ -0,0 +1,101 @@
+import { RequestMessage } from '../broadcast/model/requestMessage.js';
+import * as CryptoUtils from './cryptoHelper.js';
+import crypto from 'node:crypto';
+import CRC32 from 'crc-32';
+import { DpsPayload, Payload } from '../broadcast/model/dps.js';
+import { MessageContext } from '../broadcast/model/messageContext.js';
+import { AnsiLogger } from 'matterbridge/logger';
+import { Protocol } from '../broadcast/model/protocol.js';
+
+interface SerializeResult {
+  messageId: number;
+  buffer: Buffer<ArrayBufferLike>;
+}
+
+export class MessageSerializer {
+  private readonly context: MessageContext;
+  private readonly logger: AnsiLogger;
+  private sequence = 1;
+  private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
+
+  constructor(context: MessageContext, logger: AnsiLogger) {
+    this.context = context;
+    this.logger = logger;
+  }
+
+  public serialize(duid: string, request: RequestMessage): SerializeResult {
+    const messageId = request.messageId;
+    const buffer = this.buildBuffer(duid, messageId, request);
+    return { messageId: messageId, buffer: buffer };
+  }
+
+  private buildPayload(messageId: number, request: RequestMessage): Payload {
+    const data: DpsPayload = {
+      id: messageId,
+      method: request.method ?? '',
+      params: request.params,
+      security: undefined,
+      result: undefined,
+    };
+
+    if (request.secure) {
+      data.security = {
+        endpoint: this.context.getEndpoint(),
+        nonce: this.context.getSerializeNonceAsHex(),
+      };
+    }
+    return {
+      dps: {
+        [request.protocol]: JSON.stringify(data),
+      },
+      t: request.timestamp,
+    };
+  }
+
+  private buildBuffer(duid: string, messageId: number, request: RequestMessage): Buffer<ArrayBufferLike> {
+    const version = this.context.getProtocolVersion(duid);
+    if (!version || !this.supportedVersions.includes(version)) {
+      throw new Error('unknown protocol version ' + version);
+    }
+    let encrypted;
+    if (request.protocol === Protocol.hello_response || request.protocol === Protocol.ping_response) {
+      encrypted = Buffer.alloc(0);
+    }
+
+    const localKey = this.context.getLocalKey(duid);
+    const payloadData = this.buildPayload(messageId, request);
+    const payload = JSON.stringify(payloadData);
+
+    if (version == '1.0') {
+      const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(payloadData.t) + localKey + CryptoUtils.SALT);
+      const cipher = crypto.createCipheriv('aes-128-ecb', aesKey, null);
+      encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+    } else if (version == 'A01') {
+      // 726f626f726f636b2d67a6d6da is in version 4.0 of the roborock app
+      const encoder = new TextEncoder();
+      const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+      const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
+      encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+    } else if (version == 'B01') {
+      const encoder = new TextEncoder();
+      const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+      const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
+      // pad ??
+      encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+    } else {
+      throw new Error('unable to build the message: unsupported protocol version: ' + version);
+    }
+
+    const msg = Buffer.alloc(23 + encrypted.length);
+    msg.write(version);
+    msg.writeUint32BE(this.sequence++ & 0xffffffff, 3);
+    msg.writeUint32BE(request.nonce & 0xffffffff, 7);
+    msg.writeUint32BE(request.timestamp, 11);
+    msg.writeUint16BE(request.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;
+  }
+}

package/src/roborockCommunication/helper/nameDecoder.ts

@@ -0,0 +1,78 @@
+const token = '%[a-f0-9]{2}';
+const singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');
+const multiMatcher = new RegExp('(' + token + ')+', 'gi');
+
+function decodeComponents(components: RegExpMatchArray | string[] | [], split: number | undefined = undefined): string[] {
+  try {
+    return [decodeURIComponent(components.join(''))];
+  } catch {
+    // Do nothing
+  }
+
+  if (components.length === 1) {
+    return components;
+  }
+
+  split = split || 1;
+  const left = components.slice(0, split);
+  const right = components.slice(split);
+  return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+
+function decode(input: string) {
+  try {
+    return decodeURIComponent(input);
+  } catch {
+    let tokens = input.match(singleMatcher) || [];
+
+    for (let i = 1; i < tokens.length; i++) {
+      input = decodeComponents(tokens, i).join('');
+
+      tokens = input.match(singleMatcher) || [];
+    }
+
+    return input;
+  }
+}
+
+function customDecodeURIComponent(input: string): string {
+  const replaceMap: Record<string, string> = {
+    '%FE%FF': '\uFFFD\uFFFD',
+    '%FF%FE': '\uFFFD\uFFFD',
+  };
+
+  let match = multiMatcher.exec(input);
+  while (match) {
+    try {
+      replaceMap[match[0]] = decodeURIComponent(match[0]);
+    } catch {
+      const result = decode(match[0]);
+
+      if (result !== match[0]) {
+        replaceMap[match[0]] = result;
+      }
+    }
+
+    match = multiMatcher.exec(input);
+  }
+  replaceMap['%C2'] = '\uFFFD';
+
+  const entries = Object.keys(replaceMap);
+
+  for (const key of entries) {
+    input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+  }
+
+  return input;
+}
+
+export default function decodeComponent(encodedURI: string | undefined) {
+  if (encodedURI === undefined) {
+    return undefined;
+  }
+  try {
+    return decodeURIComponent(encodedURI);
+  } catch {
+    return customDecodeURIComponent(encodedURI);
+  }
+}

package/src/roborockCommunication/helper/sequence.ts

@@ -0,0 +1,18 @@
+export class Sequence {
+  private readonly min: number;
+  private readonly max: number;
+  private current: number;
+
+  constructor(min: number, max: number) {
+    this.min = min;
+    this.max = max;
+    this.current = min;
+  }
+
+  next(): number {
+    if (this.current > this.max) {
+      this.current = this.min;
+    }
+    return this.current++;
+  }
+}

package/src/roborockCommunication/index.ts

@@ -0,0 +1,25 @@
+export { RoborockAuthenticateApi } from './RESTAPI/roborockAuthenticateApi.js';
+export { RoborockIoTApi } from './RESTAPI/roborockIoTApi.js';
+export { MessageProcessor } from './broadcast/messageProcessor.js';
+export { VacuumErrorCode } from './Zenum/vacuumAndDockErrorCode.js';
+export { RequestMessage } from './broadcast/model/requestMessage.js';
+export { Protocol } from './broadcast/model/protocol.js';
+export { ClientRouter } from './broadcast/clientRouter.js';
+export { DeviceStatus } from './Zmodel/deviceStatus.js';
+export { ResponseMessage } from './broadcast/model/responseMessage.js';
+export { MapInfo } from './Zmodel/mapInfo.js';
+export { AdditionalPropCode } from './Zenum/additionalPropCode.js';
+export { AuthenticateResponseCode } from './Zenum/authenticateResponseCode.js';
+
+export { Scene } from './Zmodel/scene.js';
+
+export type { AbstractMessageHandler } from './broadcast/listener/abstractMessageHandler.js';
+export type { AbstractConnectionListener, AbstractMessageListener } from './broadcast/listener/index.js';
+export type { UserData } from './Zmodel/userData.js';
+export type { Device } from './Zmodel/device.js';
+export type { Home } from './Zmodel/home.js';
+export type { Client } from './broadcast/client.js';
+export type { SceneParam } from './Zmodel/scene.js';
+export type { BatteryMessage, DeviceErrorMessage, DeviceStatusNotify } from './Zmodel/batteryMessage.js';
+export type { MultipleMap } from './Zmodel/multipleMap.js';
+export type { AuthenticateFlowState } from './Zmodel/authenticateFlowState.js';