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