You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by cc...@apache.org on 2016/05/26 01:16:47 UTC
incubator-mynewt-core git commit: BLE Host - rename store ltk to sec.
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 <cc...@apache.org>
Authored: Wed May 25 15:37:51 2016 -0700
Committer: Christopher Collins <cc...@apache.org>
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) {