net/bluetooth/smp.c

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