1 #include <stdio.h> 2 3 #include "CppUTest/TestHarness.h" 4 #include "CppUTest/CommandLineTestRunner.h" 5 6 #include "bluetooth_data_types.h" 7 #include "bluetooth_gatt.h" 8 #include "btstack_debug.h" 9 #include "btstack_memory.h" 10 #include "btstack_util.h" 11 #include "mesh/adv_bearer.h" 12 #include "mesh/gatt_bearer.h" 13 #include "mesh/mesh_access.h" 14 #include "mesh/mesh_crypto.h" 15 #include "mesh/mesh_foundation.h" 16 #include "mesh/mesh_iv_index_seq_number.h" 17 #include "mesh/mesh_lower_transport.h" 18 #include "mesh/mesh_network.h" 19 #include "mesh/mesh_upper_transport.h" 20 #include "mesh/provisioning.h" 21 #include "mesh/mesh_peer.h" 22 23 extern "C" int mock_process_hci_cmd(void); 24 25 static mesh_network_pdu_t * received_network_pdu; 26 static mesh_network_pdu_t * received_proxy_pdu; 27 28 static uint8_t outgoing_gatt_network_pdu_data[29]; 29 static uint8_t outgoing_gatt_network_pdu_len; 30 31 static uint8_t outgoing_adv_network_pdu_data[29]; 32 static uint8_t outgoing_adv_network_pdu_len; 33 34 static uint8_t recv_upper_transport_pdu_data[100]; 35 static uint16_t recv_upper_transport_pdu_len; 36 37 #ifdef ENABLE_MESH_ADV_BEARER 38 static btstack_packet_handler_t adv_packet_handler; 39 void adv_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handler){ 40 adv_packet_handler = packet_handler; 41 } 42 void adv_bearer_request_can_send_now_for_network_pdu(void){ 43 // simulate can send now 44 uint8_t event[3]; 45 event[0] = HCI_EVENT_MESH_META; 46 event[1] = 1; 47 event[2] = MESH_SUBEVENT_CAN_SEND_NOW; 48 (*adv_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 49 } 50 void adv_bearer_send_network_pdu(const uint8_t * network_pdu, uint16_t size, uint8_t count, uint16_t interval){ 51 (void) count; 52 (void) interval; 53 // printf("ADV Network PDU: "); 54 // printf_hexdump(network_pdu, size); 55 memcpy(outgoing_adv_network_pdu_data, network_pdu, size); 56 outgoing_adv_network_pdu_len = size; 57 } 58 static void adv_bearer_emit_sent(void){ 59 uint8_t event[3]; 60 event[0] = HCI_EVENT_MESH_META; 61 event[1] = 1; 62 event[2] = MESH_SUBEVENT_MESSAGE_SENT; 63 (*adv_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 64 } 65 #endif 66 67 #ifdef ENABLE_MESH_GATT_BEARER 68 static btstack_packet_handler_t gatt_packet_handler; 69 void gatt_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handler){ 70 gatt_packet_handler = packet_handler; 71 } 72 void gatt_bearer_register_for_mesh_proxy_configuration(btstack_packet_handler_t packet_handler){ 73 } 74 void gatt_bearer_request_can_send_now_for_network_pdu(void){ 75 // simulate can send now 76 uint8_t event[3]; 77 event[0] = HCI_EVENT_MESH_META; 78 event[1] = 1; 79 event[2] = MESH_SUBEVENT_CAN_SEND_NOW; 80 (*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 81 } 82 void gatt_bearer_send_network_pdu(const uint8_t * network_pdu, uint16_t size){ 83 // printf("ADV Network PDU: "); 84 // printf_hexdump(network_pdu, size); 85 memcpy(outgoing_gatt_network_pdu_data, network_pdu, size); 86 outgoing_gatt_network_pdu_len = size; 87 } 88 static void gatt_bearer_emit_sent(void){ 89 uint8_t event[3]; 90 event[0] = HCI_EVENT_MESH_META; 91 event[1] = 1; 92 event[2] = MESH_SUBEVENT_MESSAGE_SENT; 93 (*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 94 } 95 static void gatt_bearer_emit_connected(void){ 96 uint8_t event[5]; 97 event[0] = HCI_EVENT_MESH_META; 98 event[1] = 1; 99 event[2] = MESH_SUBEVENT_PROXY_CONNECTED; 100 little_endian_store_16(event, 3, 0x1234); 101 (*gatt_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 102 } 103 #endif 104 105 // copy from mesh_message.c for now 106 uint16_t mesh_pdu_dst(mesh_pdu_t * pdu){ 107 switch (pdu->pdu_type){ 108 case MESH_PDU_TYPE_TRANSPORT: 109 return mesh_transport_dst((mesh_transport_pdu_t*) pdu); 110 case MESH_PDU_TYPE_NETWORK: 111 return mesh_network_dst((mesh_network_pdu_t *) pdu); 112 default: 113 return MESH_ADDRESS_UNSASSIGNED; 114 } 115 } 116 uint16_t mesh_pdu_ctl(mesh_pdu_t * pdu){ 117 switch (pdu->pdu_type){ 118 case MESH_PDU_TYPE_TRANSPORT: 119 return mesh_transport_ctl((mesh_transport_pdu_t*) pdu); 120 case MESH_PDU_TYPE_NETWORK: 121 return mesh_network_control((mesh_network_pdu_t *) pdu); 122 default: 123 return 0; 124 } 125 } 126 127 void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){ 128 int i; 129 for (i=0; i<size; i++){ 130 if (expected[i] != actual[i]) { 131 printf("offset %u wrong\n", i); 132 printf("expected: "); printf_hexdump(expected, size); 133 printf("actual: "); printf_hexdump(actual, size); 134 } 135 BYTES_EQUAL(expected[i], actual[i]); 136 } 137 } 138 139 static int scan_hex_byte(const char * byte_string){ 140 int upper_nibble = nibble_for_char(*byte_string++); 141 if (upper_nibble < 0) return -1; 142 int lower_nibble = nibble_for_char(*byte_string); 143 if (lower_nibble < 0) return -1; 144 return (upper_nibble << 4) | lower_nibble; 145 } 146 147 static int btstack_parse_hex(const char * string, uint16_t len, uint8_t * buffer){ 148 int i; 149 for (i = 0; i < len; i++) { 150 int single_byte = scan_hex_byte(string); 151 if (single_byte < 0) return 0; 152 string += 2; 153 buffer[i] = (uint8_t)single_byte; 154 // don't check seperator after last byte 155 if (i == len - 1) { 156 return 1; 157 } 158 // optional seperator 159 char separator = *string; 160 if (separator == ':' && separator == '-' && separator == ' ') { 161 string++; 162 } 163 } 164 return 1; 165 } 166 167 #if 0 168 static void btstack_print_hex(const uint8_t * data, uint16_t len, char separator){ 169 int i; 170 for (i=0;i<len;i++){ 171 printf("%02x", data[i]); 172 if (separator){ 173 printf("%c", separator); 174 } 175 } 176 printf("\n"); 177 } 178 #endif 179 180 static mesh_transport_key_t test_application_key; 181 static void mesh_application_key_set(uint16_t netkey_index, uint16_t appkey_index, uint8_t aid, const uint8_t *application_key) { 182 test_application_key.netkey_index = netkey_index; 183 test_application_key.appkey_index = appkey_index; 184 test_application_key.aid = aid; 185 test_application_key.akf = 1; 186 memcpy(test_application_key.key, application_key, 16); 187 mesh_transport_key_add(&test_application_key); 188 } 189 190 static void load_network_key_nid_68(void){ 191 mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get(); 192 network_key->nid = 0x68; 193 btstack_parse_hex("0953fa93e7caac9638f58820220a398e", 16, network_key->encryption_key); 194 btstack_parse_hex("8b84eedec100067d670971dd2aa700cf", 16, network_key->privacy_key); 195 mesh_network_key_add(network_key); 196 mesh_subnet_setup_for_netkey_index(network_key->netkey_index); 197 } 198 199 static void load_network_key_nid_5e(void){ 200 mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get(); 201 network_key->nid = 0x5e; 202 btstack_parse_hex("be635105434859f484fc798e043ce40e", 16, network_key->encryption_key); 203 btstack_parse_hex("5d396d4b54d3cbafe943e051fe9a4eb8", 16, network_key->privacy_key); 204 mesh_network_key_add(network_key); 205 mesh_subnet_setup_for_netkey_index(network_key->netkey_index); 206 } 207 208 static void load_network_key_nid_10(void){ 209 mesh_network_key_t * network_key = btstack_memory_mesh_network_key_get(); 210 network_key->nid = 0x10; 211 btstack_parse_hex("3a4fe84a6cc2c6a766ea93f1084d4039", 16, network_key->encryption_key); 212 btstack_parse_hex("f695fcce709ccface4d8b7a1e6e39d25", 16, network_key->privacy_key); 213 mesh_network_key_add(network_key); 214 mesh_subnet_setup_for_netkey_index(network_key->netkey_index); 215 } 216 217 static void load_provisioning_data_test_message(void){ 218 uint8_t application_key[16]; 219 btstack_parse_hex("63964771734fbd76e3b40519d1d94a48", 16, application_key); 220 mesh_application_key_set( 0, 0, 0x26, application_key); 221 222 uint8_t device_key[16]; 223 btstack_parse_hex("9d6dd0e96eb25dc19a40ed9914f8f03f", 16, device_key); 224 mesh_transport_set_device_key(device_key); 225 } 226 227 static void test_lower_transport_callback_handler(mesh_network_callback_type_t callback_type, mesh_network_pdu_t * network_pdu){ 228 switch (callback_type){ 229 case MESH_NETWORK_PDU_RECEIVED: 230 printf("test MESH_NETWORK_PDU_RECEIVED\n"); 231 received_network_pdu = network_pdu; 232 break; 233 case MESH_NETWORK_PDU_SENT: 234 printf("test MESH_NETWORK_PDU_SENT\n"); 235 mesh_lower_transport_received_message(MESH_NETWORK_PDU_SENT, network_pdu); 236 break; 237 default: 238 break; 239 } 240 } 241 242 static void test_proxy_server_callback_handler(mesh_network_callback_type_t callback_type, mesh_network_pdu_t * network_pdu){ 243 switch (callback_type){ 244 case MESH_NETWORK_PDU_RECEIVED: 245 printf("test MESH_PROXY_PDU_RECEIVED\n"); 246 received_proxy_pdu = network_pdu; 247 break; 248 case MESH_NETWORK_PDU_SENT: 249 // printf("test MESH_PROXY_PDU_SENT\n"); 250 // mesh_lower_transport_received_mesage(MESH_NETWORK_PDU_SENT, network_pdu); 251 break; 252 case MESH_NETWORK_PDU_ENCRYPTED: 253 printf("test MESH_NETWORK_PDU_ENCRYPTED\n"); 254 received_proxy_pdu = network_pdu; 255 break; 256 default: 257 break; 258 } 259 } 260 261 static void test_upper_transport_access_message_handler(mesh_pdu_t * pdu){ 262 mesh_access_pdu_t * access_pdu; 263 mesh_network_pdu_t * network_pdu; 264 mesh_message_pdu_t * message_pdu; 265 switch(pdu->pdu_type){ 266 case MESH_PDU_TYPE_ACCESS: 267 access_pdu = (mesh_access_pdu_t *) pdu; 268 printf("test access handler MESH_PDU_TYPE_ACCESS received\n"); 269 recv_upper_transport_pdu_len = access_pdu->len; 270 memcpy(recv_upper_transport_pdu_data, access_pdu->data, recv_upper_transport_pdu_len); 271 mesh_upper_transport_message_processed_by_higher_layer(pdu); 272 break; 273 case MESH_PDU_TYPE_MESSAGE: 274 message_pdu = (mesh_message_pdu_t *) pdu; 275 printf("test access handler MESH_PDU_TYPE_MESSAGE received\n"); 276 network_pdu = (mesh_network_pdu_t *) btstack_linked_list_get_first_item(&message_pdu->segments); 277 recv_upper_transport_pdu_len = mesh_network_pdu_len(network_pdu) - 1; 278 memcpy(recv_upper_transport_pdu_data, mesh_network_pdu_data(network_pdu) + 1, recv_upper_transport_pdu_len); 279 mesh_upper_transport_message_processed_by_higher_layer(pdu); 280 break; 281 default: 282 btstack_assert(0); 283 break; 284 } 285 } 286 287 static void test_upper_transport_control_message_handler(mesh_pdu_t * pdu){ 288 mesh_transport_pdu_t * transport_pdu; 289 mesh_network_pdu_t * network_pdu; 290 mesh_unsegmented_pdu_t * unsegmented_incoming_pdu; 291 switch(pdu->pdu_type){ 292 case MESH_PDU_TYPE_TRANSPORT: 293 transport_pdu = (mesh_transport_pdu_t *) pdu; 294 printf("test MESH_CONTROL_TRANSPORT_PDU_RECEIVED\n"); 295 recv_upper_transport_pdu_len = transport_pdu->len; 296 memcpy(recv_upper_transport_pdu_data, transport_pdu->data, recv_upper_transport_pdu_len); 297 mesh_upper_transport_message_processed_by_higher_layer(pdu); 298 break; 299 case MESH_PDU_TYPE_UNSEGMENTED: 300 unsegmented_incoming_pdu = (mesh_unsegmented_pdu_t *) pdu; 301 network_pdu = unsegmented_incoming_pdu->segment; 302 printf("test MESH_PDU_TYPE_UNSEGMENTED\n"); 303 recv_upper_transport_pdu_len = mesh_network_pdu_len(network_pdu); 304 memcpy(recv_upper_transport_pdu_data, mesh_network_pdu_data(network_pdu), recv_upper_transport_pdu_len); 305 mesh_upper_transport_message_processed_by_higher_layer(pdu); 306 break; 307 default: 308 btstack_assert(0); 309 break; 310 } 311 } 312 313 TEST_GROUP(MessageTest){ 314 void setup(void){ 315 btstack_memory_init(); 316 btstack_crypto_init(); 317 load_provisioning_data_test_message(); 318 mesh_network_init(); 319 mesh_lower_transport_init(); 320 mesh_upper_transport_init(); 321 mesh_network_key_init(); 322 // intercept messages between network and lower layer 323 mesh_network_set_higher_layer_handler(&test_lower_transport_callback_handler); 324 mesh_network_set_proxy_message_handler(&test_proxy_server_callback_handler); 325 // register to receive upper transport messages 326 mesh_upper_transport_register_access_message_handler(&test_upper_transport_access_message_handler); 327 mesh_upper_transport_register_control_message_handler(&test_upper_transport_control_message_handler); 328 mesh_seq_auth_reset(); 329 #ifdef ENABLE_MESH_GATT_BEARER 330 mesh_foundation_gatt_proxy_set(1); 331 gatt_bearer_emit_connected(); 332 #endif 333 outgoing_gatt_network_pdu_len = 0; 334 outgoing_adv_network_pdu_len = 0; 335 received_network_pdu = NULL; 336 recv_upper_transport_pdu_len =0; 337 } 338 void teardown(void){ 339 // printf("-- teardown start --\n\n"); 340 btstack_crypto_reset(); 341 mesh_network_reset(); 342 mesh_lower_transport_reset(); 343 mesh_upper_transport_dump(); 344 mesh_upper_transport_reset(); 345 // mesh_network_dump(); 346 // mesh_transport_dump(); 347 printf("-- teardown complete --\n\n"); 348 } 349 }; 350 351 static uint8_t transport_pdu_data[64]; 352 static uint16_t transport_pdu_len; 353 354 static uint8_t test_network_pdu_len; 355 static uint8_t test_network_pdu_data[29]; 356 357 void test_receive_network_pdus(int count, char ** network_pdus, char ** lower_transport_pdus, char * access_pdu){ 358 int i; 359 for (i=0;i<count;i++){ 360 test_network_pdu_len = strlen(network_pdus[i]) / 2; 361 btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data); 362 363 mesh_network_received_message(test_network_pdu_data, test_network_pdu_len, 0); 364 365 while (received_network_pdu == NULL) { 366 mock_process_hci_cmd(); 367 } 368 369 transport_pdu_len = strlen(lower_transport_pdus[i]) / 2; 370 btstack_parse_hex(lower_transport_pdus[i], transport_pdu_len, transport_pdu_data); 371 372 uint8_t * lower_transport_pdu = mesh_network_pdu_data(received_network_pdu); 373 uint8_t lower_transport_pdu_len = mesh_network_pdu_len(received_network_pdu); 374 375 // printf_hexdump(lower_transport_pdu, lower_transport_pdu_len); 376 377 CHECK_EQUAL( transport_pdu_len, lower_transport_pdu_len); 378 CHECK_EQUAL_ARRAY(transport_pdu_data, lower_transport_pdu, transport_pdu_len); 379 380 // forward to mesh_transport 381 mesh_lower_transport_received_message(MESH_NETWORK_PDU_RECEIVED, received_network_pdu); 382 383 // done 384 received_network_pdu = NULL; 385 } 386 387 // wait for tranport pdu 388 while (recv_upper_transport_pdu_len == 0) { 389 mock_process_hci_cmd(); 390 } 391 392 transport_pdu_len = strlen(access_pdu) / 2; 393 btstack_parse_hex(access_pdu, transport_pdu_len, transport_pdu_data); 394 395 printf("UpperTransportPDU: "); 396 printf_hexdump(recv_upper_transport_pdu_data, recv_upper_transport_pdu_len); 397 CHECK_EQUAL( transport_pdu_len, recv_upper_transport_pdu_len); 398 CHECK_EQUAL_ARRAY(transport_pdu_data, recv_upper_transport_pdu_data, transport_pdu_len); 399 } 400 401 static void expect_gatt_network_pdu(const uint8_t * data, uint16_t len){ 402 while (outgoing_gatt_network_pdu_len == 0) { 403 mock_process_hci_cmd(); 404 } 405 406 if (outgoing_gatt_network_pdu_len != test_network_pdu_len){ 407 printf("Test Network PDU (%u): ", outgoing_gatt_network_pdu_len); printf_hexdump(outgoing_gatt_network_pdu_data, outgoing_gatt_network_pdu_len); 408 printf("Expected PDU (%u): ", test_network_pdu_len); printf_hexdump(test_network_pdu_data, test_network_pdu_len); 409 } 410 CHECK_EQUAL( outgoing_gatt_network_pdu_len, test_network_pdu_len); 411 CHECK_EQUAL_ARRAY(test_network_pdu_data, outgoing_gatt_network_pdu_data, test_network_pdu_len); 412 413 outgoing_gatt_network_pdu_len = 0; 414 gatt_bearer_emit_sent(); 415 } 416 417 static void expect_adv_network_pdu(const uint8_t * data, uint16_t len){ 418 while (outgoing_adv_network_pdu_len == 0) { 419 mock_process_hci_cmd(); 420 } 421 422 if (outgoing_adv_network_pdu_len != test_network_pdu_len){ 423 printf("Test Network PDU (%u): ", outgoing_adv_network_pdu_len); printf_hexdump(outgoing_adv_network_pdu_data, outgoing_adv_network_pdu_len); 424 printf("Expected PDU (%u): ", test_network_pdu_len); printf_hexdump(test_network_pdu_data, test_network_pdu_len); 425 } 426 CHECK_EQUAL( outgoing_adv_network_pdu_len, test_network_pdu_len); 427 CHECK_EQUAL_ARRAY(test_network_pdu_data, outgoing_adv_network_pdu_data, test_network_pdu_len); 428 429 outgoing_adv_network_pdu_len = 0; 430 adv_bearer_emit_sent(); 431 } 432 433 void test_send_access_message(uint16_t netkey_index, uint16_t appkey_index, uint8_t ttl, uint16_t src, uint16_t dest, uint8_t szmic, char * control_pdu, int count, char ** lower_transport_pdus, char ** network_pdus){ 434 435 transport_pdu_len = strlen(control_pdu) / 2; 436 btstack_parse_hex(control_pdu, transport_pdu_len, transport_pdu_data); 437 438 mesh_pdu_t * pdu; 439 if (count == 1 ){ 440 // send as unsegmented access pdu 441 static mesh_unsegmented_pdu_t unsegmented_pdu; 442 unsegmented_pdu.pdu_header.pdu_type = MESH_PDU_TYPE_UNSEGMENTED; 443 mesh_network_pdu_t * segment = mesh_network_pdu_get(); 444 unsegmented_pdu.segment = segment; 445 pdu = (mesh_pdu_t*) &unsegmented_pdu; 446 } else { 447 // send as segmented access pdu 448 pdu = (mesh_pdu_t*) mesh_transport_pdu_get(); 449 } 450 mesh_upper_transport_setup_access_pdu(pdu, netkey_index, appkey_index, ttl, src, dest, szmic, transport_pdu_data, transport_pdu_len); 451 mesh_upper_transport_send_access_pdu(pdu); 452 453 // check for all network pdus 454 int i; 455 for (i=0;i<count;i++){ 456 // parse expected network pdu 457 test_network_pdu_len = strlen(network_pdus[i]) / 2; 458 btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data); 459 460 #ifdef ENABLE_MESH_GATT_BEARER 461 expect_gatt_network_pdu(test_network_pdu_data, test_network_pdu_len); 462 #endif 463 464 #ifdef ENABLE_MESH_ADV_BEARER 465 expect_adv_network_pdu(test_network_pdu_data, test_network_pdu_len); 466 #endif 467 } 468 } 469 470 void test_send_control_message(uint16_t netkey_index, uint8_t ttl, uint16_t src, uint16_t dest, char * control_pdu, int count, char ** lower_transport_pdus, char ** network_pdus){ 471 472 transport_pdu_len = strlen(control_pdu) / 2; 473 btstack_parse_hex(control_pdu, transport_pdu_len, transport_pdu_data); 474 475 uint8_t opcode = transport_pdu_data[0]; 476 477 mesh_pdu_t * pdu; 478 if (transport_pdu_len < 12){ 479 // send as unsegmented control pdu 480 pdu = (mesh_pdu_t *) mesh_network_pdu_get(); 481 } else { 482 // send as segmented control pdu 483 pdu = (mesh_pdu_t *) mesh_transport_pdu_get(); 484 } 485 mesh_upper_transport_setup_control_pdu(pdu, netkey_index, ttl, src, dest, opcode, transport_pdu_data+1, transport_pdu_len-1); 486 mesh_upper_transport_send_control_pdu(pdu); 487 488 // check for all network pdus 489 int i; 490 for (i=0;i<count;i++){ 491 // expected network pdu 492 test_network_pdu_len = strlen(network_pdus[i]) / 2; 493 btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data); 494 495 #ifdef ENABLE_MESH_GATT_BEARER 496 expect_gatt_network_pdu(test_network_pdu_data, test_network_pdu_len); 497 #endif 498 499 #ifdef ENABLE_MESH_ADV_BEARER 500 expect_adv_network_pdu(test_network_pdu_data, test_network_pdu_len); 501 #endif 502 503 } 504 } 505 #if 1 506 // Message 1 507 char * message1_network_pdus[] = { 508 (char *) "68eca487516765b5e5bfdacbaf6cb7fb6bff871f035444ce83a670df" 509 }; 510 char * message1_lower_transport_pdus[] = { 511 (char *) "034b50057e400000010000", 512 }; 513 char * message1_upper_transport_pdu = (char *) "034b50057e400000010000"; 514 TEST(MessageTest, Message1Receive){ 515 load_network_key_nid_68(); 516 mesh_set_iv_index(0x12345678); 517 test_receive_network_pdus(1, message1_network_pdus, message1_lower_transport_pdus, message1_upper_transport_pdu); 518 } 519 TEST(MessageTest, Message1Send){ 520 uint16_t netkey_index = 0; 521 uint8_t ttl = 0; 522 uint16_t src = 0x1201; 523 uint16_t dest = 0xfffd; 524 uint32_t seq = 1; 525 load_network_key_nid_68(); 526 mesh_set_iv_index(0x12345678); 527 mesh_sequence_number_set(seq); 528 test_send_control_message(netkey_index, ttl, src, dest, message1_upper_transport_pdu, 1, message1_lower_transport_pdus, message1_network_pdus); 529 } 530 531 // Message 2 532 char * message2_network_pdus[] = { 533 (char *) "68d4c826296d7979d7dbc0c9b4d43eebec129d20a620d01e" 534 }; 535 char * message2_lower_transport_pdus[] = { 536 (char *) "04320308ba072f", 537 }; 538 char * message2_upper_transport_pdu = (char *) "04320308ba072f"; 539 TEST(MessageTest, Message2Receive){ 540 load_network_key_nid_68(); 541 mesh_set_iv_index(0x12345678); 542 test_receive_network_pdus(1, message2_network_pdus, message2_lower_transport_pdus, message2_upper_transport_pdu); 543 } 544 TEST(MessageTest, Message2Send){ 545 uint16_t netkey_index = 0; 546 uint8_t ttl = 0; 547 uint16_t src = 0x2345; 548 uint16_t dest = 0x1201; 549 uint32_t seq = 0x014820; 550 load_network_key_nid_68(); 551 mesh_set_iv_index(0x12345678); 552 mesh_sequence_number_set(seq); 553 test_send_control_message(netkey_index, ttl, src, dest, message2_upper_transport_pdu, 1, message2_lower_transport_pdus, message2_network_pdus); 554 } 555 556 // Message 3 557 char * message3_network_pdus[] = { 558 (char *) "68da062bc96df253273086b8c5ee00bdd9cfcc62a2ddf572" 559 }; 560 char * message3_lower_transport_pdus[] = { 561 (char *) "04fa0205a6000a", 562 }; 563 char * message3_upper_transport_pdu = (char *) "04fa0205a6000a"; 564 TEST(MessageTest, Message3Receive){ 565 load_network_key_nid_68(); 566 mesh_set_iv_index(0x12345678); 567 test_receive_network_pdus(1, message3_network_pdus, message3_lower_transport_pdus, message3_upper_transport_pdu); 568 } 569 TEST(MessageTest, Message3Send){ 570 uint16_t netkey_index = 0; 571 uint8_t ttl = 0; 572 uint16_t src = 0x2fe3; 573 uint16_t dest = 0x1201; 574 uint32_t seq = 0x2b3832; 575 load_network_key_nid_68(); 576 mesh_set_iv_index(0x12345678); 577 mesh_sequence_number_set(seq); 578 test_send_control_message(netkey_index, ttl, src, dest, message3_upper_transport_pdu, 1, message3_lower_transport_pdus, message3_network_pdus); 579 } 580 581 // Message 4 582 char * message4_network_pdus[] = { 583 (char *) "5e84eba092380fb0e5d0ad970d579a4e88051c" 584 }; 585 char * message4_lower_transport_pdus[] = { 586 (char *) "0100", 587 }; 588 char * message4_upper_transport_pdu = (char *) "0100"; 589 TEST(MessageTest, Message4Receive){ 590 load_network_key_nid_5e(); 591 mesh_set_iv_index(0x12345678); 592 test_receive_network_pdus(1, message4_network_pdus, message4_lower_transport_pdus, message4_upper_transport_pdu); 593 } 594 TEST(MessageTest, Message4Send){ 595 uint16_t netkey_index = 0; 596 uint8_t ttl = 0; 597 uint16_t src = 0x1201; 598 uint16_t dest = 0x2345; 599 uint32_t seq = 0x000002; 600 load_network_key_nid_5e(); 601 mesh_set_iv_index(0x12345678); 602 mesh_sequence_number_set(seq); 603 test_send_control_message(netkey_index, ttl, src, dest, message4_upper_transport_pdu, 1, message4_lower_transport_pdus, message4_network_pdus); 604 } 605 606 // Message 5 607 char * message5_network_pdus[] = { 608 (char *) "5eafd6f53c43db5c39da1792b1fee9ec74b786c56d3a9dee", 609 }; 610 char * message5_lower_transport_pdus[] = { 611 (char *) "02001234567800", 612 }; 613 char * message5_upper_transport_pdu = (char *) "02001234567800"; 614 TEST(MessageTest, Message5Receive){ 615 load_network_key_nid_5e(); 616 mesh_set_iv_index(0x12345678); 617 test_receive_network_pdus(1, message5_network_pdus, message5_lower_transport_pdus, message5_upper_transport_pdu); 618 } 619 TEST(MessageTest, Message5Send){ 620 uint16_t netkey_index = 0; 621 uint8_t ttl = 0; 622 uint16_t src = 0x2345; 623 uint16_t dest = 0x1201; 624 uint32_t seq = 0x014834; 625 load_network_key_nid_5e(); 626 mesh_set_iv_index(0x12345678); 627 mesh_sequence_number_set(seq); 628 test_send_control_message(netkey_index, ttl, src, dest, message5_upper_transport_pdu, 1, message5_lower_transport_pdus, message5_network_pdus); 629 } 630 631 // Message 6 632 char * message6_network_pdus[] = { 633 (char *) "68cab5c5348a230afba8c63d4e686364979deaf4fd40961145939cda0e", 634 (char *) "681615b5dd4a846cae0c032bf0746f44f1b8cc8ce5edc57e55beed49c0", 635 }; 636 char * message6_lower_transport_pdus[] = { 637 (char *) "8026ac01ee9dddfd2169326d23f3afdf", 638 (char *) "8026ac21cfdc18c52fdef772e0e17308", 639 }; 640 char * message6_upper_transport_pdu = (char *) "0056341263964771734fbd76e3b40519d1d94a48"; 641 TEST(MessageTest, Message6Receive){ 642 load_network_key_nid_68(); 643 mesh_set_iv_index(0x12345678); 644 test_receive_network_pdus(2, message6_network_pdus, message6_lower_transport_pdus, message6_upper_transport_pdu); 645 } 646 TEST(MessageTest, Message6Send){ 647 uint16_t netkey_index = 0; 648 uint16_t appkey_index = MESH_DEVICE_KEY_INDEX; 649 uint8_t ttl = 4; 650 uint16_t src = 0x0003; 651 uint16_t dest = 0x1201; 652 uint32_t seq = 0x3129ab; 653 uint8_t szmic = 0; 654 655 load_network_key_nid_68(); 656 mesh_set_iv_index(0x12345678); 657 mesh_sequence_number_set(seq); 658 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message6_upper_transport_pdu, 2, message6_lower_transport_pdus, message6_network_pdus); 659 } 660 661 // Message 7 - ACK 662 char * message7_network_pdus[] = { 663 (char *) "68e476b5579c980d0d730f94d7f3509df987bb417eb7c05f", 664 }; 665 char * message7_lower_transport_pdus[] = { 666 (char *) "00a6ac00000002", 667 }; 668 char * message7_upper_transport_pdu = (char *) "00a6ac00000002"; 669 TEST(MessageTest, Message7Send){ 670 uint16_t netkey_index = 0; 671 uint8_t ttl = 0x0b; 672 uint16_t src = 0x2345; 673 uint16_t dest = 0x0003; 674 uint32_t seq = 0x014835; 675 676 load_network_key_nid_68(); 677 mesh_set_iv_index(0x12345678); 678 mesh_sequence_number_set(seq); 679 test_send_control_message(netkey_index, ttl, src, dest, message7_upper_transport_pdu, 1, message7_lower_transport_pdus, message7_network_pdus); 680 } 681 // ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu 682 // TEST(MessageTest, Message7Receive){ 683 // mesh_set_iv_index(0x12345678); 684 // test_receive_network_pdus(1, message7_network_pdus, message7_lower_transport_pdus, message7_upper_transport_pdu); 685 // } 686 687 // Message 8 - ACK 688 char * message8_network_pdus[] = { 689 (char *) "684daa6267c2cf0e2f91add6f06e66006844cec97f973105ae2534f958", 690 }; 691 char * message8_lower_transport_pdus[] = { 692 (char *) "8026ac01ee9dddfd2169326d23f3afdf", 693 }; 694 char * message8_upper_transport_pdu = (char *) "8026ac01ee9dddfd2169326d23f3afdf"; 695 // ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu 696 // TEST(MessageTest, Message8Receive){ 697 // mesh_set_iv_index(0x12345678); 698 // test_receive_network_pdus(1, message8_network_pdus, message8_lower_transport_pdus, message8_upper_transport_pdu); 699 // } 700 701 // Message 9 - ACK 702 703 // Message 10 704 char * message10_network_pdus[] = { 705 (char *) "5e7b786568759f7777ed355afaf66d899c1e3d", 706 }; 707 char * message10_lower_transport_pdus[] = { 708 (char *) "0101", 709 }; 710 char * message10_upper_transport_pdu = (char *) "0101"; 711 TEST(MessageTest, Message10Receive){ 712 load_network_key_nid_5e(); 713 mesh_set_iv_index(0x12345678); 714 test_receive_network_pdus(1, message10_network_pdus, message10_lower_transport_pdus, message10_upper_transport_pdu); 715 } 716 TEST(MessageTest, Message10Send){ 717 uint16_t netkey_index = 0; 718 uint8_t ttl = 0; 719 uint16_t src = 0x1201; 720 uint16_t dest = 0x2345; 721 uint32_t seq = 0x000003; 722 723 load_network_key_nid_5e(); 724 mesh_set_iv_index(0x12345678); 725 mesh_sequence_number_set(seq); 726 test_send_control_message(netkey_index, ttl, src, dest, message10_upper_transport_pdu, 1, message10_lower_transport_pdus, message10_network_pdus); 727 } 728 729 // Message 11 730 // The Friend node responds to this poll with the first segment of the stored message. It also indicates that it has more data. 731 732 // Message 12 733 char * message12_network_pdus[] = { 734 (char *) "5e8a18fc6e4d05ae21466087599c2426ce9a35", 735 }; 736 char * message12_lower_transport_pdus[] = { 737 (char *) "0101", 738 }; 739 char * message12_upper_transport_pdu = (char *) "0101"; 740 TEST(MessageTest, Message12Receive){ 741 load_network_key_nid_5e(); 742 mesh_set_iv_index(0x12345678); 743 test_receive_network_pdus(1, message12_network_pdus, message12_lower_transport_pdus, message12_upper_transport_pdu); 744 } 745 TEST(MessageTest, Message12Send){ 746 uint16_t netkey_index = 0; 747 uint8_t ttl = 0; 748 uint16_t src = 0x1201; 749 uint16_t dest = 0x2345; 750 uint32_t seq = 0x000004; 751 752 load_network_key_nid_5e(); 753 mesh_set_iv_index(0x12345678); 754 mesh_sequence_number_set(seq); 755 test_send_control_message(netkey_index, ttl, src, dest, message12_upper_transport_pdu, 1, message12_lower_transport_pdus, message12_network_pdus); 756 } 757 758 // Message 13 759 // The Friend node responds with the same message as last time. 760 // Message 14 761 // The Low Power node received the retransmitted stored message. As that message has the MD bit set 762 // it sends another Friend Poll to obtain the next message. 763 char * message14_network_pdus[] = { 764 (char *) "5e0bbaf92b5c8f7d3ae62a3c75dff683dce24e", 765 }; 766 char * message14_lower_transport_pdus[] = { 767 (char *) "0100", 768 }; 769 char * message14_upper_transport_pdu = (char *) "0100"; 770 TEST(MessageTest, Message14Receive){ 771 load_network_key_nid_5e(); 772 mesh_set_iv_index(0x12345678); 773 test_receive_network_pdus(1, message14_network_pdus, message14_lower_transport_pdus, message14_upper_transport_pdu); 774 } 775 TEST(MessageTest, Message14Send){ 776 uint16_t netkey_index = 0; 777 uint8_t ttl = 0; 778 uint16_t src = 0x1201; 779 uint16_t dest = 0x2345; 780 uint32_t seq = 0x000005; 781 782 load_network_key_nid_5e(); 783 mesh_set_iv_index(0x12345678); 784 mesh_sequence_number_set(seq); 785 test_send_control_message(netkey_index, ttl, src, dest, message14_upper_transport_pdu, 1, message14_lower_transport_pdus, message14_network_pdus); 786 } 787 788 // Message 15 789 // The Friend node responds, with the next message in the friend queue. The Friend node has no more data, so it sets the MD to 0. 790 char * message15_network_pdus[] = { 791 (char *) "5ea8dab50e7ee7f1d29805664d235eacd707217dedfe78497fefec7391", 792 }; 793 char * message15_lower_transport_pdus[] = { 794 (char *) "8026ac21cfdc18c52fdef772e0e17308", 795 }; 796 char * message15_upper_transport_pdu = (char *) "0100"; 797 // ACK message, handled in mesh_transport - can be checked with test_control_receive_network_pdu 798 // not sure - no upper access message 799 // TEST(MessageTest, Message15Receive){ 800 // load_network_key_nid_5e(); 801 // mesh_set_iv_index(0x12345678); 802 // test_receive_network_pdus(1, message15_network_pdus, message15_lower_transport_pdus, message15_upper_transport_pdu); 803 // } 804 805 // Message 16 806 char * message16_network_pdus[] = { 807 (char *) "68e80e5da5af0e6b9be7f5a642f2f98680e61c3a8b47f228", 808 }; 809 char * message16_lower_transport_pdus[] = { 810 (char *) "0089511bf1d1a81c11dcef", 811 }; 812 char * message16_upper_transport_pdu = (char *) "800300563412"; 813 TEST(MessageTest, Message16Receive){ 814 load_network_key_nid_68(); 815 mesh_set_iv_index(0x12345678); 816 test_receive_network_pdus(1, message16_network_pdus, message16_lower_transport_pdus, message16_upper_transport_pdu); 817 } 818 TEST(MessageTest, Message16Send){ 819 uint16_t netkey_index = 0; 820 uint16_t appkey_index = MESH_DEVICE_KEY_INDEX; 821 uint8_t ttl = 0x0b; 822 uint16_t src = 0x1201; 823 uint16_t dest = 0x0003; 824 uint32_t seq = 0x000006; 825 uint8_t szmic = 0; 826 827 load_network_key_nid_68(); 828 mesh_set_iv_index(0x12345678); 829 mesh_sequence_number_set(seq); 830 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message16_upper_transport_pdu, 1, message16_lower_transport_pdus, message16_network_pdus); 831 } 832 833 // Message 17 834 // A Relay node receives the message from the Low Power node and relays it, decrementing the TTL value. 835 // Message 18 836 char * message18_network_pdus[] = { 837 (char *) "6848cba437860e5673728a627fb938535508e21a6baf57", 838 }; 839 char * message18_lower_transport_pdus[] = { 840 (char *) "665a8bde6d9106ea078a", 841 }; 842 char * message18_upper_transport_pdu = (char *) "0400000000"; 843 TEST(MessageTest, Message18Receive){ 844 load_network_key_nid_68(); 845 mesh_set_iv_index(0x12345678); 846 test_receive_network_pdus(1, message18_network_pdus, message18_lower_transport_pdus, message18_upper_transport_pdu); 847 } 848 TEST(MessageTest, Message18Send){ 849 uint16_t netkey_index = 0; 850 uint16_t appkey_index = 0; 851 uint8_t ttl = 3; 852 uint16_t src = 0x1201; 853 uint16_t dest = 0xffff; 854 uint32_t seq = 0x00007; 855 uint8_t szmic = 0; 856 857 load_network_key_nid_68(); 858 mesh_set_iv_index(0x12345678); 859 mesh_sequence_number_set(seq); 860 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message18_upper_transport_pdu, 1, message18_lower_transport_pdus, message18_network_pdus); 861 } 862 863 864 // Message 19 865 // The Low Power node sends another Health Current Status message indicating that there are three faults: 866 // Battery Low Warning, Power Supply Interrupted Warning, and Supply Voltage Too Low Warning. 867 char * message19_network_pdus[] = { 868 (char *) "68110edeecd83c3010a05e1b23a926023da75d25ba91793736", 869 }; 870 char * message19_lower_transport_pdus[] = { 871 (char *) "66ca6cd88e698d1265f43fc5", 872 }; 873 char * message19_upper_transport_pdu = (char *) "04000000010703"; 874 TEST(MessageTest, Message19Receive){ 875 load_network_key_nid_68(); 876 mesh_set_iv_index(0x12345678); 877 test_receive_network_pdus(1, message19_network_pdus, message19_lower_transport_pdus, message19_upper_transport_pdu); 878 } 879 TEST(MessageTest, Message19Send){ 880 uint16_t netkey_index = 0; 881 uint16_t appkey_index = 0; 882 uint8_t ttl = 3; 883 uint16_t src = 0x1201; 884 uint16_t dest = 0xffff; 885 uint32_t seq = 0x00009; 886 uint8_t szmic = 0; 887 888 load_network_key_nid_68(); 889 mesh_set_iv_index(0x12345678); 890 mesh_sequence_number_set(seq); 891 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message19_upper_transport_pdu, 1, message19_lower_transport_pdus, message19_network_pdus); 892 } 893 894 // Message 20 895 char * message20_network_pdus[] = { 896 (char *) "e85cca51e2e8998c3dc87344a16c787f6b08cc897c941a5368", 897 }; 898 char * message20_lower_transport_pdus[] = { 899 (char *) "669c9803e110fea929e9542d", 900 }; 901 char * message20_upper_transport_pdu = (char *) "04000000010703"; 902 TEST(MessageTest, Message20Receive){ 903 load_network_key_nid_68(); 904 mesh_set_iv_index(0x12345677); 905 test_receive_network_pdus(1, message20_network_pdus, message20_lower_transport_pdus, message20_upper_transport_pdu); 906 } 907 TEST(MessageTest, Message20Send){ 908 uint16_t netkey_index = 0; 909 uint16_t appkey_index = 0; 910 uint8_t ttl = 3; 911 uint16_t src = 0x1234; 912 uint16_t dest = 0xffff; 913 uint32_t seq = 0x070809; 914 uint8_t szmic = 0; 915 916 load_network_key_nid_68(); 917 mesh_set_iv_index(0x12345677); 918 mesh_sequence_number_set(seq); 919 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message20_upper_transport_pdu, 1, message20_lower_transport_pdus, message20_network_pdus); 920 } 921 922 // Message 21 923 // The Low Power node sends a vendor command to a group address. 924 char * message21_network_pdus[] = { 925 (char *) "e84e8fbe003f58a4d61157bb76352ea6307eebfe0f30b83500e9", 926 }; 927 char * message21_lower_transport_pdus[] = { 928 (char *) "664d92e9dfcf3ab85b6e8fcf03", 929 }; 930 char * message21_upper_transport_pdu = (char *) "d50a0048656c6c6f"; 931 TEST(MessageTest, Message21Receive){ 932 load_network_key_nid_68(); 933 mesh_set_iv_index(0x12345677); 934 test_receive_network_pdus(1, message21_network_pdus, message21_lower_transport_pdus, message21_upper_transport_pdu); 935 } 936 TEST(MessageTest, Message21Send){ 937 uint16_t netkey_index = 0; 938 uint16_t appkey_index = 0; 939 uint8_t ttl = 3; 940 uint16_t src = 0x1234; 941 uint16_t dest = 0xc105; 942 uint32_t seq = 0x07080a; 943 uint8_t szmic = 0; 944 945 load_network_key_nid_68(); 946 mesh_set_iv_index(0x12345677); 947 mesh_sequence_number_set(seq); 948 test_send_access_message(netkey_index, appkey_index, ttl, src, dest, szmic, message21_upper_transport_pdu, 1, message21_lower_transport_pdus, message21_network_pdus); 949 } 950 951 // Message 22 952 char * message22_network_pdus[] = { 953 (char *) "e8d85caecef1e3ed31f3fdcf88a411135fea55df730b6b28e255", 954 }; 955 char * message22_lower_transport_pdus[] = { 956 (char *) "663871b904d431526316ca48a0", 957 }; 958 char * message22_upper_transport_pdu = (char *) "d50a0048656c6c6f"; 959 char * message22_label_string = (char *) "0073e7e4d8b9440faf8415df4c56c0e1"; 960 961 TEST(MessageTest, Message22Receive){ 962 load_network_key_nid_68(); 963 mesh_set_iv_index(0x12345677); 964 uint8_t label_uuid[16]; 965 btstack_parse_hex(message22_label_string, 16, label_uuid); 966 mesh_virtual_address_register(label_uuid, 0xb529); 967 test_receive_network_pdus(1, message22_network_pdus, message22_lower_transport_pdus, message22_upper_transport_pdu); 968 } 969 970 TEST(MessageTest, Message22Send){ 971 uint16_t netkey_index = 0; 972 uint16_t appkey_index = 0; 973 uint8_t ttl = 3; 974 uint16_t src = 0x1234; 975 uint32_t seq = 0x07080b; 976 uint8_t szmic = 0; 977 978 load_network_key_nid_68(); 979 mesh_set_iv_index(0x12345677); 980 mesh_sequence_number_set(seq); 981 uint8_t label_uuid[16]; 982 btstack_parse_hex(message22_label_string, 16, label_uuid); 983 mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0xb529); 984 uint16_t pseudo_dst = virtual_address->pseudo_dst; 985 test_send_access_message(netkey_index, appkey_index, ttl, src, pseudo_dst, szmic, message22_upper_transport_pdu, 1, message22_lower_transport_pdus, message22_network_pdus); 986 } 987 988 // Message 23 989 char * message23_network_pdus[] = { 990 (char *) "e877a48dd5fe2d7a9d696d3dd16a75489696f0b70c711b881385", 991 }; 992 char * message23_lower_transport_pdus[] = { 993 (char *) "662456db5e3100eef65daa7a38", 994 }; 995 char * message23_upper_transport_pdu = (char *) "d50a0048656c6c6f"; 996 char * message23_label_string = (char *) "f4a002c7fb1e4ca0a469a021de0db875"; 997 998 TEST(MessageTest, Message23Receive){ 999 load_network_key_nid_68(); 1000 mesh_set_iv_index(0x12345677); 1001 uint8_t label_uuid[16]; 1002 btstack_parse_hex(message23_label_string, 16, label_uuid); 1003 mesh_virtual_address_register(label_uuid, 0x9736); 1004 test_receive_network_pdus(1, message23_network_pdus, message23_lower_transport_pdus, message23_upper_transport_pdu); 1005 } 1006 TEST(MessageTest, Message23Send){ 1007 uint16_t netkey_index = 0; 1008 uint16_t appkey_index = 0; 1009 uint8_t ttl = 3; 1010 uint16_t src = 0x1234; 1011 uint32_t seq = 0x07080c; 1012 uint8_t szmic = 0; 1013 1014 load_network_key_nid_68(); 1015 mesh_set_iv_index(0x12345677); 1016 mesh_sequence_number_set(seq); 1017 uint8_t label_uuid[16]; 1018 btstack_parse_hex(message23_label_string, 16, label_uuid); 1019 mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0x9736); 1020 uint16_t pseudo_dst = virtual_address->pseudo_dst; 1021 test_send_access_message(netkey_index, appkey_index, ttl, src, pseudo_dst, szmic, message23_upper_transport_pdu, 1, message23_lower_transport_pdus, message23_network_pdus); 1022 } 1023 #endif 1024 1025 // Message 24 1026 char * message24_network_pdus[] = { 1027 (char *) "e8624e65bb8c1794e998b4081f47a35251fdd3896d99e4db489b918599", 1028 (char *) "e8a7d0f0a2ea42dc2f4dd6fb4db33a6c088d023b47", 1029 }; 1030 char * message24_lower_transport_pdus[] = { 1031 (char *) "e6a03401c3c51d8e476b28e3aa5001f3", 1032 (char *) "e6a034211c01cea6", 1033 }; 1034 char * message24_upper_transport_pdu = (char *) "ea0a00576f726c64"; 1035 char * message24_label_string = (char *) "f4a002c7fb1e4ca0a469a021de0db875"; 1036 TEST(MessageTest, Message24Receive){ 1037 load_network_key_nid_68(); 1038 mesh_set_iv_index(0x12345677); 1039 uint8_t label_uuid[16]; 1040 btstack_parse_hex(message24_label_string, 16, label_uuid); 1041 mesh_virtual_address_register(label_uuid, 0x9736); 1042 test_receive_network_pdus(2, message24_network_pdus, message24_lower_transport_pdus, message24_upper_transport_pdu); 1043 } 1044 TEST(MessageTest, Message24Send){ 1045 uint16_t netkey_index = 0; 1046 uint16_t appkey_index = 0; 1047 uint8_t ttl = 3; 1048 uint16_t src = 0x1234; 1049 uint32_t seq = 0x07080d; 1050 uint8_t szmic = 1; 1051 1052 load_network_key_nid_68(); 1053 mesh_set_iv_index(0x12345677); 1054 mesh_sequence_number_set(seq); 1055 uint8_t label_uuid[16]; 1056 btstack_parse_hex(message24_label_string, 16, label_uuid); 1057 mesh_virtual_address_t * virtual_address = mesh_virtual_address_register(label_uuid, 0x9736); 1058 uint16_t pseudo_dst = virtual_address->pseudo_dst; 1059 test_send_access_message(netkey_index, appkey_index, ttl, src, pseudo_dst, szmic, message24_upper_transport_pdu, 2, message24_lower_transport_pdus, message24_network_pdus); 1060 } 1061 1062 // Proxy Configuration Test 1063 char * proxy_config_pdus[] = { 1064 (char *) "0210386bd60efbbb8b8c28512e792d3711f4b526", 1065 }; 1066 char * proxy_config_lower_transport_pdus[] = { 1067 (char *) "0000", 1068 }; 1069 char * proxy_config_upper_transport_pdu = (char *) "ea0a00576f726c64"; 1070 TEST(MessageTest, ProxyConfigReceive){ 1071 mesh_set_iv_index(0x12345678); 1072 load_network_key_nid_10(); 1073 int i = 0; 1074 char ** network_pdus = proxy_config_pdus; 1075 test_network_pdu_len = strlen(network_pdus[i]) / 2; 1076 btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data); 1077 mesh_network_process_proxy_configuration_message(&test_network_pdu_data[1], test_network_pdu_len-1); 1078 while (received_proxy_pdu == NULL) { 1079 mock_process_hci_cmd(); 1080 } 1081 char ** lower_transport_pdus = proxy_config_lower_transport_pdus; 1082 transport_pdu_len = strlen(lower_transport_pdus[i]) / 2; 1083 btstack_parse_hex(lower_transport_pdus[i], transport_pdu_len, transport_pdu_data); 1084 1085 uint8_t * lower_transport_pdu = mesh_network_pdu_data(received_proxy_pdu); 1086 uint8_t lower_transport_pdu_len = mesh_network_pdu_len(received_proxy_pdu); 1087 1088 // printf_hexdump(lower_transport_pdu, lower_transport_pdu_len); 1089 1090 CHECK_EQUAL( transport_pdu_len, lower_transport_pdu_len); 1091 CHECK_EQUAL_ARRAY(transport_pdu_data, lower_transport_pdu, transport_pdu_len); 1092 1093 // done 1094 mesh_network_message_processed_by_higher_layer(received_proxy_pdu); 1095 received_proxy_pdu = NULL; 1096 } 1097 1098 1099 TEST(MessageTest, ProxyConfigSend){ 1100 uint16_t netkey_index = 0; 1101 uint8_t ctl = 1; 1102 uint8_t ttl = 0; 1103 uint16_t src = 1; 1104 uint16_t dest = 0; 1105 uint32_t seq = 1; 1106 uint8_t nid = 0x10; 1107 mesh_set_iv_index(0x12345678); 1108 load_network_key_nid_10(); 1109 mesh_network_pdu_t * network_pdu = mesh_network_pdu_get(); 1110 uint8_t data[] = { 0 , 0 }; 1111 mesh_network_setup_pdu(network_pdu, netkey_index, nid, ctl, ttl, seq, src, dest, data, sizeof(data)); 1112 mesh_network_encrypt_proxy_configuration_message(network_pdu); 1113 while (received_proxy_pdu == NULL) { 1114 mock_process_hci_cmd(); 1115 } 1116 uint8_t * proxy_pdu_data = received_proxy_pdu->data; 1117 uint8_t proxy_pdu_len = received_proxy_pdu->len; 1118 1119 int i = 0; 1120 char ** network_pdus = proxy_config_pdus; 1121 transport_pdu_len = strlen(network_pdus[i]) / 2; 1122 btstack_parse_hex(network_pdus[i], transport_pdu_len, transport_pdu_data); 1123 1124 CHECK_EQUAL( transport_pdu_len-1, proxy_pdu_len); 1125 CHECK_EQUAL_ARRAY(transport_pdu_data+1, proxy_pdu_data, transport_pdu_len-1); 1126 1127 received_proxy_pdu = NULL; 1128 1129 mesh_network_pdu_free(network_pdu); 1130 } 1131 1132 static btstack_crypto_aes128_t crypto_request_aes128; 1133 static uint8_t plaintext[16]; 1134 static uint8_t identity_key[16]; 1135 static uint8_t hash[16]; 1136 static uint8_t random_value[8]; 1137 1138 static void mesh_proxy_handle_get_aes128(void * arg){ 1139 UNUSED(arg); 1140 uint8_t expected_hash[8]; 1141 uint8_t expected_random_value[8]; 1142 1143 btstack_parse_hex("00861765aefcc57b", 8, expected_hash); 1144 CHECK_EQUAL_ARRAY(&hash[8], expected_hash, 8); 1145 1146 btstack_parse_hex("34ae608fbbc1f2c6", 8, expected_random_value); 1147 CHECK_EQUAL_ARRAY(random_value, expected_random_value, 8); 1148 } 1149 1150 TEST(MessageTest, ServiceDataUsingNodeIdentityTest){ 1151 btstack_parse_hex("34ae608fbbc1f2c6", 8, random_value); 1152 memset(plaintext, 0, sizeof(plaintext)); 1153 memcpy(&plaintext[6] , random_value, 8); 1154 big_endian_store_16(plaintext, 14, 0x1201); 1155 // 84396c435ac48560b5965385253e210c 1156 btstack_parse_hex("84396c435ac48560b5965385253e210c", 16, identity_key); 1157 btstack_crypto_aes128_encrypt(&crypto_request_aes128, identity_key, plaintext, hash, mesh_proxy_handle_get_aes128, NULL); 1158 } 1159 1160 // Mesh v1.0, 8.2.1 1161 static btstack_crypto_aes128_cmac_t aes_cmac_request; 1162 static uint8_t k4_result[1]; 1163 static void handle_k4_result(void *arg){ 1164 printf("ApplicationkeyIDTest: %02x\n", k4_result[0]); 1165 CHECK_EQUAL( 0x26, k4_result[0]); 1166 } 1167 TEST(MessageTest, ApplicationkeyIDTest){ 1168 static uint8_t application_key[16]; 1169 btstack_parse_hex("63964771734fbd76e3b40519d1d94a48", 16, application_key); 1170 mesh_k4(&aes_cmac_request, application_key, &k4_result[0], &handle_k4_result, NULL); 1171 } 1172 1173 int main (int argc, const char * argv[]){ 1174 return CommandLineTestRunner::RunAllTests(argc, argv); 1175 } 1176