Repository: incubator-mynewt-core Updated Branches: refs/heads/develop 5fe4de767 -> 4e16b9ade
BLE Host - rename store ltk to sec. Project: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/commit/4e16b9ad Tree: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/tree/4e16b9ad Diff: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/diff/4e16b9ad Branch: refs/heads/develop Commit: 4e16b9adef41636af13d409bf78d1a4aeda3ef32 Parents: 5fe4de7 Author: Christopher Collins <[email protected]> Authored: Wed May 25 15:37:51 2016 -0700 Committer: Christopher Collins <[email protected]> Committed: Wed May 25 18:16:06 2016 -0700 ---------------------------------------------------------------------- apps/bleprph/src/store.c | 175 +++++++++++++------ apps/bletiny/src/store.c | 165 +++++++++-------- net/nimble/host/include/host/ble_gap.h | 17 -- net/nimble/host/include/host/ble_store.h | 47 ++--- net/nimble/host/src/ble_l2cap_sm.c | 134 ++++++++------ net/nimble/host/src/ble_l2cap_sm_cmd.c | 2 +- net/nimble/host/src/ble_store.c | 40 ++--- .../host/src/test/ble_hs_test_util_store.c | 108 ++++++------ net/nimble/host/src/test/ble_l2cap_sm_test.c | 62 ++++--- 9 files changed, 425 insertions(+), 325 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/apps/bleprph/src/store.c ---------------------------------------------------------------------- diff --git a/apps/bleprph/src/store.c b/apps/bleprph/src/store.c index e80a625..d1b315c 100644 --- a/apps/bleprph/src/store.c +++ b/apps/bleprph/src/store.c @@ -36,72 +36,89 @@ #include "bleprph.h" #define STORE_MAX_SLV_LTKS 4 +#define STORE_MAX_MST_LTKS 4 #define STORE_MAX_CCCDS 16 -static struct ble_store_value_ltk store_slv_ltks[STORE_MAX_SLV_LTKS]; -static int store_num_slv_ltks; +static struct ble_store_value_sec store_slv_secs[STORE_MAX_SLV_LTKS]; +static int store_num_slv_secs; + +static struct ble_store_value_sec store_mst_secs[STORE_MAX_MST_LTKS]; +static int store_num_mst_secs; static struct ble_store_value_cccd store_cccds[STORE_MAX_CCCDS]; static int store_num_cccds; /***************************************************************************** - * $ltk * + * $sec * *****************************************************************************/ static void -store_print_value_ltk(struct ble_store_value_ltk *ltk) +store_print_value_sec(struct ble_store_value_sec *sec) { - BLEPRPH_LOG(INFO, "ediv=%u rand=%llu authenticated=%d ", ltk->ediv, - ltk->rand_num, ltk->authenticated); - BLEPRPH_LOG(INFO, "ltk="); - print_bytes(ltk->key, 16); + if (sec->ltk_present) { + BLEPRPH_LOG(INFO, "ediv=%u rand=%llu authenticated=%d ltk=", + sec->ediv, sec->rand_num, sec->authenticated); + print_bytes(sec->ltk, 16); + BLEPRPH_LOG(INFO, " "); + } + if (sec->irk_present) { + BLEPRPH_LOG(INFO, "irk="); + print_bytes(sec->irk, 16); + BLEPRPH_LOG(INFO, " "); + } + if (sec->csrk_present) { + BLEPRPH_LOG(INFO, "csrk="); + print_bytes(sec->csrk, 16); + BLEPRPH_LOG(INFO, " "); + } + BLEPRPH_LOG(INFO, "\n"); } static void -store_print_key_ltk(struct ble_store_key_ltk *key_ltk) +store_print_key_sec(struct ble_store_key_sec *key_sec) { - if (key_ltk->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) { + if (key_sec->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) { BLEPRPH_LOG(INFO, "peer_addr_type=%d peer_addr=", - key_ltk->peer_addr_type); - print_bytes(key_ltk->peer_addr, 6); + key_sec->peer_addr_type); + print_bytes(key_sec->peer_addr, 6); BLEPRPH_LOG(INFO, " "); } - if (key_ltk->ediv_present) { - BLEPRPH_LOG(INFO, "ediv=0x%02x ", key_ltk->ediv); - } - if (key_ltk->rand_num_present) { - BLEPRPH_LOG(INFO, "rand=0x%llx ", key_ltk->rand_num); + if (key_sec->ediv_rand_present) { + BLEPRPH_LOG(INFO, "ediv=0x%02x rand=0x%llx ", + key_sec->ediv, key_sec->rand_num); } } static int -store_find_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltks, int num_value_ltks) +store_find_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_secs, int num_value_secs) { - struct ble_store_value_ltk *cur; + struct ble_store_value_sec *cur; int i; - for (i = 0; i < num_value_ltks; i++) { - cur = value_ltks + i; + for (i = 0; i < num_value_secs; i++) { + cur = value_secs + i; - if (key_ltk->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) { - if (cur->peer_addr_type != key_ltk->peer_addr_type) { + if (key_sec->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) { + if (cur->peer_addr_type != key_sec->peer_addr_type) { continue; } - if (memcmp(cur->peer_addr, key_ltk->peer_addr, + if (memcmp(cur->peer_addr, key_sec->peer_addr, sizeof cur->peer_addr) != 0) { continue; } } - if (key_ltk->ediv_present && cur->ediv != key_ltk->ediv) { - continue; - } + if (key_sec->ediv_rand_present) { + if (cur->ediv != key_sec->ediv) { + continue; + } - if (key_ltk->rand_num_present && cur->rand_num != key_ltk->rand_num) { - continue; + if (cur->rand_num != key_sec->rand_num) { + continue; + } } return i; @@ -111,43 +128,84 @@ store_find_ltk(struct ble_store_key_ltk *key_ltk, } static int -store_read_slv_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltk) +store_read_slv_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_sec) +{ + int idx; + + idx = store_find_sec(key_sec, store_slv_secs, store_num_slv_secs); + if (idx == -1) { + return BLE_HS_ENOENT; + } + + *value_sec = store_slv_secs[idx]; + return 0; +} + +static int +store_write_slv_sec(struct ble_store_value_sec *value_sec) { + struct ble_store_key_sec key_sec; int idx; - idx = store_find_ltk(key_ltk, store_slv_ltks, store_num_slv_ltks); + BLEPRPH_LOG(INFO, "persisting slv sec; "); + store_print_value_sec(value_sec); + + ble_store_key_from_value_sec(&key_sec, value_sec); + idx = store_find_sec(&key_sec, store_slv_secs, store_num_slv_secs); + if (idx == -1) { + if (store_num_slv_secs >= STORE_MAX_SLV_LTKS) { + BLEPRPH_LOG(INFO, "error persisting slv sec; too many entries " + "(%d)\n", store_num_slv_secs); + return BLE_HS_ENOMEM; + } + + idx = store_num_slv_secs; + store_num_slv_secs++; + } + + store_slv_secs[idx] = *value_sec; + return 0; +} + +static int +store_read_mst_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_sec) +{ + int idx; + + idx = store_find_sec(key_sec, store_mst_secs, store_num_mst_secs); if (idx == -1) { return BLE_HS_ENOENT; } - *value_ltk = store_slv_ltks[idx]; + *value_sec = store_mst_secs[idx]; return 0; } static int -store_write_slv_ltk(struct ble_store_value_ltk *value_ltk) +store_write_mst_sec(struct ble_store_value_sec *value_sec) { - struct ble_store_key_ltk key_ltk; + struct ble_store_key_sec key_sec; int idx; - BLEPRPH_LOG(INFO, "persisting slv ltk; "); - store_print_value_ltk(value_ltk); + BLEPRPH_LOG(INFO, "persisting mst sec; "); + store_print_value_sec(value_sec); - ble_store_key_from_value_ltk(&key_ltk, value_ltk); - idx = store_find_ltk(&key_ltk, store_slv_ltks, store_num_slv_ltks); + ble_store_key_from_value_sec(&key_sec, value_sec); + idx = store_find_sec(&key_sec, store_mst_secs, store_num_mst_secs); if (idx == -1) { - if (store_num_slv_ltks >= STORE_MAX_SLV_LTKS) { - BLEPRPH_LOG(INFO, "error persisting slv ltk; too many entries " - "(%d)\n", store_num_slv_ltks); + if (store_num_mst_secs >= STORE_MAX_MST_LTKS) { + BLEPRPH_LOG(INFO, "error persisting mst sec; too many entries " + "(%d)\n", store_num_mst_secs); return BLE_HS_ENOMEM; } - idx = store_num_slv_ltks; - store_num_slv_ltks++; + idx = store_num_mst_secs; + store_num_mst_secs++; } - store_slv_ltks[idx] = *value_ltk; + store_mst_secs[idx] = *value_sec; return 0; } @@ -219,7 +277,7 @@ store_write_cccd(struct ble_store_value_cccd *value_cccd) if (idx == -1) { if (store_num_cccds >= STORE_MAX_SLV_LTKS) { BLEPRPH_LOG(INFO, "error persisting cccd; too many entries (%d)\n", - store_num_cccds); + store_num_cccds); return BLE_HS_ENOMEM; } @@ -247,7 +305,7 @@ store_read(int obj_type, union ble_store_key *key, int rc; switch (obj_type) { - case BLE_STORE_OBJ_TYPE_SLV_LTK: + case BLE_STORE_OBJ_TYPE_MST_SEC: /* An encryption procedure (bonding) is being attempted. The nimble * stack is asking us to look in our key database for a long-term key * corresponding to the specified ediv and random number. @@ -256,10 +314,17 @@ store_read(int obj_type, union ble_store_key *key, * result. The nimble stack will use this key if this function returns * success. */ - BLEPRPH_LOG(INFO, "looking up slv ltk; "); - store_print_key_ltk(&key->ltk); + BLEPRPH_LOG(INFO, "looking up mst sec; "); + store_print_key_sec(&key->sec); BLEPRPH_LOG(INFO, "\n"); - rc = store_read_slv_ltk(&key->ltk, &value->ltk); + rc = store_read_mst_sec(&key->sec, &value->sec); + return rc; + + case BLE_STORE_OBJ_TYPE_SLV_SEC: + BLEPRPH_LOG(INFO, "looking up slv sec; "); + store_print_key_sec(&key->sec); + BLEPRPH_LOG(INFO, "\n"); + rc = store_read_slv_sec(&key->sec, &value->sec); return rc; case BLE_STORE_OBJ_TYPE_CCCD: @@ -283,8 +348,12 @@ store_write(int obj_type, union ble_store_value *val) int rc; switch (obj_type) { - case BLE_STORE_OBJ_TYPE_SLV_LTK: - rc = store_write_slv_ltk(&val->ltk); + case BLE_STORE_OBJ_TYPE_MST_SEC: + rc = store_write_mst_sec(&val->sec); + return rc; + + case BLE_STORE_OBJ_TYPE_SLV_SEC: + rc = store_write_slv_sec(&val->sec); return rc; case BLE_STORE_OBJ_TYPE_CCCD: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/apps/bletiny/src/store.c ---------------------------------------------------------------------- diff --git a/apps/bletiny/src/store.c b/apps/bletiny/src/store.c index b3403ae..c3a234b 100644 --- a/apps/bletiny/src/store.c +++ b/apps/bletiny/src/store.c @@ -39,73 +39,86 @@ #define STORE_MAX_MST_LTKS 4 #define STORE_MAX_CCCDS 16 -static struct ble_store_value_ltk store_slv_ltks[STORE_MAX_SLV_LTKS]; -static int store_num_slv_ltks; +static struct ble_store_value_sec store_slv_secs[STORE_MAX_SLV_LTKS]; +static int store_num_slv_secs; -static struct ble_store_value_ltk store_mst_ltks[STORE_MAX_MST_LTKS]; -static int store_num_mst_ltks; +static struct ble_store_value_sec store_mst_secs[STORE_MAX_MST_LTKS]; +static int store_num_mst_secs; static struct ble_store_value_cccd store_cccds[STORE_MAX_CCCDS]; static int store_num_cccds; /***************************************************************************** - * $ltk * + * $sec * *****************************************************************************/ static void -store_print_value_ltk(struct ble_store_value_ltk *ltk) +store_print_value_sec(struct ble_store_value_sec *sec) { - console_printf("ediv=%u rand=%llu authenticated=%d ", ltk->ediv, - ltk->rand_num, ltk->authenticated); - console_printf("ltk="); - print_bytes(ltk->key, 16); + if (sec->ltk_present) { + console_printf("ediv=%u rand=%llu authenticated=%d ltk=", + sec->ediv, sec->rand_num, sec->authenticated); + print_bytes(sec->ltk, 16); + console_printf(" "); + } + if (sec->irk_present) { + console_printf("irk="); + print_bytes(sec->irk, 16); + console_printf(" "); + } + if (sec->csrk_present) { + console_printf("csrk="); + print_bytes(sec->csrk, 16); + console_printf(" "); + } + console_printf("\n"); } static void -store_print_key_ltk(struct ble_store_key_ltk *key_ltk) +store_print_key_sec(struct ble_store_key_sec *key_sec) { - if (key_ltk->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) { + if (key_sec->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) { console_printf("peer_addr_type=%d peer_addr=", - key_ltk->peer_addr_type); - print_bytes(key_ltk->peer_addr, 6); + key_sec->peer_addr_type); + print_bytes(key_sec->peer_addr, 6); console_printf(" "); } - if (key_ltk->ediv_present) { - console_printf("ediv=0x%02x ", key_ltk->ediv); - } - if (key_ltk->rand_num_present) { - console_printf("rand=0x%llx ", key_ltk->rand_num); + if (key_sec->ediv_rand_present) { + console_printf("ediv=0x%02x rand=0x%llx ", + key_sec->ediv, key_sec->rand_num); } } static int -store_find_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltks, int num_value_ltks) +store_find_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_secs, int num_value_secs) { - struct ble_store_value_ltk *cur; + struct ble_store_value_sec *cur; int i; - for (i = 0; i < num_value_ltks; i++) { - cur = value_ltks + i; + for (i = 0; i < num_value_secs; i++) { + cur = value_secs + i; - if (key_ltk->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) { - if (cur->peer_addr_type != key_ltk->peer_addr_type) { + if (key_sec->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) { + if (cur->peer_addr_type != key_sec->peer_addr_type) { continue; } - if (memcmp(cur->peer_addr, key_ltk->peer_addr, + if (memcmp(cur->peer_addr, key_sec->peer_addr, sizeof cur->peer_addr) != 0) { continue; } } - if (key_ltk->ediv_present && cur->ediv != key_ltk->ediv) { - continue; - } + if (key_sec->ediv_rand_present) { + if (cur->ediv != key_sec->ediv) { + continue; + } - if (key_ltk->rand_num_present && cur->rand_num != key_ltk->rand_num) { - continue; + if (cur->rand_num != key_sec->rand_num) { + continue; + } } return i; @@ -115,84 +128,84 @@ store_find_ltk(struct ble_store_key_ltk *key_ltk, } static int -store_read_slv_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltk) +store_read_slv_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_sec) { int idx; - idx = store_find_ltk(key_ltk, store_slv_ltks, store_num_slv_ltks); + idx = store_find_sec(key_sec, store_slv_secs, store_num_slv_secs); if (idx == -1) { return BLE_HS_ENOENT; } - *value_ltk = store_slv_ltks[idx]; + *value_sec = store_slv_secs[idx]; return 0; } static int -store_write_slv_ltk(struct ble_store_value_ltk *value_ltk) +store_write_slv_sec(struct ble_store_value_sec *value_sec) { - struct ble_store_key_ltk key_ltk; + struct ble_store_key_sec key_sec; int idx; - console_printf("persisting slv ltk; "); - store_print_value_ltk(value_ltk); + console_printf("persisting slv sec; "); + store_print_value_sec(value_sec); - ble_store_key_from_value_ltk(&key_ltk, value_ltk); - idx = store_find_ltk(&key_ltk, store_slv_ltks, store_num_slv_ltks); + ble_store_key_from_value_sec(&key_sec, value_sec); + idx = store_find_sec(&key_sec, store_slv_secs, store_num_slv_secs); if (idx == -1) { - if (store_num_slv_ltks >= STORE_MAX_SLV_LTKS) { - console_printf("error persisting slv ltk; too many entries (%d)\n", - store_num_slv_ltks); + if (store_num_slv_secs >= STORE_MAX_SLV_LTKS) { + console_printf("error persisting slv sec; too many entries (%d)\n", + store_num_slv_secs); return BLE_HS_ENOMEM; } - idx = store_num_slv_ltks; - store_num_slv_ltks++; + idx = store_num_slv_secs; + store_num_slv_secs++; } - store_slv_ltks[idx] = *value_ltk; + store_slv_secs[idx] = *value_sec; return 0; } static int -store_read_mst_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltk) +store_read_mst_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_sec) { int idx; - idx = store_find_ltk(key_ltk, store_mst_ltks, store_num_mst_ltks); + idx = store_find_sec(key_sec, store_mst_secs, store_num_mst_secs); if (idx == -1) { return BLE_HS_ENOENT; } - *value_ltk = store_mst_ltks[idx]; + *value_sec = store_mst_secs[idx]; return 0; } static int -store_write_mst_ltk(struct ble_store_value_ltk *value_ltk) +store_write_mst_sec(struct ble_store_value_sec *value_sec) { - struct ble_store_key_ltk key_ltk; + struct ble_store_key_sec key_sec; int idx; - console_printf("persisting mst ltk; "); - store_print_value_ltk(value_ltk); + console_printf("persisting mst sec; "); + store_print_value_sec(value_sec); - ble_store_key_from_value_ltk(&key_ltk, value_ltk); - idx = store_find_ltk(&key_ltk, store_mst_ltks, store_num_mst_ltks); + ble_store_key_from_value_sec(&key_sec, value_sec); + idx = store_find_sec(&key_sec, store_mst_secs, store_num_mst_secs); if (idx == -1) { - if (store_num_mst_ltks >= STORE_MAX_MST_LTKS) { - console_printf("error persisting mst ltk; too many entries " - "(%d)\n", store_num_mst_ltks); + if (store_num_mst_secs >= STORE_MAX_MST_LTKS) { + console_printf("error persisting mst sec; too many entries " + "(%d)\n", store_num_mst_secs); return BLE_HS_ENOMEM; } - idx = store_num_mst_ltks; - store_num_mst_ltks++; + idx = store_num_mst_secs; + store_num_mst_secs++; } - store_mst_ltks[idx] = *value_ltk; + store_mst_secs[idx] = *value_sec; return 0; } @@ -292,7 +305,7 @@ store_read(int obj_type, union ble_store_key *key, int rc; switch (obj_type) { - case BLE_STORE_OBJ_TYPE_MST_LTK: + case BLE_STORE_OBJ_TYPE_MST_SEC: /* An encryption procedure (bonding) is being attempted. The nimble * stack is asking us to look in our key database for a long-term key * corresponding to the specified ediv and random number. @@ -301,17 +314,17 @@ store_read(int obj_type, union ble_store_key *key, * result. The nimble stack will use this key if this function returns * success. */ - console_printf("looking up mst ltk; "); - store_print_key_ltk(&key->ltk); + console_printf("looking up mst sec; "); + store_print_key_sec(&key->sec); console_printf("\n"); - rc = store_read_mst_ltk(&key->ltk, &value->ltk); + rc = store_read_mst_sec(&key->sec, &value->sec); return rc; - case BLE_STORE_OBJ_TYPE_SLV_LTK: - console_printf("looking up slv ltk; "); - store_print_key_ltk(&key->ltk); + case BLE_STORE_OBJ_TYPE_SLV_SEC: + console_printf("looking up slv sec; "); + store_print_key_sec(&key->sec); console_printf("\n"); - rc = store_read_slv_ltk(&key->ltk, &value->ltk); + rc = store_read_slv_sec(&key->sec, &value->sec); return rc; case BLE_STORE_OBJ_TYPE_CCCD: @@ -335,12 +348,12 @@ store_write(int obj_type, union ble_store_value *val) int rc; switch (obj_type) { - case BLE_STORE_OBJ_TYPE_MST_LTK: - rc = store_write_mst_ltk(&val->ltk); + case BLE_STORE_OBJ_TYPE_MST_SEC: + rc = store_write_mst_sec(&val->sec); return rc; - case BLE_STORE_OBJ_TYPE_SLV_LTK: - rc = store_write_slv_ltk(&val->ltk); + case BLE_STORE_OBJ_TYPE_SLV_SEC: + rc = store_write_slv_sec(&val->sec); return rc; case BLE_STORE_OBJ_TYPE_CCCD: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/net/nimble/host/include/host/ble_gap.h ---------------------------------------------------------------------- diff --git a/net/nimble/host/include/host/ble_gap.h b/net/nimble/host/include/host/ble_gap.h index 5c175c4..57dcbde 100644 --- a/net/nimble/host/include/host/ble_gap.h +++ b/net/nimble/host/include/host/ble_gap.h @@ -138,22 +138,6 @@ struct ble_gap_upd_params { uint16_t max_ce_len; }; -struct ble_gap_key_parms { - unsigned is_ours:1; - unsigned ltk_valid:1; - unsigned ediv_rand_valid:1; - unsigned irk_valid:1; - unsigned csrk_valid:1; - unsigned addr_valid:1; - uint16_t ediv; - uint64_t rand_val; - uint8_t addr_type; - uint8_t ltk[16]; - uint8_t irk[16]; - uint8_t csrk[16]; - uint8_t addr[6]; -}; - struct ble_gap_notify_params { uint16_t attr_handle; void *attr_data; @@ -219,7 +203,6 @@ struct ble_gap_conn_ctxt { } notify; struct ble_gap_ltk_params *ltk_params; - struct ble_gap_key_parms *key_params; }; }; http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/net/nimble/host/include/host/ble_store.h ---------------------------------------------------------------------- diff --git a/net/nimble/host/include/host/ble_store.h b/net/nimble/host/include/host/ble_store.h index 0b9910e..d287e57 100644 --- a/net/nimble/host/include/host/ble_store.h +++ b/net/nimble/host/include/host/ble_store.h @@ -25,14 +25,14 @@ /* XXX: Rethink our/peer distinction. Might make sense to unify keys such that * each entry contains both peers' addresses. */ -#define BLE_STORE_OBJ_TYPE_MST_LTK 1 -#define BLE_STORE_OBJ_TYPE_SLV_LTK 2 +#define BLE_STORE_OBJ_TYPE_MST_SEC 1 +#define BLE_STORE_OBJ_TYPE_SLV_SEC 2 #define BLE_STORE_OBJ_TYPE_CCCD 3 #define BLE_STORE_ADDR_TYPE_NONE 0xff #define BLE_STORE_AUTHREQ_NONE 0xff -struct ble_store_key_ltk { +struct ble_store_key_sec { /** * Key by peer identity address; * peer_addr_type=BLE_STORE_ADDR_TYPE_NONE means don't key off peer. @@ -40,25 +40,32 @@ struct ble_store_key_ltk { uint8_t peer_addr[6]; uint8_t peer_addr_type; - /** Key by ediv; ediv_present=0 means don't key off ediv. */ + /** Key by ediv; ediv_rand_present=0 means don't key off ediv. */ uint16_t ediv; - unsigned ediv_present:1; - /** Key by rand_num; rand_num_present=0 means don't key off rand_num. */ + /** Key by rand_num; ediv_rand_present=0 means don't key off rand_num. */ uint64_t rand_num; - unsigned rand_num_present:1; + + unsigned ediv_rand_present:1; }; -struct ble_store_value_ltk { +struct ble_store_value_sec { uint8_t peer_addr[6]; uint8_t peer_addr_type; + uint16_t ediv; uint64_t rand_num; - uint8_t key[16]; + uint8_t ltk[16]; + unsigned ltk_present:1; + + uint8_t irk[16]; + unsigned irk_present:1; + + uint8_t csrk[16]; + unsigned csrk_present:1; unsigned authenticated:1; unsigned sc:1; - }; struct ble_store_key_cccd { @@ -88,12 +95,12 @@ struct ble_store_value_cccd { }; union ble_store_key { - struct ble_store_key_ltk ltk; + struct ble_store_key_sec sec; struct ble_store_key_cccd cccd; }; union ble_store_value { - struct ble_store_value_ltk ltk; + struct ble_store_value_sec sec; struct ble_store_value_cccd cccd; }; @@ -109,20 +116,20 @@ int ble_store_read(int obj_type, union ble_store_key *key, int ble_store_write(int obj_type, union ble_store_value *val); int ble_store_delete(int obj_type, union ble_store_key *key); -int ble_store_read_slv_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltk); -int ble_store_write_slv_ltk(struct ble_store_value_ltk *value_ltk); -int ble_store_read_mst_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltk); -int ble_store_write_mst_ltk(struct ble_store_value_ltk *value_ltk); +int ble_store_read_slv_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_sec); +int ble_store_write_slv_sec(struct ble_store_value_sec *value_sec); +int ble_store_read_mst_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_sec); +int ble_store_write_mst_sec(struct ble_store_value_sec *value_sec); int ble_store_read_cccd(struct ble_store_key_cccd *key, struct ble_store_value_cccd *out_value); int ble_store_write_cccd(struct ble_store_value_cccd *value); int ble_store_delete_cccd(struct ble_store_key_cccd *key); -void ble_store_key_from_value_ltk(struct ble_store_key_ltk *out_key, - struct ble_store_value_ltk *value); +void ble_store_key_from_value_sec(struct ble_store_key_sec *out_key, + struct ble_store_value_sec *value); void ble_store_key_from_value_cccd(struct ble_store_key_cccd *out_key, struct ble_store_value_cccd *value); http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/net/nimble/host/src/ble_l2cap_sm.c ---------------------------------------------------------------------- diff --git a/net/nimble/host/src/ble_l2cap_sm.c b/net/nimble/host/src/ble_l2cap_sm.c index a16ad55..1f04247 100644 --- a/net/nimble/host/src/ble_l2cap_sm.c +++ b/net/nimble/host/src/ble_l2cap_sm.c @@ -79,6 +79,21 @@ typedef uint16_t ble_l2cap_sm_proc_flags; +struct ble_l2cap_sm_keys { + unsigned ltk_valid:1; + unsigned ediv_rand_valid:1; + unsigned irk_valid:1; + unsigned csrk_valid:1; + unsigned addr_valid:1; + uint16_t ediv; + uint64_t rand_val; + uint8_t addr_type; + uint8_t ltk[16]; + uint8_t irk[16]; + uint8_t csrk[16]; + uint8_t addr[6]; +}; + struct ble_l2cap_sm_proc { STAILQ_ENTRY(ble_l2cap_sm_proc) next; @@ -99,8 +114,8 @@ struct ble_l2cap_sm_proc { uint8_t ltk[16]; /* this may be temporary, but we keep the keys here for now */ - struct ble_gap_key_parms our_keys; - struct ble_gap_key_parms peer_keys; + struct ble_l2cap_sm_keys our_keys; + struct ble_l2cap_sm_keys peer_keys; }; STAILQ_HEAD(ble_l2cap_sm_proc_list, ble_l2cap_sm_proc); @@ -479,12 +494,45 @@ ble_l2cap_sm_sec_state(struct ble_l2cap_sm_proc *proc, } static void +ble_l2cap_sm_fill_store_value(uint8_t peer_addr_type, uint8_t *peer_addr, + int authenticated, + struct ble_l2cap_sm_keys *keys, + struct ble_store_value_sec *value_sec) +{ + memset(value_sec, 0, sizeof *value_sec); + + if (keys->ediv_rand_valid && keys->ltk_valid) { + value_sec->peer_addr_type = peer_addr_type; + memcpy(value_sec->peer_addr, peer_addr, sizeof value_sec->peer_addr); + value_sec->ediv = keys->ediv; + value_sec->rand_num = keys->rand_val; + + memcpy(value_sec->ltk, keys->ltk, sizeof value_sec->ltk); + value_sec->ltk_present = 1; + + value_sec->authenticated = authenticated; + value_sec->sc = 0; + } + + if (keys->irk_valid) { + memcpy(value_sec->irk, keys->irk, sizeof value_sec->irk); + value_sec->irk_present = 1; + } + + if (keys->csrk_valid) { + memcpy(value_sec->csrk, keys->csrk, sizeof value_sec->csrk); + value_sec->csrk_present = 1; + } +} + +static void ble_l2cap_sm_key_exchange_events(struct ble_l2cap_sm_proc *proc) { - struct ble_store_value_ltk value_ltk; + struct ble_store_value_sec value_sec; struct ble_hs_conn *conn; uint8_t peer_addr[8]; uint8_t peer_addr_type; + int authenticated; ble_hs_lock(); @@ -496,35 +544,15 @@ ble_l2cap_sm_key_exchange_events(struct ble_l2cap_sm_proc *proc) ble_hs_unlock(); - if (proc->our_keys.ediv_rand_valid && proc->our_keys.ltk_valid) { - value_ltk.peer_addr_type = peer_addr_type; - memcpy(value_ltk.peer_addr, peer_addr, sizeof value_ltk.peer_addr); - value_ltk.ediv = proc->our_keys.ediv; - value_ltk.rand_num = proc->our_keys.rand_val; - memcpy(value_ltk.key, proc->our_keys.ltk, - sizeof value_ltk.key); - value_ltk.authenticated = - !!(proc->flags & BLE_L2CAP_SM_PROC_F_AUTHENTICATED); - value_ltk.sc = 0; + authenticated = !!(proc->flags & BLE_L2CAP_SM_PROC_F_AUTHENTICATED); - ble_store_write_slv_ltk(&value_ltk); - } - - if (proc->peer_keys.ediv_rand_valid && proc->peer_keys.ltk_valid) { - value_ltk.peer_addr_type = peer_addr_type; - memcpy(value_ltk.peer_addr, peer_addr, sizeof value_ltk.peer_addr); - value_ltk.ediv = proc->peer_keys.ediv; - value_ltk.rand_num = proc->peer_keys.rand_val; - memcpy(value_ltk.key, proc->peer_keys.ltk, - sizeof value_ltk.key); - value_ltk.authenticated = - !!(proc->flags & BLE_L2CAP_SM_PROC_F_AUTHENTICATED); - value_ltk.sc = 0; + ble_l2cap_sm_fill_store_value(peer_addr_type, peer_addr, authenticated, + &proc->our_keys, &value_sec); + ble_store_write_slv_sec(&value_sec); - ble_store_write_mst_ltk(&value_ltk); - } - - /* XXX: Persist other key data. */ + ble_l2cap_sm_fill_store_value(peer_addr_type, peer_addr, authenticated, + &proc->peer_keys, &value_sec); + ble_store_write_mst_sec(&value_sec); } static void @@ -1502,6 +1530,9 @@ ble_l2cap_sm_rx_key_exchange(uint16_t conn_handle, uint8_t op, break; } + BLE_HS_LOG(DEBUG, "op=%d rx_key_flags=0x%02x\n", + op, proc->rx_key_flags); + /* did we finish RX keys */ rc = 0; if (!proc->rx_key_flags) { @@ -1780,8 +1811,8 @@ ble_l2cap_sm_rx_pair_fail(uint16_t conn_handle, uint8_t op, static int ble_l2cap_sm_lt_key_req_ltk_handle(struct hci_le_lt_key_req *evt) { - struct ble_store_value_ltk value_ltk; - struct ble_store_key_ltk key_ltk; + struct ble_store_value_sec value_sec; + struct ble_store_key_sec key_sec; struct ble_l2cap_sm_proc *proc; struct ble_l2cap_sm_proc *prev; int store_rc; @@ -1789,17 +1820,16 @@ ble_l2cap_sm_lt_key_req_ltk_handle(struct hci_le_lt_key_req *evt) /* Tell applicaiton to look up LTK by ediv/rand pair. */ /* XXX: Also filter by peer address? */ - memset(&key_ltk, 0, sizeof key_ltk); - key_ltk.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE; - key_ltk.ediv = evt->encrypted_diversifier; - key_ltk.ediv_present = 1; - key_ltk.rand_num = evt->random_number; - key_ltk.rand_num_present = 1; - store_rc = ble_store_read_slv_ltk(&key_ltk, &value_ltk); + memset(&key_sec, 0, sizeof key_sec); + key_sec.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE; + key_sec.ediv = evt->encrypted_diversifier; + key_sec.rand_num = evt->random_number; + key_sec.ediv_rand_present = 1; + store_rc = ble_store_read_slv_sec(&key_sec, &value_sec); if (store_rc == 0) { /* Store provided a key; send it to the controller. */ rc = ble_l2cap_sm_lt_key_req_reply_tx(evt->connection_handle, - value_ltk.key); + value_sec.ltk); } else { /* Application does not have the requested key in its database. Send a * negative reply to the controller. @@ -1815,7 +1845,7 @@ ble_l2cap_sm_lt_key_req_ltk_handle(struct hci_le_lt_key_req *evt) rc = BLE_HS_EUNKNOWN; } else if (store_rc == 0 && rc == 0) { proc->state = BLE_L2CAP_SM_PROC_STATE_ENC_CHANGE; - if (value_ltk.authenticated) { + if (value_sec.authenticated) { proc->flags |= BLE_L2CAP_SM_PROC_F_AUTHENTICATED; } } else { @@ -1954,8 +1984,8 @@ static int ble_l2cap_sm_rx_sec_req(uint16_t conn_handle, uint8_t op, struct os_mbuf **om) { struct ble_l2cap_sm_sec_req cmd; - struct ble_store_value_ltk value_ltk; - struct ble_store_key_ltk key_ltk; + struct ble_store_value_sec value_sec; + struct ble_store_key_sec key_sec; struct ble_hs_conn *conn; int authreq_mitm; int rc; @@ -1989,9 +2019,9 @@ ble_l2cap_sm_rx_sec_req(uint16_t conn_handle, uint8_t op, struct os_mbuf **om) * sender; remember the sender's address while the connection list is * locked. */ - memset(&key_ltk, 0, sizeof key_ltk); - key_ltk.peer_addr_type = conn->bhc_addr_type; - memcpy(key_ltk.peer_addr, conn->bhc_addr, 6); + memset(&key_sec, 0, sizeof key_sec); + key_sec.peer_addr_type = conn->bhc_addr_type; + memcpy(key_sec.peer_addr, conn->bhc_addr, 6); } ble_hs_unlock(); @@ -2000,23 +2030,23 @@ ble_l2cap_sm_rx_sec_req(uint16_t conn_handle, uint8_t op, struct os_mbuf **om) /* Query database for an LTK corresonding to the sender. We are the * master, so retrieve a master key. */ - rc = ble_store_read_mst_ltk(&key_ltk, &value_ltk); + rc = ble_store_read_mst_sec(&key_sec, &value_sec); if (rc == 0) { /* Found a key corresponding to this peer. Make sure it meets the * requested minimum authreq. */ authreq_mitm = cmd.authreq & BLE_L2CAP_SM_PAIR_AUTHREQ_MITM; - if ((!authreq_mitm && value_ltk.authenticated) || - (authreq_mitm && !value_ltk.authenticated)) { + if ((!authreq_mitm && value_sec.authenticated) || + (authreq_mitm && !value_sec.authenticated)) { rc = BLE_HS_EREJECT; } } if (rc == 0) { - rc = ble_l2cap_sm_enc_initiate(conn_handle, value_ltk.key, - value_ltk.ediv, value_ltk.rand_num, - value_ltk.authenticated); + rc = ble_l2cap_sm_enc_initiate(conn_handle, value_sec.ltk, + value_sec.ediv, value_sec.rand_num, + value_sec.authenticated); } else { rc = ble_l2cap_sm_pair_initiate(conn_handle); } http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/net/nimble/host/src/ble_l2cap_sm_cmd.c ---------------------------------------------------------------------- diff --git a/net/nimble/host/src/ble_l2cap_sm_cmd.c b/net/nimble/host/src/ble_l2cap_sm_cmd.c index ced4c1c..035d9e3 100644 --- a/net/nimble/host/src/ble_l2cap_sm_cmd.c +++ b/net/nimble/host/src/ble_l2cap_sm_cmd.c @@ -461,7 +461,7 @@ ble_l2cap_sm_signing_info_tx(uint16_t conn_handle, goto done; } - txom->om_data[0] = BLE_L2CAP_SM_OP_IDENTITY_INFO; + txom->om_data[0] = BLE_L2CAP_SM_OP_SIGN_INFO; memcpy(txom->om_data + 1, cmd->sig_key_le, sizeof cmd->sig_key_le); rc = ble_l2cap_sm_tx(conn_handle, txom); txom = NULL; http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/net/nimble/host/src/ble_store.c ---------------------------------------------------------------------- diff --git a/net/nimble/host/src/ble_store.c b/net/nimble/host/src/ble_store.c index 91e7fb5..05f1278 100644 --- a/net/nimble/host/src/ble_store.c +++ b/net/nimble/host/src/ble_store.c @@ -66,52 +66,52 @@ ble_store_delete(int obj_type, union ble_store_key *key) } int -ble_store_read_slv_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltk) +ble_store_read_slv_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_sec) { union ble_store_value *store_value; union ble_store_key *store_key; int rc; - store_key = (void *)key_ltk; - store_value = (void *)value_ltk; - rc = ble_store_read(BLE_STORE_OBJ_TYPE_SLV_LTK, store_key, store_value); + store_key = (void *)key_sec; + store_value = (void *)value_sec; + rc = ble_store_read(BLE_STORE_OBJ_TYPE_SLV_SEC, store_key, store_value); return rc; } int -ble_store_write_slv_ltk(struct ble_store_value_ltk *value_ltk) +ble_store_write_slv_sec(struct ble_store_value_sec *value_sec) { union ble_store_value *store_value; int rc; - store_value = (void *)value_ltk; - rc = ble_store_write(BLE_STORE_OBJ_TYPE_SLV_LTK, store_value); + store_value = (void *)value_sec; + rc = ble_store_write(BLE_STORE_OBJ_TYPE_SLV_SEC, store_value); return rc; } int -ble_store_read_mst_ltk(struct ble_store_key_ltk *key_ltk, - struct ble_store_value_ltk *value_ltk) +ble_store_read_mst_sec(struct ble_store_key_sec *key_sec, + struct ble_store_value_sec *value_sec) { union ble_store_value *store_value; union ble_store_key *store_key; int rc; - store_key = (void *)key_ltk; - store_value = (void *)value_ltk; - rc = ble_store_read(BLE_STORE_OBJ_TYPE_MST_LTK, store_key, store_value); + store_key = (void *)key_sec; + store_value = (void *)value_sec; + rc = ble_store_read(BLE_STORE_OBJ_TYPE_MST_SEC, store_key, store_value); return rc; } int -ble_store_write_mst_ltk(struct ble_store_value_ltk *value_ltk) +ble_store_write_mst_sec(struct ble_store_value_sec *value_sec) { union ble_store_value *store_value; int rc; - store_value = (void *)value_ltk; - rc = ble_store_write(BLE_STORE_OBJ_TYPE_MST_LTK, store_value); + store_value = (void *)value_sec; + rc = ble_store_write(BLE_STORE_OBJ_TYPE_MST_SEC, store_value); return rc; } @@ -162,15 +162,13 @@ ble_store_key_from_value_cccd(struct ble_store_key_cccd *out_key, } void -ble_store_key_from_value_ltk(struct ble_store_key_ltk *out_key, - struct ble_store_value_ltk *value) +ble_store_key_from_value_sec(struct ble_store_key_sec *out_key, + struct ble_store_value_sec *value) { out_key->peer_addr_type = value->peer_addr_type; memcpy(out_key->peer_addr, value->peer_addr, sizeof out_key->peer_addr); out_key->ediv = value->ediv; - out_key->ediv_present = 1; - out_key->rand_num = value->rand_num; - out_key->rand_num_present = 1; + out_key->ediv_rand_present = 1; } http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/net/nimble/host/src/test/ble_hs_test_util_store.c ---------------------------------------------------------------------- diff --git a/net/nimble/host/src/test/ble_hs_test_util_store.c b/net/nimble/host/src/test/ble_hs_test_util_store.c index a466f42..6522758 100644 --- a/net/nimble/host/src/test/ble_hs_test_util_store.c +++ b/net/nimble/host/src/test/ble_hs_test_util_store.c @@ -23,15 +23,15 @@ #include "ble_hs_test_util.h" #include "ble_hs_test_util_store.h" -static int ble_hs_test_util_store_max_slv_ltks; -static int ble_hs_test_util_store_max_mst_ltks; +static int ble_hs_test_util_store_max_slv_secs; +static int ble_hs_test_util_store_max_mst_secs; static int ble_hs_test_util_store_max_cccds; -static struct ble_store_value_ltk *ble_hs_test_util_store_slv_ltks; -static struct ble_store_value_ltk *ble_hs_test_util_store_mst_ltks; +static struct ble_store_value_sec *ble_hs_test_util_store_slv_secs; +static struct ble_store_value_sec *ble_hs_test_util_store_mst_secs; static struct ble_store_value_cccd *ble_hs_test_util_store_cccds; -int ble_hs_test_util_store_num_slv_ltks; -int ble_hs_test_util_store_num_mst_ltks; +int ble_hs_test_util_store_num_slv_secs; +int ble_hs_test_util_store_num_mst_secs; int ble_hs_test_util_store_num_cccds; @@ -51,42 +51,42 @@ int ble_hs_test_util_store_num_cccds; } while (0) void -ble_hs_test_util_store_init(int max_slv_ltks, int max_mst_ltks, int max_cccds) +ble_hs_test_util_store_init(int max_slv_secs, int max_mst_secs, int max_cccds) { - free(ble_hs_test_util_store_slv_ltks); - free(ble_hs_test_util_store_mst_ltks); + free(ble_hs_test_util_store_slv_secs); + free(ble_hs_test_util_store_mst_secs); free(ble_hs_test_util_store_cccds); - ble_hs_test_util_store_slv_ltks = malloc( - ble_hs_test_util_store_max_slv_ltks * - sizeof *ble_hs_test_util_store_slv_ltks); - TEST_ASSERT_FATAL(ble_hs_test_util_store_slv_ltks != NULL); + ble_hs_test_util_store_slv_secs = malloc( + ble_hs_test_util_store_max_slv_secs * + sizeof *ble_hs_test_util_store_slv_secs); + TEST_ASSERT_FATAL(ble_hs_test_util_store_slv_secs != NULL); - ble_hs_test_util_store_mst_ltks = malloc( - ble_hs_test_util_store_max_mst_ltks * - sizeof *ble_hs_test_util_store_mst_ltks); - TEST_ASSERT_FATAL(ble_hs_test_util_store_mst_ltks != NULL); + ble_hs_test_util_store_mst_secs = malloc( + ble_hs_test_util_store_max_mst_secs * + sizeof *ble_hs_test_util_store_mst_secs); + TEST_ASSERT_FATAL(ble_hs_test_util_store_mst_secs != NULL); ble_hs_test_util_store_cccds = malloc( ble_hs_test_util_store_max_cccds * sizeof *ble_hs_test_util_store_cccds); TEST_ASSERT_FATAL(ble_hs_test_util_store_cccds != NULL); - ble_hs_test_util_store_max_slv_ltks = max_slv_ltks; - ble_hs_test_util_store_max_mst_ltks = max_mst_ltks; + ble_hs_test_util_store_max_slv_secs = max_slv_secs; + ble_hs_test_util_store_max_mst_secs = max_mst_secs; ble_hs_test_util_store_max_cccds = max_cccds; - ble_hs_test_util_store_num_slv_ltks = 0; - ble_hs_test_util_store_num_mst_ltks = 0; + ble_hs_test_util_store_num_slv_secs = 0; + ble_hs_test_util_store_num_mst_secs = 0; ble_hs_test_util_store_num_cccds = 0; } static int -ble_hs_test_util_store_read_ltk(struct ble_store_value_ltk *store, +ble_hs_test_util_store_read_sec(struct ble_store_value_sec *store, int num_values, - struct ble_store_key_ltk *key, - struct ble_store_value_ltk *value) + struct ble_store_key_sec *key, + struct ble_store_value_sec *value) { - struct ble_store_value_ltk *cur; + struct ble_store_value_sec *cur; int i; for (i = 0; i < num_values; i++) { @@ -103,12 +103,14 @@ ble_hs_test_util_store_read_ltk(struct ble_store_value_ltk *store, } } - if (key->ediv_present && cur->ediv != key->ediv) { - continue; - } + if (key->ediv_rand_present) { + if (cur->ediv != key->ediv) { + continue; + } - if (key->rand_num_present && cur->rand_num != key->rand_num) { - continue; + if (cur->rand_num != key->rand_num) { + continue; + } } *value = *cur; @@ -176,19 +178,19 @@ ble_hs_test_util_store_read(int obj_type, union ble_store_key *key, union ble_store_value *dst) { switch (obj_type) { - case BLE_STORE_OBJ_TYPE_MST_LTK: - return ble_hs_test_util_store_read_ltk( - ble_hs_test_util_store_slv_ltks, - ble_hs_test_util_store_num_slv_ltks, - &key->ltk, - &dst->ltk); - - case BLE_STORE_OBJ_TYPE_SLV_LTK: - return ble_hs_test_util_store_read_ltk( - ble_hs_test_util_store_mst_ltks, - ble_hs_test_util_store_num_mst_ltks, - &key->ltk, - &dst->ltk); + case BLE_STORE_OBJ_TYPE_MST_SEC: + return ble_hs_test_util_store_read_sec( + ble_hs_test_util_store_slv_secs, + ble_hs_test_util_store_num_slv_secs, + &key->sec, + &dst->sec); + + case BLE_STORE_OBJ_TYPE_SLV_SEC: + return ble_hs_test_util_store_read_sec( + ble_hs_test_util_store_mst_secs, + ble_hs_test_util_store_num_mst_secs, + &key->sec, + &dst->sec); case BLE_STORE_OBJ_TYPE_CCCD: return ble_hs_test_util_store_read_cccd(&key->cccd, &dst->cccd); @@ -206,19 +208,19 @@ ble_hs_test_util_store_write(int obj_type, union ble_store_value *value) int idx; switch (obj_type) { - case BLE_STORE_OBJ_TYPE_MST_LTK: + case BLE_STORE_OBJ_TYPE_MST_SEC: BLE_HS_TEST_UTIL_STORE_WRITE_GEN( - ble_hs_test_util_store_slv_ltks, - ble_hs_test_util_store_num_slv_ltks, - ble_hs_test_util_store_max_slv_ltks, - value->ltk, -1); + ble_hs_test_util_store_slv_secs, + ble_hs_test_util_store_num_slv_secs, + ble_hs_test_util_store_max_slv_secs, + value->sec, -1); - case BLE_STORE_OBJ_TYPE_SLV_LTK: + case BLE_STORE_OBJ_TYPE_SLV_SEC: BLE_HS_TEST_UTIL_STORE_WRITE_GEN( - ble_hs_test_util_store_mst_ltks, - ble_hs_test_util_store_num_mst_ltks, - ble_hs_test_util_store_max_mst_ltks, - value->ltk, -1); + ble_hs_test_util_store_mst_secs, + ble_hs_test_util_store_num_mst_secs, + ble_hs_test_util_store_max_mst_secs, + value->sec, -1); case BLE_STORE_OBJ_TYPE_CCCD: ble_store_key_from_value_cccd(&key_cccd, &value->cccd); http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/4e16b9ad/net/nimble/host/src/test/ble_l2cap_sm_test.c ---------------------------------------------------------------------- diff --git a/net/nimble/host/src/test/ble_l2cap_sm_test.c b/net/nimble/host/src/test/ble_l2cap_sm_test.c index 60c52c8..0a2cc18 100644 --- a/net/nimble/host/src/test/ble_l2cap_sm_test.c +++ b/net/nimble/host/src/test/ble_l2cap_sm_test.c @@ -1114,7 +1114,7 @@ ble_l2cap_sm_test_util_peer_bonding_good(int send_enc_req, uint8_t *ltk, int authenticated, uint16_t ediv, uint64_t rand_num) { - struct ble_store_value_ltk value_ltk; + struct ble_store_value_sec value_sec; struct ble_hs_conn *conn; int rc; @@ -1138,15 +1138,15 @@ ble_l2cap_sm_test_util_peer_bonding_good(int send_enc_req, uint8_t *ltk, TEST_ASSERT(ble_l2cap_sm_dbg_num_procs() == 0); /* Populate the SM database with an LTK for this peer. */ - value_ltk.peer_addr_type = conn->bhc_addr_type; - memcpy(value_ltk.peer_addr, conn->bhc_addr, sizeof value_ltk.peer_addr); - value_ltk.ediv = ediv; - value_ltk.rand_num = rand_num; - memcpy(value_ltk.key, ltk, sizeof value_ltk.key); - value_ltk.authenticated = authenticated; - value_ltk.sc = 0; - - rc = ble_store_write_slv_ltk(&value_ltk); + value_sec.peer_addr_type = conn->bhc_addr_type; + memcpy(value_sec.peer_addr, conn->bhc_addr, sizeof value_sec.peer_addr); + value_sec.ediv = ediv; + value_sec.rand_num = rand_num; + memcpy(value_sec.ltk, ltk, sizeof value_sec.ltk); + value_sec.authenticated = authenticated; + value_sec.sc = 0; + + rc = ble_store_write_slv_sec(&value_sec); TEST_ASSERT_FATAL(rc == 0); if (send_enc_req) { @@ -1161,19 +1161,18 @@ ble_l2cap_sm_test_util_peer_bonding_good(int send_enc_req, uint8_t *ltk, /* Ensure the LTK request event got sent to the application. */ TEST_ASSERT(ble_l2cap_sm_test_store_obj_type == - BLE_STORE_OBJ_TYPE_SLV_LTK); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.peer_addr_type == + BLE_STORE_OBJ_TYPE_SLV_SEC); + TEST_ASSERT(ble_l2cap_sm_test_store_key.sec.peer_addr_type == BLE_STORE_ADDR_TYPE_NONE); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.ediv_present); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.ediv == ediv); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.rand_num_present); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.rand_num == rand_num); + TEST_ASSERT(ble_l2cap_sm_test_store_key.sec.ediv_rand_present); + TEST_ASSERT(ble_l2cap_sm_test_store_key.sec.ediv == ediv); + TEST_ASSERT(ble_l2cap_sm_test_store_key.sec.rand_num == rand_num); TEST_ASSERT(!conn->bhc_sec_state.enc_enabled); TEST_ASSERT(ble_l2cap_sm_dbg_num_procs() == 1); /* Ensure we sent the expected long term key request reply command. */ - ble_l2cap_sm_test_util_verify_tx_lt_key_req_reply(2, value_ltk.key); + ble_l2cap_sm_test_util_verify_tx_lt_key_req_reply(2, value_sec.ltk); TEST_ASSERT(!conn->bhc_sec_state.enc_enabled); TEST_ASSERT(ble_l2cap_sm_dbg_num_procs() == 1); @@ -1227,11 +1226,10 @@ ble_l2cap_sm_test_util_peer_bonding_bad(uint16_t ediv, uint64_t rand_num) /* Ensure the LTK request event got sent to the application. */ TEST_ASSERT(ble_l2cap_sm_test_store_obj_type == - BLE_STORE_OBJ_TYPE_SLV_LTK); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.ediv_present); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.ediv == ediv); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.rand_num_present); - TEST_ASSERT(ble_l2cap_sm_test_store_key.ltk.rand_num == rand_num); + BLE_STORE_OBJ_TYPE_SLV_SEC); + TEST_ASSERT(ble_l2cap_sm_test_store_key.sec.ediv_rand_present); + TEST_ASSERT(ble_l2cap_sm_test_store_key.sec.ediv == ediv); + TEST_ASSERT(ble_l2cap_sm_test_store_key.sec.rand_num == rand_num); TEST_ASSERT(!conn->bhc_sec_state.enc_enabled); @@ -1857,7 +1855,7 @@ ble_l2cap_sm_test_util_us_bonding_good(int send_enc_req, uint8_t *ltk, uint16_t ediv, uint64_t rand_num) { struct ble_l2cap_sm_sec_req sec_req; - struct ble_store_value_ltk value_ltk; + struct ble_store_value_sec value_sec; struct ble_hs_conn *conn; int rc; @@ -1880,15 +1878,15 @@ ble_l2cap_sm_test_util_us_bonding_good(int send_enc_req, uint8_t *ltk, TEST_ASSERT(ble_l2cap_sm_dbg_num_procs() == 0); /* Populate the SM database with an LTK for this peer. */ - value_ltk.peer_addr_type = conn->bhc_addr_type; - memcpy(value_ltk.peer_addr, conn->bhc_addr, sizeof value_ltk.peer_addr); - value_ltk.ediv = ediv; - value_ltk.rand_num = rand_num; - memcpy(value_ltk.key, ltk, sizeof value_ltk.key); - value_ltk.authenticated = authenticated; - value_ltk.sc = 0; - - rc = ble_store_write_mst_ltk(&value_ltk); + value_sec.peer_addr_type = conn->bhc_addr_type; + memcpy(value_sec.peer_addr, conn->bhc_addr, sizeof value_sec.peer_addr); + value_sec.ediv = ediv; + value_sec.rand_num = rand_num; + memcpy(value_sec.ltk, ltk, sizeof value_sec.ltk); + value_sec.authenticated = authenticated; + value_sec.sc = 0; + + rc = ble_store_write_mst_sec(&value_sec); TEST_ASSERT_FATAL(rc == 0); if (send_enc_req) {
