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