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/debugfs.h>
  24 #include <linux/scatterlist.h>
  25 #include <linux/crypto.h>
  26 #include <crypto/algapi.h>
  27 #include <crypto/b128ops.h>
  28 #include <crypto/hash.h>
  29 #include <crypto/kpp.h>
  30
  31 #include <net/bluetooth/bluetooth.h>
  32 #include <net/bluetooth/hci_core.h>
  33 #include <net/bluetooth/l2cap.h>
  34 #include <net/bluetooth/mgmt.h>
  35
  36 #include "ecdh_helper.h"
  37 #include "smp.h"
  38
  39 #define SMP_DEV(hdev) \
  40         ((struct smp_dev *)((struct l2cap_chan *)((hdev)->smp_data))->data)
  41
  42 /* Low-level debug macros to be used for stuff that we don't want
  43  * accidentially in dmesg, i.e. the values of the various crypto keys
  44  * and the inputs & outputs of crypto functions.
  45  */
  46 #ifdef DEBUG
  47 #define SMP_DBG(fmt, ...) printk(KERN_DEBUG "%s: " fmt, __func__, \
  48                                  ##__VA_ARGS__)
  49 #else
  50 #define SMP_DBG(fmt, ...) no_printk(KERN_DEBUG "%s: " fmt, __func__, \
  51                                     ##__VA_ARGS__)
  52 #endif
  53
  54 #define SMP_ALLOW_CMD(smp, code)        set_bit(code, &smp->allow_cmd)
  55
  56 /* Keys which are not distributed with Secure Connections */
  57 #define SMP_SC_NO_DIST (SMP_DIST_ENC_KEY | SMP_DIST_LINK_KEY);
  58
  59 #define SMP_TIMEOUT     msecs_to_jiffies(30000)
  60
  61 #define AUTH_REQ_MASK(dev)      (hci_dev_test_flag(dev, HCI_SC_ENABLED) ? \
  62                                  0x3f : 0x07)
  63 #define KEY_DIST_MASK           0x07
  64
  65 /* Maximum message length that can be passed to aes_cmac */
  66 #define CMAC_MSG_MAX    80
  67
  68 enum {
  69         SMP_FLAG_TK_VALID,
  70         SMP_FLAG_CFM_PENDING,
  71         SMP_FLAG_MITM_AUTH,
  72         SMP_FLAG_COMPLETE,
  73         SMP_FLAG_INITIATOR,
  74         SMP_FLAG_SC,
  75         SMP_FLAG_REMOTE_PK,
  76         SMP_FLAG_DEBUG_KEY,
  77         SMP_FLAG_WAIT_USER,
  78         SMP_FLAG_DHKEY_PENDING,
  79         SMP_FLAG_REMOTE_OOB,
  80         SMP_FLAG_LOCAL_OOB,
  81         SMP_FLAG_CT2,
  82 };
  83
  84 struct smp_dev {
  85         /* Secure Connections OOB data */
  86         bool                    local_oob;
  87         u8                      local_pk[64];
  88         u8                      local_rand[16];
  89         bool                    debug_key;
  90
  91         struct crypto_cipher    *tfm_aes;
  92         struct crypto_shash     *tfm_cmac;
  93         struct crypto_kpp       *tfm_ecdh;
  94 };
  95
  96 struct smp_chan {
  97         struct l2cap_conn       *conn;
  98         struct delayed_work     security_timer;
  99         unsigned long           allow_cmd; /* Bitmask of allowed commands */
 100
 101         u8              preq[7]; /* SMP Pairing Request */
 102         u8              prsp[7]; /* SMP Pairing Response */
 103         u8              prnd[16]; /* SMP Pairing Random (local) */
 104         u8              rrnd[16]; /* SMP Pairing Random (remote) */
 105         u8              pcnf[16]; /* SMP Pairing Confirm */
 106         u8              tk[16]; /* SMP Temporary Key */
 107         u8              rr[16]; /* Remote OOB ra/rb value */
 108         u8              lr[16]; /* Local OOB ra/rb value */
 109         u8              enc_key_size;
 110         u8              remote_key_dist;
 111         bdaddr_t        id_addr;
 112         u8              id_addr_type;
 113         u8              irk[16];
 114         struct smp_csrk *csrk;
 115         struct smp_csrk *slave_csrk;
 116         struct smp_ltk  *ltk;
 117         struct smp_ltk  *slave_ltk;
 118         struct smp_irk  *remote_irk;
 119         u8              *link_key;
 120         unsigned long   flags;
 121         u8              method;
 122         u8              passkey_round;
 123
 124         /* Secure Connections variables */
 125         u8                      local_pk[64];
 126         u8                      remote_pk[64];
 127         u8                      dhkey[32];
 128         u8                      mackey[16];
 129
 130         struct crypto_cipher    *tfm_aes;
 131         struct crypto_shash     *tfm_cmac;
 132         struct crypto_kpp       *tfm_ecdh;
 133 };
 134
 135 /* These debug key values are defined in the SMP section of the core
 136  * specification. debug_pk is the public debug key and debug_sk the
 137  * private debug key.
 138  */
 139 static const u8 debug_pk[64] = {
 140                 0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
 141                 0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
 142                 0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
 143                 0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20,
 144
 145                 0x8b, 0xd2, 0x89, 0x15, 0xd0, 0x8e, 0x1c, 0x74,
 146                 0x24, 0x30, 0xed, 0x8f, 0xc2, 0x45, 0x63, 0x76,
 147                 0x5c, 0x15, 0x52, 0x5a, 0xbf, 0x9a, 0x32, 0x63,
 148                 0x6d, 0xeb, 0x2a, 0x65, 0x49, 0x9c, 0x80, 0xdc,
 149 };
 150
 151 static const u8 debug_sk[32] = {
 152                 0xbd, 0x1a, 0x3c, 0xcd, 0xa6, 0xb8, 0x99, 0x58,
 153                 0x99, 0xb7, 0x40, 0xeb, 0x7b, 0x60, 0xff, 0x4a,
 154                 0x50, 0x3f, 0x10, 0xd2, 0xe3, 0xb3, 0xc9, 0x74,
 155                 0x38, 0x5f, 0xc5, 0xa3, 0xd4, 0xf6, 0x49, 0x3f,
 156 };
 157
 158 static inline void swap_buf(const u8 *src, u8 *dst, size_t len)
 159 {
 160         size_t i;
 161
 162         for (i = 0; i < len; i++)
 163                 dst[len - 1 - i] = src[i];
 164 }
 165
 166 /* The following functions map to the LE SC SMP crypto functions
 167  * AES-CMAC, f4, f5, f6, g2 and h6.
 168  */
 169
 170 static int aes_cmac(struct crypto_shash *tfm, const u8 k[16], const u8 *m,
 171                     size_t len, u8 mac[16])
 172 {
 173         uint8_t tmp[16], mac_msb[16], msg_msb[CMAC_MSG_MAX];
 174         SHASH_DESC_ON_STACK(desc, tfm);
 175         int err;
 176
 177         if (len > CMAC_MSG_MAX)
 178                 return -EFBIG;
 179
 180         if (!tfm) {
 181                 BT_ERR("tfm %p", tfm);
 182                 return -EINVAL;
 183         }
 184
 185         desc->tfm = tfm;
 186         desc->flags = 0;
 187
 188         /* Swap key and message from LSB to MSB */
 189         swap_buf(k, tmp, 16);
 190         swap_buf(m, msg_msb, len);
 191
 192         SMP_DBG("msg (len %zu) %*phN", len, (int) len, m);
 193         SMP_DBG("key %16phN", k);
 194
 195         err = crypto_shash_setkey(tfm, tmp, 16);
 196         if (err) {
 197                 BT_ERR("cipher setkey failed: %d", err);
 198                 return err;
 199         }
 200
 201         err = crypto_shash_digest(desc, msg_msb, len, mac_msb);
 202         shash_desc_zero(desc);
 203         if (err) {
 204                 BT_ERR("Hash computation error %d", err);
 205                 return err;
 206         }
 207
 208         swap_buf(mac_msb, mac, 16);
 209
 210         SMP_DBG("mac %16phN", mac);
 211
 212         return 0;
 213 }
 214
 215 static int smp_f4(struct crypto_shash *tfm_cmac, const u8 u[32],
 216                   const u8 v[32], const u8 x[16], u8 z, u8 res[16])
 217 {
 218         u8 m[65];
 219         int err;
 220
 221         SMP_DBG("u %32phN", u);
 222         SMP_DBG("v %32phN", v);
 223         SMP_DBG("x %16phN z %02x", x, z);
 224
 225         m[0] = z;
 226         memcpy(m + 1, v, 32);
 227         memcpy(m + 33, u, 32);
 228
 229         err = aes_cmac(tfm_cmac, x, m, sizeof(m), res);
 230         if (err)
 231                 return err;
 232
 233         SMP_DBG("res %16phN", res);
 234
 235         return err;
 236 }
 237
 238 static int smp_f5(struct crypto_shash *tfm_cmac, const u8 w[32],
 239                   const u8 n1[16], const u8 n2[16], const u8 a1[7],
 240                   const u8 a2[7], u8 mackey[16], u8 ltk[16])
 241 {
 242         /* The btle, salt and length "magic" values are as defined in
 243          * the SMP section of the Bluetooth core specification. In ASCII
 244          * the btle value ends up being 'btle'. The salt is just a
 245          * random number whereas length is the value 256 in little
 246          * endian format.
 247          */
 248         const u8 btle[4] = { 0x65, 0x6c, 0x74, 0x62 };
 249         const u8 salt[16] = { 0xbe, 0x83, 0x60, 0x5a, 0xdb, 0x0b, 0x37, 0x60,
 250                               0x38, 0xa5, 0xf5, 0xaa, 0x91, 0x83, 0x88, 0x6c };
 251         const u8 length[2] = { 0x00, 0x01 };
 252         u8 m[53], t[16];
 253         int err;
 254
 255         SMP_DBG("w %32phN", w);
 256         SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
 257         SMP_DBG("a1 %7phN a2 %7phN", a1, a2);
 258
 259         err = aes_cmac(tfm_cmac, salt, w, 32, t);
 260         if (err)
 261                 return err;
 262
 263         SMP_DBG("t %16phN", t);
 264
 265         memcpy(m, length, 2);
 266         memcpy(m + 2, a2, 7);
 267         memcpy(m + 9, a1, 7);
 268         memcpy(m + 16, n2, 16);
 269         memcpy(m + 32, n1, 16);
 270         memcpy(m + 48, btle, 4);
 271
 272         m[52] = 0; /* Counter */
 273
 274         err = aes_cmac(tfm_cmac, t, m, sizeof(m), mackey);
 275         if (err)
 276                 return err;
 277
 278         SMP_DBG("mackey %16phN", mackey);
 279
 280         m[52] = 1; /* Counter */
 281
 282         err = aes_cmac(tfm_cmac, t, m, sizeof(m), ltk);
 283         if (err)
 284                 return err;
 285
 286         SMP_DBG("ltk %16phN", ltk);
 287
 288         return 0;
 289 }
 290
 291 static int smp_f6(struct crypto_shash *tfm_cmac, const u8 w[16],
 292                   const u8 n1[16], const u8 n2[16], const u8 r[16],
 293                   const u8 io_cap[3], const u8 a1[7], const u8 a2[7],
 294                   u8 res[16])
 295 {
 296         u8 m[65];
 297         int err;
 298
 299         SMP_DBG("w %16phN", w);
 300         SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
 301         SMP_DBG("r %16phN io_cap %3phN a1 %7phN a2 %7phN", r, io_cap, a1, a2);
 302
 303         memcpy(m, a2, 7);
 304         memcpy(m + 7, a1, 7);
 305         memcpy(m + 14, io_cap, 3);
 306         memcpy(m + 17, r, 16);
 307         memcpy(m + 33, n2, 16);
 308         memcpy(m + 49, n1, 16);
 309
 310         err = aes_cmac(tfm_cmac, w, m, sizeof(m), res);
 311         if (err)
 312                 return err;
 313
 314         SMP_DBG("res %16phN", res);
 315
 316         return err;
 317 }
 318
 319 static int smp_g2(struct crypto_shash *tfm_cmac, const u8 u[32], const u8 v[32],
 320                   const u8 x[16], const u8 y[16], u32 *val)
 321 {
 322         u8 m[80], tmp[16];
 323         int err;
 324
 325         SMP_DBG("u %32phN", u);
 326         SMP_DBG("v %32phN", v);
 327         SMP_DBG("x %16phN y %16phN", x, y);
 328
 329         memcpy(m, y, 16);
 330         memcpy(m + 16, v, 32);
 331         memcpy(m + 48, u, 32);
 332
 333         err = aes_cmac(tfm_cmac, x, m, sizeof(m), tmp);
 334         if (err)
 335                 return err;
 336
 337         *val = get_unaligned_le32(tmp);
 338         *val %= 1000000;
 339
 340         SMP_DBG("val %06u", *val);
 341
 342         return 0;
 343 }
 344
 345 static int smp_h6(struct crypto_shash *tfm_cmac, const u8 w[16],
 346                   const u8 key_id[4], u8 res[16])
 347 {
 348         int err;
 349
 350         SMP_DBG("w %16phN key_id %4phN", w, key_id);
 351
 352         err = aes_cmac(tfm_cmac, w, key_id, 4, res);
 353         if (err)
 354                 return err;
 355
 356         SMP_DBG("res %16phN", res);
 357
 358         return err;
 359 }
 360
 361 static int smp_h7(struct crypto_shash *tfm_cmac, const u8 w[16],
 362                   const u8 salt[16], u8 res[16])
 363 {
 364         int err;
 365
 366         SMP_DBG("w %16phN salt %16phN", w, salt);
 367
 368         err = aes_cmac(tfm_cmac, salt, w, 16, res);
 369         if (err)
 370                 return err;
 371
 372         SMP_DBG("res %16phN", res);
 373
 374         return err;
 375 }
 376
 377 /* The following functions map to the legacy SMP crypto functions e, c1,
 378  * s1 and ah.
 379  */
 380
 381 static int smp_e(struct crypto_cipher *tfm, const u8 *k, u8 *r)
 382 {
 383         uint8_t tmp[16], data[16];
 384         int err;
 385
 386         SMP_DBG("k %16phN r %16phN", k, r);
 387
 388         if (!tfm) {
 389                 BT_ERR("tfm %p", tfm);
 390                 return -EINVAL;
 391         }
 392
 393         /* The most significant octet of key corresponds to k[0] */
 394         swap_buf(k, tmp, 16);
 395
 396         err = crypto_cipher_setkey(tfm, tmp, 16);
 397         if (err) {
 398                 BT_ERR("cipher setkey failed: %d", err);
 399                 return err;
 400         }
 401
 402         /* Most significant octet of plaintextData corresponds to data[0] */
 403         swap_buf(r, data, 16);
 404
 405         crypto_cipher_encrypt_one(tfm, data, data);
 406
 407         /* Most significant octet of encryptedData corresponds to data[0] */
 408         swap_buf(data, r, 16);
 409
 410         SMP_DBG("r %16phN", r);
 411
 412         return err;
 413 }
 414
 415 static int smp_c1(struct crypto_cipher *tfm_aes, const u8 k[16],
 416                   const u8 r[16], const u8 preq[7], const u8 pres[7], u8 _iat,
 417                   const bdaddr_t *ia, u8 _rat, const bdaddr_t *ra, u8 res[16])
 418 {
 419         u8 p1[16], p2[16];
 420         int err;
 421
 422         SMP_DBG("k %16phN r %16phN", k, r);
 423         SMP_DBG("iat %u ia %6phN rat %u ra %6phN", _iat, ia, _rat, ra);
 424         SMP_DBG("preq %7phN pres %7phN", preq, pres);
 425
 426         memset(p1, 0, 16);
 427
 428         /* p1 = pres || preq || _rat || _iat */
 429         p1[0] = _iat;
 430         p1[1] = _rat;
 431         memcpy(p1 + 2, preq, 7);
 432         memcpy(p1 + 9, pres, 7);
 433
 434         SMP_DBG("p1 %16phN", p1);
 435
 436         /* res = r XOR p1 */
 437         u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
 438
 439         /* res = e(k, res) */
 440         err = smp_e(tfm_aes, k, res);
 441         if (err) {
 442                 BT_ERR("Encrypt data error");
 443                 return err;
 444         }
 445
 446         /* p2 = padding || ia || ra */
 447         memcpy(p2, ra, 6);
 448         memcpy(p2 + 6, ia, 6);
 449         memset(p2 + 12, 0, 4);
 450
 451         SMP_DBG("p2 %16phN", p2);
 452
 453         /* res = res XOR p2 */
 454         u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
 455
 456         /* res = e(k, res) */
 457         err = smp_e(tfm_aes, k, res);
 458         if (err)
 459                 BT_ERR("Encrypt data error");
 460
 461         return err;
 462 }
 463
 464 static int smp_s1(struct crypto_cipher *tfm_aes, const u8 k[16],
 465                   const u8 r1[16], const u8 r2[16], u8 _r[16])
 466 {
 467         int err;
 468
 469         /* Just least significant octets from r1 and r2 are considered */
 470         memcpy(_r, r2, 8);
 471         memcpy(_r + 8, r1, 8);
 472
 473         err = smp_e(tfm_aes, k, _r);
 474         if (err)
 475                 BT_ERR("Encrypt data error");
 476
 477         return err;
 478 }
 479
 480 static int smp_ah(struct crypto_cipher *tfm, const u8 irk[16],
 481                   const u8 r[3], u8 res[3])
 482 {
 483         u8 _res[16];
 484         int err;
 485
 486         /* r' = padding || r */
 487         memcpy(_res, r, 3);
 488         memset(_res + 3, 0, 13);
 489
 490         err = smp_e(tfm, irk, _res);
 491         if (err) {
 492                 BT_ERR("Encrypt error");
 493                 return err;
 494         }
 495
 496         /* The output of the random address function ah is:
 497          *      ah(k, r) = e(k, r') mod 2^24
 498          * The output of the security function e is then truncated to 24 bits
 499          * by taking the least significant 24 bits of the output of e as the
 500          * result of ah.
 501          */
 502         memcpy(res, _res, 3);
 503
 504         return 0;
 505 }
 506
 507 bool smp_irk_matches(struct hci_dev *hdev, const u8 irk[16],
 508                      const bdaddr_t *bdaddr)
 509 {
 510         struct l2cap_chan *chan = hdev->smp_data;
 511         struct smp_dev *smp;
 512         u8 hash[3];
 513         int err;
 514
 515         if (!chan || !chan->data)
 516                 return false;
 517
 518         smp = chan->data;
 519
 520         BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);
 521
 522         err = smp_ah(smp->tfm_aes, irk, &bdaddr->b[3], hash);
 523         if (err)
 524                 return false;
 525
 526         return !crypto_memneq(bdaddr->b, hash, 3);
 527 }
 528
 529 int smp_generate_rpa(struct hci_dev *hdev, const u8 irk[16], bdaddr_t *rpa)
 530 {
 531         struct l2cap_chan *chan = hdev->smp_data;
 532         struct smp_dev *smp;
 533         int err;
 534
 535         if (!chan || !chan->data)
 536                 return -EOPNOTSUPP;
 537
 538         smp = chan->data;
 539
 540         get_random_bytes(&rpa->b[3], 3);
 541
 542         rpa->b[5] &= 0x3f;      /* Clear two most significant bits */
 543         rpa->b[5] |= 0x40;      /* Set second most significant bit */
 544
 545         err = smp_ah(smp->tfm_aes, irk, &rpa->b[3], rpa->b);
 546         if (err < 0)
 547                 return err;
 548
 549         BT_DBG("RPA %pMR", rpa);
 550
 551         return 0;
 552 }
 553
 554 int smp_generate_oob(struct hci_dev *hdev, u8 hash[16], u8 rand[16])
 555 {
 556         struct l2cap_chan *chan = hdev->smp_data;
 557         struct smp_dev *smp;
 558         int err;
 559
 560         if (!chan || !chan->data)
 561                 return -EOPNOTSUPP;
 562
 563         smp = chan->data;
 564
 565         if (hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS)) {
 566                 BT_DBG("Using debug keys");
 567                 err = set_ecdh_privkey(smp->tfm_ecdh, debug_sk);
 568                 if (err)
 569                         return err;
 570                 memcpy(smp->local_pk, debug_pk, 64);
 571                 smp->debug_key = true;
 572         } else {
 573                 while (true) {
 574                         /* Generate key pair for Secure Connections */
 575                         err = generate_ecdh_keys(smp->tfm_ecdh, smp->local_pk);
 576                         if (err)
 577                                 return err;
 578
 579                         /* This is unlikely, but we need to check that
 580                          * we didn't accidentially generate a debug key.
 581                          */
 582                         if (crypto_memneq(smp->local_pk, debug_pk, 64))
 583                                 break;
 584                 }
 585                 smp->debug_key = false;
 586         }
 587
 588         SMP_DBG("OOB Public Key X: %32phN", smp->local_pk);
 589         SMP_DBG("OOB Public Key Y: %32phN", smp->local_pk + 32);
 590
 591         get_random_bytes(smp->local_rand, 16);
 592
 593         err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->local_pk,
 594                      smp->local_rand, 0, hash);
 595         if (err < 0)
 596                 return err;
 597
 598         memcpy(rand, smp->local_rand, 16);
 599
 600         smp->local_oob = true;
 601
 602         return 0;
 603 }
 604
 605 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
 606 {
 607         struct l2cap_chan *chan = conn->smp;
 608         struct smp_chan *smp;
 609         struct kvec iv[2];
 610         struct msghdr msg;
 611
 612         if (!chan)
 613                 return;
 614
 615         BT_DBG("code 0x%2.2x", code);
 616
 617         iv[0].iov_base = &code;
 618         iv[0].iov_len = 1;
 619
 620         iv[1].iov_base = data;
 621         iv[1].iov_len = len;
 622
 623         memset(&msg, 0, sizeof(msg));
 624
 625         iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iv, 2, 1 + len);
 626
 627         l2cap_chan_send(chan, &msg, 1 + len);
 628
 629         if (!chan->data)
 630                 return;
 631
 632         smp = chan->data;
 633
 634         cancel_delayed_work_sync(&smp->security_timer);
 635         schedule_delayed_work(&smp->security_timer, SMP_TIMEOUT);
 636 }
 637
 638 static u8 authreq_to_seclevel(u8 authreq)
 639 {
 640         if (authreq & SMP_AUTH_MITM) {
 641                 if (authreq & SMP_AUTH_SC)
 642                         return BT_SECURITY_FIPS;
 643                 else
 644                         return BT_SECURITY_HIGH;
 645         } else {
 646                 return BT_SECURITY_MEDIUM;
 647         }
 648 }
 649
 650 static __u8 seclevel_to_authreq(__u8 sec_level)
 651 {
 652         switch (sec_level) {
 653         case BT_SECURITY_FIPS:
 654         case BT_SECURITY_HIGH:
 655                 return SMP_AUTH_MITM | SMP_AUTH_BONDING;
 656         case BT_SECURITY_MEDIUM:
 657                 return SMP_AUTH_BONDING;
 658         default:
 659                 return SMP_AUTH_NONE;
 660         }
 661 }
 662
 663 static void build_pairing_cmd(struct l2cap_conn *conn,
 664                               struct smp_cmd_pairing *req,
 665                               struct smp_cmd_pairing *rsp, __u8 authreq)
 666 {
 667         struct l2cap_chan *chan = conn->smp;
 668         struct smp_chan *smp = chan->data;
 669         struct hci_conn *hcon = conn->hcon;
 670         struct hci_dev *hdev = hcon->hdev;
 671         u8 local_dist = 0, remote_dist = 0, oob_flag = SMP_OOB_NOT_PRESENT;
 672
 673         if (hci_dev_test_flag(hdev, HCI_BONDABLE)) {
 674                 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
 675                 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
 676                 authreq |= SMP_AUTH_BONDING;
 677         } else {
 678                 authreq &= ~SMP_AUTH_BONDING;
 679         }
 680
 681         if (hci_dev_test_flag(hdev, HCI_RPA_RESOLVING))
 682                 remote_dist |= SMP_DIST_ID_KEY;
 683
 684         if (hci_dev_test_flag(hdev, HCI_PRIVACY))
 685                 local_dist |= SMP_DIST_ID_KEY;
 686
 687         if (hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
 688             (authreq & SMP_AUTH_SC)) {
 689                 struct oob_data *oob_data;
 690                 u8 bdaddr_type;
 691
 692                 if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) {
 693                         local_dist |= SMP_DIST_LINK_KEY;
 694                         remote_dist |= SMP_DIST_LINK_KEY;
 695                 }
 696
 697                 if (hcon->dst_type == ADDR_LE_DEV_PUBLIC)
 698                         bdaddr_type = BDADDR_LE_PUBLIC;
 699                 else
 700                         bdaddr_type = BDADDR_LE_RANDOM;
 701
 702                 oob_data = hci_find_remote_oob_data(hdev, &hcon->dst,
 703                                                     bdaddr_type);
 704                 if (oob_data && oob_data->present) {
 705                         set_bit(SMP_FLAG_REMOTE_OOB, &smp->flags);
 706                         oob_flag = SMP_OOB_PRESENT;
 707                         memcpy(smp->rr, oob_data->rand256, 16);
 708                         memcpy(smp->pcnf, oob_data->hash256, 16);
 709                         SMP_DBG("OOB Remote Confirmation: %16phN", smp->pcnf);
 710                         SMP_DBG("OOB Remote Random: %16phN", smp->rr);
 711                 }
 712
 713         } else {
 714                 authreq &= ~SMP_AUTH_SC;
 715         }
 716
 717         if (rsp == NULL) {
 718                 req->io_capability = conn->hcon->io_capability;
 719                 req->oob_flag = oob_flag;
 720                 req->max_key_size = hdev->le_max_key_size;
 721                 req->init_key_dist = local_dist;
 722                 req->resp_key_dist = remote_dist;
 723                 req->auth_req = (authreq & AUTH_REQ_MASK(hdev));
 724
 725                 smp->remote_key_dist = remote_dist;
 726                 return;
 727         }
 728
 729         rsp->io_capability = conn->hcon->io_capability;
 730         rsp->oob_flag = oob_flag;
 731         rsp->max_key_size = hdev->le_max_key_size;
 732         rsp->init_key_dist = req->init_key_dist & remote_dist;
 733         rsp->resp_key_dist = req->resp_key_dist & local_dist;
 734         rsp->auth_req = (authreq & AUTH_REQ_MASK(hdev));
 735
 736         smp->remote_key_dist = rsp->init_key_dist;
 737 }
 738
 739 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
 740 {
 741         struct l2cap_chan *chan = conn->smp;
 742         struct hci_dev *hdev = conn->hcon->hdev;
 743         struct smp_chan *smp = chan->data;
 744
 745         if (max_key_size > hdev->le_max_key_size ||
 746             max_key_size < SMP_MIN_ENC_KEY_SIZE)
 747                 return SMP_ENC_KEY_SIZE;
 748
 749         smp->enc_key_size = max_key_size;
 750
 751         return 0;
 752 }
 753
 754 static void smp_chan_destroy(struct l2cap_conn *conn)
 755 {
 756         struct l2cap_chan *chan = conn->smp;
 757         struct smp_chan *smp = chan->data;
 758         struct hci_conn *hcon = conn->hcon;
 759         bool complete;
 760
 761         BUG_ON(!smp);
 762
 763         cancel_delayed_work_sync(&smp->security_timer);
 764
 765         complete = test_bit(SMP_FLAG_COMPLETE, &smp->flags);
 766         mgmt_smp_complete(hcon, complete);
 767
 768         kzfree(smp->csrk);
 769         kzfree(smp->slave_csrk);
 770         kzfree(smp->link_key);
 771
 772         crypto_free_cipher(smp->tfm_aes);
 773         crypto_free_shash(smp->tfm_cmac);
 774         crypto_free_kpp(smp->tfm_ecdh);
 775
 776         /* Ensure that we don't leave any debug key around if debug key
 777          * support hasn't been explicitly enabled.
 778          */
 779         if (smp->ltk && smp->ltk->type == SMP_LTK_P256_DEBUG &&
 780             !hci_dev_test_flag(hcon->hdev, HCI_KEEP_DEBUG_KEYS)) {
 781                 list_del_rcu(&smp->ltk->list);
 782                 kfree_rcu(smp->ltk, rcu);
 783                 smp->ltk = NULL;
 784         }
 785
 786         /* If pairing failed clean up any keys we might have */
 787         if (!complete) {
 788                 if (smp->ltk) {
 789                         list_del_rcu(&smp->ltk->list);
 790                         kfree_rcu(smp->ltk, rcu);
 791                 }
 792
 793                 if (smp->slave_ltk) {
 794                         list_del_rcu(&smp->slave_ltk->list);
 795                         kfree_rcu(smp->slave_ltk, rcu);
 796                 }
 797
 798                 if (smp->remote_irk) {
 799                         list_del_rcu(&smp->remote_irk->list);
 800                         kfree_rcu(smp->remote_irk, rcu);
 801                 }
 802         }
 803
 804         chan->data = NULL;
 805         kzfree(smp);
 806         hci_conn_drop(hcon);
 807 }
 808
 809 static void smp_failure(struct l2cap_conn *conn, u8 reason)
 810 {
 811         struct hci_conn *hcon = conn->hcon;
 812         struct l2cap_chan *chan = conn->smp;
 813
 814         if (reason)
 815                 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
 816                              &reason);
 817
 818         mgmt_auth_failed(hcon, HCI_ERROR_AUTH_FAILURE);
 819
 820         if (chan->data)
 821                 smp_chan_destroy(conn);
 822 }
 823
 824 #define JUST_WORKS      0x00
 825 #define JUST_CFM        0x01
 826 #define REQ_PASSKEY     0x02
 827 #define CFM_PASSKEY     0x03
 828 #define REQ_OOB         0x04
 829 #define DSP_PASSKEY     0x05
 830 #define OVERLAP         0xFF
 831
 832 static const u8 gen_method[5][5] = {
 833         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 834         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 835         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 836         { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
 837         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP     },
 838 };
 839
 840 static const u8 sc_method[5][5] = {
 841         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 842         { JUST_WORKS,  CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 843         { DSP_PASSKEY, DSP_PASSKEY, REQ_PASSKEY, JUST_WORKS, DSP_PASSKEY },
 844         { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
 845         { DSP_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 846 };
 847
 848 static u8 get_auth_method(struct smp_chan *smp, u8 local_io, u8 remote_io)
 849 {
 850         /* If either side has unknown io_caps, use JUST_CFM (which gets
 851          * converted later to JUST_WORKS if we're initiators.
 852          */
 853         if (local_io > SMP_IO_KEYBOARD_DISPLAY ||
 854             remote_io > SMP_IO_KEYBOARD_DISPLAY)
 855                 return JUST_CFM;
 856
 857         if (test_bit(SMP_FLAG_SC, &smp->flags))
 858                 return sc_method[remote_io][local_io];
 859
 860         return gen_method[remote_io][local_io];
 861 }
 862
 863 static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
 864                                                 u8 local_io, u8 remote_io)
 865 {
 866         struct hci_conn *hcon = conn->hcon;
 867         struct l2cap_chan *chan = conn->smp;
 868         struct smp_chan *smp = chan->data;
 869         u32 passkey = 0;
 870         int ret = 0;
 871
 872         /* Initialize key for JUST WORKS */
 873         memset(smp->tk, 0, sizeof(smp->tk));
 874         clear_bit(SMP_FLAG_TK_VALID, &smp->flags);
 875
 876         BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
 877
 878         /* If neither side wants MITM, either "just" confirm an incoming
 879          * request or use just-works for outgoing ones. The JUST_CFM
 880          * will be converted to JUST_WORKS if necessary later in this
 881          * function. If either side has MITM look up the method from the
 882          * table.
 883          */
 884         if (!(auth & SMP_AUTH_MITM))
 885                 smp->method = JUST_CFM;
 886         else
 887                 smp->method = get_auth_method(smp, local_io, remote_io);
 888
 889         /* Don't confirm locally initiated pairing attempts */
 890         if (smp->method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR,
 891                                                 &smp->flags))
 892                 smp->method = JUST_WORKS;
 893
 894         /* Don't bother user space with no IO capabilities */
 895         if (smp->method == JUST_CFM &&
 896             hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
 897                 smp->method = JUST_WORKS;
 898
 899         /* If Just Works, Continue with Zero TK */
 900         if (smp->method == JUST_WORKS) {
 901                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
 902                 return 0;
 903         }
 904
 905         /* If this function is used for SC -> legacy fallback we
 906          * can only recover the just-works case.
 907          */
 908         if (test_bit(SMP_FLAG_SC, &smp->flags))
 909                 return -EINVAL;
 910
 911         /* Not Just Works/Confirm results in MITM Authentication */
 912         if (smp->method != JUST_CFM) {
 913                 set_bit(SMP_FLAG_MITM_AUTH, &smp->flags);
 914                 if (hcon->pending_sec_level < BT_SECURITY_HIGH)
 915                         hcon->pending_sec_level = BT_SECURITY_HIGH;
 916         }
 917
 918         /* If both devices have Keyoard-Display I/O, the master
 919          * Confirms and the slave Enters the passkey.
 920          */
 921         if (smp->method == OVERLAP) {
 922                 if (hcon->role == HCI_ROLE_MASTER)
 923                         smp->method = CFM_PASSKEY;
 924                 else
 925                         smp->method = REQ_PASSKEY;
 926         }
 927
 928         /* Generate random passkey. */
 929         if (smp->method == CFM_PASSKEY) {
 930                 memset(smp->tk, 0, sizeof(smp->tk));
 931                 get_random_bytes(&passkey, sizeof(passkey));
 932                 passkey %= 1000000;
 933                 put_unaligned_le32(passkey, smp->tk);
 934                 BT_DBG("PassKey: %d", passkey);
 935                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
 936         }
 937
 938         if (smp->method == REQ_PASSKEY)
 939                 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
 940                                                 hcon->type, hcon->dst_type);
 941         else if (smp->method == JUST_CFM)
 942                 ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
 943                                                 hcon->type, hcon->dst_type,
 944                                                 passkey, 1);
 945         else
 946                 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
 947                                                 hcon->type, hcon->dst_type,
 948                                                 passkey, 0);
 949
 950         return ret;
 951 }
 952
 953 static u8 smp_confirm(struct smp_chan *smp)
 954 {
 955         struct l2cap_conn *conn = smp->conn;
 956         struct smp_cmd_pairing_confirm cp;
 957         int ret;
 958
 959         BT_DBG("conn %p", conn);
 960
 961         ret = smp_c1(smp->tfm_aes, smp->tk, smp->prnd, smp->preq, smp->prsp,
 962                      conn->hcon->init_addr_type, &conn->hcon->init_addr,
 963                      conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
 964                      cp.confirm_val);
 965         if (ret)
 966                 return SMP_UNSPECIFIED;
 967
 968         clear_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
 969
 970         smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
 971
 972         if (conn->hcon->out)
 973                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
 974         else
 975                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
 976
 977         return 0;
 978 }
 979
 980 static u8 smp_random(struct smp_chan *smp)
 981 {
 982         struct l2cap_conn *conn = smp->conn;
 983         struct hci_conn *hcon = conn->hcon;
 984         u8 confirm[16];
 985         int ret;
 986
 987         if (IS_ERR_OR_NULL(smp->tfm_aes))
 988                 return SMP_UNSPECIFIED;
 989
 990         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 991
 992         ret = smp_c1(smp->tfm_aes, smp->tk, smp->rrnd, smp->preq, smp->prsp,
 993                      hcon->init_addr_type, &hcon->init_addr,
 994                      hcon->resp_addr_type, &hcon->resp_addr, confirm);
 995         if (ret)
 996                 return SMP_UNSPECIFIED;
 997
 998         if (crypto_memneq(smp->pcnf, confirm, sizeof(smp->pcnf))) {
 999                 bt_dev_err(hcon->hdev, "pairing failed "
1000                            "(confirmation values mismatch)");
1001                 return SMP_CONFIRM_FAILED;
1002         }
1003
1004         if (hcon->out) {
1005                 u8 stk[16];
1006                 __le64 rand = 0;
1007                 __le16 ediv = 0;
1008
1009                 smp_s1(smp->tfm_aes, smp->tk, smp->rrnd, smp->prnd, stk);
1010
1011                 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
1012                         return SMP_UNSPECIFIED;
1013
1014                 hci_le_start_enc(hcon, ediv, rand, stk, smp->enc_key_size);
1015                 hcon->enc_key_size = smp->enc_key_size;
1016                 set_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
1017         } else {
1018                 u8 stk[16], auth;
1019                 __le64 rand = 0;
1020                 __le16 ediv = 0;
1021
1022                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1023                              smp->prnd);
1024
1025                 smp_s1(smp->tfm_aes, smp->tk, smp->prnd, smp->rrnd, stk);
1026
1027                 if (hcon->pending_sec_level == BT_SECURITY_HIGH)
1028                         auth = 1;
1029                 else
1030                         auth = 0;
1031
1032                 /* Even though there's no _SLAVE suffix this is the
1033                  * slave STK we're adding for later lookup (the master
1034                  * STK never needs to be stored).
1035                  */
1036                 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
1037                             SMP_STK, auth, stk, smp->enc_key_size, ediv, rand);
1038         }
1039
1040         return 0;
1041 }
1042
1043 static void smp_notify_keys(struct l2cap_conn *conn)
1044 {
1045         struct l2cap_chan *chan = conn->smp;
1046         struct smp_chan *smp = chan->data;
1047         struct hci_conn *hcon = conn->hcon;
1048         struct hci_dev *hdev = hcon->hdev;
1049         struct smp_cmd_pairing *req = (void *) &smp->preq[1];
1050         struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
1051         bool persistent;
1052
1053         if (hcon->type == ACL_LINK) {
1054                 if (hcon->key_type == HCI_LK_DEBUG_COMBINATION)
1055                         persistent = false;
1056                 else
1057                         persistent = !test_bit(HCI_CONN_FLUSH_KEY,
1058                                                &hcon->flags);
1059         } else {
1060                 /* The LTKs, IRKs and CSRKs should be persistent only if
1061                  * both sides had the bonding bit set in their
1062                  * authentication requests.
1063                  */
1064                 persistent = !!((req->auth_req & rsp->auth_req) &
1065                                 SMP_AUTH_BONDING);
1066         }
1067
1068         if (smp->remote_irk) {
1069                 mgmt_new_irk(hdev, smp->remote_irk, persistent);
1070
1071                 /* Now that user space can be considered to know the
1072                  * identity address track the connection based on it
1073                  * from now on (assuming this is an LE link).
1074                  */
1075                 if (hcon->type == LE_LINK) {
1076                         bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
1077                         hcon->dst_type = smp->remote_irk->addr_type;
1078                         queue_work(hdev->workqueue, &conn->id_addr_update_work);
1079                 }
1080         }
1081
1082         if (smp->csrk) {
1083                 smp->csrk->bdaddr_type = hcon->dst_type;
1084                 bacpy(&smp->csrk->bdaddr, &hcon->dst);
1085                 mgmt_new_csrk(hdev, smp->csrk, persistent);
1086         }
1087
1088         if (smp->slave_csrk) {
1089                 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1090                 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
1091                 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
1092         }
1093
1094         if (smp->ltk) {
1095                 smp->ltk->bdaddr_type = hcon->dst_type;
1096                 bacpy(&smp->ltk->bdaddr, &hcon->dst);
1097                 mgmt_new_ltk(hdev, smp->ltk, persistent);
1098         }
1099
1100         if (smp->slave_ltk) {
1101                 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1102                 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
1103                 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
1104         }
1105
1106         if (smp->link_key) {
1107                 struct link_key *key;
1108                 u8 type;
1109
1110                 if (test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags))
1111                         type = HCI_LK_DEBUG_COMBINATION;
1112                 else if (hcon->sec_level == BT_SECURITY_FIPS)
1113                         type = HCI_LK_AUTH_COMBINATION_P256;
1114                 else
1115                         type = HCI_LK_UNAUTH_COMBINATION_P256;
1116
1117                 key = hci_add_link_key(hdev, smp->conn->hcon, &hcon->dst,
1118                                        smp->link_key, type, 0, &persistent);
1119                 if (key) {
1120                         mgmt_new_link_key(hdev, key, persistent);
1121
1122                         /* Don't keep debug keys around if the relevant
1123                          * flag is not set.
1124                          */
1125                         if (!hci_dev_test_flag(hdev, HCI_KEEP_DEBUG_KEYS) &&
1126                             key->type == HCI_LK_DEBUG_COMBINATION) {
1127                                 list_del_rcu(&key->list);
1128                                 kfree_rcu(key, rcu);
1129                         }
1130                 }
1131         }
1132 }
1133
1134 static void sc_add_ltk(struct smp_chan *smp)
1135 {
1136         struct hci_conn *hcon = smp->conn->hcon;
1137         u8 key_type, auth;
1138
1139         if (test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags))
1140                 key_type = SMP_LTK_P256_DEBUG;
1141         else
1142                 key_type = SMP_LTK_P256;
1143
1144         if (hcon->pending_sec_level == BT_SECURITY_FIPS)
1145                 auth = 1;
1146         else
1147                 auth = 0;
1148
1149         smp->ltk = hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
1150                                key_type, auth, smp->tk, smp->enc_key_size,
1151                                0, 0);
1152 }
1153
1154 static void sc_generate_link_key(struct smp_chan *smp)
1155 {
1156         /* From core spec. Spells out in ASCII as 'lebr'. */
1157         const u8 lebr[4] = { 0x72, 0x62, 0x65, 0x6c };
1158
1159         smp->link_key = kzalloc(16, GFP_KERNEL);
1160         if (!smp->link_key)
1161                 return;
1162
1163         if (test_bit(SMP_FLAG_CT2, &smp->flags)) {
1164                 /* SALT = 0x00000000000000000000000000000000746D7031 */
1165                 const u8 salt[16] = { 0x31, 0x70, 0x6d, 0x74 };
1166
1167                 if (smp_h7(smp->tfm_cmac, smp->tk, salt, smp->link_key)) {
1168                         kzfree(smp->link_key);
1169                         smp->link_key = NULL;
1170                         return;
1171                 }
1172         } else {
1173                 /* From core spec. Spells out in ASCII as 'tmp1'. */
1174                 const u8 tmp1[4] = { 0x31, 0x70, 0x6d, 0x74 };
1175
1176                 if (smp_h6(smp->tfm_cmac, smp->tk, tmp1, smp->link_key)) {
1177                         kzfree(smp->link_key);
1178                         smp->link_key = NULL;
1179                         return;
1180                 }
1181         }
1182
1183         if (smp_h6(smp->tfm_cmac, smp->link_key, lebr, smp->link_key)) {
1184                 kzfree(smp->link_key);
1185                 smp->link_key = NULL;
1186                 return;
1187         }
1188 }
1189
1190 static void smp_allow_key_dist(struct smp_chan *smp)
1191 {
1192         /* Allow the first expected phase 3 PDU. The rest of the PDUs
1193          * will be allowed in each PDU handler to ensure we receive
1194          * them in the correct order.
1195          */
1196         if (smp->remote_key_dist & SMP_DIST_ENC_KEY)
1197                 SMP_ALLOW_CMD(smp, SMP_CMD_ENCRYPT_INFO);
1198         else if (smp->remote_key_dist & SMP_DIST_ID_KEY)
1199                 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
1200         else if (smp->remote_key_dist & SMP_DIST_SIGN)
1201                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
1202 }
1203
1204 static void sc_generate_ltk(struct smp_chan *smp)
1205 {
1206         /* From core spec. Spells out in ASCII as 'brle'. */
1207         const u8 brle[4] = { 0x65, 0x6c, 0x72, 0x62 };
1208         struct hci_conn *hcon = smp->conn->hcon;
1209         struct hci_dev *hdev = hcon->hdev;
1210         struct link_key *key;
1211
1212         key = hci_find_link_key(hdev, &hcon->dst);
1213         if (!key) {
1214                 bt_dev_err(hdev, "no Link Key found to generate LTK");
1215                 return;
1216         }
1217
1218         if (key->type == HCI_LK_DEBUG_COMBINATION)
1219                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1220
1221         if (test_bit(SMP_FLAG_CT2, &smp->flags)) {
1222                 /* SALT = 0x00000000000000000000000000000000746D7032 */
1223                 const u8 salt[16] = { 0x32, 0x70, 0x6d, 0x74 };
1224
1225                 if (smp_h7(smp->tfm_cmac, key->val, salt, smp->tk))
1226                         return;
1227         } else {
1228                 /* From core spec. Spells out in ASCII as 'tmp2'. */
1229                 const u8 tmp2[4] = { 0x32, 0x70, 0x6d, 0x74 };
1230
1231                 if (smp_h6(smp->tfm_cmac, key->val, tmp2, smp->tk))
1232                         return;
1233         }
1234
1235         if (smp_h6(smp->tfm_cmac, smp->tk, brle, smp->tk))
1236                 return;
1237
1238         sc_add_ltk(smp);
1239 }
1240
1241 static void smp_distribute_keys(struct smp_chan *smp)
1242 {
1243         struct smp_cmd_pairing *req, *rsp;
1244         struct l2cap_conn *conn = smp->conn;
1245         struct hci_conn *hcon = conn->hcon;
1246         struct hci_dev *hdev = hcon->hdev;
1247         __u8 *keydist;
1248
1249         BT_DBG("conn %p", conn);
1250
1251         rsp = (void *) &smp->prsp[1];
1252
1253         /* The responder sends its keys first */
1254         if (hcon->out && (smp->remote_key_dist & KEY_DIST_MASK)) {
1255                 smp_allow_key_dist(smp);
1256                 return;
1257         }
1258
1259         req = (void *) &smp->preq[1];
1260
1261         if (hcon->out) {
1262                 keydist = &rsp->init_key_dist;
1263                 *keydist &= req->init_key_dist;
1264         } else {
1265                 keydist = &rsp->resp_key_dist;
1266                 *keydist &= req->resp_key_dist;
1267         }
1268
1269         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1270                 if (hcon->type == LE_LINK && (*keydist & SMP_DIST_LINK_KEY))
1271                         sc_generate_link_key(smp);
1272                 if (hcon->type == ACL_LINK && (*keydist & SMP_DIST_ENC_KEY))
1273                         sc_generate_ltk(smp);
1274
1275                 /* Clear the keys which are generated but not distributed */
1276                 *keydist &= ~SMP_SC_NO_DIST;
1277         }
1278
1279         BT_DBG("keydist 0x%x", *keydist);
1280
1281         if (*keydist & SMP_DIST_ENC_KEY) {
1282                 struct smp_cmd_encrypt_info enc;
1283                 struct smp_cmd_master_ident ident;
1284                 struct smp_ltk *ltk;
1285                 u8 authenticated;
1286                 __le16 ediv;
1287                 __le64 rand;
1288
1289                 /* Make sure we generate only the significant amount of
1290                  * bytes based on the encryption key size, and set the rest
1291                  * of the value to zeroes.
1292                  */
1293                 get_random_bytes(enc.ltk, smp->enc_key_size);
1294                 memset(enc.ltk + smp->enc_key_size, 0,
1295                        sizeof(enc.ltk) - smp->enc_key_size);
1296
1297                 get_random_bytes(&ediv, sizeof(ediv));
1298                 get_random_bytes(&rand, sizeof(rand));
1299
1300                 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1301
1302                 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
1303                 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
1304                                   SMP_LTK_SLAVE, authenticated, enc.ltk,
1305                                   smp->enc_key_size, ediv, rand);
1306                 smp->slave_ltk = ltk;
1307
1308                 ident.ediv = ediv;
1309                 ident.rand = rand;
1310
1311                 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1312
1313                 *keydist &= ~SMP_DIST_ENC_KEY;
1314         }
1315
1316         if (*keydist & SMP_DIST_ID_KEY) {
1317                 struct smp_cmd_ident_addr_info addrinfo;
1318                 struct smp_cmd_ident_info idinfo;
1319
1320                 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
1321
1322                 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1323
1324                 /* The hci_conn contains the local identity address
1325                  * after the connection has been established.
1326                  *
1327                  * This is true even when the connection has been
1328                  * established using a resolvable random address.
1329                  */
1330                 bacpy(&addrinfo.bdaddr, &hcon->src);
1331                 addrinfo.addr_type = hcon->src_type;
1332
1333                 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1334                              &addrinfo);
1335
1336                 *keydist &= ~SMP_DIST_ID_KEY;
1337         }
1338
1339         if (*keydist & SMP_DIST_SIGN) {
1340                 struct smp_cmd_sign_info sign;
1341                 struct smp_csrk *csrk;
1342
1343                 /* Generate a new random key */
1344                 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1345
1346                 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1347                 if (csrk) {
1348                         if (hcon->sec_level > BT_SECURITY_MEDIUM)
1349                                 csrk->type = MGMT_CSRK_LOCAL_AUTHENTICATED;
1350                         else
1351                                 csrk->type = MGMT_CSRK_LOCAL_UNAUTHENTICATED;
1352                         memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1353                 }
1354                 smp->slave_csrk = csrk;
1355
1356                 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1357
1358                 *keydist &= ~SMP_DIST_SIGN;
1359         }
1360
1361         /* If there are still keys to be received wait for them */
1362         if (smp->remote_key_dist & KEY_DIST_MASK) {
1363                 smp_allow_key_dist(smp);
1364                 return;
1365         }
1366
1367         set_bit(SMP_FLAG_COMPLETE, &smp->flags);
1368         smp_notify_keys(conn);
1369
1370         smp_chan_destroy(conn);
1371 }
1372
1373 static void smp_timeout(struct work_struct *work)
1374 {
1375         struct smp_chan *smp = container_of(work, struct smp_chan,
1376                                             security_timer.work);
1377         struct l2cap_conn *conn = smp->conn;
1378
1379         BT_DBG("conn %p", conn);
1380
1381         hci_disconnect(conn->hcon, HCI_ERROR_REMOTE_USER_TERM);
1382 }
1383
1384 static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
1385 {
1386         struct l2cap_chan *chan = conn->smp;
1387         struct smp_chan *smp;
1388
1389         smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
1390         if (!smp)
1391                 return NULL;
1392
1393         smp->tfm_aes = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
1394         if (IS_ERR(smp->tfm_aes)) {
1395                 BT_ERR("Unable to create AES crypto context");
1396                 goto zfree_smp;
1397         }
1398
1399         smp->tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
1400         if (IS_ERR(smp->tfm_cmac)) {
1401                 BT_ERR("Unable to create CMAC crypto context");
1402                 goto free_cipher;
1403         }
1404
1405         smp->tfm_ecdh = crypto_alloc_kpp("ecdh", CRYPTO_ALG_INTERNAL, 0);
1406         if (IS_ERR(smp->tfm_ecdh)) {
1407                 BT_ERR("Unable to create ECDH crypto context");
1408                 goto free_shash;
1409         }
1410
1411         smp->conn = conn;
1412         chan->data = smp;
1413
1414         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_FAIL);
1415
1416         INIT_DELAYED_WORK(&smp->security_timer, smp_timeout);
1417
1418         hci_conn_hold(conn->hcon);
1419
1420         return smp;
1421
1422 free_shash:
1423         crypto_free_shash(smp->tfm_cmac);
1424 free_cipher:
1425         crypto_free_cipher(smp->tfm_aes);
1426 zfree_smp:
1427         kzfree(smp);
1428         return NULL;
1429 }
1430
1431 static int sc_mackey_and_ltk(struct smp_chan *smp, u8 mackey[16], u8 ltk[16])
1432 {
1433         struct hci_conn *hcon = smp->conn->hcon;
1434         u8 *na, *nb, a[7], b[7];
1435
1436         if (hcon->out) {
1437                 na   = smp->prnd;
1438                 nb   = smp->rrnd;
1439         } else {
1440                 na   = smp->rrnd;
1441                 nb   = smp->prnd;
1442         }
1443
1444         memcpy(a, &hcon->init_addr, 6);
1445         memcpy(b, &hcon->resp_addr, 6);
1446         a[6] = hcon->init_addr_type;
1447         b[6] = hcon->resp_addr_type;
1448
1449         return smp_f5(smp->tfm_cmac, smp->dhkey, na, nb, a, b, mackey, ltk);
1450 }
1451
1452 static void sc_dhkey_check(struct smp_chan *smp)
1453 {
1454         struct hci_conn *hcon = smp->conn->hcon;
1455         struct smp_cmd_dhkey_check check;
1456         u8 a[7], b[7], *local_addr, *remote_addr;
1457         u8 io_cap[3], r[16];
1458
1459         memcpy(a, &hcon->init_addr, 6);
1460         memcpy(b, &hcon->resp_addr, 6);
1461         a[6] = hcon->init_addr_type;
1462         b[6] = hcon->resp_addr_type;
1463
1464         if (hcon->out) {
1465                 local_addr = a;
1466                 remote_addr = b;
1467                 memcpy(io_cap, &smp->preq[1], 3);
1468         } else {
1469                 local_addr = b;
1470                 remote_addr = a;
1471                 memcpy(io_cap, &smp->prsp[1], 3);
1472         }
1473
1474         memset(r, 0, sizeof(r));
1475
1476         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1477                 put_unaligned_le32(hcon->passkey_notify, r);
1478
1479         if (smp->method == REQ_OOB)
1480                 memcpy(r, smp->rr, 16);
1481
1482         smp_f6(smp->tfm_cmac, smp->mackey, smp->prnd, smp->rrnd, r, io_cap,
1483                local_addr, remote_addr, check.e);
1484
1485         smp_send_cmd(smp->conn, SMP_CMD_DHKEY_CHECK, sizeof(check), &check);
1486 }
1487
1488 static u8 sc_passkey_send_confirm(struct smp_chan *smp)
1489 {
1490         struct l2cap_conn *conn = smp->conn;
1491         struct hci_conn *hcon = conn->hcon;
1492         struct smp_cmd_pairing_confirm cfm;
1493         u8 r;
1494
1495         r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
1496         r |= 0x80;
1497
1498         get_random_bytes(smp->prnd, sizeof(smp->prnd));
1499
1500         if (smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd, r,
1501                    cfm.confirm_val))
1502                 return SMP_UNSPECIFIED;
1503
1504         smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
1505
1506         return 0;
1507 }
1508
1509 static u8 sc_passkey_round(struct smp_chan *smp, u8 smp_op)
1510 {
1511         struct l2cap_conn *conn = smp->conn;
1512         struct hci_conn *hcon = conn->hcon;
1513         struct hci_dev *hdev = hcon->hdev;
1514         u8 cfm[16], r;
1515
1516         /* Ignore the PDU if we've already done 20 rounds (0 - 19) */
1517         if (smp->passkey_round >= 20)
1518                 return 0;
1519
1520         switch (smp_op) {
1521         case SMP_CMD_PAIRING_RANDOM:
1522                 r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
1523                 r |= 0x80;
1524
1525                 if (smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
1526                            smp->rrnd, r, cfm))
1527                         return SMP_UNSPECIFIED;
1528
1529                 if (crypto_memneq(smp->pcnf, cfm, 16))
1530                         return SMP_CONFIRM_FAILED;
1531
1532                 smp->passkey_round++;
1533
1534                 if (smp->passkey_round == 20) {
1535                         /* Generate MacKey and LTK */
1536                         if (sc_mackey_and_ltk(smp, smp->mackey, smp->tk))
1537                                 return SMP_UNSPECIFIED;
1538                 }
1539
1540                 /* The round is only complete when the initiator
1541                  * receives pairing random.
1542                  */
1543                 if (!hcon->out) {
1544                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1545                                      sizeof(smp->prnd), smp->prnd);
1546                         if (smp->passkey_round == 20)
1547                                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1548                         else
1549                                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1550                         return 0;
1551                 }
1552
1553                 /* Start the next round */
1554                 if (smp->passkey_round != 20)
1555                         return sc_passkey_round(smp, 0);
1556
1557                 /* Passkey rounds are complete - start DHKey Check */
1558                 sc_dhkey_check(smp);
1559                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1560
1561                 break;
1562
1563         case SMP_CMD_PAIRING_CONFIRM:
1564                 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
1565                         set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
1566                         return 0;
1567                 }
1568
1569                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1570
1571                 if (hcon->out) {
1572                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1573                                      sizeof(smp->prnd), smp->prnd);
1574                         return 0;
1575                 }
1576
1577                 return sc_passkey_send_confirm(smp);
1578
1579         case SMP_CMD_PUBLIC_KEY:
1580         default:
1581                 /* Initiating device starts the round */
1582                 if (!hcon->out)
1583                         return 0;
1584
1585                 BT_DBG("%s Starting passkey round %u", hdev->name,
1586                        smp->passkey_round + 1);
1587
1588                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1589
1590                 return sc_passkey_send_confirm(smp);
1591         }
1592
1593         return 0;
1594 }
1595
1596 static int sc_user_reply(struct smp_chan *smp, u16 mgmt_op, __le32 passkey)
1597 {
1598         struct l2cap_conn *conn = smp->conn;
1599         struct hci_conn *hcon = conn->hcon;
1600         u8 smp_op;
1601
1602         clear_bit(SMP_FLAG_WAIT_USER, &smp->flags);
1603
1604         switch (mgmt_op) {
1605         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
1606                 smp_failure(smp->conn, SMP_PASSKEY_ENTRY_FAILED);
1607                 return 0;
1608         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
1609                 smp_failure(smp->conn, SMP_NUMERIC_COMP_FAILED);
1610                 return 0;
1611         case MGMT_OP_USER_PASSKEY_REPLY:
1612                 hcon->passkey_notify = le32_to_cpu(passkey);
1613                 smp->passkey_round = 0;
1614
1615                 if (test_and_clear_bit(SMP_FLAG_CFM_PENDING, &smp->flags))
1616                         smp_op = SMP_CMD_PAIRING_CONFIRM;
1617                 else
1618                         smp_op = 0;
1619
1620                 if (sc_passkey_round(smp, smp_op))
1621                         return -EIO;
1622
1623                 return 0;
1624         }
1625
1626         /* Initiator sends DHKey check first */
1627         if (hcon->out) {
1628                 sc_dhkey_check(smp);
1629                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1630         } else if (test_and_clear_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags)) {
1631                 sc_dhkey_check(smp);
1632                 sc_add_ltk(smp);
1633         }
1634
1635         return 0;
1636 }
1637
1638 int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
1639 {
1640         struct l2cap_conn *conn = hcon->l2cap_data;
1641         struct l2cap_chan *chan;
1642         struct smp_chan *smp;
1643         u32 value;
1644         int err;
1645
1646         BT_DBG("");
1647
1648         if (!conn)
1649                 return -ENOTCONN;
1650
1651         chan = conn->smp;
1652         if (!chan)
1653                 return -ENOTCONN;
1654
1655         l2cap_chan_lock(chan);
1656         if (!chan->data) {
1657                 err = -ENOTCONN;
1658                 goto unlock;
1659         }
1660
1661         smp = chan->data;
1662
1663         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1664                 err = sc_user_reply(smp, mgmt_op, passkey);
1665                 goto unlock;
1666         }
1667
1668         switch (mgmt_op) {
1669         case MGMT_OP_USER_PASSKEY_REPLY:
1670                 value = le32_to_cpu(passkey);
1671                 memset(smp->tk, 0, sizeof(smp->tk));
1672                 BT_DBG("PassKey: %d", value);
1673                 put_unaligned_le32(value, smp->tk);
1674                 /* Fall Through */
1675         case MGMT_OP_USER_CONFIRM_REPLY:
1676                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
1677                 break;
1678         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
1679         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
1680                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
1681                 err = 0;
1682                 goto unlock;
1683         default:
1684                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
1685                 err = -EOPNOTSUPP;
1686                 goto unlock;
1687         }
1688
1689         err = 0;
1690
1691         /* If it is our turn to send Pairing Confirm, do so now */
1692         if (test_bit(SMP_FLAG_CFM_PENDING, &smp->flags)) {
1693                 u8 rsp = smp_confirm(smp);
1694                 if (rsp)
1695                         smp_failure(conn, rsp);
1696         }
1697
1698 unlock:
1699         l2cap_chan_unlock(chan);
1700         return err;
1701 }
1702
1703 static void build_bredr_pairing_cmd(struct smp_chan *smp,
1704                                     struct smp_cmd_pairing *req,
1705                                     struct smp_cmd_pairing *rsp)
1706 {
1707         struct l2cap_conn *conn = smp->conn;
1708         struct hci_dev *hdev = conn->hcon->hdev;
1709         u8 local_dist = 0, remote_dist = 0;
1710
1711         if (hci_dev_test_flag(hdev, HCI_BONDABLE)) {
1712                 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
1713                 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
1714         }
1715
1716         if (hci_dev_test_flag(hdev, HCI_RPA_RESOLVING))
1717                 remote_dist |= SMP_DIST_ID_KEY;
1718
1719         if (hci_dev_test_flag(hdev, HCI_PRIVACY))
1720                 local_dist |= SMP_DIST_ID_KEY;
1721
1722         if (!rsp) {
1723                 memset(req, 0, sizeof(*req));
1724
1725                 req->auth_req        = SMP_AUTH_CT2;
1726                 req->init_key_dist   = local_dist;
1727                 req->resp_key_dist   = remote_dist;
1728                 req->max_key_size    = conn->hcon->enc_key_size;
1729
1730                 smp->remote_key_dist = remote_dist;
1731
1732                 return;
1733         }
1734
1735         memset(rsp, 0, sizeof(*rsp));
1736
1737         rsp->auth_req        = SMP_AUTH_CT2;
1738         rsp->max_key_size    = conn->hcon->enc_key_size;
1739         rsp->init_key_dist   = req->init_key_dist & remote_dist;
1740         rsp->resp_key_dist   = req->resp_key_dist & local_dist;
1741
1742         smp->remote_key_dist = rsp->init_key_dist;
1743 }
1744
1745 static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
1746 {
1747         struct smp_cmd_pairing rsp, *req = (void *) skb->data;
1748         struct l2cap_chan *chan = conn->smp;
1749         struct hci_dev *hdev = conn->hcon->hdev;
1750         struct smp_chan *smp;
1751         u8 key_size, auth, sec_level;
1752         int ret;
1753
1754         BT_DBG("conn %p", conn);
1755
1756         if (skb->len < sizeof(*req))
1757                 return SMP_INVALID_PARAMS;
1758
1759         if (conn->hcon->role != HCI_ROLE_SLAVE)
1760                 return SMP_CMD_NOTSUPP;
1761
1762         if (!chan->data)
1763                 smp = smp_chan_create(conn);
1764         else
1765                 smp = chan->data;
1766
1767         if (!smp)
1768                 return SMP_UNSPECIFIED;
1769
1770         /* We didn't start the pairing, so match remote */
1771         auth = req->auth_req & AUTH_REQ_MASK(hdev);
1772
1773         if (!hci_dev_test_flag(hdev, HCI_BONDABLE) &&
1774             (auth & SMP_AUTH_BONDING))
1775                 return SMP_PAIRING_NOTSUPP;
1776
1777         if (hci_dev_test_flag(hdev, HCI_SC_ONLY) && !(auth & SMP_AUTH_SC))
1778                 return SMP_AUTH_REQUIREMENTS;
1779
1780         smp->preq[0] = SMP_CMD_PAIRING_REQ;
1781         memcpy(&smp->preq[1], req, sizeof(*req));
1782         skb_pull(skb, sizeof(*req));
1783
1784         /* If the remote side's OOB flag is set it means it has
1785          * successfully received our local OOB data - therefore set the
1786          * flag to indicate that local OOB is in use.
1787          */
1788         if (req->oob_flag == SMP_OOB_PRESENT && SMP_DEV(hdev)->local_oob)
1789                 set_bit(SMP_FLAG_LOCAL_OOB, &smp->flags);
1790
1791         /* SMP over BR/EDR requires special treatment */
1792         if (conn->hcon->type == ACL_LINK) {
1793                 /* We must have a BR/EDR SC link */
1794                 if (!test_bit(HCI_CONN_AES_CCM, &conn->hcon->flags) &&
1795                     !hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
1796                         return SMP_CROSS_TRANSP_NOT_ALLOWED;
1797
1798                 set_bit(SMP_FLAG_SC, &smp->flags);
1799
1800                 build_bredr_pairing_cmd(smp, req, &rsp);
1801
1802                 if (req->auth_req & SMP_AUTH_CT2)
1803                         set_bit(SMP_FLAG_CT2, &smp->flags);
1804
1805                 key_size = min(req->max_key_size, rsp.max_key_size);
1806                 if (check_enc_key_size(conn, key_size))
1807                         return SMP_ENC_KEY_SIZE;
1808
1809                 /* Clear bits which are generated but not distributed */
1810                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1811
1812                 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1813                 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
1814                 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
1815
1816                 smp_distribute_keys(smp);
1817                 return 0;
1818         }
1819
1820         build_pairing_cmd(conn, req, &rsp, auth);
1821
1822         if (rsp.auth_req & SMP_AUTH_SC) {
1823                 set_bit(SMP_FLAG_SC, &smp->flags);
1824
1825                 if (rsp.auth_req & SMP_AUTH_CT2)
1826                         set_bit(SMP_FLAG_CT2, &smp->flags);
1827         }
1828
1829         if (conn->hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
1830                 sec_level = BT_SECURITY_MEDIUM;
1831         else
1832                 sec_level = authreq_to_seclevel(auth);
1833
1834         if (sec_level > conn->hcon->pending_sec_level)
1835                 conn->hcon->pending_sec_level = sec_level;
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, conn->hcon->io_capability,
1842                                          req->io_capability);
1843                 if (method == JUST_WORKS || method == JUST_CFM)
1844                         return SMP_AUTH_REQUIREMENTS;
1845         }
1846
1847         key_size = min(req->max_key_size, rsp.max_key_size);
1848         if (check_enc_key_size(conn, key_size))
1849                 return SMP_ENC_KEY_SIZE;
1850
1851         get_random_bytes(smp->prnd, sizeof(smp->prnd));
1852
1853         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1854         memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
1855
1856         smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
1857
1858         clear_bit(SMP_FLAG_INITIATOR, &smp->flags);
1859
1860         /* Strictly speaking we shouldn't allow Pairing Confirm for the
1861          * SC case, however some implementations incorrectly copy RFU auth
1862          * req bits from our security request, which may create a false
1863          * positive SC enablement.
1864          */
1865         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1866
1867         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1868                 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1869                 /* Clear bits which are generated but not distributed */
1870                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1871                 /* Wait for Public Key from Initiating Device */
1872                 return 0;
1873         }
1874
1875         /* Request setup of TK */
1876         ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
1877         if (ret)
1878                 return SMP_UNSPECIFIED;
1879
1880         return 0;
1881 }
1882
1883 static u8 sc_send_public_key(struct smp_chan *smp)
1884 {
1885         struct hci_dev *hdev = smp->conn->hcon->hdev;
1886
1887         BT_DBG("");
1888
1889         if (test_bit(SMP_FLAG_LOCAL_OOB, &smp->flags)) {
1890                 struct l2cap_chan *chan = hdev->smp_data;
1891                 struct smp_dev *smp_dev;
1892
1893                 if (!chan || !chan->data)
1894                         return SMP_UNSPECIFIED;
1895
1896                 smp_dev = chan->data;
1897
1898                 memcpy(smp->local_pk, smp_dev->local_pk, 64);
1899                 memcpy(smp->lr, smp_dev->local_rand, 16);
1900
1901                 if (smp_dev->debug_key)
1902                         set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1903
1904                 goto done;
1905         }
1906
1907         if (hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS)) {
1908                 BT_DBG("Using debug keys");
1909                 if (set_ecdh_privkey(smp->tfm_ecdh, debug_sk))
1910                         return SMP_UNSPECIFIED;
1911                 memcpy(smp->local_pk, debug_pk, 64);
1912                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1913         } else {
1914                 while (true) {
1915                         /* Generate key pair for Secure Connections */
1916                         if (generate_ecdh_keys(smp->tfm_ecdh, smp->local_pk))
1917                                 return SMP_UNSPECIFIED;
1918
1919                         /* This is unlikely, but we need to check that
1920                          * we didn't accidentially generate a debug key.
1921                          */
1922                         if (crypto_memneq(smp->local_pk, debug_pk, 64))
1923                                 break;
1924                 }
1925         }
1926
1927 done:
1928         SMP_DBG("Local Public Key X: %32phN", smp->local_pk);
1929         SMP_DBG("Local Public Key Y: %32phN", smp->local_pk + 32);
1930
1931         smp_send_cmd(smp->conn, SMP_CMD_PUBLIC_KEY, 64, smp->local_pk);
1932
1933         return 0;
1934 }
1935
1936 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
1937 {
1938         struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
1939         struct l2cap_chan *chan = conn->smp;
1940         struct smp_chan *smp = chan->data;
1941         struct hci_dev *hdev = conn->hcon->hdev;
1942         u8 key_size, auth;
1943         int ret;
1944
1945         BT_DBG("conn %p", conn);
1946
1947         if (skb->len < sizeof(*rsp))
1948                 return SMP_INVALID_PARAMS;
1949
1950         if (conn->hcon->role != HCI_ROLE_MASTER)
1951                 return SMP_CMD_NOTSUPP;
1952
1953         skb_pull(skb, sizeof(*rsp));
1954
1955         req = (void *) &smp->preq[1];
1956
1957         key_size = min(req->max_key_size, rsp->max_key_size);
1958         if (check_enc_key_size(conn, key_size))
1959                 return SMP_ENC_KEY_SIZE;
1960
1961         auth = rsp->auth_req & AUTH_REQ_MASK(hdev);
1962
1963         if (hci_dev_test_flag(hdev, HCI_SC_ONLY) && !(auth & SMP_AUTH_SC))
1964                 return SMP_AUTH_REQUIREMENTS;
1965
1966         /* If the remote side's OOB flag is set it means it has
1967          * successfully received our local OOB data - therefore set the
1968          * flag to indicate that local OOB is in use.
1969          */
1970         if (rsp->oob_flag == SMP_OOB_PRESENT && SMP_DEV(hdev)->local_oob)
1971                 set_bit(SMP_FLAG_LOCAL_OOB, &smp->flags);
1972
1973         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1974         memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
1975
1976         /* Update remote key distribution in case the remote cleared
1977          * some bits that we had enabled in our request.
1978          */
1979         smp->remote_key_dist &= rsp->resp_key_dist;
1980
1981         if ((req->auth_req & SMP_AUTH_CT2) && (auth & SMP_AUTH_CT2))
1982                 set_bit(SMP_FLAG_CT2, &smp->flags);
1983
1984         /* For BR/EDR this means we're done and can start phase 3 */
1985         if (conn->hcon->type == ACL_LINK) {
1986                 /* Clear bits which are generated but not distributed */
1987                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1988                 smp_distribute_keys(smp);
1989                 return 0;
1990         }
1991
1992         if ((req->auth_req & SMP_AUTH_SC) && (auth & SMP_AUTH_SC))
1993                 set_bit(SMP_FLAG_SC, &smp->flags);
1994         else if (conn->hcon->pending_sec_level > BT_SECURITY_HIGH)
1995                 conn->hcon->pending_sec_level = BT_SECURITY_HIGH;
1996
1997         /* If we need MITM check that it can be achieved */
1998         if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1999                 u8 method;
2000
2001                 method = get_auth_method(smp, req->io_capability,
2002                                          rsp->io_capability);
2003                 if (method == JUST_WORKS || method == JUST_CFM)
2004                         return SMP_AUTH_REQUIREMENTS;
2005         }
2006
2007         get_random_bytes(smp->prnd, sizeof(smp->prnd));
2008
2009         /* Update remote key distribution in case the remote cleared
2010          * some bits that we had enabled in our request.
2011          */
2012         smp->remote_key_dist &= rsp->resp_key_dist;
2013
2014         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
2015                 /* Clear bits which are generated but not distributed */
2016                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
2017                 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
2018                 return sc_send_public_key(smp);
2019         }
2020
2021         auth |= req->auth_req;
2022
2023         ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
2024         if (ret)
2025                 return SMP_UNSPECIFIED;
2026
2027         set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
2028
2029         /* Can't compose response until we have been confirmed */
2030         if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
2031                 return smp_confirm(smp);
2032
2033         return 0;
2034 }
2035
2036 static u8 sc_check_confirm(struct smp_chan *smp)
2037 {
2038         struct l2cap_conn *conn = smp->conn;
2039
2040         BT_DBG("");
2041
2042         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2043                 return sc_passkey_round(smp, SMP_CMD_PAIRING_CONFIRM);
2044
2045         if (conn->hcon->out) {
2046                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
2047                              smp->prnd);
2048                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2049         }
2050
2051         return 0;
2052 }
2053
2054 /* Work-around for some implementations that incorrectly copy RFU bits
2055  * from our security request and thereby create the impression that
2056  * we're doing SC when in fact the remote doesn't support it.
2057  */
2058 static int fixup_sc_false_positive(struct smp_chan *smp)
2059 {
2060         struct l2cap_conn *conn = smp->conn;
2061         struct hci_conn *hcon = conn->hcon;
2062         struct hci_dev *hdev = hcon->hdev;
2063         struct smp_cmd_pairing *req, *rsp;
2064         u8 auth;
2065
2066         /* The issue is only observed when we're in slave role */
2067         if (hcon->out)
2068                 return SMP_UNSPECIFIED;
2069
2070         if (hci_dev_test_flag(hdev, HCI_SC_ONLY)) {
2071                 bt_dev_err(hdev, "refusing legacy fallback in SC-only mode");
2072                 return SMP_UNSPECIFIED;
2073         }
2074
2075         bt_dev_err(hdev, "trying to fall back to legacy SMP");
2076
2077         req = (void *) &smp->preq[1];
2078         rsp = (void *) &smp->prsp[1];
2079
2080         /* Rebuild key dist flags which may have been cleared for SC */
2081         smp->remote_key_dist = (req->init_key_dist & rsp->resp_key_dist);
2082
2083         auth = req->auth_req & AUTH_REQ_MASK(hdev);
2084
2085         if (tk_request(conn, 0, auth, rsp->io_capability, req->io_capability)) {
2086                 bt_dev_err(hdev, "failed to fall back to legacy SMP");
2087                 return SMP_UNSPECIFIED;
2088         }
2089
2090         clear_bit(SMP_FLAG_SC, &smp->flags);
2091
2092         return 0;
2093 }
2094
2095 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
2096 {
2097         struct l2cap_chan *chan = conn->smp;
2098         struct smp_chan *smp = chan->data;
2099
2100         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
2101
2102         if (skb->len < sizeof(smp->pcnf))
2103                 return SMP_INVALID_PARAMS;
2104
2105         memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
2106         skb_pull(skb, sizeof(smp->pcnf));
2107
2108         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
2109                 int ret;
2110
2111                 /* Public Key exchange must happen before any other steps */
2112                 if (test_bit(SMP_FLAG_REMOTE_PK, &smp->flags))
2113                         return sc_check_confirm(smp);
2114
2115                 BT_ERR("Unexpected SMP Pairing Confirm");
2116
2117                 ret = fixup_sc_false_positive(smp);
2118                 if (ret)
2119                         return ret;
2120         }
2121
2122         if (conn->hcon->out) {
2123                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
2124                              smp->prnd);
2125                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2126                 return 0;
2127         }
2128
2129         if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
2130                 return smp_confirm(smp);
2131
2132         set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
2133
2134         return 0;
2135 }
2136
2137 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
2138 {
2139         struct l2cap_chan *chan = conn->smp;
2140         struct smp_chan *smp = chan->data;
2141         struct hci_conn *hcon = conn->hcon;
2142         u8 *pkax, *pkbx, *na, *nb;
2143         u32 passkey;
2144         int err;
2145
2146         BT_DBG("conn %p", conn);
2147
2148         if (skb->len < sizeof(smp->rrnd))
2149                 return SMP_INVALID_PARAMS;
2150
2151         memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
2152         skb_pull(skb, sizeof(smp->rrnd));
2153
2154         if (!test_bit(SMP_FLAG_SC, &smp->flags))
2155                 return smp_random(smp);
2156
2157         if (hcon->out) {
2158                 pkax = smp->local_pk;
2159                 pkbx = smp->remote_pk;
2160                 na   = smp->prnd;
2161                 nb   = smp->rrnd;
2162         } else {
2163                 pkax = smp->remote_pk;
2164                 pkbx = smp->local_pk;
2165                 na   = smp->rrnd;
2166                 nb   = smp->prnd;
2167         }
2168
2169         if (smp->method == REQ_OOB) {
2170                 if (!hcon->out)
2171                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
2172                                      sizeof(smp->prnd), smp->prnd);
2173                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
2174                 goto mackey_and_ltk;
2175         }
2176
2177         /* Passkey entry has special treatment */
2178         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2179                 return sc_passkey_round(smp, SMP_CMD_PAIRING_RANDOM);
2180
2181         if (hcon->out) {
2182                 u8 cfm[16];
2183
2184                 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
2185                              smp->rrnd, 0, cfm);
2186                 if (err)
2187                         return SMP_UNSPECIFIED;
2188
2189                 if (crypto_memneq(smp->pcnf, cfm, 16))
2190                         return SMP_CONFIRM_FAILED;
2191         } else {
2192                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
2193                              smp->prnd);
2194                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
2195         }
2196
2197 mackey_and_ltk:
2198         /* Generate MacKey and LTK */
2199         err = sc_mackey_and_ltk(smp, smp->mackey, smp->tk);
2200         if (err)
2201                 return SMP_UNSPECIFIED;
2202
2203         if (smp->method == JUST_WORKS || smp->method == REQ_OOB) {
2204                 if (hcon->out) {
2205                         sc_dhkey_check(smp);
2206                         SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
2207                 }
2208                 return 0;
2209         }
2210
2211         err = smp_g2(smp->tfm_cmac, pkax, pkbx, na, nb, &passkey);
2212         if (err)
2213                 return SMP_UNSPECIFIED;
2214
2215         err = mgmt_user_confirm_request(hcon->hdev, &hcon->dst, hcon->type,
2216                                         hcon->dst_type, passkey, 0);
2217         if (err)
2218                 return SMP_UNSPECIFIED;
2219
2220         set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2221
2222         return 0;
2223 }
2224
2225 static bool smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
2226 {
2227         struct smp_ltk *key;
2228         struct hci_conn *hcon = conn->hcon;
2229
2230         key = hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role);
2231         if (!key)
2232                 return false;
2233
2234         if (smp_ltk_sec_level(key) < sec_level)
2235                 return false;
2236
2237         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
2238                 return true;
2239
2240         hci_le_start_enc(hcon, key->ediv, key->rand, key->val, key->enc_size);
2241         hcon->enc_key_size = key->enc_size;
2242
2243         /* We never store STKs for master role, so clear this flag */
2244         clear_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
2245
2246         return true;
2247 }
2248
2249 bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level,
2250                              enum smp_key_pref key_pref)
2251 {
2252         if (sec_level == BT_SECURITY_LOW)
2253                 return true;
2254
2255         /* If we're encrypted with an STK but the caller prefers using
2256          * LTK claim insufficient security. This way we allow the
2257          * connection to be re-encrypted with an LTK, even if the LTK
2258          * provides the same level of security. Only exception is if we
2259          * don't have an LTK (e.g. because of key distribution bits).
2260          */
2261         if (key_pref == SMP_USE_LTK &&
2262             test_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags) &&
2263             hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role))
2264                 return false;
2265
2266         if (hcon->sec_level >= sec_level)
2267                 return true;
2268
2269         return false;
2270 }
2271
2272 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
2273 {
2274         struct smp_cmd_security_req *rp = (void *) skb->data;
2275         struct smp_cmd_pairing cp;
2276         struct hci_conn *hcon = conn->hcon;
2277         struct hci_dev *hdev = hcon->hdev;
2278         struct smp_chan *smp;
2279         u8 sec_level, auth;
2280
2281         BT_DBG("conn %p", conn);
2282
2283         if (skb->len < sizeof(*rp))
2284                 return SMP_INVALID_PARAMS;
2285
2286         if (hcon->role != HCI_ROLE_MASTER)
2287                 return SMP_CMD_NOTSUPP;
2288
2289         auth = rp->auth_req & AUTH_REQ_MASK(hdev);
2290
2291         if (hci_dev_test_flag(hdev, HCI_SC_ONLY) && !(auth & SMP_AUTH_SC))
2292                 return SMP_AUTH_REQUIREMENTS;
2293
2294         if (hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
2295                 sec_level = BT_SECURITY_MEDIUM;
2296         else
2297                 sec_level = authreq_to_seclevel(auth);
2298
2299         if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK)) {
2300                 /* If link is already encrypted with sufficient security we
2301                  * still need refresh encryption as per Core Spec 5.0 Vol 3,
2302                  * Part H 2.4.6
2303                  */
2304                 smp_ltk_encrypt(conn, hcon->sec_level);
2305                 return 0;
2306         }
2307
2308         if (sec_level > hcon->pending_sec_level)
2309                 hcon->pending_sec_level = sec_level;
2310
2311         if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
2312                 return 0;
2313
2314         smp = smp_chan_create(conn);
2315         if (!smp)
2316                 return SMP_UNSPECIFIED;
2317
2318         if (!hci_dev_test_flag(hdev, HCI_BONDABLE) &&
2319             (auth & SMP_AUTH_BONDING))
2320                 return SMP_PAIRING_NOTSUPP;
2321
2322         skb_pull(skb, sizeof(*rp));
2323
2324         memset(&cp, 0, sizeof(cp));
2325         build_pairing_cmd(conn, &cp, NULL, auth);
2326
2327         smp->preq[0] = SMP_CMD_PAIRING_REQ;
2328         memcpy(&smp->preq[1], &cp, sizeof(cp));
2329
2330         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
2331         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2332
2333         return 0;
2334 }
2335
2336 int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
2337 {
2338         struct l2cap_conn *conn = hcon->l2cap_data;
2339         struct l2cap_chan *chan;
2340         struct smp_chan *smp;
2341         __u8 authreq;
2342         int ret;
2343
2344         BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
2345
2346         /* This may be NULL if there's an unexpected disconnection */
2347         if (!conn)
2348                 return 1;
2349
2350         if (!hci_dev_test_flag(hcon->hdev, HCI_LE_ENABLED))
2351                 return 1;
2352
2353         if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
2354                 return 1;
2355
2356         if (sec_level > hcon->pending_sec_level)
2357                 hcon->pending_sec_level = sec_level;
2358
2359         if (hcon->role == HCI_ROLE_MASTER)
2360                 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
2361                         return 0;
2362
2363         chan = conn->smp;
2364         if (!chan) {
2365                 bt_dev_err(hcon->hdev, "security requested but not available");
2366                 return 1;
2367         }
2368
2369         l2cap_chan_lock(chan);
2370
2371         /* If SMP is already in progress ignore this request */
2372         if (chan->data) {
2373                 ret = 0;
2374                 goto unlock;
2375         }
2376
2377         smp = smp_chan_create(conn);
2378         if (!smp) {
2379                 ret = 1;
2380                 goto unlock;
2381         }
2382
2383         authreq = seclevel_to_authreq(sec_level);
2384
2385         if (hci_dev_test_flag(hcon->hdev, HCI_SC_ENABLED)) {
2386                 authreq |= SMP_AUTH_SC;
2387                 if (hci_dev_test_flag(hcon->hdev, HCI_SSP_ENABLED))
2388                         authreq |= SMP_AUTH_CT2;
2389         }
2390
2391         /* Require MITM if IO Capability allows or the security level
2392          * requires it.
2393          */
2394         if (hcon->io_capability != HCI_IO_NO_INPUT_OUTPUT ||
2395             hcon->pending_sec_level > BT_SECURITY_MEDIUM)
2396                 authreq |= SMP_AUTH_MITM;
2397
2398         if (hcon->role == HCI_ROLE_MASTER) {
2399                 struct smp_cmd_pairing cp;
2400
2401                 build_pairing_cmd(conn, &cp, NULL, authreq);
2402                 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2403                 memcpy(&smp->preq[1], &cp, sizeof(cp));
2404
2405                 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
2406                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2407         } else {
2408                 struct smp_cmd_security_req cp;
2409                 cp.auth_req = authreq;
2410                 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
2411                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_REQ);
2412         }
2413
2414         set_bit(SMP_FLAG_INITIATOR, &smp->flags);
2415         ret = 0;
2416
2417 unlock:
2418         l2cap_chan_unlock(chan);
2419         return ret;
2420 }
2421
2422 int smp_cancel_and_remove_pairing(struct hci_dev *hdev, bdaddr_t *bdaddr,
2423                                   u8 addr_type)
2424 {
2425         struct hci_conn *hcon;
2426         struct l2cap_conn *conn;
2427         struct l2cap_chan *chan;
2428         struct smp_chan *smp;
2429         int err;
2430
2431         err = hci_remove_ltk(hdev, bdaddr, addr_type);
2432         hci_remove_irk(hdev, bdaddr, addr_type);
2433
2434         hcon = hci_conn_hash_lookup_le(hdev, bdaddr, addr_type);
2435         if (!hcon)
2436                 goto done;
2437
2438         conn = hcon->l2cap_data;
2439         if (!conn)
2440                 goto done;
2441
2442         chan = conn->smp;
2443         if (!chan)
2444                 goto done;
2445
2446         l2cap_chan_lock(chan);
2447
2448         smp = chan->data;
2449         if (smp) {
2450                 /* Set keys to NULL to make sure smp_failure() does not try to
2451                  * remove and free already invalidated rcu list entries. */
2452                 smp->ltk = NULL;
2453                 smp->slave_ltk = NULL;
2454                 smp->remote_irk = NULL;
2455
2456                 if (test_bit(SMP_FLAG_COMPLETE, &smp->flags))
2457                         smp_failure(conn, 0);
2458                 else
2459                         smp_failure(conn, SMP_UNSPECIFIED);
2460                 err = 0;
2461         }
2462
2463         l2cap_chan_unlock(chan);
2464
2465 done:
2466         return err;
2467 }
2468
2469 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
2470 {
2471         struct smp_cmd_encrypt_info *rp = (void *) skb->data;
2472         struct l2cap_chan *chan = conn->smp;
2473         struct smp_chan *smp = chan->data;
2474
2475         BT_DBG("conn %p", conn);
2476
2477         if (skb->len < sizeof(*rp))
2478                 return SMP_INVALID_PARAMS;
2479
2480         SMP_ALLOW_CMD(smp, SMP_CMD_MASTER_IDENT);
2481
2482         skb_pull(skb, sizeof(*rp));
2483
2484         memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
2485
2486         return 0;
2487 }
2488
2489 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
2490 {
2491         struct smp_cmd_master_ident *rp = (void *) skb->data;
2492         struct l2cap_chan *chan = conn->smp;
2493         struct smp_chan *smp = chan->data;
2494         struct hci_dev *hdev = conn->hcon->hdev;
2495         struct hci_conn *hcon = conn->hcon;
2496         struct smp_ltk *ltk;
2497         u8 authenticated;
2498
2499         BT_DBG("conn %p", conn);
2500
2501         if (skb->len < sizeof(*rp))
2502                 return SMP_INVALID_PARAMS;
2503
2504         /* Mark the information as received */
2505         smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
2506
2507         if (smp->remote_key_dist & SMP_DIST_ID_KEY)
2508                 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
2509         else if (smp->remote_key_dist & SMP_DIST_SIGN)
2510                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
2511
2512         skb_pull(skb, sizeof(*rp));
2513
2514         authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
2515         ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, SMP_LTK,
2516                           authenticated, smp->tk, smp->enc_key_size,
2517                           rp->ediv, rp->rand);
2518         smp->ltk = ltk;
2519         if (!(smp->remote_key_dist & KEY_DIST_MASK))
2520                 smp_distribute_keys(smp);
2521
2522         return 0;
2523 }
2524
2525 static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
2526 {
2527         struct smp_cmd_ident_info *info = (void *) skb->data;
2528         struct l2cap_chan *chan = conn->smp;
2529         struct smp_chan *smp = chan->data;
2530
2531         BT_DBG("");
2532
2533         if (skb->len < sizeof(*info))
2534                 return SMP_INVALID_PARAMS;
2535
2536         SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_ADDR_INFO);
2537
2538         skb_pull(skb, sizeof(*info));
2539
2540         memcpy(smp->irk, info->irk, 16);
2541
2542         return 0;
2543 }
2544
2545 static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
2546                                    struct sk_buff *skb)
2547 {
2548         struct smp_cmd_ident_addr_info *info = (void *) skb->data;
2549         struct l2cap_chan *chan = conn->smp;
2550         struct smp_chan *smp = chan->data;
2551         struct hci_conn *hcon = conn->hcon;
2552         bdaddr_t rpa;
2553
2554         BT_DBG("");
2555
2556         if (skb->len < sizeof(*info))
2557                 return SMP_INVALID_PARAMS;
2558
2559         /* Mark the information as received */
2560         smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
2561
2562         if (smp->remote_key_dist & SMP_DIST_SIGN)
2563                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
2564
2565         skb_pull(skb, sizeof(*info));
2566
2567         /* Strictly speaking the Core Specification (4.1) allows sending
2568          * an empty address which would force us to rely on just the IRK
2569          * as "identity information". However, since such
2570          * implementations are not known of and in order to not over
2571          * complicate our implementation, simply pretend that we never
2572          * received an IRK for such a device.
2573          *
2574          * The Identity Address must also be a Static Random or Public
2575          * Address, which hci_is_identity_address() checks for.
2576          */
2577         if (!bacmp(&info->bdaddr, BDADDR_ANY) ||
2578             !hci_is_identity_address(&info->bdaddr, info->addr_type)) {
2579                 bt_dev_err(hcon->hdev, "ignoring IRK with no identity address");
2580                 goto distribute;
2581         }
2582
2583         /* Drop IRK if peer is using identity address during pairing but is
2584          * providing different address as identity information.
2585          *
2586          * Microsoft Surface Precision Mouse is known to have this bug.
2587          */
2588         if (hci_is_identity_address(&hcon->dst, hcon->dst_type) &&
2589             (bacmp(&info->bdaddr, &hcon->dst) ||
2590              info->addr_type != hcon->dst_type)) {
2591                 bt_dev_err(hcon->hdev,
2592                            "ignoring IRK with invalid identity address");
2593                 goto distribute;
2594         }
2595
2596         bacpy(&smp->id_addr, &info->bdaddr);
2597         smp->id_addr_type = info->addr_type;
2598
2599         if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
2600                 bacpy(&rpa, &hcon->dst);
2601         else
2602                 bacpy(&rpa, BDADDR_ANY);
2603
2604         smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
2605                                       smp->id_addr_type, smp->irk, &rpa);
2606
2607 distribute:
2608         if (!(smp->remote_key_dist & KEY_DIST_MASK))
2609                 smp_distribute_keys(smp);
2610
2611         return 0;
2612 }
2613
2614 static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
2615 {
2616         struct smp_cmd_sign_info *rp = (void *) skb->data;
2617         struct l2cap_chan *chan = conn->smp;
2618         struct smp_chan *smp = chan->data;
2619         struct smp_csrk *csrk;
2620
2621         BT_DBG("conn %p", conn);
2622
2623         if (skb->len < sizeof(*rp))
2624                 return SMP_INVALID_PARAMS;
2625
2626         /* Mark the information as received */
2627         smp->remote_key_dist &= ~SMP_DIST_SIGN;
2628
2629         skb_pull(skb, sizeof(*rp));
2630
2631         csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
2632         if (csrk) {
2633                 if (conn->hcon->sec_level > BT_SECURITY_MEDIUM)
2634                         csrk->type = MGMT_CSRK_REMOTE_AUTHENTICATED;
2635                 else
2636                         csrk->type = MGMT_CSRK_REMOTE_UNAUTHENTICATED;
2637                 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
2638         }
2639         smp->csrk = csrk;
2640         smp_distribute_keys(smp);
2641
2642         return 0;
2643 }
2644
2645 static u8 sc_select_method(struct smp_chan *smp)
2646 {
2647         struct l2cap_conn *conn = smp->conn;
2648         struct hci_conn *hcon = conn->hcon;
2649         struct smp_cmd_pairing *local, *remote;
2650         u8 local_mitm, remote_mitm, local_io, remote_io, method;
2651
2652         if (test_bit(SMP_FLAG_REMOTE_OOB, &smp->flags) ||
2653             test_bit(SMP_FLAG_LOCAL_OOB, &smp->flags))
2654                 return REQ_OOB;
2655
2656         /* The preq/prsp contain the raw Pairing Request/Response PDUs
2657          * which are needed as inputs to some crypto functions. To get
2658          * the "struct smp_cmd_pairing" from them we need to skip the
2659          * first byte which contains the opcode.
2660          */
2661         if (hcon->out) {
2662                 local = (void *) &smp->preq[1];
2663                 remote = (void *) &smp->prsp[1];
2664         } else {
2665                 local = (void *) &smp->prsp[1];
2666                 remote = (void *) &smp->preq[1];
2667         }
2668
2669         local_io = local->io_capability;
2670         remote_io = remote->io_capability;
2671
2672         local_mitm = (local->auth_req & SMP_AUTH_MITM);
2673         remote_mitm = (remote->auth_req & SMP_AUTH_MITM);
2674
2675         /* If either side wants MITM, look up the method from the table,
2676          * otherwise use JUST WORKS.
2677          */
2678         if (local_mitm || remote_mitm)
2679                 method = get_auth_method(smp, local_io, remote_io);
2680         else
2681                 method = JUST_WORKS;
2682
2683         /* Don't confirm locally initiated pairing attempts */
2684         if (method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR, &smp->flags))
2685                 method = JUST_WORKS;
2686
2687         return method;
2688 }
2689
2690 static int smp_cmd_public_key(struct l2cap_conn *conn, struct sk_buff *skb)
2691 {
2692         struct smp_cmd_public_key *key = (void *) skb->data;
2693         struct hci_conn *hcon = conn->hcon;
2694         struct l2cap_chan *chan = conn->smp;
2695         struct smp_chan *smp = chan->data;
2696         struct hci_dev *hdev = hcon->hdev;
2697         struct crypto_kpp *tfm_ecdh;
2698         struct smp_cmd_pairing_confirm cfm;
2699         int err;
2700
2701         BT_DBG("conn %p", conn);
2702
2703         if (skb->len < sizeof(*key))
2704                 return SMP_INVALID_PARAMS;
2705
2706         memcpy(smp->remote_pk, key, 64);
2707
2708         if (test_bit(SMP_FLAG_REMOTE_OOB, &smp->flags)) {
2709                 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->remote_pk,
2710                              smp->rr, 0, cfm.confirm_val);
2711                 if (err)
2712                         return SMP_UNSPECIFIED;
2713
2714                 if (crypto_memneq(cfm.confirm_val, smp->pcnf, 16))
2715                         return SMP_CONFIRM_FAILED;
2716         }
2717
2718         /* Non-initiating device sends its public key after receiving
2719          * the key from the initiating device.
2720          */
2721         if (!hcon->out) {
2722                 err = sc_send_public_key(smp);
2723                 if (err)
2724                         return err;
2725         }
2726
2727         SMP_DBG("Remote Public Key X: %32phN", smp->remote_pk);
2728         SMP_DBG("Remote Public Key Y: %32phN", smp->remote_pk + 32);
2729
2730         /* Compute the shared secret on the same crypto tfm on which the private
2731          * key was set/generated.
2732          */
2733         if (test_bit(SMP_FLAG_LOCAL_OOB, &smp->flags)) {
2734                 struct l2cap_chan *hchan = hdev->smp_data;
2735                 struct smp_dev *smp_dev;
2736
2737                 if (!hchan || !hchan->data)
2738                         return SMP_UNSPECIFIED;
2739
2740                 smp_dev = hchan->data;
2741
2742                 tfm_ecdh = smp_dev->tfm_ecdh;
2743         } else {
2744                 tfm_ecdh = smp->tfm_ecdh;
2745         }
2746
2747         if (compute_ecdh_secret(tfm_ecdh, smp->remote_pk, smp->dhkey))
2748                 return SMP_UNSPECIFIED;
2749
2750         SMP_DBG("DHKey %32phN", smp->dhkey);
2751
2752         set_bit(SMP_FLAG_REMOTE_PK, &smp->flags);
2753
2754         smp->method = sc_select_method(smp);
2755
2756         BT_DBG("%s selected method 0x%02x", hdev->name, smp->method);
2757
2758         /* JUST_WORKS and JUST_CFM result in an unauthenticated key */
2759         if (smp->method == JUST_WORKS || smp->method == JUST_CFM)
2760                 hcon->pending_sec_level = BT_SECURITY_MEDIUM;
2761         else
2762                 hcon->pending_sec_level = BT_SECURITY_FIPS;
2763
2764         if (!crypto_memneq(debug_pk, smp->remote_pk, 64))
2765                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
2766
2767         if (smp->method == DSP_PASSKEY) {
2768                 get_random_bytes(&hcon->passkey_notify,
2769                                  sizeof(hcon->passkey_notify));
2770                 hcon->passkey_notify %= 1000000;
2771                 hcon->passkey_entered = 0;
2772                 smp->passkey_round = 0;
2773                 if (mgmt_user_passkey_notify(hdev, &hcon->dst, hcon->type,
2774                                              hcon->dst_type,
2775                                              hcon->passkey_notify,
2776                                              hcon->passkey_entered))
2777                         return SMP_UNSPECIFIED;
2778                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2779                 return sc_passkey_round(smp, SMP_CMD_PUBLIC_KEY);
2780         }
2781
2782         if (smp->method == REQ_OOB) {
2783                 if (hcon->out)
2784                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
2785                                      sizeof(smp->prnd), smp->prnd);
2786
2787                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2788
2789                 return 0;
2790         }
2791
2792         if (hcon->out)
2793                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2794
2795         if (smp->method == REQ_PASSKEY) {
2796                 if (mgmt_user_passkey_request(hdev, &hcon->dst, hcon->type,
2797                                               hcon->dst_type))
2798                         return SMP_UNSPECIFIED;
2799                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2800                 set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2801                 return 0;
2802         }
2803
2804         /* The Initiating device waits for the non-initiating device to
2805          * send the confirm value.
2806          */
2807         if (conn->hcon->out)
2808                 return 0;
2809
2810         err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd,
2811                      0, cfm.confirm_val);
2812         if (err)
2813                 return SMP_UNSPECIFIED;
2814
2815         smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
2816         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2817
2818         return 0;
2819 }
2820
2821 static int smp_cmd_dhkey_check(struct l2cap_conn *conn, struct sk_buff *skb)
2822 {
2823         struct smp_cmd_dhkey_check *check = (void *) skb->data;
2824         struct l2cap_chan *chan = conn->smp;
2825         struct hci_conn *hcon = conn->hcon;
2826         struct smp_chan *smp = chan->data;
2827         u8 a[7], b[7], *local_addr, *remote_addr;
2828         u8 io_cap[3], r[16], e[16];
2829         int err;
2830
2831         BT_DBG("conn %p", conn);
2832
2833         if (skb->len < sizeof(*check))
2834                 return SMP_INVALID_PARAMS;
2835
2836         memcpy(a, &hcon->init_addr, 6);
2837         memcpy(b, &hcon->resp_addr, 6);
2838         a[6] = hcon->init_addr_type;
2839         b[6] = hcon->resp_addr_type;
2840
2841         if (hcon->out) {
2842                 local_addr = a;
2843                 remote_addr = b;
2844                 memcpy(io_cap, &smp->prsp[1], 3);
2845         } else {
2846                 local_addr = b;
2847                 remote_addr = a;
2848                 memcpy(io_cap, &smp->preq[1], 3);
2849         }
2850
2851         memset(r, 0, sizeof(r));
2852
2853         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2854                 put_unaligned_le32(hcon->passkey_notify, r);
2855         else if (smp->method == REQ_OOB)
2856                 memcpy(r, smp->lr, 16);
2857
2858         err = smp_f6(smp->tfm_cmac, smp->mackey, smp->rrnd, smp->prnd, r,
2859                      io_cap, remote_addr, local_addr, e);
2860         if (err)
2861                 return SMP_UNSPECIFIED;
2862
2863         if (crypto_memneq(check->e, e, 16))
2864                 return SMP_DHKEY_CHECK_FAILED;
2865
2866         if (!hcon->out) {
2867                 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
2868                         set_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags);
2869                         return 0;
2870                 }
2871
2872                 /* Slave sends DHKey check as response to master */
2873                 sc_dhkey_check(smp);
2874         }
2875
2876         sc_add_ltk(smp);
2877
2878         if (hcon->out) {
2879                 hci_le_start_enc(hcon, 0, 0, smp->tk, smp->enc_key_size);
2880                 hcon->enc_key_size = smp->enc_key_size;
2881         }
2882
2883         return 0;
2884 }
2885
2886 static int smp_cmd_keypress_notify(struct l2cap_conn *conn,
2887                                    struct sk_buff *skb)
2888 {
2889         struct smp_cmd_keypress_notify *kp = (void *) skb->data;
2890
2891         BT_DBG("value 0x%02x", kp->value);
2892
2893         return 0;
2894 }
2895
2896 static int smp_sig_channel(struct l2cap_chan *chan, struct sk_buff *skb)
2897 {
2898         struct l2cap_conn *conn = chan->conn;
2899         struct hci_conn *hcon = conn->hcon;
2900         struct smp_chan *smp;
2901         __u8 code, reason;
2902         int err = 0;
2903
2904         if (skb->len < 1)
2905                 return -EILSEQ;
2906
2907         if (!hci_dev_test_flag(hcon->hdev, HCI_LE_ENABLED)) {
2908                 reason = SMP_PAIRING_NOTSUPP;
2909                 goto done;
2910         }
2911
2912         code = skb->data[0];
2913         skb_pull(skb, sizeof(code));
2914
2915         smp = chan->data;
2916
2917         if (code > SMP_CMD_MAX)
2918                 goto drop;
2919
2920         if (smp && !test_and_clear_bit(code, &smp->allow_cmd))
2921                 goto drop;
2922
2923         /* If we don't have a context the only allowed commands are
2924          * pairing request and security request.
2925          */
2926         if (!smp && code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ)
2927                 goto drop;
2928
2929         switch (code) {
2930         case SMP_CMD_PAIRING_REQ:
2931                 reason = smp_cmd_pairing_req(conn, skb);
2932                 break;
2933
2934         case SMP_CMD_PAIRING_FAIL:
2935                 smp_failure(conn, 0);
2936                 err = -EPERM;
2937                 break;
2938
2939         case SMP_CMD_PAIRING_RSP:
2940                 reason = smp_cmd_pairing_rsp(conn, skb);
2941                 break;
2942
2943         case SMP_CMD_SECURITY_REQ:
2944                 reason = smp_cmd_security_req(conn, skb);
2945                 break;
2946
2947         case SMP_CMD_PAIRING_CONFIRM:
2948                 reason = smp_cmd_pairing_confirm(conn, skb);
2949                 break;
2950
2951         case SMP_CMD_PAIRING_RANDOM:
2952                 reason = smp_cmd_pairing_random(conn, skb);
2953                 break;
2954
2955         case SMP_CMD_ENCRYPT_INFO:
2956                 reason = smp_cmd_encrypt_info(conn, skb);
2957                 break;
2958
2959         case SMP_CMD_MASTER_IDENT:
2960                 reason = smp_cmd_master_ident(conn, skb);
2961                 break;
2962
2963         case SMP_CMD_IDENT_INFO:
2964                 reason = smp_cmd_ident_info(conn, skb);
2965                 break;
2966
2967         case SMP_CMD_IDENT_ADDR_INFO:
2968                 reason = smp_cmd_ident_addr_info(conn, skb);
2969                 break;
2970
2971         case SMP_CMD_SIGN_INFO:
2972                 reason = smp_cmd_sign_info(conn, skb);
2973                 break;
2974
2975         case SMP_CMD_PUBLIC_KEY:
2976                 reason = smp_cmd_public_key(conn, skb);
2977                 break;
2978
2979         case SMP_CMD_DHKEY_CHECK:
2980                 reason = smp_cmd_dhkey_check(conn, skb);
2981                 break;
2982
2983         case SMP_CMD_KEYPRESS_NOTIFY:
2984                 reason = smp_cmd_keypress_notify(conn, skb);
2985                 break;
2986
2987         default:
2988                 BT_DBG("Unknown command code 0x%2.2x", code);
2989                 reason = SMP_CMD_NOTSUPP;
2990                 goto done;
2991         }
2992
2993 done:
2994         if (!err) {
2995                 if (reason)
2996                         smp_failure(conn, reason);
2997                 kfree_skb(skb);
2998         }
2999
3000         return err;
3001
3002 drop:
3003         bt_dev_err(hcon->hdev, "unexpected SMP command 0x%02x from %pMR",
3004                    code, &hcon->dst);
3005         kfree_skb(skb);
3006         return 0;
3007 }
3008
3009 static void smp_teardown_cb(struct l2cap_chan *chan, int err)
3010 {
3011         struct l2cap_conn *conn = chan->conn;
3012
3013         BT_DBG("chan %p", chan);
3014
3015         if (chan->data)
3016                 smp_chan_destroy(conn);
3017
3018         conn->smp = NULL;
3019         l2cap_chan_put(chan);
3020 }
3021
3022 static void bredr_pairing(struct l2cap_chan *chan)
3023 {
3024         struct l2cap_conn *conn = chan->conn;
3025         struct hci_conn *hcon = conn->hcon;
3026         struct hci_dev *hdev = hcon->hdev;
3027         struct smp_cmd_pairing req;
3028         struct smp_chan *smp;
3029
3030         BT_DBG("chan %p", chan);
3031
3032         /* Only new pairings are interesting */
3033         if (!test_bit(HCI_CONN_NEW_LINK_KEY, &hcon->flags))
3034                 return;
3035
3036         /* Don't bother if we're not encrypted */
3037         if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
3038                 return;
3039
3040         /* Only master may initiate SMP over BR/EDR */
3041         if (hcon->role != HCI_ROLE_MASTER)
3042                 return;
3043
3044         /* Secure Connections support must be enabled */
3045         if (!hci_dev_test_flag(hdev, HCI_SC_ENABLED))
3046                 return;
3047
3048         /* BR/EDR must use Secure Connections for SMP */
3049         if (!test_bit(HCI_CONN_AES_CCM, &hcon->flags) &&
3050             !hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
3051                 return;
3052
3053         /* If our LE support is not enabled don't do anything */
3054         if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED))
3055                 return;
3056
3057         /* Don't bother if remote LE support is not enabled */
3058         if (!lmp_host_le_capable(hcon))
3059                 return;
3060
3061         /* Remote must support SMP fixed chan for BR/EDR */
3062         if (!(conn->remote_fixed_chan & L2CAP_FC_SMP_BREDR))
3063                 return;
3064
3065         /* Don't bother if SMP is already ongoing */
3066         if (chan->data)
3067                 return;
3068
3069         smp = smp_chan_create(conn);
3070         if (!smp) {
3071                 bt_dev_err(hdev, "unable to create SMP context for BR/EDR");
3072                 return;
3073         }
3074
3075         set_bit(SMP_FLAG_SC, &smp->flags);
3076
3077         BT_DBG("%s starting SMP over BR/EDR", hdev->name);
3078
3079         /* Prepare and send the BR/EDR SMP Pairing Request */
3080         build_bredr_pairing_cmd(smp, &req, NULL);
3081
3082         smp->preq[0] = SMP_CMD_PAIRING_REQ;
3083         memcpy(&smp->preq[1], &req, sizeof(req));
3084
3085         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(req), &req);
3086         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
3087 }
3088
3089 static void smp_resume_cb(struct l2cap_chan *chan)
3090 {
3091         struct smp_chan *smp = chan->data;
3092         struct l2cap_conn *conn = chan->conn;
3093         struct hci_conn *hcon = conn->hcon;
3094
3095         BT_DBG("chan %p", chan);
3096
3097         if (hcon->type == ACL_LINK) {
3098                 bredr_pairing(chan);
3099                 return;
3100         }
3101
3102         if (!smp)
3103                 return;
3104
3105         if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
3106                 return;
3107
3108         cancel_delayed_work(&smp->security_timer);
3109
3110         smp_distribute_keys(smp);
3111 }
3112
3113 static void smp_ready_cb(struct l2cap_chan *chan)
3114 {
3115         struct l2cap_conn *conn = chan->conn;
3116         struct hci_conn *hcon = conn->hcon;
3117
3118         BT_DBG("chan %p", chan);
3119
3120         /* No need to call l2cap_chan_hold() here since we already own
3121          * the reference taken in smp_new_conn_cb(). This is just the
3122          * first time that we tie it to a specific pointer. The code in
3123          * l2cap_core.c ensures that there's no risk this function wont
3124          * get called if smp_new_conn_cb was previously called.
3125          */
3126         conn->smp = chan;
3127
3128         if (hcon->type == ACL_LINK && test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
3129                 bredr_pairing(chan);
3130 }
3131
3132 static int smp_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
3133 {
3134         int err;
3135
3136         BT_DBG("chan %p", chan);
3137
3138         err = smp_sig_channel(chan, skb);
3139         if (err) {
3140                 struct smp_chan *smp = chan->data;
3141
3142                 if (smp)
3143                         cancel_delayed_work_sync(&smp->security_timer);
3144
3145                 hci_disconnect(chan->conn->hcon, HCI_ERROR_AUTH_FAILURE);
3146         }
3147
3148         return err;
3149 }
3150
3151 static struct sk_buff *smp_alloc_skb_cb(struct l2cap_chan *chan,
3152                                         unsigned long hdr_len,
3153                                         unsigned long len, int nb)
3154 {
3155         struct sk_buff *skb;
3156
3157         skb = bt_skb_alloc(hdr_len + len, GFP_KERNEL);
3158         if (!skb)
3159                 return ERR_PTR(-ENOMEM);
3160
3161         skb->priority = HCI_PRIO_MAX;
3162         bt_cb(skb)->l2cap.chan = chan;
3163
3164         return skb;
3165 }
3166
3167 static const struct l2cap_ops smp_chan_ops = {
3168         .name                   = "Security Manager",
3169         .ready                  = smp_ready_cb,
3170         .recv                   = smp_recv_cb,
3171         .alloc_skb              = smp_alloc_skb_cb,
3172         .teardown               = smp_teardown_cb,
3173         .resume                 = smp_resume_cb,
3174
3175         .new_connection         = l2cap_chan_no_new_connection,
3176         .state_change           = l2cap_chan_no_state_change,
3177         .close                  = l2cap_chan_no_close,
3178         .defer                  = l2cap_chan_no_defer,
3179         .suspend                = l2cap_chan_no_suspend,
3180         .set_shutdown           = l2cap_chan_no_set_shutdown,
3181         .get_sndtimeo           = l2cap_chan_no_get_sndtimeo,
3182 };
3183
3184 static inline struct l2cap_chan *smp_new_conn_cb(struct l2cap_chan *pchan)
3185 {
3186         struct l2cap_chan *chan;
3187
3188         BT_DBG("pchan %p", pchan);
3189
3190         chan = l2cap_chan_create();
3191         if (!chan)
3192                 return NULL;
3193
3194         chan->chan_type = pchan->chan_type;
3195         chan->ops       = &smp_chan_ops;
3196         chan->scid      = pchan->scid;
3197         chan->dcid      = chan->scid;
3198         chan->imtu      = pchan->imtu;
3199         chan->omtu      = pchan->omtu;
3200         chan->mode      = pchan->mode;
3201
3202         /* Other L2CAP channels may request SMP routines in order to
3203          * change the security level. This means that the SMP channel
3204          * lock must be considered in its own category to avoid lockdep
3205          * warnings.
3206          */
3207         atomic_set(&chan->nesting, L2CAP_NESTING_SMP);
3208
3209         BT_DBG("created chan %p", chan);
3210
3211         return chan;
3212 }
3213
3214 static const struct l2cap_ops smp_root_chan_ops = {
3215         .name                   = "Security Manager Root",
3216         .new_connection         = smp_new_conn_cb,
3217
3218         /* None of these are implemented for the root channel */
3219         .close                  = l2cap_chan_no_close,
3220         .alloc_skb              = l2cap_chan_no_alloc_skb,
3221         .recv                   = l2cap_chan_no_recv,
3222         .state_change           = l2cap_chan_no_state_change,
3223         .teardown               = l2cap_chan_no_teardown,
3224         .ready                  = l2cap_chan_no_ready,
3225         .defer                  = l2cap_chan_no_defer,
3226         .suspend                = l2cap_chan_no_suspend,
3227         .resume                 = l2cap_chan_no_resume,
3228         .set_shutdown           = l2cap_chan_no_set_shutdown,
3229         .get_sndtimeo           = l2cap_chan_no_get_sndtimeo,
3230 };
3231
3232 static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
3233 {
3234         struct l2cap_chan *chan;
3235         struct smp_dev *smp;
3236         struct crypto_cipher *tfm_aes;
3237         struct crypto_shash *tfm_cmac;
3238         struct crypto_kpp *tfm_ecdh;
3239
3240         if (cid == L2CAP_CID_SMP_BREDR) {
3241                 smp = NULL;
3242                 goto create_chan;
3243         }
3244
3245         smp = kzalloc(sizeof(*smp), GFP_KERNEL);
3246         if (!smp)
3247                 return ERR_PTR(-ENOMEM);
3248
3249         tfm_aes = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
3250         if (IS_ERR(tfm_aes)) {
3251                 BT_ERR("Unable to create AES crypto context");
3252                 kzfree(smp);
3253                 return ERR_CAST(tfm_aes);
3254         }
3255
3256         tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
3257         if (IS_ERR(tfm_cmac)) {
3258                 BT_ERR("Unable to create CMAC crypto context");
3259                 crypto_free_cipher(tfm_aes);
3260                 kzfree(smp);
3261                 return ERR_CAST(tfm_cmac);
3262         }
3263
3264         tfm_ecdh = crypto_alloc_kpp("ecdh", CRYPTO_ALG_INTERNAL, 0);
3265         if (IS_ERR(tfm_ecdh)) {
3266                 BT_ERR("Unable to create ECDH crypto context");
3267                 crypto_free_shash(tfm_cmac);
3268                 crypto_free_cipher(tfm_aes);
3269                 kzfree(smp);
3270                 return ERR_CAST(tfm_ecdh);
3271         }
3272
3273         smp->local_oob = false;
3274         smp->tfm_aes = tfm_aes;
3275         smp->tfm_cmac = tfm_cmac;
3276         smp->tfm_ecdh = tfm_ecdh;
3277
3278 create_chan:
3279         chan = l2cap_chan_create();
3280         if (!chan) {
3281                 if (smp) {
3282                         crypto_free_cipher(smp->tfm_aes);
3283                         crypto_free_shash(smp->tfm_cmac);
3284                         crypto_free_kpp(smp->tfm_ecdh);
3285                         kzfree(smp);
3286                 }
3287                 return ERR_PTR(-ENOMEM);
3288         }
3289
3290         chan->data = smp;
3291
3292         l2cap_add_scid(chan, cid);
3293
3294         l2cap_chan_set_defaults(chan);
3295
3296         if (cid == L2CAP_CID_SMP) {
3297                 u8 bdaddr_type;
3298
3299                 hci_copy_identity_address(hdev, &chan->src, &bdaddr_type);
3300
3301                 if (bdaddr_type == ADDR_LE_DEV_PUBLIC)
3302                         chan->src_type = BDADDR_LE_PUBLIC;
3303                 else
3304                         chan->src_type = BDADDR_LE_RANDOM;
3305         } else {
3306                 bacpy(&chan->src, &hdev->bdaddr);
3307                 chan->src_type = BDADDR_BREDR;
3308         }
3309
3310         chan->state = BT_LISTEN;
3311         chan->mode = L2CAP_MODE_BASIC;
3312         chan->imtu = L2CAP_DEFAULT_MTU;
3313         chan->ops = &smp_root_chan_ops;
3314
3315         /* Set correct nesting level for a parent/listening channel */
3316         atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
3317
3318         return chan;
3319 }
3320
3321 static void smp_del_chan(struct l2cap_chan *chan)
3322 {
3323         struct smp_dev *smp;
3324
3325         BT_DBG("chan %p", chan);
3326
3327         smp = chan->data;
3328         if (smp) {
3329                 chan->data = NULL;
3330                 crypto_free_cipher(smp->tfm_aes);
3331                 crypto_free_shash(smp->tfm_cmac);
3332                 crypto_free_kpp(smp->tfm_ecdh);
3333                 kzfree(smp);
3334         }
3335
3336         l2cap_chan_put(chan);
3337 }
3338
3339 static ssize_t force_bredr_smp_read(struct file *file,
3340                                     char __user *user_buf,
3341                                     size_t count, loff_t *ppos)
3342 {
3343         struct hci_dev *hdev = file->private_data;
3344         char buf[3];
3345
3346         buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP) ? 'Y': 'N';
3347         buf[1] = '\n';
3348         buf[2] = '\0';
3349         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
3350 }
3351
3352 static ssize_t force_bredr_smp_write(struct file *file,
3353                                      const char __user *user_buf,
3354                                      size_t count, loff_t *ppos)
3355 {
3356         struct hci_dev *hdev = file->private_data;
3357         bool enable;
3358         int err;
3359
3360         err = kstrtobool_from_user(user_buf, count, &enable);
3361         if (err)
3362                 return err;
3363
3364         if (enable == hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
3365                 return -EALREADY;
3366
3367         if (enable) {
3368                 struct l2cap_chan *chan;
3369
3370                 chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
3371                 if (IS_ERR(chan))
3372                         return PTR_ERR(chan);
3373
3374                 hdev->smp_bredr_data = chan;
3375         } else {
3376                 struct l2cap_chan *chan;
3377
3378                 chan = hdev->smp_bredr_data;
3379                 hdev->smp_bredr_data = NULL;
3380                 smp_del_chan(chan);
3381         }
3382
3383         hci_dev_change_flag(hdev, HCI_FORCE_BREDR_SMP);
3384
3385         return count;
3386 }
3387
3388 static const struct file_operations force_bredr_smp_fops = {
3389         .open           = simple_open,
3390         .read           = force_bredr_smp_read,
3391         .write          = force_bredr_smp_write,
3392         .llseek         = default_llseek,
3393 };
3394
3395 static ssize_t le_min_key_size_read(struct file *file,
3396                                      char __user *user_buf,
3397                                      size_t count, loff_t *ppos)
3398 {
3399         struct hci_dev *hdev = file->private_data;
3400         char buf[4];
3401
3402         snprintf(buf, sizeof(buf), "%2u\n", hdev->le_min_key_size);
3403
3404         return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
3405 }
3406
3407 static ssize_t le_min_key_size_write(struct file *file,
3408                                       const char __user *user_buf,
3409                                       size_t count, loff_t *ppos)
3410 {
3411         struct hci_dev *hdev = file->private_data;
3412         char buf[32];
3413         size_t buf_size = min(count, (sizeof(buf) - 1));
3414         u8 key_size;
3415
3416         if (copy_from_user(buf, user_buf, buf_size))
3417                 return -EFAULT;
3418
3419         buf[buf_size] = '\0';
3420
3421         sscanf(buf, "%hhu", &key_size);
3422
3423         if (key_size > hdev->le_max_key_size ||
3424             key_size < SMP_MIN_ENC_KEY_SIZE)
3425                 return -EINVAL;
3426
3427         hdev->le_min_key_size = key_size;
3428
3429         return count;
3430 }
3431
3432 static const struct file_operations le_min_key_size_fops = {
3433         .open           = simple_open,
3434         .read           = le_min_key_size_read,
3435         .write          = le_min_key_size_write,
3436         .llseek         = default_llseek,
3437 };
3438
3439 static ssize_t le_max_key_size_read(struct file *file,
3440                                      char __user *user_buf,
3441                                      size_t count, loff_t *ppos)
3442 {
3443         struct hci_dev *hdev = file->private_data;
3444         char buf[4];
3445
3446         snprintf(buf, sizeof(buf), "%2u\n", hdev->le_max_key_size);
3447
3448         return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
3449 }
3450
3451 static ssize_t le_max_key_size_write(struct file *file,
3452                                       const char __user *user_buf,
3453                                       size_t count, loff_t *ppos)
3454 {
3455         struct hci_dev *hdev = file->private_data;
3456         char buf[32];
3457         size_t buf_size = min(count, (sizeof(buf) - 1));
3458         u8 key_size;
3459
3460         if (copy_from_user(buf, user_buf, buf_size))
3461                 return -EFAULT;
3462
3463         buf[buf_size] = '\0';
3464
3465         sscanf(buf, "%hhu", &key_size);
3466
3467         if (key_size > SMP_MAX_ENC_KEY_SIZE ||
3468             key_size < hdev->le_min_key_size)
3469                 return -EINVAL;
3470
3471         hdev->le_max_key_size = key_size;
3472
3473         return count;
3474 }
3475
3476 static const struct file_operations le_max_key_size_fops = {
3477         .open           = simple_open,
3478         .read           = le_max_key_size_read,
3479         .write          = le_max_key_size_write,
3480         .llseek         = default_llseek,
3481 };
3482
3483 int smp_register(struct hci_dev *hdev)
3484 {
3485         struct l2cap_chan *chan;
3486
3487         BT_DBG("%s", hdev->name);
3488
3489         /* If the controller does not support Low Energy operation, then
3490          * there is also no need to register any SMP channel.
3491          */
3492         if (!lmp_le_capable(hdev))
3493                 return 0;
3494
3495         if (WARN_ON(hdev->smp_data)) {
3496                 chan = hdev->smp_data;
3497                 hdev->smp_data = NULL;
3498                 smp_del_chan(chan);
3499         }
3500
3501         chan = smp_add_cid(hdev, L2CAP_CID_SMP);
3502         if (IS_ERR(chan))
3503                 return PTR_ERR(chan);
3504
3505         hdev->smp_data = chan;
3506
3507         debugfs_create_file("le_min_key_size", 0644, hdev->debugfs, hdev,
3508                             &le_min_key_size_fops);
3509         debugfs_create_file("le_max_key_size", 0644, hdev->debugfs, hdev,
3510                             &le_max_key_size_fops);
3511
3512         /* If the controller does not support BR/EDR Secure Connections
3513          * feature, then the BR/EDR SMP channel shall not be present.
3514          *
3515          * To test this with Bluetooth 4.0 controllers, create a debugfs
3516          * switch that allows forcing BR/EDR SMP support and accepting
3517          * cross-transport pairing on non-AES encrypted connections.
3518          */
3519         if (!lmp_sc_capable(hdev)) {
3520                 debugfs_create_file("force_bredr_smp", 0644, hdev->debugfs,
3521                                     hdev, &force_bredr_smp_fops);
3522
3523                 /* Flag can be already set here (due to power toggle) */
3524                 if (!hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
3525                         return 0;
3526         }
3527
3528         if (WARN_ON(hdev->smp_bredr_data)) {
3529                 chan = hdev->smp_bredr_data;
3530                 hdev->smp_bredr_data = NULL;
3531                 smp_del_chan(chan);
3532         }
3533
3534         chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
3535         if (IS_ERR(chan)) {
3536                 int err = PTR_ERR(chan);
3537                 chan = hdev->smp_data;
3538                 hdev->smp_data = NULL;
3539                 smp_del_chan(chan);
3540                 return err;
3541         }
3542
3543         hdev->smp_bredr_data = chan;
3544
3545         return 0;
3546 }
3547
3548 void smp_unregister(struct hci_dev *hdev)
3549 {
3550         struct l2cap_chan *chan;
3551
3552         if (hdev->smp_bredr_data) {
3553                 chan = hdev->smp_bredr_data;
3554                 hdev->smp_bredr_data = NULL;
3555                 smp_del_chan(chan);
3556         }
3557
3558         if (hdev->smp_data) {
3559                 chan = hdev->smp_data;
3560                 hdev->smp_data = NULL;
3561                 smp_del_chan(chan);
3562         }
3563 }
3564
3565 #if IS_ENABLED(CONFIG_BT_SELFTEST_SMP)
3566
3567 static int __init test_debug_key(struct crypto_kpp *tfm_ecdh)
3568 {
3569         u8 pk[64];
3570         int err;
3571
3572         err = set_ecdh_privkey(tfm_ecdh, debug_sk);
3573         if (err)
3574                 return err;
3575
3576         err = generate_ecdh_public_key(tfm_ecdh, pk);
3577         if (err)
3578                 return err;
3579
3580         if (crypto_memneq(pk, debug_pk, 64))
3581                 return -EINVAL;
3582
3583         return 0;
3584 }
3585
3586 static int __init test_ah(struct crypto_cipher *tfm_aes)
3587 {
3588         const u8 irk[16] = {
3589                         0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3590                         0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3591         const u8 r[3] = { 0x94, 0x81, 0x70 };
3592         const u8 exp[3] = { 0xaa, 0xfb, 0x0d };
3593         u8 res[3];
3594         int err;
3595
3596         err = smp_ah(tfm_aes, irk, r, res);
3597         if (err)
3598                 return err;
3599
3600         if (crypto_memneq(res, exp, 3))
3601                 return -EINVAL;
3602
3603         return 0;
3604 }
3605
3606 static int __init test_c1(struct crypto_cipher *tfm_aes)
3607 {
3608         const u8 k[16] = {
3609                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3610                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
3611         const u8 r[16] = {
3612                         0xe0, 0x2e, 0x70, 0xc6, 0x4e, 0x27, 0x88, 0x63,
3613                         0x0e, 0x6f, 0xad, 0x56, 0x21, 0xd5, 0x83, 0x57 };
3614         const u8 preq[7] = { 0x01, 0x01, 0x00, 0x00, 0x10, 0x07, 0x07 };
3615         const u8 pres[7] = { 0x02, 0x03, 0x00, 0x00, 0x08, 0x00, 0x05 };
3616         const u8 _iat = 0x01;
3617         const u8 _rat = 0x00;
3618         const bdaddr_t ra = { { 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1 } };
3619         const bdaddr_t ia = { { 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1 } };
3620         const u8 exp[16] = {
3621                         0x86, 0x3b, 0xf1, 0xbe, 0xc5, 0x4d, 0xa7, 0xd2,
3622                         0xea, 0x88, 0x89, 0x87, 0xef, 0x3f, 0x1e, 0x1e };
3623         u8 res[16];
3624         int err;
3625
3626         err = smp_c1(tfm_aes, k, r, preq, pres, _iat, &ia, _rat, &ra, res);
3627         if (err)
3628                 return err;
3629
3630         if (crypto_memneq(res, exp, 16))
3631                 return -EINVAL;
3632
3633         return 0;
3634 }
3635
3636 static int __init test_s1(struct crypto_cipher *tfm_aes)
3637 {
3638         const u8 k[16] = {
3639                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3640                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
3641         const u8 r1[16] = {
3642                         0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 };
3643         const u8 r2[16] = {
3644                         0x00, 0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99 };
3645         const u8 exp[16] = {
3646                         0x62, 0xa0, 0x6d, 0x79, 0xae, 0x16, 0x42, 0x5b,
3647                         0x9b, 0xf4, 0xb0, 0xe8, 0xf0, 0xe1, 0x1f, 0x9a };
3648         u8 res[16];
3649         int err;
3650
3651         err = smp_s1(tfm_aes, k, r1, r2, res);
3652         if (err)
3653                 return err;
3654
3655         if (crypto_memneq(res, exp, 16))
3656                 return -EINVAL;
3657
3658         return 0;
3659 }
3660
3661 static int __init test_f4(struct crypto_shash *tfm_cmac)
3662 {
3663         const u8 u[32] = {
3664                         0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
3665                         0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
3666                         0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
3667                         0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20 };
3668         const u8 v[32] = {
3669                         0xfd, 0xc5, 0x7f, 0xf4, 0x49, 0xdd, 0x4f, 0x6b,
3670                         0xfb, 0x7c, 0x9d, 0xf1, 0xc2, 0x9a, 0xcb, 0x59,
3671                         0x2a, 0xe7, 0xd4, 0xee, 0xfb, 0xfc, 0x0a, 0x90,
3672                         0x9a, 0xbb, 0xf6, 0x32, 0x3d, 0x8b, 0x18, 0x55 };
3673         const u8 x[16] = {
3674                         0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3675                         0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3676         const u8 z = 0x00;
3677         const u8 exp[16] = {
3678                         0x2d, 0x87, 0x74, 0xa9, 0xbe, 0xa1, 0xed, 0xf1,
3679                         0x1c, 0xbd, 0xa9, 0x07, 0xf1, 0x16, 0xc9, 0xf2 };
3680         u8 res[16];
3681         int err;
3682
3683         err = smp_f4(tfm_cmac, u, v, x, z, res);
3684         if (err)
3685                 return err;
3686
3687         if (crypto_memneq(res, exp, 16))
3688                 return -EINVAL;
3689
3690         return 0;
3691 }
3692
3693 static int __init test_f5(struct crypto_shash *tfm_cmac)
3694 {
3695         const u8 w[32] = {
3696                         0x98, 0xa6, 0xbf, 0x73, 0xf3, 0x34, 0x8d, 0x86,
3697                         0xf1, 0x66, 0xf8, 0xb4, 0x13, 0x6b, 0x79, 0x99,
3698                         0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3699                         0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3700         const u8 n1[16] = {
3701                         0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3702                         0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3703         const u8 n2[16] = {
3704                         0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3705                         0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3706         const u8 a1[7] = { 0xce, 0xbf, 0x37, 0x37, 0x12, 0x56, 0x00 };
3707         const u8 a2[7] = { 0xc1, 0xcf, 0x2d, 0x70, 0x13, 0xa7, 0x00 };
3708         const u8 exp_ltk[16] = {
3709                         0x38, 0x0a, 0x75, 0x94, 0xb5, 0x22, 0x05, 0x98,
3710                         0x23, 0xcd, 0xd7, 0x69, 0x11, 0x79, 0x86, 0x69 };
3711         const u8 exp_mackey[16] = {
3712                         0x20, 0x6e, 0x63, 0xce, 0x20, 0x6a, 0x3f, 0xfd,
3713                         0x02, 0x4a, 0x08, 0xa1, 0x76, 0xf1, 0x65, 0x29 };
3714         u8 mackey[16], ltk[16];
3715         int err;
3716
3717         err = smp_f5(tfm_cmac, w, n1, n2, a1, a2, mackey, ltk);
3718         if (err)
3719                 return err;
3720
3721         if (crypto_memneq(mackey, exp_mackey, 16))
3722                 return -EINVAL;
3723
3724         if (crypto_memneq(ltk, exp_ltk, 16))
3725                 return -EINVAL;
3726
3727         return 0;
3728 }
3729
3730 static int __init test_f6(struct crypto_shash *tfm_cmac)
3731 {
3732         const u8 w[16] = {
3733                         0x20, 0x6e, 0x63, 0xce, 0x20, 0x6a, 0x3f, 0xfd,
3734                         0x02, 0x4a, 0x08, 0xa1, 0x76, 0xf1, 0x65, 0x29 };
3735         const u8 n1[16] = {
3736                         0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3737                         0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3738         const u8 n2[16] = {
3739                         0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3740                         0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3741         const u8 r[16] = {
3742                         0xc8, 0x0f, 0x2d, 0x0c, 0xd2, 0x42, 0xda, 0x08,
3743                         0x54, 0xbb, 0x53, 0xb4, 0x3b, 0x34, 0xa3, 0x12 };
3744         const u8 io_cap[3] = { 0x02, 0x01, 0x01 };
3745         const u8 a1[7] = { 0xce, 0xbf, 0x37, 0x37, 0x12, 0x56, 0x00 };
3746         const u8 a2[7] = { 0xc1, 0xcf, 0x2d, 0x70, 0x13, 0xa7, 0x00 };
3747         const u8 exp[16] = {
3748                         0x61, 0x8f, 0x95, 0xda, 0x09, 0x0b, 0x6c, 0xd2,
3749                         0xc5, 0xe8, 0xd0, 0x9c, 0x98, 0x73, 0xc4, 0xe3 };
3750         u8 res[16];
3751         int err;
3752
3753         err = smp_f6(tfm_cmac, w, n1, n2, r, io_cap, a1, a2, res);
3754         if (err)
3755                 return err;
3756
3757         if (crypto_memneq(res, exp, 16))
3758                 return -EINVAL;
3759
3760         return 0;
3761 }
3762
3763 static int __init test_g2(struct crypto_shash *tfm_cmac)
3764 {
3765         const u8 u[32] = {
3766                         0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
3767                         0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
3768                         0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
3769                         0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20 };
3770         const u8 v[32] = {
3771                         0xfd, 0xc5, 0x7f, 0xf4, 0x49, 0xdd, 0x4f, 0x6b,
3772                         0xfb, 0x7c, 0x9d, 0xf1, 0xc2, 0x9a, 0xcb, 0x59,
3773                         0x2a, 0xe7, 0xd4, 0xee, 0xfb, 0xfc, 0x0a, 0x90,
3774                         0x9a, 0xbb, 0xf6, 0x32, 0x3d, 0x8b, 0x18, 0x55 };
3775         const u8 x[16] = {
3776                         0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3777                         0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3778         const u8 y[16] = {
3779                         0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3780                         0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3781         const u32 exp_val = 0x2f9ed5ba % 1000000;
3782         u32 val;
3783         int err;
3784
3785         err = smp_g2(tfm_cmac, u, v, x, y, &val);
3786         if (err)
3787                 return err;
3788
3789         if (val != exp_val)
3790                 return -EINVAL;
3791
3792         return 0;
3793 }
3794
3795 static int __init test_h6(struct crypto_shash *tfm_cmac)
3796 {
3797         const u8 w[16] = {
3798                         0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3799                         0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3800         const u8 key_id[4] = { 0x72, 0x62, 0x65, 0x6c };
3801         const u8 exp[16] = {
3802                         0x99, 0x63, 0xb1, 0x80, 0xe2, 0xa9, 0xd3, 0xe8,
3803                         0x1c, 0xc9, 0x6d, 0xe7, 0x02, 0xe1, 0x9a, 0x2d };
3804         u8 res[16];
3805         int err;
3806
3807         err = smp_h6(tfm_cmac, w, key_id, res);
3808         if (err)
3809                 return err;
3810
3811         if (crypto_memneq(res, exp, 16))
3812                 return -EINVAL;
3813
3814         return 0;
3815 }
3816
3817 static char test_smp_buffer[32];
3818
3819 static ssize_t test_smp_read(struct file *file, char __user *user_buf,
3820                              size_t count, loff_t *ppos)
3821 {
3822         return simple_read_from_buffer(user_buf, count, ppos, test_smp_buffer,
3823                                        strlen(test_smp_buffer));
3824 }
3825
3826 static const struct file_operations test_smp_fops = {
3827         .open           = simple_open,
3828         .read           = test_smp_read,
3829         .llseek         = default_llseek,
3830 };
3831
3832 static int __init run_selftests(struct crypto_cipher *tfm_aes,
3833                                 struct crypto_shash *tfm_cmac,
3834                                 struct crypto_kpp *tfm_ecdh)
3835 {
3836         ktime_t calltime, delta, rettime;
3837         unsigned long long duration;
3838         int err;
3839
3840         calltime = ktime_get();
3841
3842         err = test_debug_key(tfm_ecdh);
3843         if (err) {
3844                 BT_ERR("debug_key test failed");
3845                 goto done;
3846         }
3847
3848         err = test_ah(tfm_aes);
3849         if (err) {
3850                 BT_ERR("smp_ah test failed");
3851                 goto done;
3852         }
3853
3854         err = test_c1(tfm_aes);
3855         if (err) {
3856                 BT_ERR("smp_c1 test failed");
3857                 goto done;
3858         }
3859
3860         err = test_s1(tfm_aes);
3861         if (err) {
3862                 BT_ERR("smp_s1 test failed");
3863                 goto done;
3864         }
3865
3866         err = test_f4(tfm_cmac);
3867         if (err) {
3868                 BT_ERR("smp_f4 test failed");
3869                 goto done;
3870         }
3871
3872         err = test_f5(tfm_cmac);
3873         if (err) {
3874                 BT_ERR("smp_f5 test failed");
3875                 goto done;
3876         }
3877
3878         err = test_f6(tfm_cmac);
3879         if (err) {
3880                 BT_ERR("smp_f6 test failed");
3881                 goto done;
3882         }
3883
3884         err = test_g2(tfm_cmac);
3885         if (err) {
3886                 BT_ERR("smp_g2 test failed");
3887                 goto done;
3888         }
3889
3890         err = test_h6(tfm_cmac);
3891         if (err) {
3892                 BT_ERR("smp_h6 test failed");
3893                 goto done;
3894         }
3895
3896         rettime = ktime_get();
3897         delta = ktime_sub(rettime, calltime);
3898         duration = (unsigned long long) ktime_to_ns(delta) >> 10;
3899
3900         BT_INFO("SMP test passed in %llu usecs", duration);
3901
3902 done:
3903         if (!err)
3904                 snprintf(test_smp_buffer, sizeof(test_smp_buffer),
3905                          "PASS (%llu usecs)\n", duration);
3906         else
3907                 snprintf(test_smp_buffer, sizeof(test_smp_buffer), "FAIL\n");
3908
3909         debugfs_create_file("selftest_smp", 0444, bt_debugfs, NULL,
3910                             &test_smp_fops);
3911
3912         return err;
3913 }
3914
3915 int __init bt_selftest_smp(void)
3916 {
3917         struct crypto_cipher *tfm_aes;
3918         struct crypto_shash *tfm_cmac;
3919         struct crypto_kpp *tfm_ecdh;
3920         int err;
3921
3922         tfm_aes = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
3923         if (IS_ERR(tfm_aes)) {
3924                 BT_ERR("Unable to create AES crypto context");
3925                 return PTR_ERR(tfm_aes);
3926         }
3927
3928         tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, CRYPTO_ALG_ASYNC);
3929         if (IS_ERR(tfm_cmac)) {
3930                 BT_ERR("Unable to create CMAC crypto context");
3931                 crypto_free_cipher(tfm_aes);
3932                 return PTR_ERR(tfm_cmac);
3933         }
3934
3935         tfm_ecdh = crypto_alloc_kpp("ecdh", CRYPTO_ALG_INTERNAL, 0);
3936         if (IS_ERR(tfm_ecdh)) {
3937                 BT_ERR("Unable to create ECDH crypto context");
3938                 crypto_free_shash(tfm_cmac);
3939                 crypto_free_cipher(tfm_aes);
3940                 return PTR_ERR(tfm_ecdh);
3941         }
3942
3943         err = run_selftests(tfm_aes, tfm_cmac, tfm_ecdh);
3944
3945         crypto_free_shash(tfm_cmac);
3946         crypto_free_cipher(tfm_aes);
3947         crypto_free_kpp(tfm_ecdh);
3948
3949         return err;
3950 }
3951
3952 #endif