【Nordic博文分享系列】BluetoothLE安全机制以及在nRFConnectSDK中的应用

STK=s1(TK,LP_RAND_R,LP_RAND_I)

Alice: DHKey = P256(SKa, PKb) Bob: DHKey = P256(SKb, PKa)

/*** @brief Clear pairing information.** @param id  Local identity (mostly just BT_ID_DEFAULT).* @param addr Remote address, NULL or BT_ADDR_LE_ANY to clear all remote                 *             devices.** @return 0 on success or negative error value on failure.*/int bt_unpair(unit8_t id, const bt_addr_le_t *addr);

config BT_SMP    bool "Security Manager Protocol support"    select BT_CRYPTO    select BT_RPA    select BT_ECC    help      This option enables support for the Security Manager Protocol      (SMP), making it possible to pair devices over LE.

int bt_smp_init(void){  static struct bt_pub_key_cb pub_key_cb = {    .func           = bt_smp_pkey_ready,  };
  sc_supported = le_sc_supported();  if (IS_ENABLED(CONFIG_BT_SMP_SC_PAIR_ONLY) && !sc_supported) {    LOG_ERR("SC Pair Only Mode selected but LE SC not supported");    return -ENOENT;  }
  if (IS_ENABLED(CONFIG_BT_SMP_USB_HCI_CTLR_WORKAROUND)) {    LOG_WRN("BT_SMP_USB_HCI_CTLR_WORKAROUND is enabled, which "      "exposes a security vulnerability!");  }
  LOG_DBG("LE SC %s", sc_supported ? "enabled" : "disabled");
  if (!IS_ENABLED(CONFIG_BT_SMP_OOB_LEGACY_PAIR_ONLY)) {    bt_pub_key_gen(&pub_key_cb);  }
  return smp_self_test();}

static void read_supported_commands_complete(struct net_buf *buf){  struct bt_hci_rp_read_supported_commands *rp = (void *)buf->data;
  LOG_DBG("status 0x%02x", rp->status);
  memcpy(bt_dev.supported_commands, rp->commands,         sizeof(bt_dev.supported_commands));
  /* Report additional HCI commands used for ECDH as   * supported if TinyCrypt ECC is used for emulation.   */  if (IS_ENABLED(CONFIG_BT_TINYCRYPT_ECC)) {    bt_hci_ecc_supported_commands(bt_dev.supported_commands);  }}

config BT_SMP_OOB_LEGACY_PAIR_ONLY    bool "Force Out Of Band Legacy pairing"    depends on !(BT_SMP_SC_PAIR_ONLY || BT_SMP_SC_ONLY)    help      This option disables Legacy and LE SC pairing and forces legacy OOB.

config BT_CTLR_ECDH    bool "Elliptic Curve Diffie-Hellman (ECDH)"    depends on BT_CTLR_ECDH_SUPPORT    default y    help      Enable support for Bluetooth v4.2 Elliptic Curve Diffie-Hellman      feature in the controller.

/** @brief Set security level for a connection. * *  This function enable security (encryption) for a connection. If the device *  has bond information for the peer with sufficiently strong key encryption *  will be enabled. If the connection is already encrypted with sufficiently *  strong key this function does nothing. * *  If the device has no bond information for the peer and is not already paired *  then the pairing procedure will be initiated. Note that @p sec has no effect *  on the security level selected for the pairing process. The selection is *  instead controlled by the values of the registered @ref bt_conn_auth_cb. If *  the device has bond information or is already paired and the keys are too *  weak then the pairing procedure will be initiated. * *  This function may return error if required level of security is not possible *  to achieve due to local or remote device limitation (e.g., input output *  capabilities), or if the maximum number of paired devices has been reached. * *  This function may return error if the pairing procedure has already been *  initiated by the local device or the peer device. * *  @note When @kconfig{CONFIG_BT_SMP_SC_ONLY} is enabled then the security *        level will always be level 4. * *  @note When @kconfig{CONFIG_BT_SMP_OOB_LEGACY_PAIR_ONLY} is enabled then the *        security level will always be level 3. * *  @note When @ref BT_SECURITY_FORCE_PAIR within @p sec is enabled then the pairing *        procedure will always be initiated. * *  @param conn Connection object. *  @param sec Requested security level. * *  @return 0 on success or negative error */int bt_conn_set_security(struct bt_conn *conn, bt_security_t sec);

config BT_SMP_ENFORCE_MITM    bool "Enforce MITM protection"    default y    help      with this option enabled, the Security Manager will set MITM option in      the Authentication Requirements Flags whenever local IO Capabilities      allow the generated key to be authenticated.

/** @brief Allow/disallow remote LE SC OOB data to be used for pairing. * *  Set/clear the OOB data flag for LE SC SMP Pairing Request/Response data. * *  @param enable Value allowing/disallowing remote LE SC OOB data. */void bt_le_oob_set_sc_flag(bool enable);

void bt_le_oob_set_sc_flag(bool enable){  sc_oobd_present = enable;}
void bt_le_oob_set_legacy_flag(bool enable){  legacy_oobd_present = enable;}

/** * @brief LE OOB record payload descriptor. */struct nfc_ndef_le_oob_rec_payload_desc {  bt_addr_le_t *addr;  enum nfc_ndef_le_oob_rec_le_role *le_role;  struct bt_le_oob_sc_data *le_sc_data;  uint8_t *tk_value;  uint16_t *appearance;  uint8_t *flags;  const char *local_name;};

/** * @brief Get local LE Out of Band (OOB) information. * * This function allows to get local information that are useful for * Out of Band pairing or connection creation. * * If privacy @kconfig{CONFIG_BT_PRIVACY} is enabled this will result in * generating new Resolvable Private Address (RPA) that is valid for * @kconfig{CONFIG_BT_RPA_TIMEOUT} seconds. This address will be used for * advertising started by @ref bt_le_adv_start, active scanning and * connection creation. * * @note If privacy is enabled the RPA cannot be refreshed in the following *       cases: *       - Creating a connection in progress, wait for the connected callback. *      In addition when extended advertising @kconfig{CONFIG_BT_EXT_ADV} is *      not enabled or not supported by the controller: *       - Advertiser is enabled using a Random Static Identity Address for a *         different local identity. *       - The local identity conflicts with the local identity used by other *         roles. * * @param[in]  id  Local identity, in most cases BT_ID_DEFAULT. * @param[out] oob LE OOB information * * @return Zero on success or error code otherwise, positive in case of *         protocol error or negative (POSIX) in case of stack internal error. */int bt_le_oob_get_local(uint8_t id, struct bt_le_oob *oob);

/** @brief Set OOB data during LE Secure Connections (SC) pairing procedure * *  This function allows to set OOB data during the LE SC pairing procedure. *  The function should only be called in response to the oob_data_request() *  callback provided that LE SC method is used for pairing. * *  The user should submit OOB data according to the information received in the *  callback. This may yield three different configurations: with only local OOB *  data present, with only remote OOB data present or with both local and *  remote OOB data present. * *  @param conn Connection object *  @param oobd_local Local OOB data or NULL if not present *  @param oobd_remote Remote OOB data or NULL if not present * *  @return Zero on success or error code otherwise, positive in case of *          protocol error or negative (POSIX) in case of stack internal error. */int bt_le_oob_set_sc_data(struct bt_conn *conn,        const struct bt_le_oob_sc_data *oobd_local,        const struct bt_le_oob_sc_data *oobd_remote);

/** @brief Set OOB Temporary Key to be used for pairing * *  This function allows to set OOB data for the LE legacy pairing procedure. *  The function should only be called in response to the oob_data_request() *  callback provided that the legacy method is user pairing. * *  @param conn Connection object *  @param tk Pointer to 16 byte long TK array * *  @return Zero on success or -EINVAL if NULL */int bt_le_oob_set_legacy_tk(struct bt_conn *conn, const uint8_t *tk);

#define BT_SMP_IO_DISPLAY_ONLY 0x00 #define BT_SMP_IO_DISPLAY_YESNO 0x01 #define BT_SMP_IO_KEYBOARD_ONLY 0x02 #define BT_SMP_IO_NO_INPUT_OUTPUT 0x03 #define BT_SMP_IO_KEYBOARD_DISPLAY 0x04

static uint8_t get_io_capa(struct bt_smp *smp){  const struct bt_conn_auth_cb *smp_auth_cb = latch_auth_cb(smp);
  if (!smp_auth_cb) {    goto no_callbacks;  }
  /* Passkey Confirmation is valid only for LE SC */  if (smp_auth_cb->passkey_display && smp_auth_cb->passkey_entry &&      (smp_auth_cb->passkey_confirm || !sc_supported)) {    return BT_SMP_IO_KEYBOARD_DISPLAY;  }
  /* DisplayYesNo is useful only for LE SC */  if (sc_supported && smp_auth_cb->passkey_display &&      smp_auth_cb->passkey_confirm) {    return BT_SMP_IO_DISPLAY_YESNO;  }
  if (smp_auth_cb->passkey_entry) {    if (IS_ENABLED(CONFIG_BT_FIXED_PASSKEY) &&        fixed_passkey != BT_PASSKEY_INVALID) {      return BT_SMP_IO_KEYBOARD_DISPLAY;    } else {      return BT_SMP_IO_KEYBOARD_ONLY;    }  }
  if (smp_auth_cb->passkey_display) {    return BT_SMP_IO_DISPLAY_ONLY;  }
no_callbacks:  if (IS_ENABLED(CONFIG_BT_FIXED_PASSKEY) &&      fixed_passkey != BT_PASSKEY_INVALID) {    return BT_SMP_IO_DISPLAY_ONLY;  } else {    return BT_SMP_IO_NO_INPUT_OUTPUT;  }}

config BT_FOEXED_PASSKEY    bool "Use a fixed passkey for pairing"    help      With this option enabled, the application will be able to call the      bt_passley_set() API to set a fixed passkey. If set, the      pairing_confirm() callback will be called for all incoming pairings.

/** @brief Display a passkey to the user.   *   *  When called the application is expected to display the given   *  passkey to the user, with the expectation that the passkey will   *  then be entered on the peer device. The passkey will be in the   *  range of 0 - 999999, and is expected to be padded with zeroes so   *  that six digits are always shown. E.g. the value 37 should be   *  shown as 000037.   *   *  This callback may be set to NULL, which means that the local   *  device lacks the ability do display a passkey. If set   *  to non-NULL the cancel callback must also be provided, since   *  this is the only way the application can find out that it should   *  stop displaying the passkey.   *   *  @param conn Connection where pairing is currently active.   *  @param passkey Passkey to show to the user.   */  void (*passkey_display)(struct bt_conn *conn, unsigned int passkey);
#if defined(CONFIG_BT_PASSKEY_KEYPRESS)  /** @brief Receive Passkey Keypress Notification during pairing   *   *  This allows the remote device to use the local device to give users   *  feedback on the progress of entering the passkey over there. This is   *  useful when the remote device itself has no display suitable for   *  showing the progress.   *   *  The handler of this callback is expected to keep track of the number   *  of digits entered and show a password-field-like feedback to the   *  user.   *   *  This callback is only relevant while the local side does Passkey   *  Display.   *   *  The event type is verified to be in range of the enum. No other   *  sanitization has been done. The remote could send a large number of   *  events of any type in any order.   *   *  @param conn The related connection.   *  @param type Type of event. Verified in range of the enum.   */  void (*passkey_display_keypress)(struct bt_conn *conn,           enum bt_conn_auth_keypress type);#endif

/** @brief Request the user to enter a passkey.   *   *  When called the user is expected to enter a passkey. The passkey   *  must be in the range of 0 - 999999, and should be expected to   *  be zero-padded, as that's how the peer device will typically be   *  showing it (e.g. 37 would be shown as 000037).   *   *  Once the user has entered the passkey its value should be given   *  to the stack using the bt_conn_auth_passkey_entry() API.   *   *  This callback may be set to NULL, which means that the local   *  device lacks the ability to enter a passkey. If set to non-NULL   *  the cancel callback must also be provided, since this is the   *  only way the application can find out that it should stop   *  requesting the user to enter a passkey.   *   *  @param conn Connection where pairing is currently active.   */  void (*passkey_entry)(struct bt_conn *conn);

/** @brief Request the user to confirm a passkey.   *   *  When called the user is expected to confirm that the given   *  passkey is also shown on the peer device.. The passkey will   *  be in the range of 0 - 999999, and should be zero-padded to   *  always be six digits (e.g. 37 would be shown as 000037).   *   *  Once the user has confirmed the passkey to match, the   *  bt_conn_auth_passkey_confirm() API should be called. If the   *  user concluded that the passkey doesn't match the   *  bt_conn_auth_cancel() API should be called.   *   *  This callback may be set to NULL, which means that the local   *  device lacks the ability to confirm a passkey. If set to non-NULL   *  the cancel callback must also be provided, since this is the   *  only way the application can find out that it should stop   *  requesting the user to confirm a passkey.   *   *  @param conn Connection where pairing is currently active.   *  @param passkey Passkey to be confirmed.   */  void (*passkey_confirm)(struct bt_conn *conn, unsigned int passkey);

/** @brief Request confirmation for an incoming pairing.   *   *  This callback will be called to confirm an incoming pairing   *  request where none of the other user callbacks is applicable.   *   *  If the user decides to accept the pairing the   *  bt_conn_auth_pairing_confirm() API should be called. If the   *  user decides to reject the pairing the bt_conn_auth_cancel() API   *  should be called.   *   *  This callback may be set to NULL, which means that the local   *  device lacks the ability to confirm a pairing request. If set   *  to non-NULL the cancel callback must also be provided, since   *  this is the only way the application can find out that it should   *  stop requesting the user to confirm a pairing request.   *   *  @param conn Connection where pairing is currently active.   */  void (*pairing_confirm)(struct bt_conn *conn);

/** @brief Request the user to provide Out of Band (OOB) data.   *   *  When called the user is expected to provide OOB data. The required   *  data are indicated by the information structure.   *   *  For LE Secure Connections OOB pairing, the user should provide   *  local OOB data, remote OOB data or both depending on their   *  availability. Their value should be given to the stack using the   *  bt_le_oob_set_sc_data() API.   *   *  This callback must be set to non-NULL in order to support OOB   *  pairing.   *   *  @param conn Connection where pairing is currently active.   *  @param info OOB pairing information.   */  void (*oob_data_request)(struct bt_conn *conn,         struct bt_conn_oob_info *info);

*  On any incoming pairing req/rsp this callback will be called for   *  the application to decide whether to allow for the pairing to   *  continue.   *   *  The pairing info received from the peer is passed to assist   *  making the decision.   *   *  As this callback is synchronous the application should return   *  a response value immediately. Otherwise it may affect the   *  timing during pairing. Hence, this information should not be   *  conveyed to the user to take action.   *   *  The remaining callbacks are not affected by this, but do notice   *  that other callbacks can be called during the pairing. Eg. if   *  pairing_confirm is registered both will be called for Just-Works   *  pairings.   *   *  This callback may be unregistered in which case pairing continues   *  as if the Kconfig flag was not set.   *   *  This callback is not called for BR/EDR Secure Simple Pairing (SSP).   *   *  @param conn Connection where pairing is initiated.   *  @param feat Pairing req/resp info.   */  enum bt_security_err (*pairing_accept)(struct bt_conn *conn,            const struct bt_conn_pairing_feat *const feat);

/** @brief Cancel the ongoing user request.   *   *  This callback will be called to notify the application that it   *  should cancel any previous user request (passkey display, entry   *  or confirmation).   *   *  This may be set to NULL, but must always be provided whenever the   *  passkey_display, passkey_entry passkey_confirm or pairing_confirm   *  callback has been provided.   *   *  @param conn Connection where pairing is currently active.   */  void (*cancel)(struct bt_conn *conn);

//display onlystatic struct bt_conn_auth_cb conn_auth_callbacks = {  .passkey_display = auth_passkey_display,  .cancel = auth_cancel,};

//display yes nostatic struct bt_conn_auth_cb conn_auth_callbacks = {  .passkey_display = auth_passkey_display,  .passkey_confirm = auth_passkey_confirm,  .cancel = auth_cancel,};

//Keyboard displaystatic struct bt_conn_auth_cb conn_auth_callbacks = {  .passkey_display = auth_passkey_display,  .passkey_entry = auth_passkey_entry,  .passkey_confirm = auth_passkey_confirm,  .cancel = auth_cancel,};

/** Authenticated pairing information callback structure */struct bt_conn_auth_info_cb {  /** @brief notify that pairing procedure was complete.   *   *  This callback notifies the application that the pairing procedure   *  has been completed.   *   *  @param conn Connection object.   *  @param bonded Bond information has been distributed during the   *                pairing procedure.   */  void (*pairing_complete)(struct bt_conn *conn, bool bonded);
  /** @brief notify that pairing process has failed.   *   *  @param conn Connection object.   *  @param reason Pairing failed reason   */  void (*pairing_failed)(struct bt_conn *conn,             enum bt_security_err reason);
  /** @brief Notify that bond has been deleted.   *   *  This callback notifies the application that the bond information   *  for the remote peer has been deleted   *   *  @param id   Which local identity had the bond.   *  @param peer Remote address.   */  void (*bond_deleted)(uint8_t id, const bt_addr_le_t *peer);
  /** Internally used field for list handling */  sys_snode_t node;};

static struct bt_conn_auth_info_cb conn_auth_info_callbacks = {  .pairing_complete = pairing_complete,  .pairing_failed = pairing_failed};