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         /* Check if remote and local public keys are the same and debug key is
2707          * not in use.
2708          */
2709         if (!test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags) &&
2710             !crypto_memneq(key, smp->local_pk, 64)) {
2711                 bt_dev_err(hdev, "Remote and local public keys are identical");
2712                 return SMP_UNSPECIFIED;
2713         }
2714
2715         memcpy(smp->remote_pk, key, 64);
2716
2717         if (test_bit(SMP_FLAG_REMOTE_OOB, &smp->flags)) {
2718                 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->remote_pk,
2719                              smp->rr, 0, cfm.confirm_val);
2720                 if (err)
2721                         return SMP_UNSPECIFIED;
2722
2723                 if (crypto_memneq(cfm.confirm_val, smp->pcnf, 16))
2724                         return SMP_CONFIRM_FAILED;
2725         }
2726
2727         /* Non-initiating device sends its public key after receiving
2728          * the key from the initiating device.
2729          */
2730         if (!hcon->out) {
2731                 err = sc_send_public_key(smp);
2732                 if (err)
2733                         return err;
2734         }
2735
2736         SMP_DBG("Remote Public Key X: %32phN", smp->remote_pk);
2737         SMP_DBG("Remote Public Key Y: %32phN", smp->remote_pk + 32);
2738
2739         /* Compute the shared secret on the same crypto tfm on which the private
2740          * key was set/generated.
2741          */
2742         if (test_bit(SMP_FLAG_LOCAL_OOB, &smp->flags)) {
2743                 struct l2cap_chan *hchan = hdev->smp_data;
2744                 struct smp_dev *smp_dev;
2745
2746                 if (!hchan || !hchan->data)
2747                         return SMP_UNSPECIFIED;
2748
2749                 smp_dev = hchan->data;
2750
2751                 tfm_ecdh = smp_dev->tfm_ecdh;
2752         } else {
2753                 tfm_ecdh = smp->tfm_ecdh;
2754         }
2755
2756         if (compute_ecdh_secret(tfm_ecdh, smp->remote_pk, smp->dhkey))
2757                 return SMP_UNSPECIFIED;
2758
2759         SMP_DBG("DHKey %32phN", smp->dhkey);
2760
2761         set_bit(SMP_FLAG_REMOTE_PK, &smp->flags);
2762
2763         smp->method = sc_select_method(smp);
2764
2765         BT_DBG("%s selected method 0x%02x", hdev->name, smp->method);
2766
2767         /* JUST_WORKS and JUST_CFM result in an unauthenticated key */
2768         if (smp->method == JUST_WORKS || smp->method == JUST_CFM)
2769                 hcon->pending_sec_level = BT_SECURITY_MEDIUM;
2770         else
2771                 hcon->pending_sec_level = BT_SECURITY_FIPS;
2772
2773         if (!crypto_memneq(debug_pk, smp->remote_pk, 64))
2774                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
2775
2776         if (smp->method == DSP_PASSKEY) {
2777                 get_random_bytes(&hcon->passkey_notify,
2778                                  sizeof(hcon->passkey_notify));
2779                 hcon->passkey_notify %= 1000000;
2780                 hcon->passkey_entered = 0;
2781                 smp->passkey_round = 0;
2782                 if (mgmt_user_passkey_notify(hdev, &hcon->dst, hcon->type,
2783                                              hcon->dst_type,
2784                                              hcon->passkey_notify,
2785                                              hcon->passkey_entered))
2786                         return SMP_UNSPECIFIED;
2787                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2788                 return sc_passkey_round(smp, SMP_CMD_PUBLIC_KEY);
2789         }
2790
2791         if (smp->method == REQ_OOB) {
2792                 if (hcon->out)
2793                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
2794                                      sizeof(smp->prnd), smp->prnd);
2795
2796                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2797
2798                 return 0;
2799         }
2800
2801         if (hcon->out)
2802                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2803
2804         if (smp->method == REQ_PASSKEY) {
2805                 if (mgmt_user_passkey_request(hdev, &hcon->dst, hcon->type,
2806                                               hcon->dst_type))
2807                         return SMP_UNSPECIFIED;
2808                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2809                 set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2810                 return 0;
2811         }
2812
2813         /* The Initiating device waits for the non-initiating device to
2814          * send the confirm value.
2815          */
2816         if (conn->hcon->out)
2817                 return 0;
2818
2819         err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd,
2820                      0, cfm.confirm_val);
2821         if (err)
2822                 return SMP_UNSPECIFIED;
2823
2824         smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
2825         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2826
2827         return 0;
2828 }
2829
2830 static int smp_cmd_dhkey_check(struct l2cap_conn *conn, struct sk_buff *skb)
2831 {
2832         struct smp_cmd_dhkey_check *check = (void *) skb->data;
2833         struct l2cap_chan *chan = conn->smp;
2834         struct hci_conn *hcon = conn->hcon;
2835         struct smp_chan *smp = chan->data;
2836         u8 a[7], b[7], *local_addr, *remote_addr;
2837         u8 io_cap[3], r[16], e[16];
2838         int err;
2839
2840         BT_DBG("conn %p", conn);
2841
2842         if (skb->len < sizeof(*check))
2843                 return SMP_INVALID_PARAMS;
2844
2845         memcpy(a, &hcon->init_addr, 6);
2846         memcpy(b, &hcon->resp_addr, 6);
2847         a[6] = hcon->init_addr_type;
2848         b[6] = hcon->resp_addr_type;
2849
2850         if (hcon->out) {
2851                 local_addr = a;
2852                 remote_addr = b;
2853                 memcpy(io_cap, &smp->prsp[1], 3);
2854         } else {
2855                 local_addr = b;
2856                 remote_addr = a;
2857                 memcpy(io_cap, &smp->preq[1], 3);
2858         }
2859
2860         memset(r, 0, sizeof(r));
2861
2862         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2863                 put_unaligned_le32(hcon->passkey_notify, r);
2864         else if (smp->method == REQ_OOB)
2865                 memcpy(r, smp->lr, 16);
2866
2867         err = smp_f6(smp->tfm_cmac, smp->mackey, smp->rrnd, smp->prnd, r,
2868                      io_cap, remote_addr, local_addr, e);
2869         if (err)
2870                 return SMP_UNSPECIFIED;
2871
2872         if (crypto_memneq(check->e, e, 16))
2873                 return SMP_DHKEY_CHECK_FAILED;
2874
2875         if (!hcon->out) {
2876                 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
2877                         set_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags);
2878                         return 0;
2879                 }
2880
2881                 /* Slave sends DHKey check as response to master */
2882                 sc_dhkey_check(smp);
2883         }
2884
2885         sc_add_ltk(smp);
2886
2887         if (hcon->out) {
2888                 hci_le_start_enc(hcon, 0, 0, smp->tk, smp->enc_key_size);
2889                 hcon->enc_key_size = smp->enc_key_size;
2890         }
2891
2892         return 0;
2893 }
2894
2895 static int smp_cmd_keypress_notify(struct l2cap_conn *conn,
2896                                    struct sk_buff *skb)
2897 {
2898         struct smp_cmd_keypress_notify *kp = (void *) skb->data;
2899
2900         BT_DBG("value 0x%02x", kp->value);
2901
2902         return 0;
2903 }
2904
2905 static int smp_sig_channel(struct l2cap_chan *chan, struct sk_buff *skb)
2906 {
2907         struct l2cap_conn *conn = chan->conn;
2908         struct hci_conn *hcon = conn->hcon;
2909         struct smp_chan *smp;
2910         __u8 code, reason;
2911         int err = 0;
2912
2913         if (skb->len < 1)
2914                 return -EILSEQ;
2915
2916         if (!hci_dev_test_flag(hcon->hdev, HCI_LE_ENABLED)) {
2917                 reason = SMP_PAIRING_NOTSUPP;
2918                 goto done;
2919         }
2920
2921         code = skb->data[0];
2922         skb_pull(skb, sizeof(code));
2923
2924         smp = chan->data;
2925
2926         if (code > SMP_CMD_MAX)
2927                 goto drop;
2928
2929         if (smp && !test_and_clear_bit(code, &smp->allow_cmd))
2930                 goto drop;
2931
2932         /* If we don't have a context the only allowed commands are
2933          * pairing request and security request.
2934          */
2935         if (!smp && code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ)
2936                 goto drop;
2937
2938         switch (code) {
2939         case SMP_CMD_PAIRING_REQ:
2940                 reason = smp_cmd_pairing_req(conn, skb);
2941                 break;
2942
2943         case SMP_CMD_PAIRING_FAIL:
2944                 smp_failure(conn, 0);
2945                 err = -EPERM;
2946                 break;
2947
2948         case SMP_CMD_PAIRING_RSP:
2949                 reason = smp_cmd_pairing_rsp(conn, skb);
2950                 break;
2951
2952         case SMP_CMD_SECURITY_REQ:
2953                 reason = smp_cmd_security_req(conn, skb);
2954                 break;
2955
2956         case SMP_CMD_PAIRING_CONFIRM:
2957                 reason = smp_cmd_pairing_confirm(conn, skb);
2958                 break;
2959
2960         case SMP_CMD_PAIRING_RANDOM:
2961                 reason = smp_cmd_pairing_random(conn, skb);
2962                 break;
2963
2964         case SMP_CMD_ENCRYPT_INFO:
2965                 reason = smp_cmd_encrypt_info(conn, skb);
2966                 break;
2967
2968         case SMP_CMD_MASTER_IDENT:
2969                 reason = smp_cmd_master_ident(conn, skb);
2970                 break;
2971
2972         case SMP_CMD_IDENT_INFO:
2973                 reason = smp_cmd_ident_info(conn, skb);
2974                 break;
2975
2976         case SMP_CMD_IDENT_ADDR_INFO:
2977                 reason = smp_cmd_ident_addr_info(conn, skb);
2978                 break;
2979
2980         case SMP_CMD_SIGN_INFO:
2981                 reason = smp_cmd_sign_info(conn, skb);
2982                 break;
2983
2984         case SMP_CMD_PUBLIC_KEY:
2985                 reason = smp_cmd_public_key(conn, skb);
2986                 break;
2987
2988         case SMP_CMD_DHKEY_CHECK:
2989                 reason = smp_cmd_dhkey_check(conn, skb);
2990                 break;
2991
2992         case SMP_CMD_KEYPRESS_NOTIFY:
2993                 reason = smp_cmd_keypress_notify(conn, skb);
2994                 break;
2995
2996         default:
2997                 BT_DBG("Unknown command code 0x%2.2x", code);
2998                 reason = SMP_CMD_NOTSUPP;
2999                 goto done;
3000         }
3001
3002 done:
3003         if (!err) {
3004                 if (reason)
3005                         smp_failure(conn, reason);
3006                 kfree_skb(skb);
3007         }
3008
3009         return err;
3010
3011 drop:
3012         bt_dev_err(hcon->hdev, "unexpected SMP command 0x%02x from %pMR",
3013                    code, &hcon->dst);
3014         kfree_skb(skb);
3015         return 0;
3016 }
3017
3018 static void smp_teardown_cb(struct l2cap_chan *chan, int err)
3019 {
3020         struct l2cap_conn *conn = chan->conn;
3021
3022         BT_DBG("chan %p", chan);
3023
3024         if (chan->data)
3025                 smp_chan_destroy(conn);
3026
3027         conn->smp = NULL;
3028         l2cap_chan_put(chan);
3029 }
3030
3031 static void bredr_pairing(struct l2cap_chan *chan)
3032 {
3033         struct l2cap_conn *conn = chan->conn;
3034         struct hci_conn *hcon = conn->hcon;
3035         struct hci_dev *hdev = hcon->hdev;
3036         struct smp_cmd_pairing req;
3037         struct smp_chan *smp;
3038
3039         BT_DBG("chan %p", chan);
3040
3041         /* Only new pairings are interesting */
3042         if (!test_bit(HCI_CONN_NEW_LINK_KEY, &hcon->flags))
3043                 return;
3044
3045         /* Don't bother if we're not encrypted */
3046         if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
3047                 return;
3048
3049         /* Only master may initiate SMP over BR/EDR */
3050         if (hcon->role != HCI_ROLE_MASTER)
3051                 return;
3052
3053         /* Secure Connections support must be enabled */
3054         if (!hci_dev_test_flag(hdev, HCI_SC_ENABLED))
3055                 return;
3056
3057         /* BR/EDR must use Secure Connections for SMP */
3058         if (!test_bit(HCI_CONN_AES_CCM, &hcon->flags) &&
3059             !hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
3060                 return;
3061
3062         /* If our LE support is not enabled don't do anything */
3063         if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED))
3064                 return;
3065
3066         /* Don't bother if remote LE support is not enabled */
3067         if (!lmp_host_le_capable(hcon))
3068                 return;
3069
3070         /* Remote must support SMP fixed chan for BR/EDR */
3071         if (!(conn->remote_fixed_chan & L2CAP_FC_SMP_BREDR))
3072                 return;
3073
3074         /* Don't bother if SMP is already ongoing */
3075         if (chan->data)
3076                 return;
3077
3078         smp = smp_chan_create(conn);
3079         if (!smp) {
3080                 bt_dev_err(hdev, "unable to create SMP context for BR/EDR");
3081                 return;
3082         }
3083
3084         set_bit(SMP_FLAG_SC, &smp->flags);
3085
3086         BT_DBG("%s starting SMP over BR/EDR", hdev->name);
3087
3088         /* Prepare and send the BR/EDR SMP Pairing Request */
3089         build_bredr_pairing_cmd(smp, &req, NULL);
3090
3091         smp->preq[0] = SMP_CMD_PAIRING_REQ;
3092         memcpy(&smp->preq[1], &req, sizeof(req));
3093
3094         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(req), &req);
3095         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
3096 }
3097
3098 static void smp_resume_cb(struct l2cap_chan *chan)
3099 {
3100         struct smp_chan *smp = chan->data;
3101         struct l2cap_conn *conn = chan->conn;
3102         struct hci_conn *hcon = conn->hcon;
3103
3104         BT_DBG("chan %p", chan);
3105
3106         if (hcon->type == ACL_LINK) {
3107                 bredr_pairing(chan);
3108                 return;
3109         }
3110
3111         if (!smp)
3112                 return;
3113
3114         if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
3115                 return;
3116
3117         cancel_delayed_work(&smp->security_timer);
3118
3119         smp_distribute_keys(smp);
3120 }
3121
3122 static void smp_ready_cb(struct l2cap_chan *chan)
3123 {
3124         struct l2cap_conn *conn = chan->conn;
3125         struct hci_conn *hcon = conn->hcon;
3126
3127         BT_DBG("chan %p", chan);
3128
3129         /* No need to call l2cap_chan_hold() here since we already own
3130          * the reference taken in smp_new_conn_cb(). This is just the
3131          * first time that we tie it to a specific pointer. The code in
3132          * l2cap_core.c ensures that there's no risk this function wont
3133          * get called if smp_new_conn_cb was previously called.
3134          */
3135         conn->smp = chan;
3136
3137         if (hcon->type == ACL_LINK && test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
3138                 bredr_pairing(chan);
3139 }
3140
3141 static int smp_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
3142 {
3143         int err;
3144
3145         BT_DBG("chan %p", chan);
3146
3147         err = smp_sig_channel(chan, skb);
3148         if (err) {
3149                 struct smp_chan *smp = chan->data;
3150
3151                 if (smp)
3152                         cancel_delayed_work_sync(&smp->security_timer);
3153
3154                 hci_disconnect(chan->conn->hcon, HCI_ERROR_AUTH_FAILURE);
3155         }
3156
3157         return err;
3158 }
3159
3160 static struct sk_buff *smp_alloc_skb_cb(struct l2cap_chan *chan,
3161                                         unsigned long hdr_len,
3162                                         unsigned long len, int nb)
3163 {
3164         struct sk_buff *skb;
3165
3166         skb = bt_skb_alloc(hdr_len + len, GFP_KERNEL);
3167         if (!skb)
3168                 return ERR_PTR(-ENOMEM);
3169
3170         skb->priority = HCI_PRIO_MAX;
3171         bt_cb(skb)->l2cap.chan = chan;
3172
3173         return skb;
3174 }
3175
3176 static const struct l2cap_ops smp_chan_ops = {
3177         .name                   = "Security Manager",
3178         .ready                  = smp_ready_cb,
3179         .recv                   = smp_recv_cb,
3180         .alloc_skb              = smp_alloc_skb_cb,
3181         .teardown               = smp_teardown_cb,
3182         .resume                 = smp_resume_cb,
3183
3184         .new_connection         = l2cap_chan_no_new_connection,
3185         .state_change           = l2cap_chan_no_state_change,
3186         .close                  = l2cap_chan_no_close,
3187         .defer                  = l2cap_chan_no_defer,
3188         .suspend                = l2cap_chan_no_suspend,
3189         .set_shutdown           = l2cap_chan_no_set_shutdown,
3190         .get_sndtimeo           = l2cap_chan_no_get_sndtimeo,
3191 };
3192
3193 static inline struct l2cap_chan *smp_new_conn_cb(struct l2cap_chan *pchan)
3194 {
3195         struct l2cap_chan *chan;
3196
3197         BT_DBG("pchan %p", pchan);
3198
3199         chan = l2cap_chan_create();
3200         if (!chan)
3201                 return NULL;
3202
3203         chan->chan_type = pchan->chan_type;
3204         chan->ops       = &smp_chan_ops;
3205         chan->scid      = pchan->scid;
3206         chan->dcid      = chan->scid;
3207         chan->imtu      = pchan->imtu;
3208         chan->omtu      = pchan->omtu;
3209         chan->mode      = pchan->mode;
3210
3211         /* Other L2CAP channels may request SMP routines in order to
3212          * change the security level. This means that the SMP channel
3213          * lock must be considered in its own category to avoid lockdep
3214          * warnings.
3215          */
3216         atomic_set(&chan->nesting, L2CAP_NESTING_SMP);
3217
3218         BT_DBG("created chan %p", chan);
3219
3220         return chan;
3221 }
3222
3223 static const struct l2cap_ops smp_root_chan_ops = {
3224         .name                   = "Security Manager Root",
3225         .new_connection         = smp_new_conn_cb,
3226
3227         /* None of these are implemented for the root channel */
3228         .close                  = l2cap_chan_no_close,
3229         .alloc_skb              = l2cap_chan_no_alloc_skb,
3230         .recv                   = l2cap_chan_no_recv,
3231         .state_change           = l2cap_chan_no_state_change,
3232         .teardown               = l2cap_chan_no_teardown,
3233         .ready                  = l2cap_chan_no_ready,
3234         .defer                  = l2cap_chan_no_defer,
3235         .suspend                = l2cap_chan_no_suspend,
3236         .resume                 = l2cap_chan_no_resume,
3237         .set_shutdown           = l2cap_chan_no_set_shutdown,
3238         .get_sndtimeo           = l2cap_chan_no_get_sndtimeo,
3239 };
3240
3241 static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
3242 {
3243         struct l2cap_chan *chan;
3244         struct smp_dev *smp;
3245         struct crypto_cipher *tfm_aes;
3246         struct crypto_shash *tfm_cmac;
3247         struct crypto_kpp *tfm_ecdh;
3248
3249         if (cid == L2CAP_CID_SMP_BREDR) {
3250                 smp = NULL;
3251                 goto create_chan;
3252         }
3253
3254         smp = kzalloc(sizeof(*smp), GFP_KERNEL);
3255         if (!smp)
3256                 return ERR_PTR(-ENOMEM);
3257
3258         tfm_aes = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
3259         if (IS_ERR(tfm_aes)) {
3260                 BT_ERR("Unable to create AES crypto context");
3261                 kzfree(smp);
3262                 return ERR_CAST(tfm_aes);
3263         }
3264
3265         tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
3266         if (IS_ERR(tfm_cmac)) {
3267                 BT_ERR("Unable to create CMAC crypto context");
3268                 crypto_free_cipher(tfm_aes);
3269                 kzfree(smp);
3270                 return ERR_CAST(tfm_cmac);
3271         }
3272
3273         tfm_ecdh = crypto_alloc_kpp("ecdh", CRYPTO_ALG_INTERNAL, 0);
3274         if (IS_ERR(tfm_ecdh)) {
3275                 BT_ERR("Unable to create ECDH crypto context");
3276                 crypto_free_shash(tfm_cmac);
3277                 crypto_free_cipher(tfm_aes);
3278                 kzfree(smp);
3279                 return ERR_CAST(tfm_ecdh);
3280         }
3281
3282         smp->local_oob = false;
3283         smp->tfm_aes = tfm_aes;
3284         smp->tfm_cmac = tfm_cmac;
3285         smp->tfm_ecdh = tfm_ecdh;
3286
3287 create_chan:
3288         chan = l2cap_chan_create();
3289         if (!chan) {
3290                 if (smp) {
3291                         crypto_free_cipher(smp->tfm_aes);
3292                         crypto_free_shash(smp->tfm_cmac);
3293                         crypto_free_kpp(smp->tfm_ecdh);
3294                         kzfree(smp);
3295                 }
3296                 return ERR_PTR(-ENOMEM);
3297         }
3298
3299         chan->data = smp;
3300
3301         l2cap_add_scid(chan, cid);
3302
3303         l2cap_chan_set_defaults(chan);
3304
3305         if (cid == L2CAP_CID_SMP) {
3306                 u8 bdaddr_type;
3307
3308                 hci_copy_identity_address(hdev, &chan->src, &bdaddr_type);
3309
3310                 if (bdaddr_type == ADDR_LE_DEV_PUBLIC)
3311                         chan->src_type = BDADDR_LE_PUBLIC;
3312                 else
3313                         chan->src_type = BDADDR_LE_RANDOM;
3314         } else {
3315                 bacpy(&chan->src, &hdev->bdaddr);
3316                 chan->src_type = BDADDR_BREDR;
3317         }
3318
3319         chan->state = BT_LISTEN;
3320         chan->mode = L2CAP_MODE_BASIC;
3321         chan->imtu = L2CAP_DEFAULT_MTU;
3322         chan->ops = &smp_root_chan_ops;
3323
3324         /* Set correct nesting level for a parent/listening channel */
3325         atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
3326
3327         return chan;
3328 }
3329
3330 static void smp_del_chan(struct l2cap_chan *chan)
3331 {
3332         struct smp_dev *smp;
3333
3334         BT_DBG("chan %p", chan);
3335
3336         smp = chan->data;
3337         if (smp) {
3338                 chan->data = NULL;
3339                 crypto_free_cipher(smp->tfm_aes);
3340                 crypto_free_shash(smp->tfm_cmac);
3341                 crypto_free_kpp(smp->tfm_ecdh);
3342                 kzfree(smp);
3343         }
3344
3345         l2cap_chan_put(chan);
3346 }
3347
3348 static ssize_t force_bredr_smp_read(struct file *file,
3349                                     char __user *user_buf,
3350                                     size_t count, loff_t *ppos)
3351 {
3352         struct hci_dev *hdev = file->private_data;
3353         char buf[3];
3354
3355         buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP) ? 'Y': 'N';
3356         buf[1] = '\n';
3357         buf[2] = '\0';
3358         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
3359 }
3360
3361 static ssize_t force_bredr_smp_write(struct file *file,
3362                                      const char __user *user_buf,
3363                                      size_t count, loff_t *ppos)
3364 {
3365         struct hci_dev *hdev = file->private_data;
3366         bool enable;
3367         int err;
3368
3369         err = kstrtobool_from_user(user_buf, count, &enable);
3370         if (err)
3371                 return err;
3372
3373         if (enable == hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
3374                 return -EALREADY;
3375
3376         if (enable) {
3377                 struct l2cap_chan *chan;
3378
3379                 chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
3380                 if (IS_ERR(chan))
3381                         return PTR_ERR(chan);
3382
3383                 hdev->smp_bredr_data = chan;
3384         } else {
3385                 struct l2cap_chan *chan;
3386
3387                 chan = hdev->smp_bredr_data;
3388                 hdev->smp_bredr_data = NULL;
3389                 smp_del_chan(chan);
3390         }
3391
3392         hci_dev_change_flag(hdev, HCI_FORCE_BREDR_SMP);
3393
3394         return count;
3395 }
3396
3397 static const struct file_operations force_bredr_smp_fops = {
3398         .open           = simple_open,
3399         .read           = force_bredr_smp_read,
3400         .write          = force_bredr_smp_write,
3401         .llseek         = default_llseek,
3402 };
3403
3404 static ssize_t le_min_key_size_read(struct file *file,
3405                                      char __user *user_buf,
3406                                      size_t count, loff_t *ppos)
3407 {
3408         struct hci_dev *hdev = file->private_data;
3409         char buf[4];
3410
3411         snprintf(buf, sizeof(buf), "%2u\n", hdev->le_min_key_size);
3412
3413         return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
3414 }
3415
3416 static ssize_t le_min_key_size_write(struct file *file,
3417                                       const char __user *user_buf,
3418                                       size_t count, loff_t *ppos)
3419 {
3420         struct hci_dev *hdev = file->private_data;
3421         char buf[32];
3422         size_t buf_size = min(count, (sizeof(buf) - 1));
3423         u8 key_size;
3424
3425         if (copy_from_user(buf, user_buf, buf_size))
3426                 return -EFAULT;
3427
3428         buf[buf_size] = '\0';
3429
3430         sscanf(buf, "%hhu", &key_size);
3431
3432         if (key_size > hdev->le_max_key_size ||
3433             key_size < SMP_MIN_ENC_KEY_SIZE)
3434                 return -EINVAL;
3435
3436         hdev->le_min_key_size = key_size;
3437
3438         return count;
3439 }
3440
3441 static const struct file_operations le_min_key_size_fops = {
3442         .open           = simple_open,
3443         .read           = le_min_key_size_read,
3444         .write          = le_min_key_size_write,
3445         .llseek         = default_llseek,
3446 };
3447
3448 static ssize_t le_max_key_size_read(struct file *file,
3449                                      char __user *user_buf,
3450                                      size_t count, loff_t *ppos)
3451 {
3452         struct hci_dev *hdev = file->private_data;
3453         char buf[4];
3454
3455         snprintf(buf, sizeof(buf), "%2u\n", hdev->le_max_key_size);
3456
3457         return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
3458 }
3459
3460 static ssize_t le_max_key_size_write(struct file *file,
3461                                       const char __user *user_buf,
3462                                       size_t count, loff_t *ppos)
3463 {
3464         struct hci_dev *hdev = file->private_data;
3465         char buf[32];
3466         size_t buf_size = min(count, (sizeof(buf) - 1));
3467         u8 key_size;
3468
3469         if (copy_from_user(buf, user_buf, buf_size))
3470                 return -EFAULT;
3471
3472         buf[buf_size] = '\0';
3473
3474         sscanf(buf, "%hhu", &key_size);
3475
3476         if (key_size > SMP_MAX_ENC_KEY_SIZE ||
3477             key_size < hdev->le_min_key_size)
3478                 return -EINVAL;
3479
3480         hdev->le_max_key_size = key_size;
3481
3482         return count;
3483 }
3484
3485 static const struct file_operations le_max_key_size_fops = {
3486         .open           = simple_open,
3487         .read           = le_max_key_size_read,
3488         .write          = le_max_key_size_write,
3489         .llseek         = default_llseek,
3490 };
3491
3492 int smp_register(struct hci_dev *hdev)
3493 {
3494         struct l2cap_chan *chan;
3495
3496         BT_DBG("%s", hdev->name);
3497
3498         /* If the controller does not support Low Energy operation, then
3499          * there is also no need to register any SMP channel.
3500          */
3501         if (!lmp_le_capable(hdev))
3502                 return 0;
3503
3504         if (WARN_ON(hdev->smp_data)) {
3505                 chan = hdev->smp_data;
3506                 hdev->smp_data = NULL;
3507                 smp_del_chan(chan);
3508         }
3509
3510         chan = smp_add_cid(hdev, L2CAP_CID_SMP);
3511         if (IS_ERR(chan))
3512                 return PTR_ERR(chan);
3513
3514         hdev->smp_data = chan;
3515
3516         debugfs_create_file("le_min_key_size", 0644, hdev->debugfs, hdev,
3517                             &le_min_key_size_fops);
3518         debugfs_create_file("le_max_key_size", 0644, hdev->debugfs, hdev,
3519                             &le_max_key_size_fops);
3520
3521         /* If the controller does not support BR/EDR Secure Connections
3522          * feature, then the BR/EDR SMP channel shall not be present.
3523          *
3524          * To test this with Bluetooth 4.0 controllers, create a debugfs
3525          * switch that allows forcing BR/EDR SMP support and accepting
3526          * cross-transport pairing on non-AES encrypted connections.
3527          */
3528         if (!lmp_sc_capable(hdev)) {
3529                 debugfs_create_file("force_bredr_smp", 0644, hdev->debugfs,
3530                                     hdev, &force_bredr_smp_fops);
3531
3532                 /* Flag can be already set here (due to power toggle) */
3533                 if (!hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
3534                         return 0;
3535         }
3536
3537         if (WARN_ON(hdev->smp_bredr_data)) {
3538                 chan = hdev->smp_bredr_data;
3539                 hdev->smp_bredr_data = NULL;
3540                 smp_del_chan(chan);
3541         }
3542
3543         chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
3544         if (IS_ERR(chan)) {
3545                 int err = PTR_ERR(chan);
3546                 chan = hdev->smp_data;
3547                 hdev->smp_data = NULL;
3548                 smp_del_chan(chan);
3549                 return err;
3550         }
3551
3552         hdev->smp_bredr_data = chan;
3553
3554         return 0;
3555 }
3556
3557 void smp_unregister(struct hci_dev *hdev)
3558 {
3559         struct l2cap_chan *chan;
3560
3561         if (hdev->smp_bredr_data) {
3562                 chan = hdev->smp_bredr_data;
3563                 hdev->smp_bredr_data = NULL;
3564                 smp_del_chan(chan);
3565         }
3566
3567         if (hdev->smp_data) {
3568                 chan = hdev->smp_data;
3569                 hdev->smp_data = NULL;
3570                 smp_del_chan(chan);
3571         }
3572 }
3573
3574 #if IS_ENABLED(CONFIG_BT_SELFTEST_SMP)
3575
3576 static int __init test_debug_key(struct crypto_kpp *tfm_ecdh)
3577 {
3578         u8 pk[64];
3579         int err;
3580
3581         err = set_ecdh_privkey(tfm_ecdh, debug_sk);
3582         if (err)
3583                 return err;
3584
3585         err = generate_ecdh_public_key(tfm_ecdh, pk);
3586         if (err)
3587                 return err;
3588
3589         if (crypto_memneq(pk, debug_pk, 64))
3590                 return -EINVAL;
3591
3592         return 0;
3593 }
3594
3595 static int __init test_ah(struct crypto_cipher *tfm_aes)
3596 {
3597         const u8 irk[16] = {
3598                         0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3599                         0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3600         const u8 r[3] = { 0x94, 0x81, 0x70 };
3601         const u8 exp[3] = { 0xaa, 0xfb, 0x0d };
3602         u8 res[3];
3603         int err;
3604
3605         err = smp_ah(tfm_aes, irk, r, res);
3606         if (err)
3607                 return err;
3608
3609         if (crypto_memneq(res, exp, 3))
3610                 return -EINVAL;
3611
3612         return 0;
3613 }
3614
3615 static int __init test_c1(struct crypto_cipher *tfm_aes)
3616 {
3617         const u8 k[16] = {
3618                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3619                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
3620         const u8 r[16] = {
3621                         0xe0, 0x2e, 0x70, 0xc6, 0x4e, 0x27, 0x88, 0x63,
3622                         0x0e, 0x6f, 0xad, 0x56, 0x21, 0xd5, 0x83, 0x57 };
3623         const u8 preq[7] = { 0x01, 0x01, 0x00, 0x00, 0x10, 0x07, 0x07 };
3624         const u8 pres[7] = { 0x02, 0x03, 0x00, 0x00, 0x08, 0x00, 0x05 };
3625         const u8 _iat = 0x01;
3626         const u8 _rat = 0x00;
3627         const bdaddr_t ra = { { 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1 } };
3628         const bdaddr_t ia = { { 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1 } };
3629         const u8 exp[16] = {
3630                         0x86, 0x3b, 0xf1, 0xbe, 0xc5, 0x4d, 0xa7, 0xd2,
3631                         0xea, 0x88, 0x89, 0x87, 0xef, 0x3f, 0x1e, 0x1e };
3632         u8 res[16];
3633         int err;
3634
3635         err = smp_c1(tfm_aes, k, r, preq, pres, _iat, &ia, _rat, &ra, res);
3636         if (err)
3637                 return err;
3638
3639         if (crypto_memneq(res, exp, 16))
3640                 return -EINVAL;
3641
3642         return 0;
3643 }
3644
3645 static int __init test_s1(struct crypto_cipher *tfm_aes)
3646 {
3647         const u8 k[16] = {
3648                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3649                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
3650         const u8 r1[16] = {
3651                         0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 };
3652         const u8 r2[16] = {
3653                         0x00, 0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99 };
3654         const u8 exp[16] = {
3655                         0x62, 0xa0, 0x6d, 0x79, 0xae, 0x16, 0x42, 0x5b,
3656                         0x9b, 0xf4, 0xb0, 0xe8, 0xf0, 0xe1, 0x1f, 0x9a };
3657         u8 res[16];
3658         int err;
3659
3660         err = smp_s1(tfm_aes, k, r1, r2, res);
3661         if (err)
3662                 return err;
3663
3664         if (crypto_memneq(res, exp, 16))
3665                 return -EINVAL;
3666
3667         return 0;
3668 }
3669
3670 static int __init test_f4(struct crypto_shash *tfm_cmac)
3671 {
3672         const u8 u[32] = {
3673                         0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
3674                         0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
3675                         0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
3676                         0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20 };
3677         const u8 v[32] = {
3678                         0xfd, 0xc5, 0x7f, 0xf4, 0x49, 0xdd, 0x4f, 0x6b,
3679                         0xfb, 0x7c, 0x9d, 0xf1, 0xc2, 0x9a, 0xcb, 0x59,
3680                         0x2a, 0xe7, 0xd4, 0xee, 0xfb, 0xfc, 0x0a, 0x90,
3681                         0x9a, 0xbb, 0xf6, 0x32, 0x3d, 0x8b, 0x18, 0x55 };
3682         const u8 x[16] = {
3683                         0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3684                         0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3685         const u8 z = 0x00;
3686         const u8 exp[16] = {
3687                         0x2d, 0x87, 0x74, 0xa9, 0xbe, 0xa1, 0xed, 0xf1,
3688                         0x1c, 0xbd, 0xa9, 0x07, 0xf1, 0x16, 0xc9, 0xf2 };
3689         u8 res[16];
3690         int err;
3691
3692         err = smp_f4(tfm_cmac, u, v, x, z, res);
3693         if (err)
3694                 return err;
3695
3696         if (crypto_memneq(res, exp, 16))
3697                 return -EINVAL;
3698
3699         return 0;
3700 }
3701
3702 static int __init test_f5(struct crypto_shash *tfm_cmac)
3703 {
3704         const u8 w[32] = {
3705                         0x98, 0xa6, 0xbf, 0x73, 0xf3, 0x34, 0x8d, 0x86,
3706                         0xf1, 0x66, 0xf8, 0xb4, 0x13, 0x6b, 0x79, 0x99,
3707                         0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3708                         0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3709         const u8 n1[16] = {
3710                         0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3711                         0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3712         const u8 n2[16] = {
3713                         0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3714                         0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3715         const u8 a1[7] = { 0xce, 0xbf, 0x37, 0x37, 0x12, 0x56, 0x00 };
3716         const u8 a2[7] = { 0xc1, 0xcf, 0x2d, 0x70, 0x13, 0xa7, 0x00 };
3717         const u8 exp_ltk[16] = {
3718                         0x38, 0x0a, 0x75, 0x94, 0xb5, 0x22, 0x05, 0x98,
3719                         0x23, 0xcd, 0xd7, 0x69, 0x11, 0x79, 0x86, 0x69 };
3720         const u8 exp_mackey[16] = {
3721                         0x20, 0x6e, 0x63, 0xce, 0x20, 0x6a, 0x3f, 0xfd,
3722                         0x02, 0x4a, 0x08, 0xa1, 0x76, 0xf1, 0x65, 0x29 };
3723         u8 mackey[16], ltk[16];
3724         int err;
3725
3726         err = smp_f5(tfm_cmac, w, n1, n2, a1, a2, mackey, ltk);
3727         if (err)
3728                 return err;
3729
3730         if (crypto_memneq(mackey, exp_mackey, 16))
3731                 return -EINVAL;
3732
3733         if (crypto_memneq(ltk, exp_ltk, 16))
3734                 return -EINVAL;
3735
3736         return 0;
3737 }
3738
3739 static int __init test_f6(struct crypto_shash *tfm_cmac)
3740 {
3741         const u8 w[16] = {
3742                         0x20, 0x6e, 0x63, 0xce, 0x20, 0x6a, 0x3f, 0xfd,
3743                         0x02, 0x4a, 0x08, 0xa1, 0x76, 0xf1, 0x65, 0x29 };
3744         const u8 n1[16] = {
3745                         0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3746                         0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3747         const u8 n2[16] = {
3748                         0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3749                         0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3750         const u8 r[16] = {
3751                         0xc8, 0x0f, 0x2d, 0x0c, 0xd2, 0x42, 0xda, 0x08,
3752                         0x54, 0xbb, 0x53, 0xb4, 0x3b, 0x34, 0xa3, 0x12 };
3753         const u8 io_cap[3] = { 0x02, 0x01, 0x01 };
3754         const u8 a1[7] = { 0xce, 0xbf, 0x37, 0x37, 0x12, 0x56, 0x00 };
3755         const u8 a2[7] = { 0xc1, 0xcf, 0x2d, 0x70, 0x13, 0xa7, 0x00 };
3756         const u8 exp[16] = {
3757                         0x61, 0x8f, 0x95, 0xda, 0x09, 0x0b, 0x6c, 0xd2,
3758                         0xc5, 0xe8, 0xd0, 0x9c, 0x98, 0x73, 0xc4, 0xe3 };
3759         u8 res[16];
3760         int err;
3761
3762         err = smp_f6(tfm_cmac, w, n1, n2, r, io_cap, a1, a2, res);
3763         if (err)
3764                 return err;
3765
3766         if (crypto_memneq(res, exp, 16))
3767                 return -EINVAL;
3768
3769         return 0;
3770 }
3771
3772 static int __init test_g2(struct crypto_shash *tfm_cmac)
3773 {
3774         const u8 u[32] = {
3775                         0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
3776                         0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
3777                         0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
3778                         0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20 };
3779         const u8 v[32] = {
3780                         0xfd, 0xc5, 0x7f, 0xf4, 0x49, 0xdd, 0x4f, 0x6b,
3781                         0xfb, 0x7c, 0x9d, 0xf1, 0xc2, 0x9a, 0xcb, 0x59,
3782                         0x2a, 0xe7, 0xd4, 0xee, 0xfb, 0xfc, 0x0a, 0x90,
3783                         0x9a, 0xbb, 0xf6, 0x32, 0x3d, 0x8b, 0x18, 0x55 };
3784         const u8 x[16] = {
3785                         0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3786                         0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3787         const u8 y[16] = {
3788                         0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3789                         0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3790         const u32 exp_val = 0x2f9ed5ba % 1000000;
3791         u32 val;
3792         int err;
3793
3794         err = smp_g2(tfm_cmac, u, v, x, y, &val);
3795         if (err)
3796                 return err;
3797
3798         if (val != exp_val)
3799                 return -EINVAL;
3800
3801         return 0;
3802 }
3803
3804 static int __init test_h6(struct crypto_shash *tfm_cmac)
3805 {
3806         const u8 w[16] = {
3807                         0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3808                         0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3809         const u8 key_id[4] = { 0x72, 0x62, 0x65, 0x6c };
3810         const u8 exp[16] = {
3811                         0x99, 0x63, 0xb1, 0x80, 0xe2, 0xa9, 0xd3, 0xe8,
3812                         0x1c, 0xc9, 0x6d, 0xe7, 0x02, 0xe1, 0x9a, 0x2d };
3813         u8 res[16];
3814         int err;
3815
3816         err = smp_h6(tfm_cmac, w, key_id, res);
3817         if (err)
3818                 return err;
3819
3820         if (crypto_memneq(res, exp, 16))
3821                 return -EINVAL;
3822
3823         return 0;
3824 }
3825
3826 static char test_smp_buffer[32];
3827
3828 static ssize_t test_smp_read(struct file *file, char __user *user_buf,
3829                              size_t count, loff_t *ppos)
3830 {
3831         return simple_read_from_buffer(user_buf, count, ppos, test_smp_buffer,
3832                                        strlen(test_smp_buffer));
3833 }
3834
3835 static const struct file_operations test_smp_fops = {
3836         .open           = simple_open,
3837         .read           = test_smp_read,
3838         .llseek         = default_llseek,
3839 };
3840
3841 static int __init run_selftests(struct crypto_cipher *tfm_aes,
3842                                 struct crypto_shash *tfm_cmac,
3843                                 struct crypto_kpp *tfm_ecdh)
3844 {
3845         ktime_t calltime, delta, rettime;
3846         unsigned long long duration;
3847         int err;
3848
3849         calltime = ktime_get();
3850
3851         err = test_debug_key(tfm_ecdh);
3852         if (err) {
3853                 BT_ERR("debug_key test failed");
3854                 goto done;
3855         }
3856
3857         err = test_ah(tfm_aes);
3858         if (err) {
3859                 BT_ERR("smp_ah test failed");
3860                 goto done;
3861         }
3862
3863         err = test_c1(tfm_aes);
3864         if (err) {
3865                 BT_ERR("smp_c1 test failed");
3866                 goto done;
3867         }
3868
3869         err = test_s1(tfm_aes);
3870         if (err) {
3871                 BT_ERR("smp_s1 test failed");
3872                 goto done;
3873         }
3874
3875         err = test_f4(tfm_cmac);
3876         if (err) {
3877                 BT_ERR("smp_f4 test failed");
3878                 goto done;
3879         }
3880
3881         err = test_f5(tfm_cmac);
3882         if (err) {
3883                 BT_ERR("smp_f5 test failed");
3884                 goto done;
3885         }
3886
3887         err = test_f6(tfm_cmac);
3888         if (err) {
3889                 BT_ERR("smp_f6 test failed");
3890                 goto done;
3891         }
3892
3893         err = test_g2(tfm_cmac);
3894         if (err) {
3895                 BT_ERR("smp_g2 test failed");
3896                 goto done;
3897         }
3898
3899         err = test_h6(tfm_cmac);
3900         if (err) {
3901                 BT_ERR("smp_h6 test failed");
3902                 goto done;
3903         }
3904
3905         rettime = ktime_get();
3906         delta = ktime_sub(rettime, calltime);
3907         duration = (unsigned long long) ktime_to_ns(delta) >> 10;
3908
3909         BT_INFO("SMP test passed in %llu usecs", duration);
3910
3911 done:
3912         if (!err)
3913                 snprintf(test_smp_buffer, sizeof(test_smp_buffer),
3914                          "PASS (%llu usecs)\n", duration);
3915         else
3916                 snprintf(test_smp_buffer, sizeof(test_smp_buffer), "FAIL\n");
3917
3918         debugfs_create_file("selftest_smp", 0444, bt_debugfs, NULL,
3919                             &test_smp_fops);
3920
3921         return err;
3922 }
3923
3924 int __init bt_selftest_smp(void)
3925 {
3926         struct crypto_cipher *tfm_aes;
3927         struct crypto_shash *tfm_cmac;
3928         struct crypto_kpp *tfm_ecdh;
3929         int err;
3930
3931         tfm_aes = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
3932         if (IS_ERR(tfm_aes)) {
3933                 BT_ERR("Unable to create AES crypto context");
3934                 return PTR_ERR(tfm_aes);
3935         }
3936
3937         tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, CRYPTO_ALG_ASYNC);
3938         if (IS_ERR(tfm_cmac)) {
3939                 BT_ERR("Unable to create CMAC crypto context");
3940                 crypto_free_cipher(tfm_aes);
3941                 return PTR_ERR(tfm_cmac);
3942         }
3943
3944         tfm_ecdh = crypto_alloc_kpp("ecdh", CRYPTO_ALG_INTERNAL, 0);
3945         if (IS_ERR(tfm_ecdh)) {
3946                 BT_ERR("Unable to create ECDH crypto context");
3947                 crypto_free_shash(tfm_cmac);
3948                 crypto_free_cipher(tfm_aes);
3949                 return PTR_ERR(tfm_ecdh);
3950         }
3951
3952         err = run_selftests(tfm_aes, tfm_cmac, tfm_ecdh);
3953
3954         crypto_free_shash(tfm_cmac);
3955         crypto_free_cipher(tfm_aes);
3956         crypto_free_kpp(tfm_ecdh);
3957
3958         return err;
3959 }
3960
3961 #endif