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