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