extern "C" int att_write_callback(uint16_t con_handle, uint16_t attribute_handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer, uint16_t buffer_size){
// printf("gatt client test, att_write_callback mode %u, handle 0x%04x, offset %u, data ", transaction_mode, con_handle, offset);
switch(test){
case WRITE_CHARACTERISTIC_DESCRIPTOR:
case WRITE_CLIENT_CHARACTERISTIC_CONFIGURATION:
CHECK_EQUAL(ATT_TRANSACTION_MODE_NONE, transaction_mode);
CHECK_EQUAL(0, offset);
CHECK_EQUAL_ARRAY(indication, buffer, 2);
result_counter++;
break;
case WRITE_CHARACTERISTIC_VALUE:
CHECK_EQUAL(ATT_TRANSACTION_MODE_NONE, transaction_mode);
CHECK_EQUAL(0, offset);
CHECK_EQUAL_ARRAY((uint8_t *)short_value, buffer, short_value_length);
result_counter++;
break;
case WRITE_LONG_CHARACTERISTIC_DESCRIPTOR:
case WRITE_LONG_CHARACTERISTIC_VALUE:
case WRITE_RELIABLE_LONG_CHARACTERISTIC_VALUE:
if (transaction_mode == ATT_TRANSACTION_MODE_EXECUTE) break;
CHECK_EQUAL(ATT_TRANSACTION_MODE_ACTIVE, transaction_mode);
CHECK_EQUAL_ARRAY((uint8_t *)&long_value[offset], buffer, buffer_size);
if (offset + buffer_size != sizeof(long_value)) break;
result_counter++;
break;
default:
break;
}
return 0;
}
static void handle_ble_client_event(le_event_t * event){
switch(event->type){
case GATT_SERVICE_QUERY_RESULT:
services[result_index++] = ((le_service_event_t *) event)->service;
result_counter++;
break;
case GATT_INCLUDED_SERVICE_QUERY_RESULT:
included_services[result_index++] = ((le_service_event_t *) event)->service;
result_counter++;
break;
case GATT_CHARACTERISTIC_QUERY_RESULT:{
characteristics[result_index++] = ((le_characteristic_event_t *) event)->characteristic;
result_counter++;
break;
}
case GATT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT:{
le_characteristic_descriptor_event *descriptor_event = (le_characteristic_descriptor_event_t *) event;
descriptors[result_index++] = descriptor_event->characteristic_descriptor;
result_counter++;
break;
}
case GATT_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT: {
le_characteristic_descriptor_event *descriptor_event = (le_characteristic_descriptor_event_t *) event;
CHECK_EQUAL(short_value_length, descriptor_event->value_length);
CHECK_EQUAL_ARRAY((uint8_t*)short_value, descriptor_event->value, short_value_length);
result_counter++;
break;
}
case GATT_LONG_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT:{
le_characteristic_descriptor_event_t *descriptor_event = (le_characteristic_descriptor_event_t *) event;
verify_blob(descriptor_event->value_length, descriptor_event->value_offset, descriptor_event->value);
result_counter++;
break;
}
case GATT_CHARACTERISTIC_VALUE_QUERY_RESULT:{
le_characteristic_value_event *cs = (le_characteristic_value_event *) event;
CHECK_EQUAL(short_value_length, cs->blob_length);
CHECK_EQUAL_ARRAY((uint8_t*)short_value, cs->blob, short_value_length);
result_counter++;
break;
}
case GATT_LONG_CHARACTERISTIC_VALUE_QUERY_RESULT:{
le_characteristic_value_event *cl = (le_characteristic_value_event *) event;
verify_blob(cl->blob_length, cl->value_offset, cl->blob);
result_counter++;
break;
}
case GATT_QUERY_COMPLETE:
gatt_query_complete = 1;
break;
default:
break;
}
}
static void verify_blob(uint16_t value_length, uint16_t value_offset, uint8_t * value){
uint8_t * expected_value = (uint8_t*)&long_value[value_offset];
CHECK(value_length);
CHECK_EQUAL_ARRAY(expected_value, value, value_length);
if (value_offset + value_length != sizeof(long_value)) return;
result_counter++;
}
static void verify_advertisement(ad_event_t * e) {
CHECK_EQUAL(0, e->event_type);
CHECK_EQUAL(0, e->address_type);
CHECK_EQUAL(188, e->rssi);
CHECK_EQUAL(3, e->length);
CHECK_EQUAL_ARRAY((uint8_t *)test_device_addr, (uint8_t *)e->address, 6);
}
TEST(SecurityManager, CMACTest){
mock_init();
mock_simulate_hci_state_working();
// expect le encrypt commmand
CHECK_HCI_COMMAND(test_command_packet_01);
aes128_report_result();
// expect le encrypt commmand
CHECK_HCI_COMMAND(test_command_packet_02);
aes128_report_result();
mock_clear_packet_buffer();
// additional test: cmac signing
// aes cmac tests
sm_key_t key;
parse_hex(key, key_string);
uint8_t message [] = "hallo";
cmac_hash_received = 0;
sm_cmac_signed_write_start(key, 0x11, 0x1234, sizeof(message), message, 1, &cmac_done);
while (!cmac_hash_received){
aes128_report_result();
}
uint8_t expected_hash[] = { 0x40, 0x4E, 0xDC, 0x0F, 0x6E, 0x0F, 0xF9, 0x5C};
CHECK_EQUAL_ARRAY(expected_hash, cmac_hash, 8);
// generic aes cmac tests
VALIDATE_MESSAGE(m0);
VALIDATE_MESSAGE(m16);
VALIDATE_MESSAGE(m40);
VALIDATE_MESSAGE(m64);
}
//static int counter = 0;
void CHECK_EQUAL_GATT_ATTRIBUTE(const uint8_t * exp_uuid, const uint8_t * exp_handles, uint8_t * uuid, uint16_t start_handle, uint16_t end_handle){
// printf("counter %d\n", counter);
// counter++;
// printf("expected uuid16: "); pUUID128(exp_uuid);
// printf("\n");
// printf("received uuid16: "); pUUID128(uuid);
// printf("\n\n");
CHECK_EQUAL_ARRAY(exp_uuid, uuid, 16);
if (!exp_handles) return;
CHECK_EQUAL(exp_handles[0], start_handle);
CHECK_EQUAL(exp_handles[1], end_handle);
}
static void validate_message(const char * name, const char * message_string, const char * cmac_string){
mock_clear_packet_buffer();
int len = parse_hex(m, message_string);
// expected result
sm_key_t cmac;
parse_hex(cmac, cmac_string);
printf("-- verify key %s message %s, len %u:\nm: %s\ncmac: %s\n", key_string, name, len, message_string, cmac_string);
sm_key_t key;
parse_hex(key, key_string);
// printf_hexdump(key, 16);
cmac_hash_received = 0;
sm_cmac_general_start(key, len, &get_byte, &cmac_done);
while (!cmac_hash_received){
aes128_report_result();
}
CHECK_EQUAL_ARRAY(cmac, cmac_hash, 16);
}
//static int counter = 0;
void CHECK_EQUAL_GATT_ATTRIBUTE(const uint8_t * exp_uuid, const uint8_t * exp_handles, uint8_t * uuid, uint16_t start_handle, uint16_t end_handle){
CHECK_EQUAL_ARRAY(exp_uuid, uuid, 16);
if (!exp_handles) return;
CHECK_EQUAL(exp_handles[0], start_handle);
CHECK_EQUAL(exp_handles[1], end_handle);
}
