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