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