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