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