Lines Matching full:p_cb
45 static bool pts_test_send_authentication_complete_failure(tSMP_CB* p_cb) {
46 uint8_t reason = p_cb->cert_failure;
50 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
60 static void smp_update_key_mask(tSMP_CB* p_cb, uint8_t key_type, bool recv) {
63 __func__, p_cb->role, recv, p_cb->local_i_key, p_cb->local_r_key);
65 if (((p_cb->le_secure_connections_mode_is_used) || (p_cb->smp_over_br)) &&
70 p_cb->local_i_key &= ~key_type;
71 p_cb->local_r_key &= ~key_type;
72 } else if (p_cb->role == HCI_ROLE_SLAVE) {
74 p_cb->local_i_key &= ~key_type;
76 p_cb->local_r_key &= ~key_type;
79 p_cb->local_r_key &= ~key_type;
81 p_cb->local_i_key &= ~key_type;
85 p_cb->local_i_key, p_cb->local_r_key);
93 void smp_send_app_cback(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
96 SMP_TRACE_DEBUG("%s p_cb->cb_evt=%d", __func__, p_cb->cb_evt);
97 if (p_cb->p_callback && p_cb->cb_evt != 0) {
98 switch (p_cb->cb_evt) {
100 cb_data.io_req.auth_req = p_cb->peer_auth_req;
104 cb_data.io_req.init_keys = p_cb->local_i_key;
105 cb_data.io_req.resp_keys = p_cb->local_r_key;
116 cb_data.loc_oob_data = p_cb->sc_oob_data.loc_oob_data;
133 (*p_cb->p_callback)(p_cb->cb_evt, p_cb->pairing_bda, &cb_data);
135 SMP_TRACE_DEBUG("%s: callback_rc=%d p_cb->cb_evt=%d", __func__,
136 callback_rc, p_cb->cb_evt);
139 switch (p_cb->cb_evt) {
141 p_cb->loc_auth_req = cb_data.io_req.auth_req;
142 p_cb->local_io_capability = cb_data.io_req.io_cap;
143 p_cb->loc_oob_flag = cb_data.io_req.oob_data;
144 p_cb->loc_enc_size = cb_data.io_req.max_key_size;
145 p_cb->local_i_key = cb_data.io_req.init_keys;
146 p_cb->local_r_key = cb_data.io_req.resp_keys;
148 if (!(p_cb->loc_auth_req & SMP_AUTH_BOND)) {
150 p_cb->local_i_key = 0;
151 p_cb->local_r_key = 0;
158 p_cb->loc_auth_req, p_cb->local_io_capability, p_cb->loc_oob_flag,
159 p_cb->loc_enc_size, p_cb->local_i_key, p_cb->local_r_key);
161 p_cb->secure_connections_only_mode_required =
164 if (p_cb->secure_connections_only_mode_required) {
165 p_cb->loc_auth_req |= SMP_SC_SUPPORT_BIT;
168 if (!(p_cb->loc_auth_req & SMP_SC_SUPPORT_BIT) ||
169 lmp_version_below(p_cb->pairing_bda, HCI_PROTO_VERSION_4_2) ||
171 (const RawAddress*)&p_cb->pairing_bda)) {
172 p_cb->loc_auth_req &= ~SMP_KP_SUPPORT_BIT;
173 p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
174 p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
177 if (lmp_version_below(p_cb->pairing_bda, HCI_PROTO_VERSION_5_0)) {
178 p_cb->loc_auth_req &= ~SMP_H7_SUPPORT_BIT;
183 p_cb->loc_auth_req, p_cb->local_i_key, p_cb->local_r_key);
185 smp_sm_event(p_cb, SMP_IO_RSP_EVT, NULL);
189 p_cb->loc_enc_size = cb_data.io_req.max_key_size;
190 p_cb->local_i_key = cb_data.io_req.init_keys;
191 p_cb->local_r_key = cb_data.io_req.resp_keys;
192 p_cb->loc_auth_req |= SMP_H7_SUPPORT_BIT;
194 p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
195 p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
199 "local_r_key: 0x%02x, p_cb->loc_auth_req: 0x%02x",
200 p_cb->loc_enc_size, p_cb->local_i_key, p_cb->local_r_key,
201 p_cb->loc_auth_req);
203 smp_br_state_machine_event(p_cb, SMP_BR_KEYS_RSP_EVT, NULL);
209 if (!p_cb->cb_evt && p_cb->discard_sec_req) {
210 p_cb->discard_sec_req = false;
211 smp_sm_event(p_cb, SMP_DISCARD_SEC_REQ_EVT, NULL);
221 void smp_send_pair_fail(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
222 p_cb->status = *(uint8_t*)p_data;
223 p_cb->failure = *(uint8_t*)p_data;
225 SMP_TRACE_DEBUG("%s: status=%d failure=%d ", __func__, p_cb->status,
226 p_cb->failure);
228 if (p_cb->status <= SMP_MAX_FAIL_RSN_PER_SPEC &&
229 p_cb->status != SMP_SUCCESS) {
230 smp_send_cmd(SMP_OPCODE_PAIRING_FAILED, p_cb);
231 p_cb->wait_for_authorization_complete = true;
239 void smp_send_pair_req(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
240 tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(p_cb->pairing_bda);
247 smp_send_cmd(SMP_OPCODE_PAIRING_REQ, p_cb);
254 void smp_send_pair_rsp(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
257 p_cb->local_i_key &= p_cb->peer_i_key;
258 p_cb->local_r_key &= p_cb->peer_r_key;
260 if (smp_send_cmd(SMP_OPCODE_PAIRING_RSP, p_cb)) {
261 if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_OOB)
262 smp_use_oob_private_key(p_cb, NULL);
264 smp_decide_association_model(p_cb, NULL);
272 void smp_send_confirm(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
274 smp_send_cmd(SMP_OPCODE_CONFIRM, p_cb);
281 void smp_send_init(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
283 smp_send_cmd(SMP_OPCODE_INIT, p_cb);
290 void smp_send_rand(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
292 smp_send_cmd(SMP_OPCODE_RAND, p_cb);
299 void smp_send_pair_public_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
301 smp_send_cmd(SMP_OPCODE_PAIR_PUBLIC_KEY, p_cb);
308 void smp_send_commitment(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
310 smp_send_cmd(SMP_OPCODE_PAIR_COMMITM, p_cb);
317 void smp_send_dhkey_check(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
319 smp_send_cmd(SMP_OPCODE_PAIR_DHKEY_CHECK, p_cb);
326 void smp_send_keypress_notification(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
327 p_cb->local_keypress_notification = *(uint8_t*)p_data;
328 smp_send_cmd(SMP_OPCODE_PAIR_KEYPR_NOTIF, p_cb);
335 void smp_send_enc_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
338 SMP_TRACE_DEBUG("%s: p_cb->loc_enc_size = %d", __func__, p_cb->loc_enc_size);
339 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_ENC, false);
341 smp_send_cmd(SMP_OPCODE_ENCRYPT_INFO, p_cb);
342 smp_send_cmd(SMP_OPCODE_MASTER_ID, p_cb);
345 memcpy(le_key.ltk, p_cb->ltk, BT_OCTET16_LEN);
346 le_key.div = p_cb->div;
347 le_key.key_size = p_cb->loc_enc_size;
348 le_key.sec_level = p_cb->sec_level;
350 if ((p_cb->peer_auth_req & SMP_AUTH_BOND) &&
351 (p_cb->loc_auth_req & SMP_AUTH_BOND))
352 btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LENC,
357 smp_key_distribution(p_cb, NULL);
364 void smp_send_id_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
367 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_ID, false);
369 smp_send_cmd(SMP_OPCODE_IDENTITY_INFO, p_cb);
370 smp_send_cmd(SMP_OPCODE_ID_ADDR, p_cb);
372 if ((p_cb->peer_auth_req & SMP_AUTH_BOND) &&
373 (p_cb->loc_auth_req & SMP_AUTH_BOND))
374 btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LID, &le_key, true);
377 smp_key_distribution_by_transport(p_cb, NULL);
384 void smp_send_csrk_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
387 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_CSRK, false);
389 if (smp_send_cmd(SMP_OPCODE_SIGN_INFO, p_cb)) {
390 key.div = p_cb->div;
391 key.sec_level = p_cb->sec_level;
393 memcpy(key.csrk, p_cb->csrk, BT_OCTET16_LEN);
394 btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LCSRK,
398 smp_key_distribution_by_transport(p_cb, NULL);
405 void smp_send_ltk_reply(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
408 btm_ble_ltk_request_reply(p_cb->pairing_bda, true, p_data->key.p_data);
415 void smp_proc_sec_req(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
422 p_cb->cb_evt = 0;
424 btm_ble_link_sec_check(p_cb->pairing_bda, auth_req, &sec_req_act);
431 smp_sm_event(p_cb, SMP_ENC_REQ_EVT, NULL);
435 p_cb->secure_connections_only_mode_required =
439 if (p_cb->secure_connections_only_mode_required &&
442 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
445 p_cb->peer_auth_req = auth_req;
446 p_cb->local_r_key = p_cb->local_i_key = SMP_SEC_DEFAULT_KEY;
447 p_cb->cb_evt = SMP_SEC_REQUEST_EVT;
452 p_cb->discard_sec_req = true;
465 void smp_proc_sec_grant(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
469 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, p_data);
473 p_cb->cb_evt = SMP_IO_CAP_REQ_EVT;
481 void smp_proc_pair_fail(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
483 p_cb->status = *(uint8_t*)p_data;
486 alarm_cancel(p_cb->delayed_auth_timer_ent);
493 void smp_proc_pair_cmd(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
496 tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(p_cb->pairing_bda);
500 if (p_dev_rec && (p_cb->role == HCI_ROLE_SLAVE))
503 p_cb->flags |= SMP_PAIR_FLAG_ENC_AFTER_PAIR;
505 STREAM_TO_UINT8(p_cb->peer_io_caps, p);
506 STREAM_TO_UINT8(p_cb->peer_oob_flag, p);
507 STREAM_TO_UINT8(p_cb->peer_auth_req, p);
508 STREAM_TO_UINT8(p_cb->peer_enc_size, p);
509 STREAM_TO_UINT8(p_cb->peer_i_key, p);
510 STREAM_TO_UINT8(p_cb->peer_r_key, p);
512 if (smp_command_has_invalid_parameters(p_cb)) {
514 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
519 if (pts_test_send_authentication_complete_failure(p_cb)) return;
521 if (p_cb->role == HCI_ROLE_SLAVE) {
522 if (!(p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD)) {
524 p_cb->local_i_key = p_cb->peer_i_key;
525 p_cb->local_r_key = p_cb->peer_r_key;
527 p_cb->cb_evt = SMP_SEC_REQUEST_EVT;
531 p_cb->local_i_key &= p_cb->peer_i_key;
532 p_cb->local_r_key &= p_cb->peer_r_key;
533 p_cb->selected_association_model = smp_select_association_model(p_cb);
535 if (p_cb->secure_connections_only_mode_required &&
536 (!(p_cb->le_secure_connections_mode_is_used) ||
537 (p_cb->selected_association_model ==
543 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
547 if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_OOB) {
548 if (smp_request_oob_data(p_cb)) return;
550 smp_send_pair_rsp(p_cb, NULL);
555 p_cb->selected_association_model = smp_select_association_model(p_cb);
557 if (p_cb->secure_connections_only_mode_required &&
558 (!(p_cb->le_secure_connections_mode_is_used) ||
559 (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS))) {
564 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
568 if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_OOB) {
569 if (smp_request_oob_data(p_cb)) return;
571 smp_decide_association_model(p_cb, NULL);
580 void smp_proc_confirm(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
586 if (smp_command_has_invalid_parameters(p_cb)) {
587 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
593 STREAM_TO_ARRAY(p_cb->rconfirm, p, BT_OCTET16_LEN);
596 p_cb->flags |= SMP_PAIR_FLAGS_CMD_CONFIRM;
603 void smp_proc_init(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
609 if (smp_command_has_invalid_parameters(p_cb)) {
610 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
615 STREAM_TO_ARRAY(p_cb->rrand, p, BT_OCTET16_LEN);
622 void smp_proc_rand(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
628 if (smp_command_has_invalid_parameters(p_cb)) {
629 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
634 STREAM_TO_ARRAY(p_cb->rrand, p, BT_OCTET16_LEN);
645 void smp_process_pairing_public_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
651 if (smp_command_has_invalid_parameters(p_cb)) {
652 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
656 STREAM_TO_ARRAY(p_cb->peer_publ_key.x, p, BT_OCTET32_LEN);
657 STREAM_TO_ARRAY(p_cb->peer_publ_key.y, p, BT_OCTET32_LEN);
658 p_cb->flags |= SMP_PAIR_FLAG_HAVE_PEER_PUBL_KEY;
660 smp_wait_for_both_public_keys(p_cb, NULL);
667 void smp_process_pairing_commitment(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
673 if (smp_command_has_invalid_parameters(p_cb)) {
674 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
678 p_cb->flags |= SMP_PAIR_FLAG_HAVE_PEER_COMM;
681 STREAM_TO_ARRAY(p_cb->remote_commitment, p, BT_OCTET16_LEN);
689 void smp_process_dhkey_check(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
695 if (smp_command_has_invalid_parameters(p_cb)) {
696 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
701 STREAM_TO_ARRAY(p_cb->remote_dhkey_check, p, BT_OCTET16_LEN);
704 p_cb->flags |= SMP_PAIR_FLAG_HAVE_PEER_DHK_CHK;
711 void smp_process_keypress_notification(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
716 p_cb->status = *(uint8_t*)p_data;
718 if (smp_command_has_invalid_parameters(p_cb)) {
719 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
724 STREAM_TO_UINT8(p_cb->peer_keypress_notification, p);
726 p_cb->peer_keypress_notification = BTM_SP_KEY_OUT_OF_RANGE;
728 p_cb->cb_evt = SMP_PEER_KEYPR_NOT_EVT;
736 void smp_br_process_pairing_command(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
739 tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(p_cb->pairing_bda);
743 if (!p_dev_rec->new_encryption_key_is_p256 && p_cb->role == HCI_ROLE_SLAVE) {
745 smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
750 if (p_dev_rec && (p_cb->role == HCI_ROLE_SLAVE))
753 p_cb->flags |= SMP_PAIR_FLAG_ENC_AFTER_PAIR;
755 STREAM_TO_UINT8(p_cb->peer_io_caps, p);
756 STREAM_TO_UINT8(p_cb->peer_oob_flag, p);
757 STREAM_TO_UINT8(p_cb->peer_auth_req, p);
758 STREAM_TO_UINT8(p_cb->peer_enc_size, p);
759 STREAM_TO_UINT8(p_cb->peer_i_key, p);
760 STREAM_TO_UINT8(p_cb->peer_r_key, p);
762 if (smp_command_has_invalid_parameters(p_cb)) {
764 smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
770 p_cb->local_i_key = p_cb->peer_i_key;
771 p_cb->local_r_key = p_cb->peer_r_key;
773 if (p_cb->role == HCI_ROLE_SLAVE) {
776 p_cb->cb_evt = SMP_BR_KEYS_REQ_EVT;
787 p_cb->peer_auth_req |= SMP_AUTH_BOND;
788 p_cb->loc_auth_req |= SMP_AUTH_BOND;
795 void smp_br_process_security_grant(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
799 smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, p_data);
802 p_cb->cb_evt = SMP_BR_KEYS_REQ_EVT;
811 void smp_br_check_authorization_request(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
815 __func__, p_cb->local_i_key, p_cb->local_r_key);
818 p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
819 p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
823 if (p_cb->role == HCI_ROLE_MASTER) {
824 p_cb->local_r_key &= (SMP_SEC_KEY_TYPE_ID | SMP_SEC_KEY_TYPE_CSRK);
828 if ((p_cb->loc_auth_req & SMP_H7_SUPPORT_BIT) &&
829 (p_cb->peer_auth_req & SMP_H7_SUPPORT_BIT)) {
830 p_cb->key_derivation_h7_used = TRUE;
832 SMP_TRACE_DEBUG("%s: use h7 = %d", __func__, p_cb->key_derivation_h7_used);
836 __func__, p_cb->local_i_key, p_cb->local_r_key);
838 if (/*((p_cb->peer_auth_req & SMP_AUTH_BOND) ||
839 (p_cb->loc_auth_req & SMP_AUTH_BOND)) &&*/
840 (p_cb->local_i_key || p_cb->local_r_key)) {
841 smp_br_state_machine_event(p_cb, SMP_BR_BOND_REQ_EVT, NULL);
844 if (p_cb->role == HCI_ROLE_MASTER && p_cb->local_r_key == 0)
845 smp_key_distribution_by_transport(p_cb, NULL);
847 smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
856 void smp_br_select_next_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
859 p_cb->role, p_cb->local_r_key, p_cb->local_i_key);
861 if (p_cb->role == HCI_ROLE_SLAVE ||
862 (!p_cb->local_r_key && p_cb->role == HCI_ROLE_MASTER)) {
863 smp_key_pick_key(p_cb, p_data);
866 if (!p_cb->local_i_key && !p_cb->local_r_key) {
869 if (p_cb->total_tx_unacked == 0)
870 smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
872 p_cb->wait_for_authorization_complete = true;
881 void smp_proc_enc_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
885 STREAM_TO_ARRAY(p_cb->ltk, p, BT_OCTET16_LEN);
887 smp_key_distribution(p_cb, NULL);
893 void smp_proc_master_id(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
898 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_ENC, true);
904 memcpy(le_key.ltk, p_cb->ltk, BT_OCTET16_LEN);
905 le_key.sec_level = p_cb->sec_level;
906 le_key.key_size = p_cb->loc_enc_size;
908 if ((p_cb->peer_auth_req & SMP_AUTH_BOND) &&
909 (p_cb->loc_auth_req & SMP_AUTH_BOND))
910 btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_PENC,
913 smp_key_distribution(p_cb, NULL);
920 void smp_proc_id_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
924 STREAM_TO_ARRAY(p_cb->tk, p, BT_OCTET16_LEN); /* reuse TK for IRK */
925 smp_key_distribution_by_transport(p_cb, NULL);
932 void smp_proc_id_addr(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
937 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_ID, true);
941 memcpy(pid_key.irk, p_cb->tk, BT_OCTET16_LEN);
944 p_cb->id_addr_rcvd = true;
945 p_cb->id_addr_type = pid_key.addr_type;
946 p_cb->id_addr = pid_key.static_addr;
949 if ((p_cb->peer_auth_req & SMP_AUTH_BOND) &&
950 (p_cb->loc_auth_req & SMP_AUTH_BOND))
951 btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_PID,
953 smp_key_distribution_by_transport(p_cb, NULL);
960 void smp_proc_srk_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
964 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_CSRK, true);
967 le_key.sec_level = p_cb->sec_level;
975 if ((p_cb->peer_auth_req & SMP_AUTH_BOND) &&
976 (p_cb->loc_auth_req & SMP_AUTH_BOND))
977 btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_PCSRK,
979 smp_key_distribution_by_transport(p_cb, NULL);
986 void smp_proc_compare(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
990 if (!memcmp(p_cb->rconfirm, p_data->key.p_data, BT_OCTET16_LEN)) {
993 if (p_cb->peer_enc_size < p_cb->loc_enc_size)
994 p_cb->loc_enc_size = p_cb->peer_enc_size;
996 if (p_cb->role == HCI_ROLE_SLAVE)
997 smp_sm_event(p_cb, SMP_RAND_EVT, NULL);
1000 p_cb->local_i_key = p_cb->peer_i_key;
1001 p_cb->local_r_key = p_cb->peer_r_key;
1003 smp_sm_event(p_cb, SMP_ENC_REQ_EVT, NULL);
1007 reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
1008 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1016 void smp_proc_sl_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1021 smp_generate_srand_mrand_confirm(p_cb, NULL);
1025 if (p_cb->flags & SMP_PAIR_FLAGS_CMD_CONFIRM)
1026 smp_sm_event(p_cb, SMP_CONFIRM_EVT, NULL);
1034 void smp_start_enc(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1040 cmd = btm_ble_start_encrypt(p_cb->pairing_bda, true, p_data->key.p_data);
1042 cmd = btm_ble_start_encrypt(p_cb->pairing_bda, false, NULL);
1045 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1052 void smp_proc_discard(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1054 if (!(p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD))
1055 smp_reset_control_value(p_cb);
1062 void smp_enc_cmpl(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1067 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1074 void smp_check_auth_req(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1080 __func__, enc_enable, p_cb->local_i_key, p_cb->local_r_key);
1082 if (p_cb->le_secure_connections_mode_is_used) {
1084 p_cb->local_i_key |= SMP_SEC_KEY_TYPE_ENC;
1085 p_cb->local_r_key |= SMP_SEC_KEY_TYPE_ENC;
1088 if (!(p_cb->local_i_key & SMP_SEC_KEY_TYPE_LK) ||
1089 !(p_cb->local_r_key & SMP_SEC_KEY_TYPE_LK)) {
1090 p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
1091 p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
1097 if (p_cb->role == HCI_ROLE_MASTER) {
1098 p_cb->local_r_key &= (SMP_SEC_KEY_TYPE_ID | SMP_SEC_KEY_TYPE_CSRK);
1102 p_cb->local_i_key &= ~SMP_SEC_KEY_TYPE_LK;
1103 p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK;
1107 __func__, p_cb->local_i_key, p_cb->local_r_key);
1109 if (/*((p_cb->peer_auth_req & SMP_AUTH_BOND) ||
1110 (p_cb->loc_auth_req & SMP_AUTH_BOND)) &&*/
1111 (p_cb->local_i_key || p_cb->local_r_key)) {
1112 smp_sm_event(p_cb, SMP_BOND_REQ_EVT, NULL);
1114 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1117 if (p_cb->flags & SMP_PAIR_FLAG_ENC_AFTER_PAIR)
1118 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1121 else if (p_cb->role == HCI_ROLE_MASTER) {
1122 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1131 void smp_key_pick_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1133 (p_cb->role == HCI_ROLE_SLAVE) ? p_cb->local_r_key : p_cb->local_i_key;
1142 (*smp_distribute_act[i])(p_cb, p_data);
1152 void smp_key_distribution(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1154 p_cb->role, p_cb->local_r_key, p_cb->local_i_key);
1156 if (p_cb->role == HCI_ROLE_SLAVE ||
1157 (!p_cb->local_r_key && p_cb->role == HCI_ROLE_MASTER)) {
1158 smp_key_pick_key(p_cb, p_data);
1161 if (!p_cb->local_i_key && !p_cb->local_r_key) {
1164 if (p_cb->derive_lk) {
1165 smp_derive_link_key_from_long_term_key(p_cb, NULL);
1166 p_cb->derive_lk = false;
1169 if (p_cb->total_tx_unacked == 0) {
1177 if (!alarm_is_scheduled(p_cb->delayed_auth_timer_ent)) {
1179 alarm_set_on_mloop(p_cb->delayed_auth_timer_ent,
1184 p_cb->wait_for_authorization_complete = true;
1196 void smp_decide_association_model(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1203 p_cb->selected_association_model);
1205 switch (p_cb->selected_association_model) {
1207 if (p_cb->role == HCI_ROLE_MASTER &&
1208 ((p_cb->peer_auth_req & SMP_AUTH_YN_BIT) != 0) &&
1209 ((p_cb->loc_auth_req & SMP_AUTH_YN_BIT) == 0)) {
1216 p_cb->sec_level = SMP_SEC_UNAUTHENTICATE;
1217 SMP_TRACE_EVENT("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE) ",
1218 p_cb->sec_level);
1221 key.p_data = p_cb->tk;
1224 memset(p_cb->tk, 0, BT_OCTET16_LEN);
1231 p_cb->sec_level = SMP_SEC_AUTHENTICATED;
1232 SMP_TRACE_EVENT("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ",
1233 p_cb->sec_level);
1235 p_cb->cb_evt = SMP_PASSKEY_REQ_EVT;
1241 p_cb->sec_level = SMP_SEC_AUTHENTICATED;
1242 SMP_TRACE_EVENT("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ",
1243 p_cb->sec_level);
1245 p_cb->cb_evt = SMP_OOB_REQ_EVT;
1250 p_cb->sec_level = SMP_SEC_AUTHENTICATED;
1254 smp_generate_passkey(p_cb, NULL);
1274 p_cb->selected_association_model);
1279 SMP_TRACE_EVENT("sec_level=%d ", p_cb->sec_level);
1280 if (int_evt) smp_sm_event(p_cb, int_evt, p);
1287 void smp_process_io_response(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1291 if (p_cb
1294 smp_send_cmd(SMP_OPCODE_SEC_REQ, p_cb);
1298 p_cb->selected_association_model = smp_select_association_model(p_cb);
1300 if (p_cb->secure_connections_only_mode_required &&
1301 (!(p_cb->le_secure_connections_mode_is_used) ||
1302 (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS))) {
1306 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1310 if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_OOB) {
1311 if (smp_request_oob_data(p_cb)) return;
1315 if (pts_test_send_authentication_complete_failure(p_cb)) return;
1317 smp_send_pair_rsp(p_cb, NULL);
1326 void smp_br_process_slave_keys_response(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1327 smp_br_send_pair_response(p_cb, NULL);
1335 void smp_br_send_pair_response(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1338 p_cb->local_i_key &= p_cb->peer_i_key;
1339 p_cb->local_r_key &= p_cb->peer_r_key;
1341 smp_send_cmd(SMP_OPCODE_PAIRING_RSP, p_cb);
1349 void smp_pairing_cmpl(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1350 if (p_cb->total_tx_unacked == 0) {
1352 smp_proc_pairing_cmpl(p_cb);
1361 void smp_pair_terminate(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1363 p_cb->status = SMP_CONN_TOUT;
1364 smp_proc_pairing_cmpl(p_cb);
1372 void smp_idle_terminate(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1373 if (p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD) {
1375 p_cb->status = SMP_FAIL;
1376 smp_proc_pairing_cmpl(p_cb);
1384 void smp_fast_conn_param(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1389 L2CA_EnableUpdateBleConnParams(p_cb->pairing_bda, false);
1401 void smp_both_have_public_keys(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1405 smp_compute_dhkey(p_cb);
1408 if (p_cb->role == HCI_ROLE_SLAVE) smp_send_pair_public_key(p_cb, NULL);
1410 smp_sm_event(p_cb, SMP_SC_DHKEY_CMPLT_EVT, NULL);
1420 void smp_start_secure_connection_phase1(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1423 if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS) {
1424 p_cb->sec_level = SMP_SEC_UNAUTHENTICATE;
1425 SMP_TRACE_EVENT("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE) ",
1426 p_cb->sec_level);
1428 p_cb->sec_level = SMP_SEC_AUTHENTICATED;
1429 SMP_TRACE_EVENT("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ",
1430 p_cb->sec_level);
1433 switch (p_cb->selected_association_model) {
1436 memset(p_cb->local_random, 0, BT_OCTET16_LEN);
1437 smp_start_nonce_generation(p_cb);
1441 p_cb->cb_evt = SMP_PASSKEY_REQ_EVT;
1442 smp_sm_event(p_cb, SMP_TK_REQ_EVT, NULL);
1447 smp_generate_passkey(p_cb, NULL);
1451 smp_process_secure_connection_oob_data(p_cb, NULL);
1455 p_cb->selected_association_model);
1466 void smp_process_local_nonce(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1469 switch (p_cb->selected_association_model) {
1472 if (p_cb->role == HCI_ROLE_SLAVE) {
1474 smp_calculate_local_commitment(p_cb);
1475 smp_send_commitment(p_cb, NULL);
1480 if (p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_COMM) {
1486 p_cb->selected_association_model);
1487 p_cb->flags &= ~SMP_PAIR_FLAG_HAVE_PEER_COMM;
1488 smp_send_rand(p_cb, NULL);
1495 smp_calculate_local_commitment(p_cb);
1497 if (p_cb->role == HCI_ROLE_MASTER) {
1498 smp_send_commitment(p_cb, NULL);
1501 if (p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_COMM) {
1503 smp_send_commitment(p_cb, NULL);
1509 if (p_cb->role == HCI_ROLE_MASTER) {
1510 smp_send_rand(p_cb, NULL);
1517 p_cb->selected_association_model);
1530 void smp_process_peer_nonce(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1536 if (p_cb->cert_failure == SMP_CONFIRM_VALUE_ERR) {
1537 SMP_TRACE_ERROR("%s failure case = %d", __func__, p_cb->cert_failure);
1538 reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
1539 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1543 if ((p_cb->cert_failure == SMP_NUMERIC_COMPAR_FAIL) &&
1544 (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS) &&
1545 (p_cb->role == HCI_ROLE_SLAVE)) {
1546 SMP_TRACE_ERROR("%s failure case = %d", __func__, p_cb->cert_failure);
1547 reason = p_cb->failure = SMP_NUMERIC_COMPAR_FAIL;
1548 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1552 switch (p_cb->selected_association_model) {
1556 if (p_cb->role == HCI_ROLE_MASTER) {
1557 if (!smp_check_commitment(p_cb)) {
1558 reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
1559 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1564 smp_send_rand(p_cb, NULL);
1567 if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS) {
1569 smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL);
1573 smp_sm_event(p_cb, SMP_SC_CALC_NC_EVT, NULL);
1578 if (!smp_check_commitment(p_cb) &&
1579 p_cb->cert_failure != SMP_NUMERIC_COMPAR_FAIL) {
1580 reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
1581 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1585 if (p_cb->role == HCI_ROLE_SLAVE) {
1586 smp_send_rand(p_cb, NULL);
1589 if (++p_cb->round < 20) {
1591 p_cb->flags &= ~SMP_PAIR_FLAG_HAVE_PEER_COMM;
1592 smp_start_nonce_generation(p_cb);
1596 smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL);
1599 if (p_cb->role == HCI_ROLE_SLAVE) {
1600 smp_send_rand(p_cb, NULL);
1603 smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL);
1607 p_cb->selected_association_model);
1619 void smp_match_dhkey_checks(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1624 if (memcmp(p_data->key.p_data, p_cb->remote_dhkey_check, BT_OCTET16_LEN)) {
1626 p_cb->failure = reason;
1627 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1635 if (p_cb->peer_enc_size < p_cb->loc_enc_size)
1636 p_cb->loc_enc_size = p_cb->peer_enc_size;
1638 if (p_cb->role == HCI_ROLE_SLAVE) {
1639 smp_sm_event(p_cb, SMP_PAIR_DHKEY_CHCK_EVT, NULL);
1642 p_cb->local_i_key = p_cb->peer_i_key;
1643 p_cb->local_r_key = p_cb->peer_r_key;
1644 smp_sm_event(p_cb, SMP_ENC_REQ_EVT, NULL);
1655 void smp_move_to_secure_connections_phase2(tSMP_CB* p_cb,
1658 smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL);
1670 void smp_phase_2_dhkey_checks_are_present(tSMP_CB* p_cb,
1674 if (p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_DHK_CHK)
1675 smp_sm_event(p_cb, SMP_SC_2_DHCK_CHKS_PRES_EVT, NULL);
1686 void smp_wait_for_both_public_keys(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1689 if ((p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_PUBL_KEY) &&
1690 (p_cb->flags & SMP_PAIR_FLAG_HAVE_LOCAL_PUBL_KEY)) {
1691 if ((p_cb->role == HCI_ROLE_SLAVE) &&
1692 ((p_cb->req_oob_type == SMP_OOB_LOCAL) ||
1693 (p_cb->req_oob_type == SMP_OOB_BOTH))) {
1696 smp_sm_event(p_cb, SMP_BOTH_PUBL_KEYS_RCVD_EVT, NULL);
1704 void smp_start_passkey_verification(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1708 p = p_cb->local_random;
1711 p = p_cb->peer_random;
1714 p_cb->round = 0;
1715 smp_start_nonce_generation(p_cb);
1722 void smp_process_secure_connection_oob_data(tSMP_CB* p_cb,
1726 tSMP_SC_OOB_DATA* p_sc_oob_data = &p_cb->sc_oob_data;
1728 memcpy(p_cb->local_random, p_sc_oob_data->loc_oob_data.randomizer,
1729 sizeof(p_cb->local_random));
1732 memset(p_cb->local_random, 0, sizeof(p_cb->local_random));
1737 memset(p_cb->peer_random, 0, sizeof(p_cb->peer_random));
1739 memcpy(p_cb->peer_random, p_sc_oob_data->peer_oob_data.randomizer,
1740 sizeof(p_cb->peer_random));
1741 memcpy(p_cb->remote_commitment, p_sc_oob_data->peer_oob_data.commitment,
1742 sizeof(p_cb->remote_commitment));
1746 if (!smp_check_commitment(p_cb)) {
1747 p_cb->failure = reason;
1748 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
1752 if (p_cb->peer_oob_flag != SMP_OOB_PRESENT) {
1757 memset(p_cb->local_random, 0, sizeof(p_cb->local_random));
1761 print128(p_cb->local_random, (const uint8_t*)"local OOB randomizer");
1762 print128(p_cb->peer_random, (const uint8_t*)"peer OOB randomizer");
1763 smp_start_nonce_generation(p_cb);
1772 void smp_set_local_oob_keys(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1775 memcpy(p_cb->sc_oob_data.loc_oob_data.private_key_used, p_cb->private_key,
1777 p_cb->sc_oob_data.loc_oob_data.publ_key_used = p_cb->loc_publ_key;
1778 smp_start_nonce_generation(p_cb);
1787 void smp_set_local_oob_random_commitment(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1789 memcpy(p_cb->sc_oob_data.loc_oob_data.randomizer, p_cb->rand, BT_OCTET16_LEN);
1791 smp_calculate_f4(p_cb->sc_oob_data.loc_oob_data.publ_key_used.x,
1792 p_cb->sc_oob_data.loc_oob_data.publ_key_used.x,
1793 p_cb->sc_oob_data.loc_oob_data.randomizer, 0,
1794 p_cb->sc_oob_data.loc_oob_data.commitment);
1799 p_print = (uint8_t*)&p_cb->sc_oob_data.loc_oob_data.addr_sent_to;
1802 p_print = (uint8_t*)&p_cb->sc_oob_data.loc_oob_data.private_key_used;
1805 p_print = (uint8_t*)&p_cb->sc_oob_data.loc_oob_data.publ_key_used.x;
1808 p_print = (uint8_t*)&p_cb->sc_oob_data.loc_oob_data.publ_key_used.y;
1811 p_print = (uint8_t*)&p_cb->sc_oob_data.loc_oob_data.randomizer;
1813 p_print = (uint8_t*)&p_cb->sc_oob_data.loc_oob_data.commitment;
1819 p_cb->cb_evt = SMP_SC_LOC_OOB_DATA_UP_EVT;
1820 smp_send_app_cback(p_cb, NULL);
1822 smp_cb_cleanup(p_cb);
1838 tSMP_CB* p_cb = &smp_cb;
1845 if (p_cb->loc_enc_size != 0 && encr_enable) {
1847 btm_ble_update_sec_key_size(bda, p_cb->loc_enc_size);
1898 tSMP_CB* p_cb = &smp_cb;
1901 smp_save_secure_connections_long_term_key(p_cb);
1903 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_ENC, false);
1904 smp_key_distribution(p_cb, NULL);
1918 void smp_set_derive_link_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1920 p_cb->derive_lk = true;
1921 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_LK, false);
1922 smp_key_distribution(p_cb, NULL);
1934 void smp_derive_link_key_from_long_term_key(tSMP_CB* p_cb,
1939 if (!smp_calculate_link_key_from_long_term_key(p_cb)) {
1941 smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
1957 void smp_br_process_link_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1961 if (!smp_calculate_long_term_key_from_link_key(p_cb)) {
1963 smp_sm_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &status);
1969 smp_save_secure_connections_long_term_key(p_cb);
1970 smp_update_key_mask(p_cb, SMP_SEC_KEY_TYPE_ENC, false);
1971 smp_br_select_next_key(p_cb, NULL);
1979 void smp_key_distribution_by_transport(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1981 if (p_cb->smp_over_br) {
1982 smp_br_select_next_key(p_cb, NULL);
1984 smp_key_distribution(p_cb, NULL);
1993 void smp_br_pairing_complete(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
1996 if (p_cb->total_tx_unacked == 0) {
1998 smp_proc_pairing_cmpl(p_cb);
