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