1 /* 2 BlueZ - Bluetooth protocol stack for Linux 3 Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License version 2 as 7 published by the Free Software Foundation; 8 9 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 10 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 11 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 12 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 13 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 14 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 18 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 19 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 20 SOFTWARE IS DISCLAIMED. 21 */ 22 23 #include <linux/crypto.h> 24 #include <linux/scatterlist.h> 25 #include <crypto/b128ops.h> 26 27 #include <net/bluetooth/bluetooth.h> 28 #include <net/bluetooth/hci_core.h> 29 #include <net/bluetooth/l2cap.h> 30 #include <net/bluetooth/mgmt.h> 31 32 #include "smp.h" 33 34 #define SMP_TIMEOUT msecs_to_jiffies(30000) 35 36 #define AUTH_REQ_MASK 0x07 37 38 static inline void swap128(const u8 src[16], u8 dst[16]) 39 { 40 int i; 41 for (i = 0; i < 16; i++) 42 dst[15 - i] = src[i]; 43 } 44 45 static inline void swap56(const u8 src[7], u8 dst[7]) 46 { 47 int i; 48 for (i = 0; i < 7; i++) 49 dst[6 - i] = src[i]; 50 } 51 52 static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r) 53 { 54 struct blkcipher_desc desc; 55 struct scatterlist sg; 56 uint8_t tmp[16], data[16]; 57 int err; 58 59 if (tfm == NULL) { 60 BT_ERR("tfm %p", tfm); 61 return -EINVAL; 62 } 63 64 desc.tfm = tfm; 65 desc.flags = 0; 66 67 /* The most significant octet of key corresponds to k[0] */ 68 swap128(k, tmp); 69 70 err = crypto_blkcipher_setkey(tfm, tmp, 16); 71 if (err) { 72 BT_ERR("cipher setkey failed: %d", err); 73 return err; 74 } 75 76 /* Most significant octet of plaintextData corresponds to data[0] */ 77 swap128(r, data); 78 79 sg_init_one(&sg, data, 16); 80 81 err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16); 82 if (err) 83 BT_ERR("Encrypt data error %d", err); 84 85 /* Most significant octet of encryptedData corresponds to data[0] */ 86 swap128(data, r); 87 88 return err; 89 } 90 91 static int smp_ah(struct crypto_blkcipher *tfm, u8 irk[16], u8 r[3], u8 res[3]) 92 { 93 u8 _res[16]; 94 int err; 95 96 /* r' = padding || r */ 97 memcpy(_res, r, 3); 98 memset(_res + 3, 0, 13); 99 100 err = smp_e(tfm, irk, _res); 101 if (err) { 102 BT_ERR("Encrypt error"); 103 return err; 104 } 105 106 /* The output of the random address function ah is: 107 * ah(h, r) = e(k, r') mod 2^24 108 * The output of the security function e is then truncated to 24 bits 109 * by taking the least significant 24 bits of the output of e as the 110 * result of ah. 111 */ 112 memcpy(res, _res, 3); 113 114 return 0; 115 } 116 117 bool smp_irk_matches(struct crypto_blkcipher *tfm, u8 irk[16], 118 bdaddr_t *bdaddr) 119 { 120 u8 hash[3]; 121 int err; 122 123 BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk); 124 125 err = smp_ah(tfm, irk, &bdaddr->b[3], hash); 126 if (err) 127 return false; 128 129 return !memcmp(bdaddr->b, hash, 3); 130 } 131 132 int smp_generate_rpa(struct crypto_blkcipher *tfm, u8 irk[16], bdaddr_t *rpa) 133 { 134 int err; 135 136 get_random_bytes(&rpa->b[3], 3); 137 138 rpa->b[5] &= 0x3f; /* Clear two most significant bits */ 139 rpa->b[5] |= 0x40; /* Set second most significant bit */ 140 141 err = smp_ah(tfm, irk, &rpa->b[3], rpa->b); 142 if (err < 0) 143 return err; 144 145 BT_DBG("RPA %pMR", rpa); 146 147 return 0; 148 } 149 150 static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16], 151 u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia, 152 u8 _rat, bdaddr_t *ra, u8 res[16]) 153 { 154 u8 p1[16], p2[16]; 155 int err; 156 157 memset(p1, 0, 16); 158 159 /* p1 = pres || preq || _rat || _iat */ 160 p1[0] = _iat; 161 p1[1] = _rat; 162 memcpy(p1 + 2, preq, 7); 163 memcpy(p1 + 9, pres, 7); 164 165 /* p2 = padding || ia || ra */ 166 memcpy(p2, ra, 6); 167 memcpy(p2 + 6, ia, 6); 168 memset(p2 + 12, 0, 4); 169 170 /* res = r XOR p1 */ 171 u128_xor((u128 *) res, (u128 *) r, (u128 *) p1); 172 173 /* res = e(k, res) */ 174 err = smp_e(tfm, k, res); 175 if (err) { 176 BT_ERR("Encrypt data error"); 177 return err; 178 } 179 180 /* res = res XOR p2 */ 181 u128_xor((u128 *) res, (u128 *) res, (u128 *) p2); 182 183 /* res = e(k, res) */ 184 err = smp_e(tfm, k, res); 185 if (err) 186 BT_ERR("Encrypt data error"); 187 188 return err; 189 } 190 191 static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], u8 r1[16], 192 u8 r2[16], u8 _r[16]) 193 { 194 int err; 195 196 /* Just least significant octets from r1 and r2 are considered */ 197 memcpy(_r, r2, 8); 198 memcpy(_r + 8, r1, 8); 199 200 err = smp_e(tfm, k, _r); 201 if (err) 202 BT_ERR("Encrypt data error"); 203 204 return err; 205 } 206 207 static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code, 208 u16 dlen, void *data) 209 { 210 struct sk_buff *skb; 211 struct l2cap_hdr *lh; 212 int len; 213 214 len = L2CAP_HDR_SIZE + sizeof(code) + dlen; 215 216 if (len > conn->mtu) 217 return NULL; 218 219 skb = bt_skb_alloc(len, GFP_ATOMIC); 220 if (!skb) 221 return NULL; 222 223 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 224 lh->len = cpu_to_le16(sizeof(code) + dlen); 225 lh->cid = cpu_to_le16(L2CAP_CID_SMP); 226 227 memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code)); 228 229 memcpy(skb_put(skb, dlen), data, dlen); 230 231 return skb; 232 } 233 234 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data) 235 { 236 struct sk_buff *skb = smp_build_cmd(conn, code, len, data); 237 238 BT_DBG("code 0x%2.2x", code); 239 240 if (!skb) 241 return; 242 243 skb->priority = HCI_PRIO_MAX; 244 hci_send_acl(conn->hchan, skb, 0); 245 246 cancel_delayed_work_sync(&conn->security_timer); 247 schedule_delayed_work(&conn->security_timer, SMP_TIMEOUT); 248 } 249 250 static __u8 authreq_to_seclevel(__u8 authreq) 251 { 252 if (authreq & SMP_AUTH_MITM) 253 return BT_SECURITY_HIGH; 254 else 255 return BT_SECURITY_MEDIUM; 256 } 257 258 static __u8 seclevel_to_authreq(__u8 sec_level) 259 { 260 switch (sec_level) { 261 case BT_SECURITY_HIGH: 262 return SMP_AUTH_MITM | SMP_AUTH_BONDING; 263 case BT_SECURITY_MEDIUM: 264 return SMP_AUTH_BONDING; 265 default: 266 return SMP_AUTH_NONE; 267 } 268 } 269 270 static void build_pairing_cmd(struct l2cap_conn *conn, 271 struct smp_cmd_pairing *req, 272 struct smp_cmd_pairing *rsp, __u8 authreq) 273 { 274 struct smp_chan *smp = conn->smp_chan; 275 struct hci_conn *hcon = conn->hcon; 276 struct hci_dev *hdev = hcon->hdev; 277 u8 local_dist = 0, remote_dist = 0; 278 279 if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->dev_flags)) { 280 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN; 281 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN; 282 authreq |= SMP_AUTH_BONDING; 283 } else { 284 authreq &= ~SMP_AUTH_BONDING; 285 } 286 287 if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags)) 288 remote_dist |= SMP_DIST_ID_KEY; 289 290 if (test_bit(HCI_PRIVACY, &hdev->dev_flags)) 291 local_dist |= SMP_DIST_ID_KEY; 292 293 if (rsp == NULL) { 294 req->io_capability = conn->hcon->io_capability; 295 req->oob_flag = SMP_OOB_NOT_PRESENT; 296 req->max_key_size = SMP_MAX_ENC_KEY_SIZE; 297 req->init_key_dist = local_dist; 298 req->resp_key_dist = remote_dist; 299 req->auth_req = (authreq & AUTH_REQ_MASK); 300 301 smp->remote_key_dist = remote_dist; 302 return; 303 } 304 305 rsp->io_capability = conn->hcon->io_capability; 306 rsp->oob_flag = SMP_OOB_NOT_PRESENT; 307 rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE; 308 rsp->init_key_dist = req->init_key_dist & remote_dist; 309 rsp->resp_key_dist = req->resp_key_dist & local_dist; 310 rsp->auth_req = (authreq & AUTH_REQ_MASK); 311 312 smp->remote_key_dist = rsp->init_key_dist; 313 } 314 315 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size) 316 { 317 struct smp_chan *smp = conn->smp_chan; 318 319 if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) || 320 (max_key_size < SMP_MIN_ENC_KEY_SIZE)) 321 return SMP_ENC_KEY_SIZE; 322 323 smp->enc_key_size = max_key_size; 324 325 return 0; 326 } 327 328 static void smp_failure(struct l2cap_conn *conn, u8 reason) 329 { 330 struct hci_conn *hcon = conn->hcon; 331 332 if (reason) 333 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason), 334 &reason); 335 336 clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags); 337 mgmt_auth_failed(hcon->hdev, &hcon->dst, hcon->type, hcon->dst_type, 338 HCI_ERROR_AUTH_FAILURE); 339 340 cancel_delayed_work_sync(&conn->security_timer); 341 342 if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) 343 smp_chan_destroy(conn); 344 } 345 346 #define JUST_WORKS 0x00 347 #define JUST_CFM 0x01 348 #define REQ_PASSKEY 0x02 349 #define CFM_PASSKEY 0x03 350 #define REQ_OOB 0x04 351 #define OVERLAP 0xFF 352 353 static const u8 gen_method[5][5] = { 354 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY }, 355 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY }, 356 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY }, 357 { JUST_WORKS, JUST_CFM, JUST_WORKS, JUST_WORKS, JUST_CFM }, 358 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP }, 359 }; 360 361 static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth, 362 u8 local_io, u8 remote_io) 363 { 364 struct hci_conn *hcon = conn->hcon; 365 struct smp_chan *smp = conn->smp_chan; 366 u8 method; 367 u32 passkey = 0; 368 int ret = 0; 369 370 /* Initialize key for JUST WORKS */ 371 memset(smp->tk, 0, sizeof(smp->tk)); 372 clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags); 373 374 BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io); 375 376 /* If neither side wants MITM, use JUST WORKS */ 377 /* If either side has unknown io_caps, use JUST WORKS */ 378 /* Otherwise, look up method from the table */ 379 if (!(auth & SMP_AUTH_MITM) || 380 local_io > SMP_IO_KEYBOARD_DISPLAY || 381 remote_io > SMP_IO_KEYBOARD_DISPLAY) 382 method = JUST_WORKS; 383 else 384 method = gen_method[remote_io][local_io]; 385 386 /* If not bonding, don't ask user to confirm a Zero TK */ 387 if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM) 388 method = JUST_WORKS; 389 390 /* Don't confirm locally initiated pairing attempts */ 391 if (method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR, 392 &smp->smp_flags)) 393 method = JUST_WORKS; 394 395 /* If Just Works, Continue with Zero TK */ 396 if (method == JUST_WORKS) { 397 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags); 398 return 0; 399 } 400 401 /* Not Just Works/Confirm results in MITM Authentication */ 402 if (method != JUST_CFM) 403 set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags); 404 405 /* If both devices have Keyoard-Display I/O, the master 406 * Confirms and the slave Enters the passkey. 407 */ 408 if (method == OVERLAP) { 409 if (hcon->link_mode & HCI_LM_MASTER) 410 method = CFM_PASSKEY; 411 else 412 method = REQ_PASSKEY; 413 } 414 415 /* Generate random passkey. */ 416 if (method == CFM_PASSKEY) { 417 memset(smp->tk, 0, sizeof(smp->tk)); 418 get_random_bytes(&passkey, sizeof(passkey)); 419 passkey %= 1000000; 420 put_unaligned_le32(passkey, smp->tk); 421 BT_DBG("PassKey: %d", passkey); 422 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags); 423 } 424 425 hci_dev_lock(hcon->hdev); 426 427 if (method == REQ_PASSKEY) 428 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst, 429 hcon->type, hcon->dst_type); 430 else if (method == JUST_CFM) 431 ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst, 432 hcon->type, hcon->dst_type, 433 passkey, 1); 434 else 435 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst, 436 hcon->type, hcon->dst_type, 437 passkey, 0); 438 439 hci_dev_unlock(hcon->hdev); 440 441 return ret; 442 } 443 444 static void confirm_work(struct work_struct *work) 445 { 446 struct smp_chan *smp = container_of(work, struct smp_chan, confirm); 447 struct l2cap_conn *conn = smp->conn; 448 struct hci_dev *hdev = conn->hcon->hdev; 449 struct crypto_blkcipher *tfm = hdev->tfm_aes; 450 struct smp_cmd_pairing_confirm cp; 451 int ret; 452 u8 reason; 453 454 BT_DBG("conn %p", conn); 455 456 /* Prevent mutual access to hdev->tfm_aes */ 457 hci_dev_lock(hdev); 458 459 ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp, 460 conn->hcon->init_addr_type, &conn->hcon->init_addr, 461 conn->hcon->resp_addr_type, &conn->hcon->resp_addr, 462 cp.confirm_val); 463 464 hci_dev_unlock(hdev); 465 466 if (ret) { 467 reason = SMP_UNSPECIFIED; 468 goto error; 469 } 470 471 clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags); 472 473 smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp); 474 475 return; 476 477 error: 478 smp_failure(conn, reason); 479 } 480 481 static void random_work(struct work_struct *work) 482 { 483 struct smp_chan *smp = container_of(work, struct smp_chan, random); 484 struct l2cap_conn *conn = smp->conn; 485 struct hci_conn *hcon = conn->hcon; 486 struct hci_dev *hdev = hcon->hdev; 487 struct crypto_blkcipher *tfm = hdev->tfm_aes; 488 u8 reason, confirm[16]; 489 int ret; 490 491 if (IS_ERR_OR_NULL(tfm)) { 492 reason = SMP_UNSPECIFIED; 493 goto error; 494 } 495 496 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave"); 497 498 /* Prevent mutual access to hdev->tfm_aes */ 499 hci_dev_lock(hdev); 500 501 ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp, 502 hcon->init_addr_type, &hcon->init_addr, 503 hcon->resp_addr_type, &hcon->resp_addr, confirm); 504 505 hci_dev_unlock(hdev); 506 507 if (ret) { 508 reason = SMP_UNSPECIFIED; 509 goto error; 510 } 511 512 if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) { 513 BT_ERR("Pairing failed (confirmation values mismatch)"); 514 reason = SMP_CONFIRM_FAILED; 515 goto error; 516 } 517 518 if (hcon->out) { 519 u8 stk[16]; 520 __le64 rand = 0; 521 __le16 ediv = 0; 522 523 smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, stk); 524 525 memset(stk + smp->enc_key_size, 0, 526 SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size); 527 528 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) { 529 reason = SMP_UNSPECIFIED; 530 goto error; 531 } 532 533 hci_le_start_enc(hcon, ediv, rand, stk); 534 hcon->enc_key_size = smp->enc_key_size; 535 } else { 536 u8 stk[16]; 537 __le64 rand = 0; 538 __le16 ediv = 0; 539 540 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd), 541 smp->prnd); 542 543 smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, stk); 544 545 memset(stk + smp->enc_key_size, 0, 546 SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size); 547 548 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, 549 HCI_SMP_STK_SLAVE, 0, stk, smp->enc_key_size, 550 ediv, rand); 551 } 552 553 return; 554 555 error: 556 smp_failure(conn, reason); 557 } 558 559 static struct smp_chan *smp_chan_create(struct l2cap_conn *conn) 560 { 561 struct smp_chan *smp; 562 563 smp = kzalloc(sizeof(*smp), GFP_ATOMIC); 564 if (!smp) 565 return NULL; 566 567 INIT_WORK(&smp->confirm, confirm_work); 568 INIT_WORK(&smp->random, random_work); 569 570 smp->conn = conn; 571 conn->smp_chan = smp; 572 conn->hcon->smp_conn = conn; 573 574 hci_conn_hold(conn->hcon); 575 576 return smp; 577 } 578 579 void smp_chan_destroy(struct l2cap_conn *conn) 580 { 581 struct smp_chan *smp = conn->smp_chan; 582 bool complete; 583 584 BUG_ON(!smp); 585 586 complete = test_bit(SMP_FLAG_COMPLETE, &smp->smp_flags); 587 mgmt_smp_complete(conn->hcon, complete); 588 589 kfree(smp->csrk); 590 kfree(smp->slave_csrk); 591 592 /* If pairing failed clean up any keys we might have */ 593 if (!complete) { 594 if (smp->ltk) { 595 list_del(&smp->ltk->list); 596 kfree(smp->ltk); 597 } 598 599 if (smp->slave_ltk) { 600 list_del(&smp->slave_ltk->list); 601 kfree(smp->slave_ltk); 602 } 603 604 if (smp->remote_irk) { 605 list_del(&smp->remote_irk->list); 606 kfree(smp->remote_irk); 607 } 608 } 609 610 kfree(smp); 611 conn->smp_chan = NULL; 612 conn->hcon->smp_conn = NULL; 613 hci_conn_drop(conn->hcon); 614 } 615 616 int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey) 617 { 618 struct l2cap_conn *conn = hcon->smp_conn; 619 struct smp_chan *smp; 620 u32 value; 621 622 BT_DBG(""); 623 624 if (!conn) 625 return -ENOTCONN; 626 627 smp = conn->smp_chan; 628 629 switch (mgmt_op) { 630 case MGMT_OP_USER_PASSKEY_REPLY: 631 value = le32_to_cpu(passkey); 632 memset(smp->tk, 0, sizeof(smp->tk)); 633 BT_DBG("PassKey: %d", value); 634 put_unaligned_le32(value, smp->tk); 635 /* Fall Through */ 636 case MGMT_OP_USER_CONFIRM_REPLY: 637 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags); 638 break; 639 case MGMT_OP_USER_PASSKEY_NEG_REPLY: 640 case MGMT_OP_USER_CONFIRM_NEG_REPLY: 641 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED); 642 return 0; 643 default: 644 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED); 645 return -EOPNOTSUPP; 646 } 647 648 /* If it is our turn to send Pairing Confirm, do so now */ 649 if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags)) 650 queue_work(hcon->hdev->workqueue, &smp->confirm); 651 652 return 0; 653 } 654 655 static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb) 656 { 657 struct smp_cmd_pairing rsp, *req = (void *) skb->data; 658 struct smp_chan *smp; 659 u8 key_size; 660 u8 auth = SMP_AUTH_NONE; 661 int ret; 662 663 BT_DBG("conn %p", conn); 664 665 if (skb->len < sizeof(*req)) 666 return SMP_UNSPECIFIED; 667 668 if (conn->hcon->link_mode & HCI_LM_MASTER) 669 return SMP_CMD_NOTSUPP; 670 671 if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) 672 smp = smp_chan_create(conn); 673 else 674 smp = conn->smp_chan; 675 676 if (!smp) 677 return SMP_UNSPECIFIED; 678 679 smp->preq[0] = SMP_CMD_PAIRING_REQ; 680 memcpy(&smp->preq[1], req, sizeof(*req)); 681 skb_pull(skb, sizeof(*req)); 682 683 /* We didn't start the pairing, so match remote */ 684 if (req->auth_req & SMP_AUTH_BONDING) 685 auth = req->auth_req; 686 687 conn->hcon->pending_sec_level = authreq_to_seclevel(auth); 688 689 build_pairing_cmd(conn, req, &rsp, auth); 690 691 key_size = min(req->max_key_size, rsp.max_key_size); 692 if (check_enc_key_size(conn, key_size)) 693 return SMP_ENC_KEY_SIZE; 694 695 get_random_bytes(smp->prnd, sizeof(smp->prnd)); 696 697 smp->prsp[0] = SMP_CMD_PAIRING_RSP; 698 memcpy(&smp->prsp[1], &rsp, sizeof(rsp)); 699 700 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp); 701 702 /* Request setup of TK */ 703 ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability); 704 if (ret) 705 return SMP_UNSPECIFIED; 706 707 clear_bit(SMP_FLAG_INITIATOR, &smp->smp_flags); 708 709 return 0; 710 } 711 712 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb) 713 { 714 struct smp_cmd_pairing *req, *rsp = (void *) skb->data; 715 struct smp_chan *smp = conn->smp_chan; 716 struct hci_dev *hdev = conn->hcon->hdev; 717 u8 key_size, auth = SMP_AUTH_NONE; 718 int ret; 719 720 BT_DBG("conn %p", conn); 721 722 if (skb->len < sizeof(*rsp)) 723 return SMP_UNSPECIFIED; 724 725 if (!(conn->hcon->link_mode & HCI_LM_MASTER)) 726 return SMP_CMD_NOTSUPP; 727 728 skb_pull(skb, sizeof(*rsp)); 729 730 req = (void *) &smp->preq[1]; 731 732 key_size = min(req->max_key_size, rsp->max_key_size); 733 if (check_enc_key_size(conn, key_size)) 734 return SMP_ENC_KEY_SIZE; 735 736 get_random_bytes(smp->prnd, sizeof(smp->prnd)); 737 738 smp->prsp[0] = SMP_CMD_PAIRING_RSP; 739 memcpy(&smp->prsp[1], rsp, sizeof(*rsp)); 740 741 /* Update remote key distribution in case the remote cleared 742 * some bits that we had enabled in our request. 743 */ 744 smp->remote_key_dist &= rsp->resp_key_dist; 745 746 if ((req->auth_req & SMP_AUTH_BONDING) && 747 (rsp->auth_req & SMP_AUTH_BONDING)) 748 auth = SMP_AUTH_BONDING; 749 750 auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM; 751 752 ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability); 753 if (ret) 754 return SMP_UNSPECIFIED; 755 756 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags); 757 758 /* Can't compose response until we have been confirmed */ 759 if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags)) 760 queue_work(hdev->workqueue, &smp->confirm); 761 762 return 0; 763 } 764 765 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb) 766 { 767 struct smp_chan *smp = conn->smp_chan; 768 struct hci_dev *hdev = conn->hcon->hdev; 769 770 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave"); 771 772 if (skb->len < sizeof(smp->pcnf)) 773 return SMP_UNSPECIFIED; 774 775 memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf)); 776 skb_pull(skb, sizeof(smp->pcnf)); 777 778 if (conn->hcon->out) 779 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd), 780 smp->prnd); 781 else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags)) 782 queue_work(hdev->workqueue, &smp->confirm); 783 else 784 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags); 785 786 return 0; 787 } 788 789 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb) 790 { 791 struct smp_chan *smp = conn->smp_chan; 792 struct hci_dev *hdev = conn->hcon->hdev; 793 794 BT_DBG("conn %p", conn); 795 796 if (skb->len < sizeof(smp->rrnd)) 797 return SMP_UNSPECIFIED; 798 799 memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd)); 800 skb_pull(skb, sizeof(smp->rrnd)); 801 802 queue_work(hdev->workqueue, &smp->random); 803 804 return 0; 805 } 806 807 static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level) 808 { 809 struct smp_ltk *key; 810 struct hci_conn *hcon = conn->hcon; 811 812 key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type, 813 hcon->out); 814 if (!key) 815 return 0; 816 817 if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated) 818 return 0; 819 820 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) 821 return 1; 822 823 hci_le_start_enc(hcon, key->ediv, key->rand, key->val); 824 hcon->enc_key_size = key->enc_size; 825 826 return 1; 827 } 828 829 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb) 830 { 831 struct smp_cmd_security_req *rp = (void *) skb->data; 832 struct smp_cmd_pairing cp; 833 struct hci_conn *hcon = conn->hcon; 834 struct smp_chan *smp; 835 836 BT_DBG("conn %p", conn); 837 838 if (skb->len < sizeof(*rp)) 839 return SMP_UNSPECIFIED; 840 841 if (!(conn->hcon->link_mode & HCI_LM_MASTER)) 842 return SMP_CMD_NOTSUPP; 843 844 hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req); 845 846 if (smp_ltk_encrypt(conn, hcon->pending_sec_level)) 847 return 0; 848 849 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) 850 return 0; 851 852 smp = smp_chan_create(conn); 853 854 skb_pull(skb, sizeof(*rp)); 855 856 memset(&cp, 0, sizeof(cp)); 857 build_pairing_cmd(conn, &cp, NULL, rp->auth_req); 858 859 smp->preq[0] = SMP_CMD_PAIRING_REQ; 860 memcpy(&smp->preq[1], &cp, sizeof(cp)); 861 862 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp); 863 864 clear_bit(SMP_FLAG_INITIATOR, &smp->smp_flags); 865 866 return 0; 867 } 868 869 bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level) 870 { 871 if (sec_level == BT_SECURITY_LOW) 872 return true; 873 874 if (hcon->sec_level >= sec_level) 875 return true; 876 877 return false; 878 } 879 880 int smp_conn_security(struct hci_conn *hcon, __u8 sec_level) 881 { 882 struct l2cap_conn *conn = hcon->l2cap_data; 883 struct smp_chan *smp; 884 __u8 authreq; 885 886 BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level); 887 888 /* This may be NULL if there's an unexpected disconnection */ 889 if (!conn) 890 return 1; 891 892 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) 893 return 1; 894 895 if (smp_sufficient_security(hcon, sec_level)) 896 return 1; 897 898 if (hcon->link_mode & HCI_LM_MASTER) 899 if (smp_ltk_encrypt(conn, sec_level)) 900 goto done; 901 902 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) 903 return 0; 904 905 smp = smp_chan_create(conn); 906 if (!smp) 907 return 1; 908 909 authreq = seclevel_to_authreq(sec_level); 910 911 /* hcon->auth_type is set by pair_device in mgmt.c. If the MITM 912 * flag is set we should also set it for the SMP request. 913 */ 914 if ((hcon->auth_type & 0x01)) 915 authreq |= SMP_AUTH_MITM; 916 917 if (hcon->link_mode & HCI_LM_MASTER) { 918 struct smp_cmd_pairing cp; 919 920 build_pairing_cmd(conn, &cp, NULL, authreq); 921 smp->preq[0] = SMP_CMD_PAIRING_REQ; 922 memcpy(&smp->preq[1], &cp, sizeof(cp)); 923 924 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp); 925 } else { 926 struct smp_cmd_security_req cp; 927 cp.auth_req = authreq; 928 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp); 929 } 930 931 set_bit(SMP_FLAG_INITIATOR, &smp->smp_flags); 932 933 done: 934 hcon->pending_sec_level = sec_level; 935 936 return 0; 937 } 938 939 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb) 940 { 941 struct smp_cmd_encrypt_info *rp = (void *) skb->data; 942 struct smp_chan *smp = conn->smp_chan; 943 944 BT_DBG("conn %p", conn); 945 946 if (skb->len < sizeof(*rp)) 947 return SMP_UNSPECIFIED; 948 949 /* Ignore this PDU if it wasn't requested */ 950 if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY)) 951 return 0; 952 953 skb_pull(skb, sizeof(*rp)); 954 955 memcpy(smp->tk, rp->ltk, sizeof(smp->tk)); 956 957 return 0; 958 } 959 960 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb) 961 { 962 struct smp_cmd_master_ident *rp = (void *) skb->data; 963 struct smp_chan *smp = conn->smp_chan; 964 struct hci_dev *hdev = conn->hcon->hdev; 965 struct hci_conn *hcon = conn->hcon; 966 struct smp_ltk *ltk; 967 u8 authenticated; 968 969 BT_DBG("conn %p", conn); 970 971 if (skb->len < sizeof(*rp)) 972 return SMP_UNSPECIFIED; 973 974 /* Ignore this PDU if it wasn't requested */ 975 if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY)) 976 return 0; 977 978 /* Mark the information as received */ 979 smp->remote_key_dist &= ~SMP_DIST_ENC_KEY; 980 981 skb_pull(skb, sizeof(*rp)); 982 983 hci_dev_lock(hdev); 984 authenticated = (hcon->sec_level == BT_SECURITY_HIGH); 985 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK, 986 authenticated, smp->tk, smp->enc_key_size, 987 rp->ediv, rp->rand); 988 smp->ltk = ltk; 989 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY)) 990 smp_distribute_keys(conn); 991 hci_dev_unlock(hdev); 992 993 return 0; 994 } 995 996 static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb) 997 { 998 struct smp_cmd_ident_info *info = (void *) skb->data; 999 struct smp_chan *smp = conn->smp_chan; 1000 1001 BT_DBG(""); 1002 1003 if (skb->len < sizeof(*info)) 1004 return SMP_UNSPECIFIED; 1005 1006 /* Ignore this PDU if it wasn't requested */ 1007 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY)) 1008 return 0; 1009 1010 skb_pull(skb, sizeof(*info)); 1011 1012 memcpy(smp->irk, info->irk, 16); 1013 1014 return 0; 1015 } 1016 1017 static int smp_cmd_ident_addr_info(struct l2cap_conn *conn, 1018 struct sk_buff *skb) 1019 { 1020 struct smp_cmd_ident_addr_info *info = (void *) skb->data; 1021 struct smp_chan *smp = conn->smp_chan; 1022 struct hci_conn *hcon = conn->hcon; 1023 bdaddr_t rpa; 1024 1025 BT_DBG(""); 1026 1027 if (skb->len < sizeof(*info)) 1028 return SMP_UNSPECIFIED; 1029 1030 /* Ignore this PDU if it wasn't requested */ 1031 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY)) 1032 return 0; 1033 1034 /* Mark the information as received */ 1035 smp->remote_key_dist &= ~SMP_DIST_ID_KEY; 1036 1037 skb_pull(skb, sizeof(*info)); 1038 1039 /* Strictly speaking the Core Specification (4.1) allows sending 1040 * an empty address which would force us to rely on just the IRK 1041 * as "identity information". However, since such 1042 * implementations are not known of and in order to not over 1043 * complicate our implementation, simply pretend that we never 1044 * received an IRK for such a device. 1045 */ 1046 if (!bacmp(&info->bdaddr, BDADDR_ANY)) { 1047 BT_ERR("Ignoring IRK with no identity address"); 1048 smp_distribute_keys(conn); 1049 return 0; 1050 } 1051 1052 bacpy(&smp->id_addr, &info->bdaddr); 1053 smp->id_addr_type = info->addr_type; 1054 1055 if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type)) 1056 bacpy(&rpa, &hcon->dst); 1057 else 1058 bacpy(&rpa, BDADDR_ANY); 1059 1060 smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr, 1061 smp->id_addr_type, smp->irk, &rpa); 1062 1063 smp_distribute_keys(conn); 1064 1065 return 0; 1066 } 1067 1068 static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb) 1069 { 1070 struct smp_cmd_sign_info *rp = (void *) skb->data; 1071 struct smp_chan *smp = conn->smp_chan; 1072 struct hci_dev *hdev = conn->hcon->hdev; 1073 struct smp_csrk *csrk; 1074 1075 BT_DBG("conn %p", conn); 1076 1077 if (skb->len < sizeof(*rp)) 1078 return SMP_UNSPECIFIED; 1079 1080 /* Ignore this PDU if it wasn't requested */ 1081 if (!(smp->remote_key_dist & SMP_DIST_SIGN)) 1082 return 0; 1083 1084 /* Mark the information as received */ 1085 smp->remote_key_dist &= ~SMP_DIST_SIGN; 1086 1087 skb_pull(skb, sizeof(*rp)); 1088 1089 hci_dev_lock(hdev); 1090 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL); 1091 if (csrk) { 1092 csrk->master = 0x01; 1093 memcpy(csrk->val, rp->csrk, sizeof(csrk->val)); 1094 } 1095 smp->csrk = csrk; 1096 if (!(smp->remote_key_dist & SMP_DIST_SIGN)) 1097 smp_distribute_keys(conn); 1098 hci_dev_unlock(hdev); 1099 1100 return 0; 1101 } 1102 1103 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb) 1104 { 1105 struct hci_conn *hcon = conn->hcon; 1106 __u8 code, reason; 1107 int err = 0; 1108 1109 if (hcon->type != LE_LINK) { 1110 kfree_skb(skb); 1111 return 0; 1112 } 1113 1114 if (skb->len < 1) { 1115 kfree_skb(skb); 1116 return -EILSEQ; 1117 } 1118 1119 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) { 1120 err = -ENOTSUPP; 1121 reason = SMP_PAIRING_NOTSUPP; 1122 goto done; 1123 } 1124 1125 code = skb->data[0]; 1126 skb_pull(skb, sizeof(code)); 1127 1128 /* 1129 * The SMP context must be initialized for all other PDUs except 1130 * pairing and security requests. If we get any other PDU when 1131 * not initialized simply disconnect (done if this function 1132 * returns an error). 1133 */ 1134 if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ && 1135 !conn->smp_chan) { 1136 BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code); 1137 kfree_skb(skb); 1138 return -ENOTSUPP; 1139 } 1140 1141 switch (code) { 1142 case SMP_CMD_PAIRING_REQ: 1143 reason = smp_cmd_pairing_req(conn, skb); 1144 break; 1145 1146 case SMP_CMD_PAIRING_FAIL: 1147 smp_failure(conn, 0); 1148 reason = 0; 1149 err = -EPERM; 1150 break; 1151 1152 case SMP_CMD_PAIRING_RSP: 1153 reason = smp_cmd_pairing_rsp(conn, skb); 1154 break; 1155 1156 case SMP_CMD_SECURITY_REQ: 1157 reason = smp_cmd_security_req(conn, skb); 1158 break; 1159 1160 case SMP_CMD_PAIRING_CONFIRM: 1161 reason = smp_cmd_pairing_confirm(conn, skb); 1162 break; 1163 1164 case SMP_CMD_PAIRING_RANDOM: 1165 reason = smp_cmd_pairing_random(conn, skb); 1166 break; 1167 1168 case SMP_CMD_ENCRYPT_INFO: 1169 reason = smp_cmd_encrypt_info(conn, skb); 1170 break; 1171 1172 case SMP_CMD_MASTER_IDENT: 1173 reason = smp_cmd_master_ident(conn, skb); 1174 break; 1175 1176 case SMP_CMD_IDENT_INFO: 1177 reason = smp_cmd_ident_info(conn, skb); 1178 break; 1179 1180 case SMP_CMD_IDENT_ADDR_INFO: 1181 reason = smp_cmd_ident_addr_info(conn, skb); 1182 break; 1183 1184 case SMP_CMD_SIGN_INFO: 1185 reason = smp_cmd_sign_info(conn, skb); 1186 break; 1187 1188 default: 1189 BT_DBG("Unknown command code 0x%2.2x", code); 1190 1191 reason = SMP_CMD_NOTSUPP; 1192 err = -EOPNOTSUPP; 1193 goto done; 1194 } 1195 1196 done: 1197 if (reason) 1198 smp_failure(conn, reason); 1199 1200 kfree_skb(skb); 1201 return err; 1202 } 1203 1204 static void smp_notify_keys(struct l2cap_conn *conn) 1205 { 1206 struct smp_chan *smp = conn->smp_chan; 1207 struct hci_conn *hcon = conn->hcon; 1208 struct hci_dev *hdev = hcon->hdev; 1209 struct smp_cmd_pairing *req = (void *) &smp->preq[1]; 1210 struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1]; 1211 bool persistent; 1212 1213 if (smp->remote_irk) { 1214 mgmt_new_irk(hdev, smp->remote_irk); 1215 /* Now that user space can be considered to know the 1216 * identity address track the connection based on it 1217 * from now on. 1218 */ 1219 bacpy(&hcon->dst, &smp->remote_irk->bdaddr); 1220 hcon->dst_type = smp->remote_irk->addr_type; 1221 l2cap_conn_update_id_addr(hcon); 1222 } 1223 1224 /* The LTKs and CSRKs should be persistent only if both sides 1225 * had the bonding bit set in their authentication requests. 1226 */ 1227 persistent = !!((req->auth_req & rsp->auth_req) & SMP_AUTH_BONDING); 1228 1229 if (smp->csrk) { 1230 smp->csrk->bdaddr_type = hcon->dst_type; 1231 bacpy(&smp->csrk->bdaddr, &hcon->dst); 1232 mgmt_new_csrk(hdev, smp->csrk, persistent); 1233 } 1234 1235 if (smp->slave_csrk) { 1236 smp->slave_csrk->bdaddr_type = hcon->dst_type; 1237 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst); 1238 mgmt_new_csrk(hdev, smp->slave_csrk, persistent); 1239 } 1240 1241 if (smp->ltk) { 1242 smp->ltk->bdaddr_type = hcon->dst_type; 1243 bacpy(&smp->ltk->bdaddr, &hcon->dst); 1244 mgmt_new_ltk(hdev, smp->ltk, persistent); 1245 } 1246 1247 if (smp->slave_ltk) { 1248 smp->slave_ltk->bdaddr_type = hcon->dst_type; 1249 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst); 1250 mgmt_new_ltk(hdev, smp->slave_ltk, persistent); 1251 } 1252 } 1253 1254 int smp_distribute_keys(struct l2cap_conn *conn) 1255 { 1256 struct smp_cmd_pairing *req, *rsp; 1257 struct smp_chan *smp = conn->smp_chan; 1258 struct hci_conn *hcon = conn->hcon; 1259 struct hci_dev *hdev = hcon->hdev; 1260 __u8 *keydist; 1261 1262 BT_DBG("conn %p", conn); 1263 1264 if (!test_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) 1265 return 0; 1266 1267 rsp = (void *) &smp->prsp[1]; 1268 1269 /* The responder sends its keys first */ 1270 if (hcon->out && (smp->remote_key_dist & 0x07)) 1271 return 0; 1272 1273 req = (void *) &smp->preq[1]; 1274 1275 if (hcon->out) { 1276 keydist = &rsp->init_key_dist; 1277 *keydist &= req->init_key_dist; 1278 } else { 1279 keydist = &rsp->resp_key_dist; 1280 *keydist &= req->resp_key_dist; 1281 } 1282 1283 BT_DBG("keydist 0x%x", *keydist); 1284 1285 if (*keydist & SMP_DIST_ENC_KEY) { 1286 struct smp_cmd_encrypt_info enc; 1287 struct smp_cmd_master_ident ident; 1288 struct smp_ltk *ltk; 1289 u8 authenticated; 1290 __le16 ediv; 1291 __le64 rand; 1292 1293 get_random_bytes(enc.ltk, sizeof(enc.ltk)); 1294 get_random_bytes(&ediv, sizeof(ediv)); 1295 get_random_bytes(&rand, sizeof(rand)); 1296 1297 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc); 1298 1299 authenticated = hcon->sec_level == BT_SECURITY_HIGH; 1300 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, 1301 HCI_SMP_LTK_SLAVE, authenticated, enc.ltk, 1302 smp->enc_key_size, ediv, rand); 1303 smp->slave_ltk = ltk; 1304 1305 ident.ediv = ediv; 1306 ident.rand = rand; 1307 1308 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident); 1309 1310 *keydist &= ~SMP_DIST_ENC_KEY; 1311 } 1312 1313 if (*keydist & SMP_DIST_ID_KEY) { 1314 struct smp_cmd_ident_addr_info addrinfo; 1315 struct smp_cmd_ident_info idinfo; 1316 1317 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk)); 1318 1319 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo); 1320 1321 /* The hci_conn contains the local identity address 1322 * after the connection has been established. 1323 * 1324 * This is true even when the connection has been 1325 * established using a resolvable random address. 1326 */ 1327 bacpy(&addrinfo.bdaddr, &hcon->src); 1328 addrinfo.addr_type = hcon->src_type; 1329 1330 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo), 1331 &addrinfo); 1332 1333 *keydist &= ~SMP_DIST_ID_KEY; 1334 } 1335 1336 if (*keydist & SMP_DIST_SIGN) { 1337 struct smp_cmd_sign_info sign; 1338 struct smp_csrk *csrk; 1339 1340 /* Generate a new random key */ 1341 get_random_bytes(sign.csrk, sizeof(sign.csrk)); 1342 1343 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL); 1344 if (csrk) { 1345 csrk->master = 0x00; 1346 memcpy(csrk->val, sign.csrk, sizeof(csrk->val)); 1347 } 1348 smp->slave_csrk = csrk; 1349 1350 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign); 1351 1352 *keydist &= ~SMP_DIST_SIGN; 1353 } 1354 1355 /* If there are still keys to be received wait for them */ 1356 if ((smp->remote_key_dist & 0x07)) 1357 return 0; 1358 1359 clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags); 1360 cancel_delayed_work_sync(&conn->security_timer); 1361 set_bit(SMP_FLAG_COMPLETE, &smp->smp_flags); 1362 smp_notify_keys(conn); 1363 1364 smp_chan_destroy(conn); 1365 1366 return 0; 1367 } 1368