stack/smp/smp_act.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2003-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 #include <string.h>
  20 #include "device/include/interop.h"
  21 #include "include/bt_target.h"
  22 #include "stack/btm/btm_int.h"
  23 #include "stack/include/l2c_api.h"
  24 #include "stack/smp/smp_int.h"
  25 #include "utils/include/bt_utils.h"
  26
  27 extern fixed_queue_t *btu_general_alarm_queue;
  28
  29 #if SMP_INCLUDED == TRUE
  30 const UINT8 smp_association_table[2][SMP_IO_CAP_MAX][SMP_IO_CAP_MAX] =
  31 {
  32     /* initiator */
  33     {{SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_PASSKEY,   SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_PASSKEY}, /* Display Only */
  34         {SMP_MODEL_ENCRYPTION_ONLY,  SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_PASSKEY, SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_PASSKEY}, /* SMP_CAP_IO = 1 */
  35         {SMP_MODEL_KEY_NOTIF, SMP_MODEL_KEY_NOTIF,  SMP_MODEL_PASSKEY,   SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_KEY_NOTIF}, /* keyboard only */
  36         {SMP_MODEL_ENCRYPTION_ONLY,  SMP_MODEL_ENCRYPTION_ONLY,   SMP_MODEL_ENCRYPTION_ONLY,  SMP_MODEL_ENCRYPTION_ONLY,    SMP_MODEL_ENCRYPTION_ONLY},/* No Input No Output */
  37         {SMP_MODEL_KEY_NOTIF, SMP_MODEL_KEY_NOTIF,  SMP_MODEL_PASSKEY,   SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_KEY_NOTIF}}, /* keyboard display */
  38     /* responder */
  39     {{SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_ENCRYPTION_ONLY,   SMP_MODEL_KEY_NOTIF, SMP_MODEL_ENCRYPTION_ONLY,    SMP_MODEL_KEY_NOTIF}, /* Display Only */
  40         {SMP_MODEL_ENCRYPTION_ONLY,  SMP_MODEL_ENCRYPTION_ONLY,   SMP_MODEL_KEY_NOTIF,   SMP_MODEL_ENCRYPTION_ONLY,    SMP_MODEL_KEY_NOTIF}, /* SMP_CAP_IO = 1 */
  41         {SMP_MODEL_PASSKEY,   SMP_MODEL_PASSKEY,    SMP_MODEL_PASSKEY,   SMP_MODEL_ENCRYPTION_ONLY,    SMP_MODEL_PASSKEY}, /* keyboard only */
  42         {SMP_MODEL_ENCRYPTION_ONLY,  SMP_MODEL_ENCRYPTION_ONLY,   SMP_MODEL_ENCRYPTION_ONLY,  SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_ENCRYPTION_ONLY},/* No Input No Output */
  43         {SMP_MODEL_PASSKEY,   SMP_MODEL_PASSKEY,    SMP_MODEL_KEY_NOTIF, SMP_MODEL_ENCRYPTION_ONLY, SMP_MODEL_PASSKEY}} /* keyboard display */
  44     /* display only */    /*SMP_CAP_IO = 1 */  /* keyboard only */   /* No InputOutput */  /* keyboard display */
  45 };
  46
  47 #define SMP_KEY_DIST_TYPE_MAX       4
  48 const tSMP_ACT smp_distribute_act [] =
  49 {
  50     smp_generate_ltk,
  51     smp_send_id_info,
  52     smp_generate_csrk,
  53     smp_set_derive_link_key
  54 };
  55
  56 static bool lmp_version_below(BD_ADDR bda, uint8_t version)
  57 {
  58     tACL_CONN *acl = btm_bda_to_acl(bda, BT_TRANSPORT_LE);
  59     if (acl == NULL || acl->lmp_version == 0)
  60     {
  61         SMP_TRACE_WARNING("%s cannot retrieve LMP version...", __func__);
  62         return false;
  63     }
  64     SMP_TRACE_WARNING("%s LMP version %d < %d", __func__, acl->lmp_version, version);
  65     return acl->lmp_version < version;
  66 }
  67
  68 static bool pts_test_send_authentication_complete_failure(tSMP_CB *p_cb)
  69 {
  70     uint8_t reason = 0;
  71
  72     if (p_cb->cert_failure < 2 || p_cb->cert_failure > 6)
  73         return false;
  74
  75     SMP_TRACE_ERROR("%s failure case = %d", __func__, p_cb->cert_failure);
  76
  77     switch (p_cb->cert_failure)
  78     {
  79         case 2:
  80             reason = SMP_PAIR_AUTH_FAIL;
  81             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
  82             break;
  83         case 3:
  84             reason = SMP_PAIR_FAIL_UNKNOWN;
  85             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
  86             break;
  87         case 4:
  88             reason = SMP_PAIR_NOT_SUPPORT;
  89             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
  90             break;
  91         case 5:
  92             reason = SMP_PASSKEY_ENTRY_FAIL;
  93             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
  94             break;
  95         case 6:
  96             reason = SMP_REPEATED_ATTEMPTS;
  97             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
  98             break;
  99     }
 100
 101     return true;;
 102 }
 103
 104 /*******************************************************************************
 105 ** Function         smp_update_key_mask
 106 ** Description      This function updates the key mask for sending or receiving.
 107 *******************************************************************************/
 108 static void smp_update_key_mask (tSMP_CB *p_cb, UINT8 key_type, BOOLEAN recv)
 109 {
 110     SMP_TRACE_DEBUG("%s before update role=%d recv=%d local_i_key = %02x, local_r_key = %02x",
 111         __func__, p_cb->role, recv, p_cb->local_i_key, p_cb->local_r_key);
 112
 113     if (((p_cb->le_secure_connections_mode_is_used) ||
 114         (p_cb->smp_over_br)) &&
 115         ((key_type == SMP_SEC_KEY_TYPE_ENC) || (key_type == SMP_SEC_KEY_TYPE_LK)))
 116     {
 117         /* in LE SC mode LTK, CSRK and BR/EDR LK are derived locally instead of
 118         ** being exchanged with the peer */
 119         p_cb->local_i_key &= ~key_type;
 120         p_cb->local_r_key &= ~key_type;
 121     }
 122     else
 123     if (p_cb->role == HCI_ROLE_SLAVE)
 124     {
 125         if (recv)
 126             p_cb->local_i_key &= ~key_type;
 127         else
 128             p_cb->local_r_key &= ~key_type;
 129     }
 130     else
 131     {
 132         if (recv)
 133             p_cb->local_r_key &= ~key_type;
 134         else
 135             p_cb->local_i_key &= ~key_type;
 136     }
 137
 138     SMP_TRACE_DEBUG("updated local_i_key = %02x, local_r_key = %02x", p_cb->local_i_key,
 139                       p_cb->local_r_key);
 140 }
 141
 142 /*******************************************************************************
 143 ** Function     smp_send_app_cback
 144 ** Description  notifies application about the events the application is interested in
 145 *******************************************************************************/
 146 void smp_send_app_cback(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 147 {
 148     tSMP_EVT_DATA   cb_data;
 149     tSMP_STATUS callback_rc;
 150     SMP_TRACE_DEBUG("%s p_cb->cb_evt=%d", __func__, p_cb->cb_evt);
 151     if (p_cb->p_callback && p_cb->cb_evt != 0)
 152     {
 153         switch (p_cb->cb_evt)
 154         {
 155             case SMP_IO_CAP_REQ_EVT:
 156                 cb_data.io_req.auth_req = p_cb->peer_auth_req;
 157                 cb_data.io_req.oob_data = SMP_OOB_NONE;
 158                 cb_data.io_req.io_cap = SMP_DEFAULT_IO_CAPS;
 159                 cb_data.io_req.max_key_size = SMP_MAX_ENC_KEY_SIZE;
 160                 cb_data.io_req.init_keys = p_cb->local_i_key ;
 161                 cb_data.io_req.resp_keys = p_cb->local_r_key ;
 162                 SMP_TRACE_WARNING ( "io_cap = %d",cb_data.io_req.io_cap);
 163                 break;
 164
 165             case SMP_NC_REQ_EVT:
 166                 cb_data.passkey = p_data->passkey;
 167                 break;
 168             case SMP_SC_OOB_REQ_EVT:
 169                 cb_data.req_oob_type = p_data->req_oob_type;
 170                 break;
 171             case SMP_SC_LOC_OOB_DATA_UP_EVT:
 172                 cb_data.loc_oob_data = p_cb->sc_oob_data.loc_oob_data;
 173                 break;
 174
 175             case SMP_BR_KEYS_REQ_EVT:
 176                 cb_data.io_req.auth_req = 0;
 177                 cb_data.io_req.oob_data = SMP_OOB_NONE;
 178                 cb_data.io_req.io_cap = 0;
 179                 cb_data.io_req.max_key_size = SMP_MAX_ENC_KEY_SIZE;
 180                 cb_data.io_req.init_keys = SMP_BR_SEC_DEFAULT_KEY;
 181                 cb_data.io_req.resp_keys = SMP_BR_SEC_DEFAULT_KEY;
 182                 break;
 183
 184             default:
 185                 break;
 186         }
 187
 188         callback_rc = (*p_cb->p_callback)(p_cb->cb_evt, p_cb->pairing_bda, &cb_data);
 189
 190         SMP_TRACE_DEBUG("callback_rc=%d  p_cb->cb_evt=%d",callback_rc, p_cb->cb_evt );
 191
 192         if (callback_rc == SMP_SUCCESS)
 193         {
 194             switch (p_cb->cb_evt)
 195             {
 196                 case SMP_IO_CAP_REQ_EVT:
 197                     p_cb->loc_auth_req   = cb_data.io_req.auth_req;
 198                     p_cb->local_io_capability  = cb_data.io_req.io_cap;
 199                     p_cb->loc_oob_flag = cb_data.io_req.oob_data;
 200                     p_cb->loc_enc_size = cb_data.io_req.max_key_size;
 201                     p_cb->local_i_key = cb_data.io_req.init_keys;
 202                     p_cb->local_r_key = cb_data.io_req.resp_keys;
 203
 204                     if (!(p_cb->loc_auth_req & SMP_AUTH_BOND))
 205                     {
 206                         SMP_TRACE_WARNING ("Non bonding: No keys will be exchanged");
 207                         p_cb->local_i_key = 0;
 208                         p_cb->local_r_key = 0;
 209                     }
 210
 211                     SMP_TRACE_WARNING ( "rcvd auth_req: 0x%02x, io_cap: %d \
 212                         loc_oob_flag: %d loc_enc_size: %d,"
 213                         "local_i_key: 0x%02x, local_r_key: 0x%02x",
 214                         p_cb->loc_auth_req, p_cb->local_io_capability, p_cb->loc_oob_flag,
 215                         p_cb->loc_enc_size, p_cb->local_i_key, p_cb->local_r_key);
 216
 217                     p_cb->secure_connections_only_mode_required =
 218                         (btm_cb.security_mode == BTM_SEC_MODE_SC) ? TRUE : FALSE;
 219
 220                     if (p_cb->secure_connections_only_mode_required)
 221                     {
 222                         p_cb->loc_auth_req |= SMP_SC_SUPPORT_BIT;
 223                     }
 224
 225                     if (!(p_cb->loc_auth_req & SMP_SC_SUPPORT_BIT)
 226                         || lmp_version_below(p_cb->pairing_bda, HCI_PROTO_VERSION_4_2)
 227                         || interop_match_addr(INTEROP_DISABLE_LE_SECURE_CONNECTIONS,
 228                             (const bt_bdaddr_t *)&p_cb->pairing_bda))
 229                     {
 230                         p_cb->loc_auth_req &= ~SMP_KP_SUPPORT_BIT;
 231                         p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
 232                         p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
 233                     }
 234
 235                     SMP_TRACE_WARNING("set auth_req: 0x%02x, local_i_key: 0x%02x, local_r_key: 0x%02x",
 236                         p_cb->loc_auth_req, p_cb->local_i_key, p_cb->local_r_key);
 237
 238                     smp_sm_event(p_cb, SMP_IO_RSP_EVT, NULL);
 239                     break;
 240
 241                 case SMP_BR_KEYS_REQ_EVT:
 242                     p_cb->loc_enc_size = cb_data.io_req.max_key_size;
 243                     p_cb->local_i_key = cb_data.io_req.init_keys;
 244                     p_cb->local_r_key = cb_data.io_req.resp_keys;
 245
 246                     p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
 247                     p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
 248
 249                     SMP_TRACE_WARNING ( "for SMP over BR max_key_size: 0x%02x,\
 250                         local_i_key: 0x%02x, local_r_key: 0x%02x",
 251                         p_cb->loc_enc_size, p_cb->local_i_key, p_cb->local_r_key);
 252
 253                     smp_br_state_machine_event(p_cb, SMP_BR_KEYS_RSP_EVT, NULL);
 254                     break;
 255             }
 256         }
 257     }
 258
 259     if (!p_cb->cb_evt && p_cb->discard_sec_req)
 260     {
 261         p_cb->discard_sec_req = FALSE;
 262         smp_sm_event(p_cb, SMP_DISCARD_SEC_REQ_EVT, NULL);
 263     }
 264
 265     SMP_TRACE_DEBUG("%s return", __func__);
 266 }
 267
 268 /*******************************************************************************
 269 ** Function     smp_send_pair_fail
 270 ** Description  pairing failure to peer device if needed.
 271 *******************************************************************************/
 272 void smp_send_pair_fail(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 273 {
 274     p_cb->status = *(UINT8 *)p_data;
 275     p_cb->failure = *(UINT8 *)p_data;
 276
 277     SMP_TRACE_DEBUG("%s status=%d failure=%d ", __func__, p_cb->status, p_cb->failure);
 278
 279     if (p_cb->status <= SMP_MAX_FAIL_RSN_PER_SPEC && p_cb->status != SMP_SUCCESS)
 280     {
 281         smp_send_cmd(SMP_OPCODE_PAIRING_FAILED, p_cb);
 282         p_cb->wait_for_authorization_complete = TRUE;
 283     }
 284 }
 285
 286 /*******************************************************************************
 287 ** Function     smp_send_pair_req
 288 ** Description  actions related to sending pairing request
 289 *******************************************************************************/
 290 void smp_send_pair_req(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 291 {
 292     tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (p_cb->pairing_bda);
 293     SMP_TRACE_DEBUG("%s", __func__);
 294
 295     /* erase all keys when master sends pairing req*/
 296     if (p_dev_rec)
 297         btm_sec_clear_ble_keys(p_dev_rec);
 298     /* do not manipulate the key, let app decide,
 299        leave out to BTM to mandate key distribution for bonding case */
 300     smp_send_cmd(SMP_OPCODE_PAIRING_REQ, p_cb);
 301 }
 302
 303 /*******************************************************************************
 304 ** Function     smp_send_pair_rsp
 305 ** Description  actions related to sending pairing response
 306 *******************************************************************************/
 307 void smp_send_pair_rsp(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 308 {
 309     SMP_TRACE_DEBUG("%s", __func__);
 310
 311     p_cb->local_i_key &= p_cb->peer_i_key;
 312     p_cb->local_r_key &= p_cb->peer_r_key;
 313
 314     if (smp_send_cmd (SMP_OPCODE_PAIRING_RSP, p_cb))
 315     {
 316         if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_OOB)
 317             smp_use_oob_private_key(p_cb, NULL);
 318         else
 319             smp_decide_association_model(p_cb, NULL);
 320     }
 321 }
 322
 323 /*******************************************************************************
 324 ** Function     smp_send_confirm
 325 ** Description  send confirmation to the peer
 326 *******************************************************************************/
 327 void smp_send_confirm(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 328 {
 329     SMP_TRACE_DEBUG("%s", __func__);
 330     smp_send_cmd(SMP_OPCODE_CONFIRM, p_cb);
 331 }
 332
 333 /*******************************************************************************
 334 ** Function     smp_send_init
 335 ** Description  process pairing initializer to slave device
 336 *******************************************************************************/
 337 void smp_send_init(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 338 {
 339     SMP_TRACE_DEBUG("%s", __func__);
 340     smp_send_cmd(SMP_OPCODE_INIT, p_cb);
 341 }
 342
 343 /*******************************************************************************
 344 ** Function     smp_send_rand
 345 ** Description  send pairing random to the peer
 346 *******************************************************************************/
 347 void smp_send_rand(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 348 {
 349     SMP_TRACE_DEBUG("%s", __func__);
 350     smp_send_cmd(SMP_OPCODE_RAND, p_cb);
 351 }
 352
 353 /*******************************************************************************
 354 ** Function     smp_send_pair_public_key
 355 ** Description  send pairing public key command to the peer
 356 *******************************************************************************/
 357 void smp_send_pair_public_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 358 {
 359     SMP_TRACE_DEBUG("%s", __func__);
 360     smp_send_cmd(SMP_OPCODE_PAIR_PUBLIC_KEY, p_cb);
 361 }
 362
 363 /*******************************************************************************
 364 ** Function     SMP_SEND_COMMITMENT
 365 ** Description send commitment command to the peer
 366 *******************************************************************************/
 367 void smp_send_commitment(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 368 {
 369     SMP_TRACE_DEBUG("%s", __func__);
 370     smp_send_cmd(SMP_OPCODE_PAIR_COMMITM, p_cb);
 371 }
 372
 373 /*******************************************************************************
 374 ** Function     smp_send_dhkey_check
 375 ** Description send DHKey Check command to the peer
 376 *******************************************************************************/
 377 void smp_send_dhkey_check(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 378 {
 379     SMP_TRACE_DEBUG("%s", __func__);
 380     smp_send_cmd(SMP_OPCODE_PAIR_DHKEY_CHECK, p_cb);
 381 }
 382
 383 /*******************************************************************************
 384 ** Function     smp_send_keypress_notification
 385 ** Description send Keypress Notification command to the peer
 386 *******************************************************************************/
 387 void smp_send_keypress_notification(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 388 {
 389     p_cb->local_keypress_notification = *(UINT8 *) p_data;
 390     smp_send_cmd(SMP_OPCODE_PAIR_KEYPR_NOTIF, p_cb);
 391 }
 392
 393 /*******************************************************************************
 394 ** Function     smp_send_enc_info
 395 ** Description  send encryption information command.
 396 *******************************************************************************/
 397 void smp_send_enc_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 398 {
 399     tBTM_LE_LENC_KEYS   le_key;
 400
 401     SMP_TRACE_DEBUG("%s p_cb->loc_enc_size = %d", __func__, p_cb->loc_enc_size);
 402     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ENC, FALSE);
 403
 404     smp_send_cmd(SMP_OPCODE_ENCRYPT_INFO, p_cb);
 405     smp_send_cmd(SMP_OPCODE_MASTER_ID, p_cb);
 406
 407     /* save the DIV and key size information when acting as slave device */
 408     memcpy(le_key.ltk, p_cb->ltk, BT_OCTET16_LEN);
 409     le_key.div =  p_cb->div;
 410     le_key.key_size = p_cb->loc_enc_size;
 411     le_key.sec_level = p_cb->sec_level;
 412
 413     if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
 414         btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LENC,
 415                             (tBTM_LE_KEY_VALUE *)&le_key, TRUE);
 416
 417     SMP_TRACE_WARNING ("%s", __func__);
 418
 419     smp_key_distribution(p_cb, NULL);
 420 }
 421
 422 /*******************************************************************************
 423 ** Function     smp_send_id_info
 424 ** Description  send ID information command.
 425 *******************************************************************************/
 426 void smp_send_id_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 427 {
 428     tBTM_LE_KEY_VALUE   le_key;
 429     SMP_TRACE_DEBUG("%s", __func__);
 430     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ID, FALSE);
 431
 432     smp_send_cmd(SMP_OPCODE_IDENTITY_INFO, p_cb);
 433     smp_send_cmd(SMP_OPCODE_ID_ADDR, p_cb);
 434
 435     if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
 436         btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LID,
 437                             &le_key, TRUE);
 438
 439     SMP_TRACE_WARNING ("%s", __func__);
 440     smp_key_distribution_by_transport(p_cb, NULL);
 441 }
 442
 443 /*******************************************************************************
 444 ** Function     smp_send_csrk_info
 445 ** Description  send CSRK command.
 446 *******************************************************************************/
 447 void smp_send_csrk_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 448 {
 449     tBTM_LE_LCSRK_KEYS  key;
 450     SMP_TRACE_DEBUG("%s", __func__);
 451     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_CSRK, FALSE);
 452
 453     if (smp_send_cmd(SMP_OPCODE_SIGN_INFO, p_cb))
 454     {
 455         key.div = p_cb->div;
 456         key.sec_level = p_cb->sec_level;
 457         key.counter = 0; /* initialize the local counter */
 458         memcpy (key.csrk, p_cb->csrk, BT_OCTET16_LEN);
 459         btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LCSRK, (tBTM_LE_KEY_VALUE *)&key, TRUE);
 460     }
 461
 462     smp_key_distribution_by_transport(p_cb, NULL);
 463 }
 464
 465 /*******************************************************************************
 466 ** Function     smp_send_ltk_reply
 467 ** Description  send LTK reply
 468 *******************************************************************************/
 469 void smp_send_ltk_reply(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 470 {
 471     SMP_TRACE_DEBUG("%s", __func__);
 472     /* send stk as LTK response */
 473     btm_ble_ltk_request_reply(p_cb->pairing_bda, TRUE, p_data->key.p_data);
 474 }
 475
 476 /*******************************************************************************
 477 ** Function     smp_proc_sec_req
 478 ** Description  process security request.
 479 *******************************************************************************/
 480 void smp_proc_sec_req(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 481 {
 482     tBTM_LE_AUTH_REQ auth_req = *(tBTM_LE_AUTH_REQ *)p_data;
 483     tBTM_BLE_SEC_REQ_ACT sec_req_act;
 484     UINT8 reason;
 485
 486     SMP_TRACE_DEBUG("%s auth_req=0x%x", __func__, auth_req);
 487
 488     p_cb->cb_evt = 0;
 489
 490     btm_ble_link_sec_check(p_cb->pairing_bda, auth_req,  &sec_req_act);
 491
 492     SMP_TRACE_DEBUG("%s sec_req_act=0x%x", __func__, sec_req_act);
 493
 494     switch (sec_req_act)
 495     {
 496         case  BTM_BLE_SEC_REQ_ACT_ENCRYPT:
 497             SMP_TRACE_DEBUG("%s BTM_BLE_SEC_REQ_ACT_ENCRYPT", __func__);
 498             smp_sm_event(p_cb, SMP_ENC_REQ_EVT, NULL);
 499             break;
 500
 501         case BTM_BLE_SEC_REQ_ACT_PAIR:
 502             p_cb->secure_connections_only_mode_required =
 503                     (btm_cb.security_mode == BTM_SEC_MODE_SC) ? TRUE : FALSE;
 504
 505             /* respond to non SC pairing request as failure in SC only mode */
 506             if (p_cb->secure_connections_only_mode_required &&
 507                 (auth_req & SMP_SC_SUPPORT_BIT) == 0)
 508             {
 509                 reason = SMP_PAIR_AUTH_FAIL;
 510                 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 511             }
 512             else
 513             {
 514                 /* initialize local i/r key to be default keys */
 515                 p_cb->peer_auth_req = auth_req;
 516                 p_cb->local_r_key = p_cb->local_i_key = SMP_SEC_DEFAULT_KEY ;
 517                 p_cb->cb_evt = SMP_SEC_REQUEST_EVT;
 518             }
 519             break;
 520
 521         case BTM_BLE_SEC_REQ_ACT_DISCARD:
 522             p_cb->discard_sec_req = TRUE;
 523             break;
 524
 525         default:
 526             /* do nothing */
 527             break;
 528     }
 529 }
 530
 531 /*******************************************************************************
 532 ** Function     smp_proc_sec_grant
 533 ** Description  process security grant.
 534 *******************************************************************************/
 535 void smp_proc_sec_grant(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 536 {
 537     UINT8 res= *(UINT8 *)p_data;
 538     SMP_TRACE_DEBUG("%s", __func__);
 539     if (res != SMP_SUCCESS)
 540     {
 541         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, p_data);
 542     }
 543     else /*otherwise, start pairing */
 544     {
 545         /* send IO request callback */
 546         p_cb->cb_evt = SMP_IO_CAP_REQ_EVT;
 547     }
 548 }
 549
 550 /*******************************************************************************
 551 ** Function     smp_proc_pair_fail
 552 ** Description  process pairing failure from peer device
 553 *******************************************************************************/
 554 void smp_proc_pair_fail(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 555 {
 556     SMP_TRACE_DEBUG("%s", __func__);
 557     p_cb->status = *(UINT8 *)p_data;
 558
 559     /* Cancel pending auth complete timer if set */
 560     alarm_cancel(p_cb->delayed_auth_timer_ent);
 561 }
 562
 563 /*******************************************************************************
 564 ** Function     smp_proc_pair_cmd
 565 ** Description  Process the SMP pairing request/response from peer device
 566 *******************************************************************************/
 567 void smp_proc_pair_cmd(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 568 {
 569     UINT8   *p = (UINT8 *)p_data;
 570     UINT8   reason = SMP_ENC_KEY_SIZE;
 571     tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (p_cb->pairing_bda);
 572
 573     SMP_TRACE_DEBUG("%s", __func__);
 574     /* erase all keys if it is slave proc pairing req*/
 575     if (p_dev_rec && (p_cb->role == HCI_ROLE_SLAVE))
 576         btm_sec_clear_ble_keys(p_dev_rec);
 577
 578     p_cb->flags |= SMP_PAIR_FLAG_ENC_AFTER_PAIR;
 579
 580     STREAM_TO_UINT8(p_cb->peer_io_caps, p);
 581     STREAM_TO_UINT8(p_cb->peer_oob_flag, p);
 582     STREAM_TO_UINT8(p_cb->peer_auth_req, p);
 583     STREAM_TO_UINT8(p_cb->peer_enc_size, p);
 584     STREAM_TO_UINT8(p_cb->peer_i_key, p);
 585     STREAM_TO_UINT8(p_cb->peer_r_key, p);
 586
 587     if (smp_command_has_invalid_parameters(p_cb))
 588     {
 589         reason = SMP_INVALID_PARAMETERS;
 590         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 591         return;
 592     }
 593
 594     // PTS Testing failure modes
 595     if (pts_test_send_authentication_complete_failure(p_cb))
 596         return;
 597
 598     if (p_cb->role == HCI_ROLE_SLAVE)
 599     {
 600         if (!(p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD))
 601         {
 602             /* peer (master) started pairing sending Pairing Request */
 603             p_cb->local_i_key = p_cb->peer_i_key;
 604             p_cb->local_r_key = p_cb->peer_r_key;
 605
 606             p_cb->cb_evt = SMP_SEC_REQUEST_EVT;
 607         }
 608         else /* update local i/r key according to pairing request */
 609         {
 610             /* pairing started with this side (slave) sending Security Request */
 611             p_cb->local_i_key &= p_cb->peer_i_key;
 612             p_cb->local_r_key &= p_cb->peer_r_key;
 613             p_cb->selected_association_model = smp_select_association_model(p_cb);
 614
 615             if (p_cb->secure_connections_only_mode_required &&
 616                 (!(p_cb->le_secure_connections_mode_is_used) ||
 617                (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS)))
 618             {
 619                 SMP_TRACE_ERROR("%s pairing failed - slave requires secure connection only mode",
 620                     __func__);
 621                 reason = SMP_PAIR_AUTH_FAIL;
 622                 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 623                 return;
 624             }
 625
 626             if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_OOB)
 627             {
 628                 if (smp_request_oob_data(p_cb)) return;
 629             }
 630             else
 631             {
 632                 smp_send_pair_rsp(p_cb, NULL);
 633             }
 634         }
 635     }
 636     else /* Master receives pairing response */
 637     {
 638         p_cb->selected_association_model = smp_select_association_model(p_cb);
 639
 640         if (p_cb->secure_connections_only_mode_required &&
 641             (!(p_cb->le_secure_connections_mode_is_used) ||
 642            (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS)))
 643         {
 644             SMP_TRACE_ERROR ("Master requires secure connection only mode \
 645                 but it can't be provided -> Master fails pairing");
 646             reason = SMP_PAIR_AUTH_FAIL;
 647             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 648             return;
 649         }
 650
 651         if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_OOB)
 652         {
 653             if (smp_request_oob_data(p_cb)) return;
 654         }
 655         else
 656         {
 657             smp_decide_association_model(p_cb, NULL);
 658         }
 659     }
 660 }
 661
 662 /*******************************************************************************
 663 ** Function     smp_proc_confirm
 664 ** Description  process pairing confirm from peer device
 665 *******************************************************************************/
 666 void smp_proc_confirm(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 667 {
 668     UINT8 *p = (UINT8 *)p_data;
 669     UINT8 reason = SMP_INVALID_PARAMETERS;
 670
 671     SMP_TRACE_DEBUG("%s", __func__);
 672
 673     if (smp_command_has_invalid_parameters(p_cb))
 674     {
 675         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 676         return;
 677     }
 678
 679     if (p != NULL)
 680     {
 681         /* save the SConfirm for comparison later */
 682         STREAM_TO_ARRAY(p_cb->rconfirm, p, BT_OCTET16_LEN);
 683     }
 684
 685     p_cb->flags |= SMP_PAIR_FLAGS_CMD_CONFIRM;
 686 }
 687
 688 /*******************************************************************************
 689 ** Function     smp_proc_init
 690 ** Description  process pairing initializer from peer device
 691 *******************************************************************************/
 692 void smp_proc_init(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 693 {
 694     UINT8 *p = (UINT8 *)p_data;
 695     UINT8 reason = SMP_INVALID_PARAMETERS;
 696
 697     SMP_TRACE_DEBUG("%s", __func__);
 698
 699     if (smp_command_has_invalid_parameters(p_cb))
 700     {
 701         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 702         return;
 703     }
 704
 705     /* save the SRand for comparison */
 706     STREAM_TO_ARRAY(p_cb->rrand, p, BT_OCTET16_LEN);
 707 }
 708
 709 /*******************************************************************************
 710 ** Function     smp_proc_rand
 711 ** Description  process pairing random (nonce) from peer device
 712 *******************************************************************************/
 713 void smp_proc_rand(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 714 {
 715     UINT8 *p = (UINT8 *)p_data;
 716     UINT8 reason = SMP_INVALID_PARAMETERS;
 717
 718     SMP_TRACE_DEBUG("%s", __func__);
 719
 720     if (smp_command_has_invalid_parameters(p_cb))
 721     {
 722         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 723         return;
 724     }
 725
 726     /* save the SRand for comparison */
 727     STREAM_TO_ARRAY(p_cb->rrand, p, BT_OCTET16_LEN);
 728 }
 729
 730 /*******************************************************************************
 731 ** Function     smp_process_pairing_public_key
 732 ** Description  process pairing public key command from the peer device
 733 **              - saves the peer public key;
 734 **              - sets the flag indicating that the peer public key is received;
 735 **              - calls smp_wait_for_both_public_keys(...).
 736 **
 737 *******************************************************************************/
 738 void smp_process_pairing_public_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 739 {
 740     UINT8 *p = (UINT8 *)p_data;
 741     UINT8 reason = SMP_INVALID_PARAMETERS;
 742
 743     SMP_TRACE_DEBUG("%s", __func__);
 744
 745     if (smp_command_has_invalid_parameters(p_cb))
 746     {
 747         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 748         return;
 749     }
 750
 751     STREAM_TO_ARRAY(p_cb->peer_publ_key.x, p, BT_OCTET32_LEN);
 752     STREAM_TO_ARRAY(p_cb->peer_publ_key.y, p, BT_OCTET32_LEN);
 753     p_cb->flags |= SMP_PAIR_FLAG_HAVE_PEER_PUBL_KEY;
 754
 755     smp_wait_for_both_public_keys(p_cb, NULL);
 756 }
 757
 758 /*******************************************************************************
 759 ** Function     smp_process_pairing_commitment
 760 ** Description  process pairing commitment from peer device
 761 *******************************************************************************/
 762 void smp_process_pairing_commitment(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 763 {
 764     UINT8 *p = (UINT8 *)p_data;
 765     UINT8 reason = SMP_INVALID_PARAMETERS;
 766
 767     SMP_TRACE_DEBUG("%s", __func__);
 768
 769     if (smp_command_has_invalid_parameters(p_cb))
 770     {
 771         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 772         return;
 773     }
 774
 775     p_cb->flags |= SMP_PAIR_FLAG_HAVE_PEER_COMM;
 776
 777     if (p != NULL)
 778     {
 779         STREAM_TO_ARRAY(p_cb->remote_commitment, p, BT_OCTET16_LEN);
 780     }
 781 }
 782
 783 /*******************************************************************************
 784 ** Function     smp_process_dhkey_check
 785 ** Description  process DHKey Check from peer device
 786 *******************************************************************************/
 787 void smp_process_dhkey_check(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 788 {
 789     UINT8 *p = (UINT8 *)p_data;
 790     UINT8 reason = SMP_INVALID_PARAMETERS;
 791
 792     SMP_TRACE_DEBUG("%s", __func__);
 793
 794     if (smp_command_has_invalid_parameters(p_cb))
 795     {
 796         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 797         return;
 798     }
 799
 800     if (p != NULL)
 801     {
 802         STREAM_TO_ARRAY(p_cb->remote_dhkey_check, p, BT_OCTET16_LEN);
 803     }
 804
 805     p_cb->flags |= SMP_PAIR_FLAG_HAVE_PEER_DHK_CHK;
 806 }
 807
 808 /*******************************************************************************
 809 ** Function     smp_process_keypress_notification
 810 ** Description  process pairing keypress notification from peer device
 811 *******************************************************************************/
 812 void smp_process_keypress_notification(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 813 {
 814     UINT8 *p = (UINT8 *)p_data;
 815     UINT8 reason = SMP_INVALID_PARAMETERS;
 816
 817     SMP_TRACE_DEBUG("%s", __func__);
 818     p_cb->status = *(UINT8 *)p_data;
 819
 820     if (smp_command_has_invalid_parameters(p_cb))
 821     {
 822         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
 823         return;
 824     }
 825
 826     if (p != NULL)
 827     {
 828         STREAM_TO_UINT8(p_cb->peer_keypress_notification, p);
 829     }
 830     else
 831     {
 832         p_cb->peer_keypress_notification = BTM_SP_KEY_OUT_OF_RANGE;
 833     }
 834     p_cb->cb_evt = SMP_PEER_KEYPR_NOT_EVT;
 835 }
 836
 837 /*******************************************************************************
 838 ** Function     smp_br_process_pairing_command
 839 ** Description  Process the SMP pairing request/response from peer device via
 840 **              BR/EDR transport.
 841 *******************************************************************************/
 842 void smp_br_process_pairing_command(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 843 {
 844     UINT8   *p = (UINT8 *)p_data;
 845     UINT8   reason = SMP_ENC_KEY_SIZE;
 846     tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (p_cb->pairing_bda);
 847
 848     SMP_TRACE_DEBUG("%s", __func__);
 849     /* rejecting BR pairing request over non-SC BR link */
 850     if (!p_dev_rec->new_encryption_key_is_p256 && p_cb->role == HCI_ROLE_SLAVE)
 851     {
 852         reason = SMP_XTRANS_DERIVE_NOT_ALLOW;
 853         smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
 854         return;
 855     }
 856
 857     /* erase all keys if it is slave proc pairing req*/
 858     if (p_dev_rec && (p_cb->role == HCI_ROLE_SLAVE))
 859         btm_sec_clear_ble_keys(p_dev_rec);
 860
 861     p_cb->flags |= SMP_PAIR_FLAG_ENC_AFTER_PAIR;
 862
 863     STREAM_TO_UINT8(p_cb->peer_io_caps, p);
 864     STREAM_TO_UINT8(p_cb->peer_oob_flag, p);
 865     STREAM_TO_UINT8(p_cb->peer_auth_req, p);
 866     STREAM_TO_UINT8(p_cb->peer_enc_size, p);
 867     STREAM_TO_UINT8(p_cb->peer_i_key, p);
 868     STREAM_TO_UINT8(p_cb->peer_r_key, p);
 869
 870     if (smp_command_has_invalid_parameters(p_cb))
 871     {
 872         reason = SMP_INVALID_PARAMETERS;
 873         smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
 874         return;
 875     }
 876
 877     /* peer (master) started pairing sending Pairing Request */
 878     /* or being master device always use received i/r key as keys to distribute */
 879     p_cb->local_i_key = p_cb->peer_i_key;
 880     p_cb->local_r_key = p_cb->peer_r_key;
 881
 882     if (p_cb->role == HCI_ROLE_SLAVE)
 883     {
 884         p_dev_rec->new_encryption_key_is_p256 = FALSE;
 885         /* shortcut to skip Security Grant step */
 886         p_cb->cb_evt = SMP_BR_KEYS_REQ_EVT;
 887     }
 888     else /* Master receives pairing response */
 889     {
 890         SMP_TRACE_DEBUG("%s master rcvs valid PAIRING RESPONSE."
 891                           " Supposed to move to key distribution phase. ", __func__);
 892     }
 893
 894     /* auth_req received via BR/EDR SM channel is set to 0,
 895        but everything derived/exchanged has to be saved */
 896     p_cb->peer_auth_req |= SMP_AUTH_BOND;
 897     p_cb->loc_auth_req |= SMP_AUTH_BOND;
 898 }
 899
 900 /*******************************************************************************
 901 ** Function     smp_br_process_security_grant
 902 ** Description  process security grant in case of pairing over BR/EDR transport.
 903 *******************************************************************************/
 904 void smp_br_process_security_grant(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 905 {
 906     UINT8 res= *(UINT8 *)p_data;
 907     SMP_TRACE_DEBUG("%s", __func__);
 908     if (res != SMP_SUCCESS)
 909     {
 910         smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, p_data);
 911     }
 912     else /*otherwise, start pairing */
 913     {
 914         /* send IO request callback */
 915         p_cb->cb_evt = SMP_BR_KEYS_REQ_EVT;
 916     }
 917 }
 918
 919 /*******************************************************************************
 920 ** Function     smp_br_check_authorization_request
 921 ** Description  sets the SMP kes to be derived/distribute over BR/EDR transport
 922 **              before starting the distribution/derivation
 923 *******************************************************************************/
 924 void smp_br_check_authorization_request(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 925 {
 926     UINT8 reason = SMP_SUCCESS;
 927
 928     SMP_TRACE_DEBUG("%s rcvs i_keys=0x%x r_keys=0x%x "
 929                       "(i-initiator r-responder)", __FUNCTION__, p_cb->local_i_key,
 930                       p_cb->local_r_key);
 931
 932     /* In LE SC mode LK field is ignored when BR/EDR transport is used */
 933     p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
 934     p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
 935
 936     /* In LE SC mode only IRK, IAI, CSRK are exchanged with the peer.
 937     ** Set local_r_key on master to expect only these keys. */
 938     if (p_cb->role == HCI_ROLE_MASTER)
 939     {
 940         p_cb->local_r_key &= (SMP_SEC_KEY_TYPE_ID | SMP_SEC_KEY_TYPE_CSRK);
 941     }
 942
 943     SMP_TRACE_DEBUG("%s rcvs upgrades: i_keys=0x%x r_keys=0x%x "
 944                       "(i-initiator r-responder)", __FUNCTION__, p_cb->local_i_key,
 945                       p_cb->local_r_key);
 946
 947     if (/*((p_cb->peer_auth_req & SMP_AUTH_BOND) ||
 948             (p_cb->loc_auth_req & SMP_AUTH_BOND)) &&*/
 949         (p_cb->local_i_key || p_cb->local_r_key))
 950     {
 951         smp_br_state_machine_event(p_cb, SMP_BR_BOND_REQ_EVT, NULL);
 952
 953         /* if no peer key is expected, start master key distribution */
 954         if (p_cb->role == HCI_ROLE_MASTER && p_cb->local_r_key == 0)
 955             smp_key_distribution_by_transport(p_cb, NULL);
 956     }
 957     else
 958     {
 959         smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
 960     }
 961 }
 962
 963 /*******************************************************************************
 964 ** Function     smp_br_select_next_key
 965 ** Description  selects the next key to derive/send when BR/EDR transport is
 966 **              used.
 967 *******************************************************************************/
 968 void smp_br_select_next_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 969 {
 970     UINT8   reason = SMP_SUCCESS;
 971     SMP_TRACE_DEBUG("%s role=%d (0-master) r_keys=0x%x i_keys=0x%x",
 972                        __func__, p_cb->role, p_cb->local_r_key, p_cb->local_i_key);
 973
 974     if (p_cb->role == HCI_ROLE_SLAVE||
 975         (!p_cb->local_r_key && p_cb->role == HCI_ROLE_MASTER))
 976     {
 977         smp_key_pick_key(p_cb, p_data);
 978     }
 979
 980     if (!p_cb->local_i_key && !p_cb->local_r_key)
 981     {
 982         /* state check to prevent re-entrance */
 983         if (smp_get_br_state() == SMP_BR_STATE_BOND_PENDING)
 984         {
 985             if (p_cb->total_tx_unacked == 0)
 986                 smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
 987             else
 988                 p_cb->wait_for_authorization_complete = TRUE;
 989         }
 990     }
 991 }
 992
 993 /*******************************************************************************
 994 ** Function     smp_proc_enc_info
 995 ** Description  process encryption information from peer device
 996 *******************************************************************************/
 997 void smp_proc_enc_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
 998 {
 999     UINT8   *p = (UINT8 *)p_data;
1000
1001     SMP_TRACE_DEBUG("%s", __func__);
1002     STREAM_TO_ARRAY(p_cb->ltk, p, BT_OCTET16_LEN);
1003
1004     smp_key_distribution(p_cb, NULL);
1005 }
1006 /*******************************************************************************
1007 ** Function     smp_proc_master_id
1008 ** Description  process master ID from slave device
1009 *******************************************************************************/
1010 void smp_proc_master_id(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1011 {
1012     UINT8   *p = (UINT8 *)p_data;
1013     tBTM_LE_PENC_KEYS   le_key;
1014
1015     SMP_TRACE_DEBUG("%s", __func__);
1016     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ENC, TRUE);
1017
1018     STREAM_TO_UINT16(le_key.ediv, p);
1019     STREAM_TO_ARRAY(le_key.rand, p, BT_OCTET8_LEN );
1020
1021     /* store the encryption keys from peer device */
1022     memcpy(le_key.ltk, p_cb->ltk, BT_OCTET16_LEN);
1023     le_key.sec_level = p_cb->sec_level;
1024     le_key.key_size  = p_cb->loc_enc_size;
1025
1026     if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
1027         btm_sec_save_le_key(p_cb->pairing_bda,
1028                             BTM_LE_KEY_PENC,
1029                             (tBTM_LE_KEY_VALUE *)&le_key, TRUE);
1030
1031     smp_key_distribution(p_cb, NULL);
1032 }
1033
1034 /*******************************************************************************
1035 ** Function     smp_proc_enc_info
1036 ** Description  process identity information from peer device
1037 *******************************************************************************/
1038 void smp_proc_id_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1039 {
1040     UINT8   *p = (UINT8 *)p_data;
1041
1042     SMP_TRACE_DEBUG("%s", __func__);
1043     STREAM_TO_ARRAY (p_cb->tk, p, BT_OCTET16_LEN);   /* reuse TK for IRK */
1044     smp_key_distribution_by_transport(p_cb, NULL);
1045 }
1046
1047 /*******************************************************************************
1048 ** Function     smp_proc_id_addr
1049 ** Description  process identity address from peer device
1050 *******************************************************************************/
1051 void smp_proc_id_addr(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1052 {
1053     UINT8   *p = (UINT8 *)p_data;
1054     tBTM_LE_PID_KEYS    pid_key;
1055
1056     SMP_TRACE_DEBUG("%s", __func__);
1057     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ID, TRUE);
1058
1059     STREAM_TO_UINT8(pid_key.addr_type, p);
1060     STREAM_TO_BDADDR(pid_key.static_addr, p);
1061     memcpy(pid_key.irk, p_cb->tk, BT_OCTET16_LEN);
1062
1063     /* to use as BD_ADDR for lk derived from ltk */
1064     p_cb->id_addr_rcvd = TRUE;
1065     p_cb->id_addr_type = pid_key.addr_type;
1066     memcpy(p_cb->id_addr, pid_key.static_addr, BD_ADDR_LEN);
1067
1068     /* store the ID key from peer device */
1069     if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
1070         btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_PID,
1071                             (tBTM_LE_KEY_VALUE *)&pid_key, TRUE);
1072     smp_key_distribution_by_transport(p_cb, NULL);
1073 }
1074
1075 /*******************************************************************************
1076 ** Function     smp_proc_srk_info
1077 ** Description  process security information from peer device
1078 *******************************************************************************/
1079 void smp_proc_srk_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1080 {
1081     tBTM_LE_PCSRK_KEYS   le_key;
1082
1083     SMP_TRACE_DEBUG("%s", __func__);
1084     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_CSRK, TRUE);
1085
1086     /* save CSRK to security record */
1087     le_key.sec_level = p_cb->sec_level;
1088     memcpy (le_key.csrk, p_data, BT_OCTET16_LEN);   /* get peer CSRK */
1089     le_key.counter = 0; /* initialize the peer counter */
1090
1091     if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
1092         btm_sec_save_le_key(p_cb->pairing_bda,
1093                             BTM_LE_KEY_PCSRK,
1094                             (tBTM_LE_KEY_VALUE *)&le_key, TRUE);
1095     smp_key_distribution_by_transport(p_cb, NULL);
1096 }
1097
1098 /*******************************************************************************
1099 ** Function     smp_proc_compare
1100 ** Description  process compare value
1101 *******************************************************************************/
1102 void smp_proc_compare(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1103 {
1104     UINT8   reason;
1105
1106     SMP_TRACE_DEBUG("%s", __func__);
1107     if (!memcmp(p_cb->rconfirm, p_data->key.p_data, BT_OCTET16_LEN))
1108     {
1109         /* compare the max encryption key size, and save the smaller one for the link */
1110         if ( p_cb->peer_enc_size < p_cb->loc_enc_size)
1111             p_cb->loc_enc_size = p_cb->peer_enc_size;
1112
1113         if (p_cb->role == HCI_ROLE_SLAVE)
1114             smp_sm_event(p_cb, SMP_RAND_EVT, NULL);
1115         else
1116         {
1117             /* master device always use received i/r key as keys to distribute */
1118             p_cb->local_i_key = p_cb->peer_i_key;
1119             p_cb->local_r_key = p_cb->peer_r_key;
1120
1121             smp_sm_event(p_cb, SMP_ENC_REQ_EVT, NULL);
1122         }
1123
1124     }
1125     else
1126     {
1127         reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
1128         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1129     }
1130 }
1131
1132 /*******************************************************************************
1133 ** Function     smp_proc_sl_key
1134 ** Description  process key ready events.
1135 *******************************************************************************/
1136 void smp_proc_sl_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1137 {
1138     UINT8 key_type = p_data->key.key_type;
1139
1140     SMP_TRACE_DEBUG("%s", __func__);
1141     if (key_type == SMP_KEY_TYPE_TK)
1142     {
1143         smp_generate_srand_mrand_confirm(p_cb, NULL);
1144     }
1145     else if (key_type == SMP_KEY_TYPE_CFM)
1146     {
1147         smp_set_state(SMP_STATE_WAIT_CONFIRM);
1148
1149         if (p_cb->flags & SMP_PAIR_FLAGS_CMD_CONFIRM)
1150             smp_sm_event(p_cb, SMP_CONFIRM_EVT, NULL);
1151     }
1152 }
1153
1154 /*******************************************************************************
1155 ** Function     smp_start_enc
1156 ** Description  start encryption
1157 *******************************************************************************/
1158 void smp_start_enc(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1159 {
1160     tBTM_STATUS cmd;
1161     UINT8 reason = SMP_ENC_FAIL;
1162
1163     SMP_TRACE_DEBUG("%s", __func__);
1164     if (p_data != NULL)
1165         cmd = btm_ble_start_encrypt(p_cb->pairing_bda, TRUE, p_data->key.p_data);
1166     else
1167         cmd = btm_ble_start_encrypt(p_cb->pairing_bda, FALSE, NULL);
1168
1169     if (cmd != BTM_CMD_STARTED && cmd != BTM_BUSY)
1170         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1171 }
1172
1173 /*******************************************************************************
1174 ** Function     smp_proc_discard
1175 ** Description   processing for discard security request
1176 *******************************************************************************/
1177 void smp_proc_discard(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1178 {
1179     SMP_TRACE_DEBUG("%s", __func__);
1180     if (!(p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD))
1181         smp_reset_control_value(p_cb);
1182 }
1183
1184 /*******************************************************************************
1185 ** Function     smp_enc_cmpl
1186 ** Description   encryption success
1187 *******************************************************************************/
1188 void smp_enc_cmpl(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1189 {
1190     UINT8 enc_enable = *(UINT8 *)p_data;
1191     UINT8 reason = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL;
1192
1193     SMP_TRACE_DEBUG("%s", __func__);
1194     smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1195 }
1196
1197 /*******************************************************************************
1198 ** Function     smp_check_auth_req
1199 ** Description  check authentication request
1200 *******************************************************************************/
1201 void smp_check_auth_req(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1202 {
1203     UINT8 enc_enable = *(UINT8 *)p_data;
1204     UINT8 reason = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL;
1205
1206     SMP_TRACE_DEBUG("%s rcvs enc_enable=%d i_keys=0x%x r_keys=0x%x "
1207                       "(i-initiator r-responder)",
1208                       __func__, enc_enable, p_cb->local_i_key, p_cb->local_r_key);
1209     if (enc_enable == 1)
1210     {
1211         if (p_cb->le_secure_connections_mode_is_used)
1212         {
1213             /* In LE SC mode LTK is used instead of STK and has to be always saved */
1214             p_cb->local_i_key |= SMP_SEC_KEY_TYPE_ENC;
1215             p_cb->local_r_key |= SMP_SEC_KEY_TYPE_ENC;
1216
1217            /* In LE SC mode LK is derived from LTK only if both sides request it */
1218            if (!(p_cb->local_i_key & SMP_SEC_KEY_TYPE_LK) ||
1219                !(p_cb->local_r_key & SMP_SEC_KEY_TYPE_LK))
1220             {
1221                 p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
1222                 p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
1223             }
1224
1225             /* In LE SC mode only IRK, IAI, CSRK are exchanged with the peer.
1226             ** Set local_r_key on master to expect only these keys.
1227             */
1228             if (p_cb->role == HCI_ROLE_MASTER)
1229             {
1230                 p_cb->local_r_key &= (SMP_SEC_KEY_TYPE_ID | SMP_SEC_KEY_TYPE_CSRK);
1231             }
1232         }
1233         else
1234         {
1235             /* in legacy mode derivation of BR/EDR LK is not supported */
1236             p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
1237             p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
1238         }
1239         SMP_TRACE_DEBUG("%s rcvs upgrades: i_keys=0x%x r_keys=0x%x "
1240                           "(i-initiator r-responder)",
1241                           __func__, p_cb->local_i_key, p_cb->local_r_key);
1242
1243         if (/*((p_cb->peer_auth_req & SMP_AUTH_BOND) ||
1244              (p_cb->loc_auth_req & SMP_AUTH_BOND)) &&*/
1245             (p_cb->local_i_key || p_cb->local_r_key))
1246         {
1247             smp_sm_event(p_cb, SMP_BOND_REQ_EVT, NULL);
1248         }
1249         else
1250             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1251     }
1252     else if (enc_enable == 0)
1253     {
1254         /* if failed for encryption after pairing, send callback */
1255         if (p_cb->flags & SMP_PAIR_FLAG_ENC_AFTER_PAIR)
1256             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1257         /* if enc failed for old security information */
1258         /* if master device, clean up and abck to idle; slave device do nothing */
1259         else if (p_cb->role == HCI_ROLE_MASTER)
1260         {
1261             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1262         }
1263     }
1264 }
1265
1266 /*******************************************************************************
1267 ** Function     smp_key_pick_key
1268 ** Description  Pick a key distribution function based on the key mask.
1269 *******************************************************************************/
1270 void smp_key_pick_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1271 {
1272     UINT8   key_to_dist = (p_cb->role == HCI_ROLE_SLAVE) ? p_cb->local_r_key : p_cb->local_i_key;
1273     UINT8   i = 0;
1274
1275     SMP_TRACE_DEBUG("%s key_to_dist=0x%x", __func__, key_to_dist);
1276     while (i < SMP_KEY_DIST_TYPE_MAX)
1277     {
1278         SMP_TRACE_DEBUG("key to send = %02x, i = %d",  key_to_dist, i);
1279
1280         if (key_to_dist & (1 << i))
1281         {
1282             SMP_TRACE_DEBUG("smp_distribute_act[%d]", i);
1283             (* smp_distribute_act[i])(p_cb, p_data);
1284             break;
1285         }
1286         i ++;
1287     }
1288 }
1289 /*******************************************************************************
1290 ** Function     smp_key_distribution
1291 ** Description  start key distribution if required.
1292 *******************************************************************************/
1293 void smp_key_distribution(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1294 {
1295     SMP_TRACE_DEBUG("%s role=%d (0-master) r_keys=0x%x i_keys=0x%x",
1296                       __func__, p_cb->role, p_cb->local_r_key, p_cb->local_i_key);
1297
1298     if (p_cb->role == HCI_ROLE_SLAVE ||
1299        (!p_cb->local_r_key && p_cb->role == HCI_ROLE_MASTER))
1300     {
1301         smp_key_pick_key(p_cb, p_data);
1302     }
1303
1304     if (!p_cb->local_i_key && !p_cb->local_r_key)
1305     {
1306         /* state check to prevent re-entrant */
1307         if (smp_get_state() == SMP_STATE_BOND_PENDING)
1308         {
1309             if (p_cb->derive_lk)
1310             {
1311                 smp_derive_link_key_from_long_term_key(p_cb, NULL);
1312                 p_cb->derive_lk = FALSE;
1313             }
1314
1315             if (p_cb->total_tx_unacked == 0)
1316             {
1317                 /*
1318                  * Instead of declaring authorization complete immediately,
1319                  * delay the event from being sent by SMP_DELAYED_AUTH_TIMEOUT_MS.
1320                  * This allows the slave to send over Pairing Failed if the
1321                  * last key is rejected.  During this waiting window, the
1322                  * state should remain in SMP_STATE_BOND_PENDING.
1323                  */
1324                 if (!alarm_is_scheduled(p_cb->delayed_auth_timer_ent)) {
1325                     SMP_TRACE_DEBUG("%s delaying auth complete.", __func__);
1326                     alarm_set_on_queue(p_cb->delayed_auth_timer_ent, SMP_DELAYED_AUTH_TIMEOUT_MS,
1327                                        smp_delayed_auth_complete_timeout, NULL, btu_general_alarm_queue);
1328                 }
1329             } else {
1330                 p_cb->wait_for_authorization_complete = TRUE;
1331             }
1332         }
1333     }
1334 }
1335
1336 /*******************************************************************************
1337 ** Function         smp_decide_association_model
1338 ** Description      This function is called to select assoc model to be used for
1339 **                  STK generation and to start STK generation process.
1340 **
1341 *******************************************************************************/
1342 void smp_decide_association_model(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1343 {
1344     UINT8   failure = SMP_UNKNOWN_IO_CAP;
1345     UINT8 int_evt = 0;
1346     tSMP_KEY key;
1347     tSMP_INT_DATA   *p = NULL;
1348
1349     SMP_TRACE_DEBUG("%s Association Model = %d", __func__, p_cb->selected_association_model);
1350
1351     switch (p_cb->selected_association_model)
1352     {
1353         case SMP_MODEL_ENCRYPTION_ONLY:  /* TK = 0, go calculate Confirm */
1354             if (p_cb->role == HCI_ROLE_MASTER &&
1355                 ((p_cb->peer_auth_req & SMP_AUTH_YN_BIT) != 0) &&
1356                 ((p_cb->loc_auth_req & SMP_AUTH_YN_BIT) == 0))
1357             {
1358                 SMP_TRACE_ERROR ("IO capability does not meet authentication requirement");
1359                 failure = SMP_PAIR_AUTH_FAIL;
1360                 p = (tSMP_INT_DATA *)&failure;
1361                 int_evt = SMP_AUTH_CMPL_EVT;
1362             }
1363             else
1364             {
1365                 p_cb->sec_level = SMP_SEC_UNAUTHENTICATE;
1366                 SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE) ", p_cb->sec_level );
1367
1368                 key.key_type = SMP_KEY_TYPE_TK;
1369                 key.p_data = p_cb->tk;
1370                 p = (tSMP_INT_DATA *)&key;
1371
1372                 memset(p_cb->tk, 0, BT_OCTET16_LEN);
1373                 /* TK, ready  */
1374                 int_evt = SMP_KEY_READY_EVT;
1375             }
1376             break;
1377
1378         case SMP_MODEL_PASSKEY:
1379             p_cb->sec_level = SMP_SEC_AUTHENTICATED;
1380             SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ", p_cb->sec_level );
1381
1382             p_cb->cb_evt = SMP_PASSKEY_REQ_EVT;
1383             int_evt = SMP_TK_REQ_EVT;
1384             break;
1385
1386         case SMP_MODEL_OOB:
1387             SMP_TRACE_ERROR ("Association Model = SMP_MODEL_OOB");
1388             p_cb->sec_level = SMP_SEC_AUTHENTICATED;
1389             SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ", p_cb->sec_level );
1390
1391             p_cb->cb_evt = SMP_OOB_REQ_EVT;
1392             int_evt = SMP_TK_REQ_EVT;
1393             break;
1394
1395         case SMP_MODEL_KEY_NOTIF:
1396             p_cb->sec_level = SMP_SEC_AUTHENTICATED;
1397             SMP_TRACE_DEBUG("Need to generate Passkey");
1398
1399             /* generate passkey and notify application */
1400             smp_generate_passkey(p_cb, NULL);
1401             break;
1402
1403         case SMP_MODEL_SEC_CONN_JUSTWORKS:
1404         case SMP_MODEL_SEC_CONN_NUM_COMP:
1405         case SMP_MODEL_SEC_CONN_PASSKEY_ENT:
1406         case SMP_MODEL_SEC_CONN_PASSKEY_DISP:
1407         case SMP_MODEL_SEC_CONN_OOB:
1408             int_evt = SMP_PUBL_KEY_EXCH_REQ_EVT;
1409             break;
1410
1411         case SMP_MODEL_OUT_OF_RANGE:
1412             SMP_TRACE_ERROR("Association Model = SMP_MODEL_OUT_OF_RANGE (failed)");
1413             p = (tSMP_INT_DATA *)&failure;
1414             int_evt = SMP_AUTH_CMPL_EVT;
1415             break;
1416
1417         default:
1418             SMP_TRACE_ERROR("Association Model = %d (SOMETHING IS WRONG WITH THE CODE)",
1419                              p_cb->selected_association_model);
1420             p = (tSMP_INT_DATA *)&failure;
1421             int_evt = SMP_AUTH_CMPL_EVT;
1422     }
1423
1424     SMP_TRACE_EVENT ("sec_level=%d ", p_cb->sec_level );
1425     if (int_evt)
1426         smp_sm_event(p_cb, int_evt, p);
1427 }
1428
1429 /*******************************************************************************
1430 ** Function     smp_process_io_response
1431 ** Description  process IO response for a slave device.
1432 *******************************************************************************/
1433 void smp_process_io_response(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1434 {
1435     uint8_t reason = SMP_PAIR_AUTH_FAIL;
1436
1437     SMP_TRACE_DEBUG("%s", __func__);
1438     if (p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD)
1439     {
1440         /* pairing started by local (slave) Security Request */
1441         smp_set_state(SMP_STATE_SEC_REQ_PENDING);
1442         smp_send_cmd(SMP_OPCODE_SEC_REQ, p_cb);
1443     }
1444     else /* plan to send pairing respond */
1445     {
1446         /* pairing started by peer (master) Pairing Request */
1447         p_cb->selected_association_model = smp_select_association_model(p_cb);
1448
1449         if (p_cb->secure_connections_only_mode_required &&
1450             (!(p_cb->le_secure_connections_mode_is_used) ||
1451             (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS)))
1452         {
1453             SMP_TRACE_ERROR ("Slave requires secure connection only mode \
1454                               but it can't be provided -> Slave fails pairing");
1455             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1456             return;
1457         }
1458
1459         if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_OOB)
1460         {
1461             if (smp_request_oob_data(p_cb)) return;
1462         }
1463
1464         // PTS Testing failure modes
1465         if (pts_test_send_authentication_complete_failure(p_cb))
1466             return;
1467
1468         smp_send_pair_rsp(p_cb, NULL);
1469     }
1470 }
1471
1472 /*******************************************************************************
1473 ** Function     smp_br_process_slave_keys_response
1474 ** Description  process application keys response for a slave device
1475 **              (BR/EDR transport).
1476 *******************************************************************************/
1477 void smp_br_process_slave_keys_response(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1478 {
1479     smp_br_send_pair_response(p_cb, NULL);
1480 }
1481
1482 /*******************************************************************************
1483 ** Function     smp_br_send_pair_response
1484 ** Description  actions related to sending pairing response over BR/EDR transport.
1485 *******************************************************************************/
1486 void smp_br_send_pair_response(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1487 {
1488     SMP_TRACE_DEBUG("%s", __func__);
1489
1490     p_cb->local_i_key &= p_cb->peer_i_key;
1491     p_cb->local_r_key &= p_cb->peer_r_key;
1492
1493     smp_send_cmd (SMP_OPCODE_PAIRING_RSP, p_cb);
1494 }
1495
1496 /*******************************************************************************
1497 ** Function         smp_pairing_cmpl
1498 ** Description      This function is called to send the pairing complete callback
1499 **                  and remove the connection if needed.
1500 *******************************************************************************/
1501 void smp_pairing_cmpl(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1502 {
1503     if (p_cb->total_tx_unacked == 0)
1504     {
1505         /* update connection parameter to remote preferred */
1506         L2CA_EnableUpdateBleConnParams(p_cb->pairing_bda, TRUE);
1507         /* process the pairing complete */
1508         smp_proc_pairing_cmpl(p_cb);
1509     }
1510 }
1511
1512 /*******************************************************************************
1513 ** Function         smp_pair_terminate
1514 ** Description      This function is called to send the pairing complete callback
1515 **                  and remove the connection if needed.
1516 *******************************************************************************/
1517 void smp_pair_terminate(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1518 {
1519     SMP_TRACE_DEBUG("%s", __func__);
1520     p_cb->status = SMP_CONN_TOUT;
1521     smp_proc_pairing_cmpl(p_cb);
1522 }
1523
1524 /*******************************************************************************
1525 ** Function         smp_idle_terminate
1526 ** Description      This function calledin idle state to determine to send authentication
1527 **                  complete or not.
1528 *******************************************************************************/
1529 void smp_idle_terminate(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1530 {
1531     if (p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD)
1532     {
1533         SMP_TRACE_DEBUG("Pairing terminated at IDLE state.");
1534         p_cb->status = SMP_FAIL;
1535         smp_proc_pairing_cmpl(p_cb);
1536     }
1537 }
1538
1539 /*******************************************************************************
1540 ** Function     smp_fast_conn_param
1541 ** Description  apply default connection parameter for pairing process
1542 *******************************************************************************/
1543 void smp_fast_conn_param(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1544 {
1545     /* disable connection parameter update */
1546     L2CA_EnableUpdateBleConnParams(p_cb->pairing_bda, FALSE);
1547 }
1548
1549 /*******************************************************************************
1550 ** Function     smp_both_have_public_keys
1551 ** Description  The function is called when both local and peer public keys are
1552 **              saved.
1553 **              Actions:
1554 **              - invokes DHKey computation;
1555 **              - on slave side invokes sending local public key to the peer.
1556 **              - invokes SC phase 1 process.
1557 *******************************************************************************/
1558 void smp_both_have_public_keys(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1559 {
1560     SMP_TRACE_DEBUG("%s",__func__);
1561
1562     /* invokes DHKey computation */
1563     smp_compute_dhkey(p_cb);
1564
1565     /* on slave side invokes sending local public key to the peer */
1566     if (p_cb->role == HCI_ROLE_SLAVE)
1567         smp_send_pair_public_key(p_cb, NULL);
1568
1569     smp_sm_event(p_cb, SMP_SC_DHKEY_CMPLT_EVT, NULL);
1570 }
1571
1572 /*******************************************************************************
1573 ** Function     smp_start_secure_connection_phase1
1574 ** Description  The function starts Secure Connection phase1 i.e. invokes initialization of Secure Connection
1575 **              phase 1 parameters and starts building/sending to the peer
1576 **              messages appropriate for the role and association model.
1577 *******************************************************************************/
1578 void smp_start_secure_connection_phase1(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1579 {
1580     SMP_TRACE_DEBUG("%s", __func__);
1581
1582     if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS)
1583     {
1584         p_cb->sec_level = SMP_SEC_UNAUTHENTICATE;
1585         SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE) ", p_cb->sec_level );
1586     }
1587     else
1588     {
1589         p_cb->sec_level = SMP_SEC_AUTHENTICATED;
1590         SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ", p_cb->sec_level );
1591     }
1592
1593     switch(p_cb->selected_association_model)
1594     {
1595         case SMP_MODEL_SEC_CONN_JUSTWORKS:
1596         case SMP_MODEL_SEC_CONN_NUM_COMP:
1597             memset(p_cb->local_random, 0, BT_OCTET16_LEN);
1598             smp_start_nonce_generation(p_cb);
1599             break;
1600         case SMP_MODEL_SEC_CONN_PASSKEY_ENT:
1601             /* user has to provide passkey */
1602             p_cb->cb_evt = SMP_PASSKEY_REQ_EVT;
1603             smp_sm_event(p_cb, SMP_TK_REQ_EVT, NULL);
1604             break;
1605         case SMP_MODEL_SEC_CONN_PASSKEY_DISP:
1606             /* passkey has to be provided to user */
1607             SMP_TRACE_DEBUG("Need to generate SC Passkey");
1608             smp_generate_passkey(p_cb, NULL);
1609             break;
1610         case SMP_MODEL_SEC_CONN_OOB:
1611             /* use the available OOB information */
1612             smp_process_secure_connection_oob_data(p_cb, NULL);
1613             break;
1614         default:
1615             SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC",
1616                               p_cb->selected_association_model);
1617             break;
1618     }
1619 }
1620
1621 /*******************************************************************************
1622 ** Function     smp_process_local_nonce
1623 ** Description  The function processes new local nonce.
1624 **
1625 ** Note         It is supposed to be called in SC phase1.
1626 *******************************************************************************/
1627 void smp_process_local_nonce(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1628 {
1629     SMP_TRACE_DEBUG("%s", __func__);
1630
1631     switch(p_cb->selected_association_model)
1632     {
1633         case SMP_MODEL_SEC_CONN_JUSTWORKS:
1634         case SMP_MODEL_SEC_CONN_NUM_COMP:
1635             if (p_cb->role == HCI_ROLE_SLAVE)
1636             {
1637                 /* slave calculates and sends local commitment */
1638                 smp_calculate_local_commitment(p_cb);
1639                 smp_send_commitment(p_cb, NULL);
1640                 /* slave has to wait for peer nonce */
1641                 smp_set_state(SMP_STATE_WAIT_NONCE);
1642             }
1643             else    /* i.e. master */
1644             {
1645                 if (p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_COMM)
1646                 {
1647                     /* slave commitment is already received, send local nonce, wait for remote nonce*/
1648                     SMP_TRACE_DEBUG("master in assoc mode = %d \
1649                     already rcvd slave commitment - race condition",
1650                                       p_cb->selected_association_model);
1651                     p_cb->flags &= ~SMP_PAIR_FLAG_HAVE_PEER_COMM;
1652                     smp_send_rand(p_cb, NULL);
1653                     smp_set_state(SMP_STATE_WAIT_NONCE);
1654                 }
1655             }
1656             break;
1657         case SMP_MODEL_SEC_CONN_PASSKEY_ENT:
1658         case SMP_MODEL_SEC_CONN_PASSKEY_DISP:
1659             smp_calculate_local_commitment(p_cb);
1660
1661             if (p_cb->role == HCI_ROLE_MASTER)
1662             {
1663                 smp_send_commitment(p_cb, NULL);
1664             }
1665             else    /* slave */
1666             {
1667                 if (p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_COMM)
1668                 {
1669                     /* master commitment is already received */
1670                     smp_send_commitment(p_cb, NULL);
1671                     smp_set_state(SMP_STATE_WAIT_NONCE);
1672                 }
1673             }
1674             break;
1675         case SMP_MODEL_SEC_CONN_OOB:
1676             if (p_cb->role == HCI_ROLE_MASTER)
1677             {
1678                 smp_send_rand(p_cb, NULL);
1679             }
1680
1681             smp_set_state(SMP_STATE_WAIT_NONCE);
1682             break;
1683         default:
1684             SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC",
1685                               p_cb->selected_association_model);
1686             break;
1687     }
1688 }
1689
1690 /*******************************************************************************
1691 ** Function     smp_process_peer_nonce
1692 ** Description  The function processes newly received and saved in CB peer nonce.
1693 **              The actions depend on the selected association model and the role.
1694 **
1695 ** Note         It is supposed to be called in SC phase1.
1696 *******************************************************************************/
1697 void smp_process_peer_nonce(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1698 {
1699     UINT8   reason;
1700
1701     SMP_TRACE_DEBUG("%s start ", __func__);
1702
1703     // PTS Testing failure modes
1704     if (p_cb->cert_failure == 1) {
1705         SMP_TRACE_ERROR("%s failure case = %d", __func__, p_cb->cert_failure);
1706         reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
1707         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1708         return;
1709     }
1710
1711     switch(p_cb->selected_association_model)
1712     {
1713         case SMP_MODEL_SEC_CONN_JUSTWORKS:
1714         case SMP_MODEL_SEC_CONN_NUM_COMP:
1715             /* in these models only master receives commitment */
1716             if (p_cb->role == HCI_ROLE_MASTER)
1717             {
1718                 if (!smp_check_commitment(p_cb))
1719                 {
1720                     reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
1721                     smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1722                     break;
1723                 }
1724             }
1725             else
1726             {
1727                 /* slave sends local nonce */
1728                 smp_send_rand(p_cb, NULL);
1729             }
1730
1731             if(p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS)
1732             {
1733                 /* go directly to phase 2 */
1734                 smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL);
1735             }
1736             else    /* numeric comparison */
1737             {
1738                 smp_set_state(SMP_STATE_WAIT_NONCE);
1739                 smp_sm_event(p_cb, SMP_SC_CALC_NC_EVT, NULL);
1740             }
1741             break;
1742         case SMP_MODEL_SEC_CONN_PASSKEY_ENT:
1743         case SMP_MODEL_SEC_CONN_PASSKEY_DISP:
1744             if (!smp_check_commitment(p_cb) && p_cb->cert_failure != 9)
1745             {
1746                 reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
1747                 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1748                 break;
1749             }
1750
1751             if (p_cb->role == HCI_ROLE_SLAVE)
1752             {
1753                 smp_send_rand(p_cb, NULL);
1754             }
1755
1756             if (++p_cb->round < 20)
1757             {
1758                 smp_set_state(SMP_STATE_SEC_CONN_PHS1_START);
1759                 p_cb->flags &= ~SMP_PAIR_FLAG_HAVE_PEER_COMM;
1760                 smp_start_nonce_generation(p_cb);
1761                 break;
1762             }
1763
1764             smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL);
1765             break;
1766         case SMP_MODEL_SEC_CONN_OOB:
1767             if (p_cb->role == HCI_ROLE_SLAVE)
1768             {
1769                 smp_send_rand(p_cb, NULL);
1770             }
1771
1772             smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL);
1773             break;
1774         default:
1775             SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC",
1776                               p_cb->selected_association_model);
1777             break;
1778     }
1779
1780     SMP_TRACE_DEBUG("%s end ",__FUNCTION__);
1781 }
1782
1783 /*******************************************************************************
1784 ** Function     smp_match_dhkey_checks
1785 ** Description  checks if the calculated peer DHKey Check value is the same as
1786 **              received from the peer DHKey check value.
1787 *******************************************************************************/
1788 void smp_match_dhkey_checks(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1789 {
1790     UINT8 reason = SMP_DHKEY_CHK_FAIL;
1791
1792     SMP_TRACE_DEBUG("%s", __func__);
1793
1794     if (memcmp(p_data->key.p_data, p_cb->remote_dhkey_check, BT_OCTET16_LEN))
1795     {
1796         SMP_TRACE_WARNING ("dhkey chcks do no match");
1797         p_cb->failure = reason;
1798         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1799         return;
1800     }
1801
1802     SMP_TRACE_EVENT ("dhkey chcks match");
1803
1804     /* compare the max encryption key size, and save the smaller one for the link */
1805     if (p_cb->peer_enc_size < p_cb->loc_enc_size)
1806         p_cb->loc_enc_size = p_cb->peer_enc_size;
1807
1808     if (p_cb->role == HCI_ROLE_SLAVE)
1809     {
1810         smp_sm_event(p_cb, SMP_PAIR_DHKEY_CHCK_EVT, NULL);
1811     }
1812     else
1813     {
1814         /* master device always use received i/r key as keys to distribute */
1815         p_cb->local_i_key = p_cb->peer_i_key;
1816         p_cb->local_r_key = p_cb->peer_r_key;
1817         smp_sm_event(p_cb, SMP_ENC_REQ_EVT, NULL);
1818     }
1819 }
1820
1821 /*******************************************************************************
1822 ** Function     smp_move_to_secure_connections_phase2
1823 ** Description  Signal State Machine to start SC phase 2 initialization (to
1824 **              compute local DHKey Check value).
1825 **
1826 ** Note         SM is supposed to be in the state SMP_STATE_SEC_CONN_PHS2_START.
1827 *******************************************************************************/
1828 void smp_move_to_secure_connections_phase2(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1829 {
1830     SMP_TRACE_DEBUG("%s",__func__);
1831     smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL);
1832 }
1833
1834 /*******************************************************************************
1835 ** Function     smp_phase_2_dhkey_checks_are_present
1836 ** Description  generates event if dhkey check from the peer is already received.
1837 **
1838 ** Note         It is supposed to be used on slave to prevent race condition.
1839 **              It is supposed to be called after slave dhkey check is calculated.
1840 *******************************************************************************/
1841 void smp_phase_2_dhkey_checks_are_present(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1842 {
1843     SMP_TRACE_DEBUG("%s",__func__);
1844
1845     if (p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_DHK_CHK)
1846         smp_sm_event(p_cb, SMP_SC_2_DHCK_CHKS_PRES_EVT, NULL);
1847 }
1848
1849 /*******************************************************************************
1850 ** Function     smp_wait_for_both_public_keys
1851 ** Description  generates SMP_BOTH_PUBL_KEYS_RCVD_EVT event when both local and master
1852 **              public keys are available.
1853 **
1854 ** Note         on the slave it is used to prevent race condition.
1855 **
1856 *******************************************************************************/
1857 void smp_wait_for_both_public_keys(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1858 {
1859     SMP_TRACE_DEBUG("%s",__func__);
1860
1861     if ((p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_PUBL_KEY) &&
1862         (p_cb->flags & SMP_PAIR_FLAG_HAVE_LOCAL_PUBL_KEY))
1863     {
1864         if ((p_cb->role == HCI_ROLE_SLAVE) &&
1865             ((p_cb->req_oob_type == SMP_OOB_LOCAL) || (p_cb->req_oob_type == SMP_OOB_BOTH)))
1866         {
1867             smp_set_state(SMP_STATE_PUBLIC_KEY_EXCH);
1868         }
1869         smp_sm_event(p_cb, SMP_BOTH_PUBL_KEYS_RCVD_EVT, NULL);
1870     }
1871 }
1872
1873 /*******************************************************************************
1874 ** Function     smp_start_passkey_verification
1875 ** Description  Starts SC passkey entry verification.
1876 *******************************************************************************/
1877 void smp_start_passkey_verification(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1878 {
1879     UINT8 *p = NULL;
1880
1881     SMP_TRACE_DEBUG("%s", __func__);
1882     p = p_cb->local_random;
1883     UINT32_TO_STREAM(p, p_data->passkey);
1884
1885     p = p_cb->peer_random;
1886     UINT32_TO_STREAM(p, p_data->passkey);
1887
1888     p_cb->round = 0;
1889     smp_start_nonce_generation(p_cb);
1890 }
1891
1892 /*******************************************************************************
1893 ** Function     smp_process_secure_connection_oob_data
1894 ** Description  Processes local/peer SC OOB data received from somewhere.
1895 *******************************************************************************/
1896 void smp_process_secure_connection_oob_data(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1897 {
1898     SMP_TRACE_DEBUG("%s", __func__);
1899
1900     tSMP_SC_OOB_DATA *p_sc_oob_data = &p_cb->sc_oob_data;
1901     if (p_sc_oob_data->loc_oob_data.present)
1902     {
1903         memcpy(p_cb->local_random, p_sc_oob_data->loc_oob_data.randomizer,
1904                sizeof(p_cb->local_random));
1905     }
1906     else
1907     {
1908         SMP_TRACE_EVENT ("local OOB randomizer is absent");
1909         memset(p_cb->local_random, 0, sizeof (p_cb->local_random));
1910     }
1911
1912     if (!p_sc_oob_data->peer_oob_data.present)
1913     {
1914         SMP_TRACE_EVENT ("peer OOB data is absent");
1915         memset(p_cb->peer_random, 0, sizeof (p_cb->peer_random));
1916     }
1917     else
1918     {
1919         memcpy(p_cb->peer_random, p_sc_oob_data->peer_oob_data.randomizer,
1920                sizeof(p_cb->peer_random));
1921         memcpy(p_cb->remote_commitment, p_sc_oob_data->peer_oob_data.commitment,
1922                sizeof(p_cb->remote_commitment));
1923
1924         UINT8 reason = SMP_CONFIRM_VALUE_ERR;
1925         /* check commitment */
1926         if (!smp_check_commitment(p_cb))
1927         {
1928             p_cb->failure = reason;
1929             smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1930             return;
1931         }
1932
1933         if (p_cb->peer_oob_flag != SMP_OOB_PRESENT)
1934         {
1935             /* the peer doesn't have local randomiser */
1936             SMP_TRACE_EVENT ("peer didn't receive local OOB data, set local randomizer to 0");
1937             memset(p_cb->local_random, 0, sizeof (p_cb->local_random));
1938         }
1939     }
1940
1941     print128(p_cb->local_random, (const UINT8 *)"local OOB randomizer");
1942     print128(p_cb->peer_random, (const UINT8 *)"peer OOB randomizer");
1943     smp_start_nonce_generation(p_cb);
1944 }
1945
1946 /*******************************************************************************
1947 ** Function     smp_set_local_oob_keys
1948 ** Description  Saves calculated private/public keys in sc_oob_data.loc_oob_data,
1949 **              starts nonce generation
1950 **              (to be saved in sc_oob_data.loc_oob_data.randomizer).
1951 *******************************************************************************/
1952 void smp_set_local_oob_keys(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1953 {
1954     SMP_TRACE_DEBUG("%s", __func__);
1955
1956     memcpy(p_cb->sc_oob_data.loc_oob_data.private_key_used, p_cb->private_key,
1957            BT_OCTET32_LEN);
1958     p_cb->sc_oob_data.loc_oob_data.publ_key_used = p_cb->loc_publ_key;
1959     smp_start_nonce_generation(p_cb);
1960 }
1961
1962 /*******************************************************************************
1963 ** Function     smp_set_local_oob_random_commitment
1964 ** Description  Saves calculated randomizer and commitment in sc_oob_data.loc_oob_data,
1965 **              passes sc_oob_data.loc_oob_data up for safekeeping.
1966 *******************************************************************************/
1967 void smp_set_local_oob_random_commitment(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
1968 {
1969     SMP_TRACE_DEBUG("%s", __func__);
1970     memcpy(p_cb->sc_oob_data.loc_oob_data.randomizer, p_cb->rand,
1971            BT_OCTET16_LEN);
1972
1973     smp_calculate_f4(p_cb->sc_oob_data.loc_oob_data.publ_key_used.x,
1974                      p_cb->sc_oob_data.loc_oob_data.publ_key_used.x,
1975                      p_cb->sc_oob_data.loc_oob_data.randomizer, 0,
1976                      p_cb->sc_oob_data.loc_oob_data.commitment);
1977
1978 #if SMP_DEBUG == TRUE
1979     UINT8   *p_print = NULL;
1980     SMP_TRACE_DEBUG("local SC OOB data set:");
1981     p_print = (UINT8*) &p_cb->sc_oob_data.loc_oob_data.addr_sent_to;
1982     smp_debug_print_nbyte_little_endian (p_print, (const UINT8 *)"addr_sent_to",
1983                                          sizeof(tBLE_BD_ADDR));
1984     p_print = (UINT8*) &p_cb->sc_oob_data.loc_oob_data.private_key_used;
1985     smp_debug_print_nbyte_little_endian (p_print, (const UINT8 *)"private_key_used",
1986                                          BT_OCTET32_LEN);
1987     p_print = (UINT8*) &p_cb->sc_oob_data.loc_oob_data.publ_key_used.x;
1988     smp_debug_print_nbyte_little_endian (p_print, (const UINT8 *)"publ_key_used.x",
1989                                          BT_OCTET32_LEN);
1990     p_print = (UINT8*) &p_cb->sc_oob_data.loc_oob_data.publ_key_used.y;
1991     smp_debug_print_nbyte_little_endian (p_print, (const UINT8 *)"publ_key_used.y",
1992                                          BT_OCTET32_LEN);
1993     p_print = (UINT8*) &p_cb->sc_oob_data.loc_oob_data.randomizer;
1994     smp_debug_print_nbyte_little_endian (p_print, (const UINT8 *)"randomizer",
1995                                          BT_OCTET16_LEN);
1996     p_print = (UINT8*) &p_cb->sc_oob_data.loc_oob_data.commitment;
1997     smp_debug_print_nbyte_little_endian (p_print,(const UINT8 *) "commitment",
1998                                          BT_OCTET16_LEN);
1999     SMP_TRACE_DEBUG("");
2000 #endif
2001
2002     /* pass created OOB data up */
2003     p_cb->cb_evt = SMP_SC_LOC_OOB_DATA_UP_EVT;
2004     smp_send_app_cback(p_cb, NULL);
2005
2006     smp_cb_cleanup(p_cb);
2007 }
2008
2009 /*******************************************************************************
2010 **
2011 ** Function         smp_link_encrypted
2012 **
2013 ** Description      This function is called when link is encrypted and notified to
2014 **                  slave device. Proceed to to send LTK, DIV and ER to master if
2015 **                  bonding the devices.
2016 **
2017 **
2018 ** Returns          void
2019 **
2020 *******************************************************************************/
2021 void smp_link_encrypted(BD_ADDR bda, UINT8 encr_enable)
2022 {
2023     tSMP_CB *p_cb = &smp_cb;
2024
2025     SMP_TRACE_DEBUG("%s encr_enable=%d", __func__, encr_enable);
2026
2027     if (memcmp(&smp_cb.pairing_bda[0], bda, BD_ADDR_LEN) == 0)
2028     {
2029         /* encryption completed with STK, remmeber the key size now, could be overwite
2030         *  when key exchange happens                                        */
2031         if (p_cb->loc_enc_size != 0 && encr_enable)
2032         {
2033             /* update the link encryption key size if a SMP pairing just performed */
2034             btm_ble_update_sec_key_size(bda, p_cb->loc_enc_size);
2035         }
2036
2037         smp_sm_event(&smp_cb, SMP_ENCRYPTED_EVT, &encr_enable);
2038     }
2039 }
2040
2041 /*******************************************************************************
2042 **
2043 ** Function         smp_proc_ltk_request
2044 **
2045 ** Description      This function is called when LTK request is received from
2046 **                  controller.
2047 **
2048 ** Returns          void
2049 **
2050 *******************************************************************************/
2051 BOOLEAN smp_proc_ltk_request(BD_ADDR bda)
2052 {
2053     SMP_TRACE_DEBUG("%s state = %d",  __func__, smp_cb.state);
2054     BOOLEAN match = FALSE;
2055
2056     if (!memcmp(bda, smp_cb.pairing_bda, BD_ADDR_LEN))
2057     {
2058         match = TRUE;
2059     } else {
2060         BD_ADDR dummy_bda = {0};
2061         tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev(bda);
2062         if (p_dev_rec != NULL &&
2063             0 == memcmp(p_dev_rec->ble.pseudo_addr, smp_cb.pairing_bda, BD_ADDR_LEN) &&
2064             0 != memcmp(p_dev_rec->ble.pseudo_addr, dummy_bda, BD_ADDR_LEN))
2065         {
2066             match = TRUE;
2067         }
2068     }
2069
2070     if (match && smp_cb.state == SMP_STATE_ENCRYPTION_PENDING)
2071     {
2072         smp_sm_event(&smp_cb, SMP_ENC_REQ_EVT, NULL);
2073         return TRUE;
2074     }
2075
2076     return FALSE;
2077 }
2078
2079 /*******************************************************************************
2080 **
2081 ** Function         smp_process_secure_connection_long_term_key
2082 **
2083 ** Description      This function is called to process SC LTK.
2084 **                  SC LTK is calculated and used instead of STK.
2085 **                  Here SC LTK is saved in BLE DB.
2086 **
2087 ** Returns          void
2088 **
2089 *******************************************************************************/
2090 void smp_process_secure_connection_long_term_key(void)
2091 {
2092     tSMP_CB     *p_cb = &smp_cb;
2093
2094     SMP_TRACE_DEBUG("%s", __func__);
2095     smp_save_secure_connections_long_term_key(p_cb);
2096
2097     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ENC, FALSE);
2098     smp_key_distribution(p_cb, NULL);
2099 }
2100
2101 /*******************************************************************************
2102 **
2103 ** Function         smp_set_derive_link_key
2104 **
2105 ** Description      This function is called to set flag that indicates that
2106 **                  BR/EDR LK has to be derived from LTK after all keys are
2107 **                  distributed.
2108 **
2109 ** Returns          void
2110 **
2111 *******************************************************************************/
2112 void smp_set_derive_link_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
2113 {
2114     SMP_TRACE_DEBUG ("%s", __func__);
2115     p_cb->derive_lk = TRUE;
2116     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_LK, FALSE);
2117     smp_key_distribution(p_cb, NULL);
2118 }
2119
2120 /*******************************************************************************
2121 **
2122 ** Function         smp_derive_link_key_from_long_term_key
2123 **
2124 ** Description      This function is called to derive BR/EDR LK from LTK.
2125 **
2126 ** Returns          void
2127 **
2128 *******************************************************************************/
2129 void smp_derive_link_key_from_long_term_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
2130 {
2131     tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN;
2132
2133     SMP_TRACE_DEBUG("%s", __func__);
2134     if (!smp_calculate_link_key_from_long_term_key(p_cb))
2135     {
2136         SMP_TRACE_ERROR("%s failed", __FUNCTION__);
2137         smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
2138         return;
2139     }
2140 }
2141
2142 /*******************************************************************************
2143 **
2144 ** Function         smp_br_process_link_key
2145 **
2146 ** Description      This function is called to process BR/EDR LK:
2147 **                  - to derive SMP LTK from BR/EDR LK;
2148 *8                  - to save SMP LTK.
2149 **
2150 ** Returns          void
2151 **
2152 *******************************************************************************/
2153 void smp_br_process_link_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
2154 {
2155     tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN;
2156
2157     SMP_TRACE_DEBUG("%s", __func__);
2158     if (!smp_calculate_long_term_key_from_link_key(p_cb))
2159     {
2160         SMP_TRACE_ERROR ("%s failed",__FUNCTION__);
2161         smp_sm_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &status);
2162         return;
2163     }
2164
2165     SMP_TRACE_DEBUG("%s: LTK derivation from LK successfully completed", __FUNCTION__);
2166     smp_save_secure_connections_long_term_key(p_cb);
2167     smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ENC, FALSE);
2168     smp_br_select_next_key(p_cb, NULL);
2169 }
2170
2171 /*******************************************************************************
2172 ** Function     smp_key_distribution_by_transport
2173 ** Description  depending on the transport used at the moment calls either
2174 **              smp_key_distribution(...) or smp_br_key_distribution(...).
2175 *******************************************************************************/
2176 void smp_key_distribution_by_transport(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
2177 {
2178     SMP_TRACE_DEBUG("%s", __func__);
2179     if (p_cb->smp_over_br)
2180     {
2181         smp_br_select_next_key(p_cb, NULL);
2182     }
2183     else
2184     {
2185         smp_key_distribution(p_cb, NULL);
2186     }
2187 }
2188
2189 /*******************************************************************************
2190 ** Function         smp_br_pairing_complete
2191 ** Description      This function is called to send the pairing complete callback
2192 **                  and remove the connection if needed.
2193 *******************************************************************************/
2194 void smp_br_pairing_complete(tSMP_CB *p_cb, tSMP_INT_DATA *p_data)
2195 {
2196     SMP_TRACE_DEBUG("%s", __func__);
2197
2198     if (p_cb->total_tx_unacked == 0)
2199     {
2200         /* process the pairing complete */
2201         smp_proc_pairing_cmpl(p_cb);
2202     }
2203 }
2204
2205 #endif