tests/bluetooth/host/keys/bt_keys_find_irk/src/main.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2022 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include "mocks/keys_help_utils.h"
 #include "mocks/rpa.h"
 #include "testing_common_defs.h"

 #include <zephyr/bluetooth/bluetooth.h>
 #include <zephyr/fff.h>
 #include <zephyr/kernel.h>

 #include <host/keys.h>

 DEFINE_FFF_GLOBALS;

 /* This LUT contains different combinations of ID, Address and key type.
  * Item in this list will be used to fill keys pool.
  */
 static const struct id_addr_type testing_id_addr_type_lut[] = {

 	{BT_ADDR_ID_1, BT_ADDR_LE_1, BT_KEYS_PERIPH_LTK},
 	{BT_ADDR_ID_1, BT_RPA_ADDR_LE_1, BT_KEYS_PERIPH_LTK},
 	{BT_ADDR_ID_1, BT_RPA_ADDR_LE_2, BT_KEYS_IRK},
 	{BT_ADDR_ID_1, BT_ADDR_LE_3, BT_KEYS_IRK},

 	{BT_ADDR_ID_2, BT_ADDR_LE_1, BT_KEYS_LTK},
 	{BT_ADDR_ID_2, BT_RPA_ADDR_LE_3, BT_KEYS_IRK},
 	{BT_ADDR_ID_2, BT_RPA_ADDR_LE_4, BT_KEYS_IRK},
 	{BT_ADDR_ID_2, BT_ADDR_LE_2, BT_KEYS_LOCAL_CSRK},

 	{BT_ADDR_ID_3, BT_ADDR_LE_1, BT_KEYS_REMOTE_CSRK},
 	{BT_ADDR_ID_3, BT_ADDR_LE_2, BT_KEYS_LTK_P256},

 	{BT_ADDR_ID_4, BT_ADDR_LE_1, BT_KEYS_ALL}};

 /* Global iterator to iterate over the ID, Address and type LUT */
 static uint8_t params_it;

 /* Pointer to the current set of testing parameters */
 static struct id_addr_type const *current_params_vector;

 /* This list will hold returned references while filling keys pool */
 static struct bt_keys *returned_keys_refs[CONFIG_BT_MAX_PAIRED];

 BUILD_ASSERT(ARRAY_SIZE(testing_id_addr_type_lut) == CONFIG_BT_MAX_PAIRED);
 BUILD_ASSERT(ARRAY_SIZE(testing_id_addr_type_lut) == ARRAY_SIZE(returned_keys_refs));

 /* Check if a Bluetooth LE random address is resolvable private address. */
 #define BT_ADDR_IS_RPA(a) (((a)->val[5] & 0xc0) == 0x40)

 static bool check_if_addr_is_rpa(const bt_addr_le_t *addr)
 {
 	if (addr->type != BT_ADDR_LE_RANDOM) {
 		return false;
 	}

 	return BT_ADDR_IS_RPA(&addr->a);
 }

 static bool bt_rpa_irk_matches_unreachable_custom_fake(const uint8_t irk[16], const bt_addr_t *addr)
 {
 	zassert_unreachable("Unexpected call to 'bt_rpa_irk_matches()' occurred");
 	return true;
 }

 static bool bt_rpa_irk_matches_custom_fake(const uint8_t irk[16], const bt_addr_t *addr)
 {
 	if (irk[0] != (params_it) && !bt_addr_cmp(&current_params_vector->addr->a, addr)) {
 		return false;
 	}

 	return true;
 }

 static void *empty_list_ts_setup(void)
 {
 	clear_key_pool();

 	return NULL;
 }

 ZTEST_SUITE(bt_keys_find_irk_initially_empty_list, NULL, empty_list_ts_setup, NULL, NULL, NULL);

 /*
  *  Find a non-existing key reference for ID and Address of type 'BT_KEYS_IRK'
  *
  *  Constraints:
  *   - Empty keys pool list
  *
  *  Expected behaviour:
  *   - A NULL value is returned
  */
 ZTEST(bt_keys_find_irk_initially_empty_list, test_find_non_existing_key_reference)
 {
 	uint8_t id;
 	const bt_addr_le_t *addr;
 	struct bt_keys *returned_ref;
 	struct id_addr_type const *params_vector;

 	for (size_t i = 0; i < ARRAY_SIZE(testing_id_addr_type_lut); i++) {

 		params_vector = &testing_id_addr_type_lut[i];
 		id = params_vector->id;
 		addr = params_vector->addr;

 		returned_ref = bt_keys_find_irk(id, addr);

 		zassert_true(returned_ref == NULL,
 			     "bt_keys_find_irk() returned a non-valid reference");
 	}
 }

 static void rpa_resolving_ts_setup(void *f)
 {
 	clear_key_pool();
 	int rv = fill_key_pool_by_id_addr_type(
 		testing_id_addr_type_lut, ARRAY_SIZE(testing_id_addr_type_lut), returned_keys_refs);

 	zassert_true(rv == 0, "Failed to fill keys pool list, error code %d", -rv);

 	/* Set the index to the IRK value to recognize row index during bt_rpa_irk_matches()
 	 * callback
 	 */
 	for (size_t it = 0; it < ARRAY_SIZE(returned_keys_refs); it++) {
 		returned_keys_refs[it]->irk.val[0] = it;
 	}

 	RPA_FFF_FAKES_LIST(RESET_FAKE);
 }

 ZTEST_SUITE(bt_keys_find_irk_rpa_resolving, NULL, NULL, rpa_resolving_ts_setup, NULL, NULL);

 /*
  *  Try to resolve an RPA address using IRK by finding an existing key reference for ID and Address
  *  of type 'BT_KEYS_IRK'. Matching the address with existing IRKs fails.
  *
  *  Constraints:
  *   - Full keys pool list
  *   - IRK value and device address don't match
  *
  *  Expected behaviour:
  *   - A NULL value is returned
  */
 ZTEST(bt_keys_find_irk_rpa_resolving, test_resolving_rpa_address_by_irk_but_matching_fails)
 {
 	uint8_t id;
 	const bt_addr_le_t *addr;
 	struct bt_keys *returned_ref;
 	struct id_addr_type const *params_vector;

 	bt_rpa_irk_matches_fake.return_val = false;

 	for (size_t i = 0; i < ARRAY_SIZE(testing_id_addr_type_lut); i++) {

 		params_vector = &testing_id_addr_type_lut[i];
 		id = params_vector->id;
 		addr = params_vector->addr;

 		returned_ref = bt_keys_find_irk(id, addr);

 		zassert_true(returned_ref == NULL,
 			     "bt_keys_find_irk() returned a non-valid reference");
 	}
 }

 /*
  *  Try to resolve an RPA address using IRK by finding an existing key reference for ID and Address
  *  of type 'BT_KEYS_IRK'. Matching the address with existing IRKs fails.
  *
  *  Constraints:
  *   - Full keys pool list
  *   - IRK value and device address match
  *
  *  Expected behaviour:
  *   - A valid reference value is returned
  */
 ZTEST(bt_keys_find_irk_rpa_resolving, test_resolving_rpa_address_by_irk_and_matching_succeeds)
 {
 	int type;
 	uint8_t id;
 	const bt_addr_le_t *addr;
 	struct id_addr_type const *params_vector;
 	struct bt_keys *returned_ref, *expected_key_ref;

 	bt_rpa_irk_matches_fake.custom_fake = bt_rpa_irk_matches_custom_fake;

 	for (size_t it = 0; it < ARRAY_SIZE(testing_id_addr_type_lut); it++) {

 		params_vector = &testing_id_addr_type_lut[it];
 		type = params_vector->type;
 		id = params_vector->id;
 		addr = params_vector->addr;

 		/* Set global variables to be used within bt_rpa_irk_matches_custom_fake() */
 		params_it = it;
 		current_params_vector = params_vector;

 		expected_key_ref = returned_keys_refs[it];

 		/*
 		 * Try to resolve the current testing vector address.
 		 * Address will be considered resolvable if:
 		 *  - The current testing vector address is an RPA
 		 *  - The current testing vector key type is an IRK
 		 */
 		returned_ref = bt_keys_find_irk(id, addr);

 		if (check_if_addr_is_rpa(addr) && (type & BT_KEYS_IRK)) {

 			zassert_true(returned_ref != NULL,
 				     "bt_keys_find_irk() returned a NULL reference %d", it);

 			zassert_equal_ptr(returned_ref, expected_key_ref,
 					  "bt_keys_find_irk() returned unexpected reference");

 			/* Check if address has been stored */
 			zassert_mem_equal(&returned_ref->irk.rpa, &addr->a, sizeof(bt_addr_t),
 					  "Incorrect address was stored by 'bt_keys_find_irk()'");
 		} else {
 			zassert_true(returned_ref == NULL,
 				     "bt_keys_find_irk() returned a non-valid reference %d", it);
 		}
 	}
 }

 static void *no_resolving_ts_setup(void)
 {
 	int type;
 	const bt_addr_le_t *addr;
 	struct id_addr_type const *params_vector;

 	clear_key_pool();
 	int rv = fill_key_pool_by_id_addr_type(
 		testing_id_addr_type_lut, ARRAY_SIZE(testing_id_addr_type_lut), returned_keys_refs);

 	zassert_true(rv == 0, "Failed to fill keys pool list, error code %d", -rv);

 	/* Set the index to the IRK value to recognize row index during bt_rpa_irk_matches()
 	 * callback
 	 */
 	for (size_t it = 0; it < ARRAY_SIZE(returned_keys_refs); it++) {
 		returned_keys_refs[it]->irk.val[0] = it;
 	}

 	/* Copy the address as if was previously resolved using IRK */
 	for (size_t it = 0; it < ARRAY_SIZE(returned_keys_refs); it++) {

 		params_vector = &testing_id_addr_type_lut[it];
 		type = params_vector->type;
 		addr = params_vector->addr;

 		if (check_if_addr_is_rpa(addr) && (type & BT_KEYS_IRK)) {
 			bt_addr_copy(&returned_keys_refs[it]->irk.rpa, &addr->a);
 		}
 	}

 	return NULL;
 }

 ZTEST_SUITE(bt_keys_find_irk_no_resolving, NULL, no_resolving_ts_setup, NULL, NULL, NULL);

 /*
  *  Find an existing key reference for ID and Address of type 'BT_KEYS_IRK'
  *  while the address has been resolved previously using the IRK
  *
  *  Constraints:
  *   - Full keys pool list
  *   - IRK address and device address match
  *
  *  Expected behaviour:
  *   - A valid reference value is returned
  */
 ZTEST(bt_keys_find_irk_no_resolving, test_find_key_of_previously_resolved_address)
 {
 	int type;
 	uint8_t id;
 	const bt_addr_le_t *addr;
 	struct id_addr_type const *params_vector;
 	struct bt_keys *returned_ref, *expected_key_ref;

 	for (size_t it = 0; it < ARRAY_SIZE(testing_id_addr_type_lut); it++) {

 		params_vector = &testing_id_addr_type_lut[it];
 		type = params_vector->type;
 		id = params_vector->id;
 		addr = params_vector->addr;

 		/* Set global variables to be used within bt_rpa_irk_matches_custom_fake() */
 		params_it = it;
 		current_params_vector = params_vector;

 		/*
 		 * Now, as the address under test should have been resolved before,
 		 * bt_rpa_irk_matches() isn't expected to be called for an RPA.
 		 *
 		 * But, for other records, which won't be resolved, a call to bt_rpa_irk_matches()
 		 * is expected simulating the attempt to resolve it
 		 */
 		if (check_if_addr_is_rpa(addr) && (type & BT_KEYS_IRK)) {
 			bt_rpa_irk_matches_fake.custom_fake =
 				bt_rpa_irk_matches_unreachable_custom_fake;
 		} else {
 			bt_rpa_irk_matches_fake.custom_fake = bt_rpa_irk_matches_custom_fake;
 		}

 		expected_key_ref = returned_keys_refs[it];

 		returned_ref = bt_keys_find_irk(id, addr);

 		if (check_if_addr_is_rpa(addr) && (type & BT_KEYS_IRK)) {

 			zassert_true(returned_ref != NULL,
 				     "bt_keys_find_irk() returned a NULL reference");
 			zassert_equal_ptr(returned_ref, expected_key_ref,
 					  "bt_keys_find_irk() returned unexpected reference");

 			/* Check if address has been stored */
 			zassert_mem_equal(&returned_ref->irk.rpa, &addr->a, sizeof(bt_addr_t),
 					  "Incorrect address was stored by 'bt_keys_find_irk()'");
 		} else {
 			zassert_true(returned_ref == NULL,
 				     "bt_keys_find_irk() returned a non-valid reference");
 		}
 	}
 }
	/*
	* Copyright (c) 2022 Nordic Semiconductor ASA
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include "mocks/keys_help_utils.h"
	#include "mocks/rpa.h"
	#include "testing_common_defs.h"

	#include <zephyr/bluetooth/bluetooth.h>
	#include <zephyr/fff.h>
	#include <zephyr/kernel.h>

	#include <host/keys.h>

	DEFINE_FFF_GLOBALS;

	/* This LUT contains different combinations of ID, Address and key type.
	* Item in this list will be used to fill keys pool.
	*/
	static const struct id_addr_type testing_id_addr_type_lut[] = {

	{BT_ADDR_ID_1, BT_ADDR_LE_1, BT_KEYS_PERIPH_LTK},
	{BT_ADDR_ID_1, BT_RPA_ADDR_LE_1, BT_KEYS_PERIPH_LTK},
	{BT_ADDR_ID_1, BT_RPA_ADDR_LE_2, BT_KEYS_IRK},
	{BT_ADDR_ID_1, BT_ADDR_LE_3, BT_KEYS_IRK},

	{BT_ADDR_ID_2, BT_ADDR_LE_1, BT_KEYS_LTK},
	{BT_ADDR_ID_2, BT_RPA_ADDR_LE_3, BT_KEYS_IRK},
	{BT_ADDR_ID_2, BT_RPA_ADDR_LE_4, BT_KEYS_IRK},
	{BT_ADDR_ID_2, BT_ADDR_LE_2, BT_KEYS_LOCAL_CSRK},

	{BT_ADDR_ID_3, BT_ADDR_LE_1, BT_KEYS_REMOTE_CSRK},
	{BT_ADDR_ID_3, BT_ADDR_LE_2, BT_KEYS_LTK_P256},

	{BT_ADDR_ID_4, BT_ADDR_LE_1, BT_KEYS_ALL}};

	/* Global iterator to iterate over the ID, Address and type LUT */
	static uint8_t params_it;

	/* Pointer to the current set of testing parameters */
	static struct id_addr_type const *current_params_vector;

	/* This list will hold returned references while filling keys pool */
	static struct bt_keys *returned_keys_refs[CONFIG_BT_MAX_PAIRED];

	BUILD_ASSERT(ARRAY_SIZE(testing_id_addr_type_lut) == CONFIG_BT_MAX_PAIRED);
	BUILD_ASSERT(ARRAY_SIZE(testing_id_addr_type_lut) == ARRAY_SIZE(returned_keys_refs));

	/* Check if a Bluetooth LE random address is resolvable private address. */
	#define BT_ADDR_IS_RPA(a) (((a)->val[5] & 0xc0) == 0x40)

	static bool check_if_addr_is_rpa(const bt_addr_le_t *addr)
	{
	if (addr->type != BT_ADDR_LE_RANDOM) {
	return false;
	}

	return BT_ADDR_IS_RPA(&addr->a);
	}

	static bool bt_rpa_irk_matches_unreachable_custom_fake(const uint8_t irk[16], const bt_addr_t *addr)
	{
	zassert_unreachable("Unexpected call to 'bt_rpa_irk_matches()' occurred");
	return true;
	}

	static bool bt_rpa_irk_matches_custom_fake(const uint8_t irk[16], const bt_addr_t *addr)
	{
	if (irk[0] != (params_it) && !bt_addr_cmp(&current_params_vector->addr->a, addr)) {
	return false;
	}

	return true;
	}

	static void *empty_list_ts_setup(void)
	{
	clear_key_pool();

	return NULL;
	}

	ZTEST_SUITE(bt_keys_find_irk_initially_empty_list, NULL, empty_list_ts_setup, NULL, NULL, NULL);

	/*
	* Find a non-existing key reference for ID and Address of type 'BT_KEYS_IRK'
	*
	* Constraints:
	* - Empty keys pool list
	*
	* Expected behaviour:
	* - A NULL value is returned
	*/
	ZTEST(bt_keys_find_irk_initially_empty_list, test_find_non_existing_key_reference)
	{
	uint8_t id;
	const bt_addr_le_t *addr;
	struct bt_keys *returned_ref;
	struct id_addr_type const *params_vector;

	for (size_t i = 0; i < ARRAY_SIZE(testing_id_addr_type_lut); i++) {

	params_vector = &testing_id_addr_type_lut[i];
	id = params_vector->id;
	addr = params_vector->addr;

	returned_ref = bt_keys_find_irk(id, addr);

	zassert_true(returned_ref == NULL,
	"bt_keys_find_irk() returned a non-valid reference");
	}
	}

	static void rpa_resolving_ts_setup(void *f)
	{
	clear_key_pool();
	int rv = fill_key_pool_by_id_addr_type(
	testing_id_addr_type_lut, ARRAY_SIZE(testing_id_addr_type_lut), returned_keys_refs);

	zassert_true(rv == 0, "Failed to fill keys pool list, error code %d", -rv);

	/* Set the index to the IRK value to recognize row index during bt_rpa_irk_matches()
	* callback
	*/
	for (size_t it = 0; it < ARRAY_SIZE(returned_keys_refs); it++) {
	returned_keys_refs[it]->irk.val[0] = it;
	}

	RPA_FFF_FAKES_LIST(RESET_FAKE);
	}

	ZTEST_SUITE(bt_keys_find_irk_rpa_resolving, NULL, NULL, rpa_resolving_ts_setup, NULL, NULL);

	/*
	* Try to resolve an RPA address using IRK by finding an existing key reference for ID and Address
	* of type 'BT_KEYS_IRK'. Matching the address with existing IRKs fails.
	*
	* Constraints:
	* - Full keys pool list
	* - IRK value and device address don't match
	*
	* Expected behaviour:
	* - A NULL value is returned
	*/
	ZTEST(bt_keys_find_irk_rpa_resolving, test_resolving_rpa_address_by_irk_but_matching_fails)
	{
	uint8_t id;
	const bt_addr_le_t *addr;
	struct bt_keys *returned_ref;
	struct id_addr_type const *params_vector;

	bt_rpa_irk_matches_fake.return_val = false;

	for (size_t i = 0; i < ARRAY_SIZE(testing_id_addr_type_lut); i++) {

	params_vector = &testing_id_addr_type_lut[i];
	id = params_vector->id;
	addr = params_vector->addr;

	returned_ref = bt_keys_find_irk(id, addr);

	zassert_true(returned_ref == NULL,
	"bt_keys_find_irk() returned a non-valid reference");
	}
	}

	/*
	* Try to resolve an RPA address using IRK by finding an existing key reference for ID and Address
	* of type 'BT_KEYS_IRK'. Matching the address with existing IRKs fails.
	*
	* Constraints:
	* - Full keys pool list
	* - IRK value and device address match
	*
	* Expected behaviour:
	* - A valid reference value is returned
	*/
	ZTEST(bt_keys_find_irk_rpa_resolving, test_resolving_rpa_address_by_irk_and_matching_succeeds)
	{
	int type;
	uint8_t id;
	const bt_addr_le_t *addr;
	struct id_addr_type const *params_vector;
	struct bt_keys returned_ref, expected_key_ref;

	bt_rpa_irk_matches_fake.custom_fake = bt_rpa_irk_matches_custom_fake;

	for (size_t it = 0; it < ARRAY_SIZE(testing_id_addr_type_lut); it++) {

	params_vector = &testing_id_addr_type_lut[it];
	type = params_vector->type;
	id = params_vector->id;
	addr = params_vector->addr;

	/* Set global variables to be used within bt_rpa_irk_matches_custom_fake() */
	params_it = it;
	current_params_vector = params_vector;

	expected_key_ref = returned_keys_refs[it];

	/*
	* Try to resolve the current testing vector address.
	* Address will be considered resolvable if:
	* - The current testing vector address is an RPA
	* - The current testing vector key type is an IRK
	*/
	returned_ref = bt_keys_find_irk(id, addr);

	if (check_if_addr_is_rpa(addr) && (type & BT_KEYS_IRK)) {

	zassert_true(returned_ref != NULL,
	"bt_keys_find_irk() returned a NULL reference %d", it);

	zassert_equal_ptr(returned_ref, expected_key_ref,
	"bt_keys_find_irk() returned unexpected reference");

	/* Check if address has been stored */
	zassert_mem_equal(&returned_ref->irk.rpa, &addr->a, sizeof(bt_addr_t),
	"Incorrect address was stored by 'bt_keys_find_irk()'");
	} else {
	zassert_true(returned_ref == NULL,
	"bt_keys_find_irk() returned a non-valid reference %d", it);
	}
	}
	}

	static void *no_resolving_ts_setup(void)
	{
	int type;
	const bt_addr_le_t *addr;
	struct id_addr_type const *params_vector;

	clear_key_pool();
	int rv = fill_key_pool_by_id_addr_type(
	testing_id_addr_type_lut, ARRAY_SIZE(testing_id_addr_type_lut), returned_keys_refs);

	zassert_true(rv == 0, "Failed to fill keys pool list, error code %d", -rv);

	/* Set the index to the IRK value to recognize row index during bt_rpa_irk_matches()
	* callback
	*/
	for (size_t it = 0; it < ARRAY_SIZE(returned_keys_refs); it++) {
	returned_keys_refs[it]->irk.val[0] = it;
	}

	/* Copy the address as if was previously resolved using IRK */
	for (size_t it = 0; it < ARRAY_SIZE(returned_keys_refs); it++) {

	params_vector = &testing_id_addr_type_lut[it];
	type = params_vector->type;
	addr = params_vector->addr;

	if (check_if_addr_is_rpa(addr) && (type & BT_KEYS_IRK)) {
	bt_addr_copy(&returned_keys_refs[it]->irk.rpa, &addr->a);
	}
	}

	return NULL;
	}

	ZTEST_SUITE(bt_keys_find_irk_no_resolving, NULL, no_resolving_ts_setup, NULL, NULL, NULL);

	/*
	* Find an existing key reference for ID and Address of type 'BT_KEYS_IRK'
	* while the address has been resolved previously using the IRK
	*
	* Constraints:
	* - Full keys pool list
	* - IRK address and device address match
	*
	* Expected behaviour:
	* - A valid reference value is returned
	*/
	ZTEST(bt_keys_find_irk_no_resolving, test_find_key_of_previously_resolved_address)
	{
	int type;
	uint8_t id;
	const bt_addr_le_t *addr;
	struct id_addr_type const *params_vector;
	struct bt_keys returned_ref, expected_key_ref;

	for (size_t it = 0; it < ARRAY_SIZE(testing_id_addr_type_lut); it++) {

	params_vector = &testing_id_addr_type_lut[it];
	type = params_vector->type;
	id = params_vector->id;
	addr = params_vector->addr;

	/* Set global variables to be used within bt_rpa_irk_matches_custom_fake() */
	params_it = it;
	current_params_vector = params_vector;

	/*
	* Now, as the address under test should have been resolved before,
	* bt_rpa_irk_matches() isn't expected to be called for an RPA.
	*
	* But, for other records, which won't be resolved, a call to bt_rpa_irk_matches()
	* is expected simulating the attempt to resolve it
	*/
	if (check_if_addr_is_rpa(addr) && (type & BT_KEYS_IRK)) {
	bt_rpa_irk_matches_fake.custom_fake =
	bt_rpa_irk_matches_unreachable_custom_fake;
	} else {
	bt_rpa_irk_matches_fake.custom_fake = bt_rpa_irk_matches_custom_fake;
	}

	expected_key_ref = returned_keys_refs[it];

	returned_ref = bt_keys_find_irk(id, addr);

	if (check_if_addr_is_rpa(addr) && (type & BT_KEYS_IRK)) {

	zassert_true(returned_ref != NULL,
	"bt_keys_find_irk() returned a NULL reference");
	zassert_equal_ptr(returned_ref, expected_key_ref,
	"bt_keys_find_irk() returned unexpected reference");

	/* Check if address has been stored */
	zassert_mem_equal(&returned_ref->irk.rpa, &addr->a, sizeof(bt_addr_t),
	"Incorrect address was stored by 'bt_keys_find_irk()'");
	} else {
	zassert_true(returned_ref == NULL,
	"bt_keys_find_irk() returned a non-valid reference");
	}
	}
	}