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