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 <net/bluetooth/bluetooth.h> 24 #include <net/bluetooth/hci_core.h> 25 #include <net/bluetooth/l2cap.h> 26 #include <net/bluetooth/mgmt.h> 27 #include <net/bluetooth/smp.h> 28 #include <linux/crypto.h> 29 #include <linux/scatterlist.h> 30 #include <crypto/b128ops.h> 31 32 #define SMP_TIMEOUT 30000 /* 30 seconds */ 33 34 static inline void swap128(u8 src[16], u8 dst[16]) 35 { 36 int i; 37 for (i = 0; i < 16; i++) 38 dst[15 - i] = src[i]; 39 } 40 41 static inline void swap56(u8 src[7], u8 dst[7]) 42 { 43 int i; 44 for (i = 0; i < 7; i++) 45 dst[6 - i] = src[i]; 46 } 47 48 static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r) 49 { 50 struct blkcipher_desc desc; 51 struct scatterlist sg; 52 int err, iv_len; 53 unsigned char iv[128]; 54 55 if (tfm == NULL) { 56 BT_ERR("tfm %p", tfm); 57 return -EINVAL; 58 } 59 60 desc.tfm = tfm; 61 desc.flags = 0; 62 63 err = crypto_blkcipher_setkey(tfm, k, 16); 64 if (err) { 65 BT_ERR("cipher setkey failed: %d", err); 66 return err; 67 } 68 69 sg_init_one(&sg, r, 16); 70 71 iv_len = crypto_blkcipher_ivsize(tfm); 72 if (iv_len) { 73 memset(&iv, 0xff, iv_len); 74 crypto_blkcipher_set_iv(tfm, iv, iv_len); 75 } 76 77 err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16); 78 if (err) 79 BT_ERR("Encrypt data error %d", err); 80 81 return err; 82 } 83 84 static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16], 85 u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia, 86 u8 _rat, bdaddr_t *ra, u8 res[16]) 87 { 88 u8 p1[16], p2[16]; 89 int err; 90 91 memset(p1, 0, 16); 92 93 /* p1 = pres || preq || _rat || _iat */ 94 swap56(pres, p1); 95 swap56(preq, p1 + 7); 96 p1[14] = _rat; 97 p1[15] = _iat; 98 99 memset(p2, 0, 16); 100 101 /* p2 = padding || ia || ra */ 102 baswap((bdaddr_t *) (p2 + 4), ia); 103 baswap((bdaddr_t *) (p2 + 10), ra); 104 105 /* res = r XOR p1 */ 106 u128_xor((u128 *) res, (u128 *) r, (u128 *) p1); 107 108 /* res = e(k, res) */ 109 err = smp_e(tfm, k, res); 110 if (err) { 111 BT_ERR("Encrypt data error"); 112 return err; 113 } 114 115 /* res = res XOR p2 */ 116 u128_xor((u128 *) res, (u128 *) res, (u128 *) p2); 117 118 /* res = e(k, res) */ 119 err = smp_e(tfm, k, res); 120 if (err) 121 BT_ERR("Encrypt data error"); 122 123 return err; 124 } 125 126 static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], 127 u8 r1[16], u8 r2[16], u8 _r[16]) 128 { 129 int err; 130 131 /* Just least significant octets from r1 and r2 are considered */ 132 memcpy(_r, r1 + 8, 8); 133 memcpy(_r + 8, r2 + 8, 8); 134 135 err = smp_e(tfm, k, _r); 136 if (err) 137 BT_ERR("Encrypt data error"); 138 139 return err; 140 } 141 142 static int smp_rand(u8 *buf) 143 { 144 get_random_bytes(buf, 16); 145 146 return 0; 147 } 148 149 static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code, 150 u16 dlen, void *data) 151 { 152 struct sk_buff *skb; 153 struct l2cap_hdr *lh; 154 int len; 155 156 len = L2CAP_HDR_SIZE + sizeof(code) + dlen; 157 158 if (len > conn->mtu) 159 return NULL; 160 161 skb = bt_skb_alloc(len, GFP_ATOMIC); 162 if (!skb) 163 return NULL; 164 165 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 166 lh->len = cpu_to_le16(sizeof(code) + dlen); 167 lh->cid = cpu_to_le16(L2CAP_CID_SMP); 168 169 memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code)); 170 171 memcpy(skb_put(skb, dlen), data, dlen); 172 173 return skb; 174 } 175 176 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data) 177 { 178 struct sk_buff *skb = smp_build_cmd(conn, code, len, data); 179 180 BT_DBG("code 0x%2.2x", code); 181 182 if (!skb) 183 return; 184 185 skb->priority = HCI_PRIO_MAX; 186 hci_send_acl(conn->hchan, skb, 0); 187 188 cancel_delayed_work_sync(&conn->security_timer); 189 schedule_delayed_work(&conn->security_timer, 190 msecs_to_jiffies(SMP_TIMEOUT)); 191 } 192 193 static __u8 authreq_to_seclevel(__u8 authreq) 194 { 195 if (authreq & SMP_AUTH_MITM) 196 return BT_SECURITY_HIGH; 197 else 198 return BT_SECURITY_MEDIUM; 199 } 200 201 static __u8 seclevel_to_authreq(__u8 sec_level) 202 { 203 switch (sec_level) { 204 case BT_SECURITY_HIGH: 205 return SMP_AUTH_MITM | SMP_AUTH_BONDING; 206 case BT_SECURITY_MEDIUM: 207 return SMP_AUTH_BONDING; 208 default: 209 return SMP_AUTH_NONE; 210 } 211 } 212 213 static void build_pairing_cmd(struct l2cap_conn *conn, 214 struct smp_cmd_pairing *req, 215 struct smp_cmd_pairing *rsp, 216 __u8 authreq) 217 { 218 u8 dist_keys = 0; 219 220 if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->flags)) { 221 dist_keys = SMP_DIST_ENC_KEY; 222 authreq |= SMP_AUTH_BONDING; 223 } else { 224 authreq &= ~SMP_AUTH_BONDING; 225 } 226 227 if (rsp == NULL) { 228 req->io_capability = conn->hcon->io_capability; 229 req->oob_flag = SMP_OOB_NOT_PRESENT; 230 req->max_key_size = SMP_MAX_ENC_KEY_SIZE; 231 req->init_key_dist = 0; 232 req->resp_key_dist = dist_keys; 233 req->auth_req = authreq; 234 return; 235 } 236 237 rsp->io_capability = conn->hcon->io_capability; 238 rsp->oob_flag = SMP_OOB_NOT_PRESENT; 239 rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE; 240 rsp->init_key_dist = 0; 241 rsp->resp_key_dist = req->resp_key_dist & dist_keys; 242 rsp->auth_req = authreq; 243 } 244 245 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size) 246 { 247 struct smp_chan *smp = conn->smp_chan; 248 249 if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) || 250 (max_key_size < SMP_MIN_ENC_KEY_SIZE)) 251 return SMP_ENC_KEY_SIZE; 252 253 smp->smp_key_size = max_key_size; 254 255 return 0; 256 } 257 258 static void smp_failure(struct l2cap_conn *conn, u8 reason, u8 send) 259 { 260 if (send) 261 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason), 262 &reason); 263 264 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->hcon->pend); 265 mgmt_auth_failed(conn->hcon->hdev, conn->dst, reason); 266 cancel_delayed_work_sync(&conn->security_timer); 267 smp_chan_destroy(conn); 268 } 269 270 #define JUST_WORKS 0x00 271 #define JUST_CFM 0x01 272 #define REQ_PASSKEY 0x02 273 #define CFM_PASSKEY 0x03 274 #define REQ_OOB 0x04 275 #define OVERLAP 0xFF 276 277 static const u8 gen_method[5][5] = { 278 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY }, 279 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY }, 280 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY }, 281 { JUST_WORKS, JUST_CFM, JUST_WORKS, JUST_WORKS, JUST_CFM }, 282 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP }, 283 }; 284 285 static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth, 286 u8 local_io, u8 remote_io) 287 { 288 struct hci_conn *hcon = conn->hcon; 289 struct smp_chan *smp = conn->smp_chan; 290 u8 method; 291 u32 passkey = 0; 292 int ret = 0; 293 294 /* Initialize key for JUST WORKS */ 295 memset(smp->tk, 0, sizeof(smp->tk)); 296 clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags); 297 298 BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io); 299 300 /* If neither side wants MITM, use JUST WORKS */ 301 /* If either side has unknown io_caps, use JUST WORKS */ 302 /* Otherwise, look up method from the table */ 303 if (!(auth & SMP_AUTH_MITM) || 304 local_io > SMP_IO_KEYBOARD_DISPLAY || 305 remote_io > SMP_IO_KEYBOARD_DISPLAY) 306 method = JUST_WORKS; 307 else 308 method = gen_method[local_io][remote_io]; 309 310 /* If not bonding, don't ask user to confirm a Zero TK */ 311 if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM) 312 method = JUST_WORKS; 313 314 /* If Just Works, Continue with Zero TK */ 315 if (method == JUST_WORKS) { 316 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags); 317 return 0; 318 } 319 320 /* Not Just Works/Confirm results in MITM Authentication */ 321 if (method != JUST_CFM) 322 set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags); 323 324 /* If both devices have Keyoard-Display I/O, the master 325 * Confirms and the slave Enters the passkey. 326 */ 327 if (method == OVERLAP) { 328 if (hcon->link_mode & HCI_LM_MASTER) 329 method = CFM_PASSKEY; 330 else 331 method = REQ_PASSKEY; 332 } 333 334 /* Generate random passkey. Not valid until confirmed. */ 335 if (method == CFM_PASSKEY) { 336 u8 key[16]; 337 338 memset(key, 0, sizeof(key)); 339 get_random_bytes(&passkey, sizeof(passkey)); 340 passkey %= 1000000; 341 put_unaligned_le32(passkey, key); 342 swap128(key, smp->tk); 343 BT_DBG("PassKey: %d", passkey); 344 } 345 346 hci_dev_lock(hcon->hdev); 347 348 if (method == REQ_PASSKEY) 349 ret = mgmt_user_passkey_request(hcon->hdev, conn->dst); 350 else 351 ret = mgmt_user_confirm_request(hcon->hdev, conn->dst, 352 cpu_to_le32(passkey), 0); 353 354 hci_dev_unlock(hcon->hdev); 355 356 return ret; 357 } 358 359 static void confirm_work(struct work_struct *work) 360 { 361 struct smp_chan *smp = container_of(work, struct smp_chan, confirm); 362 struct l2cap_conn *conn = smp->conn; 363 struct crypto_blkcipher *tfm; 364 struct smp_cmd_pairing_confirm cp; 365 int ret; 366 u8 res[16], reason; 367 368 BT_DBG("conn %p", conn); 369 370 tfm = crypto_alloc_blkcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC); 371 if (IS_ERR(tfm)) { 372 reason = SMP_UNSPECIFIED; 373 goto error; 374 } 375 376 smp->tfm = tfm; 377 378 if (conn->hcon->out) 379 ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp, 0, 380 conn->src, conn->hcon->dst_type, conn->dst, 381 res); 382 else 383 ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp, 384 conn->hcon->dst_type, conn->dst, 0, conn->src, 385 res); 386 if (ret) { 387 reason = SMP_UNSPECIFIED; 388 goto error; 389 } 390 391 clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags); 392 393 swap128(res, cp.confirm_val); 394 smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp); 395 396 return; 397 398 error: 399 smp_failure(conn, reason, 1); 400 } 401 402 static void random_work(struct work_struct *work) 403 { 404 struct smp_chan *smp = container_of(work, struct smp_chan, random); 405 struct l2cap_conn *conn = smp->conn; 406 struct hci_conn *hcon = conn->hcon; 407 struct crypto_blkcipher *tfm = smp->tfm; 408 u8 reason, confirm[16], res[16], key[16]; 409 int ret; 410 411 if (IS_ERR_OR_NULL(tfm)) { 412 reason = SMP_UNSPECIFIED; 413 goto error; 414 } 415 416 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave"); 417 418 if (hcon->out) 419 ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp, 0, 420 conn->src, hcon->dst_type, conn->dst, 421 res); 422 else 423 ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp, 424 hcon->dst_type, conn->dst, 0, conn->src, 425 res); 426 if (ret) { 427 reason = SMP_UNSPECIFIED; 428 goto error; 429 } 430 431 swap128(res, confirm); 432 433 if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) { 434 BT_ERR("Pairing failed (confirmation values mismatch)"); 435 reason = SMP_CONFIRM_FAILED; 436 goto error; 437 } 438 439 if (hcon->out) { 440 u8 stk[16], rand[8]; 441 __le16 ediv; 442 443 memset(rand, 0, sizeof(rand)); 444 ediv = 0; 445 446 smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, key); 447 swap128(key, stk); 448 449 memset(stk + smp->smp_key_size, 0, 450 SMP_MAX_ENC_KEY_SIZE - smp->smp_key_size); 451 452 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend)) { 453 reason = SMP_UNSPECIFIED; 454 goto error; 455 } 456 457 hci_le_start_enc(hcon, ediv, rand, stk); 458 hcon->enc_key_size = smp->smp_key_size; 459 } else { 460 u8 stk[16], r[16], rand[8]; 461 __le16 ediv; 462 463 memset(rand, 0, sizeof(rand)); 464 ediv = 0; 465 466 swap128(smp->prnd, r); 467 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(r), r); 468 469 smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, key); 470 swap128(key, stk); 471 472 memset(stk + smp->smp_key_size, 0, 473 SMP_MAX_ENC_KEY_SIZE - smp->smp_key_size); 474 475 hci_add_ltk(hcon->hdev, 0, conn->dst, smp->smp_key_size, 476 ediv, rand, stk); 477 } 478 479 return; 480 481 error: 482 smp_failure(conn, reason, 1); 483 } 484 485 static struct smp_chan *smp_chan_create(struct l2cap_conn *conn) 486 { 487 struct smp_chan *smp; 488 489 smp = kzalloc(sizeof(struct smp_chan), GFP_ATOMIC); 490 if (!smp) 491 return NULL; 492 493 INIT_WORK(&smp->confirm, confirm_work); 494 INIT_WORK(&smp->random, random_work); 495 496 smp->conn = conn; 497 conn->smp_chan = smp; 498 conn->hcon->smp_conn = conn; 499 500 hci_conn_hold(conn->hcon); 501 502 return smp; 503 } 504 505 void smp_chan_destroy(struct l2cap_conn *conn) 506 { 507 struct smp_chan *smp = conn->smp_chan; 508 509 clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->pend); 510 511 if (smp->tfm) 512 crypto_free_blkcipher(smp->tfm); 513 514 kfree(smp); 515 conn->smp_chan = NULL; 516 conn->hcon->smp_conn = NULL; 517 hci_conn_put(conn->hcon); 518 } 519 520 int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey) 521 { 522 struct l2cap_conn *conn = hcon->smp_conn; 523 struct smp_chan *smp; 524 u32 value; 525 u8 key[16]; 526 527 BT_DBG(""); 528 529 if (!conn) 530 return -ENOTCONN; 531 532 smp = conn->smp_chan; 533 534 switch (mgmt_op) { 535 case MGMT_OP_USER_PASSKEY_REPLY: 536 value = le32_to_cpu(passkey); 537 memset(key, 0, sizeof(key)); 538 BT_DBG("PassKey: %d", value); 539 put_unaligned_le32(value, key); 540 swap128(key, smp->tk); 541 /* Fall Through */ 542 case MGMT_OP_USER_CONFIRM_REPLY: 543 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags); 544 break; 545 case MGMT_OP_USER_PASSKEY_NEG_REPLY: 546 case MGMT_OP_USER_CONFIRM_NEG_REPLY: 547 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED, 1); 548 return 0; 549 default: 550 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED, 1); 551 return -EOPNOTSUPP; 552 } 553 554 /* If it is our turn to send Pairing Confirm, do so now */ 555 if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags)) 556 queue_work(hcon->hdev->workqueue, &smp->confirm); 557 558 return 0; 559 } 560 561 static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb) 562 { 563 struct smp_cmd_pairing rsp, *req = (void *) skb->data; 564 struct smp_chan *smp; 565 u8 key_size; 566 u8 auth = SMP_AUTH_NONE; 567 int ret; 568 569 BT_DBG("conn %p", conn); 570 571 if (conn->hcon->link_mode & HCI_LM_MASTER) 572 return SMP_CMD_NOTSUPP; 573 574 if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->pend)) 575 smp = smp_chan_create(conn); 576 577 smp = conn->smp_chan; 578 579 smp->preq[0] = SMP_CMD_PAIRING_REQ; 580 memcpy(&smp->preq[1], req, sizeof(*req)); 581 skb_pull(skb, sizeof(*req)); 582 583 /* We didn't start the pairing, so match remote */ 584 if (req->auth_req & SMP_AUTH_BONDING) 585 auth = req->auth_req; 586 587 build_pairing_cmd(conn, req, &rsp, auth); 588 589 key_size = min(req->max_key_size, rsp.max_key_size); 590 if (check_enc_key_size(conn, key_size)) 591 return SMP_ENC_KEY_SIZE; 592 593 ret = smp_rand(smp->prnd); 594 if (ret) 595 return SMP_UNSPECIFIED; 596 597 smp->prsp[0] = SMP_CMD_PAIRING_RSP; 598 memcpy(&smp->prsp[1], &rsp, sizeof(rsp)); 599 600 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp); 601 602 /* Request setup of TK */ 603 ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability); 604 if (ret) 605 return SMP_UNSPECIFIED; 606 607 return 0; 608 } 609 610 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb) 611 { 612 struct smp_cmd_pairing *req, *rsp = (void *) skb->data; 613 struct smp_chan *smp = conn->smp_chan; 614 struct hci_dev *hdev = conn->hcon->hdev; 615 u8 key_size, auth = SMP_AUTH_NONE; 616 int ret; 617 618 BT_DBG("conn %p", conn); 619 620 if (!(conn->hcon->link_mode & HCI_LM_MASTER)) 621 return SMP_CMD_NOTSUPP; 622 623 skb_pull(skb, sizeof(*rsp)); 624 625 req = (void *) &smp->preq[1]; 626 627 key_size = min(req->max_key_size, rsp->max_key_size); 628 if (check_enc_key_size(conn, key_size)) 629 return SMP_ENC_KEY_SIZE; 630 631 ret = smp_rand(smp->prnd); 632 if (ret) 633 return SMP_UNSPECIFIED; 634 635 smp->prsp[0] = SMP_CMD_PAIRING_RSP; 636 memcpy(&smp->prsp[1], rsp, sizeof(*rsp)); 637 638 if ((req->auth_req & SMP_AUTH_BONDING) && 639 (rsp->auth_req & SMP_AUTH_BONDING)) 640 auth = SMP_AUTH_BONDING; 641 642 auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM; 643 644 ret = tk_request(conn, 0, auth, rsp->io_capability, req->io_capability); 645 if (ret) 646 return SMP_UNSPECIFIED; 647 648 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags); 649 650 /* Can't compose response until we have been confirmed */ 651 if (!test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags)) 652 return 0; 653 654 queue_work(hdev->workqueue, &smp->confirm); 655 656 return 0; 657 } 658 659 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb) 660 { 661 struct smp_chan *smp = conn->smp_chan; 662 struct hci_dev *hdev = conn->hcon->hdev; 663 664 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave"); 665 666 memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf)); 667 skb_pull(skb, sizeof(smp->pcnf)); 668 669 if (conn->hcon->out) { 670 u8 random[16]; 671 672 swap128(smp->prnd, random); 673 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(random), 674 random); 675 } else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags)) { 676 queue_work(hdev->workqueue, &smp->confirm); 677 } else { 678 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags); 679 } 680 681 return 0; 682 } 683 684 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb) 685 { 686 struct smp_chan *smp = conn->smp_chan; 687 struct hci_dev *hdev = conn->hcon->hdev; 688 689 BT_DBG("conn %p", conn); 690 691 swap128(skb->data, smp->rrnd); 692 skb_pull(skb, sizeof(smp->rrnd)); 693 694 queue_work(hdev->workqueue, &smp->random); 695 696 return 0; 697 } 698 699 static u8 smp_ltk_encrypt(struct l2cap_conn *conn) 700 { 701 struct link_key *key; 702 struct key_master_id *master; 703 struct hci_conn *hcon = conn->hcon; 704 705 key = hci_find_link_key_type(hcon->hdev, conn->dst, 706 HCI_LK_SMP_LTK); 707 if (!key) 708 return 0; 709 710 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, 711 &hcon->pend)) 712 return 1; 713 714 master = (void *) key->data; 715 hci_le_start_enc(hcon, master->ediv, master->rand, 716 key->val); 717 hcon->enc_key_size = key->pin_len; 718 719 return 1; 720 721 } 722 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb) 723 { 724 struct smp_cmd_security_req *rp = (void *) skb->data; 725 struct smp_cmd_pairing cp; 726 struct hci_conn *hcon = conn->hcon; 727 struct smp_chan *smp; 728 729 BT_DBG("conn %p", conn); 730 731 hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req); 732 733 if (smp_ltk_encrypt(conn)) 734 return 0; 735 736 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->pend)) 737 return 0; 738 739 smp = smp_chan_create(conn); 740 741 skb_pull(skb, sizeof(*rp)); 742 743 memset(&cp, 0, sizeof(cp)); 744 build_pairing_cmd(conn, &cp, NULL, rp->auth_req); 745 746 smp->preq[0] = SMP_CMD_PAIRING_REQ; 747 memcpy(&smp->preq[1], &cp, sizeof(cp)); 748 749 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp); 750 751 return 0; 752 } 753 754 int smp_conn_security(struct l2cap_conn *conn, __u8 sec_level) 755 { 756 struct hci_conn *hcon = conn->hcon; 757 struct smp_chan *smp = conn->smp_chan; 758 __u8 authreq; 759 760 BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level); 761 762 if (!lmp_host_le_capable(hcon->hdev)) 763 return 1; 764 765 if (sec_level == BT_SECURITY_LOW) 766 return 1; 767 768 if (hcon->sec_level >= sec_level) 769 return 1; 770 771 if (hcon->link_mode & HCI_LM_MASTER) 772 if (smp_ltk_encrypt(conn)) 773 goto done; 774 775 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->pend)) 776 return 0; 777 778 smp = smp_chan_create(conn); 779 if (!smp) 780 return 1; 781 782 authreq = seclevel_to_authreq(sec_level); 783 784 if (hcon->link_mode & HCI_LM_MASTER) { 785 struct smp_cmd_pairing cp; 786 787 build_pairing_cmd(conn, &cp, NULL, authreq); 788 smp->preq[0] = SMP_CMD_PAIRING_REQ; 789 memcpy(&smp->preq[1], &cp, sizeof(cp)); 790 791 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp); 792 } else { 793 struct smp_cmd_security_req cp; 794 cp.auth_req = authreq; 795 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp); 796 } 797 798 done: 799 hcon->pending_sec_level = sec_level; 800 801 return 0; 802 } 803 804 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb) 805 { 806 struct smp_cmd_encrypt_info *rp = (void *) skb->data; 807 struct smp_chan *smp = conn->smp_chan; 808 809 skb_pull(skb, sizeof(*rp)); 810 811 memcpy(smp->tk, rp->ltk, sizeof(smp->tk)); 812 813 return 0; 814 } 815 816 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb) 817 { 818 struct smp_cmd_master_ident *rp = (void *) skb->data; 819 struct smp_chan *smp = conn->smp_chan; 820 821 skb_pull(skb, sizeof(*rp)); 822 823 hci_add_ltk(conn->hcon->hdev, 1, conn->dst, smp->smp_key_size, 824 rp->ediv, rp->rand, smp->tk); 825 826 smp_distribute_keys(conn, 1); 827 828 return 0; 829 } 830 831 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb) 832 { 833 __u8 code = skb->data[0]; 834 __u8 reason; 835 int err = 0; 836 837 if (!lmp_host_le_capable(conn->hcon->hdev)) { 838 err = -ENOTSUPP; 839 reason = SMP_PAIRING_NOTSUPP; 840 goto done; 841 } 842 843 skb_pull(skb, sizeof(code)); 844 845 switch (code) { 846 case SMP_CMD_PAIRING_REQ: 847 reason = smp_cmd_pairing_req(conn, skb); 848 break; 849 850 case SMP_CMD_PAIRING_FAIL: 851 smp_failure(conn, skb->data[0], 0); 852 reason = 0; 853 err = -EPERM; 854 break; 855 856 case SMP_CMD_PAIRING_RSP: 857 reason = smp_cmd_pairing_rsp(conn, skb); 858 break; 859 860 case SMP_CMD_SECURITY_REQ: 861 reason = smp_cmd_security_req(conn, skb); 862 break; 863 864 case SMP_CMD_PAIRING_CONFIRM: 865 reason = smp_cmd_pairing_confirm(conn, skb); 866 break; 867 868 case SMP_CMD_PAIRING_RANDOM: 869 reason = smp_cmd_pairing_random(conn, skb); 870 break; 871 872 case SMP_CMD_ENCRYPT_INFO: 873 reason = smp_cmd_encrypt_info(conn, skb); 874 break; 875 876 case SMP_CMD_MASTER_IDENT: 877 reason = smp_cmd_master_ident(conn, skb); 878 break; 879 880 case SMP_CMD_IDENT_INFO: 881 case SMP_CMD_IDENT_ADDR_INFO: 882 case SMP_CMD_SIGN_INFO: 883 /* Just ignored */ 884 reason = 0; 885 break; 886 887 default: 888 BT_DBG("Unknown command code 0x%2.2x", code); 889 890 reason = SMP_CMD_NOTSUPP; 891 err = -EOPNOTSUPP; 892 goto done; 893 } 894 895 done: 896 if (reason) 897 smp_failure(conn, reason, 1); 898 899 kfree_skb(skb); 900 return err; 901 } 902 903 int smp_distribute_keys(struct l2cap_conn *conn, __u8 force) 904 { 905 struct smp_cmd_pairing *req, *rsp; 906 struct smp_chan *smp = conn->smp_chan; 907 __u8 *keydist; 908 909 BT_DBG("conn %p force %d", conn, force); 910 911 if (!test_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->pend)) 912 return 0; 913 914 rsp = (void *) &smp->prsp[1]; 915 916 /* The responder sends its keys first */ 917 if (!force && conn->hcon->out && (rsp->resp_key_dist & 0x07)) 918 return 0; 919 920 req = (void *) &smp->preq[1]; 921 922 if (conn->hcon->out) { 923 keydist = &rsp->init_key_dist; 924 *keydist &= req->init_key_dist; 925 } else { 926 keydist = &rsp->resp_key_dist; 927 *keydist &= req->resp_key_dist; 928 } 929 930 931 BT_DBG("keydist 0x%x", *keydist); 932 933 if (*keydist & SMP_DIST_ENC_KEY) { 934 struct smp_cmd_encrypt_info enc; 935 struct smp_cmd_master_ident ident; 936 __le16 ediv; 937 938 get_random_bytes(enc.ltk, sizeof(enc.ltk)); 939 get_random_bytes(&ediv, sizeof(ediv)); 940 get_random_bytes(ident.rand, sizeof(ident.rand)); 941 942 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc); 943 944 hci_add_ltk(conn->hcon->hdev, 1, conn->dst, smp->smp_key_size, 945 ediv, ident.rand, enc.ltk); 946 947 ident.ediv = cpu_to_le16(ediv); 948 949 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident); 950 951 *keydist &= ~SMP_DIST_ENC_KEY; 952 } 953 954 if (*keydist & SMP_DIST_ID_KEY) { 955 struct smp_cmd_ident_addr_info addrinfo; 956 struct smp_cmd_ident_info idinfo; 957 958 /* Send a dummy key */ 959 get_random_bytes(idinfo.irk, sizeof(idinfo.irk)); 960 961 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo); 962 963 /* Just public address */ 964 memset(&addrinfo, 0, sizeof(addrinfo)); 965 bacpy(&addrinfo.bdaddr, conn->src); 966 967 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo), 968 &addrinfo); 969 970 *keydist &= ~SMP_DIST_ID_KEY; 971 } 972 973 if (*keydist & SMP_DIST_SIGN) { 974 struct smp_cmd_sign_info sign; 975 976 /* Send a dummy key */ 977 get_random_bytes(sign.csrk, sizeof(sign.csrk)); 978 979 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign); 980 981 *keydist &= ~SMP_DIST_SIGN; 982 } 983 984 if (conn->hcon->out || force) { 985 clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->pend); 986 cancel_delayed_work_sync(&conn->security_timer); 987 smp_chan_destroy(conn); 988 } 989 990 return 0; 991 } 992