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