ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
xiaomi_ble.cpp
Go to the documentation of this file.
1#include "xiaomi_ble.h"
3#include "esphome/core/log.h"
4
5#include <algorithm>
6#include <cstring>
7
8// AES-CCM backend for encrypted-payload (bindkey) decryption:
9// - ESP32 + ESP-IDF >= 6.0 -> PSA crypto (psa_aead_decrypt), hardware-backed.
10// - every other platform -> the portable software AES-CCM in ble_device_base, so
11// decryption never depends on the SDK exposing mbedtls/PSA to application code.
12#ifdef USE_ESP32
13#include <esp_idf_version.h>
14#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
15#include <psa/crypto.h>
16#define XIAOMI_CRYPTO_PSA
17#endif
18#endif
19#ifndef XIAOMI_CRYPTO_PSA
21#endif
22
24
25ESPHOME_LOG_TAG(TAG, "xiaomi_ble");
26
27// Maximum bytes to log in very verbose hex output (covers largest packet of ~24 bytes)
28static constexpr size_t XIAOMI_MAX_LOG_BYTES = 32;
29
30bool parse_xiaomi_value(uint16_t value_type, const uint8_t *data, uint8_t value_length, XiaomiParseResult &result) {
31 // button pressed, 3 bytes, only byte 3 is used for supported devices so far
32 if ((value_type == 0x1001) && (value_length == 3)) {
33 result.button_press = data[2] == 0;
34 return true;
35 }
36 // motion detection, 1 byte, 8-bit unsigned integer
37 else if ((value_type == 0x0003) && (value_length == 1)) {
38 result.has_motion = data[0];
39 }
40 // temperature, 2 bytes, 16-bit signed integer (LE), 0.1 °C
41 else if ((value_type == 0x1004) && (value_length == 2)) {
42 const int16_t temperature = encode_value_le<int16_t>(data);
43 result.temperature = temperature / 10.0f;
44 }
45 // humidity, 2 bytes, 16-bit signed integer (LE), 0.1 %
46 else if ((value_type == 0x1006) && (value_length == 2)) {
47 const int16_t humidity = encode_value_le<int16_t>(data);
48 result.humidity = humidity / 10.0f;
49 }
50 // illuminance (+ motion), 3 bytes, 24-bit unsigned integer (LE), 1 lx
51 else if (((value_type == 0x1007) || (value_type == 0x000F)) && (value_length == 3)) {
52 const uint32_t illuminance = encode_uint24(data[2], data[1], data[0]);
53 result.illuminance = illuminance;
54 result.is_light = illuminance >= 100;
55 if (value_type == 0x0F)
56 result.has_motion = true;
57 }
58 // soil moisture, 1 byte, 8-bit unsigned integer, 1 %
59 else if ((value_type == 0x1008) && (value_length == 1)) {
60 result.moisture = data[0];
61 }
62 // conductivity, 2 bytes, 16-bit unsigned integer (LE), 1 µS/cm
63 else if ((value_type == 0x1009) && (value_length == 2)) {
64 const uint16_t conductivity = encode_uint16(data[1], data[0]);
65 result.conductivity = conductivity;
66 }
67 // battery / MiaoMiaoce battery, 1 byte, 8-bit unsigned integer, 1 %
68 else if ((value_type == 0x100A || value_type == 0x4803) && (value_length == 1)) {
69 result.battery_level = data[0];
70 }
71 // temperature + humidity, 4 bytes, 16-bit signed integer (LE) each, 0.1 °C, 0.1 %
72 else if ((value_type == 0x100D) && (value_length == 4)) {
73 const int16_t temperature = encode_value_le<int16_t>(data);
74 const int16_t humidity = encode_value_le<int16_t>(&data[2]);
75 result.temperature = temperature / 10.0f;
76 result.humidity = humidity / 10.0f;
77 }
78 // formaldehyde, 2 bytes, 16-bit unsigned integer (LE), 0.01 mg / m3
79 else if ((value_type == 0x1010) && (value_length == 2)) {
80 const uint16_t formaldehyde = encode_uint16(data[1], data[0]);
81 result.formaldehyde = formaldehyde / 100.0f;
82 }
83 // on/off state, 1 byte, 8-bit unsigned integer
84 else if ((value_type == 0x1012) && (value_length == 1)) {
85 result.is_active = data[0];
86 }
87 // mosquito tablet, 1 byte, 8-bit unsigned integer, 1 %
88 else if ((value_type == 0x1013) && (value_length == 1)) {
89 result.tablet = data[0];
90 }
91 // idle time since last motion, 4 byte, 32-bit unsigned integer, 1 min
92 else if ((value_type == 0x1017) && (value_length == 4)) {
93 const uint32_t idle_time = encode_uint32(data[3], data[2], data[1], data[0]);
94 result.idle_time = idle_time / 60.0f;
95 result.has_motion = !idle_time;
96 } else if ((value_type == 0x1018) && (value_length == 1)) {
97 result.is_light = data[0];
98 }
99 // MiaoMiaoce temperature, 4 bytes, float, 0.1 °C
100 else if ((value_type == 0x4C01) && (value_length == 4)) {
101 const uint32_t int_number = encode_uint32(data[3], data[2], data[1], data[0]);
102 float temperature;
103 std::memcpy(&temperature, &int_number, sizeof(temperature));
104 result.temperature = temperature;
105 }
106 // MiaoMiaoce humidity, 1 byte, 8-bit unsigned integer, 1 %
107 else if ((value_type == 0x4C02) && (value_length == 1)) {
108 result.humidity = data[0];
109 }
110 // XMWSDJ04MMC humidity, 4 bytes, float, 0.1 °C
111 else if ((value_type == 0x4C08) && (value_length == 4)) {
112 const uint32_t int_number = encode_uint32(data[3], data[2], data[1], data[0]);
113 float humidity;
114 std::memcpy(&humidity, &int_number, sizeof(humidity));
115 result.humidity = humidity;
116 } else {
117 return false;
118 }
119
120 return true;
121}
122
123bool parse_xiaomi_message(const uint8_t *message, size_t size, XiaomiParseResult &result) {
124 result.has_encryption = message[0] & 0x08; // update encryption status
125 if (result.has_encryption) {
126 ESP_LOGVV(TAG, "parse_xiaomi_message(): payload is encrypted, stop reading message.");
127 return false;
128 }
129
130 // Data point specs
131 // Byte 0: type
132 // Byte 1: fixed 0x10
133 // Byte 2: length
134 // Byte 3..3+len-1: data point value
135
136 if (result.raw_offset < 0 || static_cast<size_t>(result.raw_offset) >= size) {
137 ESP_LOGVV(TAG, "parse_xiaomi_message(): raw_offset (%d) exceeds message size (%u)!", result.raw_offset,
138 static_cast<unsigned>(size));
139 return false;
140 }
141 const uint8_t *payload = message + result.raw_offset;
142 uint8_t payload_length = size - result.raw_offset;
143 uint8_t payload_offset = 0;
144 bool success = false;
145
146 if (payload_length < 4) {
147 ESP_LOGVV(TAG, "parse_xiaomi_message(): payload has wrong size (%d)!", payload_length);
148 return false;
149 }
150
151 while (payload_length > 3) {
152 if (payload[payload_offset + 1] != 0x10 && payload[payload_offset + 1] != 0x00 &&
153 payload[payload_offset + 1] != 0x4C && payload[payload_offset + 1] != 0x48) {
154 ESP_LOGVV(TAG, "parse_xiaomi_message(): fixed byte not found, stop parsing residual data.");
155 break;
156 }
157
158 const uint8_t value_length = payload[payload_offset + 2];
159 if ((value_length < 1) || (value_length > 4) || (payload_length < (3 + value_length))) {
160 ESP_LOGVV(TAG, "parse_xiaomi_message(): value has wrong size (%d)!", value_length);
161 break;
162 }
163
164 const uint16_t value_type = encode_uint16(payload[payload_offset + 1], payload[payload_offset + 0]);
165 const uint8_t *data = &payload[payload_offset + 3];
166
167 if (parse_xiaomi_value(value_type, data, value_length, result))
168 success = true;
169
170 payload_length -= 3 + value_length;
171 payload_offset += 3 + value_length;
172 }
173
174 return success;
175}
176
177optional<XiaomiParseResult> parse_xiaomi_header(const uint8_t *raw, size_t size) {
178 XiaomiParseResult result;
179 if (size < 5) {
180 ESP_LOGVV(TAG, "parse_xiaomi_header(): service data too short (%u).", static_cast<unsigned>(size));
181 return {};
182 }
183 result.has_encryption = raw[0] & 0x08;
184
185 if (!(raw[0] & 0x40)) {
186 ESP_LOGVV(TAG, "parse_xiaomi_header(): service data has no DATA flag.");
187 return {};
188 }
189
190 result.raw_offset = (raw[0] & 0x20) ? 12 : 11;
191
192 const uint16_t device_uuid = encode_uint16(raw[3], raw[2]);
193
194 if (device_uuid == 0x0098) { // MiFlora
196 result.name = "HHCCJCY01";
197 } else if (device_uuid == 0x01aa) { // round body, segment LCD
199 result.name = "LYWSDCGQ";
200 } else if (device_uuid == 0x015d) { // FlowerPot, RoPot
202 result.name = "HHCCPOT002";
203 } else if (device_uuid == 0x02df) { // Xiaomi (Honeywell) formaldehyde sensor, OLED display
205 result.name = "JQJCY01YM";
206 } else if (device_uuid == 0x03dd) { // Philips/Xiaomi BLE nightlight
208 result.name = "MUE4094RT";
209 result.raw_offset -= 6;
210 } else if (device_uuid == 0x0347 || // ClearGrass-branded, round body, e-ink display
211 device_uuid == 0x0B48) { // Qingping-branded, round body, e-ink display — with bindkeys
213 result.name = "CGG1";
214 } else if (device_uuid == 0x03bc) { // VegTrug Grow Care Garden
216 result.name = "GCLS002";
217 } else if (device_uuid == 0x045b) { // rectangular body, e-ink display
219 result.name = "LYWSD02";
220 } else if (device_uuid == 0x2542 || // rectangular body, e-ink display — with bindkeys
221 device_uuid == 0x16e4) { // same, hardware revision F3_A1 (firmware 2.0.1_0060)
223 result.name = "LYWSD02MMC";
224 if (size == 19)
225 result.raw_offset -= 6;
226 } else if (device_uuid == 0x040a) { // Mosquito Repellent Smart Version
228 result.name = "WX08ZM";
229 } else if (device_uuid == 0x0576) { // Cleargrass (Qingping) alarm clock, segment LCD
231 result.name = "CGD1";
232 } else if (device_uuid == 0x066F) { // Cleargrass (Qingping) Temp & RH Lite
234 result.name = "CGDK2";
235 } else if (device_uuid == 0x055b) { // small square body, segment LCD, encrypted
237 result.name = "LYWSD03MMC";
238 } else if (device_uuid == 0x1203) { // small square body, e-ink display, encrypted
240 result.name = "XMWSDJ04MMC";
241 if (size == 19)
242 result.raw_offset -= 6;
243 } else if (device_uuid == 0x07f6) { // Xiaomi-Yeelight BLE nightlight
245 result.name = "MJYD02YLA";
246 if (size == 19)
247 result.raw_offset -= 6;
248 } else if (device_uuid == 0x06d3) { // rectangular body, e-ink display with alarm
250 result.name = "MHOC303";
251 } else if (device_uuid == 0x0387) { // square body, e-ink display
253 result.name = "MHOC401";
254 } else if (device_uuid == 0x0A83) { // Qingping-branded, motion & ambient light sensor
256 result.name = "CGPR1";
257 if (size == 19)
258 result.raw_offset -= 6;
259 } else if (device_uuid == 0x0A8D) { // Xiaomi Mi Motion Sensor 2
261 result.name = "RTCGQ02LM";
262 if (size == 19)
263 result.raw_offset -= 6;
264 } else {
265 ESP_LOGVV(TAG, "parse_xiaomi_header(): unknown device, no magic bytes.");
266 return {};
267 }
268
269 return result;
270}
271
272bool decrypt_xiaomi_payload(uint8_t *raw, size_t size, const uint8_t *bindkey, uint64_t address) {
273 if ((size != 19) && ((size < 22) || (size > XIAOMI_MAX_ENCRYPTED_FRAME_SIZE))) {
274 ESP_LOGVV(TAG, "decrypt_xiaomi_payload(): data packet has wrong size (%u)!", static_cast<unsigned>(size));
275 ESP_LOGVV_HEX(TAG, raw, size, XIAOMI_MAX_LOG_BYTES, " Packet : %s");
276 return false;
277 }
278
279 uint8_t mac_reverse[MAC_ADDRESS_SIZE] = {0};
280 mac_reverse[5] = (uint8_t) (address >> 40);
281 mac_reverse[4] = (uint8_t) (address >> 32);
282 mac_reverse[3] = (uint8_t) (address >> 24);
283 mac_reverse[2] = (uint8_t) (address >> 16);
284 mac_reverse[1] = (uint8_t) (address >> 8);
285 mac_reverse[0] = (uint8_t) (address >> 0);
286
287 XiaomiAESVector vector{.key = {0},
288 .plaintext = {0},
289 .ciphertext = {0},
290 .authdata = {0x11},
291 .iv = {0},
292 .tag = {0},
293 .keysize = 16,
294 .authsize = 1,
295 .datasize = 0,
296 .tagsize = 4,
297 .ivsize = 12};
298
299 vector.datasize = (size == 19) ? size - 12 : size - 18;
300 const size_t cipher_pos = (size == 19) ? 5 : 11;
301
302 const uint8_t *v = raw;
303
304 memcpy(vector.key, bindkey, vector.keysize);
305 memcpy(vector.ciphertext, v + cipher_pos, vector.datasize);
306 memcpy(vector.tag, v + size - vector.tagsize, vector.tagsize);
307 memcpy(vector.iv, mac_reverse, 6); // MAC address reverse
308 memcpy(vector.iv + 6, v + 2, 3); // sensor type (2) + packet id (1)
309 memcpy(vector.iv + 9, v + size - 7, 3); // payload counter
310
311#ifdef XIAOMI_CRYPTO_PSA
312 // PSA AEAD expects ciphertext + tag concatenated
313 uint8_t ct_with_tag[sizeof(vector.ciphertext) + sizeof(vector.tag)];
314 memcpy(ct_with_tag, vector.ciphertext, vector.datasize);
315 memcpy(ct_with_tag + vector.datasize, vector.tag, vector.tagsize);
316 size_t ct_with_tag_size = vector.datasize + vector.tagsize;
317
318 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
319 psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
320 psa_set_key_bits(&attributes, vector.keysize * 8);
321 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
322 psa_set_key_algorithm(&attributes, PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_CCM, vector.tagsize));
323
324 mbedtls_svc_key_id_t key_id;
325 if (psa_import_key(&attributes, vector.key, vector.keysize, &key_id) != PSA_SUCCESS) {
326 ESP_LOGVV(TAG, "decrypt_xiaomi_payload(): psa_import_key() failed.");
327 return false;
328 }
329
330 size_t plaintext_length;
331 psa_status_t status = psa_aead_decrypt(key_id, PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_CCM, vector.tagsize),
332 vector.iv, vector.ivsize, vector.authdata, vector.authsize, ct_with_tag,
333 ct_with_tag_size, vector.plaintext, vector.datasize, &plaintext_length);
334 psa_destroy_key(key_id);
335 bool decrypt_ok = (status == PSA_SUCCESS && plaintext_length == vector.datasize);
336#else
337 // Portable software AES-CCM (ble_device_base) — no SDK mbedtls/PSA dependency.
338 bool decrypt_ok = ble_device_base::aes_ccm_auth_decrypt(vector.key, vector.iv, vector.ivsize, vector.authdata,
339 vector.authsize, vector.ciphertext, vector.datasize,
340 vector.plaintext, vector.tag, vector.tagsize);
341#endif
342
343 if (!decrypt_ok) {
344 uint8_t mac_address[MAC_ADDRESS_SIZE] = {0};
345 memcpy(mac_address, mac_reverse + 5, 1);
346 memcpy(mac_address + 1, mac_reverse + 4, 1);
347 memcpy(mac_address + 2, mac_reverse + 3, 1);
348 memcpy(mac_address + 3, mac_reverse + 2, 1);
349 memcpy(mac_address + 4, mac_reverse + 1, 1);
350 memcpy(mac_address + 5, mac_reverse, 1);
351 ESP_LOGVV(TAG, "decrypt_xiaomi_payload(): authenticated decryption failed.");
352#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
353 char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
354 format_mac_addr_upper(mac_address, mac_buf);
355 char hex_buf[format_hex_pretty_size(XIAOMI_MAX_LOG_BYTES)];
356#endif
357 ESP_LOGVV(TAG, " MAC address : %s", mac_buf);
358 ESP_LOGVV(TAG, " Packet : %s", format_hex_pretty_to(hex_buf, raw, size));
359 ESP_LOGVV(TAG, " Key : %s", format_hex_pretty_to(hex_buf, vector.key, vector.keysize));
360 ESP_LOGVV(TAG, " Iv : %s", format_hex_pretty_to(hex_buf, vector.iv, vector.ivsize));
361 ESP_LOGVV(TAG, " Cipher : %s", format_hex_pretty_to(hex_buf, vector.ciphertext, vector.datasize));
362 ESP_LOGVV(TAG, " Tag : %s", format_hex_pretty_to(hex_buf, vector.tag, vector.tagsize));
363 return false;
364 }
365
366 memcpy(raw + cipher_pos, vector.plaintext, vector.datasize);
367 raw[0] &= ~0x08;
368
369 ESP_LOGVV(TAG, "decrypt_xiaomi_payload(): authenticated decryption passed.");
370#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
371 char hex_buf[format_hex_pretty_size(XIAOMI_MAX_LOG_BYTES)];
372#endif
373 ESP_LOGVV(TAG, " Plaintext : %s, Packet : %d", format_hex_pretty_to(hex_buf, raw + cipher_pos, vector.datasize),
374 static_cast<int>(raw[4]));
375
376 return true;
377}
378
379#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
380static void report_xiaomi_results(const XiaomiParseResult &result, const char *address) {
381 ESP_LOGD(TAG, "Got Xiaomi %s (%s):", result.name, address);
382
383 if (result.temperature.has_value()) {
384 ESP_LOGD(TAG, " Temperature: %.1f°C", *result.temperature);
385 }
386 if (result.humidity.has_value()) {
387 ESP_LOGD(TAG, " Humidity: %.1f%%", *result.humidity);
388 }
389 if (result.battery_level.has_value()) {
390 ESP_LOGD(TAG, " Battery Level: %.0f%%", *result.battery_level);
391 }
392 if (result.conductivity.has_value()) {
393 ESP_LOGD(TAG, " Conductivity: %.0fµS/cm", *result.conductivity);
394 }
395 if (result.illuminance.has_value()) {
396 ESP_LOGD(TAG, " Illuminance: %.0flx", *result.illuminance);
397 }
398 if (result.moisture.has_value()) {
399 ESP_LOGD(TAG, " Moisture: %.0f%%", *result.moisture);
400 }
401 if (result.tablet.has_value()) {
402 ESP_LOGD(TAG, " Mosquito tablet: %.0f%%", *result.tablet);
403 }
404 if (result.is_active.has_value()) {
405 ESP_LOGD(TAG, " Repellent: %s", *result.is_active ? LOG_STR_LITERAL("on") : LOG_STR_LITERAL("off"));
406 }
407 if (result.has_motion.has_value()) {
408 ESP_LOGD(TAG, " Motion: %s", *result.has_motion ? LOG_STR_LITERAL("yes") : LOG_STR_LITERAL("no"));
409 }
410 if (result.is_light.has_value()) {
411 ESP_LOGD(TAG, " Light: %s", *result.is_light ? LOG_STR_LITERAL("on") : LOG_STR_LITERAL("off"));
412 }
413 if (result.button_press.has_value()) {
414 ESP_LOGD(TAG, " Button: %s", *result.button_press ? LOG_STR_LITERAL("pressed") : LOG_STR_LITERAL(""));
415 }
416}
417#endif
418
419bool XiaomiDevice::parse_xiaomi_device_(const ble_device_base::ESPBTDevice &device, const uint8_t *bindkey) {
420 if (device.address_uint64() != this->address_)
421 return false;
422
423 bool success = false;
424 for (const auto &service_data : device.get_service_datas()) {
425 if (!service_data.uuid.contains(0x95, 0xFE))
426 continue;
427 const uint8_t *raw = service_data.data.data();
428 const size_t size = service_data.data.size();
429 // Devices repeat each frame many times; drop repeats before parsing the header
430 if (size >= 5 && this->last_frame_count_.has_value() && *this->last_frame_count_ == raw[4]) {
431 ESP_LOGVV(TAG, "Duplicate frame %u.", raw[4]);
432 continue;
433 }
434 auto res = parse_xiaomi_header(raw, size);
435 if (!res.has_value())
436 continue;
437 // Decrypt a copy: the tracker hands the same service data to every listener
438 uint8_t plaintext[XIAOMI_MAX_ENCRYPTED_FRAME_SIZE];
439 if (res->has_encryption) {
440 if (bindkey == nullptr) {
441 ESP_LOGVV(TAG, "Encrypted frame but no bindkey.");
442 continue;
443 }
444 if (size > sizeof(plaintext))
445 continue;
446 memcpy(plaintext, raw, size);
447 if (!decrypt_xiaomi_payload(plaintext, size, bindkey, this->address_))
448 continue;
449 raw = plaintext;
450 }
451 // Only a frame that decrypted (or was plain) advances the duplicate filter
452 this->last_frame_count_ = raw[4];
453 if (!parse_xiaomi_message(raw, size, *res))
454 continue;
455#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
456 char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
457 report_xiaomi_results(*res, device.address_str_to(addr_buf));
458#endif
459 this->publish_result(*res);
460 success = true;
461 }
462 return success;
463}
464
465void XiaomiEncryptedDevice::dump_bindkey_(const char *tag) const {
466 char bindkey_hex[format_hex_pretty_size(sizeof(this->bindkey_))];
467 ESP_LOGCONFIG(tag, " Bindkey: %s", format_hex_pretty_to(bindkey_hex, this->bindkey_, sizeof(this->bindkey_), '.'));
468}
469
470void XiaomiEncryptedDevice::set_bindkey(std::initializer_list<uint8_t> bindkey) {
471 memcpy(this->bindkey_, bindkey.begin(), std::min(bindkey.size(), sizeof(this->bindkey_)));
472}
473
475 // Previously the message was parsed twice per packet, once by XiaomiListener::parse_device()
476 // and then again by the respective device class's parse_device() function. Parsing the header
477 // here and then for each device seems to be unnecessary and complicates the duplicate packet filtering.
478 // Hence I disabled the call to parse_xiaomi_header() here and the message parsing is done entirely
479 // in the respective device instance. The XiaomiListener class is defined in __init__.py and I was not
480 // able to remove it entirely.
481
482 return false; // with true it's not showing device scans
483}
484
485} // namespace esphome::xiaomi_ble
uint8_t raw[35]
Definition bl0939.h:0
uint8_t status
Definition bl0942.h:8
ESPDEPRECATED("Use address_str_to() instead. Removed in 2027.2.0.", "2026.8.0") std const char * address_str_to(char *buf) const
Return MAC as "XX:XX:XX:XX:XX:XX" string.
uint64_t address_uint64() const
Return MAC as packed uint64 (byte 0 in LSB — matches esp32's address_uint64).
const std::vector< ServiceData > & get_service_datas() const
Definition ble_device.h:225
optional< uint8_t > last_frame_count_
Definition xiaomi_ble.h:88
bool parse_xiaomi_device_(const ble_device_base::ESPBTDevice &device, const uint8_t *bindkey)
Encrypted frames are dropped when bindkey is null.
virtual void publish_result(const XiaomiParseResult &result)=0
void set_bindkey(std::initializer_list< uint8_t > bindkey)
void dump_bindkey_(const char *tag) const
bool parse_device(const ble_device_base::ESPBTDevice &device) override
const LogString * message
Definition component.cpp:35
bool aes_ccm_auth_decrypt(const uint8_t key[16], const uint8_t *nonce, size_t nonce_len, const uint8_t *aad, size_t aad_len, const uint8_t *ciphertext, size_t ct_len, uint8_t *plaintext, const uint8_t *tag, size_t tag_len)
bool parse_xiaomi_message(const uint8_t *message, size_t size, XiaomiParseResult &result)
bool decrypt_xiaomi_payload(uint8_t *raw, size_t size, const uint8_t *bindkey, uint64_t address)
Decrypts the payload of raw in place and clears its encryption flag.
bool parse_xiaomi_value(uint16_t value_type, const uint8_t *data, uint8_t value_length, XiaomiParseResult &result)
optional< XiaomiParseResult > parse_xiaomi_header(const uint8_t *raw, size_t size)
Parses the frame control and product id; the caller checks the 0xFE95 UUID and filters duplicates.
ESPHOME_LOG_TAG(TAG, "xiaomi_ble")
constexpr uint32_t encode_uint24(uint8_t byte1, uint8_t byte2, uint8_t byte3)
Encode a 24-bit value given three bytes in most to least significant byte order.
Definition helpers.h:1047
char * format_hex_pretty_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length, char separator)
Format byte array as uppercase hex to buffer (base implementation).
Definition helpers.cpp:498
uint16_t size
Definition helpers.cpp:34
constexpr T encode_value_le(const uint8_t *bytes)
Encode a value from its constituent bytes (from least to most significant) in an array with length si...
Definition helpers.h:1084
constexpr size_t format_hex_pretty_size(size_t byte_count)
Calculate buffer size needed for format_hex_pretty_to with separator: "XX:XX:...:XX\0".
Definition helpers.h:1687
constexpr uint32_t encode_uint32(uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4)
Encode a 32-bit value given four bytes in most to least significant byte order.
Definition helpers.h:1051
constexpr uint16_t encode_uint16(uint8_t msb, uint8_t lsb)
Encode a 16-bit value given the most and least significant byte.
Definition helpers.h:1043
char * format_mac_addr_upper(const uint8_t *mac, char *output)
Format MAC address as XX:XX:XX:XX:XX:XX (uppercase, colon separators)
Definition helpers.h:1754
static void uint32_t
enum esphome::xiaomi_ble::XiaomiParseResult::@206 type
uint16_t temperature
Definition sun_gtil2.cpp:12