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         /* If Just Works, Continue with Zero TK */
 391         if (method == JUST_WORKS) {
 392                 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 393                 return 0;
 394         }
 395
 396         /* Not Just Works/Confirm results in MITM Authentication */
 397         if (method != JUST_CFM)
 398                 set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags);
 399
 400         /* If both devices have Keyoard-Display I/O, the master
 401          * Confirms and the slave Enters the passkey.
 402          */
 403         if (method == OVERLAP) {
 404                 if (hcon->link_mode & HCI_LM_MASTER)
 405                         method = CFM_PASSKEY;
 406                 else
 407                         method = REQ_PASSKEY;
 408         }
 409
 410         /* Generate random passkey. */
 411         if (method == CFM_PASSKEY) {
 412                 memset(smp->tk, 0, sizeof(smp->tk));
 413                 get_random_bytes(&passkey, sizeof(passkey));
 414                 passkey %= 1000000;
 415                 put_unaligned_le32(passkey, smp->tk);
 416                 BT_DBG("PassKey: %d", passkey);
 417                 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 418         }
 419
 420         hci_dev_lock(hcon->hdev);
 421
 422         if (method == REQ_PASSKEY)
 423                 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
 424                                                 hcon->type, hcon->dst_type);
 425         else
 426                 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
 427                                                 hcon->type, hcon->dst_type,
 428                                                 passkey, 0);
 429
 430         hci_dev_unlock(hcon->hdev);
 431
 432         return ret;
 433 }
 434
 435 static void confirm_work(struct work_struct *work)
 436 {
 437         struct smp_chan *smp = container_of(work, struct smp_chan, confirm);
 438         struct l2cap_conn *conn = smp->conn;
 439         struct hci_dev *hdev = conn->hcon->hdev;
 440         struct crypto_blkcipher *tfm = hdev->tfm_aes;
 441         struct smp_cmd_pairing_confirm cp;
 442         int ret;
 443         u8 reason;
 444
 445         BT_DBG("conn %p", conn);
 446
 447         /* Prevent mutual access to hdev->tfm_aes */
 448         hci_dev_lock(hdev);
 449
 450         ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
 451                      conn->hcon->init_addr_type, &conn->hcon->init_addr,
 452                      conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
 453                      cp.confirm_val);
 454
 455         hci_dev_unlock(hdev);
 456
 457         if (ret) {
 458                 reason = SMP_UNSPECIFIED;
 459                 goto error;
 460         }
 461
 462         clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 463
 464         smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
 465
 466         return;
 467
 468 error:
 469         smp_failure(conn, reason);
 470 }
 471
 472 static void random_work(struct work_struct *work)
 473 {
 474         struct smp_chan *smp = container_of(work, struct smp_chan, random);
 475         struct l2cap_conn *conn = smp->conn;
 476         struct hci_conn *hcon = conn->hcon;
 477         struct hci_dev *hdev = hcon->hdev;
 478         struct crypto_blkcipher *tfm = hdev->tfm_aes;
 479         u8 reason, confirm[16];
 480         int ret;
 481
 482         if (IS_ERR_OR_NULL(tfm)) {
 483                 reason = SMP_UNSPECIFIED;
 484                 goto error;
 485         }
 486
 487         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 488
 489         /* Prevent mutual access to hdev->tfm_aes */
 490         hci_dev_lock(hdev);
 491
 492         ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
 493                      hcon->init_addr_type, &hcon->init_addr,
 494                      hcon->resp_addr_type, &hcon->resp_addr, confirm);
 495
 496         hci_dev_unlock(hdev);
 497
 498         if (ret) {
 499                 reason = SMP_UNSPECIFIED;
 500                 goto error;
 501         }
 502
 503         if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
 504                 BT_ERR("Pairing failed (confirmation values mismatch)");
 505                 reason = SMP_CONFIRM_FAILED;
 506                 goto error;
 507         }
 508
 509         if (hcon->out) {
 510                 u8 stk[16];
 511                 __le64 rand = 0;
 512                 __le16 ediv = 0;
 513
 514                 smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, stk);
 515
 516                 memset(stk + smp->enc_key_size, 0,
 517                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 518
 519                 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) {
 520                         reason = SMP_UNSPECIFIED;
 521                         goto error;
 522                 }
 523
 524                 hci_le_start_enc(hcon, ediv, rand, stk);
 525                 hcon->enc_key_size = smp->enc_key_size;
 526         } else {
 527                 u8 stk[16];
 528                 __le64 rand = 0;
 529                 __le16 ediv = 0;
 530
 531                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
 532                              smp->prnd);
 533
 534                 smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, stk);
 535
 536                 memset(stk + smp->enc_key_size, 0,
 537                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 538
 539                 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
 540                             HCI_SMP_STK_SLAVE, 0, stk, smp->enc_key_size,
 541                             ediv, rand);
 542         }
 543
 544         return;
 545
 546 error:
 547         smp_failure(conn, reason);
 548 }
 549
 550 static void smp_reencrypt(struct work_struct *work)
 551 {
 552         struct smp_chan *smp = container_of(work, struct smp_chan,
 553                                             reencrypt.work);
 554         struct l2cap_conn *conn = smp->conn;
 555         struct hci_conn *hcon = conn->hcon;
 556         struct smp_ltk *ltk = smp->ltk;
 557
 558         BT_DBG("");
 559
 560         hci_le_start_enc(hcon, ltk->ediv, ltk->rand, ltk->val);
 561         hcon->enc_key_size = ltk->enc_size;
 562 }
 563
 564 static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
 565 {
 566         struct smp_chan *smp;
 567
 568         smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
 569         if (!smp)
 570                 return NULL;
 571
 572         INIT_WORK(&smp->confirm, confirm_work);
 573         INIT_WORK(&smp->random, random_work);
 574         INIT_DELAYED_WORK(&smp->reencrypt, smp_reencrypt);
 575
 576         smp->conn = conn;
 577         conn->smp_chan = smp;
 578         conn->hcon->smp_conn = conn;
 579
 580         hci_conn_hold(conn->hcon);
 581
 582         return smp;
 583 }
 584
 585 void smp_chan_destroy(struct l2cap_conn *conn)
 586 {
 587         struct smp_chan *smp = conn->smp_chan;
 588         bool complete;
 589
 590         BUG_ON(!smp);
 591
 592         cancel_delayed_work_sync(&smp->reencrypt);
 593
 594         complete = test_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
 595         mgmt_smp_complete(conn->hcon, complete);
 596
 597         kfree(smp->csrk);
 598         kfree(smp->slave_csrk);
 599
 600         /* If pairing failed clean up any keys we might have */
 601         if (!complete) {
 602                 if (smp->ltk) {
 603                         list_del(&smp->ltk->list);
 604                         kfree(smp->ltk);
 605                 }
 606
 607                 if (smp->slave_ltk) {
 608                         list_del(&smp->slave_ltk->list);
 609                         kfree(smp->slave_ltk);
 610                 }
 611
 612                 if (smp->remote_irk) {
 613                         list_del(&smp->remote_irk->list);
 614                         kfree(smp->remote_irk);
 615                 }
 616         }
 617
 618         kfree(smp);
 619         conn->smp_chan = NULL;
 620         conn->hcon->smp_conn = NULL;
 621         hci_conn_drop(conn->hcon);
 622 }
 623
 624 int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
 625 {
 626         struct l2cap_conn *conn = hcon->smp_conn;
 627         struct smp_chan *smp;
 628         u32 value;
 629
 630         BT_DBG("");
 631
 632         if (!conn)
 633                 return -ENOTCONN;
 634
 635         smp = conn->smp_chan;
 636
 637         switch (mgmt_op) {
 638         case MGMT_OP_USER_PASSKEY_REPLY:
 639                 value = le32_to_cpu(passkey);
 640                 memset(smp->tk, 0, sizeof(smp->tk));
 641                 BT_DBG("PassKey: %d", value);
 642                 put_unaligned_le32(value, smp->tk);
 643                 /* Fall Through */
 644         case MGMT_OP_USER_CONFIRM_REPLY:
 645                 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 646                 break;
 647         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
 648         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
 649                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
 650                 return 0;
 651         default:
 652                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
 653                 return -EOPNOTSUPP;
 654         }
 655
 656         /* If it is our turn to send Pairing Confirm, do so now */
 657         if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags))
 658                 queue_work(hcon->hdev->workqueue, &smp->confirm);
 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;
 668         u8 auth = SMP_AUTH_NONE;
 669         int ret;
 670
 671         BT_DBG("conn %p", conn);
 672
 673         if (skb->len < sizeof(*req))
 674                 return SMP_UNSPECIFIED;
 675
 676         if (conn->hcon->link_mode & HCI_LM_MASTER)
 677                 return SMP_CMD_NOTSUPP;
 678
 679         if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
 680                 smp = smp_chan_create(conn);
 681         else
 682                 smp = conn->smp_chan;
 683
 684         if (!smp)
 685                 return SMP_UNSPECIFIED;
 686
 687         smp->preq[0] = SMP_CMD_PAIRING_REQ;
 688         memcpy(&smp->preq[1], req, sizeof(*req));
 689         skb_pull(skb, sizeof(*req));
 690
 691         /* We didn't start the pairing, so match remote */
 692         if (req->auth_req & SMP_AUTH_BONDING)
 693                 auth = req->auth_req;
 694
 695         conn->hcon->pending_sec_level = authreq_to_seclevel(auth);
 696
 697         build_pairing_cmd(conn, req, &rsp, auth);
 698
 699         key_size = min(req->max_key_size, rsp.max_key_size);
 700         if (check_enc_key_size(conn, key_size))
 701                 return SMP_ENC_KEY_SIZE;
 702
 703         get_random_bytes(smp->prnd, sizeof(smp->prnd));
 704
 705         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
 706         memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
 707
 708         smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
 709
 710         /* Request setup of TK */
 711         ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
 712         if (ret)
 713                 return SMP_UNSPECIFIED;
 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         struct hci_dev *hdev = conn->hcon->hdev;
 723         u8 key_size, auth = SMP_AUTH_NONE;
 724         int ret;
 725
 726         BT_DBG("conn %p", conn);
 727
 728         if (skb->len < sizeof(*rsp))
 729                 return SMP_UNSPECIFIED;
 730
 731         if (!(conn->hcon->link_mode & HCI_LM_MASTER))
 732                 return SMP_CMD_NOTSUPP;
 733
 734         skb_pull(skb, sizeof(*rsp));
 735
 736         req = (void *) &smp->preq[1];
 737
 738         key_size = min(req->max_key_size, rsp->max_key_size);
 739         if (check_enc_key_size(conn, key_size))
 740                 return SMP_ENC_KEY_SIZE;
 741
 742         get_random_bytes(smp->prnd, sizeof(smp->prnd));
 743
 744         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
 745         memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
 746
 747         /* Update remote key distribution in case the remote cleared
 748          * some bits that we had enabled in our request.
 749          */
 750         smp->remote_key_dist &= rsp->resp_key_dist;
 751
 752         if ((req->auth_req & SMP_AUTH_BONDING) &&
 753             (rsp->auth_req & SMP_AUTH_BONDING))
 754                 auth = SMP_AUTH_BONDING;
 755
 756         auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
 757
 758         ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
 759         if (ret)
 760                 return SMP_UNSPECIFIED;
 761
 762         set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 763
 764         /* Can't compose response until we have been confirmed */
 765         if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
 766                 queue_work(hdev->workqueue, &smp->confirm);
 767
 768         return 0;
 769 }
 770
 771 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
 772 {
 773         struct smp_chan *smp = conn->smp_chan;
 774         struct hci_dev *hdev = conn->hcon->hdev;
 775
 776         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 777
 778         if (skb->len < sizeof(smp->pcnf))
 779                 return SMP_UNSPECIFIED;
 780
 781         memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
 782         skb_pull(skb, sizeof(smp->pcnf));
 783
 784         if (conn->hcon->out)
 785                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
 786                              smp->prnd);
 787         else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
 788                 queue_work(hdev->workqueue, &smp->confirm);
 789         else
 790                 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 791
 792         return 0;
 793 }
 794
 795 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
 796 {
 797         struct smp_chan *smp = conn->smp_chan;
 798         struct hci_dev *hdev = conn->hcon->hdev;
 799
 800         BT_DBG("conn %p", conn);
 801
 802         if (skb->len < sizeof(smp->rrnd))
 803                 return SMP_UNSPECIFIED;
 804
 805         memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
 806         skb_pull(skb, sizeof(smp->rrnd));
 807
 808         queue_work(hdev->workqueue, &smp->random);
 809
 810         return 0;
 811 }
 812
 813 static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
 814 {
 815         struct smp_ltk *key;
 816         struct hci_conn *hcon = conn->hcon;
 817
 818         key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type,
 819                                    hcon->out);
 820         if (!key)
 821                 return 0;
 822
 823         if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
 824                 return 0;
 825
 826         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
 827                 return 1;
 828
 829         hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
 830         hcon->enc_key_size = key->enc_size;
 831
 832         return 1;
 833 }
 834
 835 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
 836 {
 837         struct smp_cmd_security_req *rp = (void *) skb->data;
 838         struct smp_cmd_pairing cp;
 839         struct hci_conn *hcon = conn->hcon;
 840         struct smp_chan *smp;
 841
 842         BT_DBG("conn %p", conn);
 843
 844         if (skb->len < sizeof(*rp))
 845                 return SMP_UNSPECIFIED;
 846
 847         if (!(conn->hcon->link_mode & HCI_LM_MASTER))
 848                 return SMP_CMD_NOTSUPP;
 849
 850         hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
 851
 852         if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
 853                 return 0;
 854
 855         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 856                 return 0;
 857
 858         smp = smp_chan_create(conn);
 859
 860         skb_pull(skb, sizeof(*rp));
 861
 862         memset(&cp, 0, sizeof(cp));
 863         build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
 864
 865         smp->preq[0] = SMP_CMD_PAIRING_REQ;
 866         memcpy(&smp->preq[1], &cp, sizeof(cp));
 867
 868         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 869
 870         return 0;
 871 }
 872
 873 bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level)
 874 {
 875         if (sec_level == BT_SECURITY_LOW)
 876                 return true;
 877
 878         if (hcon->sec_level >= sec_level)
 879                 return true;
 880
 881         return false;
 882 }
 883
 884 int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
 885 {
 886         struct l2cap_conn *conn = hcon->l2cap_data;
 887         struct smp_chan *smp;
 888         __u8 authreq;
 889
 890         BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
 891
 892         /* This may be NULL if there's an unexpected disconnection */
 893         if (!conn)
 894                 return 1;
 895
 896         smp = conn->smp_chan;
 897
 898         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
 899                 return 1;
 900
 901         if (smp_sufficient_security(hcon, sec_level))
 902                 return 1;
 903
 904         if (hcon->link_mode & HCI_LM_MASTER)
 905                 if (smp_ltk_encrypt(conn, sec_level))
 906                         goto done;
 907
 908         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 909                 return 0;
 910
 911         smp = smp_chan_create(conn);
 912         if (!smp)
 913                 return 1;
 914
 915         authreq = seclevel_to_authreq(sec_level);
 916
 917         /* hcon->auth_type is set by pair_device in mgmt.c. If the MITM
 918          * flag is set we should also set it for the SMP request.
 919          */
 920         if ((hcon->auth_type & 0x01))
 921                 authreq |= SMP_AUTH_MITM;
 922
 923         if (hcon->link_mode & HCI_LM_MASTER) {
 924                 struct smp_cmd_pairing cp;
 925
 926                 build_pairing_cmd(conn, &cp, NULL, authreq);
 927                 smp->preq[0] = SMP_CMD_PAIRING_REQ;
 928                 memcpy(&smp->preq[1], &cp, sizeof(cp));
 929
 930                 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 931         } else {
 932                 struct smp_cmd_security_req cp;
 933                 cp.auth_req = authreq;
 934                 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
 935         }
 936
 937 done:
 938         hcon->pending_sec_level = sec_level;
 939
 940         return 0;
 941 }
 942
 943 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
 944 {
 945         struct smp_cmd_encrypt_info *rp = (void *) skb->data;
 946         struct smp_chan *smp = conn->smp_chan;
 947
 948         BT_DBG("conn %p", conn);
 949
 950         if (skb->len < sizeof(*rp))
 951                 return SMP_UNSPECIFIED;
 952
 953         /* Ignore this PDU if it wasn't requested */
 954         if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
 955                 return 0;
 956
 957         skb_pull(skb, sizeof(*rp));
 958
 959         memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
 960
 961         return 0;
 962 }
 963
 964 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
 965 {
 966         struct smp_cmd_master_ident *rp = (void *) skb->data;
 967         struct smp_chan *smp = conn->smp_chan;
 968         struct hci_dev *hdev = conn->hcon->hdev;
 969         struct hci_conn *hcon = conn->hcon;
 970         struct smp_ltk *ltk;
 971         u8 authenticated;
 972
 973         BT_DBG("conn %p", conn);
 974
 975         if (skb->len < sizeof(*rp))
 976                 return SMP_UNSPECIFIED;
 977
 978         /* Ignore this PDU if it wasn't requested */
 979         if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
 980                 return 0;
 981
 982         /* Mark the information as received */
 983         smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
 984
 985         skb_pull(skb, sizeof(*rp));
 986
 987         hci_dev_lock(hdev);
 988         authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
 989         ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK,
 990                           authenticated, smp->tk, smp->enc_key_size,
 991                           rp->ediv, rp->rand);
 992         smp->ltk = ltk;
 993         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
 994                 smp_distribute_keys(conn);
 995         hci_dev_unlock(hdev);
 996
 997         return 0;
 998 }
 999
1000 static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
1001 {
1002         struct smp_cmd_ident_info *info = (void *) skb->data;
1003         struct smp_chan *smp = conn->smp_chan;
1004
1005         BT_DBG("");
1006
1007         if (skb->len < sizeof(*info))
1008                 return SMP_UNSPECIFIED;
1009
1010         /* Ignore this PDU if it wasn't requested */
1011         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1012                 return 0;
1013
1014         skb_pull(skb, sizeof(*info));
1015
1016         memcpy(smp->irk, info->irk, 16);
1017
1018         return 0;
1019 }
1020
1021 static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
1022                                    struct sk_buff *skb)
1023 {
1024         struct smp_cmd_ident_addr_info *info = (void *) skb->data;
1025         struct smp_chan *smp = conn->smp_chan;
1026         struct hci_conn *hcon = conn->hcon;
1027         bdaddr_t rpa;
1028
1029         BT_DBG("");
1030
1031         if (skb->len < sizeof(*info))
1032                 return SMP_UNSPECIFIED;
1033
1034         /* Ignore this PDU if it wasn't requested */
1035         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1036                 return 0;
1037
1038         /* Mark the information as received */
1039         smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
1040
1041         skb_pull(skb, sizeof(*info));
1042
1043         /* Strictly speaking the Core Specification (4.1) allows sending
1044          * an empty address which would force us to rely on just the IRK
1045          * as "identity information". However, since such
1046          * implementations are not known of and in order to not over
1047          * complicate our implementation, simply pretend that we never
1048          * received an IRK for such a device.
1049          */
1050         if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
1051                 BT_ERR("Ignoring IRK with no identity address");
1052                 smp_distribute_keys(conn);
1053                 return 0;
1054         }
1055
1056         bacpy(&smp->id_addr, &info->bdaddr);
1057         smp->id_addr_type = info->addr_type;
1058
1059         if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
1060                 bacpy(&rpa, &hcon->dst);
1061         else
1062                 bacpy(&rpa, BDADDR_ANY);
1063
1064         smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
1065                                       smp->id_addr_type, smp->irk, &rpa);
1066
1067         smp_distribute_keys(conn);
1068
1069         return 0;
1070 }
1071
1072 static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
1073 {
1074         struct smp_cmd_sign_info *rp = (void *) skb->data;
1075         struct smp_chan *smp = conn->smp_chan;
1076         struct hci_dev *hdev = conn->hcon->hdev;
1077         struct smp_csrk *csrk;
1078
1079         BT_DBG("conn %p", conn);
1080
1081         if (skb->len < sizeof(*rp))
1082                 return SMP_UNSPECIFIED;
1083
1084         /* Ignore this PDU if it wasn't requested */
1085         if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1086                 return 0;
1087
1088         /* Mark the information as received */
1089         smp->remote_key_dist &= ~SMP_DIST_SIGN;
1090
1091         skb_pull(skb, sizeof(*rp));
1092
1093         hci_dev_lock(hdev);
1094         csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1095         if (csrk) {
1096                 csrk->master = 0x01;
1097                 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
1098         }
1099         smp->csrk = csrk;
1100         if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1101                 smp_distribute_keys(conn);
1102         hci_dev_unlock(hdev);
1103
1104         return 0;
1105 }
1106
1107 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
1108 {
1109         struct hci_conn *hcon = conn->hcon;
1110         __u8 code, reason;
1111         int err = 0;
1112
1113         if (hcon->type != LE_LINK) {
1114                 kfree_skb(skb);
1115                 return 0;
1116         }
1117
1118         if (skb->len < 1) {
1119                 kfree_skb(skb);
1120                 return -EILSEQ;
1121         }
1122
1123         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
1124                 err = -ENOTSUPP;
1125                 reason = SMP_PAIRING_NOTSUPP;
1126                 goto done;
1127         }
1128
1129         code = skb->data[0];
1130         skb_pull(skb, sizeof(code));
1131
1132         /*
1133          * The SMP context must be initialized for all other PDUs except
1134          * pairing and security requests. If we get any other PDU when
1135          * not initialized simply disconnect (done if this function
1136          * returns an error).
1137          */
1138         if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
1139             !conn->smp_chan) {
1140                 BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
1141                 kfree_skb(skb);
1142                 return -ENOTSUPP;
1143         }
1144
1145         switch (code) {
1146         case SMP_CMD_PAIRING_REQ:
1147                 reason = smp_cmd_pairing_req(conn, skb);
1148                 break;
1149
1150         case SMP_CMD_PAIRING_FAIL:
1151                 smp_failure(conn, 0);
1152                 reason = 0;
1153                 err = -EPERM;
1154                 break;
1155
1156         case SMP_CMD_PAIRING_RSP:
1157                 reason = smp_cmd_pairing_rsp(conn, skb);
1158                 break;
1159
1160         case SMP_CMD_SECURITY_REQ:
1161                 reason = smp_cmd_security_req(conn, skb);
1162                 break;
1163
1164         case SMP_CMD_PAIRING_CONFIRM:
1165                 reason = smp_cmd_pairing_confirm(conn, skb);
1166                 break;
1167
1168         case SMP_CMD_PAIRING_RANDOM:
1169                 reason = smp_cmd_pairing_random(conn, skb);
1170                 break;
1171
1172         case SMP_CMD_ENCRYPT_INFO:
1173                 reason = smp_cmd_encrypt_info(conn, skb);
1174                 break;
1175
1176         case SMP_CMD_MASTER_IDENT:
1177                 reason = smp_cmd_master_ident(conn, skb);
1178                 break;
1179
1180         case SMP_CMD_IDENT_INFO:
1181                 reason = smp_cmd_ident_info(conn, skb);
1182                 break;
1183
1184         case SMP_CMD_IDENT_ADDR_INFO:
1185                 reason = smp_cmd_ident_addr_info(conn, skb);
1186                 break;
1187
1188         case SMP_CMD_SIGN_INFO:
1189                 reason = smp_cmd_sign_info(conn, skb);
1190                 break;
1191
1192         default:
1193                 BT_DBG("Unknown command code 0x%2.2x", code);
1194
1195                 reason = SMP_CMD_NOTSUPP;
1196                 err = -EOPNOTSUPP;
1197                 goto done;
1198         }
1199
1200 done:
1201         if (reason)
1202                 smp_failure(conn, reason);
1203
1204         kfree_skb(skb);
1205         return err;
1206 }
1207
1208 static void smp_notify_keys(struct l2cap_conn *conn)
1209 {
1210         struct smp_chan *smp = conn->smp_chan;
1211         struct hci_conn *hcon = conn->hcon;
1212         struct hci_dev *hdev = hcon->hdev;
1213         struct smp_cmd_pairing *req = (void *) &smp->preq[1];
1214         struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
1215         bool persistent;
1216
1217         if (smp->remote_irk) {
1218                 mgmt_new_irk(hdev, smp->remote_irk);
1219                 /* Now that user space can be considered to know the
1220                  * identity address track the connection based on it
1221                  * from now on.
1222                  */
1223                 bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
1224                 hcon->dst_type = smp->remote_irk->addr_type;
1225                 l2cap_conn_update_id_addr(hcon);
1226         }
1227
1228         /* The LTKs and CSRKs should be persistent only if both sides
1229          * had the bonding bit set in their authentication requests.
1230          */
1231         persistent = !!((req->auth_req & rsp->auth_req) & SMP_AUTH_BONDING);
1232
1233         if (smp->csrk) {
1234                 smp->csrk->bdaddr_type = hcon->dst_type;
1235                 bacpy(&smp->csrk->bdaddr, &hcon->dst);
1236                 mgmt_new_csrk(hdev, smp->csrk, persistent);
1237         }
1238
1239         if (smp->slave_csrk) {
1240                 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1241                 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
1242                 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
1243         }
1244
1245         if (smp->ltk) {
1246                 smp->ltk->bdaddr_type = hcon->dst_type;
1247                 bacpy(&smp->ltk->bdaddr, &hcon->dst);
1248                 mgmt_new_ltk(hdev, smp->ltk, persistent);
1249         }
1250
1251         if (smp->slave_ltk) {
1252                 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1253                 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
1254                 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
1255         }
1256 }
1257
1258 int smp_distribute_keys(struct l2cap_conn *conn)
1259 {
1260         struct smp_cmd_pairing *req, *rsp;
1261         struct smp_chan *smp = conn->smp_chan;
1262         struct hci_conn *hcon = conn->hcon;
1263         struct hci_dev *hdev = hcon->hdev;
1264         bool ltk_encrypt;
1265         __u8 *keydist;
1266
1267         BT_DBG("conn %p", conn);
1268
1269         if (!test_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
1270                 return 0;
1271
1272         rsp = (void *) &smp->prsp[1];
1273
1274         /* The responder sends its keys first */
1275         if (hcon->out && (smp->remote_key_dist & 0x07))
1276                 return 0;
1277
1278         req = (void *) &smp->preq[1];
1279
1280         if (hcon->out) {
1281                 keydist = &rsp->init_key_dist;
1282                 *keydist &= req->init_key_dist;
1283         } else {
1284                 keydist = &rsp->resp_key_dist;
1285                 *keydist &= req->resp_key_dist;
1286         }
1287
1288         BT_DBG("keydist 0x%x", *keydist);
1289
1290         if (*keydist & SMP_DIST_ENC_KEY) {
1291                 struct smp_cmd_encrypt_info enc;
1292                 struct smp_cmd_master_ident ident;
1293                 struct smp_ltk *ltk;
1294                 u8 authenticated;
1295                 __le16 ediv;
1296                 __le64 rand;
1297
1298                 get_random_bytes(enc.ltk, sizeof(enc.ltk));
1299                 get_random_bytes(&ediv, sizeof(ediv));
1300                 get_random_bytes(&rand, sizeof(rand));
1301
1302                 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1303
1304                 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
1305                 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
1306                                   HCI_SMP_LTK_SLAVE, authenticated, enc.ltk,
1307                                   smp->enc_key_size, ediv, rand);
1308                 smp->slave_ltk = ltk;
1309
1310                 ident.ediv = ediv;
1311                 ident.rand = rand;
1312
1313                 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1314
1315                 *keydist &= ~SMP_DIST_ENC_KEY;
1316         }
1317
1318         if (*keydist & SMP_DIST_ID_KEY) {
1319                 struct smp_cmd_ident_addr_info addrinfo;
1320                 struct smp_cmd_ident_info idinfo;
1321
1322                 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
1323
1324                 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1325
1326                 /* The hci_conn contains the local identity address
1327                  * after the connection has been established.
1328                  *
1329                  * This is true even when the connection has been
1330                  * established using a resolvable random address.
1331                  */
1332                 bacpy(&addrinfo.bdaddr, &hcon->src);
1333                 addrinfo.addr_type = hcon->src_type;
1334
1335                 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1336                              &addrinfo);
1337
1338                 *keydist &= ~SMP_DIST_ID_KEY;
1339         }
1340
1341         if (*keydist & SMP_DIST_SIGN) {
1342                 struct smp_cmd_sign_info sign;
1343                 struct smp_csrk *csrk;
1344
1345                 /* Generate a new random key */
1346                 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1347
1348                 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1349                 if (csrk) {
1350                         csrk->master = 0x00;
1351                         memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1352                 }
1353                 smp->slave_csrk = csrk;
1354
1355                 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1356
1357                 *keydist &= ~SMP_DIST_SIGN;
1358         }
1359
1360         /* If there are still keys to be received wait for them */
1361         if ((smp->remote_key_dist & 0x07))
1362                 return 0;
1363
1364         /* Check if we should try to re-encrypt the link with the LTK.
1365          * SMP_FLAG_LTK_ENCRYPT flag is used to track whether we've
1366          * already tried this (in which case we shouldn't try again).
1367          *
1368          * The request will trigger an encryption key refresh event
1369          * which will cause a call to auth_cfm and eventually lead to
1370          * l2cap_core.c calling this smp_distribute_keys function again
1371          * and thereby completing the process.
1372          */
1373         if (smp->ltk)
1374                 ltk_encrypt = !test_and_set_bit(SMP_FLAG_LTK_ENCRYPT,
1375                                                 &smp->smp_flags);
1376         else
1377                 ltk_encrypt = false;
1378
1379         /* Re-encrypt the link with LTK if possible */
1380         if (ltk_encrypt && hcon->out) {
1381                 queue_delayed_work(hdev->req_workqueue, &smp->reencrypt,
1382                                    SMP_REENCRYPT_TIMEOUT);
1383         } else {
1384                 clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags);
1385                 cancel_delayed_work_sync(&conn->security_timer);
1386                 set_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
1387                 smp_notify_keys(conn);
1388                 smp_chan_destroy(conn);
1389         }
1390
1391         return 0;
1392 }