nimble/host: implement robust gatt caching (server side)

Add support for Robust GATT Caching.

Author: piotrnarajowski

nimble/host/include/host/ble_att.h

@@ -110,6 +110,9 @@ struct os_mbuf;
 /**Insufficient Resources to complete the request. */
 #define BLE_ATT_ERR_INSUFFICIENT_RES        0x11
 
+/**The server requests the client to rediscover the database. */
+#define BLE_ATT_ERR_DB_OUT_OF_SYNC          0x12
+
 /**Requested value is not allowed. */
 #define BLE_ATT_ERR_VALUE_NOT_ALLOWED       0x13
 

nimble/host/include/host/ble_store.h

@@ -48,6 +48,9 @@ extern "C" {
 /** Object type: Client Characteristic Configuration Descriptor. */
 #define BLE_STORE_OBJ_TYPE_CCCD         3
 
+/** Object type: Peer database hash. */
+#define BLE_STORE_OBJ_TYPE_DB_HASH    4
+
 /** @} */
 
 /**
@@ -154,6 +157,36 @@ struct ble_store_value_cccd {
     unsigned value_changed:1;
 };
 
+/**
+ * Used as key for lookups of stored database hash.
+ * This struct corresponds to the BLE_STORE_OBJ_TYPE_DB_HASH store object
+ * type.
+ */
+struct ble_store_key_db_hash {
+    /**
+     * Key by peer identity address;
+     * peer_addr=BLE_ADDR_NONE means don't key off peer.
+     */
+    ble_addr_t peer_addr;
+
+    /** Number of results to skip; 0 means retrieve the first match. */
+    uint8_t idx;
+};
+
+/**
+ * Represents a stored database hash of a peer. This struct
+ * corresponds to the BLE_STORE_OBJ_TYPE_DB_HASH store object type.
+ */
+ struct ble_store_value_db_hash {
+     /** The peer address associated with the stored database hash.  */
+     ble_addr_t peer_addr;
+     /** Flag indicating whether the peer is supporting robust cacheing. */
+     bool is_cache_supported;
+     /** Database hash; can be used to determine whether the peer
+      * is change aware/unaware. */
+     uint8_t db_hash[16];
+ };
+
 /**
  * Used as a key for store lookups.  This union must be accompanied by an
  * object type code to indicate which field is valid.
@@ -163,6 +196,8 @@ union ble_store_key {
     struct ble_store_key_sec sec;
     /** Key for Client Characteristic Configuration Descriptor store lookups. */
     struct ble_store_key_cccd cccd;
+    /** Key for database hash store lookups */
+    struct ble_store_key_db_hash db_hash;
 };
 
 /**
@@ -174,6 +209,8 @@ union ble_store_value {
     struct ble_store_value_sec sec;
     /** Stored Client Characteristic Configuration Descriptor. */
     struct ble_store_value_cccd cccd;
+    /** Stored database hash. */
+    struct ble_store_value_db_hash db_hash;
 };
 
 /** Represents an event associated with the BLE Store. */
@@ -540,6 +577,22 @@ int ble_store_read_cccd(const struct ble_store_key_cccd *key,
  */
 int ble_store_write_cccd(const struct ble_store_value_cccd *value);
 
+///**
+// * @brief Writes a database hash to a storage.
+// *
+// * This function writes database hash value to a storage based on the
+// * provided value.
+// *
+// * @param value                 A pointer to a `ble_store_value_db_hash`
+// *                                  structure representing the database hash
+// *                                  to be written to a storage.
+// *
+// * @return                      0 if the database hash was successfully
+// *                                  written to a storage;
+// *                              Non-zero on error.
+// */
+//int ble_store_write_db_hash(const struct ble_store_value_db_hash *value);
+
 /**
  * @brief Deletes a Client Characteristic Configuration Descriptor (CCCD) from
  * a storage.

nimble/host/services/gatt/include/services/gatt/ble_svc_gatt.h

@@ -31,6 +31,7 @@ struct ble_hs_cfg;
 #define BLE_SVC_GATT_CHR_SERVICE_CHANGED_UUID16         0x2a05
 #define BLE_SVC_GATT_CHR_SERVER_SUPPORTED_FEAT_UUID16   0x2b3a
 #define BLE_SVC_GATT_CHR_CLIENT_SUPPORTED_FEAT_UUID16   0x2b29
+#define BLE_SVC_GATT_CHR_DATABASE_HASH_UUID16           0x2b2a
 
 uint8_t ble_svc_gatt_get_local_cl_supported_feat(void);
 void ble_svc_gatt_changed(uint16_t start_handle, uint16_t end_handle);

nimble/host/services/gatt/src/ble_svc_gatt.c

@@ -21,6 +21,7 @@
 
 #include "sysinit/sysinit.h"
 #include "host/ble_hs.h"
+#include "../src/ble_hs_priv.h"
 #include "services/gatt/ble_svc_gatt.h"
 #include "../src/ble_gatt_priv.h"
 
@@ -32,7 +33,7 @@ static uint16_t ble_svc_gatt_end_handle;
 #define BLE_SVC_GATT_SRV_SUP_FEAT_EATT_BIT      (0x00)
 
 /* Client supported features */
-#define BLE_SVC_GATT_CLI_SUP_FEAT_ROBUST_CATCHING_BIT   (0x00)
+#define BLE_SVC_GATT_CLI_SUP_FEAT_ROBUST_CACHING_BIT   (0x00)
 #define BLE_SVC_GATT_CLI_SUP_FEAT_EATT_BIT              (0x01)
 #define BLE_SVC_GATT_CLI_SUP_FEAT_MULT_NTF_BIT          (0x02)
 
@@ -51,6 +52,10 @@ static int
 ble_svc_gatt_cl_sup_feat_access(uint16_t conn_handle, uint16_t attr_handle,
                                 struct ble_gatt_access_ctxt *ctxt, void *arg);
 
+static int
+ble_svc_gatt_db_hash_access(uint16_t conn_handle, uint16_t attr_handle,
+                            struct ble_gatt_access_ctxt *ctxt, void *arg);
+
 static const struct ble_gatt_svc_def ble_svc_gatt_defs[] = {
     {
         /*** Service: GATT */
@@ -73,6 +78,13 @@ static const struct ble_gatt_svc_def ble_svc_gatt_defs[] = {
                 .access_cb = ble_svc_gatt_cl_sup_feat_access,
                 .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_WRITE,
             },
+#if MYNEWT_VAL(BLE_ATT_SVR_ROBUST_CACHE)
+            {
+                .uuid = BLE_UUID16_DECLARE(BLE_SVC_GATT_CHR_DATABASE_HASH_UUID16),
+                .access_cb = ble_svc_gatt_db_hash_access,
+                .flags = BLE_GATT_CHR_F_READ,
+            },
+#endif
             {
                 0, /* No more characteristics in this service. */
             }
@@ -121,6 +133,21 @@ ble_svc_gatt_cl_sup_feat_access(uint16_t conn_handle, uint16_t attr_handle,
     return 0;
 }
 
+static int
+ble_svc_gatt_db_hash_access(uint16_t conn_handle, uint16_t attr_handle,
+                            struct ble_gatt_access_ctxt *ctxt, void *arg)
+{
+    int rc;
+
+    if (ctxt->op != BLE_GATT_ACCESS_OP_READ_CHR) {
+        return BLE_ATT_ERR_WRITE_NOT_PERMITTED;
+    }
+
+    rc = os_mbuf_append(ctxt->om, db_hash, sizeof(db_hash));
+
+    return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
+}
+
 static int
 ble_svc_gatt_access(uint16_t conn_handle, uint16_t attr_handle,
                     struct ble_gatt_access_ctxt *ctxt, void *arg)
@@ -193,4 +220,8 @@ ble_svc_gatt_init(void)
     if (MYNEWT_VAL(BLE_ATT_SVR_NOTIFY_MULTI) > 0) {
         ble_svc_gatt_local_cl_sup_feat |= (1 << BLE_SVC_GATT_CLI_SUP_FEAT_MULT_NTF_BIT);
     }
+
+    if (MYNEWT_VAL(BLE_ATT_SVR_ROBUST_CACHE) > 0) {
+        ble_svc_gatt_local_cl_sup_feat |= (1 << BLE_SVC_GATT_CLI_SUP_FEAT_ROBUST_CACHING_BIT);
+    }
 }

nimble/host/src/ble_att_priv.h

@@ -173,6 +173,9 @@ uint16_t ble_att_mtu_by_cid(uint16_t conn_handle, uint16_t cid);
 int ble_att_init(void);
 
 /*** @svr */
+/** Type definition for ATT svr entry interation callback. */
+typedef int (*ble_gatts_entry_foreach)(struct ble_att_svr_entry *entry,
+                                       void *arg);
 
 int ble_att_svr_start(void);
 
@@ -217,6 +220,8 @@ void ble_att_svr_prep_clear(struct ble_att_prep_entry_list *prep_list);
 int ble_att_svr_read_handle(uint16_t conn_handle, uint16_t attr_handle,
                             uint16_t offset, struct os_mbuf *om,
                             uint8_t *out_att_err);
+void ble_att_svr_foreach(uint16_t start_handle, uint16_t end_handle,
+                         ble_gatts_entry_foreach cb, void *arg);
 void ble_att_svr_reset(void);
 int ble_att_svr_init(void);
 

nimble/host/src/ble_att_svr.c

@@ -209,6 +209,26 @@ ble_att_svr_find_by_uuid(struct ble_att_svr_entry *prev, const ble_uuid_t *uuid,
     return NULL;
 }
 
+void ble_att_svr_foreach(uint16_t start_handle, uint16_t end_handle,
+                         ble_gatts_entry_foreach cb, void *arg)
+{
+    int rc;
+    struct ble_att_svr_entry *entry;
+
+    for (entry = STAILQ_FIRST(&ble_att_svr_list);
+         entry != NULL || entry->ha_handle_id == end_handle;
+         entry = STAILQ_NEXT(entry, ha_next)) {
+
+        if (entry->ha_handle_id == start_handle) {
+            rc = cb(entry, arg);
+            if (rc != 0) {
+                break;
+            }
+        }
+        start_handle++;
+    }
+}
+
 static int
 ble_att_svr_pullup_req_base(struct os_mbuf **om, int base_len,
                             uint8_t *out_att_err)

nimble/host/src/ble_gatt_priv.h

@@ -145,6 +145,7 @@ void ble_gattc_rx_find_info_idata(uint16_t conn_handle, uint16_t cid,
 void ble_gattc_rx_find_info_complete(uint16_t conn_handle, uint16_t cid, int status);
 void ble_gattc_connection_txable(uint16_t conn_handle);
 void ble_gattc_connection_broken(uint16_t conn_handle);
+int ble_gatts_calculate_db_hash(uint8_t *hash);
 int32_t ble_gattc_timer(void);
 
 int ble_gattc_any_jobs(void);

nimble/host/src/ble_gatts.c

@@ -25,6 +25,9 @@
 #include "host/ble_uuid.h"
 #include "host/ble_store.h"
 #include "ble_hs_priv.h"
+#include "tinycrypt/aes.h"
+#include "tinycrypt/cmac_mode.h"
+#include "tinycrypt/constants.h"
 
 #define BLE_GATTS_INCLUDE_SZ    6
 #define BLE_GATTS_CHR_MAX_SZ    19
@@ -65,6 +68,10 @@ struct ble_gatts_clt_cfg {
 static struct ble_gatts_clt_cfg *ble_gatts_clt_cfgs;
 static int ble_gatts_num_cfgable_chrs;
 
+#if MYNEWT_VAL(BLE_ATT_SVR_ROBUST_CACHE)
+uint8_t db_hash[16];
+#endif
+
 STATS_SECT_DECL(ble_gatts_stats) ble_gatts_stats;
 STATS_NAME_START(ble_gatts_stats)
     STATS_NAME(ble_gatts_stats, svcs)
@@ -1061,6 +1068,8 @@ ble_gatts_register_svcs(const struct ble_gatt_svc_def *svcs,
     int rc;
     int i;
 
+    num_svcs = 0;
+
     for (i = 0; svcs[i].type != BLE_GATT_SVC_TYPE_END; i++) {
         idx = ble_gatts_num_svc_entries + i;
         if (idx >= ble_hs_max_services) {
@@ -1227,6 +1236,13 @@ ble_gatts_start(void)
     }
     ble_gatts_free_svc_defs();
 
+#if MYNEWT_VAL(BLE_ATT_SVR_ROBUST_CACHE)
+    rc = ble_gatts_calculate_db_hash(db_hash);
+    if (rc != 0) {
+        goto done;
+    }
+#endif
+
     if (ble_gatts_num_cfgable_chrs == 0) {
         rc = 0;
         goto done;
@@ -2226,6 +2242,87 @@ ble_gatts_lcl_svc_foreach(ble_gatt_svc_foreach_fn cb, void *arg)
     }
 }
 
+/* Helpers to append data to buf */
+#define BUF_PUT_LE16(buf, buf_len, val)      \
+    do {                                     \
+        put_le16((buf) + (buf_len), (val));  \
+        (buf_len) += 2;                      \
+    } while (0)
+
+int ble_gatt_foreach_hash_append(struct ble_att_svr_entry *entry, void *arg)
+{
+    uint16_t uuid;
+    struct os_mbuf *om;
+    uint8_t buf[24];
+    uint16_t buf_len;
+    int rc;
+
+    uuid = ble_uuid_u16(entry->ha_uuid);
+    buf_len = 0;
+    switch (uuid) {
+    case BLE_ATT_UUID_PRIMARY_SERVICE:
+    case BLE_ATT_UUID_SECONDARY_SERVICE:
+    case BLE_ATT_UUID_INCLUDE:
+    case BLE_ATT_UUID_CHARACTERISTIC:
+    case BLE_GATT_DSC_EXT_PROP_UUID16:
+        /* attr handle */
+        BUF_PUT_LE16(buf, buf_len, entry->ha_handle_id);
+        /* attr type */
+        BUF_PUT_LE16(buf, buf_len, uuid);
+        rc = ble_att_svr_read_local(entry->ha_handle_id, &om);
+        if (rc != 0) {
+            return rc;
+        }
+        os_mbuf_copydata(om, 0, os_mbuf_len(om), buf + buf_len);
+        buf_len += os_mbuf_len(om);
+        break;
+
+    case BLE_GATT_DSC_CLT_CFG_UUID16:
+        BUF_PUT_LE16(buf, buf_len, entry->ha_handle_id);
+        BUF_PUT_LE16(buf, buf_len, uuid);
+        break;
+    default:
+        return 0;
+    }
+    if (tc_cmac_update(arg, buf, buf_len) == TC_CRYPTO_FAIL) {
+        return BLE_HS_EUNKNOWN;
+    }
+
+    return 0;
+}
+
+/**
+ * Calculate db_hash
+ * @param hash
+ * @return
+ */
+
+int ble_gatts_calculate_db_hash(uint8_t *hash)
+{
+#if !MYNEWT_VAL(BLE_ATT_SVR_ROBUST_CACHE)
+    return BLE_HS_ENOTSUP;
+#endif
+    struct tc_aes_key_sched_struct sched;
+    struct tc_cmac_struct state;
+
+    /* k is the 128-bit key, which shall be all zero (7.3.1 Core spec) */
+    const uint8_t key[16] = {0};
+
+    if (tc_cmac_setup(&state, key, &sched) == TC_CRYPTO_FAIL) {
+        return BLE_HS_EUNKNOWN;
+    }
+
+    ble_att_svr_foreach(0x0001, 0xFFFF, ble_gatt_foreach_hash_append, &state);
+
+    if (tc_cmac_final(hash, &state) == TC_CRYPTO_FAIL) {
+        return BLE_HS_EUNKNOWN;
+    }
+
+    swap_in_place(hash, 16);
+
+    return 0;
+}
+
 int
 ble_gatts_reset(void)
 {

nimble/host/src/ble_hs_priv.h

@@ -100,6 +100,8 @@ extern uint16_t ble_hs_max_attrs;
 extern uint16_t ble_hs_max_services;
 extern uint16_t ble_hs_max_client_configs;
 
+extern uint8_t db_hash[16];
+
 void ble_hs_process_rx_data_queue(void);
 int ble_hs_tx_data(struct os_mbuf *om);
 void ble_hs_wakeup_tx(void);