net/bluetooth/smp.c

   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(const 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(const 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         uint8_t tmp[16], data[16];
  57         int err;
  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         /* The most significant octet of key corresponds to k[0] */
  68         swap128(k, tmp);
  69
  70         err = crypto_blkcipher_setkey(tfm, tmp, 16);
  71         if (err) {
  72                 BT_ERR("cipher setkey failed: %d", err);
  73                 return err;
  74         }
  75
  76         /* Most significant octet of plaintextData corresponds to data[0] */
  77         swap128(r, data);
  78
  79         sg_init_one(&sg, data, 16);
  80
  81         err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
  82         if (err)
  83                 BT_ERR("Encrypt data error %d", err);
  84
  85         /* Most significant octet of encryptedData corresponds to data[0] */
  86         swap128(data, r);
  87
  88         return err;
  89 }
  90
  91 static int smp_ah(struct crypto_blkcipher *tfm, u8 irk[16], u8 r[3], u8 res[3])
  92 {
  93         u8 _res[16];
  94         int err;
  95
  96         /* r' = padding || r */
  97         memcpy(_res, r, 3);
  98         memset(_res + 3, 0, 13);
  99
 100         err = smp_e(tfm, irk, _res);
 101         if (err) {
 102                 BT_ERR("Encrypt error");
 103                 return err;
 104         }
 105
 106         /* The output of the random address function ah is:
 107          *      ah(h, r) = e(k, r') mod 2^24
 108          * The output of the security function e is then truncated to 24 bits
 109          * by taking the least significant 24 bits of the output of e as the
 110          * result of ah.
 111          */
 112         memcpy(res, _res, 3);
 113
 114         return 0;
 115 }
 116
 117 bool smp_irk_matches(struct crypto_blkcipher *tfm, u8 irk[16],
 118                      bdaddr_t *bdaddr)
 119 {
 120         u8 hash[3];
 121         int err;
 122
 123         BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);
 124
 125         err = smp_ah(tfm, irk, &bdaddr->b[3], hash);
 126         if (err)
 127                 return false;
 128
 129         return !memcmp(bdaddr->b, hash, 3);
 130 }
 131
 132 int smp_generate_rpa(struct crypto_blkcipher *tfm, u8 irk[16], bdaddr_t *rpa)
 133 {
 134         int err;
 135
 136         get_random_bytes(&rpa->b[3], 3);
 137
 138         rpa->b[5] &= 0x3f;      /* Clear two most significant bits */
 139         rpa->b[5] |= 0x40;      /* Set second most significant bit */
 140
 141         err = smp_ah(tfm, irk, &rpa->b[3], rpa->b);
 142         if (err < 0)
 143                 return err;
 144
 145         BT_DBG("RPA %pMR", rpa);
 146
 147         return 0;
 148 }
 149
 150 static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
 151                   u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
 152                   u8 _rat, bdaddr_t *ra, u8 res[16])
 153 {
 154         u8 p1[16], p2[16];
 155         int err;
 156
 157         memset(p1, 0, 16);
 158
 159         /* p1 = pres || preq || _rat || _iat */
 160         p1[0] = _iat;
 161         p1[1] = _rat;
 162         memcpy(p1 + 2, preq, 7);
 163         memcpy(p1 + 9, pres, 7);
 164
 165         /* p2 = padding || ia || ra */
 166         memcpy(p2, ra, 6);
 167         memcpy(p2 + 6, ia, 6);
 168         memset(p2 + 12, 0, 4);
 169
 170         /* res = r XOR p1 */
 171         u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
 172
 173         /* res = e(k, res) */
 174         err = smp_e(tfm, k, res);
 175         if (err) {
 176                 BT_ERR("Encrypt data error");
 177                 return err;
 178         }
 179
 180         /* res = res XOR p2 */
 181         u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
 182
 183         /* res = e(k, res) */
 184         err = smp_e(tfm, k, res);
 185         if (err)
 186                 BT_ERR("Encrypt data error");
 187
 188         return err;
 189 }
 190
 191 static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], u8 r1[16],
 192                   u8 r2[16], u8 _r[16])
 193 {
 194         int err;
 195
 196         /* Just least significant octets from r1 and r2 are considered */
 197         memcpy(_r, r2, 8);
 198         memcpy(_r + 8, r1, 8);
 199
 200         err = smp_e(tfm, k, _r);
 201         if (err)
 202                 BT_ERR("Encrypt data error");
 203
 204         return err;
 205 }
 206
 207 static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
 208                                      u16 dlen, void *data)
 209 {
 210         struct sk_buff *skb;
 211         struct l2cap_hdr *lh;
 212         int len;
 213
 214         len = L2CAP_HDR_SIZE + sizeof(code) + dlen;
 215
 216         if (len > conn->mtu)
 217                 return NULL;
 218
 219         skb = bt_skb_alloc(len, GFP_ATOMIC);
 220         if (!skb)
 221                 return NULL;
 222
 223         lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
 224         lh->len = cpu_to_le16(sizeof(code) + dlen);
 225         lh->cid = cpu_to_le16(L2CAP_CID_SMP);
 226
 227         memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code));
 228
 229         memcpy(skb_put(skb, dlen), data, dlen);
 230
 231         return skb;
 232 }
 233
 234 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
 235 {
 236         struct sk_buff *skb = smp_build_cmd(conn, code, len, data);
 237
 238         BT_DBG("code 0x%2.2x", code);
 239
 240         if (!skb)
 241                 return;
 242
 243         skb->priority = HCI_PRIO_MAX;
 244         hci_send_acl(conn->hchan, skb, 0);
 245
 246         cancel_delayed_work_sync(&conn->security_timer);
 247         schedule_delayed_work(&conn->security_timer, SMP_TIMEOUT);
 248 }
 249
 250 static __u8 authreq_to_seclevel(__u8 authreq)
 251 {
 252         if (authreq & SMP_AUTH_MITM)
 253                 return BT_SECURITY_HIGH;
 254         else
 255                 return BT_SECURITY_MEDIUM;
 256 }
 257
 258 static __u8 seclevel_to_authreq(__u8 sec_level)
 259 {
 260         switch (sec_level) {
 261         case BT_SECURITY_HIGH:
 262                 return SMP_AUTH_MITM | SMP_AUTH_BONDING;
 263         case BT_SECURITY_MEDIUM:
 264                 return SMP_AUTH_BONDING;
 265         default:
 266                 return SMP_AUTH_NONE;
 267         }
 268 }
 269
 270 static void build_pairing_cmd(struct l2cap_conn *conn,
 271                               struct smp_cmd_pairing *req,
 272                               struct smp_cmd_pairing *rsp, __u8 authreq)
 273 {
 274         struct smp_chan *smp = conn->smp_chan;
 275         struct hci_conn *hcon = conn->hcon;
 276         struct hci_dev *hdev = hcon->hdev;
 277         u8 local_dist = 0, remote_dist = 0;
 278
 279         if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->dev_flags)) {
 280                 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
 281                 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
 282                 authreq |= SMP_AUTH_BONDING;
 283         } else {
 284                 authreq &= ~SMP_AUTH_BONDING;
 285         }
 286
 287         if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
 288                 remote_dist |= SMP_DIST_ID_KEY;
 289
 290         if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
 291                 local_dist |= SMP_DIST_ID_KEY;
 292
 293         if (rsp == NULL) {
 294                 req->io_capability = conn->hcon->io_capability;
 295                 req->oob_flag = SMP_OOB_NOT_PRESENT;
 296                 req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 297                 req->init_key_dist = local_dist;
 298                 req->resp_key_dist = remote_dist;
 299                 req->auth_req = (authreq & AUTH_REQ_MASK);
 300
 301                 smp->remote_key_dist = remote_dist;
 302                 return;
 303         }
 304
 305         rsp->io_capability = conn->hcon->io_capability;
 306         rsp->oob_flag = SMP_OOB_NOT_PRESENT;
 307         rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 308         rsp->init_key_dist = req->init_key_dist & remote_dist;
 309         rsp->resp_key_dist = req->resp_key_dist & local_dist;
 310         rsp->auth_req = (authreq & AUTH_REQ_MASK);
 311
 312         smp->remote_key_dist = rsp->init_key_dist;
 313 }
 314
 315 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
 316 {
 317         struct smp_chan *smp = conn->smp_chan;
 318
 319         if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
 320             (max_key_size < SMP_MIN_ENC_KEY_SIZE))
 321                 return SMP_ENC_KEY_SIZE;
 322
 323         smp->enc_key_size = max_key_size;
 324
 325         return 0;
 326 }
 327
 328 static void smp_failure(struct l2cap_conn *conn, u8 reason)
 329 {
 330         struct hci_conn *hcon = conn->hcon;
 331
 332         if (reason)
 333                 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
 334                              &reason);
 335
 336         clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags);
 337         mgmt_auth_failed(hcon->hdev, &hcon->dst, hcon->type, hcon->dst_type,
 338                          HCI_ERROR_AUTH_FAILURE);
 339
 340         cancel_delayed_work_sync(&conn->security_timer);
 341
 342         if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 343                 smp_chan_destroy(conn);
 344 }
 345
 346 #define JUST_WORKS      0x00
 347 #define JUST_CFM        0x01
 348 #define REQ_PASSKEY     0x02
 349 #define CFM_PASSKEY     0x03
 350 #define REQ_OOB         0x04
 351 #define OVERLAP         0xFF
 352
 353 static const u8 gen_method[5][5] = {
 354         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 355         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 356         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 357         { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
 358         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP     },
 359 };
 360
 361 static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
 362                                                 u8 local_io, u8 remote_io)
 363 {
 364         struct hci_conn *hcon = conn->hcon;
 365         struct smp_chan *smp = conn->smp_chan;
 366         u8 method;
 367         u32 passkey = 0;
 368         int ret = 0;
 369
 370         /* Initialize key for JUST WORKS */
 371         memset(smp->tk, 0, sizeof(smp->tk));
 372         clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 373
 374         BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
 375
 376         /* If neither side wants MITM, use JUST WORKS */
 377         /* If either side has unknown io_caps, use JUST WORKS */
 378         /* Otherwise, look up method from the table */
 379         if (!(auth & SMP_AUTH_MITM) ||
 380             local_io > SMP_IO_KEYBOARD_DISPLAY ||
 381             remote_io > SMP_IO_KEYBOARD_DISPLAY)
 382                 method = JUST_WORKS;
 383         else
 384                 method = gen_method[remote_io][local_io];
 385
 386         /* If not bonding, don't ask user to confirm a Zero TK */
 387         if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM)
 388                 method = JUST_WORKS;
 389
 390         /* Don't confirm locally initiated pairing attempts */
 391         if (method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR,
 392                                            &smp->smp_flags))
 393                 method = JUST_WORKS;
 394
 395         /* If Just Works, Continue with Zero TK */
 396         if (method == JUST_WORKS) {
 397                 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 398                 return 0;
 399         }
 400
 401         /* Not Just Works/Confirm results in MITM Authentication */
 402         if (method != JUST_CFM)
 403                 set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags);
 404
 405         /* If both devices have Keyoard-Display I/O, the master
 406          * Confirms and the slave Enters the passkey.
 407          */
 408         if (method == OVERLAP) {
 409                 if (hcon->link_mode & HCI_LM_MASTER)
 410                         method = CFM_PASSKEY;
 411                 else
 412                         method = REQ_PASSKEY;
 413         }
 414
 415         /* Generate random passkey. */
 416         if (method == CFM_PASSKEY) {
 417                 memset(smp->tk, 0, sizeof(smp->tk));
 418                 get_random_bytes(&passkey, sizeof(passkey));
 419                 passkey %= 1000000;
 420                 put_unaligned_le32(passkey, smp->tk);
 421                 BT_DBG("PassKey: %d", passkey);
 422                 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 423         }
 424
 425         hci_dev_lock(hcon->hdev);
 426
 427         if (method == REQ_PASSKEY)
 428                 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
 429                                                 hcon->type, hcon->dst_type);
 430         else if (method == JUST_CFM)
 431                 ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
 432                                                 hcon->type, hcon->dst_type,
 433                                                 passkey, 1);
 434         else
 435                 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
 436                                                 hcon->type, hcon->dst_type,
 437                                                 passkey, 0);
 438
 439         hci_dev_unlock(hcon->hdev);
 440
 441         return ret;
 442 }
 443
 444 static void confirm_work(struct work_struct *work)
 445 {
 446         struct smp_chan *smp = container_of(work, struct smp_chan, confirm);
 447         struct l2cap_conn *conn = smp->conn;
 448         struct hci_dev *hdev = conn->hcon->hdev;
 449         struct crypto_blkcipher *tfm = hdev->tfm_aes;
 450         struct smp_cmd_pairing_confirm cp;
 451         int ret;
 452         u8 reason;
 453
 454         BT_DBG("conn %p", conn);
 455
 456         /* Prevent mutual access to hdev->tfm_aes */
 457         hci_dev_lock(hdev);
 458
 459         ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
 460                      conn->hcon->init_addr_type, &conn->hcon->init_addr,
 461                      conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
 462                      cp.confirm_val);
 463
 464         hci_dev_unlock(hdev);
 465
 466         if (ret) {
 467                 reason = SMP_UNSPECIFIED;
 468                 goto error;
 469         }
 470
 471         clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 472
 473         smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
 474
 475         return;
 476
 477 error:
 478         smp_failure(conn, reason);
 479 }
 480
 481 static void random_work(struct work_struct *work)
 482 {
 483         struct smp_chan *smp = container_of(work, struct smp_chan, random);
 484         struct l2cap_conn *conn = smp->conn;
 485         struct hci_conn *hcon = conn->hcon;
 486         struct hci_dev *hdev = hcon->hdev;
 487         struct crypto_blkcipher *tfm = hdev->tfm_aes;
 488         u8 reason, confirm[16];
 489         int ret;
 490
 491         if (IS_ERR_OR_NULL(tfm)) {
 492                 reason = SMP_UNSPECIFIED;
 493                 goto error;
 494         }
 495
 496         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 497
 498         /* Prevent mutual access to hdev->tfm_aes */
 499         hci_dev_lock(hdev);
 500
 501         ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
 502                      hcon->init_addr_type, &hcon->init_addr,
 503                      hcon->resp_addr_type, &hcon->resp_addr, confirm);
 504
 505         hci_dev_unlock(hdev);
 506
 507         if (ret) {
 508                 reason = SMP_UNSPECIFIED;
 509                 goto error;
 510         }
 511
 512         if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
 513                 BT_ERR("Pairing failed (confirmation values mismatch)");
 514                 reason = SMP_CONFIRM_FAILED;
 515                 goto error;
 516         }
 517
 518         if (hcon->out) {
 519                 u8 stk[16];
 520                 __le64 rand = 0;
 521                 __le16 ediv = 0;
 522
 523                 smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, stk);
 524
 525                 memset(stk + smp->enc_key_size, 0,
 526                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 527
 528                 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) {
 529                         reason = SMP_UNSPECIFIED;
 530                         goto error;
 531                 }
 532
 533                 hci_le_start_enc(hcon, ediv, rand, stk);
 534                 hcon->enc_key_size = smp->enc_key_size;
 535         } else {
 536                 u8 stk[16];
 537                 __le64 rand = 0;
 538                 __le16 ediv = 0;
 539
 540                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
 541                              smp->prnd);
 542
 543                 smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, stk);
 544
 545                 memset(stk + smp->enc_key_size, 0,
 546                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 547
 548                 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
 549                             HCI_SMP_STK_SLAVE, 0, stk, smp->enc_key_size,
 550                             ediv, rand);
 551         }
 552
 553         return;
 554
 555 error:
 556         smp_failure(conn, reason);
 557 }
 558
 559 static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
 560 {
 561         struct smp_chan *smp;
 562
 563         smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
 564         if (!smp)
 565                 return NULL;
 566
 567         INIT_WORK(&smp->confirm, confirm_work);
 568         INIT_WORK(&smp->random, random_work);
 569
 570         smp->conn = conn;
 571         conn->smp_chan = smp;
 572         conn->hcon->smp_conn = conn;
 573
 574         hci_conn_hold(conn->hcon);
 575
 576         return smp;
 577 }
 578
 579 void smp_chan_destroy(struct l2cap_conn *conn)
 580 {
 581         struct smp_chan *smp = conn->smp_chan;
 582         bool complete;
 583
 584         BUG_ON(!smp);
 585
 586         complete = test_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
 587         mgmt_smp_complete(conn->hcon, complete);
 588
 589         kfree(smp->csrk);
 590         kfree(smp->slave_csrk);
 591
 592         /* If pairing failed clean up any keys we might have */
 593         if (!complete) {
 594                 if (smp->ltk) {
 595                         list_del(&smp->ltk->list);
 596                         kfree(smp->ltk);
 597                 }
 598
 599                 if (smp->slave_ltk) {
 600                         list_del(&smp->slave_ltk->list);
 601                         kfree(smp->slave_ltk);
 602                 }
 603
 604                 if (smp->remote_irk) {
 605                         list_del(&smp->remote_irk->list);
 606                         kfree(smp->remote_irk);
 607                 }
 608         }
 609
 610         kfree(smp);
 611         conn->smp_chan = NULL;
 612         conn->hcon->smp_conn = NULL;
 613         hci_conn_drop(conn->hcon);
 614 }
 615
 616 int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
 617 {
 618         struct l2cap_conn *conn = hcon->smp_conn;
 619         struct smp_chan *smp;
 620         u32 value;
 621
 622         BT_DBG("");
 623
 624         if (!conn)
 625                 return -ENOTCONN;
 626
 627         smp = conn->smp_chan;
 628
 629         switch (mgmt_op) {
 630         case MGMT_OP_USER_PASSKEY_REPLY:
 631                 value = le32_to_cpu(passkey);
 632                 memset(smp->tk, 0, sizeof(smp->tk));
 633                 BT_DBG("PassKey: %d", value);
 634                 put_unaligned_le32(value, smp->tk);
 635                 /* Fall Through */
 636         case MGMT_OP_USER_CONFIRM_REPLY:
 637                 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 638                 break;
 639         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
 640         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
 641                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
 642                 return 0;
 643         default:
 644                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
 645                 return -EOPNOTSUPP;
 646         }
 647
 648         /* If it is our turn to send Pairing Confirm, do so now */
 649         if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags))
 650                 queue_work(hcon->hdev->workqueue, &smp->confirm);
 651
 652         return 0;
 653 }
 654
 655 static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
 656 {
 657         struct smp_cmd_pairing rsp, *req = (void *) skb->data;
 658         struct smp_chan *smp;
 659         u8 key_size;
 660         u8 auth = SMP_AUTH_NONE;
 661         int ret;
 662
 663         BT_DBG("conn %p", conn);
 664
 665         if (skb->len < sizeof(*req))
 666                 return SMP_UNSPECIFIED;
 667
 668         if (conn->hcon->link_mode & HCI_LM_MASTER)
 669                 return SMP_CMD_NOTSUPP;
 670
 671         if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
 672                 smp = smp_chan_create(conn);
 673         else
 674                 smp = conn->smp_chan;
 675
 676         if (!smp)
 677                 return SMP_UNSPECIFIED;
 678
 679         smp->preq[0] = SMP_CMD_PAIRING_REQ;
 680         memcpy(&smp->preq[1], req, sizeof(*req));
 681         skb_pull(skb, sizeof(*req));
 682
 683         /* We didn't start the pairing, so match remote */
 684         if (req->auth_req & SMP_AUTH_BONDING)
 685                 auth = req->auth_req;
 686
 687         conn->hcon->pending_sec_level = authreq_to_seclevel(auth);
 688
 689         build_pairing_cmd(conn, req, &rsp, auth);
 690
 691         key_size = min(req->max_key_size, rsp.max_key_size);
 692         if (check_enc_key_size(conn, key_size))
 693                 return SMP_ENC_KEY_SIZE;
 694
 695         get_random_bytes(smp->prnd, sizeof(smp->prnd));
 696
 697         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
 698         memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
 699
 700         smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
 701
 702         /* Request setup of TK */
 703         ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
 704         if (ret)
 705                 return SMP_UNSPECIFIED;
 706
 707         clear_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);
 708
 709         return 0;
 710 }
 711
 712 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
 713 {
 714         struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
 715         struct smp_chan *smp = conn->smp_chan;
 716         struct hci_dev *hdev = conn->hcon->hdev;
 717         u8 key_size, auth = SMP_AUTH_NONE;
 718         int ret;
 719
 720         BT_DBG("conn %p", conn);
 721
 722         if (skb->len < sizeof(*rsp))
 723                 return SMP_UNSPECIFIED;
 724
 725         if (!(conn->hcon->link_mode & HCI_LM_MASTER))
 726                 return SMP_CMD_NOTSUPP;
 727
 728         skb_pull(skb, sizeof(*rsp));
 729
 730         req = (void *) &smp->preq[1];
 731
 732         key_size = min(req->max_key_size, rsp->max_key_size);
 733         if (check_enc_key_size(conn, key_size))
 734                 return SMP_ENC_KEY_SIZE;
 735
 736         get_random_bytes(smp->prnd, sizeof(smp->prnd));
 737
 738         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
 739         memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
 740
 741         /* Update remote key distribution in case the remote cleared
 742          * some bits that we had enabled in our request.
 743          */
 744         smp->remote_key_dist &= rsp->resp_key_dist;
 745
 746         if ((req->auth_req & SMP_AUTH_BONDING) &&
 747             (rsp->auth_req & SMP_AUTH_BONDING))
 748                 auth = SMP_AUTH_BONDING;
 749
 750         auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
 751
 752         ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
 753         if (ret)
 754                 return SMP_UNSPECIFIED;
 755
 756         set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 757
 758         /* Can't compose response until we have been confirmed */
 759         if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
 760                 queue_work(hdev->workqueue, &smp->confirm);
 761
 762         return 0;
 763 }
 764
 765 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
 766 {
 767         struct smp_chan *smp = conn->smp_chan;
 768         struct hci_dev *hdev = conn->hcon->hdev;
 769
 770         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 771
 772         if (skb->len < sizeof(smp->pcnf))
 773                 return SMP_UNSPECIFIED;
 774
 775         memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
 776         skb_pull(skb, sizeof(smp->pcnf));
 777
 778         if (conn->hcon->out)
 779                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
 780                              smp->prnd);
 781         else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
 782                 queue_work(hdev->workqueue, &smp->confirm);
 783         else
 784                 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 785
 786         return 0;
 787 }
 788
 789 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
 790 {
 791         struct smp_chan *smp = conn->smp_chan;
 792         struct hci_dev *hdev = conn->hcon->hdev;
 793
 794         BT_DBG("conn %p", conn);
 795
 796         if (skb->len < sizeof(smp->rrnd))
 797                 return SMP_UNSPECIFIED;
 798
 799         memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
 800         skb_pull(skb, sizeof(smp->rrnd));
 801
 802         queue_work(hdev->workqueue, &smp->random);
 803
 804         return 0;
 805 }
 806
 807 static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
 808 {
 809         struct smp_ltk *key;
 810         struct hci_conn *hcon = conn->hcon;
 811
 812         key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type,
 813                                    hcon->out);
 814         if (!key)
 815                 return 0;
 816
 817         if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
 818                 return 0;
 819
 820         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
 821                 return 1;
 822
 823         hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
 824         hcon->enc_key_size = key->enc_size;
 825
 826         return 1;
 827 }
 828
 829 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
 830 {
 831         struct smp_cmd_security_req *rp = (void *) skb->data;
 832         struct smp_cmd_pairing cp;
 833         struct hci_conn *hcon = conn->hcon;
 834         struct smp_chan *smp;
 835
 836         BT_DBG("conn %p", conn);
 837
 838         if (skb->len < sizeof(*rp))
 839                 return SMP_UNSPECIFIED;
 840
 841         if (!(conn->hcon->link_mode & HCI_LM_MASTER))
 842                 return SMP_CMD_NOTSUPP;
 843
 844         hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
 845
 846         if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
 847                 return 0;
 848
 849         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 850                 return 0;
 851
 852         smp = smp_chan_create(conn);
 853
 854         skb_pull(skb, sizeof(*rp));
 855
 856         memset(&cp, 0, sizeof(cp));
 857         build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
 858
 859         smp->preq[0] = SMP_CMD_PAIRING_REQ;
 860         memcpy(&smp->preq[1], &cp, sizeof(cp));
 861
 862         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 863
 864         clear_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);
 865
 866         return 0;
 867 }
 868
 869 bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level)
 870 {
 871         if (sec_level == BT_SECURITY_LOW)
 872                 return true;
 873
 874         if (hcon->sec_level >= sec_level)
 875                 return true;
 876
 877         return false;
 878 }
 879
 880 int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
 881 {
 882         struct l2cap_conn *conn = hcon->l2cap_data;
 883         struct smp_chan *smp;
 884         __u8 authreq;
 885
 886         BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
 887
 888         /* This may be NULL if there's an unexpected disconnection */
 889         if (!conn)
 890                 return 1;
 891
 892         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
 893                 return 1;
 894
 895         if (smp_sufficient_security(hcon, sec_level))
 896                 return 1;
 897
 898         if (hcon->link_mode & HCI_LM_MASTER)
 899                 if (smp_ltk_encrypt(conn, sec_level))
 900                         goto done;
 901
 902         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 903                 return 0;
 904
 905         smp = smp_chan_create(conn);
 906         if (!smp)
 907                 return 1;
 908
 909         authreq = seclevel_to_authreq(sec_level);
 910
 911         /* hcon->auth_type is set by pair_device in mgmt.c. If the MITM
 912          * flag is set we should also set it for the SMP request.
 913          */
 914         if ((hcon->auth_type & 0x01))
 915                 authreq |= SMP_AUTH_MITM;
 916
 917         if (hcon->link_mode & HCI_LM_MASTER) {
 918                 struct smp_cmd_pairing cp;
 919
 920                 build_pairing_cmd(conn, &cp, NULL, authreq);
 921                 smp->preq[0] = SMP_CMD_PAIRING_REQ;
 922                 memcpy(&smp->preq[1], &cp, sizeof(cp));
 923
 924                 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 925         } else {
 926                 struct smp_cmd_security_req cp;
 927                 cp.auth_req = authreq;
 928                 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
 929         }
 930
 931         set_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);
 932
 933 done:
 934         hcon->pending_sec_level = sec_level;
 935
 936         return 0;
 937 }
 938
 939 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
 940 {
 941         struct smp_cmd_encrypt_info *rp = (void *) skb->data;
 942         struct smp_chan *smp = conn->smp_chan;
 943
 944         BT_DBG("conn %p", conn);
 945
 946         if (skb->len < sizeof(*rp))
 947                 return SMP_UNSPECIFIED;
 948
 949         /* Ignore this PDU if it wasn't requested */
 950         if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
 951                 return 0;
 952
 953         skb_pull(skb, sizeof(*rp));
 954
 955         memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
 956
 957         return 0;
 958 }
 959
 960 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
 961 {
 962         struct smp_cmd_master_ident *rp = (void *) skb->data;
 963         struct smp_chan *smp = conn->smp_chan;
 964         struct hci_dev *hdev = conn->hcon->hdev;
 965         struct hci_conn *hcon = conn->hcon;
 966         struct smp_ltk *ltk;
 967         u8 authenticated;
 968
 969         BT_DBG("conn %p", conn);
 970
 971         if (skb->len < sizeof(*rp))
 972                 return SMP_UNSPECIFIED;
 973
 974         /* Ignore this PDU if it wasn't requested */
 975         if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
 976                 return 0;
 977
 978         /* Mark the information as received */
 979         smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
 980
 981         skb_pull(skb, sizeof(*rp));
 982
 983         hci_dev_lock(hdev);
 984         authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
 985         ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK,
 986                           authenticated, smp->tk, smp->enc_key_size,
 987                           rp->ediv, rp->rand);
 988         smp->ltk = ltk;
 989         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
 990                 smp_distribute_keys(conn);
 991         hci_dev_unlock(hdev);
 992
 993         return 0;
 994 }
 995
 996 static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
 997 {
 998         struct smp_cmd_ident_info *info = (void *) skb->data;
 999         struct smp_chan *smp = conn->smp_chan;
1000
1001         BT_DBG("");
1002
1003         if (skb->len < sizeof(*info))
1004                 return SMP_UNSPECIFIED;
1005
1006         /* Ignore this PDU if it wasn't requested */
1007         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1008                 return 0;
1009
1010         skb_pull(skb, sizeof(*info));
1011
1012         memcpy(smp->irk, info->irk, 16);
1013
1014         return 0;
1015 }
1016
1017 static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
1018                                    struct sk_buff *skb)
1019 {
1020         struct smp_cmd_ident_addr_info *info = (void *) skb->data;
1021         struct smp_chan *smp = conn->smp_chan;
1022         struct hci_conn *hcon = conn->hcon;
1023         bdaddr_t rpa;
1024
1025         BT_DBG("");
1026
1027         if (skb->len < sizeof(*info))
1028                 return SMP_UNSPECIFIED;
1029
1030         /* Ignore this PDU if it wasn't requested */
1031         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1032                 return 0;
1033
1034         /* Mark the information as received */
1035         smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
1036
1037         skb_pull(skb, sizeof(*info));
1038
1039         /* Strictly speaking the Core Specification (4.1) allows sending
1040          * an empty address which would force us to rely on just the IRK
1041          * as "identity information". However, since such
1042          * implementations are not known of and in order to not over
1043          * complicate our implementation, simply pretend that we never
1044          * received an IRK for such a device.
1045          */
1046         if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
1047                 BT_ERR("Ignoring IRK with no identity address");
1048                 smp_distribute_keys(conn);
1049                 return 0;
1050         }
1051
1052         bacpy(&smp->id_addr, &info->bdaddr);
1053         smp->id_addr_type = info->addr_type;
1054
1055         if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
1056                 bacpy(&rpa, &hcon->dst);
1057         else
1058                 bacpy(&rpa, BDADDR_ANY);
1059
1060         smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
1061                                       smp->id_addr_type, smp->irk, &rpa);
1062
1063         smp_distribute_keys(conn);
1064
1065         return 0;
1066 }
1067
1068 static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
1069 {
1070         struct smp_cmd_sign_info *rp = (void *) skb->data;
1071         struct smp_chan *smp = conn->smp_chan;
1072         struct hci_dev *hdev = conn->hcon->hdev;
1073         struct smp_csrk *csrk;
1074
1075         BT_DBG("conn %p", conn);
1076
1077         if (skb->len < sizeof(*rp))
1078                 return SMP_UNSPECIFIED;
1079
1080         /* Ignore this PDU if it wasn't requested */
1081         if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1082                 return 0;
1083
1084         /* Mark the information as received */
1085         smp->remote_key_dist &= ~SMP_DIST_SIGN;
1086
1087         skb_pull(skb, sizeof(*rp));
1088
1089         hci_dev_lock(hdev);
1090         csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1091         if (csrk) {
1092                 csrk->master = 0x01;
1093                 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
1094         }
1095         smp->csrk = csrk;
1096         if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1097                 smp_distribute_keys(conn);
1098         hci_dev_unlock(hdev);
1099
1100         return 0;
1101 }
1102
1103 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
1104 {
1105         struct hci_conn *hcon = conn->hcon;
1106         __u8 code, reason;
1107         int err = 0;
1108
1109         if (hcon->type != LE_LINK) {
1110                 kfree_skb(skb);
1111                 return 0;
1112         }
1113
1114         if (skb->len < 1) {
1115                 kfree_skb(skb);
1116                 return -EILSEQ;
1117         }
1118
1119         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
1120                 err = -ENOTSUPP;
1121                 reason = SMP_PAIRING_NOTSUPP;
1122                 goto done;
1123         }
1124
1125         code = skb->data[0];
1126         skb_pull(skb, sizeof(code));
1127
1128         /*
1129          * The SMP context must be initialized for all other PDUs except
1130          * pairing and security requests. If we get any other PDU when
1131          * not initialized simply disconnect (done if this function
1132          * returns an error).
1133          */
1134         if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
1135             !conn->smp_chan) {
1136                 BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
1137                 kfree_skb(skb);
1138                 return -ENOTSUPP;
1139         }
1140
1141         switch (code) {
1142         case SMP_CMD_PAIRING_REQ:
1143                 reason = smp_cmd_pairing_req(conn, skb);
1144                 break;
1145
1146         case SMP_CMD_PAIRING_FAIL:
1147                 smp_failure(conn, 0);
1148                 reason = 0;
1149                 err = -EPERM;
1150                 break;
1151
1152         case SMP_CMD_PAIRING_RSP:
1153                 reason = smp_cmd_pairing_rsp(conn, skb);
1154                 break;
1155
1156         case SMP_CMD_SECURITY_REQ:
1157                 reason = smp_cmd_security_req(conn, skb);
1158                 break;
1159
1160         case SMP_CMD_PAIRING_CONFIRM:
1161                 reason = smp_cmd_pairing_confirm(conn, skb);
1162                 break;
1163
1164         case SMP_CMD_PAIRING_RANDOM:
1165                 reason = smp_cmd_pairing_random(conn, skb);
1166                 break;
1167
1168         case SMP_CMD_ENCRYPT_INFO:
1169                 reason = smp_cmd_encrypt_info(conn, skb);
1170                 break;
1171
1172         case SMP_CMD_MASTER_IDENT:
1173                 reason = smp_cmd_master_ident(conn, skb);
1174                 break;
1175
1176         case SMP_CMD_IDENT_INFO:
1177                 reason = smp_cmd_ident_info(conn, skb);
1178                 break;
1179
1180         case SMP_CMD_IDENT_ADDR_INFO:
1181                 reason = smp_cmd_ident_addr_info(conn, skb);
1182                 break;
1183
1184         case SMP_CMD_SIGN_INFO:
1185                 reason = smp_cmd_sign_info(conn, skb);
1186                 break;
1187
1188         default:
1189                 BT_DBG("Unknown command code 0x%2.2x", code);
1190
1191                 reason = SMP_CMD_NOTSUPP;
1192                 err = -EOPNOTSUPP;
1193                 goto done;
1194         }
1195
1196 done:
1197         if (reason)
1198                 smp_failure(conn, reason);
1199
1200         kfree_skb(skb);
1201         return err;
1202 }
1203
1204 static void smp_notify_keys(struct l2cap_conn *conn)
1205 {
1206         struct smp_chan *smp = conn->smp_chan;
1207         struct hci_conn *hcon = conn->hcon;
1208         struct hci_dev *hdev = hcon->hdev;
1209         struct smp_cmd_pairing *req = (void *) &smp->preq[1];
1210         struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
1211         bool persistent;
1212
1213         if (smp->remote_irk) {
1214                 mgmt_new_irk(hdev, smp->remote_irk);
1215                 /* Now that user space can be considered to know the
1216                  * identity address track the connection based on it
1217                  * from now on.
1218                  */
1219                 bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
1220                 hcon->dst_type = smp->remote_irk->addr_type;
1221                 l2cap_conn_update_id_addr(hcon);
1222         }
1223
1224         /* The LTKs and CSRKs should be persistent only if both sides
1225          * had the bonding bit set in their authentication requests.
1226          */
1227         persistent = !!((req->auth_req & rsp->auth_req) & SMP_AUTH_BONDING);
1228
1229         if (smp->csrk) {
1230                 smp->csrk->bdaddr_type = hcon->dst_type;
1231                 bacpy(&smp->csrk->bdaddr, &hcon->dst);
1232                 mgmt_new_csrk(hdev, smp->csrk, persistent);
1233         }
1234
1235         if (smp->slave_csrk) {
1236                 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1237                 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
1238                 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
1239         }
1240
1241         if (smp->ltk) {
1242                 smp->ltk->bdaddr_type = hcon->dst_type;
1243                 bacpy(&smp->ltk->bdaddr, &hcon->dst);
1244                 mgmt_new_ltk(hdev, smp->ltk, persistent);
1245         }
1246
1247         if (smp->slave_ltk) {
1248                 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1249                 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
1250                 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
1251         }
1252 }
1253
1254 int smp_distribute_keys(struct l2cap_conn *conn)
1255 {
1256         struct smp_cmd_pairing *req, *rsp;
1257         struct smp_chan *smp = conn->smp_chan;
1258         struct hci_conn *hcon = conn->hcon;
1259         struct hci_dev *hdev = hcon->hdev;
1260         __u8 *keydist;
1261
1262         BT_DBG("conn %p", conn);
1263
1264         if (!test_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
1265                 return 0;
1266
1267         rsp = (void *) &smp->prsp[1];
1268
1269         /* The responder sends its keys first */
1270         if (hcon->out && (smp->remote_key_dist & 0x07))
1271                 return 0;
1272
1273         req = (void *) &smp->preq[1];
1274
1275         if (hcon->out) {
1276                 keydist = &rsp->init_key_dist;
1277                 *keydist &= req->init_key_dist;
1278         } else {
1279                 keydist = &rsp->resp_key_dist;
1280                 *keydist &= req->resp_key_dist;
1281         }
1282
1283         BT_DBG("keydist 0x%x", *keydist);
1284
1285         if (*keydist & SMP_DIST_ENC_KEY) {
1286                 struct smp_cmd_encrypt_info enc;
1287                 struct smp_cmd_master_ident ident;
1288                 struct smp_ltk *ltk;
1289                 u8 authenticated;
1290                 __le16 ediv;
1291                 __le64 rand;
1292
1293                 get_random_bytes(enc.ltk, sizeof(enc.ltk));
1294                 get_random_bytes(&ediv, sizeof(ediv));
1295                 get_random_bytes(&rand, sizeof(rand));
1296
1297                 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1298
1299                 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
1300                 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
1301                                   HCI_SMP_LTK_SLAVE, authenticated, enc.ltk,
1302                                   smp->enc_key_size, ediv, rand);
1303                 smp->slave_ltk = ltk;
1304
1305                 ident.ediv = ediv;
1306                 ident.rand = rand;
1307
1308                 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1309
1310                 *keydist &= ~SMP_DIST_ENC_KEY;
1311         }
1312
1313         if (*keydist & SMP_DIST_ID_KEY) {
1314                 struct smp_cmd_ident_addr_info addrinfo;
1315                 struct smp_cmd_ident_info idinfo;
1316
1317                 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
1318
1319                 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1320
1321                 /* The hci_conn contains the local identity address
1322                  * after the connection has been established.
1323                  *
1324                  * This is true even when the connection has been
1325                  * established using a resolvable random address.
1326                  */
1327                 bacpy(&addrinfo.bdaddr, &hcon->src);
1328                 addrinfo.addr_type = hcon->src_type;
1329
1330                 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1331                              &addrinfo);
1332
1333                 *keydist &= ~SMP_DIST_ID_KEY;
1334         }
1335
1336         if (*keydist & SMP_DIST_SIGN) {
1337                 struct smp_cmd_sign_info sign;
1338                 struct smp_csrk *csrk;
1339
1340                 /* Generate a new random key */
1341                 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1342
1343                 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1344                 if (csrk) {
1345                         csrk->master = 0x00;
1346                         memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1347                 }
1348                 smp->slave_csrk = csrk;
1349
1350                 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1351
1352                 *keydist &= ~SMP_DIST_SIGN;
1353         }
1354
1355         /* If there are still keys to be received wait for them */
1356         if ((smp->remote_key_dist & 0x07))
1357                 return 0;
1358
1359         clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags);
1360         cancel_delayed_work_sync(&conn->security_timer);
1361         set_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
1362         smp_notify_keys(conn);
1363
1364         smp_chan_destroy(conn);
1365
1366         return 0;
1367 }