diff --git a/components/bt/bluedroid/api/esp_gap_ble_api.c b/components/bt/bluedroid/api/esp_gap_ble_api.c index 9c444bb13e..f9c2b79534 100644 --- a/components/bt/bluedroid/api/esp_gap_ble_api.c +++ b/components/bt/bluedroid/api/esp_gap_ble_api.c @@ -598,6 +598,29 @@ esp_err_t esp_ble_get_bond_device_list(int *dev_num, esp_ble_bond_dev_t *dev_lis return (ret == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); } + +esp_err_t esp_ble_oob_req_reply(esp_bd_addr_t bd_addr, uint8_t *TK, uint8_t len) +{ + if(len != ESP_BT_OCTET16_LEN) { + return ESP_ERR_INVALID_ARG; + } + + btc_msg_t msg; + btc_ble_gap_args_t arg; + + ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); + + msg.sig = BTC_SIG_API_CALL; + msg.pid = BTC_PID_GAP_BLE; + msg.act = BTC_GAP_BLE_OOB_REQ_REPLY_EVT; + memcpy(arg.oob_req_reply.bd_addr, bd_addr, ESP_BD_ADDR_LEN); + arg.oob_req_reply.len = len; + arg.oob_req_reply.p_value = TK; + + return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gap_args_t), btc_gap_ble_arg_deep_copy) + == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); +} + #endif /* #if (SMP_INCLUDED == TRUE) */ esp_err_t esp_ble_gap_disconnect(esp_bd_addr_t remote_device) diff --git a/components/bt/bluedroid/api/include/api/esp_gap_ble_api.h b/components/bt/bluedroid/api/include/api/esp_gap_ble_api.h index b624365cb9..4e0f9d3958 100644 --- a/components/bt/bluedroid/api/include/api/esp_gap_ble_api.h +++ b/components/bt/bluedroid/api/include/api/esp_gap_ble_api.h @@ -54,6 +54,7 @@ typedef uint8_t esp_ble_key_type_t; #define ESP_LE_AUTH_NO_BOND 0x00 /*!< 0*/ /* relate to BTM_LE_AUTH_NO_BOND in stack/btm_api.h */ #define ESP_LE_AUTH_BOND 0x01 /*!< 1 << 0 */ /* relate to BTM_LE_AUTH_BOND in stack/btm_api.h */ #define ESP_LE_AUTH_REQ_MITM (1 << 2) /*!< 1 << 2 */ /* relate to BTM_LE_AUTH_REQ_MITM in stack/btm_api.h */ +#define ESP_LE_AUTH_REQ_BOND_MITM (ESP_LE_AUTH_BOND | ESP_LE_AUTH_REQ_MITM)/*!< 0101*/ #define ESP_LE_AUTH_REQ_SC_ONLY (1 << 3) /*!< 1 << 3 */ /* relate to BTM_LE_AUTH_REQ_SC_ONLY in stack/btm_api.h */ #define ESP_LE_AUTH_REQ_SC_BOND (ESP_LE_AUTH_BOND | ESP_LE_AUTH_REQ_SC_ONLY) /*!< 1001 */ /* relate to BTM_LE_AUTH_REQ_SC_BOND in stack/btm_api.h */ #define ESP_LE_AUTH_REQ_SC_MITM (ESP_LE_AUTH_REQ_MITM | ESP_LE_AUTH_REQ_SC_ONLY) /*!< 1100 */ /* relate to BTM_LE_AUTH_REQ_SC_MITM in stack/btm_api.h */ @@ -63,6 +64,9 @@ typedef uint8_t esp_ble_auth_req_t; /*!< combination of the above bit #define ESP_BLE_ONLY_ACCEPT_SPECIFIED_AUTH_DISABLE 0 #define ESP_BLE_ONLY_ACCEPT_SPECIFIED_AUTH_ENABLE 1 +#define ESP_BLE_OOB_DISABLE 0 +#define ESP_BLE_OOB_ENABLE 1 + /* relate to BTM_IO_CAP_xxx in stack/btm_api.h */ #define ESP_IO_CAP_OUT 0 /*!< DisplayOnly */ /* relate to BTM_IO_CAP_OUT in stack/btm_api.h */ #define ESP_IO_CAP_IO 1 /*!< DisplayYesNo */ /* relate to BTM_IO_CAP_IO in stack/btm_api.h */ @@ -270,6 +274,7 @@ typedef enum { ESP_BLE_SM_SET_STATIC_PASSKEY, ESP_BLE_SM_CLEAR_STATIC_PASSKEY, ESP_BLE_SM_ONLY_ACCEPT_SPECIFIED_SEC_AUTH, + ESP_BLE_SM_OOB_SUPPORT, ESP_BLE_SM_MAX_PARAM, } esp_ble_sm_param_t; @@ -1116,6 +1121,20 @@ int esp_ble_get_bond_device_num(void); */ esp_err_t esp_ble_get_bond_device_list(int *dev_num, esp_ble_bond_dev_t *dev_list); +/** +* @brief This function is called to provide the OOB data for +* SMP in response to ESP_GAP_BLE_OOB_REQ_EVT +* +* @param[in] bd_addr: BD address of the peer device. +* @param[in] TK: TK value, the TK value shall be a 128-bit random number +* @param[in] len: length of tk, should always be 128-bit +* +* @return - ESP_OK : success +* - other : failed +* +*/ +esp_err_t esp_ble_oob_req_reply(esp_bd_addr_t bd_addr, uint8_t *TK, uint8_t len); + #endif /* #if (SMP_INCLUDED == TRUE) */ /** diff --git a/components/bt/bluedroid/bta/dm/bta_dm_act.c b/components/bt/bluedroid/bta/dm/bta_dm_act.c index 95a17a4807..d334f00f9d 100644 --- a/components/bt/bluedroid/bta/dm/bta_dm_act.c +++ b/components/bt/bluedroid/bta/dm/bta_dm_act.c @@ -1150,6 +1150,21 @@ void bta_dm_loc_oob(tBTA_DM_MSG *p_data) BTM_ReadLocalOobData(); } +/******************************************************************************* +** +** Function bta_dm_oob_reply +** +** Description This function is called to provide the OOB data for +** SMP in response to BLE OOB request. +** +** Returns void +** +*******************************************************************************/ +void bta_dm_oob_reply(tBTA_DM_MSG *p_data) +{ + BTM_BleOobDataReply(p_data->oob_reply.bd_addr, BTM_SUCCESS, p_data->oob_reply.len, p_data->oob_reply.value); +} + /******************************************************************************* ** ** Function bta_dm_ci_io_req_act diff --git a/components/bt/bluedroid/bta/dm/bta_dm_api.c b/components/bt/bluedroid/bta/dm/bta_dm_api.c index a20a6efab9..0b4c1a564f 100644 --- a/components/bt/bluedroid/bta/dm/bta_dm_api.c +++ b/components/bt/bluedroid/bta/dm/bta_dm_api.c @@ -510,6 +510,36 @@ void BTA_DmLocalOob(void) bta_sys_sendmsg(p_msg); } } + +/******************************************************************************* +** +** Function BTA_DmOobReply +** +** This function is called to provide the OOB data for +** SMP in response to BTM_LE_OOB_REQ_EVT +** +** Parameters: bd_addr - Address of the peer device +** len - length of simple pairing Randomizer C +** p_value - simple pairing Randomizer C. +** +** Returns void +** +*******************************************************************************/ +void BTA_DmOobReply(BD_ADDR bd_addr, UINT8 len, UINT8 *p_value) +{ + tBTA_DM_API_OOB_REPLY *p_msg; + + if ((p_msg = (tBTA_DM_API_OOB_REPLY *) osi_malloc(sizeof(tBTA_DM_API_OOB_REPLY))) != NULL) { + p_msg->hdr.event = BTA_DM_API_OOB_REPLY_EVT; + if(p_value == NULL || len > BT_OCTET16_LEN) { + return; + } + memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN); + p_msg->len = len; + memcpy(p_msg->value, p_value, len); + bta_sys_sendmsg(p_msg); + } +} #endif /* BTM_OOB_INCLUDED */ /******************************************************************************* ** diff --git a/components/bt/bluedroid/bta/dm/bta_dm_co.c b/components/bt/bluedroid/bta/dm/bta_dm_co.c index 586da2865e..7e6cb4808f 100644 --- a/components/bt/bluedroid/bta/dm/bta_dm_co.c +++ b/components/bt/bluedroid/bta/dm/bta_dm_co.c @@ -35,6 +35,9 @@ #define BTM_BLE_ONLY_ACCEPT_SPECIFIED_SEC_AUTH_DISABLE 0 #define BTM_BLE_ONLY_ACCEPT_SPECIFIED_SEC_AUTH_ENABLE 1 +#define BTM_BLE_OOB_DISABLE 0 +#define BTM_BLE_OOB_ENABLE 1 + tBTE_APPL_CFG bte_appl_cfg = { #if SMP_INCLUDED == TRUE BTA_LE_AUTH_REQ_SC_MITM_BOND, // Authentication requirements @@ -45,7 +48,8 @@ tBTE_APPL_CFG bte_appl_cfg = { BTM_BLE_INITIATOR_KEY_SIZE, BTM_BLE_RESPONDER_KEY_SIZE, BTM_BLE_MAX_KEY_SIZE, - BTM_BLE_ONLY_ACCEPT_SPECIFIED_SEC_AUTH_DISABLE + BTM_BLE_ONLY_ACCEPT_SPECIFIED_SEC_AUTH_DISABLE, + BTM_BLE_OOB_DISABLE, }; #endif @@ -338,12 +342,16 @@ void bta_dm_co_ble_io_req(BD_ADDR bd_addr, tBTA_IO_CAP *p_io_cap, * If the answer can not be obtained right away, * set *p_oob_data to BTA_OOB_UNKNOWN and call bta_dm_ci_io_req() when the answer is available */ - *p_oob_data = FALSE; + *p_oob_data = bte_appl_cfg.oob_support; /* *p_auth_req by default is FALSE for devices with NoInputNoOutput; TRUE for other devices. */ *p_auth_req = bte_appl_cfg.ble_auth_req | (bte_appl_cfg.ble_auth_req & BTA_LE_AUTH_REQ_MITM) | ((*p_auth_req) & BTA_LE_AUTH_REQ_MITM); + if (*p_oob_data == BTM_BLE_OOB_ENABLE) { + *p_auth_req = (*p_auth_req)&(~BTA_LE_AUTH_REQ_SC_ONLY); + } + if (bte_appl_cfg.ble_io_cap <= 4) { *p_io_cap = bte_appl_cfg.ble_io_cap; } @@ -433,5 +441,16 @@ UINT8 bta_dm_co_ble_get_auth_req(void) return 0; } +void bta_dm_co_ble_oob_support(UINT8 enable) +{ +#if (SMP_INCLUDED == TRUE) + if (enable) { + bte_appl_cfg.oob_support = BTM_BLE_OOB_ENABLE; + } else { + bte_appl_cfg.oob_support = BTM_BLE_OOB_DISABLE; + } +#endif ///SMP_INCLUDED == TRUE +} + #endif diff --git a/components/bt/bluedroid/bta/dm/bta_dm_main.c b/components/bt/bluedroid/bta/dm/bta_dm_main.c index aa651c267e..f005326542 100644 --- a/components/bt/bluedroid/bta/dm/bta_dm_main.c +++ b/components/bt/bluedroid/bta/dm/bta_dm_main.c @@ -82,6 +82,7 @@ const tBTA_DM_ACTION bta_dm_action[BTA_DM_MAX_EVT] = { #endif ///SMP_INCLUDED == TRUE #if (BTM_OOB_INCLUDED == TRUE && SMP_INCLUDED == TRUE) bta_dm_loc_oob, /* BTA_DM_API_LOC_OOB_EVT */ + bta_dm_oob_reply, /* BTA_DM_API_OOB_REPLY_EVT */ bta_dm_ci_io_req_act, /* BTA_DM_CI_IO_REQ_EVT */ bta_dm_ci_rmt_oob_act, /* BTA_DM_CI_RMT_OOB_EVT */ #endif /* BTM_OOB_INCLUDED */ diff --git a/components/bt/bluedroid/bta/dm/include/bta_dm_int.h b/components/bt/bluedroid/bta/dm/include/bta_dm_int.h index c54f26728b..88e2715121 100644 --- a/components/bt/bluedroid/bta/dm/include/bta_dm_int.h +++ b/components/bt/bluedroid/bta/dm/include/bta_dm_int.h @@ -79,6 +79,7 @@ enum { #endif ///SMP_INCLUDED == TRUE #if (BTM_OOB_INCLUDED == TRUE && SMP_INCLUDED == TRUE) BTA_DM_API_LOC_OOB_EVT, + BTA_DM_API_OOB_REPLY_EVT, BTA_DM_CI_IO_REQ_EVT, BTA_DM_CI_RMT_OOB_EVT, #endif /* BTM_OOB_INCLUDED */ @@ -298,6 +299,14 @@ typedef struct { BT_HDR hdr; } tBTA_DM_API_LOC_OOB; +/* data type for BTA_DM_API_OOB_REPLY_EVT */ +typedef struct { + BT_HDR hdr; + BD_ADDR bd_addr; + UINT8 len; + UINT8 value[BT_OCTET16_LEN]; +} tBTA_DM_API_OOB_REPLY; + /* data type for BTA_DM_API_CONFIRM_EVT */ typedef struct { BT_HDR hdr; @@ -779,6 +788,7 @@ typedef union { tBTA_DM_API_PIN_REPLY pin_reply; tBTA_DM_API_LOC_OOB loc_oob; + tBTA_DM_API_OOB_REPLY oob_reply; tBTA_DM_API_CONFIRM confirm; tBTA_DM_API_KEY_REQ key_req; tBTA_DM_CI_IO_REQ ci_io_req; @@ -1266,6 +1276,7 @@ extern void bta_dm_confirm(tBTA_DM_MSG *p_data); extern void bta_dm_key_req(tBTA_DM_MSG *p_data); #if (BTM_OOB_INCLUDED == TRUE) extern void bta_dm_loc_oob(tBTA_DM_MSG *p_data); +extern void bta_dm_oob_reply(tBTA_DM_MSG *p_data); extern void bta_dm_ci_io_req_act(tBTA_DM_MSG *p_data); extern void bta_dm_ci_rmt_oob_act(tBTA_DM_MSG *p_data); #endif /* BTM_OOB_INCLUDED */ diff --git a/components/bt/bluedroid/bta/include/bta/bta_api.h b/components/bt/bluedroid/bta/include/bta/bta_api.h index 22a56f3bf6..9bac48a63b 100644 --- a/components/bt/bluedroid/bta/include/bta/bta_api.h +++ b/components/bt/bluedroid/bta/include/bta/bta_api.h @@ -1611,6 +1611,22 @@ extern void BTA_DmPinReply(BD_ADDR bd_addr, BOOLEAN accept, UINT8 pin_len, ** *******************************************************************************/ extern void BTA_DmLocalOob(void); + +/******************************************************************************* +** +** Function BTA_DmOobReply +** +** This function is called to provide the OOB data for +** SMP in response to BTM_LE_OOB_REQ_EVT +** +** Parameters: bd_addr - Address of the peer device +** len - length of simple pairing Randomizer C +** p_value - simple pairing Randomizer C. +** +** Returns void +** +*******************************************************************************/ +extern void BTA_DmOobReply(BD_ADDR bd_addr, UINT8 len, UINT8 *p_value); #endif /* BTM_OOB_INCLUDED */ /******************************************************************************* diff --git a/components/bt/bluedroid/bta/include/bta/bta_dm_co.h b/components/bt/bluedroid/bta/include/bta/bta_dm_co.h index c69a266eaf..b9e98b4653 100644 --- a/components/bt/bluedroid/bta/include/bta/bta_dm_co.h +++ b/components/bt/bluedroid/bta/include/bta/bta_dm_co.h @@ -210,4 +210,6 @@ extern void bta_dm_co_ble_set_accept_auth_enable(UINT8 enable); extern UINT8 bta_dm_co_ble_get_accept_auth_enable(void); extern UINT8 bta_dm_co_ble_get_auth_req(void); + +extern void bta_dm_co_ble_oob_support(UINT8 enable); #endif diff --git a/components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c b/components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c index a64b66debf..c9d5f70b42 100644 --- a/components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c +++ b/components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c @@ -931,6 +931,21 @@ void btc_gap_ble_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src) } break; } + case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: { + btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src; + btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest; + uint8_t length = 0; + if (src->oob_req_reply.p_value) { + length = dst->oob_req_reply.len; + dst->oob_req_reply.p_value = osi_malloc(length); + if (dst->oob_req_reply.p_value != NULL) { + memcpy(dst->oob_req_reply.p_value, src->oob_req_reply.p_value, length); + } else { + BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act); + } + } + break; + } default: BTC_TRACE_ERROR("Unhandled deep copy %d\n", msg->act); break; @@ -986,6 +1001,13 @@ void btc_gap_ble_arg_deep_free(btc_msg_t *msg) } break; } + case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: { + uint8_t *value = ((btc_ble_gap_args_t *)msg->arg)->oob_req_reply.p_value; + if (value) { + osi_free(value); + } + break; + } default: BTC_TRACE_DEBUG("Unhandled deep free %d\n", msg->act); break; @@ -1144,6 +1166,12 @@ void btc_gap_ble_call_handler(btc_msg_t *msg) bta_dm_co_ble_set_accept_auth_enable(enable); break; } + case ESP_BLE_SM_OOB_SUPPORT: { + uint8_t enable = 0; + STREAM_TO_UINT8(enable, value); + bta_dm_co_ble_oob_support(enable); + break; + } default: break; } @@ -1174,6 +1202,9 @@ void btc_gap_ble_call_handler(btc_msg_t *msg) BTA_DmRemoveDevice(bd_addr, BT_TRANSPORT_LE); break; } + case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: + BTA_DmOobReply(arg->oob_req_reply.bd_addr, arg->oob_req_reply.len, arg->oob_req_reply.p_value); + break; #endif ///SMP_INCLUDED == TRUE case BTC_GAP_BLE_DISCONNECT_EVT: btc_ble_disconnect(arg->disconnect.remote_device); diff --git a/components/bt/bluedroid/btc/profile/std/include/btc_gap_ble.h b/components/bt/bluedroid/btc/profile/std/include/btc_gap_ble.h index b737594816..4f37043a7c 100644 --- a/components/bt/bluedroid/btc/profile/std/include/btc_gap_ble.h +++ b/components/bt/bluedroid/btc/profile/std/include/btc_gap_ble.h @@ -46,6 +46,7 @@ typedef enum { BTC_GAP_BLE_CONFIRM_REPLY_EVT, BTC_GAP_BLE_DISCONNECT_EVT, BTC_GAP_BLE_REMOVE_BOND_DEV_EVT, + BTC_GAP_BLE_OOB_REQ_REPLY_EVT, } btc_gap_ble_act_t; /* btc_ble_gap_args_t */ @@ -144,6 +145,12 @@ typedef union { esp_bd_addr_t bd_addr; bool accept; } enc_comfirm_replay; + //BTC_GAP_BLE_OOB_DATA_REPLY_EVT + struct oob_req_reply_args { + esp_bd_addr_t bd_addr; + uint8_t len; + uint8_t *p_value; + } oob_req_reply; //BTC_GAP_BLE_DISCONNECT_EVT struct disconnect_args { esp_bd_addr_t remote_device; diff --git a/components/bt/bluedroid/common/include/common/bte_appl.h b/components/bt/bluedroid/common/include/common/bte_appl.h index 4fe465c35a..4810bd6ff4 100644 --- a/components/bt/bluedroid/common/include/common/bte_appl.h +++ b/components/bt/bluedroid/common/include/common/bte_appl.h @@ -32,6 +32,7 @@ typedef struct { UINT8 ble_resp_key; UINT8 ble_max_key_size; UINT8 ble_accept_auth_enable; + UINT8 oob_support; #endif } tBTE_APPL_CFG; diff --git a/examples/bluetooth/gatt_security_client/main/example_ble_sec_gattc_demo.c b/examples/bluetooth/gatt_security_client/main/example_ble_sec_gattc_demo.c index 278a929fef..c8de541b29 100644 --- a/examples/bluetooth/gatt_security_client/main/example_ble_sec_gattc_demo.c +++ b/examples/bluetooth/gatt_security_client/main/example_ble_sec_gattc_demo.c @@ -139,6 +139,9 @@ static char *esp_auth_req_to_str(esp_ble_auth_req_t auth_req) case ESP_LE_AUTH_REQ_MITM: auth_str = "ESP_LE_AUTH_REQ_MITM"; break; + case ESP_LE_AUTH_REQ_BOND_MITM: + auth_str = "ESP_LE_AUTH_REQ_BOND_MITM"; + break; case ESP_LE_AUTH_REQ_SC_ONLY: auth_str = "ESP_LE_AUTH_REQ_SC_ONLY"; break; @@ -384,9 +387,12 @@ static void esp_gap_cb(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *par //esp_ble_passkey_reply(gl_profile_tab[PROFILE_A_APP_ID].remote_bda, true, 0x00); ESP_LOGI(GATTC_TAG, "ESP_GAP_BLE_PASSKEY_REQ_EVT"); break; - case ESP_GAP_BLE_OOB_REQ_EVT: /* OOB request event */ + case ESP_GAP_BLE_OOB_REQ_EVT: { ESP_LOGI(GATTC_TAG, "ESP_GAP_BLE_OOB_REQ_EVT"); + uint8_t tk[16] = {1}; //If you paired with OOB, both devices need to use the same tk + esp_ble_oob_req_reply(param->ble_security.ble_req.bd_addr, tk, sizeof(tk)); break; + } case ESP_GAP_BLE_LOCAL_IR_EVT: /* BLE local IR event */ ESP_LOGI(GATTC_TAG, "ESP_GAP_BLE_LOCAL_IR_EVT"); break; @@ -563,14 +569,16 @@ void app_main() } /* set the security iocap & auth_req & key size & init key response key parameters to the stack*/ - esp_ble_auth_req_t auth_req = ESP_LE_AUTH_BOND; //bonding with peer device after authentication + esp_ble_auth_req_t auth_req = ESP_LE_AUTH_REQ_SC_MITM_BOND; //bonding with peer device after authentication esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE; //set the IO capability to No output No input uint8_t key_size = 16; //the key size should be 7~16 bytes uint8_t init_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK; uint8_t rsp_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK; + uint8_t oob_support = ESP_BLE_OOB_DISABLE; esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &auth_req, sizeof(uint8_t)); esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t)); esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &key_size, sizeof(uint8_t)); + esp_ble_gap_set_security_param(ESP_BLE_SM_OOB_SUPPORT, &oob_support, sizeof(uint8_t)); /* If your BLE device act as a Slave, the init_key means you hope which types of key of the master should distribut to you, and the response key means which key you can distribut to the Master; If your BLE device act as a master, the response key means you hope which types of key of the slave should distribut to you, diff --git a/examples/bluetooth/gatt_security_server/main/example_ble_sec_gatts_demo.c b/examples/bluetooth/gatt_security_server/main/example_ble_sec_gatts_demo.c index ac06e85e0b..cae4e67aa0 100644 --- a/examples/bluetooth/gatt_security_server/main/example_ble_sec_gatts_demo.c +++ b/examples/bluetooth/gatt_security_server/main/example_ble_sec_gatts_demo.c @@ -240,6 +240,9 @@ static char *esp_auth_req_to_str(esp_ble_auth_req_t auth_req) case ESP_LE_AUTH_REQ_MITM: auth_str = "ESP_LE_AUTH_REQ_MITM"; break; + case ESP_LE_AUTH_REQ_BOND_MITM: + auth_str = "ESP_LE_AUTH_REQ_BOND_MITM"; + break; case ESP_LE_AUTH_REQ_SC_ONLY: auth_str = "ESP_LE_AUTH_REQ_SC_ONLY"; break; @@ -318,9 +321,12 @@ static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param ESP_LOGI(GATTS_TABLE_TAG, "ESP_GAP_BLE_PASSKEY_REQ_EVT"); //esp_ble_passkey_reply(heart_rate_profile_tab[HEART_PROFILE_APP_IDX].remote_bda, true, 0x00); break; - case ESP_GAP_BLE_OOB_REQ_EVT: /* OOB request event */ + case ESP_GAP_BLE_OOB_REQ_EVT: { ESP_LOGI(GATTS_TABLE_TAG, "ESP_GAP_BLE_OOB_REQ_EVT"); + uint8_t tk[16] = {1}; //If you paired with OOB, both devices need to use the same tk + esp_ble_oob_req_reply(param->ble_security.ble_req.bd_addr, tk, sizeof(tk)); break; + } case ESP_GAP_BLE_LOCAL_IR_EVT: /* BLE local IR event */ ESP_LOGI(GATTS_TABLE_TAG, "ESP_GAP_BLE_LOCAL_IR_EVT"); break; @@ -553,7 +559,7 @@ void app_main() } /* set the security iocap & auth_req & key size & init key response key parameters to the stack*/ - esp_ble_auth_req_t auth_req = ESP_LE_AUTH_BOND; //bonding with peer device after authentication + esp_ble_auth_req_t auth_req = ESP_LE_AUTH_REQ_SC_MITM_BOND; //bonding with peer device after authentication esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE; //set the IO capability to No output No input uint8_t key_size = 16; //the key size should be 7~16 bytes uint8_t init_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK; @@ -561,11 +567,13 @@ void app_main() //set static passkey uint32_t passkey = 123456; uint8_t auth_option = ESP_BLE_ONLY_ACCEPT_SPECIFIED_AUTH_DISABLE; + uint8_t oob_support = ESP_BLE_OOB_DISABLE; esp_ble_gap_set_security_param(ESP_BLE_SM_SET_STATIC_PASSKEY, &passkey, sizeof(uint32_t)); esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &auth_req, sizeof(uint8_t)); esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t)); esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &key_size, sizeof(uint8_t)); esp_ble_gap_set_security_param(ESP_BLE_SM_ONLY_ACCEPT_SPECIFIED_SEC_AUTH, &auth_option, sizeof(uint8_t)); + esp_ble_gap_set_security_param(ESP_BLE_SM_OOB_SUPPORT, &oob_support, sizeof(uint8_t)); /* If your BLE device act as a Slave, the init_key means you hope which types of key of the master should distribut to you, and the response key means which key you can distribut to the Master; If your BLE device act as a master, the response key means you hope which types of key of the slave should distribut to you,