net/bluetooth/smp.c

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