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 "ecc.h"
  33 #include "smp.h"
  34
  35 /* Low-level debug macros to be used for stuff that we don't want
  36  * accidentially in dmesg, i.e. the values of the various crypto keys
  37  * and the inputs & outputs of crypto functions.
  38  */
  39 #ifdef DEBUG
  40 #define SMP_DBG(fmt, ...) printk(KERN_DEBUG "%s: " fmt, __func__, \
  41                                  ##__VA_ARGS__)
  42 #else
  43 #define SMP_DBG(fmt, ...) no_printk(KERN_DEBUG "%s: " fmt, __func__, \
  44                                     ##__VA_ARGS__)
  45 #endif
  46
  47 #define SMP_ALLOW_CMD(smp, code)        set_bit(code, &smp->allow_cmd)
  48
  49 /* Keys which are not distributed with Secure Connections */
  50 #define SMP_SC_NO_DIST (SMP_DIST_ENC_KEY | SMP_DIST_LINK_KEY);
  51
  52 #define SMP_TIMEOUT     msecs_to_jiffies(30000)
  53
  54 #define AUTH_REQ_MASK(dev)      (test_bit(HCI_SC_ENABLED, &(dev)->dev_flags) ? \
  55                                  0x1f : 0x07)
  56 #define KEY_DIST_MASK           0x07
  57
  58 /* Maximum message length that can be passed to aes_cmac */
  59 #define CMAC_MSG_MAX    80
  60
  61 enum {
  62         SMP_FLAG_TK_VALID,
  63         SMP_FLAG_CFM_PENDING,
  64         SMP_FLAG_MITM_AUTH,
  65         SMP_FLAG_COMPLETE,
  66         SMP_FLAG_INITIATOR,
  67         SMP_FLAG_SC,
  68         SMP_FLAG_REMOTE_PK,
  69         SMP_FLAG_DEBUG_KEY,
  70         SMP_FLAG_WAIT_USER,
  71         SMP_FLAG_DHKEY_PENDING,
  72         SMP_FLAG_OOB,
  73 };
  74
  75 struct smp_chan {
  76         struct l2cap_conn       *conn;
  77         struct delayed_work     security_timer;
  78         unsigned long           allow_cmd; /* Bitmask of allowed commands */
  79
  80         u8              preq[7]; /* SMP Pairing Request */
  81         u8              prsp[7]; /* SMP Pairing Response */
  82         u8              prnd[16]; /* SMP Pairing Random (local) */
  83         u8              rrnd[16]; /* SMP Pairing Random (remote) */
  84         u8              pcnf[16]; /* SMP Pairing Confirm */
  85         u8              tk[16]; /* SMP Temporary Key */
  86         u8              rr[16];
  87         u8              enc_key_size;
  88         u8              remote_key_dist;
  89         bdaddr_t        id_addr;
  90         u8              id_addr_type;
  91         u8              irk[16];
  92         struct smp_csrk *csrk;
  93         struct smp_csrk *slave_csrk;
  94         struct smp_ltk  *ltk;
  95         struct smp_ltk  *slave_ltk;
  96         struct smp_irk  *remote_irk;
  97         u8              *link_key;
  98         unsigned long   flags;
  99         u8              method;
 100         u8              passkey_round;
 101
 102         /* Secure Connections variables */
 103         u8                      local_pk[64];
 104         u8                      local_sk[32];
 105         u8                      remote_pk[64];
 106         u8                      dhkey[32];
 107         u8                      mackey[16];
 108
 109         struct crypto_blkcipher *tfm_aes;
 110         struct crypto_hash      *tfm_cmac;
 111 };
 112
 113 /* These debug key values are defined in the SMP section of the core
 114  * specification. debug_pk is the public debug key and debug_sk the
 115  * private debug key.
 116  */
 117 static const u8 debug_pk[64] = {
 118                 0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
 119                 0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
 120                 0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
 121                 0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20,
 122
 123                 0x8b, 0xd2, 0x89, 0x15, 0xd0, 0x8e, 0x1c, 0x74,
 124                 0x24, 0x30, 0xed, 0x8f, 0xc2, 0x45, 0x63, 0x76,
 125                 0x5c, 0x15, 0x52, 0x5a, 0xbf, 0x9a, 0x32, 0x63,
 126                 0x6d, 0xeb, 0x2a, 0x65, 0x49, 0x9c, 0x80, 0xdc,
 127 };
 128
 129 static const u8 debug_sk[32] = {
 130                 0xbd, 0x1a, 0x3c, 0xcd, 0xa6, 0xb8, 0x99, 0x58,
 131                 0x99, 0xb7, 0x40, 0xeb, 0x7b, 0x60, 0xff, 0x4a,
 132                 0x50, 0x3f, 0x10, 0xd2, 0xe3, 0xb3, 0xc9, 0x74,
 133                 0x38, 0x5f, 0xc5, 0xa3, 0xd4, 0xf6, 0x49, 0x3f,
 134 };
 135
 136 static inline void swap_buf(const u8 *src, u8 *dst, size_t len)
 137 {
 138         size_t i;
 139
 140         for (i = 0; i < len; i++)
 141                 dst[len - 1 - i] = src[i];
 142 }
 143
 144 /* The following functions map to the LE SC SMP crypto functions
 145  * AES-CMAC, f4, f5, f6, g2 and h6.
 146  */
 147
 148 static int aes_cmac(struct crypto_hash *tfm, const u8 k[16], const u8 *m,
 149                     size_t len, u8 mac[16])
 150 {
 151         uint8_t tmp[16], mac_msb[16], msg_msb[CMAC_MSG_MAX];
 152         struct hash_desc desc;
 153         struct scatterlist sg;
 154         int err;
 155
 156         if (len > CMAC_MSG_MAX)
 157                 return -EFBIG;
 158
 159         if (!tfm) {
 160                 BT_ERR("tfm %p", tfm);
 161                 return -EINVAL;
 162         }
 163
 164         desc.tfm = tfm;
 165         desc.flags = 0;
 166
 167         crypto_hash_init(&desc);
 168
 169         /* Swap key and message from LSB to MSB */
 170         swap_buf(k, tmp, 16);
 171         swap_buf(m, msg_msb, len);
 172
 173         SMP_DBG("msg (len %zu) %*phN", len, (int) len, m);
 174         SMP_DBG("key %16phN", k);
 175
 176         err = crypto_hash_setkey(tfm, tmp, 16);
 177         if (err) {
 178                 BT_ERR("cipher setkey failed: %d", err);
 179                 return err;
 180         }
 181
 182         sg_init_one(&sg, msg_msb, len);
 183
 184         err = crypto_hash_update(&desc, &sg, len);
 185         if (err) {
 186                 BT_ERR("Hash update error %d", err);
 187                 return err;
 188         }
 189
 190         err = crypto_hash_final(&desc, mac_msb);
 191         if (err) {
 192                 BT_ERR("Hash final error %d", err);
 193                 return err;
 194         }
 195
 196         swap_buf(mac_msb, mac, 16);
 197
 198         SMP_DBG("mac %16phN", mac);
 199
 200         return 0;
 201 }
 202
 203 static int smp_f4(struct crypto_hash *tfm_cmac, const u8 u[32], const u8 v[32],
 204                   const u8 x[16], u8 z, u8 res[16])
 205 {
 206         u8 m[65];
 207         int err;
 208
 209         SMP_DBG("u %32phN", u);
 210         SMP_DBG("v %32phN", v);
 211         SMP_DBG("x %16phN z %02x", x, z);
 212
 213         m[0] = z;
 214         memcpy(m + 1, v, 32);
 215         memcpy(m + 33, u, 32);
 216
 217         err = aes_cmac(tfm_cmac, x, m, sizeof(m), res);
 218         if (err)
 219                 return err;
 220
 221         SMP_DBG("res %16phN", res);
 222
 223         return err;
 224 }
 225
 226 static int smp_f5(struct crypto_hash *tfm_cmac, u8 w[32], u8 n1[16], u8 n2[16],
 227                   u8 a1[7], u8 a2[7], u8 mackey[16], u8 ltk[16])
 228 {
 229         /* The btle, salt and length "magic" values are as defined in
 230          * the SMP section of the Bluetooth core specification. In ASCII
 231          * the btle value ends up being 'btle'. The salt is just a
 232          * random number whereas length is the value 256 in little
 233          * endian format.
 234          */
 235         const u8 btle[4] = { 0x65, 0x6c, 0x74, 0x62 };
 236         const u8 salt[16] = { 0xbe, 0x83, 0x60, 0x5a, 0xdb, 0x0b, 0x37, 0x60,
 237                               0x38, 0xa5, 0xf5, 0xaa, 0x91, 0x83, 0x88, 0x6c };
 238         const u8 length[2] = { 0x00, 0x01 };
 239         u8 m[53], t[16];
 240         int err;
 241
 242         SMP_DBG("w %32phN", w);
 243         SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
 244         SMP_DBG("a1 %7phN a2 %7phN", a1, a2);
 245
 246         err = aes_cmac(tfm_cmac, salt, w, 32, t);
 247         if (err)
 248                 return err;
 249
 250         SMP_DBG("t %16phN", t);
 251
 252         memcpy(m, length, 2);
 253         memcpy(m + 2, a2, 7);
 254         memcpy(m + 9, a1, 7);
 255         memcpy(m + 16, n2, 16);
 256         memcpy(m + 32, n1, 16);
 257         memcpy(m + 48, btle, 4);
 258
 259         m[52] = 0; /* Counter */
 260
 261         err = aes_cmac(tfm_cmac, t, m, sizeof(m), mackey);
 262         if (err)
 263                 return err;
 264
 265         SMP_DBG("mackey %16phN", mackey);
 266
 267         m[52] = 1; /* Counter */
 268
 269         err = aes_cmac(tfm_cmac, t, m, sizeof(m), ltk);
 270         if (err)
 271                 return err;
 272
 273         SMP_DBG("ltk %16phN", ltk);
 274
 275         return 0;
 276 }
 277
 278 static int smp_f6(struct crypto_hash *tfm_cmac, const u8 w[16],
 279                   const u8 n1[16], u8 n2[16], const u8 r[16],
 280                   const u8 io_cap[3], const u8 a1[7], const u8 a2[7],
 281                   u8 res[16])
 282 {
 283         u8 m[65];
 284         int err;
 285
 286         SMP_DBG("w %16phN", w);
 287         SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
 288         SMP_DBG("r %16phN io_cap %3phN a1 %7phN a2 %7phN", r, io_cap, a1, a2);
 289
 290         memcpy(m, a2, 7);
 291         memcpy(m + 7, a1, 7);
 292         memcpy(m + 14, io_cap, 3);
 293         memcpy(m + 17, r, 16);
 294         memcpy(m + 33, n2, 16);
 295         memcpy(m + 49, n1, 16);
 296
 297         err = aes_cmac(tfm_cmac, w, m, sizeof(m), res);
 298         if (err)
 299                 return err;
 300
 301         BT_DBG("res %16phN", res);
 302
 303         return err;
 304 }
 305
 306 static int smp_g2(struct crypto_hash *tfm_cmac, const u8 u[32], const u8 v[32],
 307                   const u8 x[16], const u8 y[16], u32 *val)
 308 {
 309         u8 m[80], tmp[16];
 310         int err;
 311
 312         SMP_DBG("u %32phN", u);
 313         SMP_DBG("v %32phN", v);
 314         SMP_DBG("x %16phN y %16phN", x, y);
 315
 316         memcpy(m, y, 16);
 317         memcpy(m + 16, v, 32);
 318         memcpy(m + 48, u, 32);
 319
 320         err = aes_cmac(tfm_cmac, x, m, sizeof(m), tmp);
 321         if (err)
 322                 return err;
 323
 324         *val = get_unaligned_le32(tmp);
 325         *val %= 1000000;
 326
 327         SMP_DBG("val %06u", *val);
 328
 329         return 0;
 330 }
 331
 332 static int smp_h6(struct crypto_hash *tfm_cmac, const u8 w[16],
 333                   const u8 key_id[4], u8 res[16])
 334 {
 335         int err;
 336
 337         SMP_DBG("w %16phN key_id %4phN", w, key_id);
 338
 339         err = aes_cmac(tfm_cmac, w, key_id, 4, res);
 340         if (err)
 341                 return err;
 342
 343         SMP_DBG("res %16phN", res);
 344
 345         return err;
 346 }
 347
 348 /* The following functions map to the legacy SMP crypto functions e, c1,
 349  * s1 and ah.
 350  */
 351
 352 static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
 353 {
 354         struct blkcipher_desc desc;
 355         struct scatterlist sg;
 356         uint8_t tmp[16], data[16];
 357         int err;
 358
 359         if (!tfm) {
 360                 BT_ERR("tfm %p", tfm);
 361                 return -EINVAL;
 362         }
 363
 364         desc.tfm = tfm;
 365         desc.flags = 0;
 366
 367         /* The most significant octet of key corresponds to k[0] */
 368         swap_buf(k, tmp, 16);
 369
 370         err = crypto_blkcipher_setkey(tfm, tmp, 16);
 371         if (err) {
 372                 BT_ERR("cipher setkey failed: %d", err);
 373                 return err;
 374         }
 375
 376         /* Most significant octet of plaintextData corresponds to data[0] */
 377         swap_buf(r, data, 16);
 378
 379         sg_init_one(&sg, data, 16);
 380
 381         err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
 382         if (err)
 383                 BT_ERR("Encrypt data error %d", err);
 384
 385         /* Most significant octet of encryptedData corresponds to data[0] */
 386         swap_buf(data, r, 16);
 387
 388         return err;
 389 }
 390
 391 static int smp_c1(struct crypto_blkcipher *tfm_aes, const u8 k[16],
 392                   const u8 r[16], const u8 preq[7], const u8 pres[7], u8 _iat,
 393                   const bdaddr_t *ia, u8 _rat, const bdaddr_t *ra, u8 res[16])
 394 {
 395         u8 p1[16], p2[16];
 396         int err;
 397
 398         memset(p1, 0, 16);
 399
 400         /* p1 = pres || preq || _rat || _iat */
 401         p1[0] = _iat;
 402         p1[1] = _rat;
 403         memcpy(p1 + 2, preq, 7);
 404         memcpy(p1 + 9, pres, 7);
 405
 406         /* p2 = padding || ia || ra */
 407         memcpy(p2, ra, 6);
 408         memcpy(p2 + 6, ia, 6);
 409         memset(p2 + 12, 0, 4);
 410
 411         /* res = r XOR p1 */
 412         u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
 413
 414         /* res = e(k, res) */
 415         err = smp_e(tfm_aes, k, res);
 416         if (err) {
 417                 BT_ERR("Encrypt data error");
 418                 return err;
 419         }
 420
 421         /* res = res XOR p2 */
 422         u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
 423
 424         /* res = e(k, res) */
 425         err = smp_e(tfm_aes, k, res);
 426         if (err)
 427                 BT_ERR("Encrypt data error");
 428
 429         return err;
 430 }
 431
 432 static int smp_s1(struct crypto_blkcipher *tfm_aes, const u8 k[16],
 433                   const u8 r1[16], const u8 r2[16], u8 _r[16])
 434 {
 435         int err;
 436
 437         /* Just least significant octets from r1 and r2 are considered */
 438         memcpy(_r, r2, 8);
 439         memcpy(_r + 8, r1, 8);
 440
 441         err = smp_e(tfm_aes, k, _r);
 442         if (err)
 443                 BT_ERR("Encrypt data error");
 444
 445         return err;
 446 }
 447
 448 static int smp_ah(struct crypto_blkcipher *tfm, const u8 irk[16],
 449                   const u8 r[3], u8 res[3])
 450 {
 451         u8 _res[16];
 452         int err;
 453
 454         /* r' = padding || r */
 455         memcpy(_res, r, 3);
 456         memset(_res + 3, 0, 13);
 457
 458         err = smp_e(tfm, irk, _res);
 459         if (err) {
 460                 BT_ERR("Encrypt error");
 461                 return err;
 462         }
 463
 464         /* The output of the random address function ah is:
 465          *      ah(h, r) = e(k, r') mod 2^24
 466          * The output of the security function e is then truncated to 24 bits
 467          * by taking the least significant 24 bits of the output of e as the
 468          * result of ah.
 469          */
 470         memcpy(res, _res, 3);
 471
 472         return 0;
 473 }
 474
 475 bool smp_irk_matches(struct hci_dev *hdev, const u8 irk[16],
 476                      const bdaddr_t *bdaddr)
 477 {
 478         struct l2cap_chan *chan = hdev->smp_data;
 479         struct crypto_blkcipher *tfm;
 480         u8 hash[3];
 481         int err;
 482
 483         if (!chan || !chan->data)
 484                 return false;
 485
 486         tfm = chan->data;
 487
 488         BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);
 489
 490         err = smp_ah(tfm, irk, &bdaddr->b[3], hash);
 491         if (err)
 492                 return false;
 493
 494         return !memcmp(bdaddr->b, hash, 3);
 495 }
 496
 497 int smp_generate_rpa(struct hci_dev *hdev, const u8 irk[16], bdaddr_t *rpa)
 498 {
 499         struct l2cap_chan *chan = hdev->smp_data;
 500         struct crypto_blkcipher *tfm;
 501         int err;
 502
 503         if (!chan || !chan->data)
 504                 return -EOPNOTSUPP;
 505
 506         tfm = chan->data;
 507
 508         get_random_bytes(&rpa->b[3], 3);
 509
 510         rpa->b[5] &= 0x3f;      /* Clear two most significant bits */
 511         rpa->b[5] |= 0x40;      /* Set second most significant bit */
 512
 513         err = smp_ah(tfm, irk, &rpa->b[3], rpa->b);
 514         if (err < 0)
 515                 return err;
 516
 517         BT_DBG("RPA %pMR", rpa);
 518
 519         return 0;
 520 }
 521
 522 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
 523 {
 524         struct l2cap_chan *chan = conn->smp;
 525         struct smp_chan *smp;
 526         struct kvec iv[2];
 527         struct msghdr msg;
 528
 529         if (!chan)
 530                 return;
 531
 532         BT_DBG("code 0x%2.2x", code);
 533
 534         iv[0].iov_base = &code;
 535         iv[0].iov_len = 1;
 536
 537         iv[1].iov_base = data;
 538         iv[1].iov_len = len;
 539
 540         memset(&msg, 0, sizeof(msg));
 541
 542         iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iv, 2, 1 + len);
 543
 544         l2cap_chan_send(chan, &msg, 1 + len);
 545
 546         if (!chan->data)
 547                 return;
 548
 549         smp = chan->data;
 550
 551         cancel_delayed_work_sync(&smp->security_timer);
 552         schedule_delayed_work(&smp->security_timer, SMP_TIMEOUT);
 553 }
 554
 555 static u8 authreq_to_seclevel(u8 authreq)
 556 {
 557         if (authreq & SMP_AUTH_MITM) {
 558                 if (authreq & SMP_AUTH_SC)
 559                         return BT_SECURITY_FIPS;
 560                 else
 561                         return BT_SECURITY_HIGH;
 562         } else {
 563                 return BT_SECURITY_MEDIUM;
 564         }
 565 }
 566
 567 static __u8 seclevel_to_authreq(__u8 sec_level)
 568 {
 569         switch (sec_level) {
 570         case BT_SECURITY_FIPS:
 571         case BT_SECURITY_HIGH:
 572                 return SMP_AUTH_MITM | SMP_AUTH_BONDING;
 573         case BT_SECURITY_MEDIUM:
 574                 return SMP_AUTH_BONDING;
 575         default:
 576                 return SMP_AUTH_NONE;
 577         }
 578 }
 579
 580 static void build_pairing_cmd(struct l2cap_conn *conn,
 581                               struct smp_cmd_pairing *req,
 582                               struct smp_cmd_pairing *rsp, __u8 authreq)
 583 {
 584         struct l2cap_chan *chan = conn->smp;
 585         struct smp_chan *smp = chan->data;
 586         struct hci_conn *hcon = conn->hcon;
 587         struct hci_dev *hdev = hcon->hdev;
 588         u8 local_dist = 0, remote_dist = 0, oob_flag = SMP_OOB_NOT_PRESENT;
 589
 590         if (test_bit(HCI_BONDABLE, &conn->hcon->hdev->dev_flags)) {
 591                 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
 592                 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
 593                 authreq |= SMP_AUTH_BONDING;
 594         } else {
 595                 authreq &= ~SMP_AUTH_BONDING;
 596         }
 597
 598         if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
 599                 remote_dist |= SMP_DIST_ID_KEY;
 600
 601         if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
 602                 local_dist |= SMP_DIST_ID_KEY;
 603
 604         if (test_bit(HCI_SC_ENABLED, &hdev->dev_flags) &&
 605             (authreq & SMP_AUTH_SC)) {
 606                 struct oob_data *oob_data;
 607                 u8 bdaddr_type;
 608
 609                 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) {
 610                         local_dist |= SMP_DIST_LINK_KEY;
 611                         remote_dist |= SMP_DIST_LINK_KEY;
 612                 }
 613
 614                 if (hcon->dst_type == ADDR_LE_DEV_PUBLIC)
 615                         bdaddr_type = BDADDR_LE_PUBLIC;
 616                 else
 617                         bdaddr_type = BDADDR_LE_RANDOM;
 618
 619                 oob_data = hci_find_remote_oob_data(hdev, &hcon->dst,
 620                                                     bdaddr_type);
 621                 if (oob_data) {
 622                         set_bit(SMP_FLAG_OOB, &smp->flags);
 623                         oob_flag = SMP_OOB_PRESENT;
 624                         memcpy(smp->rr, oob_data->rand256, 16);
 625                         memcpy(smp->pcnf, oob_data->hash256, 16);
 626                 }
 627
 628         } else {
 629                 authreq &= ~SMP_AUTH_SC;
 630         }
 631
 632         if (rsp == NULL) {
 633                 req->io_capability = conn->hcon->io_capability;
 634                 req->oob_flag = oob_flag;
 635                 req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 636                 req->init_key_dist = local_dist;
 637                 req->resp_key_dist = remote_dist;
 638                 req->auth_req = (authreq & AUTH_REQ_MASK(hdev));
 639
 640                 smp->remote_key_dist = remote_dist;
 641                 return;
 642         }
 643
 644         rsp->io_capability = conn->hcon->io_capability;
 645         rsp->oob_flag = oob_flag;
 646         rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 647         rsp->init_key_dist = req->init_key_dist & remote_dist;
 648         rsp->resp_key_dist = req->resp_key_dist & local_dist;
 649         rsp->auth_req = (authreq & AUTH_REQ_MASK(hdev));
 650
 651         smp->remote_key_dist = rsp->init_key_dist;
 652 }
 653
 654 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
 655 {
 656         struct l2cap_chan *chan = conn->smp;
 657         struct smp_chan *smp = chan->data;
 658
 659         if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
 660             (max_key_size < SMP_MIN_ENC_KEY_SIZE))
 661                 return SMP_ENC_KEY_SIZE;
 662
 663         smp->enc_key_size = max_key_size;
 664
 665         return 0;
 666 }
 667
 668 static void smp_chan_destroy(struct l2cap_conn *conn)
 669 {
 670         struct l2cap_chan *chan = conn->smp;
 671         struct smp_chan *smp = chan->data;
 672         struct hci_conn *hcon = conn->hcon;
 673         bool complete;
 674
 675         BUG_ON(!smp);
 676
 677         cancel_delayed_work_sync(&smp->security_timer);
 678
 679         complete = test_bit(SMP_FLAG_COMPLETE, &smp->flags);
 680         mgmt_smp_complete(hcon, complete);
 681
 682         kfree(smp->csrk);
 683         kfree(smp->slave_csrk);
 684         kfree(smp->link_key);
 685
 686         crypto_free_blkcipher(smp->tfm_aes);
 687         crypto_free_hash(smp->tfm_cmac);
 688
 689         /* Ensure that we don't leave any debug key around if debug key
 690          * support hasn't been explicitly enabled.
 691          */
 692         if (smp->ltk && smp->ltk->type == SMP_LTK_P256_DEBUG &&
 693             !test_bit(HCI_KEEP_DEBUG_KEYS, &hcon->hdev->dev_flags)) {
 694                 list_del_rcu(&smp->ltk->list);
 695                 kfree_rcu(smp->ltk, rcu);
 696                 smp->ltk = NULL;
 697         }
 698
 699         /* If pairing failed clean up any keys we might have */
 700         if (!complete) {
 701                 if (smp->ltk) {
 702                         list_del_rcu(&smp->ltk->list);
 703                         kfree_rcu(smp->ltk, rcu);
 704                 }
 705
 706                 if (smp->slave_ltk) {
 707                         list_del_rcu(&smp->slave_ltk->list);
 708                         kfree_rcu(smp->slave_ltk, rcu);
 709                 }
 710
 711                 if (smp->remote_irk) {
 712                         list_del_rcu(&smp->remote_irk->list);
 713                         kfree_rcu(smp->remote_irk, rcu);
 714                 }
 715         }
 716
 717         chan->data = NULL;
 718         kfree(smp);
 719         hci_conn_drop(hcon);
 720 }
 721
 722 static void smp_failure(struct l2cap_conn *conn, u8 reason)
 723 {
 724         struct hci_conn *hcon = conn->hcon;
 725         struct l2cap_chan *chan = conn->smp;
 726
 727         if (reason)
 728                 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
 729                              &reason);
 730
 731         clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags);
 732         mgmt_auth_failed(hcon, HCI_ERROR_AUTH_FAILURE);
 733
 734         if (chan->data)
 735                 smp_chan_destroy(conn);
 736 }
 737
 738 #define JUST_WORKS      0x00
 739 #define JUST_CFM        0x01
 740 #define REQ_PASSKEY     0x02
 741 #define CFM_PASSKEY     0x03
 742 #define REQ_OOB         0x04
 743 #define DSP_PASSKEY     0x05
 744 #define OVERLAP         0xFF
 745
 746 static const u8 gen_method[5][5] = {
 747         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 748         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 749         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 750         { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
 751         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP     },
 752 };
 753
 754 static const u8 sc_method[5][5] = {
 755         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 756         { JUST_WORKS,  CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 757         { DSP_PASSKEY, DSP_PASSKEY, REQ_PASSKEY, JUST_WORKS, DSP_PASSKEY },
 758         { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
 759         { DSP_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 760 };
 761
 762 static u8 get_auth_method(struct smp_chan *smp, u8 local_io, u8 remote_io)
 763 {
 764         /* If either side has unknown io_caps, use JUST_CFM (which gets
 765          * converted later to JUST_WORKS if we're initiators.
 766          */
 767         if (local_io > SMP_IO_KEYBOARD_DISPLAY ||
 768             remote_io > SMP_IO_KEYBOARD_DISPLAY)
 769                 return JUST_CFM;
 770
 771         if (test_bit(SMP_FLAG_SC, &smp->flags))
 772                 return sc_method[remote_io][local_io];
 773
 774         return gen_method[remote_io][local_io];
 775 }
 776
 777 static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
 778                                                 u8 local_io, u8 remote_io)
 779 {
 780         struct hci_conn *hcon = conn->hcon;
 781         struct l2cap_chan *chan = conn->smp;
 782         struct smp_chan *smp = chan->data;
 783         u32 passkey = 0;
 784         int ret = 0;
 785
 786         /* Initialize key for JUST WORKS */
 787         memset(smp->tk, 0, sizeof(smp->tk));
 788         clear_bit(SMP_FLAG_TK_VALID, &smp->flags);
 789
 790         BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
 791
 792         /* If neither side wants MITM, either "just" confirm an incoming
 793          * request or use just-works for outgoing ones. The JUST_CFM
 794          * will be converted to JUST_WORKS if necessary later in this
 795          * function. If either side has MITM look up the method from the
 796          * table.
 797          */
 798         if (!(auth & SMP_AUTH_MITM))
 799                 smp->method = JUST_CFM;
 800         else
 801                 smp->method = get_auth_method(smp, local_io, remote_io);
 802
 803         /* Don't confirm locally initiated pairing attempts */
 804         if (smp->method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR,
 805                                                 &smp->flags))
 806                 smp->method = JUST_WORKS;
 807
 808         /* Don't bother user space with no IO capabilities */
 809         if (smp->method == JUST_CFM &&
 810             hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
 811                 smp->method = JUST_WORKS;
 812
 813         /* If Just Works, Continue with Zero TK */
 814         if (smp->method == JUST_WORKS) {
 815                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
 816                 return 0;
 817         }
 818
 819         /* Not Just Works/Confirm results in MITM Authentication */
 820         if (smp->method != JUST_CFM) {
 821                 set_bit(SMP_FLAG_MITM_AUTH, &smp->flags);
 822                 if (hcon->pending_sec_level < BT_SECURITY_HIGH)
 823                         hcon->pending_sec_level = BT_SECURITY_HIGH;
 824         }
 825
 826         /* If both devices have Keyoard-Display I/O, the master
 827          * Confirms and the slave Enters the passkey.
 828          */
 829         if (smp->method == OVERLAP) {
 830                 if (hcon->role == HCI_ROLE_MASTER)
 831                         smp->method = CFM_PASSKEY;
 832                 else
 833                         smp->method = REQ_PASSKEY;
 834         }
 835
 836         /* Generate random passkey. */
 837         if (smp->method == CFM_PASSKEY) {
 838                 memset(smp->tk, 0, sizeof(smp->tk));
 839                 get_random_bytes(&passkey, sizeof(passkey));
 840                 passkey %= 1000000;
 841                 put_unaligned_le32(passkey, smp->tk);
 842                 BT_DBG("PassKey: %d", passkey);
 843                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
 844         }
 845
 846         if (smp->method == REQ_PASSKEY)
 847                 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
 848                                                 hcon->type, hcon->dst_type);
 849         else if (smp->method == JUST_CFM)
 850                 ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
 851                                                 hcon->type, hcon->dst_type,
 852                                                 passkey, 1);
 853         else
 854                 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
 855                                                 hcon->type, hcon->dst_type,
 856                                                 passkey, 0);
 857
 858         return ret;
 859 }
 860
 861 static u8 smp_confirm(struct smp_chan *smp)
 862 {
 863         struct l2cap_conn *conn = smp->conn;
 864         struct smp_cmd_pairing_confirm cp;
 865         int ret;
 866
 867         BT_DBG("conn %p", conn);
 868
 869         ret = smp_c1(smp->tfm_aes, smp->tk, smp->prnd, smp->preq, smp->prsp,
 870                      conn->hcon->init_addr_type, &conn->hcon->init_addr,
 871                      conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
 872                      cp.confirm_val);
 873         if (ret)
 874                 return SMP_UNSPECIFIED;
 875
 876         clear_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
 877
 878         smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
 879
 880         if (conn->hcon->out)
 881                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
 882         else
 883                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
 884
 885         return 0;
 886 }
 887
 888 static u8 smp_random(struct smp_chan *smp)
 889 {
 890         struct l2cap_conn *conn = smp->conn;
 891         struct hci_conn *hcon = conn->hcon;
 892         u8 confirm[16];
 893         int ret;
 894
 895         if (IS_ERR_OR_NULL(smp->tfm_aes))
 896                 return SMP_UNSPECIFIED;
 897
 898         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 899
 900         ret = smp_c1(smp->tfm_aes, smp->tk, smp->rrnd, smp->preq, smp->prsp,
 901                      hcon->init_addr_type, &hcon->init_addr,
 902                      hcon->resp_addr_type, &hcon->resp_addr, confirm);
 903         if (ret)
 904                 return SMP_UNSPECIFIED;
 905
 906         if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
 907                 BT_ERR("Pairing failed (confirmation values mismatch)");
 908                 return SMP_CONFIRM_FAILED;
 909         }
 910
 911         if (hcon->out) {
 912                 u8 stk[16];
 913                 __le64 rand = 0;
 914                 __le16 ediv = 0;
 915
 916                 smp_s1(smp->tfm_aes, smp->tk, smp->rrnd, smp->prnd, stk);
 917
 918                 memset(stk + smp->enc_key_size, 0,
 919                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 920
 921                 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
 922                         return SMP_UNSPECIFIED;
 923
 924                 hci_le_start_enc(hcon, ediv, rand, stk);
 925                 hcon->enc_key_size = smp->enc_key_size;
 926                 set_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
 927         } else {
 928                 u8 stk[16], auth;
 929                 __le64 rand = 0;
 930                 __le16 ediv = 0;
 931
 932                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
 933                              smp->prnd);
 934
 935                 smp_s1(smp->tfm_aes, smp->tk, smp->prnd, smp->rrnd, stk);
 936
 937                 memset(stk + smp->enc_key_size, 0,
 938                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 939
 940                 if (hcon->pending_sec_level == BT_SECURITY_HIGH)
 941                         auth = 1;
 942                 else
 943                         auth = 0;
 944
 945                 /* Even though there's no _SLAVE suffix this is the
 946                  * slave STK we're adding for later lookup (the master
 947                  * STK never needs to be stored).
 948                  */
 949                 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
 950                             SMP_STK, auth, stk, smp->enc_key_size, ediv, rand);
 951         }
 952
 953         return 0;
 954 }
 955
 956 static void smp_notify_keys(struct l2cap_conn *conn)
 957 {
 958         struct l2cap_chan *chan = conn->smp;
 959         struct smp_chan *smp = chan->data;
 960         struct hci_conn *hcon = conn->hcon;
 961         struct hci_dev *hdev = hcon->hdev;
 962         struct smp_cmd_pairing *req = (void *) &smp->preq[1];
 963         struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
 964         bool persistent;
 965
 966         if (smp->remote_irk) {
 967                 mgmt_new_irk(hdev, smp->remote_irk);
 968                 /* Now that user space can be considered to know the
 969                  * identity address track the connection based on it
 970                  * from now on (assuming this is an LE link).
 971                  */
 972                 if (hcon->type == LE_LINK) {
 973                         bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
 974                         hcon->dst_type = smp->remote_irk->addr_type;
 975                         queue_work(hdev->workqueue, &conn->id_addr_update_work);
 976                 }
 977
 978                 /* When receiving an indentity resolving key for
 979                  * a remote device that does not use a resolvable
 980                  * private address, just remove the key so that
 981                  * it is possible to use the controller white
 982                  * list for scanning.
 983                  *
 984                  * Userspace will have been told to not store
 985                  * this key at this point. So it is safe to
 986                  * just remove it.
 987                  */
 988                 if (!bacmp(&smp->remote_irk->rpa, BDADDR_ANY)) {
 989                         list_del_rcu(&smp->remote_irk->list);
 990                         kfree_rcu(smp->remote_irk, rcu);
 991                         smp->remote_irk = NULL;
 992                 }
 993         }
 994
 995         if (hcon->type == ACL_LINK) {
 996                 if (hcon->key_type == HCI_LK_DEBUG_COMBINATION)
 997                         persistent = false;
 998                 else
 999                         persistent = !test_bit(HCI_CONN_FLUSH_KEY,
1000                                                &hcon->flags);
1001         } else {
1002                 /* The LTKs and CSRKs should be persistent only if both sides
1003                  * had the bonding bit set in their authentication requests.
1004                  */
1005                 persistent = !!((req->auth_req & rsp->auth_req) &
1006                                 SMP_AUTH_BONDING);
1007         }
1008
1009
1010         if (smp->csrk) {
1011                 smp->csrk->bdaddr_type = hcon->dst_type;
1012                 bacpy(&smp->csrk->bdaddr, &hcon->dst);
1013                 mgmt_new_csrk(hdev, smp->csrk, persistent);
1014         }
1015
1016         if (smp->slave_csrk) {
1017                 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1018                 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
1019                 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
1020         }
1021
1022         if (smp->ltk) {
1023                 smp->ltk->bdaddr_type = hcon->dst_type;
1024                 bacpy(&smp->ltk->bdaddr, &hcon->dst);
1025                 mgmt_new_ltk(hdev, smp->ltk, persistent);
1026         }
1027
1028         if (smp->slave_ltk) {
1029                 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1030                 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
1031                 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
1032         }
1033
1034         if (smp->link_key) {
1035                 struct link_key *key;
1036                 u8 type;
1037
1038                 if (test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags))
1039                         type = HCI_LK_DEBUG_COMBINATION;
1040                 else if (hcon->sec_level == BT_SECURITY_FIPS)
1041                         type = HCI_LK_AUTH_COMBINATION_P256;
1042                 else
1043                         type = HCI_LK_UNAUTH_COMBINATION_P256;
1044
1045                 key = hci_add_link_key(hdev, smp->conn->hcon, &hcon->dst,
1046                                        smp->link_key, type, 0, &persistent);
1047                 if (key) {
1048                         mgmt_new_link_key(hdev, key, persistent);
1049
1050                         /* Don't keep debug keys around if the relevant
1051                          * flag is not set.
1052                          */
1053                         if (!test_bit(HCI_KEEP_DEBUG_KEYS, &hdev->dev_flags) &&
1054                             key->type == HCI_LK_DEBUG_COMBINATION) {
1055                                 list_del_rcu(&key->list);
1056                                 kfree_rcu(key, rcu);
1057                         }
1058                 }
1059         }
1060 }
1061
1062 static void sc_add_ltk(struct smp_chan *smp)
1063 {
1064         struct hci_conn *hcon = smp->conn->hcon;
1065         u8 key_type, auth;
1066
1067         if (test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags))
1068                 key_type = SMP_LTK_P256_DEBUG;
1069         else
1070                 key_type = SMP_LTK_P256;
1071
1072         if (hcon->pending_sec_level == BT_SECURITY_FIPS)
1073                 auth = 1;
1074         else
1075                 auth = 0;
1076
1077         memset(smp->tk + smp->enc_key_size, 0,
1078                SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
1079
1080         smp->ltk = hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
1081                                key_type, auth, smp->tk, smp->enc_key_size,
1082                                0, 0);
1083 }
1084
1085 static void sc_generate_link_key(struct smp_chan *smp)
1086 {
1087         /* These constants are as specified in the core specification.
1088          * In ASCII they spell out to 'tmp1' and 'lebr'.
1089          */
1090         const u8 tmp1[4] = { 0x31, 0x70, 0x6d, 0x74 };
1091         const u8 lebr[4] = { 0x72, 0x62, 0x65, 0x6c };
1092
1093         smp->link_key = kzalloc(16, GFP_KERNEL);
1094         if (!smp->link_key)
1095                 return;
1096
1097         if (smp_h6(smp->tfm_cmac, smp->tk, tmp1, smp->link_key)) {
1098                 kfree(smp->link_key);
1099                 smp->link_key = NULL;
1100                 return;
1101         }
1102
1103         if (smp_h6(smp->tfm_cmac, smp->link_key, lebr, smp->link_key)) {
1104                 kfree(smp->link_key);
1105                 smp->link_key = NULL;
1106                 return;
1107         }
1108 }
1109
1110 static void smp_allow_key_dist(struct smp_chan *smp)
1111 {
1112         /* Allow the first expected phase 3 PDU. The rest of the PDUs
1113          * will be allowed in each PDU handler to ensure we receive
1114          * them in the correct order.
1115          */
1116         if (smp->remote_key_dist & SMP_DIST_ENC_KEY)
1117                 SMP_ALLOW_CMD(smp, SMP_CMD_ENCRYPT_INFO);
1118         else if (smp->remote_key_dist & SMP_DIST_ID_KEY)
1119                 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
1120         else if (smp->remote_key_dist & SMP_DIST_SIGN)
1121                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
1122 }
1123
1124 static void sc_generate_ltk(struct smp_chan *smp)
1125 {
1126         /* These constants are as specified in the core specification.
1127          * In ASCII they spell out to 'tmp2' and 'brle'.
1128          */
1129         const u8 tmp2[4] = { 0x32, 0x70, 0x6d, 0x74 };
1130         const u8 brle[4] = { 0x65, 0x6c, 0x72, 0x62 };
1131         struct hci_conn *hcon = smp->conn->hcon;
1132         struct hci_dev *hdev = hcon->hdev;
1133         struct link_key *key;
1134
1135         key = hci_find_link_key(hdev, &hcon->dst);
1136         if (!key) {
1137                 BT_ERR("%s No Link Key found to generate LTK", hdev->name);
1138                 return;
1139         }
1140
1141         if (key->type == HCI_LK_DEBUG_COMBINATION)
1142                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1143
1144         if (smp_h6(smp->tfm_cmac, key->val, tmp2, smp->tk))
1145                 return;
1146
1147         if (smp_h6(smp->tfm_cmac, smp->tk, brle, smp->tk))
1148                 return;
1149
1150         sc_add_ltk(smp);
1151 }
1152
1153 static void smp_distribute_keys(struct smp_chan *smp)
1154 {
1155         struct smp_cmd_pairing *req, *rsp;
1156         struct l2cap_conn *conn = smp->conn;
1157         struct hci_conn *hcon = conn->hcon;
1158         struct hci_dev *hdev = hcon->hdev;
1159         __u8 *keydist;
1160
1161         BT_DBG("conn %p", conn);
1162
1163         rsp = (void *) &smp->prsp[1];
1164
1165         /* The responder sends its keys first */
1166         if (hcon->out && (smp->remote_key_dist & KEY_DIST_MASK)) {
1167                 smp_allow_key_dist(smp);
1168                 return;
1169         }
1170
1171         req = (void *) &smp->preq[1];
1172
1173         if (hcon->out) {
1174                 keydist = &rsp->init_key_dist;
1175                 *keydist &= req->init_key_dist;
1176         } else {
1177                 keydist = &rsp->resp_key_dist;
1178                 *keydist &= req->resp_key_dist;
1179         }
1180
1181         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1182                 if (hcon->type == LE_LINK && (*keydist & SMP_DIST_LINK_KEY))
1183                         sc_generate_link_key(smp);
1184                 if (hcon->type == ACL_LINK && (*keydist & SMP_DIST_ENC_KEY))
1185                         sc_generate_ltk(smp);
1186
1187                 /* Clear the keys which are generated but not distributed */
1188                 *keydist &= ~SMP_SC_NO_DIST;
1189         }
1190
1191         BT_DBG("keydist 0x%x", *keydist);
1192
1193         if (*keydist & SMP_DIST_ENC_KEY) {
1194                 struct smp_cmd_encrypt_info enc;
1195                 struct smp_cmd_master_ident ident;
1196                 struct smp_ltk *ltk;
1197                 u8 authenticated;
1198                 __le16 ediv;
1199                 __le64 rand;
1200
1201                 get_random_bytes(enc.ltk, sizeof(enc.ltk));
1202                 get_random_bytes(&ediv, sizeof(ediv));
1203                 get_random_bytes(&rand, sizeof(rand));
1204
1205                 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1206
1207                 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
1208                 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
1209                                   SMP_LTK_SLAVE, authenticated, enc.ltk,
1210                                   smp->enc_key_size, ediv, rand);
1211                 smp->slave_ltk = ltk;
1212
1213                 ident.ediv = ediv;
1214                 ident.rand = rand;
1215
1216                 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1217
1218                 *keydist &= ~SMP_DIST_ENC_KEY;
1219         }
1220
1221         if (*keydist & SMP_DIST_ID_KEY) {
1222                 struct smp_cmd_ident_addr_info addrinfo;
1223                 struct smp_cmd_ident_info idinfo;
1224
1225                 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
1226
1227                 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1228
1229                 /* The hci_conn contains the local identity address
1230                  * after the connection has been established.
1231                  *
1232                  * This is true even when the connection has been
1233                  * established using a resolvable random address.
1234                  */
1235                 bacpy(&addrinfo.bdaddr, &hcon->src);
1236                 addrinfo.addr_type = hcon->src_type;
1237
1238                 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1239                              &addrinfo);
1240
1241                 *keydist &= ~SMP_DIST_ID_KEY;
1242         }
1243
1244         if (*keydist & SMP_DIST_SIGN) {
1245                 struct smp_cmd_sign_info sign;
1246                 struct smp_csrk *csrk;
1247
1248                 /* Generate a new random key */
1249                 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1250
1251                 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1252                 if (csrk) {
1253                         csrk->master = 0x00;
1254                         memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1255                 }
1256                 smp->slave_csrk = csrk;
1257
1258                 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1259
1260                 *keydist &= ~SMP_DIST_SIGN;
1261         }
1262
1263         /* If there are still keys to be received wait for them */
1264         if (smp->remote_key_dist & KEY_DIST_MASK) {
1265                 smp_allow_key_dist(smp);
1266                 return;
1267         }
1268
1269         set_bit(SMP_FLAG_COMPLETE, &smp->flags);
1270         smp_notify_keys(conn);
1271
1272         smp_chan_destroy(conn);
1273 }
1274
1275 static void smp_timeout(struct work_struct *work)
1276 {
1277         struct smp_chan *smp = container_of(work, struct smp_chan,
1278                                             security_timer.work);
1279         struct l2cap_conn *conn = smp->conn;
1280
1281         BT_DBG("conn %p", conn);
1282
1283         hci_disconnect(conn->hcon, HCI_ERROR_REMOTE_USER_TERM);
1284 }
1285
1286 static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
1287 {
1288         struct l2cap_chan *chan = conn->smp;
1289         struct smp_chan *smp;
1290
1291         smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
1292         if (!smp)
1293                 return NULL;
1294
1295         smp->tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
1296         if (IS_ERR(smp->tfm_aes)) {
1297                 BT_ERR("Unable to create ECB crypto context");
1298                 kfree(smp);
1299                 return NULL;
1300         }
1301
1302         smp->tfm_cmac = crypto_alloc_hash("cmac(aes)", 0, CRYPTO_ALG_ASYNC);
1303         if (IS_ERR(smp->tfm_cmac)) {
1304                 BT_ERR("Unable to create CMAC crypto context");
1305                 crypto_free_blkcipher(smp->tfm_aes);
1306                 kfree(smp);
1307                 return NULL;
1308         }
1309
1310         smp->conn = conn;
1311         chan->data = smp;
1312
1313         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_FAIL);
1314
1315         INIT_DELAYED_WORK(&smp->security_timer, smp_timeout);
1316
1317         hci_conn_hold(conn->hcon);
1318
1319         return smp;
1320 }
1321
1322 static int sc_mackey_and_ltk(struct smp_chan *smp, u8 mackey[16], u8 ltk[16])
1323 {
1324         struct hci_conn *hcon = smp->conn->hcon;
1325         u8 *na, *nb, a[7], b[7];
1326
1327         if (hcon->out) {
1328                 na   = smp->prnd;
1329                 nb   = smp->rrnd;
1330         } else {
1331                 na   = smp->rrnd;
1332                 nb   = smp->prnd;
1333         }
1334
1335         memcpy(a, &hcon->init_addr, 6);
1336         memcpy(b, &hcon->resp_addr, 6);
1337         a[6] = hcon->init_addr_type;
1338         b[6] = hcon->resp_addr_type;
1339
1340         return smp_f5(smp->tfm_cmac, smp->dhkey, na, nb, a, b, mackey, ltk);
1341 }
1342
1343 static void sc_dhkey_check(struct smp_chan *smp)
1344 {
1345         struct hci_conn *hcon = smp->conn->hcon;
1346         struct smp_cmd_dhkey_check check;
1347         u8 a[7], b[7], *local_addr, *remote_addr;
1348         u8 io_cap[3], r[16];
1349
1350         memcpy(a, &hcon->init_addr, 6);
1351         memcpy(b, &hcon->resp_addr, 6);
1352         a[6] = hcon->init_addr_type;
1353         b[6] = hcon->resp_addr_type;
1354
1355         if (hcon->out) {
1356                 local_addr = a;
1357                 remote_addr = b;
1358                 memcpy(io_cap, &smp->preq[1], 3);
1359         } else {
1360                 local_addr = b;
1361                 remote_addr = a;
1362                 memcpy(io_cap, &smp->prsp[1], 3);
1363         }
1364
1365         memset(r, 0, sizeof(r));
1366
1367         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1368                 put_unaligned_le32(hcon->passkey_notify, r);
1369
1370         if (smp->method == REQ_OOB)
1371                 memcpy(r, smp->rr, 16);
1372
1373         smp_f6(smp->tfm_cmac, smp->mackey, smp->prnd, smp->rrnd, r, io_cap,
1374                local_addr, remote_addr, check.e);
1375
1376         smp_send_cmd(smp->conn, SMP_CMD_DHKEY_CHECK, sizeof(check), &check);
1377 }
1378
1379 static u8 sc_passkey_send_confirm(struct smp_chan *smp)
1380 {
1381         struct l2cap_conn *conn = smp->conn;
1382         struct hci_conn *hcon = conn->hcon;
1383         struct smp_cmd_pairing_confirm cfm;
1384         u8 r;
1385
1386         r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
1387         r |= 0x80;
1388
1389         get_random_bytes(smp->prnd, sizeof(smp->prnd));
1390
1391         if (smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd, r,
1392                    cfm.confirm_val))
1393                 return SMP_UNSPECIFIED;
1394
1395         smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
1396
1397         return 0;
1398 }
1399
1400 static u8 sc_passkey_round(struct smp_chan *smp, u8 smp_op)
1401 {
1402         struct l2cap_conn *conn = smp->conn;
1403         struct hci_conn *hcon = conn->hcon;
1404         struct hci_dev *hdev = hcon->hdev;
1405         u8 cfm[16], r;
1406
1407         /* Ignore the PDU if we've already done 20 rounds (0 - 19) */
1408         if (smp->passkey_round >= 20)
1409                 return 0;
1410
1411         switch (smp_op) {
1412         case SMP_CMD_PAIRING_RANDOM:
1413                 r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
1414                 r |= 0x80;
1415
1416                 if (smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
1417                            smp->rrnd, r, cfm))
1418                         return SMP_UNSPECIFIED;
1419
1420                 if (memcmp(smp->pcnf, cfm, 16))
1421                         return SMP_CONFIRM_FAILED;
1422
1423                 smp->passkey_round++;
1424
1425                 if (smp->passkey_round == 20) {
1426                         /* Generate MacKey and LTK */
1427                         if (sc_mackey_and_ltk(smp, smp->mackey, smp->tk))
1428                                 return SMP_UNSPECIFIED;
1429                 }
1430
1431                 /* The round is only complete when the initiator
1432                  * receives pairing random.
1433                  */
1434                 if (!hcon->out) {
1435                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1436                                      sizeof(smp->prnd), smp->prnd);
1437                         if (smp->passkey_round == 20)
1438                                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1439                         else
1440                                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1441                         return 0;
1442                 }
1443
1444                 /* Start the next round */
1445                 if (smp->passkey_round != 20)
1446                         return sc_passkey_round(smp, 0);
1447
1448                 /* Passkey rounds are complete - start DHKey Check */
1449                 sc_dhkey_check(smp);
1450                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1451
1452                 break;
1453
1454         case SMP_CMD_PAIRING_CONFIRM:
1455                 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
1456                         set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
1457                         return 0;
1458                 }
1459
1460                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1461
1462                 if (hcon->out) {
1463                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1464                                      sizeof(smp->prnd), smp->prnd);
1465                         return 0;
1466                 }
1467
1468                 return sc_passkey_send_confirm(smp);
1469
1470         case SMP_CMD_PUBLIC_KEY:
1471         default:
1472                 /* Initiating device starts the round */
1473                 if (!hcon->out)
1474                         return 0;
1475
1476                 BT_DBG("%s Starting passkey round %u", hdev->name,
1477                        smp->passkey_round + 1);
1478
1479                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1480
1481                 return sc_passkey_send_confirm(smp);
1482         }
1483
1484         return 0;
1485 }
1486
1487 static int sc_user_reply(struct smp_chan *smp, u16 mgmt_op, __le32 passkey)
1488 {
1489         struct l2cap_conn *conn = smp->conn;
1490         struct hci_conn *hcon = conn->hcon;
1491         u8 smp_op;
1492
1493         clear_bit(SMP_FLAG_WAIT_USER, &smp->flags);
1494
1495         switch (mgmt_op) {
1496         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
1497                 smp_failure(smp->conn, SMP_PASSKEY_ENTRY_FAILED);
1498                 return 0;
1499         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
1500                 smp_failure(smp->conn, SMP_NUMERIC_COMP_FAILED);
1501                 return 0;
1502         case MGMT_OP_USER_PASSKEY_REPLY:
1503                 hcon->passkey_notify = le32_to_cpu(passkey);
1504                 smp->passkey_round = 0;
1505
1506                 if (test_and_clear_bit(SMP_FLAG_CFM_PENDING, &smp->flags))
1507                         smp_op = SMP_CMD_PAIRING_CONFIRM;
1508                 else
1509                         smp_op = 0;
1510
1511                 if (sc_passkey_round(smp, smp_op))
1512                         return -EIO;
1513
1514                 return 0;
1515         }
1516
1517         /* Initiator sends DHKey check first */
1518         if (hcon->out) {
1519                 sc_dhkey_check(smp);
1520                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1521         } else if (test_and_clear_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags)) {
1522                 sc_dhkey_check(smp);
1523                 sc_add_ltk(smp);
1524         }
1525
1526         return 0;
1527 }
1528
1529 int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
1530 {
1531         struct l2cap_conn *conn = hcon->l2cap_data;
1532         struct l2cap_chan *chan;
1533         struct smp_chan *smp;
1534         u32 value;
1535         int err;
1536
1537         BT_DBG("");
1538
1539         if (!conn)
1540                 return -ENOTCONN;
1541
1542         chan = conn->smp;
1543         if (!chan)
1544                 return -ENOTCONN;
1545
1546         l2cap_chan_lock(chan);
1547         if (!chan->data) {
1548                 err = -ENOTCONN;
1549                 goto unlock;
1550         }
1551
1552         smp = chan->data;
1553
1554         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1555                 err = sc_user_reply(smp, mgmt_op, passkey);
1556                 goto unlock;
1557         }
1558
1559         switch (mgmt_op) {
1560         case MGMT_OP_USER_PASSKEY_REPLY:
1561                 value = le32_to_cpu(passkey);
1562                 memset(smp->tk, 0, sizeof(smp->tk));
1563                 BT_DBG("PassKey: %d", value);
1564                 put_unaligned_le32(value, smp->tk);
1565                 /* Fall Through */
1566         case MGMT_OP_USER_CONFIRM_REPLY:
1567                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
1568                 break;
1569         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
1570         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
1571                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
1572                 err = 0;
1573                 goto unlock;
1574         default:
1575                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
1576                 err = -EOPNOTSUPP;
1577                 goto unlock;
1578         }
1579
1580         err = 0;
1581
1582         /* If it is our turn to send Pairing Confirm, do so now */
1583         if (test_bit(SMP_FLAG_CFM_PENDING, &smp->flags)) {
1584                 u8 rsp = smp_confirm(smp);
1585                 if (rsp)
1586                         smp_failure(conn, rsp);
1587         }
1588
1589 unlock:
1590         l2cap_chan_unlock(chan);
1591         return err;
1592 }
1593
1594 static void build_bredr_pairing_cmd(struct smp_chan *smp,
1595                                     struct smp_cmd_pairing *req,
1596                                     struct smp_cmd_pairing *rsp)
1597 {
1598         struct l2cap_conn *conn = smp->conn;
1599         struct hci_dev *hdev = conn->hcon->hdev;
1600         u8 local_dist = 0, remote_dist = 0;
1601
1602         if (test_bit(HCI_BONDABLE, &hdev->dev_flags)) {
1603                 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
1604                 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
1605         }
1606
1607         if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
1608                 remote_dist |= SMP_DIST_ID_KEY;
1609
1610         if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
1611                 local_dist |= SMP_DIST_ID_KEY;
1612
1613         if (!rsp) {
1614                 memset(req, 0, sizeof(*req));
1615
1616                 req->init_key_dist   = local_dist;
1617                 req->resp_key_dist   = remote_dist;
1618                 req->max_key_size    = SMP_MAX_ENC_KEY_SIZE;
1619
1620                 smp->remote_key_dist = remote_dist;
1621
1622                 return;
1623         }
1624
1625         memset(rsp, 0, sizeof(*rsp));
1626
1627         rsp->max_key_size    = SMP_MAX_ENC_KEY_SIZE;
1628         rsp->init_key_dist   = req->init_key_dist & remote_dist;
1629         rsp->resp_key_dist   = req->resp_key_dist & local_dist;
1630
1631         smp->remote_key_dist = rsp->init_key_dist;
1632 }
1633
1634 static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
1635 {
1636         struct smp_cmd_pairing rsp, *req = (void *) skb->data;
1637         struct l2cap_chan *chan = conn->smp;
1638         struct hci_dev *hdev = conn->hcon->hdev;
1639         struct smp_chan *smp;
1640         u8 key_size, auth, sec_level;
1641         int ret;
1642
1643         BT_DBG("conn %p", conn);
1644
1645         if (skb->len < sizeof(*req))
1646                 return SMP_INVALID_PARAMS;
1647
1648         if (conn->hcon->role != HCI_ROLE_SLAVE)
1649                 return SMP_CMD_NOTSUPP;
1650
1651         if (!chan->data)
1652                 smp = smp_chan_create(conn);
1653         else
1654                 smp = chan->data;
1655
1656         if (!smp)
1657                 return SMP_UNSPECIFIED;
1658
1659         /* We didn't start the pairing, so match remote */
1660         auth = req->auth_req & AUTH_REQ_MASK(hdev);
1661
1662         if (!test_bit(HCI_BONDABLE, &hdev->dev_flags) &&
1663             (auth & SMP_AUTH_BONDING))
1664                 return SMP_PAIRING_NOTSUPP;
1665
1666         if (test_bit(HCI_SC_ONLY, &hdev->dev_flags) && !(auth & SMP_AUTH_SC))
1667                 return SMP_AUTH_REQUIREMENTS;
1668
1669         smp->preq[0] = SMP_CMD_PAIRING_REQ;
1670         memcpy(&smp->preq[1], req, sizeof(*req));
1671         skb_pull(skb, sizeof(*req));
1672
1673         /* SMP over BR/EDR requires special treatment */
1674         if (conn->hcon->type == ACL_LINK) {
1675                 /* We must have a BR/EDR SC link */
1676                 if (!test_bit(HCI_CONN_AES_CCM, &conn->hcon->flags))
1677                         return SMP_CROSS_TRANSP_NOT_ALLOWED;
1678
1679                 set_bit(SMP_FLAG_SC, &smp->flags);
1680
1681                 build_bredr_pairing_cmd(smp, req, &rsp);
1682
1683                 key_size = min(req->max_key_size, rsp.max_key_size);
1684                 if (check_enc_key_size(conn, key_size))
1685                         return SMP_ENC_KEY_SIZE;
1686
1687                 /* Clear bits which are generated but not distributed */
1688                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1689
1690                 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1691                 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
1692                 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
1693
1694                 smp_distribute_keys(smp);
1695                 return 0;
1696         }
1697
1698         build_pairing_cmd(conn, req, &rsp, auth);
1699
1700         if (rsp.auth_req & SMP_AUTH_SC)
1701                 set_bit(SMP_FLAG_SC, &smp->flags);
1702
1703         if (conn->hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
1704                 sec_level = BT_SECURITY_MEDIUM;
1705         else
1706                 sec_level = authreq_to_seclevel(auth);
1707
1708         if (sec_level > conn->hcon->pending_sec_level)
1709                 conn->hcon->pending_sec_level = sec_level;
1710
1711         /* If we need MITM check that it can be achieved */
1712         if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1713                 u8 method;
1714
1715                 method = get_auth_method(smp, conn->hcon->io_capability,
1716                                          req->io_capability);
1717                 if (method == JUST_WORKS || method == JUST_CFM)
1718                         return SMP_AUTH_REQUIREMENTS;
1719         }
1720
1721         key_size = min(req->max_key_size, rsp.max_key_size);
1722         if (check_enc_key_size(conn, key_size))
1723                 return SMP_ENC_KEY_SIZE;
1724
1725         get_random_bytes(smp->prnd, sizeof(smp->prnd));
1726
1727         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1728         memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
1729
1730         smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
1731
1732         clear_bit(SMP_FLAG_INITIATOR, &smp->flags);
1733
1734         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1735                 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1736                 /* Clear bits which are generated but not distributed */
1737                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1738                 /* Wait for Public Key from Initiating Device */
1739                 return 0;
1740         } else {
1741                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1742         }
1743
1744         /* Request setup of TK */
1745         ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
1746         if (ret)
1747                 return SMP_UNSPECIFIED;
1748
1749         return 0;
1750 }
1751
1752 static u8 sc_send_public_key(struct smp_chan *smp)
1753 {
1754         struct hci_dev *hdev = smp->conn->hcon->hdev;
1755
1756         BT_DBG("");
1757
1758         if (test_bit(HCI_USE_DEBUG_KEYS, &hdev->dev_flags)) {
1759                 BT_DBG("Using debug keys");
1760                 memcpy(smp->local_pk, debug_pk, 64);
1761                 memcpy(smp->local_sk, debug_sk, 32);
1762                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1763         } else {
1764                 while (true) {
1765                         /* Generate local key pair for Secure Connections */
1766                         if (!ecc_make_key(smp->local_pk, smp->local_sk))
1767                                 return SMP_UNSPECIFIED;
1768
1769                         /* This is unlikely, but we need to check that
1770                          * we didn't accidentially generate a debug key.
1771                          */
1772                         if (memcmp(smp->local_sk, debug_sk, 32))
1773                                 break;
1774                 }
1775         }
1776
1777         SMP_DBG("Local Public Key X: %32phN", smp->local_pk);
1778         SMP_DBG("Local Public Key Y: %32phN", &smp->local_pk[32]);
1779         SMP_DBG("Local Private Key:  %32phN", smp->local_sk);
1780
1781         smp_send_cmd(smp->conn, SMP_CMD_PUBLIC_KEY, 64, smp->local_pk);
1782
1783         return 0;
1784 }
1785
1786 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
1787 {
1788         struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
1789         struct l2cap_chan *chan = conn->smp;
1790         struct smp_chan *smp = chan->data;
1791         struct hci_dev *hdev = conn->hcon->hdev;
1792         u8 key_size, auth;
1793         int ret;
1794
1795         BT_DBG("conn %p", conn);
1796
1797         if (skb->len < sizeof(*rsp))
1798                 return SMP_INVALID_PARAMS;
1799
1800         if (conn->hcon->role != HCI_ROLE_MASTER)
1801                 return SMP_CMD_NOTSUPP;
1802
1803         skb_pull(skb, sizeof(*rsp));
1804
1805         req = (void *) &smp->preq[1];
1806
1807         key_size = min(req->max_key_size, rsp->max_key_size);
1808         if (check_enc_key_size(conn, key_size))
1809                 return SMP_ENC_KEY_SIZE;
1810
1811         auth = rsp->auth_req & AUTH_REQ_MASK(hdev);
1812
1813         if (test_bit(HCI_SC_ONLY, &hdev->dev_flags) && !(auth & SMP_AUTH_SC))
1814                 return SMP_AUTH_REQUIREMENTS;
1815
1816         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1817         memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
1818
1819         /* Update remote key distribution in case the remote cleared
1820          * some bits that we had enabled in our request.
1821          */
1822         smp->remote_key_dist &= rsp->resp_key_dist;
1823
1824         /* For BR/EDR this means we're done and can start phase 3 */
1825         if (conn->hcon->type == ACL_LINK) {
1826                 /* Clear bits which are generated but not distributed */
1827                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1828                 smp_distribute_keys(smp);
1829                 return 0;
1830         }
1831
1832         if ((req->auth_req & SMP_AUTH_SC) && (auth & SMP_AUTH_SC))
1833                 set_bit(SMP_FLAG_SC, &smp->flags);
1834         else if (conn->hcon->pending_sec_level > BT_SECURITY_HIGH)
1835                 conn->hcon->pending_sec_level = BT_SECURITY_HIGH;
1836
1837         /* If we need MITM check that it can be achieved */
1838         if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1839                 u8 method;
1840
1841                 method = get_auth_method(smp, req->io_capability,
1842                                          rsp->io_capability);
1843                 if (method == JUST_WORKS || method == JUST_CFM)
1844                         return SMP_AUTH_REQUIREMENTS;
1845         }
1846
1847         get_random_bytes(smp->prnd, sizeof(smp->prnd));
1848
1849         /* Update remote key distribution in case the remote cleared
1850          * some bits that we had enabled in our request.
1851          */
1852         smp->remote_key_dist &= rsp->resp_key_dist;
1853
1854         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1855                 /* Clear bits which are generated but not distributed */
1856                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1857                 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1858                 return sc_send_public_key(smp);
1859         }
1860
1861         auth |= req->auth_req;
1862
1863         ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
1864         if (ret)
1865                 return SMP_UNSPECIFIED;
1866
1867         set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
1868
1869         /* Can't compose response until we have been confirmed */
1870         if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
1871                 return smp_confirm(smp);
1872
1873         return 0;
1874 }
1875
1876 static u8 sc_check_confirm(struct smp_chan *smp)
1877 {
1878         struct l2cap_conn *conn = smp->conn;
1879
1880         BT_DBG("");
1881
1882         /* Public Key exchange must happen before any other steps */
1883         if (!test_bit(SMP_FLAG_REMOTE_PK, &smp->flags))
1884                 return SMP_UNSPECIFIED;
1885
1886         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1887                 return sc_passkey_round(smp, SMP_CMD_PAIRING_CONFIRM);
1888
1889         if (conn->hcon->out) {
1890                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1891                              smp->prnd);
1892                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1893         }
1894
1895         return 0;
1896 }
1897
1898 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
1899 {
1900         struct l2cap_chan *chan = conn->smp;
1901         struct smp_chan *smp = chan->data;
1902
1903         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
1904
1905         if (skb->len < sizeof(smp->pcnf))
1906                 return SMP_INVALID_PARAMS;
1907
1908         memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
1909         skb_pull(skb, sizeof(smp->pcnf));
1910
1911         if (test_bit(SMP_FLAG_SC, &smp->flags))
1912                 return sc_check_confirm(smp);
1913
1914         if (conn->hcon->out) {
1915                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1916                              smp->prnd);
1917                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1918                 return 0;
1919         }
1920
1921         if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
1922                 return smp_confirm(smp);
1923         else
1924                 set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
1925
1926         return 0;
1927 }
1928
1929 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
1930 {
1931         struct l2cap_chan *chan = conn->smp;
1932         struct smp_chan *smp = chan->data;
1933         struct hci_conn *hcon = conn->hcon;
1934         u8 *pkax, *pkbx, *na, *nb;
1935         u32 passkey;
1936         int err;
1937
1938         BT_DBG("conn %p", conn);
1939
1940         if (skb->len < sizeof(smp->rrnd))
1941                 return SMP_INVALID_PARAMS;
1942
1943         memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
1944         skb_pull(skb, sizeof(smp->rrnd));
1945
1946         if (!test_bit(SMP_FLAG_SC, &smp->flags))
1947                 return smp_random(smp);
1948
1949         if (hcon->out) {
1950                 pkax = smp->local_pk;
1951                 pkbx = smp->remote_pk;
1952                 na   = smp->prnd;
1953                 nb   = smp->rrnd;
1954         } else {
1955                 pkax = smp->remote_pk;
1956                 pkbx = smp->local_pk;
1957                 na   = smp->rrnd;
1958                 nb   = smp->prnd;
1959         }
1960
1961         if (smp->method == REQ_OOB) {
1962                 if (!hcon->out)
1963                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1964                                      sizeof(smp->prnd), smp->prnd);
1965                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1966                 goto mackey_and_ltk;
1967         }
1968
1969         /* Passkey entry has special treatment */
1970         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1971                 return sc_passkey_round(smp, SMP_CMD_PAIRING_RANDOM);
1972
1973         if (hcon->out) {
1974                 u8 cfm[16];
1975
1976                 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
1977                              smp->rrnd, 0, cfm);
1978                 if (err)
1979                         return SMP_UNSPECIFIED;
1980
1981                 if (memcmp(smp->pcnf, cfm, 16))
1982                         return SMP_CONFIRM_FAILED;
1983         } else {
1984                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1985                              smp->prnd);
1986                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1987         }
1988
1989 mackey_and_ltk:
1990         /* Generate MacKey and LTK */
1991         err = sc_mackey_and_ltk(smp, smp->mackey, smp->tk);
1992         if (err)
1993                 return SMP_UNSPECIFIED;
1994
1995         if (smp->method == JUST_WORKS || smp->method == REQ_OOB) {
1996                 if (hcon->out) {
1997                         sc_dhkey_check(smp);
1998                         SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1999                 }
2000                 return 0;
2001         }
2002
2003         err = smp_g2(smp->tfm_cmac, pkax, pkbx, na, nb, &passkey);
2004         if (err)
2005                 return SMP_UNSPECIFIED;
2006
2007         err = mgmt_user_confirm_request(hcon->hdev, &hcon->dst, hcon->type,
2008                                         hcon->dst_type, passkey, 0);
2009         if (err)
2010                 return SMP_UNSPECIFIED;
2011
2012         set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2013
2014         return 0;
2015 }
2016
2017 static bool smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
2018 {
2019         struct smp_ltk *key;
2020         struct hci_conn *hcon = conn->hcon;
2021
2022         key = hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role);
2023         if (!key)
2024                 return false;
2025
2026         if (smp_ltk_sec_level(key) < sec_level)
2027                 return false;
2028
2029         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
2030                 return true;
2031
2032         hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
2033         hcon->enc_key_size = key->enc_size;
2034
2035         /* We never store STKs for master role, so clear this flag */
2036         clear_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
2037
2038         return true;
2039 }
2040
2041 bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level,
2042                              enum smp_key_pref key_pref)
2043 {
2044         if (sec_level == BT_SECURITY_LOW)
2045                 return true;
2046
2047         /* If we're encrypted with an STK but the caller prefers using
2048          * LTK claim insufficient security. This way we allow the
2049          * connection to be re-encrypted with an LTK, even if the LTK
2050          * provides the same level of security. Only exception is if we
2051          * don't have an LTK (e.g. because of key distribution bits).
2052          */
2053         if (key_pref == SMP_USE_LTK &&
2054             test_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags) &&
2055             hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role))
2056                 return false;
2057
2058         if (hcon->sec_level >= sec_level)
2059                 return true;
2060
2061         return false;
2062 }
2063
2064 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
2065 {
2066         struct smp_cmd_security_req *rp = (void *) skb->data;
2067         struct smp_cmd_pairing cp;
2068         struct hci_conn *hcon = conn->hcon;
2069         struct hci_dev *hdev = hcon->hdev;
2070         struct smp_chan *smp;
2071         u8 sec_level, auth;
2072
2073         BT_DBG("conn %p", conn);
2074
2075         if (skb->len < sizeof(*rp))
2076                 return SMP_INVALID_PARAMS;
2077
2078         if (hcon->role != HCI_ROLE_MASTER)
2079                 return SMP_CMD_NOTSUPP;
2080
2081         auth = rp->auth_req & AUTH_REQ_MASK(hdev);
2082
2083         if (test_bit(HCI_SC_ONLY, &hdev->dev_flags) && !(auth & SMP_AUTH_SC))
2084                 return SMP_AUTH_REQUIREMENTS;
2085
2086         if (hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
2087                 sec_level = BT_SECURITY_MEDIUM;
2088         else
2089                 sec_level = authreq_to_seclevel(auth);
2090
2091         if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
2092                 return 0;
2093
2094         if (sec_level > hcon->pending_sec_level)
2095                 hcon->pending_sec_level = sec_level;
2096
2097         if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
2098                 return 0;
2099
2100         smp = smp_chan_create(conn);
2101         if (!smp)
2102                 return SMP_UNSPECIFIED;
2103
2104         if (!test_bit(HCI_BONDABLE, &hcon->hdev->dev_flags) &&
2105             (auth & SMP_AUTH_BONDING))
2106                 return SMP_PAIRING_NOTSUPP;
2107
2108         skb_pull(skb, sizeof(*rp));
2109
2110         memset(&cp, 0, sizeof(cp));
2111         build_pairing_cmd(conn, &cp, NULL, auth);
2112
2113         smp->preq[0] = SMP_CMD_PAIRING_REQ;
2114         memcpy(&smp->preq[1], &cp, sizeof(cp));
2115
2116         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
2117         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2118
2119         return 0;
2120 }
2121
2122 int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
2123 {
2124         struct l2cap_conn *conn = hcon->l2cap_data;
2125         struct l2cap_chan *chan;
2126         struct smp_chan *smp;
2127         __u8 authreq;
2128         int ret;
2129
2130         BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
2131
2132         /* This may be NULL if there's an unexpected disconnection */
2133         if (!conn)
2134                 return 1;
2135
2136         chan = conn->smp;
2137
2138         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
2139                 return 1;
2140
2141         if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
2142                 return 1;
2143
2144         if (sec_level > hcon->pending_sec_level)
2145                 hcon->pending_sec_level = sec_level;
2146
2147         if (hcon->role == HCI_ROLE_MASTER)
2148                 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
2149                         return 0;
2150
2151         l2cap_chan_lock(chan);
2152
2153         /* If SMP is already in progress ignore this request */
2154         if (chan->data) {
2155                 ret = 0;
2156                 goto unlock;
2157         }
2158
2159         smp = smp_chan_create(conn);
2160         if (!smp) {
2161                 ret = 1;
2162                 goto unlock;
2163         }
2164
2165         authreq = seclevel_to_authreq(sec_level);
2166
2167         if (test_bit(HCI_SC_ENABLED, &hcon->hdev->dev_flags))
2168                 authreq |= SMP_AUTH_SC;
2169
2170         /* Require MITM if IO Capability allows or the security level
2171          * requires it.
2172          */
2173         if (hcon->io_capability != HCI_IO_NO_INPUT_OUTPUT ||
2174             hcon->pending_sec_level > BT_SECURITY_MEDIUM)
2175                 authreq |= SMP_AUTH_MITM;
2176
2177         if (hcon->role == HCI_ROLE_MASTER) {
2178                 struct smp_cmd_pairing cp;
2179
2180                 build_pairing_cmd(conn, &cp, NULL, authreq);
2181                 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2182                 memcpy(&smp->preq[1], &cp, sizeof(cp));
2183
2184                 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
2185                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2186         } else {
2187                 struct smp_cmd_security_req cp;
2188                 cp.auth_req = authreq;
2189                 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
2190                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_REQ);
2191         }
2192
2193         set_bit(SMP_FLAG_INITIATOR, &smp->flags);
2194         ret = 0;
2195
2196 unlock:
2197         l2cap_chan_unlock(chan);
2198         return ret;
2199 }
2200
2201 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
2202 {
2203         struct smp_cmd_encrypt_info *rp = (void *) skb->data;
2204         struct l2cap_chan *chan = conn->smp;
2205         struct smp_chan *smp = chan->data;
2206
2207         BT_DBG("conn %p", conn);
2208
2209         if (skb->len < sizeof(*rp))
2210                 return SMP_INVALID_PARAMS;
2211
2212         SMP_ALLOW_CMD(smp, SMP_CMD_MASTER_IDENT);
2213
2214         skb_pull(skb, sizeof(*rp));
2215
2216         memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
2217
2218         return 0;
2219 }
2220
2221 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
2222 {
2223         struct smp_cmd_master_ident *rp = (void *) skb->data;
2224         struct l2cap_chan *chan = conn->smp;
2225         struct smp_chan *smp = chan->data;
2226         struct hci_dev *hdev = conn->hcon->hdev;
2227         struct hci_conn *hcon = conn->hcon;
2228         struct smp_ltk *ltk;
2229         u8 authenticated;
2230
2231         BT_DBG("conn %p", conn);
2232
2233         if (skb->len < sizeof(*rp))
2234                 return SMP_INVALID_PARAMS;
2235
2236         /* Mark the information as received */
2237         smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
2238
2239         if (smp->remote_key_dist & SMP_DIST_ID_KEY)
2240                 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
2241         else if (smp->remote_key_dist & SMP_DIST_SIGN)
2242                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
2243
2244         skb_pull(skb, sizeof(*rp));
2245
2246         authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
2247         ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, SMP_LTK,
2248                           authenticated, smp->tk, smp->enc_key_size,
2249                           rp->ediv, rp->rand);
2250         smp->ltk = ltk;
2251         if (!(smp->remote_key_dist & KEY_DIST_MASK))
2252                 smp_distribute_keys(smp);
2253
2254         return 0;
2255 }
2256
2257 static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
2258 {
2259         struct smp_cmd_ident_info *info = (void *) skb->data;
2260         struct l2cap_chan *chan = conn->smp;
2261         struct smp_chan *smp = chan->data;
2262
2263         BT_DBG("");
2264
2265         if (skb->len < sizeof(*info))
2266                 return SMP_INVALID_PARAMS;
2267
2268         SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_ADDR_INFO);
2269
2270         skb_pull(skb, sizeof(*info));
2271
2272         memcpy(smp->irk, info->irk, 16);
2273
2274         return 0;
2275 }
2276
2277 static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
2278                                    struct sk_buff *skb)
2279 {
2280         struct smp_cmd_ident_addr_info *info = (void *) skb->data;
2281         struct l2cap_chan *chan = conn->smp;
2282         struct smp_chan *smp = chan->data;
2283         struct hci_conn *hcon = conn->hcon;
2284         bdaddr_t rpa;
2285
2286         BT_DBG("");
2287
2288         if (skb->len < sizeof(*info))
2289                 return SMP_INVALID_PARAMS;
2290
2291         /* Mark the information as received */
2292         smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
2293
2294         if (smp->remote_key_dist & SMP_DIST_SIGN)
2295                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
2296
2297         skb_pull(skb, sizeof(*info));
2298
2299         /* Strictly speaking the Core Specification (4.1) allows sending
2300          * an empty address which would force us to rely on just the IRK
2301          * as "identity information". However, since such
2302          * implementations are not known of and in order to not over
2303          * complicate our implementation, simply pretend that we never
2304          * received an IRK for such a device.
2305          */
2306         if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
2307                 BT_ERR("Ignoring IRK with no identity address");
2308                 goto distribute;
2309         }
2310
2311         bacpy(&smp->id_addr, &info->bdaddr);
2312         smp->id_addr_type = info->addr_type;
2313
2314         if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
2315                 bacpy(&rpa, &hcon->dst);
2316         else
2317                 bacpy(&rpa, BDADDR_ANY);
2318
2319         smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
2320                                       smp->id_addr_type, smp->irk, &rpa);
2321
2322 distribute:
2323         if (!(smp->remote_key_dist & KEY_DIST_MASK))
2324                 smp_distribute_keys(smp);
2325
2326         return 0;
2327 }
2328
2329 static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
2330 {
2331         struct smp_cmd_sign_info *rp = (void *) skb->data;
2332         struct l2cap_chan *chan = conn->smp;
2333         struct smp_chan *smp = chan->data;
2334         struct smp_csrk *csrk;
2335
2336         BT_DBG("conn %p", conn);
2337
2338         if (skb->len < sizeof(*rp))
2339                 return SMP_INVALID_PARAMS;
2340
2341         /* Mark the information as received */
2342         smp->remote_key_dist &= ~SMP_DIST_SIGN;
2343
2344         skb_pull(skb, sizeof(*rp));
2345
2346         csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
2347         if (csrk) {
2348                 csrk->master = 0x01;
2349                 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
2350         }
2351         smp->csrk = csrk;
2352         smp_distribute_keys(smp);
2353
2354         return 0;
2355 }
2356
2357 static u8 sc_select_method(struct smp_chan *smp)
2358 {
2359         struct l2cap_conn *conn = smp->conn;
2360         struct hci_conn *hcon = conn->hcon;
2361         struct smp_cmd_pairing *local, *remote;
2362         u8 local_mitm, remote_mitm, local_io, remote_io, method;
2363
2364         if (test_bit(SMP_FLAG_OOB, &smp->flags))
2365                 return REQ_OOB;
2366
2367         /* The preq/prsp contain the raw Pairing Request/Response PDUs
2368          * which are needed as inputs to some crypto functions. To get
2369          * the "struct smp_cmd_pairing" from them we need to skip the
2370          * first byte which contains the opcode.
2371          */
2372         if (hcon->out) {
2373                 local = (void *) &smp->preq[1];
2374                 remote = (void *) &smp->prsp[1];
2375         } else {
2376                 local = (void *) &smp->prsp[1];
2377                 remote = (void *) &smp->preq[1];
2378         }
2379
2380         local_io = local->io_capability;
2381         remote_io = remote->io_capability;
2382
2383         local_mitm = (local->auth_req & SMP_AUTH_MITM);
2384         remote_mitm = (remote->auth_req & SMP_AUTH_MITM);
2385
2386         /* If either side wants MITM, look up the method from the table,
2387          * otherwise use JUST WORKS.
2388          */
2389         if (local_mitm || remote_mitm)
2390                 method = get_auth_method(smp, local_io, remote_io);
2391         else
2392                 method = JUST_WORKS;
2393
2394         /* Don't confirm locally initiated pairing attempts */
2395         if (method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR, &smp->flags))
2396                 method = JUST_WORKS;
2397
2398         return method;
2399 }
2400
2401 static int smp_cmd_public_key(struct l2cap_conn *conn, struct sk_buff *skb)
2402 {
2403         struct smp_cmd_public_key *key = (void *) skb->data;
2404         struct hci_conn *hcon = conn->hcon;
2405         struct l2cap_chan *chan = conn->smp;
2406         struct smp_chan *smp = chan->data;
2407         struct hci_dev *hdev = hcon->hdev;
2408         struct smp_cmd_pairing_confirm cfm;
2409         int err;
2410
2411         BT_DBG("conn %p", conn);
2412
2413         if (skb->len < sizeof(*key))
2414                 return SMP_INVALID_PARAMS;
2415
2416         memcpy(smp->remote_pk, key, 64);
2417
2418         /* Non-initiating device sends its public key after receiving
2419          * the key from the initiating device.
2420          */
2421         if (!hcon->out) {
2422                 err = sc_send_public_key(smp);
2423                 if (err)
2424                         return err;
2425         }
2426
2427         SMP_DBG("Remote Public Key X: %32phN", smp->remote_pk);
2428         SMP_DBG("Remote Public Key Y: %32phN", &smp->remote_pk[32]);
2429
2430         if (!ecdh_shared_secret(smp->remote_pk, smp->local_sk, smp->dhkey))
2431                 return SMP_UNSPECIFIED;
2432
2433         SMP_DBG("DHKey %32phN", smp->dhkey);
2434
2435         set_bit(SMP_FLAG_REMOTE_PK, &smp->flags);
2436
2437         smp->method = sc_select_method(smp);
2438
2439         BT_DBG("%s selected method 0x%02x", hdev->name, smp->method);
2440
2441         /* JUST_WORKS and JUST_CFM result in an unauthenticated key */
2442         if (smp->method == JUST_WORKS || smp->method == JUST_CFM)
2443                 hcon->pending_sec_level = BT_SECURITY_MEDIUM;
2444         else
2445                 hcon->pending_sec_level = BT_SECURITY_FIPS;
2446
2447         if (!memcmp(debug_pk, smp->remote_pk, 64))
2448                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
2449
2450         if (smp->method == DSP_PASSKEY) {
2451                 get_random_bytes(&hcon->passkey_notify,
2452                                  sizeof(hcon->passkey_notify));
2453                 hcon->passkey_notify %= 1000000;
2454                 hcon->passkey_entered = 0;
2455                 smp->passkey_round = 0;
2456                 if (mgmt_user_passkey_notify(hdev, &hcon->dst, hcon->type,
2457                                              hcon->dst_type,
2458                                              hcon->passkey_notify,
2459                                              hcon->passkey_entered))
2460                         return SMP_UNSPECIFIED;
2461                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2462                 return sc_passkey_round(smp, SMP_CMD_PUBLIC_KEY);
2463         }
2464
2465         if (smp->method == REQ_OOB) {
2466                 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->remote_pk,
2467                              smp->rr, 0, cfm.confirm_val);
2468                 if (err)
2469                         return SMP_UNSPECIFIED;
2470
2471                 if (memcmp(cfm.confirm_val, smp->pcnf, 16))
2472                         return SMP_CONFIRM_FAILED;
2473
2474                 if (hcon->out)
2475                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
2476                                      sizeof(smp->prnd), smp->prnd);
2477
2478                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2479
2480                 return 0;
2481         }
2482
2483         if (hcon->out)
2484                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2485
2486         if (smp->method == REQ_PASSKEY) {
2487                 if (mgmt_user_passkey_request(hdev, &hcon->dst, hcon->type,
2488                                               hcon->dst_type))
2489                         return SMP_UNSPECIFIED;
2490                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2491                 set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2492                 return 0;
2493         }
2494
2495         /* The Initiating device waits for the non-initiating device to
2496          * send the confirm value.
2497          */
2498         if (conn->hcon->out)
2499                 return 0;
2500
2501         err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd,
2502                      0, cfm.confirm_val);
2503         if (err)
2504                 return SMP_UNSPECIFIED;
2505
2506         smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
2507         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2508
2509         return 0;
2510 }
2511
2512 static int smp_cmd_dhkey_check(struct l2cap_conn *conn, struct sk_buff *skb)
2513 {
2514         struct smp_cmd_dhkey_check *check = (void *) skb->data;
2515         struct l2cap_chan *chan = conn->smp;
2516         struct hci_conn *hcon = conn->hcon;
2517         struct smp_chan *smp = chan->data;
2518         u8 a[7], b[7], *local_addr, *remote_addr;
2519         u8 io_cap[3], r[16], e[16];
2520         int err;
2521
2522         BT_DBG("conn %p", conn);
2523
2524         if (skb->len < sizeof(*check))
2525                 return SMP_INVALID_PARAMS;
2526
2527         memcpy(a, &hcon->init_addr, 6);
2528         memcpy(b, &hcon->resp_addr, 6);
2529         a[6] = hcon->init_addr_type;
2530         b[6] = hcon->resp_addr_type;
2531
2532         if (hcon->out) {
2533                 local_addr = a;
2534                 remote_addr = b;
2535                 memcpy(io_cap, &smp->prsp[1], 3);
2536         } else {
2537                 local_addr = b;
2538                 remote_addr = a;
2539                 memcpy(io_cap, &smp->preq[1], 3);
2540         }
2541
2542         memset(r, 0, sizeof(r));
2543
2544         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2545                 put_unaligned_le32(hcon->passkey_notify, r);
2546
2547         err = smp_f6(smp->tfm_cmac, smp->mackey, smp->rrnd, smp->prnd, r,
2548                      io_cap, remote_addr, local_addr, e);
2549         if (err)
2550                 return SMP_UNSPECIFIED;
2551
2552         if (memcmp(check->e, e, 16))
2553                 return SMP_DHKEY_CHECK_FAILED;
2554
2555         if (!hcon->out) {
2556                 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
2557                         set_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags);
2558                         return 0;
2559                 }
2560
2561                 /* Slave sends DHKey check as response to master */
2562                 sc_dhkey_check(smp);
2563         }
2564
2565         sc_add_ltk(smp);
2566
2567         if (hcon->out) {
2568                 hci_le_start_enc(hcon, 0, 0, smp->tk);
2569                 hcon->enc_key_size = smp->enc_key_size;
2570         }
2571
2572         return 0;
2573 }
2574
2575 static int smp_cmd_keypress_notify(struct l2cap_conn *conn,
2576                                    struct sk_buff *skb)
2577 {
2578         struct smp_cmd_keypress_notify *kp = (void *) skb->data;
2579
2580         BT_DBG("value 0x%02x", kp->value);
2581
2582         return 0;
2583 }
2584
2585 static int smp_sig_channel(struct l2cap_chan *chan, struct sk_buff *skb)
2586 {
2587         struct l2cap_conn *conn = chan->conn;
2588         struct hci_conn *hcon = conn->hcon;
2589         struct smp_chan *smp;
2590         __u8 code, reason;
2591         int err = 0;
2592
2593         if (skb->len < 1)
2594                 return -EILSEQ;
2595
2596         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
2597                 reason = SMP_PAIRING_NOTSUPP;
2598                 goto done;
2599         }
2600
2601         code = skb->data[0];
2602         skb_pull(skb, sizeof(code));
2603
2604         smp = chan->data;
2605
2606         if (code > SMP_CMD_MAX)
2607                 goto drop;
2608
2609         if (smp && !test_and_clear_bit(code, &smp->allow_cmd))
2610                 goto drop;
2611
2612         /* If we don't have a context the only allowed commands are
2613          * pairing request and security request.
2614          */
2615         if (!smp && code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ)
2616                 goto drop;
2617
2618         switch (code) {
2619         case SMP_CMD_PAIRING_REQ:
2620                 reason = smp_cmd_pairing_req(conn, skb);
2621                 break;
2622
2623         case SMP_CMD_PAIRING_FAIL:
2624                 smp_failure(conn, 0);
2625                 err = -EPERM;
2626                 break;
2627
2628         case SMP_CMD_PAIRING_RSP:
2629                 reason = smp_cmd_pairing_rsp(conn, skb);
2630                 break;
2631
2632         case SMP_CMD_SECURITY_REQ:
2633                 reason = smp_cmd_security_req(conn, skb);
2634                 break;
2635
2636         case SMP_CMD_PAIRING_CONFIRM:
2637                 reason = smp_cmd_pairing_confirm(conn, skb);
2638                 break;
2639
2640         case SMP_CMD_PAIRING_RANDOM:
2641                 reason = smp_cmd_pairing_random(conn, skb);
2642                 break;
2643
2644         case SMP_CMD_ENCRYPT_INFO:
2645                 reason = smp_cmd_encrypt_info(conn, skb);
2646                 break;
2647
2648         case SMP_CMD_MASTER_IDENT:
2649                 reason = smp_cmd_master_ident(conn, skb);
2650                 break;
2651
2652         case SMP_CMD_IDENT_INFO:
2653                 reason = smp_cmd_ident_info(conn, skb);
2654                 break;
2655
2656         case SMP_CMD_IDENT_ADDR_INFO:
2657                 reason = smp_cmd_ident_addr_info(conn, skb);
2658                 break;
2659
2660         case SMP_CMD_SIGN_INFO:
2661                 reason = smp_cmd_sign_info(conn, skb);
2662                 break;
2663
2664         case SMP_CMD_PUBLIC_KEY:
2665                 reason = smp_cmd_public_key(conn, skb);
2666                 break;
2667
2668         case SMP_CMD_DHKEY_CHECK:
2669                 reason = smp_cmd_dhkey_check(conn, skb);
2670                 break;
2671
2672         case SMP_CMD_KEYPRESS_NOTIFY:
2673                 reason = smp_cmd_keypress_notify(conn, skb);
2674                 break;
2675
2676         default:
2677                 BT_DBG("Unknown command code 0x%2.2x", code);
2678                 reason = SMP_CMD_NOTSUPP;
2679                 goto done;
2680         }
2681
2682 done:
2683         if (!err) {
2684                 if (reason)
2685                         smp_failure(conn, reason);
2686                 kfree_skb(skb);
2687         }
2688
2689         return err;
2690
2691 drop:
2692         BT_ERR("%s unexpected SMP command 0x%02x from %pMR", hcon->hdev->name,
2693                code, &hcon->dst);
2694         kfree_skb(skb);
2695         return 0;
2696 }
2697
2698 static void smp_teardown_cb(struct l2cap_chan *chan, int err)
2699 {
2700         struct l2cap_conn *conn = chan->conn;
2701
2702         BT_DBG("chan %p", chan);
2703
2704         if (chan->data)
2705                 smp_chan_destroy(conn);
2706
2707         conn->smp = NULL;
2708         l2cap_chan_put(chan);
2709 }
2710
2711 static void bredr_pairing(struct l2cap_chan *chan)
2712 {
2713         struct l2cap_conn *conn = chan->conn;
2714         struct hci_conn *hcon = conn->hcon;
2715         struct hci_dev *hdev = hcon->hdev;
2716         struct smp_cmd_pairing req;
2717         struct smp_chan *smp;
2718
2719         BT_DBG("chan %p", chan);
2720
2721         /* Only new pairings are interesting */
2722         if (!test_bit(HCI_CONN_NEW_LINK_KEY, &hcon->flags))
2723                 return;
2724
2725         /* Don't bother if we're not encrypted */
2726         if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2727                 return;
2728
2729         /* Only master may initiate SMP over BR/EDR */
2730         if (hcon->role != HCI_ROLE_MASTER)
2731                 return;
2732
2733         /* Secure Connections support must be enabled */
2734         if (!test_bit(HCI_SC_ENABLED, &hdev->dev_flags))
2735                 return;
2736
2737         /* BR/EDR must use Secure Connections for SMP */
2738         if (!test_bit(HCI_CONN_AES_CCM, &hcon->flags) &&
2739             !test_bit(HCI_FORCE_LESC, &hdev->dbg_flags))
2740                 return;
2741
2742         /* If our LE support is not enabled don't do anything */
2743         if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
2744                 return;
2745
2746         /* Don't bother if remote LE support is not enabled */
2747         if (!lmp_host_le_capable(hcon))
2748                 return;
2749
2750         /* Remote must support SMP fixed chan for BR/EDR */
2751         if (!(conn->remote_fixed_chan & L2CAP_FC_SMP_BREDR))
2752                 return;
2753
2754         /* Don't bother if SMP is already ongoing */
2755         if (chan->data)
2756                 return;
2757
2758         smp = smp_chan_create(conn);
2759         if (!smp) {
2760                 BT_ERR("%s unable to create SMP context for BR/EDR",
2761                        hdev->name);
2762                 return;
2763         }
2764
2765         set_bit(SMP_FLAG_SC, &smp->flags);
2766
2767         BT_DBG("%s starting SMP over BR/EDR", hdev->name);
2768
2769         /* Prepare and send the BR/EDR SMP Pairing Request */
2770         build_bredr_pairing_cmd(smp, &req, NULL);
2771
2772         smp->preq[0] = SMP_CMD_PAIRING_REQ;
2773         memcpy(&smp->preq[1], &req, sizeof(req));
2774
2775         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(req), &req);
2776         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2777 }
2778
2779 static void smp_resume_cb(struct l2cap_chan *chan)
2780 {
2781         struct smp_chan *smp = chan->data;
2782         struct l2cap_conn *conn = chan->conn;
2783         struct hci_conn *hcon = conn->hcon;
2784
2785         BT_DBG("chan %p", chan);
2786
2787         if (hcon->type == ACL_LINK) {
2788                 bredr_pairing(chan);
2789                 return;
2790         }
2791
2792         if (!smp)
2793                 return;
2794
2795         if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2796                 return;
2797
2798         cancel_delayed_work(&smp->security_timer);
2799
2800         smp_distribute_keys(smp);
2801 }
2802
2803 static void smp_ready_cb(struct l2cap_chan *chan)
2804 {
2805         struct l2cap_conn *conn = chan->conn;
2806         struct hci_conn *hcon = conn->hcon;
2807
2808         BT_DBG("chan %p", chan);
2809
2810         conn->smp = chan;
2811         l2cap_chan_hold(chan);
2812
2813         if (hcon->type == ACL_LINK && test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2814                 bredr_pairing(chan);
2815 }
2816
2817 static int smp_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
2818 {
2819         int err;
2820
2821         BT_DBG("chan %p", chan);
2822
2823         err = smp_sig_channel(chan, skb);
2824         if (err) {
2825                 struct smp_chan *smp = chan->data;
2826
2827                 if (smp)
2828                         cancel_delayed_work_sync(&smp->security_timer);
2829
2830                 hci_disconnect(chan->conn->hcon, HCI_ERROR_AUTH_FAILURE);
2831         }
2832
2833         return err;
2834 }
2835
2836 static struct sk_buff *smp_alloc_skb_cb(struct l2cap_chan *chan,
2837                                         unsigned long hdr_len,
2838                                         unsigned long len, int nb)
2839 {
2840         struct sk_buff *skb;
2841
2842         skb = bt_skb_alloc(hdr_len + len, GFP_KERNEL);
2843         if (!skb)
2844                 return ERR_PTR(-ENOMEM);
2845
2846         skb->priority = HCI_PRIO_MAX;
2847         bt_cb(skb)->chan = chan;
2848
2849         return skb;
2850 }
2851
2852 static const struct l2cap_ops smp_chan_ops = {
2853         .name                   = "Security Manager",
2854         .ready                  = smp_ready_cb,
2855         .recv                   = smp_recv_cb,
2856         .alloc_skb              = smp_alloc_skb_cb,
2857         .teardown               = smp_teardown_cb,
2858         .resume                 = smp_resume_cb,
2859
2860         .new_connection         = l2cap_chan_no_new_connection,
2861         .state_change           = l2cap_chan_no_state_change,
2862         .close                  = l2cap_chan_no_close,
2863         .defer                  = l2cap_chan_no_defer,
2864         .suspend                = l2cap_chan_no_suspend,
2865         .set_shutdown           = l2cap_chan_no_set_shutdown,
2866         .get_sndtimeo           = l2cap_chan_no_get_sndtimeo,
2867 };
2868
2869 static inline struct l2cap_chan *smp_new_conn_cb(struct l2cap_chan *pchan)
2870 {
2871         struct l2cap_chan *chan;
2872
2873         BT_DBG("pchan %p", pchan);
2874
2875         chan = l2cap_chan_create();
2876         if (!chan)
2877                 return NULL;
2878
2879         chan->chan_type = pchan->chan_type;
2880         chan->ops       = &smp_chan_ops;
2881         chan->scid      = pchan->scid;
2882         chan->dcid      = chan->scid;
2883         chan->imtu      = pchan->imtu;
2884         chan->omtu      = pchan->omtu;
2885         chan->mode      = pchan->mode;
2886
2887         /* Other L2CAP channels may request SMP routines in order to
2888          * change the security level. This means that the SMP channel
2889          * lock must be considered in its own category to avoid lockdep
2890          * warnings.
2891          */
2892         atomic_set(&chan->nesting, L2CAP_NESTING_SMP);
2893
2894         BT_DBG("created chan %p", chan);
2895
2896         return chan;
2897 }
2898
2899 static const struct l2cap_ops smp_root_chan_ops = {
2900         .name                   = "Security Manager Root",
2901         .new_connection         = smp_new_conn_cb,
2902
2903         /* None of these are implemented for the root channel */
2904         .close                  = l2cap_chan_no_close,
2905         .alloc_skb              = l2cap_chan_no_alloc_skb,
2906         .recv                   = l2cap_chan_no_recv,
2907         .state_change           = l2cap_chan_no_state_change,
2908         .teardown               = l2cap_chan_no_teardown,
2909         .ready                  = l2cap_chan_no_ready,
2910         .defer                  = l2cap_chan_no_defer,
2911         .suspend                = l2cap_chan_no_suspend,
2912         .resume                 = l2cap_chan_no_resume,
2913         .set_shutdown           = l2cap_chan_no_set_shutdown,
2914         .get_sndtimeo           = l2cap_chan_no_get_sndtimeo,
2915 };
2916
2917 static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
2918 {
2919         struct l2cap_chan *chan;
2920         struct crypto_blkcipher *tfm_aes;
2921
2922         if (cid == L2CAP_CID_SMP_BREDR) {
2923                 tfm_aes = NULL;
2924                 goto create_chan;
2925         }
2926
2927         tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, 0);
2928         if (IS_ERR(tfm_aes)) {
2929                 BT_ERR("Unable to create crypto context");
2930                 return ERR_PTR(PTR_ERR(tfm_aes));
2931         }
2932
2933 create_chan:
2934         chan = l2cap_chan_create();
2935         if (!chan) {
2936                 crypto_free_blkcipher(tfm_aes);
2937                 return ERR_PTR(-ENOMEM);
2938         }
2939
2940         chan->data = tfm_aes;
2941
2942         l2cap_add_scid(chan, cid);
2943
2944         l2cap_chan_set_defaults(chan);
2945
2946         bacpy(&chan->src, &hdev->bdaddr);
2947         if (cid == L2CAP_CID_SMP)
2948                 chan->src_type = BDADDR_LE_PUBLIC;
2949         else
2950                 chan->src_type = BDADDR_BREDR;
2951         chan->state = BT_LISTEN;
2952         chan->mode = L2CAP_MODE_BASIC;
2953         chan->imtu = L2CAP_DEFAULT_MTU;
2954         chan->ops = &smp_root_chan_ops;
2955
2956         /* Set correct nesting level for a parent/listening channel */
2957         atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
2958
2959         return chan;
2960 }
2961
2962 static void smp_del_chan(struct l2cap_chan *chan)
2963 {
2964         struct crypto_blkcipher *tfm_aes;
2965
2966         BT_DBG("chan %p", chan);
2967
2968         tfm_aes = chan->data;
2969         if (tfm_aes) {
2970                 chan->data = NULL;
2971                 crypto_free_blkcipher(tfm_aes);
2972         }
2973
2974         l2cap_chan_put(chan);
2975 }
2976
2977 int smp_register(struct hci_dev *hdev)
2978 {
2979         struct l2cap_chan *chan;
2980
2981         BT_DBG("%s", hdev->name);
2982
2983         chan = smp_add_cid(hdev, L2CAP_CID_SMP);
2984         if (IS_ERR(chan))
2985                 return PTR_ERR(chan);
2986
2987         hdev->smp_data = chan;
2988
2989         if (!lmp_sc_capable(hdev) &&
2990             !test_bit(HCI_FORCE_LESC, &hdev->dbg_flags))
2991                 return 0;
2992
2993         chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
2994         if (IS_ERR(chan)) {
2995                 int err = PTR_ERR(chan);
2996                 chan = hdev->smp_data;
2997                 hdev->smp_data = NULL;
2998                 smp_del_chan(chan);
2999                 return err;
3000         }
3001
3002         hdev->smp_bredr_data = chan;
3003
3004         return 0;
3005 }
3006
3007 void smp_unregister(struct hci_dev *hdev)
3008 {
3009         struct l2cap_chan *chan;
3010
3011         if (hdev->smp_bredr_data) {
3012                 chan = hdev->smp_bredr_data;
3013                 hdev->smp_bredr_data = NULL;
3014                 smp_del_chan(chan);
3015         }
3016
3017         if (hdev->smp_data) {
3018                 chan = hdev->smp_data;
3019                 hdev->smp_data = NULL;
3020                 smp_del_chan(chan);
3021         }
3022 }