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/smp.h> 27 #include <linux/crypto.h> 28 #include <linux/scatterlist.h> 29 #include <crypto/b128ops.h> 30 31 #define SMP_TIMEOUT 30000 /* 30 seconds */ 32 33 static inline void swap128(u8 src[16], u8 dst[16]) 34 { 35 int i; 36 for (i = 0; i < 16; i++) 37 dst[15 - i] = src[i]; 38 } 39 40 static inline void swap56(u8 src[7], u8 dst[7]) 41 { 42 int i; 43 for (i = 0; i < 7; i++) 44 dst[6 - i] = src[i]; 45 } 46 47 static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r) 48 { 49 struct blkcipher_desc desc; 50 struct scatterlist sg; 51 int err, iv_len; 52 unsigned char iv[128]; 53 54 if (tfm == NULL) { 55 BT_ERR("tfm %p", tfm); 56 return -EINVAL; 57 } 58 59 desc.tfm = tfm; 60 desc.flags = 0; 61 62 err = crypto_blkcipher_setkey(tfm, k, 16); 63 if (err) { 64 BT_ERR("cipher setkey failed: %d", err); 65 return err; 66 } 67 68 sg_init_one(&sg, r, 16); 69 70 iv_len = crypto_blkcipher_ivsize(tfm); 71 if (iv_len) { 72 memset(&iv, 0xff, iv_len); 73 crypto_blkcipher_set_iv(tfm, iv, iv_len); 74 } 75 76 err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16); 77 if (err) 78 BT_ERR("Encrypt data error %d", err); 79 80 return err; 81 } 82 83 static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16], 84 u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia, 85 u8 _rat, bdaddr_t *ra, u8 res[16]) 86 { 87 u8 p1[16], p2[16]; 88 int err; 89 90 memset(p1, 0, 16); 91 92 /* p1 = pres || preq || _rat || _iat */ 93 swap56(pres, p1); 94 swap56(preq, p1 + 7); 95 p1[14] = _rat; 96 p1[15] = _iat; 97 98 memset(p2, 0, 16); 99 100 /* p2 = padding || ia || ra */ 101 baswap((bdaddr_t *) (p2 + 4), ia); 102 baswap((bdaddr_t *) (p2 + 10), ra); 103 104 /* res = r XOR p1 */ 105 u128_xor((u128 *) res, (u128 *) r, (u128 *) p1); 106 107 /* res = e(k, res) */ 108 err = smp_e(tfm, k, res); 109 if (err) { 110 BT_ERR("Encrypt data error"); 111 return err; 112 } 113 114 /* res = res XOR p2 */ 115 u128_xor((u128 *) res, (u128 *) res, (u128 *) p2); 116 117 /* res = e(k, res) */ 118 err = smp_e(tfm, k, res); 119 if (err) 120 BT_ERR("Encrypt data error"); 121 122 return err; 123 } 124 125 static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], 126 u8 r1[16], u8 r2[16], u8 _r[16]) 127 { 128 int err; 129 130 /* Just least significant octets from r1 and r2 are considered */ 131 memcpy(_r, r1 + 8, 8); 132 memcpy(_r + 8, r2 + 8, 8); 133 134 err = smp_e(tfm, k, _r); 135 if (err) 136 BT_ERR("Encrypt data error"); 137 138 return err; 139 } 140 141 static int smp_rand(u8 *buf) 142 { 143 get_random_bytes(buf, 16); 144 145 return 0; 146 } 147 148 static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code, 149 u16 dlen, void *data) 150 { 151 struct sk_buff *skb; 152 struct l2cap_hdr *lh; 153 int len; 154 155 len = L2CAP_HDR_SIZE + sizeof(code) + dlen; 156 157 if (len > conn->mtu) 158 return NULL; 159 160 skb = bt_skb_alloc(len, GFP_ATOMIC); 161 if (!skb) 162 return NULL; 163 164 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 165 lh->len = cpu_to_le16(sizeof(code) + dlen); 166 lh->cid = cpu_to_le16(L2CAP_CID_SMP); 167 168 memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code)); 169 170 memcpy(skb_put(skb, dlen), data, dlen); 171 172 return skb; 173 } 174 175 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data) 176 { 177 struct sk_buff *skb = smp_build_cmd(conn, code, len, data); 178 179 BT_DBG("code 0x%2.2x", code); 180 181 if (!skb) 182 return; 183 184 hci_send_acl(conn->hcon, skb, 0); 185 } 186 187 static __u8 seclevel_to_authreq(__u8 level) 188 { 189 switch (level) { 190 case BT_SECURITY_HIGH: 191 /* Right now we don't support bonding */ 192 return SMP_AUTH_MITM; 193 194 default: 195 return SMP_AUTH_NONE; 196 } 197 } 198 199 static void build_pairing_cmd(struct l2cap_conn *conn, 200 struct smp_cmd_pairing *req, 201 struct smp_cmd_pairing *rsp, 202 __u8 authreq) 203 { 204 u8 dist_keys; 205 206 dist_keys = 0; 207 if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->flags)) { 208 dist_keys = SMP_DIST_ENC_KEY | SMP_DIST_ID_KEY | SMP_DIST_SIGN; 209 authreq |= SMP_AUTH_BONDING; 210 } 211 212 if (rsp == NULL) { 213 req->io_capability = conn->hcon->io_capability; 214 req->oob_flag = SMP_OOB_NOT_PRESENT; 215 req->max_key_size = SMP_MAX_ENC_KEY_SIZE; 216 req->init_key_dist = dist_keys; 217 req->resp_key_dist = dist_keys; 218 req->auth_req = authreq; 219 return; 220 } 221 222 rsp->io_capability = conn->hcon->io_capability; 223 rsp->oob_flag = SMP_OOB_NOT_PRESENT; 224 rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE; 225 rsp->init_key_dist = req->init_key_dist & dist_keys; 226 rsp->resp_key_dist = req->resp_key_dist & dist_keys; 227 rsp->auth_req = authreq; 228 } 229 230 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size) 231 { 232 if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) || 233 (max_key_size < SMP_MIN_ENC_KEY_SIZE)) 234 return SMP_ENC_KEY_SIZE; 235 236 conn->smp_key_size = max_key_size; 237 238 return 0; 239 } 240 241 static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb) 242 { 243 struct smp_cmd_pairing rsp, *req = (void *) skb->data; 244 u8 key_size; 245 246 BT_DBG("conn %p", conn); 247 248 conn->preq[0] = SMP_CMD_PAIRING_REQ; 249 memcpy(&conn->preq[1], req, sizeof(*req)); 250 skb_pull(skb, sizeof(*req)); 251 252 if (req->oob_flag) 253 return SMP_OOB_NOT_AVAIL; 254 255 /* We didn't start the pairing, so no requirements */ 256 build_pairing_cmd(conn, req, &rsp, SMP_AUTH_NONE); 257 258 key_size = min(req->max_key_size, rsp.max_key_size); 259 if (check_enc_key_size(conn, key_size)) 260 return SMP_ENC_KEY_SIZE; 261 262 /* Just works */ 263 memset(conn->tk, 0, sizeof(conn->tk)); 264 265 conn->prsp[0] = SMP_CMD_PAIRING_RSP; 266 memcpy(&conn->prsp[1], &rsp, sizeof(rsp)); 267 268 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp); 269 270 mod_timer(&conn->security_timer, jiffies + 271 msecs_to_jiffies(SMP_TIMEOUT)); 272 273 return 0; 274 } 275 276 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb) 277 { 278 struct smp_cmd_pairing *req, *rsp = (void *) skb->data; 279 struct smp_cmd_pairing_confirm cp; 280 struct crypto_blkcipher *tfm = conn->hcon->hdev->tfm; 281 int ret; 282 u8 res[16], key_size; 283 284 BT_DBG("conn %p", conn); 285 286 skb_pull(skb, sizeof(*rsp)); 287 288 req = (void *) &conn->preq[1]; 289 290 key_size = min(req->max_key_size, rsp->max_key_size); 291 if (check_enc_key_size(conn, key_size)) 292 return SMP_ENC_KEY_SIZE; 293 294 if (rsp->oob_flag) 295 return SMP_OOB_NOT_AVAIL; 296 297 /* Just works */ 298 memset(conn->tk, 0, sizeof(conn->tk)); 299 300 conn->prsp[0] = SMP_CMD_PAIRING_RSP; 301 memcpy(&conn->prsp[1], rsp, sizeof(*rsp)); 302 303 ret = smp_rand(conn->prnd); 304 if (ret) 305 return SMP_UNSPECIFIED; 306 307 ret = smp_c1(tfm, conn->tk, conn->prnd, conn->preq, conn->prsp, 0, 308 conn->src, conn->hcon->dst_type, conn->dst, res); 309 if (ret) 310 return SMP_UNSPECIFIED; 311 312 swap128(res, cp.confirm_val); 313 314 smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp); 315 316 return 0; 317 } 318 319 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb) 320 { 321 struct crypto_blkcipher *tfm = conn->hcon->hdev->tfm; 322 323 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave"); 324 325 memcpy(conn->pcnf, skb->data, sizeof(conn->pcnf)); 326 skb_pull(skb, sizeof(conn->pcnf)); 327 328 if (conn->hcon->out) { 329 u8 random[16]; 330 331 swap128(conn->prnd, random); 332 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(random), 333 random); 334 } else { 335 struct smp_cmd_pairing_confirm cp; 336 int ret; 337 u8 res[16]; 338 339 ret = smp_rand(conn->prnd); 340 if (ret) 341 return SMP_UNSPECIFIED; 342 343 ret = smp_c1(tfm, conn->tk, conn->prnd, conn->preq, conn->prsp, 344 conn->hcon->dst_type, conn->dst, 345 0, conn->src, res); 346 if (ret) 347 return SMP_CONFIRM_FAILED; 348 349 swap128(res, cp.confirm_val); 350 351 smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp); 352 } 353 354 mod_timer(&conn->security_timer, jiffies + 355 msecs_to_jiffies(SMP_TIMEOUT)); 356 357 return 0; 358 } 359 360 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb) 361 { 362 struct hci_conn *hcon = conn->hcon; 363 struct crypto_blkcipher *tfm = hcon->hdev->tfm; 364 int ret; 365 u8 key[16], res[16], random[16], confirm[16]; 366 367 swap128(skb->data, random); 368 skb_pull(skb, sizeof(random)); 369 370 if (conn->hcon->out) 371 ret = smp_c1(tfm, conn->tk, random, conn->preq, conn->prsp, 0, 372 conn->src, conn->hcon->dst_type, conn->dst, 373 res); 374 else 375 ret = smp_c1(tfm, conn->tk, random, conn->preq, conn->prsp, 376 conn->hcon->dst_type, conn->dst, 0, conn->src, 377 res); 378 if (ret) 379 return SMP_UNSPECIFIED; 380 381 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave"); 382 383 swap128(res, confirm); 384 385 if (memcmp(conn->pcnf, confirm, sizeof(conn->pcnf)) != 0) { 386 BT_ERR("Pairing failed (confirmation values mismatch)"); 387 return SMP_CONFIRM_FAILED; 388 } 389 390 if (conn->hcon->out) { 391 u8 stk[16], rand[8]; 392 __le16 ediv; 393 394 memset(rand, 0, sizeof(rand)); 395 ediv = 0; 396 397 smp_s1(tfm, conn->tk, random, conn->prnd, key); 398 swap128(key, stk); 399 400 memset(stk + conn->smp_key_size, 0, 401 SMP_MAX_ENC_KEY_SIZE - conn->smp_key_size); 402 403 hci_le_start_enc(hcon, ediv, rand, stk); 404 hcon->enc_key_size = conn->smp_key_size; 405 } else { 406 u8 stk[16], r[16], rand[8]; 407 __le16 ediv; 408 409 memset(rand, 0, sizeof(rand)); 410 ediv = 0; 411 412 swap128(conn->prnd, r); 413 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(r), r); 414 415 smp_s1(tfm, conn->tk, conn->prnd, random, key); 416 swap128(key, stk); 417 418 memset(stk + conn->smp_key_size, 0, 419 SMP_MAX_ENC_KEY_SIZE - conn->smp_key_size); 420 421 hci_add_ltk(conn->hcon->hdev, 0, conn->dst, conn->smp_key_size, 422 ediv, rand, stk); 423 } 424 425 return 0; 426 } 427 428 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb) 429 { 430 struct smp_cmd_security_req *rp = (void *) skb->data; 431 struct smp_cmd_pairing cp; 432 struct hci_conn *hcon = conn->hcon; 433 434 BT_DBG("conn %p", conn); 435 436 if (test_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend)) 437 return 0; 438 439 skb_pull(skb, sizeof(*rp)); 440 441 memset(&cp, 0, sizeof(cp)); 442 build_pairing_cmd(conn, &cp, NULL, rp->auth_req); 443 444 conn->preq[0] = SMP_CMD_PAIRING_REQ; 445 memcpy(&conn->preq[1], &cp, sizeof(cp)); 446 447 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp); 448 449 mod_timer(&conn->security_timer, jiffies + 450 msecs_to_jiffies(SMP_TIMEOUT)); 451 452 set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend); 453 454 return 0; 455 } 456 457 int smp_conn_security(struct l2cap_conn *conn, __u8 sec_level) 458 { 459 struct hci_conn *hcon = conn->hcon; 460 __u8 authreq; 461 462 BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level); 463 464 if (!lmp_host_le_capable(hcon->hdev)) 465 return 1; 466 467 if (IS_ERR(hcon->hdev->tfm)) 468 return 1; 469 470 if (test_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend)) 471 return 0; 472 473 if (sec_level == BT_SECURITY_LOW) 474 return 1; 475 476 if (hcon->sec_level >= sec_level) 477 return 1; 478 479 authreq = seclevel_to_authreq(sec_level); 480 481 if (hcon->link_mode & HCI_LM_MASTER) { 482 struct smp_cmd_pairing cp; 483 struct link_key *key; 484 485 key = hci_find_link_key_type(hcon->hdev, conn->dst, 486 HCI_LK_SMP_LTK); 487 if (key) { 488 struct key_master_id *master = (void *) key->data; 489 490 hci_le_start_enc(hcon, master->ediv, master->rand, 491 key->val); 492 hcon->enc_key_size = key->pin_len; 493 494 goto done; 495 } 496 497 build_pairing_cmd(conn, &cp, NULL, authreq); 498 conn->preq[0] = SMP_CMD_PAIRING_REQ; 499 memcpy(&conn->preq[1], &cp, sizeof(cp)); 500 501 mod_timer(&conn->security_timer, jiffies + 502 msecs_to_jiffies(SMP_TIMEOUT)); 503 504 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp); 505 } else { 506 struct smp_cmd_security_req cp; 507 cp.auth_req = authreq; 508 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp); 509 } 510 511 done: 512 hcon->pending_sec_level = sec_level; 513 set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend); 514 515 return 0; 516 } 517 518 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb) 519 { 520 struct smp_cmd_encrypt_info *rp = (void *) skb->data; 521 522 skb_pull(skb, sizeof(*rp)); 523 524 memcpy(conn->tk, rp->ltk, sizeof(conn->tk)); 525 526 return 0; 527 } 528 529 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb) 530 { 531 struct smp_cmd_master_ident *rp = (void *) skb->data; 532 533 skb_pull(skb, sizeof(*rp)); 534 535 hci_add_ltk(conn->hcon->hdev, 1, conn->src, conn->smp_key_size, 536 rp->ediv, rp->rand, conn->tk); 537 538 smp_distribute_keys(conn, 1); 539 540 return 0; 541 } 542 543 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb) 544 { 545 __u8 code = skb->data[0]; 546 __u8 reason; 547 int err = 0; 548 549 if (!lmp_host_le_capable(conn->hcon->hdev)) { 550 err = -ENOTSUPP; 551 reason = SMP_PAIRING_NOTSUPP; 552 goto done; 553 } 554 555 if (IS_ERR(conn->hcon->hdev->tfm)) { 556 err = PTR_ERR(conn->hcon->hdev->tfm); 557 reason = SMP_PAIRING_NOTSUPP; 558 goto done; 559 } 560 561 skb_pull(skb, sizeof(code)); 562 563 switch (code) { 564 case SMP_CMD_PAIRING_REQ: 565 reason = smp_cmd_pairing_req(conn, skb); 566 break; 567 568 case SMP_CMD_PAIRING_FAIL: 569 reason = 0; 570 err = -EPERM; 571 break; 572 573 case SMP_CMD_PAIRING_RSP: 574 reason = smp_cmd_pairing_rsp(conn, skb); 575 break; 576 577 case SMP_CMD_SECURITY_REQ: 578 reason = smp_cmd_security_req(conn, skb); 579 break; 580 581 case SMP_CMD_PAIRING_CONFIRM: 582 reason = smp_cmd_pairing_confirm(conn, skb); 583 break; 584 585 case SMP_CMD_PAIRING_RANDOM: 586 reason = smp_cmd_pairing_random(conn, skb); 587 break; 588 589 case SMP_CMD_ENCRYPT_INFO: 590 reason = smp_cmd_encrypt_info(conn, skb); 591 break; 592 593 case SMP_CMD_MASTER_IDENT: 594 reason = smp_cmd_master_ident(conn, skb); 595 break; 596 597 case SMP_CMD_IDENT_INFO: 598 case SMP_CMD_IDENT_ADDR_INFO: 599 case SMP_CMD_SIGN_INFO: 600 /* Just ignored */ 601 reason = 0; 602 break; 603 604 default: 605 BT_DBG("Unknown command code 0x%2.2x", code); 606 607 reason = SMP_CMD_NOTSUPP; 608 err = -EOPNOTSUPP; 609 goto done; 610 } 611 612 done: 613 if (reason) 614 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason), 615 &reason); 616 617 kfree_skb(skb); 618 return err; 619 } 620 621 int smp_distribute_keys(struct l2cap_conn *conn, __u8 force) 622 { 623 struct smp_cmd_pairing *req, *rsp; 624 __u8 *keydist; 625 626 BT_DBG("conn %p force %d", conn, force); 627 628 if (IS_ERR(conn->hcon->hdev->tfm)) 629 return PTR_ERR(conn->hcon->hdev->tfm); 630 631 rsp = (void *) &conn->prsp[1]; 632 633 /* The responder sends its keys first */ 634 if (!force && conn->hcon->out && (rsp->resp_key_dist & 0x07)) 635 return 0; 636 637 req = (void *) &conn->preq[1]; 638 639 if (conn->hcon->out) { 640 keydist = &rsp->init_key_dist; 641 *keydist &= req->init_key_dist; 642 } else { 643 keydist = &rsp->resp_key_dist; 644 *keydist &= req->resp_key_dist; 645 } 646 647 648 BT_DBG("keydist 0x%x", *keydist); 649 650 if (*keydist & SMP_DIST_ENC_KEY) { 651 struct smp_cmd_encrypt_info enc; 652 struct smp_cmd_master_ident ident; 653 __le16 ediv; 654 655 get_random_bytes(enc.ltk, sizeof(enc.ltk)); 656 get_random_bytes(&ediv, sizeof(ediv)); 657 get_random_bytes(ident.rand, sizeof(ident.rand)); 658 659 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc); 660 661 hci_add_ltk(conn->hcon->hdev, 1, conn->dst, conn->smp_key_size, 662 ediv, ident.rand, enc.ltk); 663 664 ident.ediv = cpu_to_le16(ediv); 665 666 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident); 667 668 *keydist &= ~SMP_DIST_ENC_KEY; 669 } 670 671 if (*keydist & SMP_DIST_ID_KEY) { 672 struct smp_cmd_ident_addr_info addrinfo; 673 struct smp_cmd_ident_info idinfo; 674 675 /* Send a dummy key */ 676 get_random_bytes(idinfo.irk, sizeof(idinfo.irk)); 677 678 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo); 679 680 /* Just public address */ 681 memset(&addrinfo, 0, sizeof(addrinfo)); 682 bacpy(&addrinfo.bdaddr, conn->src); 683 684 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo), 685 &addrinfo); 686 687 *keydist &= ~SMP_DIST_ID_KEY; 688 } 689 690 if (*keydist & SMP_DIST_SIGN) { 691 struct smp_cmd_sign_info sign; 692 693 /* Send a dummy key */ 694 get_random_bytes(sign.csrk, sizeof(sign.csrk)); 695 696 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign); 697 698 *keydist &= ~SMP_DIST_SIGN; 699 } 700 701 return 0; 702 } 703