michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: bsim: Bluetooth: Add GATT encrypt tests

Browse source 
Add tests for the GATT permissions to read and write for
characteristics that require encryption and LESC encryption.

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>
This commit is contained in:
Emil Gydesen 2024-02-19 10:51:07 +01:00 • committed by Henrik Brix Andersen
commit 686a8c9e54
4 changed files with 113 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

3
tests/bsim/bluetooth/host/gatt/general/prj.conf
View file

@ -1,6 +1,9 @@
CONFIG_BT=y CONFIG_BT=y
CONFIG_BT_SMP=y
CONFIG_BT_DEVICE_NAME="GATT tester" CONFIG_BT_DEVICE_NAME="GATT tester"
CONFIG_BT_PERIPHERAL=y CONFIG_BT_PERIPHERAL=y
CONFIG_BT_CENTRAL=y CONFIG_BT_CENTRAL=y
CONFIG_BT_GATT_CLIENT=y CONFIG_BT_GATT_CLIENT=y
CONFIG_BT_ATT_PREPARE_COUNT=3 CONFIG_BT_ATT_PREPARE_COUNT=3
# Disable auto security so that we can test security errors
CONFIG_BT_ATT_RETRY_ON_SEC_ERR=n

8
tests/bsim/bluetooth/host/gatt/general/src/common.h
View file

@ -62,5 +62,13 @@ extern enum bst_result_t bst_result;
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \ BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0x11) 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0x11)
#define TEST_ENC_CHRC_UUID \
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0x22)
#define TEST_LESC_CHRC_UUID \
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0x33)
void test_tick(bs_time_t HW_device_time); void test_tick(bs_time_t HW_device_time);
void test_init(void); void test_init(void);

110
tests/bsim/bluetooth/host/gatt/general/src/gatt_client_test.c
View file

@ -11,12 +11,16 @@
CREATE_FLAG(flag_is_connected); CREATE_FLAG(flag_is_connected);
CREATE_FLAG(flag_discover_complete); CREATE_FLAG(flag_discover_complete);
CREATE_FLAG(flag_security_changed);
CREATE_FLAG(flag_write_complete); CREATE_FLAG(flag_write_complete);
CREATE_FLAG(flag_read_complete); CREATE_FLAG(flag_read_complete);
static struct bt_conn *g_conn; static struct bt_conn *g_conn;
static uint16_t chrc_handle; static uint16_t chrc_handle;
static uint16_t long_chrc_handle; static uint16_t long_chrc_handle;
static uint16_t enc_chrc_handle;
static uint16_t lesc_chrc_handle;
static uint8_t att_err;
static const struct bt_uuid *test_svc_uuid = TEST_SERVICE_UUID; static const struct bt_uuid *test_svc_uuid = TEST_SERVICE_UUID;
#define ARRAY_ITEM(i, _) i #define ARRAY_ITEM(i, _) i
@ -61,9 +65,19 @@ static void disconnected(struct bt_conn *conn, uint8_t reason)
UNSET_FLAG(flag_is_connected); UNSET_FLAG(flag_is_connected);
} }
static void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
{
if (err != BT_SECURITY_ERR_SUCCESS) {
FAIL("Security failed (err %d)\n", err);
} else {
SET_FLAG(flag_security_changed);
}
}
BT_CONN_CB_DEFINE(conn_callbacks) = { BT_CONN_CB_DEFINE(conn_callbacks) = {
.connected = connected, .connected = connected,
.disconnected = disconnected, .disconnected = disconnected,
.security_changed = security_changed,
}; };
void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type, void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
@ -141,6 +155,12 @@ static uint8_t discover_func(struct bt_conn *conn,
} else if (bt_uuid_cmp(chrc->uuid, TEST_LONG_CHRC_UUID) == 0) { } else if (bt_uuid_cmp(chrc->uuid, TEST_LONG_CHRC_UUID) == 0) {
printk("Found long_chrc\n"); printk("Found long_chrc\n");
long_chrc_handle = chrc->value_handle; long_chrc_handle = chrc->value_handle;
} else if (bt_uuid_cmp(chrc->uuid, TEST_ENC_CHRC_UUID) == 0) {
printk("Found enc_chrc_handle\n");
enc_chrc_handle = chrc->value_handle;
} else if (bt_uuid_cmp(chrc->uuid, TEST_LESC_CHRC_UUID) == 0) {
printk("Found lesc_chrc_handle\n");
lesc_chrc_handle = chrc->value_handle;
} }
} }
@ -169,31 +189,49 @@ static void gatt_discover(void)
printk("Discover complete\n"); printk("Discover complete\n");
} }
static void gatt_write_cb(struct bt_conn *conn, uint8_t err, static void update_security(void)
struct bt_gatt_write_params *params)
{ {
if (err != BT_ATT_ERR_SUCCESS) { int err;
FAIL("Write failed: 0x%02X\n", err);
printk("Updating security\n");
err = bt_conn_set_security(g_conn, BT_SECURITY_L2);
if (err != 0) {
FAIL("Set security failed (err %d)\n", err);
} }
WAIT_FOR_FLAG(flag_security_changed);
printk("Security changed\n");
}
static void gatt_write_cb(struct bt_conn *conn, uint8_t err, struct bt_gatt_write_params *params)
{
(void)memset(params, 0, sizeof(*params)); (void)memset(params, 0, sizeof(*params));
att_err = err;
SET_FLAG(flag_write_complete); SET_FLAG(flag_write_complete);
} }
static void gatt_write(uint16_t handle) static void gatt_write(uint16_t handle, uint8_t expect_att_err)
{ {
static struct bt_gatt_write_params write_params; static struct bt_gatt_write_params write_params;
int err; int err;
if (handle == chrc_handle) { if (handle == chrc_handle) {
printk("Writing to chrc\n"); printk("Writing to chrc and expecting 0x%02X\n", expect_att_err);
write_params.data = chrc_data; write_params.data = chrc_data;
write_params.length = sizeof(chrc_data); write_params.length = sizeof(chrc_data);
} else if (handle == long_chrc_handle) { } else if (handle == long_chrc_handle) {
printk("Writing to long_chrc\n"); printk("Writing to long_chrc and expecting 0x%02X\n", expect_att_err);
write_params.data = long_chrc_data; write_params.data = long_chrc_data;
write_params.length = sizeof(long_chrc_data); write_params.length = sizeof(long_chrc_data);
} else if (handle == enc_chrc_handle) {
printk("Writing to enc_chrc and expecting 0x%02X\n", expect_att_err);
write_params.data = chrc_data;
write_params.length = sizeof(chrc_data);
} else if (handle == lesc_chrc_handle) {
printk("Writing to lesc_chrc and expecting 0x%02X\n", expect_att_err);
write_params.data = chrc_data;
write_params.length = sizeof(chrc_data);
} }
write_params.func = gatt_write_cb; write_params.func = gatt_write_cb;
@ -207,6 +245,11 @@ static void gatt_write(uint16_t handle)
} }
WAIT_FOR_FLAG(flag_write_complete); WAIT_FOR_FLAG(flag_write_complete);
if (att_err != expect_att_err) {
FAIL("Write failed: 0x%02X\n", att_err);
}
printk("success\n"); printk("success\n");
} }
@ -214,8 +257,13 @@ static uint8_t gatt_read_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params, struct bt_gatt_read_params *params,
const void *data, uint16_t length) const void *data, uint16_t length)
{ {
att_err = err;
if (err != BT_ATT_ERR_SUCCESS) { if (err != BT_ATT_ERR_SUCCESS) {
FAIL("Read failed: 0x%02X\n", err); printk("Read failed: 0x%02X\n", err);
(void)memset(params, 0, sizeof(*params));
SET_FLAG(flag_read_complete);
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
} }
@ -242,16 +290,25 @@ static uint8_t gatt_read_cb(struct bt_conn *conn, uint8_t err,
FAIL("long_chrc data different than expected (%u %u)\n", length, FAIL("long_chrc data different than expected (%u %u)\n", length,
LONG_CHRC_SIZE); LONG_CHRC_SIZE);
} }
} else if (params->single.handle == enc_chrc_handle) {
if (data_received_size != CHRC_SIZE ||
memcmp(data_received, chrc_data, data_received_size) != 0) {
FAIL("enc_chrc data different than expected (%u %u)\n", length, CHRC_SIZE);
}
} else if (params->single.handle == lesc_chrc_handle) {
if (data_received_size != CHRC_SIZE ||
memcmp(data_received, chrc_data, data_received_size) != 0) {
FAIL("lesc_chrc data different than expected (%u %u)\n", length, CHRC_SIZE);
}
} }
(void)memset(params, 0, sizeof(*params)); (void)memset(params, 0, sizeof(*params));
SET_FLAG(flag_read_complete); SET_FLAG(flag_read_complete);
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
} }
static void gatt_read(uint16_t handle) static void gatt_read(uint16_t handle, uint8_t expect_att_err)
{ {
static struct bt_gatt_read_params read_params; static struct bt_gatt_read_params read_params;
int err; int err;
@ -260,9 +317,13 @@ static void gatt_read(uint16_t handle)
memset(data_received, 0, sizeof(data_received)); memset(data_received, 0, sizeof(data_received));
if (handle == chrc_handle) { if (handle == chrc_handle) {
printk("Reading chrc\n"); printk("Reading chrc and expecting 0x%02X\n", expect_att_err);
} else if (handle == long_chrc_handle) { } else if (handle == long_chrc_handle) {
printk("Reading long_chrc\n"); printk("Reading long_chrc and expecting 0x%02X\n", expect_att_err);
} else if (handle == enc_chrc_handle) {
printk("Reading enc_chrc and expecting 0x%02X\n", expect_att_err);
} else if (handle == lesc_chrc_handle) {
printk("Reading lesc_chrc and expecting 0x%02X\n", expect_att_err);
} }
read_params.func = gatt_read_cb; read_params.func = gatt_read_cb;
@ -278,6 +339,11 @@ static void gatt_read(uint16_t handle)
} }
WAIT_FOR_FLAG(flag_read_complete); WAIT_FOR_FLAG(flag_read_complete);
if (att_err != expect_att_err) {
FAIL("Read failed: 0x%02X\n", att_err);
}
printk("success\n"); printk("success\n");
} }
@ -303,12 +369,24 @@ static void test_main(void)
/* Write and read a few times to ensure stateless behavior */ /* Write and read a few times to ensure stateless behavior */
for (size_t i = 0; i < 3; i++) { for (size_t i = 0; i < 3; i++) {
gatt_write(chrc_handle); gatt_write(chrc_handle, BT_ATT_ERR_SUCCESS);
gatt_read(chrc_handle); gatt_read(chrc_handle, BT_ATT_ERR_SUCCESS);
gatt_write(long_chrc_handle); gatt_write(long_chrc_handle, BT_ATT_ERR_SUCCESS);
gatt_read(long_chrc_handle); gatt_read(long_chrc_handle, BT_ATT_ERR_SUCCESS);
} }
gatt_write(enc_chrc_handle, BT_ATT_ERR_AUTHENTICATION);
gatt_read(enc_chrc_handle, BT_ATT_ERR_AUTHENTICATION);
gatt_write(lesc_chrc_handle, BT_ATT_ERR_AUTHENTICATION);
gatt_read(lesc_chrc_handle, BT_ATT_ERR_AUTHENTICATION);
update_security();
gatt_write(enc_chrc_handle, BT_ATT_ERR_SUCCESS);
gatt_read(enc_chrc_handle, BT_ATT_ERR_SUCCESS);
gatt_write(lesc_chrc_handle, BT_ATT_ERR_SUCCESS);
gatt_read(lesc_chrc_handle, BT_ATT_ERR_SUCCESS);
PASS("GATT client Passed\n"); PASS("GATT client Passed\n");
} }

8
tests/bsim/bluetooth/host/gatt/general/src/gatt_server_test.c
View file

@ -134,6 +134,14 @@ BT_GATT_SERVICE_DEFINE(test_svc,
BT_GATT_CHRC_WRITE | BT_GATT_CHRC_READ, BT_GATT_CHRC_WRITE | BT_GATT_CHRC_READ,
BT_GATT_PERM_WRITE | BT_GATT_PERM_READ | BT_GATT_PERM_PREPARE_WRITE, BT_GATT_PERM_WRITE | BT_GATT_PERM_READ | BT_GATT_PERM_PREPARE_WRITE,
read_long_test_chrc, write_long_test_chrc, NULL), read_long_test_chrc, write_long_test_chrc, NULL),
BT_GATT_CHARACTERISTIC(TEST_ENC_CHRC_UUID,
BT_GATT_CHRC_WRITE | BT_GATT_CHRC_READ,
BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT,
read_test_chrc, write_test_chrc, NULL),
BT_GATT_CHARACTERISTIC(TEST_LESC_CHRC_UUID,
BT_GATT_CHRC_WRITE | BT_GATT_CHRC_READ,
BT_GATT_PERM_READ_LESC | BT_GATT_PERM_WRITE_LESC,
read_test_chrc, write_test_chrc, NULL),
); );
static void test_main(void) static void test_main(void)