Lines Matching +full:remote +full:- +full:mac +full:- +full:address
8 * Copyright (c) 2015-2016 Intel Corporation
10 * SPDX-License-Identifier: Apache-2.0
132 SMP_FLAG_DHCHECK_WAIT, /* if waiting for remote DHCheck (as periph) */
138 /* Total number of flags - must be at the end */
144 /* Commands that remote is allowed to send */
165 /* Remote random number */
171 /* Remote Public Key for LE SC */
177 /* Remote DHKey check */
192 /* LE SC remote OOB data */
198 /* Remote key distribution */
221 (smp)->method == PASSKEY_DISPLAY)
225 static const uint8_t gen_method_legacy[5 /* remote */][5 /* local */] = {
238 static const uint8_t gen_method_sc[5 /* remote */][5 /* local */] = {
253 /* Commands that remote is allowed to send */
262 /* Remote key distribution */
294 /* Value used to mark that per-connection bondable flag is not initialized.
297 #define BT_SMP_BONDABLE_UNINITIALIZED ((atomic_val_t)-1)
303 * "LE Read Local P-256 Public Key" and "LE Generate DH Key" commands. in le_sc_supported()
316 (void)atomic_ptr_cas(&smp->auth_cb, BT_SMP_AUTH_CB_UNINITIALIZED, in latch_auth_cb()
319 return atomic_ptr_get(&smp->auth_cb); in latch_auth_cb()
324 (void)atomic_cas(&smp->bondable, BT_SMP_BONDABLE_UNINITIALIZED, (atomic_val_t)bondable); in latch_bondable()
326 return atomic_get(&smp->bondable); in latch_bondable()
338 if (smp_auth_cb->passkey_display && smp_auth_cb->passkey_entry && in get_io_capa()
339 (smp_auth_cb->passkey_confirm || !sc_supported)) { in get_io_capa()
344 if (sc_supported && smp_auth_cb->passkey_display && in get_io_capa()
345 smp_auth_cb->passkey_confirm) { in get_io_capa()
349 if (smp_auth_cb->passkey_entry) { in get_io_capa()
358 if (smp_auth_cb->passkey_display) { in get_io_capa()
377 if (atomic_test_bit(conn->flags, BT_CONN_FORCE_PAIR)) { in smp_keys_check()
381 if (!conn->le.keys) { in smp_keys_check()
382 conn->le.keys = bt_keys_find(BT_KEYS_LTK_P256, in smp_keys_check()
383 conn->id, &conn->le.dst); in smp_keys_check()
384 if (!conn->le.keys) { in smp_keys_check()
385 conn->le.keys = bt_keys_find(BT_KEYS_LTK, in smp_keys_check()
386 conn->id, in smp_keys_check()
387 &conn->le.dst); in smp_keys_check()
391 if (!conn->le.keys || in smp_keys_check()
392 !(conn->le.keys->keys & (BT_KEYS_LTK | BT_KEYS_LTK_P256))) { in smp_keys_check()
396 if (conn->required_sec_level >= BT_SECURITY_L3 && in smp_keys_check()
397 !(conn->le.keys->flags & BT_KEYS_AUTHENTICATED)) { in smp_keys_check()
401 if (conn->required_sec_level >= BT_SECURITY_L4 && in smp_keys_check()
402 !((conn->le.keys->flags & BT_KEYS_AUTHENTICATED) && in smp_keys_check()
403 (conn->le.keys->keys & BT_KEYS_LTK_P256) && in smp_keys_check()
404 (conn->le.keys->enc_size == BT_SMP_MAX_ENC_KEY_SIZE))) { in smp_keys_check()
414 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in get_pair_method()
422 req = (struct bt_smp_pairing *)&smp->preq[1]; in get_pair_method()
423 rsp = (struct bt_smp_pairing *)&smp->prsp[1]; in get_pair_method()
425 if ((req->auth_req & rsp->auth_req) & BT_SMP_AUTH_SC) { in get_pair_method()
427 if ((req->oob_flag | rsp->oob_flag) & BT_SMP_OOB_DATA_MASK) { in get_pair_method()
437 if (!((req->auth_req | rsp->auth_req) & BT_SMP_AUTH_MITM)) { in get_pair_method()
571 if (atomic_test_bit(smp->flags, SMP_FLAG_TIMEOUT)) { in smp_create_pdu()
585 atomic_set_bit(smp->flags, SMP_FLAG_TIMEOUT); in smp_create_pdu()
590 hdr->code = op; in smp_create_pdu()
599 req = (struct bt_smp_pairing *)&smp->preq[1]; in get_encryption_key_size()
600 rsp = (struct bt_smp_pairing *)&smp->prsp[1]; in get_encryption_key_size()
607 return MIN(req->max_key_size, rsp->max_key_size); in get_encryption_key_size()
616 !atomic_test_bit(smp->flags, SMP_FLAG_SC) && in update_keys_check()
617 smp->method != LEGACY_OOB) { in update_keys_check()
622 smp->method != LEGACY_OOB) { in update_keys_check()
627 !(keys->keys & (BT_KEYS_LTK_P256 | BT_KEYS_LTK))) { in update_keys_check()
631 if (keys->enc_size > get_encryption_key_size(smp)) { in update_keys_check()
635 if ((keys->keys & BT_KEYS_LTK_P256) && in update_keys_check()
636 !atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in update_keys_check()
640 if ((keys->flags & BT_KEYS_AUTHENTICATED) && in update_keys_check()
641 smp->method == JUST_WORKS) { in update_keys_check()
646 (!(keys->flags & BT_KEYS_AUTHENTICATED) in update_keys_check()
647 && smp->method == JUST_WORKS)) { in update_keys_check()
649 (keys->id == smp->chan.chan.conn->id)) { in update_keys_check()
660 struct bt_conn *conn = smp->chan.chan.conn; in update_debug_keys_check()
662 if (!conn->le.keys) { in update_debug_keys_check()
663 conn->le.keys = bt_keys_get_addr(conn->id, &conn->le.dst); in update_debug_keys_check()
666 if (!conn->le.keys || in update_debug_keys_check()
667 !(conn->le.keys->keys & (BT_KEYS_LTK_P256 | BT_KEYS_LTK))) { in update_debug_keys_check()
671 if (conn->le.keys->flags & BT_KEYS_DEBUG) { in update_debug_keys_check()
691 if (conn->type == BT_CONN_TYPE_LE) { in smp_check_complete()
698 smp->local_dist &= ~dist_complete; in smp_check_complete()
701 if (!smp->local_dist && !smp->remote_dist) { in smp_check_complete()
709 if (conn->type == BT_CONN_TYPE_BR) { in smp_check_complete()
716 smp->local_dist &= ~dist_complete; in smp_check_complete()
719 if (!smp->local_dist && !smp->remote_dist) { in smp_check_complete()
750 struct bt_conn *conn = smp->chan.chan.conn; in sc_derive_link_key()
759 * At this point remote device identity is known so we can use in sc_derive_link_key()
760 * destination address here in sc_derive_link_key()
762 link_key = bt_keys_get_link_key(&conn->le.dst.a); in sc_derive_link_key()
767 if (atomic_test_bit(smp->flags, SMP_FLAG_CT2)) { in sc_derive_link_key()
774 if (bt_crypto_h7(salt, conn->le.keys->ltk.val, ilk)) { in sc_derive_link_key()
782 if (bt_crypto_h6(conn->le.keys->ltk.val, tmp1, ilk)) { in sc_derive_link_key()
788 if (bt_crypto_h6(ilk, lebr, link_key->val)) { in sc_derive_link_key()
792 link_key->flags |= BT_LINK_KEY_SC; in sc_derive_link_key()
794 if (conn->le.keys->flags & BT_KEYS_AUTHENTICATED) { in sc_derive_link_key()
795 link_key->flags |= BT_LINK_KEY_AUTHENTICATED; in sc_derive_link_key()
797 link_key->flags &= ~BT_LINK_KEY_AUTHENTICATED; in sc_derive_link_key()
806 atomic_set(smp->flags, 0); in smp_br_reset()
812 (void)k_work_cancel_delayable(&smp->work); in smp_br_reset()
814 atomic_set(smp->allowed_cmds, 0); in smp_br_reset()
816 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_REQ); in smp_br_reset()
821 struct bt_conn *conn = smp->chan.chan.conn; in smp_pairing_br_complete()
827 /* For dualmode devices LE address is same as BR/EDR address in smp_pairing_br_complete()
830 bt_addr_copy(&addr.a, &conn->br.dst); in smp_pairing_br_complete()
832 keys = bt_keys_find_addr(conn->id, &addr); in smp_pairing_br_complete()
843 if (listener->pairing_failed) { in smp_pairing_br_complete()
844 listener->pairing_failed(smp->chan.chan.conn, in smp_pairing_br_complete()
849 bool bond_flag = atomic_test_bit(smp->flags, SMP_FLAG_BOND); in smp_pairing_br_complete()
858 if (listener->pairing_complete) { in smp_pairing_br_complete()
859 listener->pairing_complete(smp->chan.chan.conn, in smp_pairing_br_complete()
876 atomic_set_bit(smp->flags, SMP_FLAG_TIMEOUT); in smp_br_timeout()
882 int err = bt_l2cap_br_send_cb(smp->chan.chan.conn, BT_L2CAP_CID_BR_SMP, buf, cb, NULL); in smp_br_send()
885 if (err == -ENOBUFS) { in smp_br_send()
893 k_work_reschedule(&smp->work, SMP_TIMEOUT); in smp_br_send()
901 CONTAINER_OF(chan, struct bt_l2cap_br_chan, chan)->tx.cid); in bt_smp_br_connected()
903 atomic_set_bit(smp->flags, SMP_FLAG_BR_CONNECTED); in bt_smp_br_connected()
909 if (atomic_test_bit(smp->flags, SMP_FLAG_BR_PAIR)) { in bt_smp_br_connected()
910 bt_smp_br_send_pairing_req(chan->conn); in bt_smp_br_connected()
919 CONTAINER_OF(chan, struct bt_l2cap_br_chan, chan)->tx.cid); in bt_smp_br_disconnected()
924 (void)k_work_cancel_delayable(&smp->work); in bt_smp_br_disconnected()
936 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_FAIL); in smp_br_init()
943 struct bt_conn *conn = smp->chan.chan.conn; in smp_br_derive_ltk()
944 struct bt_keys_link_key *link_key = conn->br.link_key; in smp_br_derive_ltk()
955 if (IS_ENABLED(CONFIG_BT_SMP_FORCE_BREDR) && conn->encrypt != 0x02) { in smp_br_derive_ltk()
960 * For dualmode devices LE address is same as BR/EDR address and is of in smp_br_derive_ltk()
963 bt_addr_copy(&addr.a, &conn->br.dst); in smp_br_derive_ltk()
966 keys = bt_keys_get_type(BT_KEYS_LTK_P256, conn->id, &addr); in smp_br_derive_ltk()
972 if (atomic_test_bit(smp->flags, SMP_FLAG_CT2)) { in smp_br_derive_ltk()
979 if (bt_crypto_h7(salt, link_key->val, ilk)) { in smp_br_derive_ltk()
987 if (bt_crypto_h6(link_key->val, tmp2, ilk)) { in smp_br_derive_ltk()
993 if (bt_crypto_h6(ilk, brle, keys->ltk.val)) { in smp_br_derive_ltk()
998 (void)memset(keys->ltk.ediv, 0, sizeof(keys->ltk.ediv)); in smp_br_derive_ltk()
999 (void)memset(keys->ltk.rand, 0, sizeof(keys->ltk.rand)); in smp_br_derive_ltk()
1000 keys->enc_size = smp->enc_key_size; in smp_br_derive_ltk()
1002 if (link_key->flags & BT_LINK_KEY_AUTHENTICATED) { in smp_br_derive_ltk()
1003 keys->flags |= BT_KEYS_AUTHENTICATED; in smp_br_derive_ltk()
1005 keys->flags &= ~BT_KEYS_AUTHENTICATED; in smp_br_derive_ltk()
1019 if (atomic_test_bit(smp->flags, SMP_FLAG_TIMEOUT)) { in smp_br_create_pdu()
1033 atomic_set_bit(smp->flags, SMP_FLAG_TIMEOUT); in smp_br_create_pdu()
1038 hdr->code = op; in smp_br_create_pdu()
1045 struct bt_conn *conn = smp->chan.chan.conn; in smp_br_distribute_keys()
1050 * For dualmode devices LE address is same as BR/EDR address and is of in smp_br_distribute_keys()
1053 bt_addr_copy(&addr.a, &conn->br.dst); in smp_br_distribute_keys()
1056 keys = bt_keys_get_addr(conn->id, &addr); in smp_br_distribute_keys()
1063 if (smp->local_dist & BT_SMP_DIST_ID_KEY) { in smp_br_distribute_keys()
1068 smp->local_dist &= ~BT_SMP_DIST_ID_KEY; in smp_br_distribute_keys()
1078 memcpy(id_info->irk, bt_dev.irk[conn->id], 16); in smp_br_distribute_keys()
1090 bt_addr_le_copy(&id_addr_info->addr, &bt_dev.id_addr[conn->id]); in smp_br_distribute_keys()
1097 if (smp->local_dist & BT_SMP_DIST_SIGN) { in smp_br_distribute_keys()
1101 smp->local_dist &= ~BT_SMP_DIST_SIGN; in smp_br_distribute_keys()
1112 if (bt_rand(info->csrk, sizeof(info->csrk))) { in smp_br_distribute_keys()
1117 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in smp_br_distribute_keys()
1119 memcpy(keys->local_csrk.val, info->csrk, 16); in smp_br_distribute_keys()
1120 keys->local_csrk.cnt = 0U; in smp_br_distribute_keys()
1130 if (smp->chan.chan.conn->encrypt == 0x02) { in smp_br_pairing_allowed()
1135 smp->chan.chan.conn->encrypt == 0x01) { in smp_br_pairing_allowed()
1136 LOG_WRN("Allowing BR/EDR SMP with P-192 key"); in smp_br_pairing_allowed()
1145 struct bt_smp_pairing *req = (void *)buf->data; in smp_br_pairing_req()
1146 struct bt_conn *conn = smp->chan.chan.conn; in smp_br_pairing_req()
1153 req->io_capability, req->oob_flag, req->auth_req, in smp_br_pairing_req()
1154 req->max_key_size, req->init_key_dist, req->resp_key_dist); in smp_br_pairing_req()
1158 * either cross-transport key derivation/generation is not supported or in smp_br_pairing_req()
1161 * "Cross-transport Key Derivation/Generation not allowed" (0x0E)." in smp_br_pairing_req()
1173 if (req->max_key_size != max_key_size) { in smp_br_pairing_req()
1183 smp->enc_key_size = max_key_size; in smp_br_pairing_req()
1193 rsp->auth_req = BT_SMP_AUTH_CT2; in smp_br_pairing_req()
1194 rsp->io_capability = 0x00; in smp_br_pairing_req()
1195 rsp->oob_flag = 0x00; in smp_br_pairing_req()
1196 rsp->max_key_size = max_key_size; in smp_br_pairing_req()
1197 rsp->init_key_dist = (req->init_key_dist & BR_RECV_KEYS_SC); in smp_br_pairing_req()
1198 rsp->resp_key_dist = (req->resp_key_dist & BR_RECV_KEYS_SC); in smp_br_pairing_req()
1200 smp->local_dist = rsp->resp_key_dist; in smp_br_pairing_req()
1201 smp->remote_dist = rsp->init_key_dist; in smp_br_pairing_req()
1205 rsp->io_capability, rsp->oob_flag, rsp->auth_req, in smp_br_pairing_req()
1206 rsp->max_key_size, rsp->init_key_dist, rsp->resp_key_dist); in smp_br_pairing_req()
1210 atomic_set_bit(smp->flags, SMP_FLAG_PAIRING); in smp_br_pairing_req()
1213 if ((rsp->auth_req & BT_SMP_AUTH_CT2) && in smp_br_pairing_req()
1214 (req->auth_req & BT_SMP_AUTH_CT2)) { in smp_br_pairing_req()
1215 atomic_set_bit(smp->flags, SMP_FLAG_CT2); in smp_br_pairing_req()
1219 if ((smp->local_dist & BT_SMP_DIST_ENC_KEY) && in smp_br_pairing_req()
1220 (smp->remote_dist & BT_SMP_DIST_ENC_KEY)) { in smp_br_pairing_req()
1223 smp->local_dist &= ~BT_SMP_DIST_ENC_KEY; in smp_br_pairing_req()
1224 smp->remote_dist &= ~BT_SMP_DIST_ENC_KEY; in smp_br_pairing_req()
1229 if (smp->remote_dist & BT_SMP_DIST_ID_KEY) { in smp_br_pairing_req()
1230 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_IDENT_INFO); in smp_br_pairing_req()
1231 } else if (smp->remote_dist & BT_SMP_DIST_SIGN) { in smp_br_pairing_req()
1232 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SIGNING_INFO); in smp_br_pairing_req()
1236 if (!smp->local_dist && !smp->remote_dist) { in smp_br_pairing_req()
1245 struct bt_smp_pairing *rsp = (void *)buf->data; in smp_br_pairing_rsp()
1246 struct bt_conn *conn = smp->chan.chan.conn; in smp_br_pairing_rsp()
1251 rsp->io_capability, rsp->oob_flag, rsp->auth_req, in smp_br_pairing_rsp()
1252 rsp->max_key_size, rsp->init_key_dist, rsp->resp_key_dist); in smp_br_pairing_rsp()
1260 if (rsp->max_key_size != max_key_size) { in smp_br_pairing_rsp()
1264 smp->local_dist &= rsp->init_key_dist; in smp_br_pairing_rsp()
1265 smp->remote_dist &= rsp->resp_key_dist; in smp_br_pairing_rsp()
1267 smp->local_dist &= BR_SEND_KEYS_SC; in smp_br_pairing_rsp()
1268 smp->remote_dist &= BR_RECV_KEYS_SC; in smp_br_pairing_rsp()
1272 if (smp->remote_dist & BT_SMP_DIST_ID_KEY) { in smp_br_pairing_rsp()
1273 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_IDENT_INFO); in smp_br_pairing_rsp()
1274 } else if (smp->remote_dist & BT_SMP_DIST_SIGN) { in smp_br_pairing_rsp()
1275 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SIGNING_INFO); in smp_br_pairing_rsp()
1282 if (rsp->auth_req & BT_SMP_AUTH_CT2) { in smp_br_pairing_rsp()
1283 atomic_set_bit(smp->flags, SMP_FLAG_CT2); in smp_br_pairing_rsp()
1287 if ((smp->local_dist & BT_SMP_DIST_ENC_KEY) && in smp_br_pairing_rsp()
1288 (smp->remote_dist & BT_SMP_DIST_ENC_KEY)) { in smp_br_pairing_rsp()
1291 smp->local_dist &= ~BT_SMP_DIST_ENC_KEY; in smp_br_pairing_rsp()
1292 smp->remote_dist &= ~BT_SMP_DIST_ENC_KEY; in smp_br_pairing_rsp()
1295 if (smp->remote_dist) { in smp_br_pairing_rsp()
1302 if (!smp->local_dist && !smp->remote_dist) { in smp_br_pairing_rsp()
1311 struct bt_smp_pairing_fail *req = (void *)buf->data; in smp_br_pairing_failed()
1313 LOG_ERR("pairing failed (peer reason 0x%x)", req->reason); in smp_br_pairing_failed()
1315 smp_pairing_br_complete(smp, req->reason); in smp_br_pairing_failed()
1324 struct bt_smp_ident_info *req = (void *)buf->data; in smp_br_ident_info()
1325 struct bt_conn *conn = smp->chan.chan.conn; in smp_br_ident_info()
1331 /* TODO should we resolve LE address if matching RPA is connected? */ in smp_br_ident_info()
1334 * For dualmode devices LE address is same as BR/EDR address and is of in smp_br_ident_info()
1337 bt_addr_copy(&addr.a, &conn->br.dst); in smp_br_ident_info()
1340 keys = bt_keys_get_type(BT_KEYS_IRK, conn->id, &addr); in smp_br_ident_info()
1346 memcpy(keys->irk.val, req->irk, sizeof(keys->irk.val)); in smp_br_ident_info()
1348 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_IDENT_ADDR_INFO); in smp_br_ident_info()
1356 struct bt_conn *conn = smp->chan.chan.conn; in smp_br_ident_addr_info()
1357 struct bt_smp_ident_addr_info *req = (void *)buf->data; in smp_br_ident_addr_info()
1360 LOG_DBG("identity %s", bt_addr_le_str(&req->addr)); in smp_br_ident_addr_info()
1363 * For dual mode device identity address must be same as BR/EDR address in smp_br_ident_addr_info()
1365 * address we fail. in smp_br_ident_addr_info()
1368 bt_addr_copy(&addr.a, &conn->br.dst); in smp_br_ident_addr_info()
1371 if (!bt_addr_le_eq(&addr, &req->addr)) { in smp_br_ident_addr_info()
1375 smp->remote_dist &= ~BT_SMP_DIST_ID_KEY; in smp_br_ident_addr_info()
1377 if (smp->remote_dist & BT_SMP_DIST_SIGN) { in smp_br_ident_addr_info()
1378 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SIGNING_INFO); in smp_br_ident_addr_info()
1381 if (conn->role == BT_CONN_ROLE_CENTRAL && !smp->remote_dist) { in smp_br_ident_addr_info()
1386 if (!smp->local_dist && !smp->remote_dist) { in smp_br_ident_addr_info()
1396 struct bt_smp_signing_info *req = (void *)buf->data; in smp_br_signing_info()
1397 struct bt_conn *conn = smp->chan.chan.conn; in smp_br_signing_info()
1404 * For dualmode devices LE address is same as BR/EDR address and is of in smp_br_signing_info()
1407 bt_addr_copy(&addr.a, &conn->br.dst); in smp_br_signing_info()
1410 keys = bt_keys_get_type(BT_KEYS_REMOTE_CSRK, conn->id, &addr); in smp_br_signing_info()
1416 memcpy(keys->remote_csrk.val, req->csrk, sizeof(keys->remote_csrk.val)); in smp_br_signing_info()
1418 smp->remote_dist &= ~BT_SMP_DIST_SIGN; in smp_br_signing_info()
1420 if (conn->role == BT_CONN_ROLE_CENTRAL && !smp->remote_dist) { in smp_br_signing_info()
1425 if (!smp->local_dist && !smp->remote_dist) { in smp_br_signing_info()
1442 { }, /* No op-code defined for 0x00 */
1468 return -ENOBUFS; in smp_br_error()
1472 rsp->reason = reason; in smp_br_error()
1478 if (bt_l2cap_br_send_cb(smp->chan.chan.conn, BT_L2CAP_CID_BR_SMP, buf, in smp_br_error()
1492 if (buf->len < sizeof(*hdr)) { in bt_smp_br_recv()
1498 LOG_DBG("Received SMP code 0x%02x len %u", hdr->code, buf->len); in bt_smp_br_recv()
1505 if (atomic_test_bit(smp->flags, SMP_FLAG_TIMEOUT)) { in bt_smp_br_recv()
1506 LOG_WRN("SMP command (code 0x%02x) received after timeout", hdr->code); in bt_smp_br_recv()
1510 if (hdr->code >= ARRAY_SIZE(br_handlers) || in bt_smp_br_recv()
1511 !br_handlers[hdr->code].func) { in bt_smp_br_recv()
1512 LOG_WRN("Unhandled SMP code 0x%02x", hdr->code); in bt_smp_br_recv()
1517 if (!atomic_test_and_clear_bit(smp->allowed_cmds, hdr->code)) { in bt_smp_br_recv()
1518 LOG_WRN("Unexpected SMP code 0x%02x", hdr->code); in bt_smp_br_recv()
1523 if (buf->len != br_handlers[hdr->code].expect_len) { in bt_smp_br_recv()
1524 LOG_ERR("Invalid len %u for code 0x%02x", buf->len, hdr->code); in bt_smp_br_recv()
1529 err = br_handlers[hdr->code].func(smp, buf); in bt_smp_br_recv()
1558 return -ENOTSUP; in bt_smp_br_accept()
1561 LOG_DBG("conn %p handle %u", conn, conn->handle); in bt_smp_br_accept()
1566 if (smp->chan.chan.conn) { in bt_smp_br_accept()
1570 smp->chan.chan.ops = &ops; in bt_smp_br_accept()
1572 *chan = &smp->chan.chan; in bt_smp_br_accept()
1574 k_work_init_delayable(&smp->work, smp_br_timeout); in bt_smp_br_accept()
1582 return -ENOMEM; in bt_smp_br_accept()
1608 return -ENOTSUP; in bt_smp_br_send_pairing_req()
1613 return -ENOTCONN; in bt_smp_br_send_pairing_req()
1617 if (atomic_test_bit(smp->flags, SMP_FLAG_TIMEOUT)) { in bt_smp_br_send_pairing_req()
1618 return -EIO; in bt_smp_br_send_pairing_req()
1622 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in bt_smp_br_send_pairing_req()
1623 return -EBUSY; in bt_smp_br_send_pairing_req()
1632 if (!atomic_test_bit(smp->flags, SMP_FLAG_BR_CONNECTED)) { in bt_smp_br_send_pairing_req()
1633 atomic_set_bit(smp->flags, SMP_FLAG_BR_PAIR); in bt_smp_br_send_pairing_req()
1640 return -EIO; in bt_smp_br_send_pairing_req()
1644 smp->enc_key_size = max_key_size; in bt_smp_br_send_pairing_req()
1648 return -ENOBUFS; in bt_smp_br_send_pairing_req()
1660 req->auth_req = BT_SMP_AUTH_CT2; in bt_smp_br_send_pairing_req()
1661 req->io_capability = 0x00; in bt_smp_br_send_pairing_req()
1662 req->oob_flag = 0x00; in bt_smp_br_send_pairing_req()
1663 req->max_key_size = max_key_size; in bt_smp_br_send_pairing_req()
1664 req->init_key_dist = BR_SEND_KEYS_SC; in bt_smp_br_send_pairing_req()
1665 req->resp_key_dist = BR_RECV_KEYS_SC; in bt_smp_br_send_pairing_req()
1669 smp->local_dist = BR_SEND_KEYS_SC; in bt_smp_br_send_pairing_req()
1670 smp->remote_dist = BR_RECV_KEYS_SC; in bt_smp_br_send_pairing_req()
1672 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RSP); in bt_smp_br_send_pairing_req()
1674 atomic_set_bit(smp->flags, SMP_FLAG_PAIRING); in bt_smp_br_send_pairing_req()
1682 struct bt_conn *conn = smp->chan.chan.conn; in smp_reset()
1687 atomic_set(smp->flags, 0); in smp_reset()
1693 (void)k_work_cancel_delayable(&smp->work); in smp_reset()
1695 smp->method = JUST_WORKS; in smp_reset()
1696 atomic_set(smp->allowed_cmds, 0); in smp_reset()
1699 conn->role == BT_HCI_ROLE_CENTRAL) { in smp_reset()
1700 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SECURITY_REQUEST); in smp_reset()
1705 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_REQ); in smp_reset()
1734 struct bt_conn *conn = smp->chan.chan.conn; in smp_pairing_complete()
1738 if (conn->le.keys == NULL) { in smp_pairing_complete()
1742 LOG_WRN("The in-progress pairing has been deleted!"); in smp_pairing_complete()
1752 if (atomic_test_bit(smp->flags, SMP_FLAG_DERIVE_LK) && in smp_pairing_complete()
1753 (!atomic_test_bit(smp->flags, SMP_FLAG_SC_DEBUG_KEY) || in smp_pairing_complete()
1758 bool bond_flag = atomic_test_bit(smp->flags, SMP_FLAG_BOND); in smp_pairing_complete()
1762 bt_keys_show_sniffer_info(conn->le.keys, NULL); in smp_pairing_complete()
1765 if (bond_flag && conn->le.keys) { in smp_pairing_complete()
1766 bt_keys_store(conn->le.keys); in smp_pairing_complete()
1771 if (listener->pairing_complete) { in smp_pairing_complete()
1772 listener->pairing_complete(conn, bond_flag); in smp_pairing_complete()
1782 if (conn->le.keys && in smp_pairing_complete()
1783 (!conn->le.keys->enc_size || in smp_pairing_complete()
1784 atomic_test_bit(smp->flags, SMP_FLAG_KEYS_DISTR))) { in smp_pairing_complete()
1785 bt_keys_clear(conn->le.keys); in smp_pairing_complete()
1786 conn->le.keys = NULL; in smp_pairing_complete()
1789 if (!atomic_test_bit(smp->flags, SMP_FLAG_KEYS_DISTR)) { in smp_pairing_complete()
1798 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in smp_pairing_complete()
1804 if (listener->pairing_failed) { in smp_pairing_complete()
1805 listener->pairing_failed(conn, security_err); in smp_pairing_complete()
1813 if (conn->state == BT_CONN_CONNECTED && conn->sec_level != conn->required_sec_level) { in smp_pairing_complete()
1830 atomic_set_bit(smp->flags, SMP_FLAG_TIMEOUT); in smp_timeout()
1838 int err = bt_l2cap_send_pdu(&smp->chan, buf, cb, NULL); in smp_send()
1841 if (err == -ENOBUFS) { in smp_send()
1849 k_work_reschedule(&smp->work, SMP_TIMEOUT); in smp_send()
1859 * key to distribute is acknowledged at link-layer. in smp_error()
1861 remote_already_completed = (atomic_test_bit(smp->flags, SMP_FLAG_KEYS_DISTR) && in smp_error()
1862 !smp->local_dist && !smp->remote_dist); in smp_error()
1864 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING) || in smp_error()
1865 atomic_test_bit(smp->flags, SMP_FLAG_ENC_PENDING) || in smp_error()
1866 atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ)) { in smp_error()
1875 * on the central's identity address information, but that was the last key to in smp_error()
1878 * peripheral link-layer confirmed the reception of the PDU with the last key. in smp_error()
1880 bt_conn_disconnect(smp->chan.chan.conn, BT_HCI_ERR_AUTH_FAIL); in smp_error()
1886 return -ENOBUFS; in smp_error()
1890 rsp->reason = reason; in smp_error()
1893 if (bt_l2cap_send_pdu(&smp->chan, buf, NULL, NULL)) { in smp_error()
1911 memcpy(req->val, smp->prnd, sizeof(req->val)); in smp_send_pairing_random()
1935 p1[0] = ia->type; in smp_c1()
1936 p1[1] = ra->type; in smp_c1()
1953 memcpy(p2, ra->a.val, 6); in smp_c1()
1954 memcpy(p2 + 6, ia->a.val, 6); in smp_c1()
1971 switch (smp->method) { in smp_send_pairing_confirm()
1985 r = (smp->passkey >> smp->passkey_round) & 0x01; in smp_send_pairing_confirm()
1989 LOG_ERR("Unknown pairing method (%u)", smp->method); in smp_send_pairing_confirm()
2000 if (bt_crypto_f4(sc_public_key, smp->pkey, smp->prnd, r, req->val)) { in smp_send_pairing_confirm()
2007 atomic_clear_bit(smp->flags, SMP_FLAG_CFM_DELAYED); in smp_send_pairing_confirm()
2022 struct bt_conn *conn = smp->chan.chan.conn; in legacy_distribute_keys()
2023 struct bt_keys *keys = conn->le.keys; in legacy_distribute_keys()
2025 if (smp->local_dist & BT_SMP_DIST_ENC_KEY) { in legacy_distribute_keys()
2051 memcpy(info->ltk, rand.key, keys->enc_size); in legacy_distribute_keys()
2052 if (keys->enc_size < sizeof(info->ltk)) { in legacy_distribute_keys()
2053 (void)memset(info->ltk + keys->enc_size, 0, in legacy_distribute_keys()
2054 sizeof(info->ltk) - keys->enc_size); in legacy_distribute_keys()
2067 memcpy(ident->rand, rand.rand, sizeof(ident->rand)); in legacy_distribute_keys()
2068 memcpy(ident->ediv, rand.ediv, sizeof(ident->ediv)); in legacy_distribute_keys()
2072 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in legacy_distribute_keys()
2075 memcpy(keys->periph_ltk.val, rand.key, in legacy_distribute_keys()
2076 sizeof(keys->periph_ltk.val)); in legacy_distribute_keys()
2077 memcpy(keys->periph_ltk.rand, rand.rand, in legacy_distribute_keys()
2078 sizeof(keys->periph_ltk.rand)); in legacy_distribute_keys()
2079 memcpy(keys->periph_ltk.ediv, rand.ediv, in legacy_distribute_keys()
2080 sizeof(keys->periph_ltk.ediv)); in legacy_distribute_keys()
2088 struct bt_conn *conn = smp->chan.chan.conn; in bt_smp_distribute_keys()
2089 struct bt_keys *keys = conn->le.keys; in bt_smp_distribute_keys()
2092 LOG_ERR("No keys space for %s", bt_addr_le_str(&conn->le.dst)); in bt_smp_distribute_keys()
2098 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in bt_smp_distribute_keys()
2104 if (smp->local_dist & BT_SMP_DIST_ID_KEY) { in bt_smp_distribute_keys()
2117 memcpy(id_info->irk, bt_dev.irk[conn->id], 16); in bt_smp_distribute_keys()
2129 bt_addr_le_copy(&id_addr_info->addr, &bt_dev.id_addr[conn->id]); in bt_smp_distribute_keys()
2136 if (smp->local_dist & BT_SMP_DIST_SIGN) { in bt_smp_distribute_keys()
2149 if (bt_rand(info->csrk, sizeof(info->csrk))) { in bt_smp_distribute_keys()
2153 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in bt_smp_distribute_keys()
2155 memcpy(keys->local_csrk.val, info->csrk, 16); in bt_smp_distribute_keys()
2156 keys->local_csrk.cnt = 0U; in bt_smp_distribute_keys()
2178 memcpy(rsp, smp->prsp + 1, sizeof(*rsp)); in send_pairing_rsp()
2190 struct bt_conn *conn = smp->chan.chan.conn; in smp_pairing_accept_query()
2192 if (smp_auth_cb && smp_auth_cb->pairing_accept) { in smp_pairing_accept_query()
2194 .io_capability = pairing->io_capability, in smp_pairing_accept_query()
2195 .oob_data_flag = pairing->oob_flag, in smp_pairing_accept_query()
2196 .auth_req = pairing->auth_req, in smp_pairing_accept_query()
2197 .max_enc_key_size = pairing->max_key_size, in smp_pairing_accept_query()
2198 .init_key_dist = pairing->init_key_dist, in smp_pairing_accept_query()
2199 .resp_key_dist = pairing->resp_key_dist in smp_pairing_accept_query()
2202 return smp_err_get(smp_auth_cb->pairing_accept(conn, &feat)); in smp_pairing_accept_query()
2212 /* The most significant 64-bits of r1 are discarded to generate in smp_s1()
2213 * r1' and the most significant 64-bits of r2 are discarded to in smp_s1()
2216 * the 128-bit input parameter plaintextData to security function e: in smp_s1()
2236 req = (struct bt_smp_pairing *)&smp->preq[1]; in legacy_get_pair_method()
2237 rsp = (struct bt_smp_pairing *)&smp->prsp[1]; in legacy_get_pair_method()
2240 if ((req->oob_flag & rsp->oob_flag) & BT_SMP_OOB_DATA_MASK) { in legacy_get_pair_method()
2245 if (!((req->auth_req | rsp->auth_req) & BT_SMP_AUTH_MITM)) { in legacy_get_pair_method()
2255 if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in legacy_get_pair_method()
2267 struct bt_conn *conn = smp->chan.chan.conn; in legacy_request_tk()
2277 keys = bt_keys_find_addr(conn->id, &conn->le.dst); in legacy_request_tk()
2278 if (keys && (keys->flags & BT_KEYS_AUTHENTICATED) && in legacy_request_tk()
2279 smp->method == JUST_WORKS) { in legacy_request_tk()
2284 switch (smp->method) { in legacy_request_tk()
2286 if (smp_auth_cb && smp_auth_cb->oob_data_request) { in legacy_request_tk()
2291 atomic_set_bit(smp->flags, SMP_FLAG_USER); in legacy_request_tk()
2292 smp_auth_cb->oob_data_request(smp->chan.chan.conn, &info); in legacy_request_tk()
2314 if (smp_auth_cb && smp_auth_cb->passkey_display) { in legacy_request_tk()
2315 atomic_set_bit(smp->flags, SMP_FLAG_DISPLAY); in legacy_request_tk()
2316 smp_auth_cb->passkey_display(conn, passkey); in legacy_request_tk()
2319 sys_put_le32(passkey, smp->tk); in legacy_request_tk()
2323 atomic_set_bit(smp->flags, SMP_FLAG_USER); in legacy_request_tk()
2324 smp_auth_cb->passkey_entry(conn); in legacy_request_tk()
2329 LOG_ERR("Unknown pairing method (%u)", smp->method); in legacy_request_tk()
2338 struct bt_conn *conn = smp->chan.chan.conn; in legacy_send_pairing_confirm()
2349 if (smp_c1(smp->tk, smp->prnd, smp->preq, smp->prsp, in legacy_send_pairing_confirm()
2350 &conn->le.init_addr, &conn->le.resp_addr, req->val)) { in legacy_send_pairing_confirm()
2357 atomic_clear_bit(smp->flags, SMP_FLAG_CFM_DELAYED); in legacy_send_pairing_confirm()
2376 if ((DISPLAY_FIXED(smp) || smp->method == JUST_WORKS) && in legacy_pairing_req()
2377 !atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ) && in legacy_pairing_req()
2378 smp_auth_cb && smp_auth_cb->pairing_confirm) { in legacy_pairing_req()
2379 atomic_set_bit(smp->flags, SMP_FLAG_USER); in legacy_pairing_req()
2380 smp_auth_cb->pairing_confirm(smp->chan.chan.conn); in legacy_pairing_req()
2384 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM); in legacy_pairing_req()
2385 atomic_set_bit(smp->allowed_cmds, BT_SMP_KEYPRESS_NOTIFICATION); in legacy_pairing_req()
2392 struct bt_conn *conn = smp->chan.chan.conn; in legacy_pairing_random()
2399 err = smp_c1(smp->tk, smp->rrnd, smp->preq, smp->prsp, in legacy_pairing_random()
2400 &conn->le.init_addr, &conn->le.resp_addr, tmp); in legacy_pairing_random()
2405 LOG_DBG("pcnf %s", bt_hex(smp->pcnf, 16)); in legacy_pairing_random()
2408 if (memcmp(smp->pcnf, tmp, sizeof(smp->pcnf))) { in legacy_pairing_random()
2413 conn->role == BT_HCI_ROLE_CENTRAL) { in legacy_pairing_random()
2417 err = smp_s1(smp->tk, smp->rrnd, smp->prnd, tmp); in legacy_pairing_random()
2431 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in legacy_pairing_random()
2434 if (smp->remote_dist & BT_SMP_DIST_ENC_KEY) { in legacy_pairing_random()
2435 atomic_set_bit(smp->allowed_cmds, in legacy_pairing_random()
2437 } else if (smp->remote_dist & BT_SMP_DIST_ID_KEY) { in legacy_pairing_random()
2438 atomic_set_bit(smp->allowed_cmds, in legacy_pairing_random()
2440 } else if (smp->remote_dist & BT_SMP_DIST_SIGN) { in legacy_pairing_random()
2441 atomic_set_bit(smp->allowed_cmds, in legacy_pairing_random()
2450 err = smp_s1(smp->tk, smp->prnd, smp->rrnd, tmp); in legacy_pairing_random()
2456 memcpy(smp->tk, tmp, sizeof(smp->tk)); in legacy_pairing_random()
2457 LOG_DBG("generated STK %s", bt_hex(smp->tk, 16)); in legacy_pairing_random()
2459 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in legacy_pairing_random()
2472 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in legacy_pairing_confirm()
2473 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM); in legacy_pairing_confirm()
2478 if (!atomic_test_bit(smp->flags, SMP_FLAG_USER)) { in legacy_pairing_confirm()
2479 atomic_set_bit(smp->allowed_cmds, in legacy_pairing_confirm()
2484 atomic_set_bit(smp->flags, SMP_FLAG_CFM_DELAYED); in legacy_pairing_confirm()
2492 if (!atomic_test_and_clear_bit(smp->flags, SMP_FLAG_CFM_DELAYED)) { in legacy_user_tk_entry()
2503 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in legacy_user_tk_entry()
2504 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM); in legacy_user_tk_entry()
2509 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM); in legacy_user_tk_entry()
2516 memcpy(smp->tk, &passkey, sizeof(passkey)); in legacy_passkey_entry()
2525 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in smp_encrypt_info()
2526 struct bt_smp_encrypt_info *req = (void *)buf->data; in smp_encrypt_info()
2527 struct bt_conn *conn = smp->chan.chan.conn; in smp_encrypt_info()
2530 keys = bt_keys_get_type(BT_KEYS_LTK, conn->id, &conn->le.dst); in smp_encrypt_info()
2532 LOG_ERR("Unable to get keys for %s", bt_addr_le_str(&conn->le.dst)); in smp_encrypt_info()
2536 memcpy(keys->ltk.val, req->ltk, 16); in smp_encrypt_info()
2539 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_CENTRAL_IDENT); in smp_encrypt_info()
2546 struct bt_conn *conn = smp->chan.chan.conn; in smp_central_ident()
2551 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in smp_central_ident()
2552 struct bt_smp_central_ident *req = (void *)buf->data; in smp_central_ident()
2555 keys = bt_keys_get_type(BT_KEYS_LTK, conn->id, &conn->le.dst); in smp_central_ident()
2557 LOG_ERR("Unable to get keys for %s", bt_addr_le_str(&conn->le.dst)); in smp_central_ident()
2561 memcpy(keys->ltk.ediv, req->ediv, sizeof(keys->ltk.ediv)); in smp_central_ident()
2562 memcpy(keys->ltk.rand, req->rand, sizeof(req->rand)); in smp_central_ident()
2565 smp->remote_dist &= ~BT_SMP_DIST_ENC_KEY; in smp_central_ident()
2567 if (smp->remote_dist & BT_SMP_DIST_ID_KEY) { in smp_central_ident()
2568 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_IDENT_INFO); in smp_central_ident()
2569 } else if (smp->remote_dist & BT_SMP_DIST_SIGN) { in smp_central_ident()
2570 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SIGNING_INFO); in smp_central_ident()
2574 conn->role == BT_HCI_ROLE_CENTRAL && !smp->remote_dist) { in smp_central_ident()
2582 if (!smp->local_dist && !smp->remote_dist) { in smp_central_ident()
2603 if ((DISPLAY_FIXED(smp) || smp->method == JUST_WORKS) && in legacy_pairing_rsp()
2604 atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ) && in legacy_pairing_rsp()
2605 smp_auth_cb && smp_auth_cb->pairing_confirm) { in legacy_pairing_rsp()
2606 atomic_set_bit(smp->flags, SMP_FLAG_USER); in legacy_pairing_rsp()
2607 smp_auth_cb->pairing_confirm(smp->chan.chan.conn); in legacy_pairing_rsp()
2611 if (!atomic_test_bit(smp->flags, SMP_FLAG_USER)) { in legacy_pairing_rsp()
2612 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM); in legacy_pairing_rsp()
2613 atomic_set_bit(smp->allowed_cmds, BT_SMP_KEYPRESS_NOTIFICATION); in legacy_pairing_rsp()
2617 atomic_set_bit(smp->flags, SMP_FLAG_CFM_DELAYED); in legacy_pairing_rsp()
2642 if (bt_rand(smp->prnd, 16)) { in smp_init()
2646 LOG_DBG("prnd %s", bt_hex(smp->prnd, 16)); in smp_init()
2648 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_FAIL); in smp_init()
2679 struct bt_conn *conn = smp->chan.chan.conn; in get_auth()
2689 (conn->required_sec_level < BT_SECURITY_L3))) { in get_auth()
2716 bt_security_t sec = smp->chan.chan.conn->required_sec_level; in remote_sec_level_reachable()
2735 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in remote_sec_level_reachable()
2740 if (smp->method == JUST_WORKS) { in remote_sec_level_reachable()
2754 switch (smp->chan.chan.conn->required_sec_level) { in sec_level_reachable()
2760 (smp_auth_cb && smp_auth_cb->oob_data_request); in sec_level_reachable()
2763 (smp_auth_cb && smp_auth_cb->oob_data_request)) && sc_supported; in sec_level_reachable()
2797 atomic_test_bit(smp->flags, SMP_FLAG_PAIRING) && in bt_smp_request_ltk()
2798 atomic_test_bit(smp->flags, SMP_FLAG_ENC_PENDING)) { in bt_smp_request_ltk()
2805 memcpy(ltk, smp->tk, enc_size); in bt_smp_request_ltk()
2808 BT_SMP_MAX_ENC_KEY_SIZE - enc_size); in bt_smp_request_ltk()
2811 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in bt_smp_request_ltk()
2815 if (!conn->le.keys) { in bt_smp_request_ltk()
2816 conn->le.keys = bt_keys_find(BT_KEYS_LTK_P256, conn->id, in bt_smp_request_ltk()
2817 &conn->le.dst); in bt_smp_request_ltk()
2818 if (!conn->le.keys) { in bt_smp_request_ltk()
2819 conn->le.keys = bt_keys_find(BT_KEYS_PERIPH_LTK, in bt_smp_request_ltk()
2820 conn->id, &conn->le.dst); in bt_smp_request_ltk()
2825 conn->le.keys && (conn->le.keys->keys & BT_KEYS_LTK_P256)) { in bt_smp_request_ltk()
2826 enc_size = conn->le.keys->enc_size; in bt_smp_request_ltk()
2828 memcpy(ltk, conn->le.keys->ltk.val, enc_size); in bt_smp_request_ltk()
2831 BT_SMP_MAX_ENC_KEY_SIZE - enc_size); in bt_smp_request_ltk()
2834 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in bt_smp_request_ltk()
2839 if (conn->le.keys && (conn->le.keys->keys & BT_KEYS_PERIPH_LTK) && in bt_smp_request_ltk()
2840 !memcmp(conn->le.keys->periph_ltk.rand, &rand, 8) && in bt_smp_request_ltk()
2841 !memcmp(conn->le.keys->periph_ltk.ediv, &ediv, 2)) { in bt_smp_request_ltk()
2842 enc_size = conn->le.keys->enc_size; in bt_smp_request_ltk()
2844 memcpy(ltk, conn->le.keys->periph_ltk.val, enc_size); in bt_smp_request_ltk()
2847 BT_SMP_MAX_ENC_KEY_SIZE - enc_size); in bt_smp_request_ltk()
2850 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in bt_smp_request_ltk()
2855 if (atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ)) { in bt_smp_request_ltk()
2878 return -ENOTCONN; in smp_send_security_req()
2882 if (atomic_test_bit(smp->flags, SMP_FLAG_TIMEOUT)) { in smp_send_security_req()
2883 return -EIO; in smp_send_security_req()
2887 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in smp_send_security_req()
2888 return -EBUSY; in smp_send_security_req()
2891 if (atomic_test_bit(smp->flags, SMP_FLAG_ENC_PENDING)) { in smp_send_security_req()
2892 return -EBUSY; in smp_send_security_req()
2897 return -EINVAL; in smp_send_security_req()
2900 if (!conn->le.keys) { in smp_send_security_req()
2901 conn->le.keys = bt_keys_get_addr(conn->id, &conn->le.dst); in smp_send_security_req()
2902 if (!conn->le.keys) { in smp_send_security_req()
2903 return -ENOMEM; in smp_send_security_req()
2908 return -ENOBUFS; in smp_send_security_req()
2914 return -ENOBUFS; in smp_send_security_req()
2918 req->auth_req = get_auth(smp, BT_SMP_AUTH_DEFAULT); in smp_send_security_req()
2921 err = bt_l2cap_send_pdu(&smp->chan, req_buf, NULL, NULL); in smp_send_security_req()
2927 atomic_set_bit(smp->flags, SMP_FLAG_SEC_REQ); in smp_send_security_req()
2928 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_REQ); in smp_send_security_req()
2935 struct bt_conn *conn = smp->chan.chan.conn; in smp_pairing_req()
2938 struct bt_smp_pairing *req = (void *)buf->data; in smp_pairing_req()
2944 req->io_capability, req->oob_flag, req->auth_req, in smp_pairing_req()
2945 req->max_key_size, req->init_key_dist, req->resp_key_dist); in smp_pairing_req()
2947 if ((req->max_key_size > BT_SMP_MAX_ENC_KEY_SIZE) || in smp_pairing_req()
2948 (req->max_key_size < BT_SMP_MIN_ENC_KEY_SIZE)) { in smp_pairing_req()
2952 if (!conn->le.keys) { in smp_pairing_req()
2953 conn->le.keys = bt_keys_get_addr(conn->id, &conn->le.dst); in smp_pairing_req()
2954 if (!conn->le.keys) { in smp_pairing_req()
2955 LOG_DBG("Unable to get keys for %s", bt_addr_le_str(&conn->le.dst)); in smp_pairing_req()
2963 if (!atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ)) { in smp_pairing_req()
2972 smp->preq[0] = BT_SMP_CMD_PAIRING_REQ; in smp_pairing_req()
2973 memcpy(smp->preq + 1, req, sizeof(*req)); in smp_pairing_req()
2976 smp->prsp[0] = BT_SMP_CMD_PAIRING_RSP; in smp_pairing_req()
2977 rsp = (struct bt_smp_pairing *)&smp->prsp[1]; in smp_pairing_req()
2979 rsp->auth_req = get_auth(smp, req->auth_req); in smp_pairing_req()
2980 rsp->io_capability = get_io_capa(smp); in smp_pairing_req()
2981 rsp->max_key_size = BT_SMP_MAX_ENC_KEY_SIZE; in smp_pairing_req()
2982 rsp->init_key_dist = (req->init_key_dist & RECV_KEYS); in smp_pairing_req()
2983 rsp->resp_key_dist = (req->resp_key_dist & SEND_KEYS); in smp_pairing_req()
2985 if ((rsp->auth_req & BT_SMP_AUTH_SC) && in smp_pairing_req()
2986 (req->auth_req & BT_SMP_AUTH_SC)) { in smp_pairing_req()
2987 atomic_set_bit(smp->flags, SMP_FLAG_SC); in smp_pairing_req()
2989 rsp->init_key_dist &= RECV_KEYS_SC; in smp_pairing_req()
2990 rsp->resp_key_dist &= SEND_KEYS_SC; in smp_pairing_req()
2993 if (atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in smp_pairing_req()
2994 rsp->oob_flag = sc_oobd_present ? BT_SMP_OOB_PRESENT : in smp_pairing_req()
2997 rsp->oob_flag = legacy_oobd_present ? BT_SMP_OOB_PRESENT : in smp_pairing_req()
3001 if ((rsp->auth_req & BT_SMP_AUTH_CT2) && in smp_pairing_req()
3002 (req->auth_req & BT_SMP_AUTH_CT2)) { in smp_pairing_req()
3003 atomic_set_bit(smp->flags, SMP_FLAG_CT2); in smp_pairing_req()
3006 if ((rsp->auth_req & BT_SMP_AUTH_BONDING) && in smp_pairing_req()
3007 (req->auth_req & BT_SMP_AUTH_BONDING)) { in smp_pairing_req()
3008 atomic_set_bit(smp->flags, SMP_FLAG_BOND); in smp_pairing_req()
3014 rsp->init_key_dist = 0; in smp_pairing_req()
3015 rsp->resp_key_dist = 0; in smp_pairing_req()
3018 smp->local_dist = rsp->resp_key_dist; in smp_pairing_req()
3019 smp->remote_dist = rsp->init_key_dist; in smp_pairing_req()
3021 atomic_set_bit(smp->flags, SMP_FLAG_PAIRING); in smp_pairing_req()
3023 smp->method = get_pair_method(smp, req->io_capability); in smp_pairing_req()
3025 if (!update_keys_check(smp, conn->le.keys)) { in smp_pairing_req()
3034 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in smp_pairing_req()
3057 (DISPLAY_FIXED(smp) || smp->method == JUST_WORKS) && in smp_pairing_req()
3058 !atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ) && in smp_pairing_req()
3059 smp_auth_cb && smp_auth_cb->pairing_confirm) { in smp_pairing_req()
3060 atomic_set_bit(smp->flags, SMP_FLAG_USER); in smp_pairing_req()
3061 smp_auth_cb->pairing_confirm(conn); in smp_pairing_req()
3065 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PUBLIC_KEY); in smp_pairing_req()
3069 rsp->io_capability, rsp->oob_flag, rsp->auth_req, in smp_pairing_req()
3070 rsp->max_key_size, rsp->init_key_dist, rsp->resp_key_dist); in smp_pairing_req()
3093 memcpy(req->x, sc_public_key, sizeof(req->x)); in sc_send_public_key()
3094 memcpy(req->y, &sc_public_key[32], sizeof(req->y)); in sc_send_public_key()
3099 atomic_set_bit(smp->flags, SMP_FLAG_SC_DEBUG_KEY); in sc_send_public_key()
3116 return -ENOTCONN; in smp_send_pairing_req()
3120 if (atomic_test_bit(smp->flags, SMP_FLAG_TIMEOUT)) { in smp_send_pairing_req()
3121 return -EIO; in smp_send_pairing_req()
3127 if (atomic_test_bit(smp->flags, SMP_FLAG_KEYS_DISTR)) { in smp_send_pairing_req()
3132 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in smp_send_pairing_req()
3133 return -EBUSY; in smp_send_pairing_req()
3137 if (atomic_test_bit(smp->flags, SMP_FLAG_ENC_PENDING)) { in smp_send_pairing_req()
3138 return -EBUSY; in smp_send_pairing_req()
3143 return -EINVAL; in smp_send_pairing_req()
3146 if (!conn->le.keys) { in smp_send_pairing_req()
3147 conn->le.keys = bt_keys_get_addr(conn->id, &conn->le.dst); in smp_send_pairing_req()
3148 if (!conn->le.keys) { in smp_send_pairing_req()
3149 return -ENOMEM; in smp_send_pairing_req()
3154 return -ENOBUFS; in smp_send_pairing_req()
3159 return -ENOBUFS; in smp_send_pairing_req()
3164 req->auth_req = get_auth(smp, BT_SMP_AUTH_DEFAULT); in smp_send_pairing_req()
3165 req->io_capability = get_io_capa(smp); in smp_send_pairing_req()
3171 req->oob_flag = (legacy_oobd_present || sc_oobd_present) ? in smp_send_pairing_req()
3174 req->max_key_size = BT_SMP_MAX_ENC_KEY_SIZE; in smp_send_pairing_req()
3176 if (req->auth_req & BT_SMP_AUTH_BONDING) { in smp_send_pairing_req()
3177 req->init_key_dist = SEND_KEYS; in smp_send_pairing_req()
3178 req->resp_key_dist = RECV_KEYS; in smp_send_pairing_req()
3180 req->init_key_dist = 0; in smp_send_pairing_req()
3181 req->resp_key_dist = 0; in smp_send_pairing_req()
3184 smp->local_dist = req->init_key_dist; in smp_send_pairing_req()
3185 smp->remote_dist = req->resp_key_dist; in smp_send_pairing_req()
3188 smp->preq[0] = BT_SMP_CMD_PAIRING_REQ; in smp_send_pairing_req()
3189 memcpy(smp->preq + 1, req, sizeof(*req)); in smp_send_pairing_req()
3193 req->io_capability, req->oob_flag, req->auth_req, in smp_send_pairing_req()
3194 req->max_key_size, req->init_key_dist, req->resp_key_dist); in smp_send_pairing_req()
3198 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RSP); in smp_send_pairing_req()
3199 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SECURITY_REQUEST); in smp_send_pairing_req()
3200 atomic_set_bit(smp->flags, SMP_FLAG_PAIRING); in smp_send_pairing_req()
3207 struct bt_conn *conn = smp->chan.chan.conn; in smp_pairing_rsp()
3208 struct bt_smp_pairing *rsp = (void *)buf->data; in smp_pairing_rsp()
3209 struct bt_smp_pairing *req = (struct bt_smp_pairing *)&smp->preq[1]; in smp_pairing_rsp()
3214 rsp->io_capability, rsp->oob_flag, rsp->auth_req, in smp_pairing_rsp()
3215 rsp->max_key_size, rsp->init_key_dist, rsp->resp_key_dist); in smp_pairing_rsp()
3217 if ((rsp->max_key_size > BT_SMP_MAX_ENC_KEY_SIZE) || in smp_pairing_rsp()
3218 (rsp->max_key_size < BT_SMP_MIN_ENC_KEY_SIZE)) { in smp_pairing_rsp()
3222 smp->local_dist &= rsp->init_key_dist; in smp_pairing_rsp()
3223 smp->remote_dist &= rsp->resp_key_dist; in smp_pairing_rsp()
3226 smp->prsp[0] = BT_SMP_CMD_PAIRING_RSP; in smp_pairing_rsp()
3227 memcpy(smp->prsp + 1, rsp, sizeof(*rsp)); in smp_pairing_rsp()
3229 if ((rsp->auth_req & BT_SMP_AUTH_SC) && in smp_pairing_rsp()
3230 (req->auth_req & BT_SMP_AUTH_SC)) { in smp_pairing_rsp()
3231 atomic_set_bit(smp->flags, SMP_FLAG_SC); in smp_pairing_rsp()
3234 if ((rsp->auth_req & BT_SMP_AUTH_CT2) && in smp_pairing_rsp()
3235 (req->auth_req & BT_SMP_AUTH_CT2)) { in smp_pairing_rsp()
3236 atomic_set_bit(smp->flags, SMP_FLAG_CT2); in smp_pairing_rsp()
3239 if ((rsp->auth_req & BT_SMP_AUTH_BONDING) && in smp_pairing_rsp()
3240 (req->auth_req & BT_SMP_AUTH_BONDING)) { in smp_pairing_rsp()
3241 atomic_set_bit(smp->flags, SMP_FLAG_BOND); in smp_pairing_rsp()
3247 smp->local_dist = 0; in smp_pairing_rsp()
3248 smp->remote_dist = 0; in smp_pairing_rsp()
3251 smp->method = get_pair_method(smp, rsp->io_capability); in smp_pairing_rsp()
3253 if (!update_keys_check(smp, conn->le.keys)) { in smp_pairing_rsp()
3272 !atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in smp_pairing_rsp()
3289 smp->local_dist &= SEND_KEYS_SC; in smp_pairing_rsp()
3290 smp->remote_dist &= RECV_KEYS_SC; in smp_pairing_rsp()
3300 (DISPLAY_FIXED(smp) || smp->method == JUST_WORKS) && in smp_pairing_rsp()
3301 atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ) && in smp_pairing_rsp()
3302 smp_auth_cb && smp_auth_cb->pairing_confirm) { in smp_pairing_rsp()
3303 atomic_set_bit(smp->flags, SMP_FLAG_USER); in smp_pairing_rsp()
3304 smp_auth_cb->pairing_confirm(conn); in smp_pairing_rsp()
3309 atomic_set_bit(smp->flags, SMP_FLAG_PKEY_SEND); in smp_pairing_rsp()
3313 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PUBLIC_KEY); in smp_pairing_rsp()
3314 atomic_clear_bit(smp->allowed_cmds, BT_SMP_CMD_SECURITY_REQUEST); in smp_pairing_rsp()
3327 struct bt_smp_pairing_confirm *req = (void *)buf->data; in smp_pairing_confirm()
3331 atomic_clear_bit(smp->flags, SMP_FLAG_DISPLAY); in smp_pairing_confirm()
3333 memcpy(smp->pcnf, req->val, sizeof(smp->pcnf)); in smp_pairing_confirm()
3336 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in smp_pairing_confirm()
3337 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM); in smp_pairing_confirm()
3346 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in smp_pairing_confirm()
3351 switch (smp->method) { in smp_pairing_confirm()
3353 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM); in smp_pairing_confirm()
3356 if (atomic_test_bit(smp->flags, SMP_FLAG_USER)) { in smp_pairing_confirm()
3357 atomic_set_bit(smp->flags, SMP_FLAG_CFM_DELAYED); in smp_pairing_confirm()
3361 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM); in smp_pairing_confirm()
3366 LOG_ERR("Unknown pairing method (%u)", smp->method); in smp_pairing_confirm()
3384 memcpy(req->e, e, sizeof(req->e)); in sc_smp_send_dhkey_check()
3398 switch (smp->method) { in compute_and_send_central_dhcheck()
3404 memcpy(r, &smp->passkey, sizeof(smp->passkey)); in compute_and_send_central_dhcheck()
3407 if (smp->oobd_remote) { in compute_and_send_central_dhcheck()
3408 memcpy(r, smp->oobd_remote->r, sizeof(r)); in compute_and_send_central_dhcheck()
3412 LOG_ERR("Unknown pairing method (%u)", smp->method); in compute_and_send_central_dhcheck()
3417 if (bt_crypto_f5(smp->dhkey, smp->prnd, smp->rrnd, &smp->chan.chan.conn->le.init_addr, in compute_and_send_central_dhcheck()
3418 &smp->chan.chan.conn->le.resp_addr, smp->mackey, smp->tk)) { in compute_and_send_central_dhcheck()
3423 if (bt_crypto_f6(smp->mackey, smp->prnd, smp->rrnd, r, &smp->preq[1], in compute_and_send_central_dhcheck()
3424 &smp->chan.chan.conn->le.init_addr, &smp->chan.chan.conn->le.resp_addr, in compute_and_send_central_dhcheck()
3430 atomic_set_bit(smp->allowed_cmds, BT_SMP_DHKEY_CHECK); in compute_and_send_central_dhcheck()
3443 switch (smp->method) { in compute_and_check_and_send_periph_dhcheck()
3449 memcpy(r, &smp->passkey, sizeof(smp->passkey)); in compute_and_check_and_send_periph_dhcheck()
3452 if (smp->oobd_remote) { in compute_and_check_and_send_periph_dhcheck()
3453 memcpy(r, smp->oobd_remote->r, sizeof(r)); in compute_and_check_and_send_periph_dhcheck()
3457 LOG_ERR("Unknown pairing method (%u)", smp->method); in compute_and_check_and_send_periph_dhcheck()
3462 if (bt_crypto_f5(smp->dhkey, smp->rrnd, smp->prnd, &smp->chan.chan.conn->le.init_addr, in compute_and_check_and_send_periph_dhcheck()
3463 &smp->chan.chan.conn->le.resp_addr, smp->mackey, smp->tk)) { in compute_and_check_and_send_periph_dhcheck()
3469 if (bt_crypto_f6(smp->mackey, smp->prnd, smp->rrnd, r, &smp->prsp[1], in compute_and_check_and_send_periph_dhcheck()
3470 &smp->chan.chan.conn->le.resp_addr, &smp->chan.chan.conn->le.init_addr, in compute_and_check_and_send_periph_dhcheck()
3476 if (smp->method == LE_SC_OOB) { in compute_and_check_and_send_periph_dhcheck()
3477 if (smp->oobd_local) { in compute_and_check_and_send_periph_dhcheck()
3478 memcpy(r, smp->oobd_local->r, sizeof(r)); in compute_and_check_and_send_periph_dhcheck()
3484 /* calculate remote DHKey check */ in compute_and_check_and_send_periph_dhcheck()
3485 if (bt_crypto_f6(smp->mackey, smp->rrnd, smp->prnd, r, &smp->preq[1], in compute_and_check_and_send_periph_dhcheck()
3486 &smp->chan.chan.conn->le.init_addr, &smp->chan.chan.conn->le.resp_addr, in compute_and_check_and_send_periph_dhcheck()
3488 LOG_ERR("Calculate remote DHKey check failed"); in compute_and_check_and_send_periph_dhcheck()
3492 /* compare received E with calculated remote */ in compute_and_check_and_send_periph_dhcheck()
3493 if (memcmp(smp->e, re, 16)) { in compute_and_check_and_send_periph_dhcheck()
3503 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in compute_and_check_and_send_periph_dhcheck()
3513 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_GEN); in smp_dhkey_generate()
3514 err = bt_dh_key_gen(smp->pkey, bt_smp_dhkey_ready); in smp_dhkey_generate()
3516 atomic_clear_bit(smp->flags, SMP_FLAG_DHKEY_GEN); in smp_dhkey_generate()
3531 atomic_clear_bit(smp->flags, SMP_FLAG_DHKEY_PENDING); in smp_dhkey_ready()
3532 memcpy(smp->dhkey, dhkey, BT_DH_KEY_LEN); in smp_dhkey_ready()
3535 if (atomic_test_bit(smp->flags, SMP_FLAG_USER)) { in smp_dhkey_ready()
3536 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_SEND); in smp_dhkey_ready()
3540 /* wait for remote DHKey Check */ in smp_dhkey_ready()
3541 if (atomic_test_bit(smp->flags, SMP_FLAG_DHCHECK_WAIT)) { in smp_dhkey_ready()
3542 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_SEND); in smp_dhkey_ready()
3546 if (atomic_test_bit(smp->flags, SMP_FLAG_DHKEY_SEND)) { in smp_dhkey_ready()
3548 if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in smp_dhkey_ready()
3580 atomic_clear_bit(smp->flags, SMP_FLAG_DHKEY_GEN); in bt_smp_dhkey_ready()
3604 switch (smp->method) { in sc_smp_check_confirm()
3620 r = (smp->passkey >> smp->passkey_round) & 0x01; in sc_smp_check_confirm()
3624 LOG_ERR("Unknown pairing method (%u)", smp->method); in sc_smp_check_confirm()
3628 if (bt_crypto_f4(smp->pkey, sc_public_key, smp->rrnd, r, cfm)) { in sc_smp_check_confirm()
3633 LOG_DBG("pcnf %s", bt_hex(smp->pcnf, 16)); in sc_smp_check_confirm()
3636 if (memcmp(smp->pcnf, cfm, 16)) { in sc_smp_check_confirm()
3645 struct bt_smp_pairing *req = (struct bt_smp_pairing *)&smp->preq[1]; in le_sc_oob_data_req_check()
3647 return ((req->oob_flag & BT_SMP_OOB_DATA_MASK) == BT_SMP_OOB_PRESENT); in le_sc_oob_data_req_check()
3652 struct bt_smp_pairing *rsp = (struct bt_smp_pairing *)&smp->prsp[1]; in le_sc_oob_data_rsp_check()
3654 return ((rsp->oob_flag & BT_SMP_OOB_DATA_MASK) == BT_SMP_OOB_PRESENT); in le_sc_oob_data_rsp_check()
3665 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in le_sc_oob_config_set()
3685 info->lesc.oob_config = oob_config; in le_sc_oob_config_set()
3691 struct bt_smp_pairing_random *req = (void *)buf->data; in smp_pairing_random()
3697 memcpy(smp->rrnd, req->val, sizeof(smp->rrnd)); in smp_pairing_random()
3700 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in smp_pairing_random()
3706 if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in smp_pairing_random()
3712 switch (smp->method) { in smp_pairing_random()
3715 if (bt_crypto_g2(sc_public_key, smp->pkey, smp->prnd, smp->rrnd, in smp_pairing_random()
3720 atomic_set_bit(smp->flags, SMP_FLAG_USER); in smp_pairing_random()
3721 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_SEND); in smp_pairing_random()
3722 smp_auth_cb->passkey_confirm(smp->chan.chan.conn, passkey); in smp_pairing_random()
3730 smp->passkey_round++; in smp_pairing_random()
3731 if (smp->passkey_round == 20U) { in smp_pairing_random()
3735 if (bt_rand(smp->prnd, 16)) { in smp_pairing_random()
3739 atomic_set_bit(smp->allowed_cmds, in smp_pairing_random()
3743 LOG_ERR("Unknown pairing method (%u)", smp->method); in smp_pairing_random()
3748 if (atomic_test_bit(smp->flags, SMP_FLAG_DHKEY_PENDING)) { in smp_pairing_random()
3749 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_SEND); in smp_pairing_random()
3758 switch (smp->method) { in smp_pairing_random()
3760 if (bt_crypto_g2(smp->pkey, sc_public_key, smp->rrnd, smp->prnd, &passkey)) { in smp_pairing_random()
3764 atomic_set_bit(smp->flags, SMP_FLAG_USER); in smp_pairing_random()
3765 smp_auth_cb->passkey_confirm(smp->chan.chan.conn, passkey); in smp_pairing_random()
3776 atomic_set_bit(smp->allowed_cmds, in smp_pairing_random()
3783 smp->passkey_round++; in smp_pairing_random()
3784 if (smp->passkey_round == 20U) { in smp_pairing_random()
3785 atomic_set_bit(smp->allowed_cmds, BT_SMP_DHKEY_CHECK); in smp_pairing_random()
3786 atomic_set_bit(smp->flags, SMP_FLAG_DHCHECK_WAIT); in smp_pairing_random()
3790 if (bt_rand(smp->prnd, 16)) { in smp_pairing_random()
3797 if (bt_rand(smp->prnd, 16)) { in smp_pairing_random()
3802 smp_auth_cb->oob_data_request) { in smp_pairing_random()
3810 smp->oobd_local = NULL; in smp_pairing_random()
3811 smp->oobd_remote = NULL; in smp_pairing_random()
3813 atomic_set_bit(smp->flags, SMP_FLAG_OOB_PENDING); in smp_pairing_random()
3814 smp_auth_cb->oob_data_request(smp->chan.chan.conn, &info); in smp_pairing_random()
3821 LOG_ERR("Unknown pairing method (%u)", smp->method); in smp_pairing_random()
3825 atomic_set_bit(smp->allowed_cmds, BT_SMP_DHKEY_CHECK); in smp_pairing_random()
3826 atomic_set_bit(smp->flags, SMP_FLAG_DHCHECK_WAIT); in smp_pairing_random()
3835 struct bt_conn *conn = smp->chan.chan.conn; in smp_pairing_failed()
3837 struct bt_smp_pairing_fail *req = (void *)buf->data; in smp_pairing_failed()
3839 LOG_ERR("pairing failed (peer reason 0x%x)", req->reason); in smp_pairing_failed()
3841 if (atomic_test_and_clear_bit(smp->flags, SMP_FLAG_USER) || in smp_pairing_failed()
3842 atomic_test_and_clear_bit(smp->flags, SMP_FLAG_DISPLAY)) { in smp_pairing_failed()
3843 if (smp_auth_cb && smp_auth_cb->cancel) { in smp_pairing_failed()
3844 smp_auth_cb->cancel(conn); in smp_pairing_failed()
3848 smp_pairing_complete(smp, req->reason); in smp_pairing_failed()
3858 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in smp_ident_info()
3859 struct bt_smp_ident_info *req = (void *)buf->data; in smp_ident_info()
3860 struct bt_conn *conn = smp->chan.chan.conn; in smp_ident_info()
3863 keys = bt_keys_get_type(BT_KEYS_IRK, conn->id, &conn->le.dst); in smp_ident_info()
3865 LOG_ERR("Unable to get keys for %s", bt_addr_le_str(&conn->le.dst)); in smp_ident_info()
3869 memcpy(keys->irk.val, req->irk, 16); in smp_ident_info()
3872 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_IDENT_ADDR_INFO); in smp_ident_info()
3882 * have the remote identity. in smp_id_add_replace()
3884 __ASSERT_NO_MSG(!(smp->remote_dist & BT_SMP_DIST_ID_KEY)); in smp_id_add_replace()
3888 LOG_DBG("New bond conflicts with a bond on id %d.", conflict->id); in smp_id_add_replace()
3906 LOG_DBG("Un-pairing old conflicting bond and finalizing new."); in smp_id_add_replace()
3908 unpair_err = bt_unpair(conflict->id, &conflict->addr); in smp_id_add_replace()
3926 if (bt_addr_le_eq(&conn->le.dst, addr_match->rpa)) { in convert_to_id_on_match()
3927 bt_addr_le_copy(&conn->le.dst, addr_match->id_addr); in convert_to_id_on_match()
3933 struct bt_conn *conn = smp->chan.chan.conn; in smp_ident_addr_info()
3934 struct bt_smp_ident_addr_info *req = (void *)buf->data; in smp_ident_addr_info()
3937 LOG_DBG("identity %s", bt_addr_le_str(&req->addr)); in smp_ident_addr_info()
3939 smp->remote_dist &= ~BT_SMP_DIST_ID_KEY; in smp_ident_addr_info()
3941 if (!bt_addr_le_is_identity(&req->addr)) { in smp_ident_addr_info()
3942 LOG_ERR("Invalid identity %s", bt_addr_le_str(&req->addr)); in smp_ident_addr_info()
3943 LOG_ERR(" for %s", bt_addr_le_str(&conn->le.dst)); in smp_ident_addr_info()
3947 if (!bt_addr_le_eq(&conn->le.dst, &req->addr)) { in smp_ident_addr_info()
3948 struct bt_keys *keys = bt_keys_find_addr(conn->id, &req->addr); in smp_ident_addr_info()
3959 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in smp_ident_addr_info()
3963 keys = bt_keys_get_type(BT_KEYS_IRK, conn->id, &conn->le.dst); in smp_ident_addr_info()
3965 LOG_ERR("Unable to get keys for %s", bt_addr_le_str(&conn->le.dst)); in smp_ident_addr_info()
3970 * We can't use conn->dst here as this might already contain in smp_ident_addr_info()
3971 * identity address known from previous pairing. Since all keys in smp_ident_addr_info()
3972 * are cleared on re-pairing we wouldn't store IRK distributed in smp_ident_addr_info()
3975 if (conn->role == BT_HCI_ROLE_CENTRAL) { in smp_ident_addr_info()
3976 dst = &conn->le.resp_addr; in smp_ident_addr_info()
3978 dst = &conn->le.init_addr; in smp_ident_addr_info()
3983 bt_addr_copy(&keys->irk.rpa, &dst->a); in smp_ident_addr_info()
3986 * Update connection address and notify about identity in smp_ident_addr_info()
3988 * with identity address. This may happen if IRK was in smp_ident_addr_info()
3989 * present before ie. due to re-pairing. in smp_ident_addr_info()
3991 if (!bt_addr_le_is_identity(&conn->le.dst)) { in smp_ident_addr_info()
3993 .rpa = &conn->le.dst, in smp_ident_addr_info()
3994 .id_addr = &req->addr, in smp_ident_addr_info()
4000 bt_addr_le_copy(&keys->addr, &req->addr); in smp_ident_addr_info()
4012 if (smp->remote_dist & BT_SMP_DIST_SIGN) { in smp_ident_addr_info()
4013 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SIGNING_INFO); in smp_ident_addr_info()
4017 conn->role == BT_HCI_ROLE_CENTRAL && !smp->remote_dist) { in smp_ident_addr_info()
4025 if (!smp->local_dist && !smp->remote_dist) { in smp_ident_addr_info()
4035 struct bt_conn *conn = smp->chan.chan.conn; in smp_signing_info()
4040 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in smp_signing_info()
4041 struct bt_smp_signing_info *req = (void *)buf->data; in smp_signing_info()
4044 keys = bt_keys_get_type(BT_KEYS_REMOTE_CSRK, conn->id, in smp_signing_info()
4045 &conn->le.dst); in smp_signing_info()
4047 LOG_ERR("Unable to get keys for %s", bt_addr_le_str(&conn->le.dst)); in smp_signing_info()
4051 memcpy(keys->remote_csrk.val, req->csrk, in smp_signing_info()
4052 sizeof(keys->remote_csrk.val)); in smp_signing_info()
4055 smp->remote_dist &= ~BT_SMP_DIST_SIGN; in smp_signing_info()
4058 conn->role == BT_HCI_ROLE_CENTRAL && !smp->remote_dist) { in smp_signing_info()
4066 if (!smp->local_dist && !smp->remote_dist) { in smp_signing_info()
4082 struct bt_conn *conn = smp->chan.chan.conn; in smp_security_request()
4083 struct bt_smp_security_request *req = (void *)buf->data; in smp_security_request()
4091 if (atomic_test_bit(smp->flags, SMP_FLAG_KEYS_DISTR)) { in smp_security_request()
4095 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in smp_security_request()
4100 if (atomic_test_bit(smp->flags, SMP_FLAG_ENC_PENDING)) { in smp_security_request()
4106 auth = req->auth_req & BT_SMP_AUTH_MASK_SC; in smp_security_request()
4108 auth = req->auth_req & BT_SMP_AUTH_MASK; in smp_security_request()
4123 if (conn->le.keys) { in smp_security_request()
4125 if (!(conn->le.keys->keys & (BT_KEYS_LTK_P256 | BT_KEYS_LTK))) { in smp_security_request()
4129 conn->le.keys = bt_keys_find(BT_KEYS_LTK_P256, conn->id, in smp_security_request()
4130 &conn->le.dst); in smp_security_request()
4131 if (!conn->le.keys) { in smp_security_request()
4132 conn->le.keys = bt_keys_find(BT_KEYS_LTK, conn->id, in smp_security_request()
4133 &conn->le.dst); in smp_security_request()
4137 if (!conn->le.keys) { in smp_security_request()
4143 !(conn->le.keys->flags & BT_KEYS_AUTHENTICATED)) { in smp_security_request()
4155 !(conn->le.keys->keys & BT_KEYS_LTK_P256)) { in smp_security_request()
4160 if (bt_conn_le_start_encryption(conn, conn->le.keys->ltk.rand, in smp_security_request()
4161 conn->le.keys->ltk.ediv, in smp_security_request()
4162 conn->le.keys->ltk.val, in smp_security_request()
4163 conn->le.keys->enc_size) < 0) { in smp_security_request()
4168 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in smp_security_request()
4176 atomic_set_bit(smp->flags, SMP_FLAG_SEC_REQ); in smp_security_request()
4193 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_PENDING); in generate_dhkey()
4203 struct bt_conn *conn = smp->chan.chan.conn; in display_passkey()
4208 smp->passkey = fixed_passkey; in display_passkey()
4210 if (bt_rand(&smp->passkey, sizeof(smp->passkey))) { in display_passkey()
4214 smp->passkey %= 1000000; in display_passkey()
4217 smp->passkey_round = 0U; in display_passkey()
4219 if (smp_auth_cb && smp_auth_cb->passkey_display) { in display_passkey()
4220 atomic_set_bit(smp->flags, SMP_FLAG_DISPLAY); in display_passkey()
4221 smp_auth_cb->passkey_display(conn, smp->passkey); in display_passkey()
4224 smp->passkey = sys_cpu_to_le32(smp->passkey); in display_passkey()
4235 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC_DEBUG_KEY) && in smp_public_key_periph()
4236 memcmp(smp->pkey, sc_public_key, BT_PUB_KEY_COORD_LEN) == 0) { in smp_public_key_periph()
4240 LOG_WRN("Remote public key rejected"); in smp_public_key_periph()
4249 switch (smp->method) { in smp_public_key_periph()
4252 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM); in smp_public_key_periph()
4265 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM); in smp_public_key_periph()
4266 atomic_set_bit(smp->allowed_cmds, BT_SMP_KEYPRESS_NOTIFICATION); in smp_public_key_periph()
4269 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM); in smp_public_key_periph()
4270 atomic_set_bit(smp->allowed_cmds, BT_SMP_KEYPRESS_NOTIFICATION); in smp_public_key_periph()
4271 atomic_set_bit(smp->flags, SMP_FLAG_USER); in smp_public_key_periph()
4272 smp_auth_cb->passkey_entry(smp->chan.chan.conn); in smp_public_key_periph()
4275 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM); in smp_public_key_periph()
4278 LOG_ERR("Unknown pairing method (%u)", smp->method); in smp_public_key_periph()
4295 struct bt_smp_public_key *req = (void *)buf->data; in smp_public_key()
4300 memcpy(smp->pkey, req->x, BT_PUB_KEY_COORD_LEN); in smp_public_key()
4301 memcpy(&smp->pkey[BT_PUB_KEY_COORD_LEN], req->y, BT_PUB_KEY_COORD_LEN); in smp_public_key()
4303 /* mark key as debug if remote is using it */ in smp_public_key()
4304 if (bt_pub_key_is_debug(smp->pkey)) { in smp_public_key()
4305 LOG_INF("Remote is using Debug Public key"); in smp_public_key()
4306 atomic_set_bit(smp->flags, SMP_FLAG_SC_DEBUG_KEY); in smp_public_key()
4314 } else if (!bt_pub_key_is_valid(smp->pkey)) { in smp_public_key()
4320 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in smp_public_key()
4321 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC_DEBUG_KEY) && in smp_public_key()
4322 memcmp(smp->pkey, sc_public_key, BT_PUB_KEY_COORD_LEN) == 0) { in smp_public_key()
4326 LOG_WRN("Remote public key rejected"); in smp_public_key()
4330 switch (smp->method) { in smp_public_key()
4333 atomic_set_bit(smp->allowed_cmds, in smp_public_key()
4342 atomic_set_bit(smp->allowed_cmds, in smp_public_key()
4345 atomic_set_bit(smp->allowed_cmds, in smp_public_key()
4354 atomic_set_bit(smp->flags, SMP_FLAG_USER); in smp_public_key()
4355 smp_auth_cb->passkey_entry(smp->chan.chan.conn); in smp_public_key()
4357 atomic_set_bit(smp->allowed_cmds, in smp_public_key()
4363 if (bt_rand(smp->prnd, 16)) { in smp_public_key()
4367 if (smp_auth_cb && smp_auth_cb->oob_data_request) { in smp_public_key()
4375 smp->oobd_local = NULL; in smp_public_key()
4376 smp->oobd_remote = NULL; in smp_public_key()
4378 atomic_set_bit(smp->flags, in smp_public_key()
4380 smp_auth_cb->oob_data_request(smp->chan.chan.conn, &info); in smp_public_key()
4386 LOG_ERR("Unknown pairing method (%u)", smp->method); in smp_public_key()
4395 atomic_set_bit(smp->flags, SMP_FLAG_PKEY_SEND); in smp_public_key()
4411 struct bt_smp_dhkey_check *req = (void *)buf->data; in smp_dhkey_check()
4416 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in smp_dhkey_check()
4422 switch (smp->method) { in smp_dhkey_check()
4428 memcpy(r, &smp->passkey, sizeof(smp->passkey)); in smp_dhkey_check()
4431 if (smp->oobd_local) { in smp_dhkey_check()
4432 memcpy(r, smp->oobd_local->r, sizeof(r)); in smp_dhkey_check()
4436 LOG_ERR("Unknown pairing method (%u)", smp->method); in smp_dhkey_check()
4440 /* calculate remote DHKey check for comparison */ in smp_dhkey_check()
4441 if (bt_crypto_f6(smp->mackey, smp->rrnd, smp->prnd, r, &smp->prsp[1], in smp_dhkey_check()
4442 &smp->chan.chan.conn->le.resp_addr, in smp_dhkey_check()
4443 &smp->chan.chan.conn->le.init_addr, e)) { in smp_dhkey_check()
4447 if (memcmp(e, req->e, 16)) { in smp_dhkey_check()
4456 if (bt_conn_le_start_encryption(smp->chan.chan.conn, rand, ediv, in smp_dhkey_check()
4457 smp->tk, enc_size) < 0) { in smp_dhkey_check()
4462 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in smp_dhkey_check()
4465 if (smp->remote_dist & BT_SMP_DIST_ID_KEY) { in smp_dhkey_check()
4466 atomic_set_bit(smp->allowed_cmds, in smp_dhkey_check()
4468 } else if (smp->remote_dist & BT_SMP_DIST_SIGN) { in smp_dhkey_check()
4469 atomic_set_bit(smp->allowed_cmds, in smp_dhkey_check()
4478 if (smp->chan.chan.conn->role == BT_HCI_ROLE_PERIPHERAL) { in smp_dhkey_check()
4479 atomic_clear_bit(smp->flags, SMP_FLAG_DHCHECK_WAIT); in smp_dhkey_check()
4480 memcpy(smp->e, req->e, sizeof(smp->e)); in smp_dhkey_check()
4483 if (atomic_test_bit(smp->flags, SMP_FLAG_DHKEY_PENDING)) { in smp_dhkey_check()
4484 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_SEND); in smp_dhkey_check()
4489 if (atomic_test_bit(smp->flags, SMP_FLAG_USER)) { in smp_dhkey_check()
4490 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_SEND); in smp_dhkey_check()
4505 struct bt_conn *conn = smp->chan.chan.conn; in smp_keypress_notif()
4506 struct bt_smp_keypress_notif *notif = (void *)buf->data; in smp_keypress_notif()
4507 enum bt_conn_auth_keypress type = notif->type; in smp_keypress_notif()
4515 atomic_set_bit(smp->allowed_cmds, BT_SMP_KEYPRESS_NOTIFICATION); in smp_keypress_notif()
4525 k_work_reschedule(&smp->work, SMP_TIMEOUT); in smp_keypress_notif()
4527 if (smp_auth_cb->passkey_display_keypress) { in smp_keypress_notif()
4528 smp_auth_cb->passkey_display_keypress(conn, type); in smp_keypress_notif()
4542 atomic_set_bit(smp->allowed_cmds, BT_SMP_KEYPRESS_NOTIFICATION); in smp_keypress_notif()
4551 { }, /* No op-code defined for 0x00 */
4570 return atomic_test_bit(smp->flags, SMP_FLAG_PAIRING); in is_in_pairing_procedure()
4579 if (buf->len < sizeof(*hdr)) { in bt_smp_recv()
4585 LOG_DBG("Received SMP code 0x%02x len %u", hdr->code, buf->len); in bt_smp_recv()
4592 if (atomic_test_bit(smp->flags, SMP_FLAG_TIMEOUT)) { in bt_smp_recv()
4593 LOG_WRN("SMP command (code 0x%02x) received after timeout", hdr->code); in bt_smp_recv()
4602 if (hdr->code >= ARRAY_SIZE(handlers)) { in bt_smp_recv()
4603 LOG_WRN("Received reserved SMP code 0x%02x", hdr->code); in bt_smp_recv()
4607 if (!handlers[hdr->code].func) { in bt_smp_recv()
4608 LOG_WRN("Unhandled SMP code 0x%02x", hdr->code); in bt_smp_recv()
4613 if (!atomic_test_and_clear_bit(smp->allowed_cmds, hdr->code)) { in bt_smp_recv()
4614 LOG_WRN("Unexpected SMP code 0x%02x", hdr->code); in bt_smp_recv()
4622 if (buf->len != handlers[hdr->code].expect_len) { in bt_smp_recv()
4623 LOG_ERR("Invalid len %u for code 0x%02x", buf->len, hdr->code); in bt_smp_recv()
4628 err = handlers[hdr->code].func(smp, buf); in bt_smp_recv()
4655 if (!atomic_test_bit(smp->flags, SMP_FLAG_PKEY_SEND)) { in bt_smp_pkey_ready()
4660 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in bt_smp_pkey_ready()
4666 atomic_set_bit(smp->allowed_cmds, in bt_smp_pkey_ready()
4685 CONTAINER_OF(chan, struct bt_l2cap_le_chan, chan)->tx.cid); in bt_smp_connected()
4687 k_work_init_delayable(&smp->work, smp_timeout); in bt_smp_connected()
4690 atomic_ptr_set(&smp->auth_cb, BT_SMP_AUTH_CB_UNINITIALIZED); in bt_smp_connected()
4691 atomic_set(&smp->bondable, BT_SMP_BONDABLE_UNINITIALIZED); in bt_smp_connected()
4697 struct bt_keys *keys = chan->conn->le.keys; in bt_smp_disconnected()
4700 CONTAINER_OF(chan, struct bt_l2cap_le_chan, chan)->tx.cid); in bt_smp_disconnected()
4705 (void)k_work_cancel_delayable(&smp->work); in bt_smp_disconnected()
4707 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING) || in bt_smp_disconnected()
4708 atomic_test_bit(smp->flags, SMP_FLAG_ENC_PENDING) || in bt_smp_disconnected()
4709 atomic_test_bit(smp->flags, SMP_FLAG_SEC_REQ)) { in bt_smp_disconnected()
4719 if (!keys->keys || (!IS_ENABLED(CONFIG_BT_STORE_DEBUG_KEYS) && in bt_smp_disconnected()
4720 (keys->flags & BT_KEYS_DEBUG))) { in bt_smp_disconnected()
4732 struct bt_conn *conn = chan->conn; in bt_smp_encrypt_change()
4735 conn->handle, conn->encrypt, hci_status, bt_hci_err_to_str(hci_status)); in bt_smp_encrypt_change()
4737 if (!atomic_test_and_clear_bit(smp->flags, SMP_FLAG_ENC_PENDING)) { in bt_smp_encrypt_change()
4746 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in bt_smp_encrypt_change()
4751 atomic_set_bit(smp->flags, SMP_FLAG_KEYS_DISTR); in bt_smp_encrypt_change()
4758 if (!conn->encrypt) { in bt_smp_encrypt_change()
4766 if (!atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in bt_smp_encrypt_change()
4772 if (atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in bt_smp_encrypt_change()
4773 if ((smp->local_dist & BT_SMP_DIST_LINK_KEY) && in bt_smp_encrypt_change()
4774 (smp->remote_dist & BT_SMP_DIST_LINK_KEY)) { in bt_smp_encrypt_change()
4777 * make sure remote device identity is known in bt_smp_encrypt_change()
4779 atomic_set_bit(smp->flags, SMP_FLAG_DERIVE_LK); in bt_smp_encrypt_change()
4785 smp->local_dist &= ~BT_SMP_DIST_LINK_KEY; in bt_smp_encrypt_change()
4786 smp->remote_dist &= ~BT_SMP_DIST_LINK_KEY; in bt_smp_encrypt_change()
4789 if (smp->remote_dist & BT_SMP_DIST_ENC_KEY) { in bt_smp_encrypt_change()
4790 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_ENCRYPT_INFO); in bt_smp_encrypt_change()
4791 } else if (smp->remote_dist & BT_SMP_DIST_ID_KEY) { in bt_smp_encrypt_change()
4792 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_IDENT_INFO); in bt_smp_encrypt_change()
4793 } else if (smp->remote_dist & BT_SMP_DIST_SIGN) { in bt_smp_encrypt_change()
4794 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SIGNING_INFO); in bt_smp_encrypt_change()
4807 * We need an entry in the RL despite the remote not using privacy. This in bt_smp_encrypt_change()
4818 conn->role == BT_HCI_ROLE_CENTRAL && in bt_smp_encrypt_change()
4819 !(smp->remote_dist & BT_SMP_DIST_ID_KEY)) { in bt_smp_encrypt_change()
4822 smp_err = smp_id_add_replace(smp, conn->le.keys); in bt_smp_encrypt_change()
4828 atomic_set_bit(smp->flags, SMP_FLAG_KEYS_DISTR); in bt_smp_encrypt_change()
4832 conn->role == BT_HCI_ROLE_CENTRAL && smp->remote_dist) { in bt_smp_encrypt_change()
4837 /* Avoid the HCI-USB race condition where HCI data and in bt_smp_encrypt_change()
4838 * HCI events can be re-ordered, and pairing information appears in bt_smp_encrypt_change()
4849 if (!smp->local_dist && !smp->remote_dist) { in bt_smp_encrypt_change()
4902 memcpy(sig, net_buf_tail(buf) - sizeof(sig), sizeof(sig)); in bt_smp_sign_verify()
4904 keys = bt_keys_find(BT_KEYS_REMOTE_CSRK, conn->id, &conn->le.dst); in bt_smp_sign_verify()
4906 LOG_ERR("Unable to find Remote CSRK for %s", bt_addr_le_str(&conn->le.dst)); in bt_smp_sign_verify()
4907 return -ENOENT; in bt_smp_sign_verify()
4911 cnt = sys_cpu_to_le32(keys->remote_csrk.cnt); in bt_smp_sign_verify()
4912 memcpy(net_buf_tail(buf) - sizeof(sig), &cnt, sizeof(cnt)); in bt_smp_sign_verify()
4914 LOG_DBG("Sign data len %zu key %s count %u", buf->len - sizeof(sig), in bt_smp_sign_verify()
4915 bt_hex(keys->remote_csrk.val, 16), keys->remote_csrk.cnt); in bt_smp_sign_verify()
4917 err = smp_sign_buf(keys->remote_csrk.val, buf->data, in bt_smp_sign_verify()
4918 buf->len - sizeof(sig)); in bt_smp_sign_verify()
4920 LOG_ERR("Unable to create signature for %s", bt_addr_le_str(&conn->le.dst)); in bt_smp_sign_verify()
4921 return -EIO; in bt_smp_sign_verify()
4924 if (memcmp(sig, net_buf_tail(buf) - sizeof(sig), sizeof(sig))) { in bt_smp_sign_verify()
4925 LOG_ERR("Unable to verify signature for %s", bt_addr_le_str(&conn->le.dst)); in bt_smp_sign_verify()
4926 return -EBADMSG; in bt_smp_sign_verify()
4929 keys->remote_csrk.cnt++; in bt_smp_sign_verify()
4940 keys = bt_keys_find(BT_KEYS_LOCAL_CSRK, conn->id, &conn->le.dst); in bt_smp_sign()
4942 LOG_ERR("Unable to find local CSRK for %s", bt_addr_le_str(&conn->le.dst)); in bt_smp_sign()
4943 return -ENOENT; in bt_smp_sign()
4950 cnt = sys_cpu_to_le32(keys->local_csrk.cnt); in bt_smp_sign()
4951 memcpy(net_buf_tail(buf) - 12, &cnt, sizeof(cnt)); in bt_smp_sign()
4953 LOG_DBG("Sign data len %u key %s count %u", buf->len, bt_hex(keys->local_csrk.val, 16), in bt_smp_sign()
4954 keys->local_csrk.cnt); in bt_smp_sign()
4956 err = smp_sign_buf(keys->local_csrk.val, buf->data, buf->len - 12); in bt_smp_sign()
4958 LOG_ERR("Unable to create signature for %s", bt_addr_le_str(&conn->le.dst)); in bt_smp_sign()
4959 return -EIO; in bt_smp_sign()
4962 keys->local_csrk.cnt++; in bt_smp_sign()
4969 return -ENOTSUP; in bt_smp_sign_verify()
4974 return -ENOTSUP; in bt_smp_sign()
4986 memset(&res[4], 0, 16 - 4); in smp_d1()
5002 return -EINVAL; in bt_smp_irk_get()
5030 uint16_t len, const uint8_t *mac) in aes_test() argument
5037 if (!memcmp(out, mac, 16)) { in aes_test()
5041 return -1; in aes_test()
5067 err = aes_test("Test aes-cmac0", key, M, 0, mac1); in smp_aes_cmac_test()
5072 err = aes_test("Test aes-cmac16", key, M, 16, mac2); in smp_aes_cmac_test()
5077 err = aes_test("Test aes-cmac40", key, M, 40, mac3); in smp_aes_cmac_test()
5082 err = aes_test("Test aes-cmac64", key, M, 64, mac4); in smp_aes_cmac_test()
5118 return -1; in sign_test()
5125 return -1; in sign_test()
5152 /* Use the same key as aes-cmac but swap bytes */ in smp_sign_test()
5202 return -EINVAL; in smp_f4_test()
5237 return -EINVAL; in smp_f5_test()
5269 return -EINVAL; in smp_f6_test()
5299 return -EINVAL; in smp_g2_test()
5322 return -EINVAL; in smp_h6_test()
5345 return -EINVAL; in smp_h7_test()
5371 return -EINVAL; in smp_h8_test()
5383 LOG_ERR("SMP AES-CMAC self tests failed"); in smp_self_test()
5450 if (IS_ENABLED(CONFIG_BT_CLASSIC) && (conn->type == BT_CONN_TYPE_BR)) { in bt_conn_set_bondable()
5451 if (enable && atomic_test_and_set_bit(conn->flags, BT_CONN_BR_BONDABLE)) { in bt_conn_set_bondable()
5452 return -EALREADY; in bt_conn_set_bondable()
5454 if (!enable && !atomic_test_and_clear_bit(conn->flags, BT_CONN_BR_BONDABLE)) { in bt_conn_set_bondable()
5455 return -EALREADY; in bt_conn_set_bondable()
5462 return -EINVAL; in bt_conn_set_bondable()
5465 if (atomic_cas(&smp->bondable, BT_SMP_BONDABLE_UNINITIALIZED, (atomic_val_t)enable)) { in bt_conn_set_bondable()
5468 return -EALREADY; in bt_conn_set_bondable()
5479 return -EINVAL; in bt_smp_auth_cb_overlay()
5482 if (atomic_ptr_cas(&smp->auth_cb, BT_SMP_AUTH_CB_UNINITIALIZED, (atomic_ptr_val_t)cb)) { in bt_smp_auth_cb_overlay()
5485 return -EALREADY; in bt_smp_auth_cb_overlay()
5497 return -ENOMEM; in smp_send_keypress_notif()
5501 req->type = type; in smp_send_keypress_notif()
5516 return -EINVAL; in bt_smp_auth_keypress_notify()
5523 return -EINVAL; in bt_smp_auth_keypress_notify()
5526 if (smp->method != PASSKEY_INPUT || in bt_smp_auth_keypress_notify()
5527 !atomic_test_bit(smp->flags, SMP_FLAG_USER)) { in bt_smp_auth_keypress_notify()
5529 return -EINVAL; in bt_smp_auth_keypress_notify()
5543 return -EINVAL; in bt_smp_auth_passkey_entry()
5546 if (!atomic_test_and_clear_bit(smp->flags, SMP_FLAG_USER)) { in bt_smp_auth_passkey_entry()
5547 return -EINVAL; in bt_smp_auth_passkey_entry()
5551 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in bt_smp_auth_passkey_entry()
5557 smp->passkey = sys_cpu_to_le32(passkey); in bt_smp_auth_passkey_entry()
5560 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in bt_smp_auth_passkey_entry()
5561 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_CONFIRM); in bt_smp_auth_passkey_entry()
5571 atomic_test_bit(smp->flags, SMP_FLAG_CFM_DELAYED)) { in bt_smp_auth_passkey_entry()
5572 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM); in bt_smp_auth_passkey_entry()
5589 return -EINVAL; in bt_smp_auth_passkey_confirm()
5592 if (!atomic_test_and_clear_bit(smp->flags, SMP_FLAG_USER)) { in bt_smp_auth_passkey_confirm()
5593 return -EINVAL; in bt_smp_auth_passkey_confirm()
5597 if (atomic_test_bit(smp->flags, SMP_FLAG_DHKEY_PENDING)) { in bt_smp_auth_passkey_confirm()
5598 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_SEND); in bt_smp_auth_passkey_confirm()
5602 /* wait for remote DHKey Check */ in bt_smp_auth_passkey_confirm()
5603 if (atomic_test_bit(smp->flags, SMP_FLAG_DHCHECK_WAIT)) { in bt_smp_auth_passkey_confirm()
5604 atomic_set_bit(smp->flags, SMP_FLAG_DHKEY_SEND); in bt_smp_auth_passkey_confirm()
5608 if (atomic_test_bit(smp->flags, SMP_FLAG_DHKEY_SEND)) { in bt_smp_auth_passkey_confirm()
5612 if (smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in bt_smp_auth_passkey_confirm()
5639 return -EINVAL; in bt_smp_le_oob_set_tk()
5644 if (!atomic_test_and_clear_bit(smp->flags, SMP_FLAG_USER)) { in bt_smp_le_oob_set_tk()
5645 return -EINVAL; in bt_smp_le_oob_set_tk()
5655 memcpy(smp->tk, tk, 16*sizeof(uint8_t)); in bt_smp_le_oob_set_tk()
5668 return -ENOTSUP; in bt_smp_le_oob_generate_sc_data()
5684 memcpy(le_sc_oob->r, rand_num, sizeof(le_sc_oob->r)); in bt_smp_le_oob_generate_sc_data()
5686 err = bt_rand(le_sc_oob->r, 16); in bt_smp_le_oob_generate_sc_data()
5692 err = bt_crypto_f4(sc_public_key, sc_public_key, le_sc_oob->r, 0, in bt_smp_le_oob_generate_sc_data()
5693 le_sc_oob->c); in bt_smp_le_oob_generate_sc_data()
5709 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in le_sc_oob_data_check()
5726 if (smp->oobd_remote) { in le_sc_oob_pairing_continue()
5730 err = bt_crypto_f4(smp->pkey, smp->pkey, smp->oobd_remote->r, 0, c); in le_sc_oob_pairing_continue()
5735 bool match = (memcmp(c, smp->oobd_remote->c, sizeof(c)) == 0); in le_sc_oob_pairing_continue()
5744 smp->chan.chan.conn->role == BT_HCI_ROLE_CENTRAL) { in le_sc_oob_pairing_continue()
5745 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PAIRING_RANDOM); in le_sc_oob_pairing_continue()
5747 atomic_set_bit(smp->allowed_cmds, BT_SMP_DHKEY_CHECK); in le_sc_oob_pairing_continue()
5748 atomic_set_bit(smp->flags, SMP_FLAG_DHCHECK_WAIT); in le_sc_oob_pairing_continue()
5762 return -EINVAL; in bt_smp_le_oob_set_sc_data()
5767 return -EINVAL; in bt_smp_le_oob_set_sc_data()
5770 if (!atomic_test_and_clear_bit(smp->flags, SMP_FLAG_OOB_PENDING)) { in bt_smp_le_oob_set_sc_data()
5771 return -EINVAL; in bt_smp_le_oob_set_sc_data()
5774 smp->oobd_local = oobd_local; in bt_smp_le_oob_set_sc_data()
5775 smp->oobd_remote = oobd_remote; in bt_smp_le_oob_set_sc_data()
5788 return -EINVAL; in bt_smp_le_oob_get_sc_data()
5791 if (!smp->oobd_local && !smp->oobd_remote) { in bt_smp_le_oob_get_sc_data()
5792 return -ESRCH; in bt_smp_le_oob_get_sc_data()
5796 *oobd_local = smp->oobd_local; in bt_smp_le_oob_get_sc_data()
5800 *oobd_remote = smp->oobd_remote; in bt_smp_le_oob_get_sc_data()
5813 return -EINVAL; in bt_smp_auth_cancel()
5816 if (!atomic_test_and_clear_bit(smp->flags, SMP_FLAG_USER)) { in bt_smp_auth_cancel()
5817 return -EINVAL; in bt_smp_auth_cancel()
5822 switch (smp->method) { in bt_smp_auth_cancel()
5834 LOG_ERR("Unknown pairing method (%u)", smp->method); in bt_smp_auth_cancel()
5846 return -EINVAL; in bt_smp_auth_pairing_confirm()
5849 if (!atomic_test_and_clear_bit(smp->flags, SMP_FLAG_USER)) { in bt_smp_auth_pairing_confirm()
5850 return -EINVAL; in bt_smp_auth_pairing_confirm()
5854 conn->role == BT_CONN_ROLE_CENTRAL) { in bt_smp_auth_pairing_confirm()
5855 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in bt_smp_auth_pairing_confirm()
5856 atomic_set_bit(smp->allowed_cmds, in bt_smp_auth_pairing_confirm()
5862 atomic_set_bit(smp->flags, SMP_FLAG_PKEY_SEND); in bt_smp_auth_pairing_confirm()
5866 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PUBLIC_KEY); in bt_smp_auth_pairing_confirm()
5871 if (!atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in bt_smp_auth_pairing_confirm()
5872 atomic_set_bit(smp->allowed_cmds, in bt_smp_auth_pairing_confirm()
5877 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_PUBLIC_KEY); in bt_smp_auth_pairing_confirm()
5879 return -EIO; in bt_smp_auth_pairing_confirm()
5889 return -EINVAL; in bt_smp_auth_pairing_confirm()
5902 return -EINVAL; in bt_passkey_set()
5912 switch (conn->role) { in bt_smp_start_security()
5921 return -ENOTCONN; in bt_smp_start_security()
5925 if (atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in bt_smp_start_security()
5926 return -EBUSY; in bt_smp_start_security()
5930 if (atomic_test_bit(smp->flags, SMP_FLAG_ENC_PENDING)) { in bt_smp_start_security()
5931 return -EBUSY; in bt_smp_start_security()
5940 conn->le.keys->ltk.rand, in bt_smp_start_security()
5941 conn->le.keys->ltk.ediv, in bt_smp_start_security()
5942 conn->le.keys->ltk.val, in bt_smp_start_security()
5943 conn->le.keys->enc_size); in bt_smp_start_security()
5948 atomic_set_bit(smp->allowed_cmds, BT_SMP_CMD_SECURITY_REQUEST); in bt_smp_start_security()
5949 atomic_set_bit(smp->flags, SMP_FLAG_ENC_PENDING); in bt_smp_start_security()
5958 return -EINVAL; in bt_smp_start_security()
5971 if (!atomic_test_bit(smp->flags, SMP_FLAG_PAIRING)) { in bt_smp_update_keys()
5979 if (conn->le.keys) { in bt_smp_update_keys()
5980 bt_keys_clear(conn->le.keys); in bt_smp_update_keys()
5983 conn->le.keys = bt_keys_get_addr(conn->id, &conn->le.dst); in bt_smp_update_keys()
5984 if (!conn->le.keys) { in bt_smp_update_keys()
5985 LOG_ERR("Unable to get keys for %s", bt_addr_le_str(&conn->le.dst)); in bt_smp_update_keys()
5991 if (atomic_test_bit(smp->flags, SMP_FLAG_SC_DEBUG_KEY)) { in bt_smp_update_keys()
5992 conn->le.keys->flags |= BT_KEYS_DEBUG; in bt_smp_update_keys()
6000 switch (smp->method) { in bt_smp_update_keys()
6003 conn->le.keys->flags |= BT_KEYS_OOB; in bt_smp_update_keys()
6008 conn->le.keys->flags |= BT_KEYS_AUTHENTICATED; in bt_smp_update_keys()
6013 conn->le.keys->flags &= ~BT_KEYS_OOB; in bt_smp_update_keys()
6014 conn->le.keys->flags &= ~BT_KEYS_AUTHENTICATED; in bt_smp_update_keys()
6018 conn->le.keys->enc_size = get_encryption_key_size(smp); in bt_smp_update_keys()
6025 if (atomic_test_bit(smp->flags, SMP_FLAG_SC)) { in bt_smp_update_keys()
6026 conn->le.keys->flags |= BT_KEYS_SC; in bt_smp_update_keys()
6028 if (atomic_test_bit(smp->flags, SMP_FLAG_BOND)) { in bt_smp_update_keys()
6029 bt_keys_add_type(conn->le.keys, BT_KEYS_LTK_P256); in bt_smp_update_keys()
6030 memcpy(conn->le.keys->ltk.val, smp->tk, in bt_smp_update_keys()
6031 sizeof(conn->le.keys->ltk.val)); in bt_smp_update_keys()
6032 (void)memset(conn->le.keys->ltk.rand, 0, in bt_smp_update_keys()
6033 sizeof(conn->le.keys->ltk.rand)); in bt_smp_update_keys()
6034 (void)memset(conn->le.keys->ltk.ediv, 0, in bt_smp_update_keys()
6035 sizeof(conn->le.keys->ltk.ediv)); in bt_smp_update_keys()
6039 sys_memcpy_swap(ltk, smp->tk, conn->le.keys->enc_size); in bt_smp_update_keys()
6040 LOG_INF("SC LTK: 0x%s (No bonding)", bt_hex(ltk, conn->le.keys->enc_size)); in bt_smp_update_keys()
6043 conn->le.keys->flags &= ~BT_KEYS_SC; in bt_smp_update_keys()
6057 LOG_DBG("conn %p handle %u", conn, conn->handle); in bt_smp_accept()
6062 if (smp->chan.chan.conn) { in bt_smp_accept()
6066 smp->chan.chan.ops = &ops; in bt_smp_accept()
6068 *chan = &smp->chan.chan; in bt_smp_accept()
6075 return -ENOMEM; in bt_smp_accept()
6093 return -ENOENT; in bt_smp_init()