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/crypto.h>
  24 #include <linux/scatterlist.h>
  25 #include <crypto/b128ops.h>
  26
  27 #include <net/bluetooth/bluetooth.h>
  28 #include <net/bluetooth/hci_core.h>
  29 #include <net/bluetooth/l2cap.h>
  30 #include <net/bluetooth/mgmt.h>
  31
  32 #include "ecc.h"
  33 #include "smp.h"
  34
  35 /* Low-level debug macros to be used for stuff that we don't want
  36  * accidentially in dmesg, i.e. the values of the various crypto keys
  37  * and the inputs & outputs of crypto functions.
  38  */
  39 #ifdef DEBUG
  40 #define SMP_DBG(fmt, ...) printk(KERN_DEBUG "%s: " fmt, __func__, \
  41                                  ##__VA_ARGS__)
  42 #else
  43 #define SMP_DBG(fmt, ...) no_printk(KERN_DEBUG "%s: " fmt, __func__, \
  44                                     ##__VA_ARGS__)
  45 #endif
  46
  47 #define SMP_ALLOW_CMD(smp, code)        set_bit(code, &smp->allow_cmd)
  48
  49 /* Keys which are not distributed with Secure Connections */
  50 #define SMP_SC_NO_DIST (SMP_DIST_ENC_KEY | SMP_DIST_LINK_KEY);
  51
  52 #define SMP_TIMEOUT     msecs_to_jiffies(30000)
  53
  54 #define AUTH_REQ_MASK(dev)      (test_bit(HCI_SC_ENABLED, &(dev)->dev_flags) ? \
  55                                  0x1f : 0x07)
  56 #define KEY_DIST_MASK           0x07
  57
  58 /* Maximum message length that can be passed to aes_cmac */
  59 #define CMAC_MSG_MAX    80
  60
  61 enum {
  62         SMP_FLAG_TK_VALID,
  63         SMP_FLAG_CFM_PENDING,
  64         SMP_FLAG_MITM_AUTH,
  65         SMP_FLAG_COMPLETE,
  66         SMP_FLAG_INITIATOR,
  67         SMP_FLAG_SC,
  68         SMP_FLAG_REMOTE_PK,
  69         SMP_FLAG_DEBUG_KEY,
  70         SMP_FLAG_WAIT_USER,
  71         SMP_FLAG_DHKEY_PENDING,
  72         SMP_FLAG_OOB,
  73 };
  74
  75 struct smp_chan {
  76         struct l2cap_conn       *conn;
  77         struct delayed_work     security_timer;
  78         unsigned long           allow_cmd; /* Bitmask of allowed commands */
  79
  80         u8              preq[7]; /* SMP Pairing Request */
  81         u8              prsp[7]; /* SMP Pairing Response */
  82         u8              prnd[16]; /* SMP Pairing Random (local) */
  83         u8              rrnd[16]; /* SMP Pairing Random (remote) */
  84         u8              pcnf[16]; /* SMP Pairing Confirm */
  85         u8              tk[16]; /* SMP Temporary Key */
  86         u8              rr[16];
  87         u8              enc_key_size;
  88         u8              remote_key_dist;
  89         bdaddr_t        id_addr;
  90         u8              id_addr_type;
  91         u8              irk[16];
  92         struct smp_csrk *csrk;
  93         struct smp_csrk *slave_csrk;
  94         struct smp_ltk  *ltk;
  95         struct smp_ltk  *slave_ltk;
  96         struct smp_irk  *remote_irk;
  97         u8              *link_key;
  98         unsigned long   flags;
  99         u8              method;
 100         u8              passkey_round;
 101
 102         /* Secure Connections variables */
 103         u8                      local_pk[64];
 104         u8                      local_sk[32];
 105         u8                      remote_pk[64];
 106         u8                      dhkey[32];
 107         u8                      mackey[16];
 108
 109         struct crypto_blkcipher *tfm_aes;
 110         struct crypto_hash      *tfm_cmac;
 111 };
 112
 113 /* These debug key values are defined in the SMP section of the core
 114  * specification. debug_pk is the public debug key and debug_sk the
 115  * private debug key.
 116  */
 117 static const u8 debug_pk[64] = {
 118                 0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
 119                 0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
 120                 0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
 121                 0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20,
 122
 123                 0x8b, 0xd2, 0x89, 0x15, 0xd0, 0x8e, 0x1c, 0x74,
 124                 0x24, 0x30, 0xed, 0x8f, 0xc2, 0x45, 0x63, 0x76,
 125                 0x5c, 0x15, 0x52, 0x5a, 0xbf, 0x9a, 0x32, 0x63,
 126                 0x6d, 0xeb, 0x2a, 0x65, 0x49, 0x9c, 0x80, 0xdc,
 127 };
 128
 129 static const u8 debug_sk[32] = {
 130                 0xbd, 0x1a, 0x3c, 0xcd, 0xa6, 0xb8, 0x99, 0x58,
 131                 0x99, 0xb7, 0x40, 0xeb, 0x7b, 0x60, 0xff, 0x4a,
 132                 0x50, 0x3f, 0x10, 0xd2, 0xe3, 0xb3, 0xc9, 0x74,
 133                 0x38, 0x5f, 0xc5, 0xa3, 0xd4, 0xf6, 0x49, 0x3f,
 134 };
 135
 136 static inline void swap_buf(const u8 *src, u8 *dst, size_t len)
 137 {
 138         size_t i;
 139
 140         for (i = 0; i < len; i++)
 141                 dst[len - 1 - i] = src[i];
 142 }
 143
 144 /* The following functions map to the LE SC SMP crypto functions
 145  * AES-CMAC, f4, f5, f6, g2 and h6.
 146  */
 147
 148 static int aes_cmac(struct crypto_hash *tfm, const u8 k[16], const u8 *m,
 149                     size_t len, u8 mac[16])
 150 {
 151         uint8_t tmp[16], mac_msb[16], msg_msb[CMAC_MSG_MAX];
 152         struct hash_desc desc;
 153         struct scatterlist sg;
 154         int err;
 155
 156         if (len > CMAC_MSG_MAX)
 157                 return -EFBIG;
 158
 159         if (!tfm) {
 160                 BT_ERR("tfm %p", tfm);
 161                 return -EINVAL;
 162         }
 163
 164         desc.tfm = tfm;
 165         desc.flags = 0;
 166
 167         crypto_hash_init(&desc);
 168
 169         /* Swap key and message from LSB to MSB */
 170         swap_buf(k, tmp, 16);
 171         swap_buf(m, msg_msb, len);
 172
 173         SMP_DBG("msg (len %zu) %*phN", len, (int) len, m);
 174         SMP_DBG("key %16phN", k);
 175
 176         err = crypto_hash_setkey(tfm, tmp, 16);
 177         if (err) {
 178                 BT_ERR("cipher setkey failed: %d", err);
 179                 return err;
 180         }
 181
 182         sg_init_one(&sg, msg_msb, len);
 183
 184         err = crypto_hash_update(&desc, &sg, len);
 185         if (err) {
 186                 BT_ERR("Hash update error %d", err);
 187                 return err;
 188         }
 189
 190         err = crypto_hash_final(&desc, mac_msb);
 191         if (err) {
 192                 BT_ERR("Hash final error %d", err);
 193                 return err;
 194         }
 195
 196         swap_buf(mac_msb, mac, 16);
 197
 198         SMP_DBG("mac %16phN", mac);
 199
 200         return 0;
 201 }
 202
 203 static int smp_f4(struct crypto_hash *tfm_cmac, const u8 u[32], const u8 v[32],
 204                   const u8 x[16], u8 z, u8 res[16])
 205 {
 206         u8 m[65];
 207         int err;
 208
 209         SMP_DBG("u %32phN", u);
 210         SMP_DBG("v %32phN", v);
 211         SMP_DBG("x %16phN z %02x", x, z);
 212
 213         m[0] = z;
 214         memcpy(m + 1, v, 32);
 215         memcpy(m + 33, u, 32);
 216
 217         err = aes_cmac(tfm_cmac, x, m, sizeof(m), res);
 218         if (err)
 219                 return err;
 220
 221         SMP_DBG("res %16phN", res);
 222
 223         return err;
 224 }
 225
 226 static int smp_f5(struct crypto_hash *tfm_cmac, u8 w[32], u8 n1[16], u8 n2[16],
 227                   u8 a1[7], u8 a2[7], u8 mackey[16], u8 ltk[16])
 228 {
 229         /* The btle, salt and length "magic" values are as defined in
 230          * the SMP section of the Bluetooth core specification. In ASCII
 231          * the btle value ends up being 'btle'. The salt is just a
 232          * random number whereas length is the value 256 in little
 233          * endian format.
 234          */
 235         const u8 btle[4] = { 0x65, 0x6c, 0x74, 0x62 };
 236         const u8 salt[16] = { 0xbe, 0x83, 0x60, 0x5a, 0xdb, 0x0b, 0x37, 0x60,
 237                               0x38, 0xa5, 0xf5, 0xaa, 0x91, 0x83, 0x88, 0x6c };
 238         const u8 length[2] = { 0x00, 0x01 };
 239         u8 m[53], t[16];
 240         int err;
 241
 242         SMP_DBG("w %32phN", w);
 243         SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
 244         SMP_DBG("a1 %7phN a2 %7phN", a1, a2);
 245
 246         err = aes_cmac(tfm_cmac, salt, w, 32, t);
 247         if (err)
 248                 return err;
 249
 250         SMP_DBG("t %16phN", t);
 251
 252         memcpy(m, length, 2);
 253         memcpy(m + 2, a2, 7);
 254         memcpy(m + 9, a1, 7);
 255         memcpy(m + 16, n2, 16);
 256         memcpy(m + 32, n1, 16);
 257         memcpy(m + 48, btle, 4);
 258
 259         m[52] = 0; /* Counter */
 260
 261         err = aes_cmac(tfm_cmac, t, m, sizeof(m), mackey);
 262         if (err)
 263                 return err;
 264
 265         SMP_DBG("mackey %16phN", mackey);
 266
 267         m[52] = 1; /* Counter */
 268
 269         err = aes_cmac(tfm_cmac, t, m, sizeof(m), ltk);
 270         if (err)
 271                 return err;
 272
 273         SMP_DBG("ltk %16phN", ltk);
 274
 275         return 0;
 276 }
 277
 278 static int smp_f6(struct crypto_hash *tfm_cmac, const u8 w[16],
 279                   const u8 n1[16], u8 n2[16], const u8 r[16],
 280                   const u8 io_cap[3], const u8 a1[7], const u8 a2[7],
 281                   u8 res[16])
 282 {
 283         u8 m[65];
 284         int err;
 285
 286         SMP_DBG("w %16phN", w);
 287         SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
 288         SMP_DBG("r %16phN io_cap %3phN a1 %7phN a2 %7phN", r, io_cap, a1, a2);
 289
 290         memcpy(m, a2, 7);
 291         memcpy(m + 7, a1, 7);
 292         memcpy(m + 14, io_cap, 3);
 293         memcpy(m + 17, r, 16);
 294         memcpy(m + 33, n2, 16);
 295         memcpy(m + 49, n1, 16);
 296
 297         err = aes_cmac(tfm_cmac, w, m, sizeof(m), res);
 298         if (err)
 299                 return err;
 300
 301         BT_DBG("res %16phN", res);
 302
 303         return err;
 304 }
 305
 306 static int smp_g2(struct crypto_hash *tfm_cmac, const u8 u[32], const u8 v[32],
 307                   const u8 x[16], const u8 y[16], u32 *val)
 308 {
 309         u8 m[80], tmp[16];
 310         int err;
 311
 312         SMP_DBG("u %32phN", u);
 313         SMP_DBG("v %32phN", v);
 314         SMP_DBG("x %16phN y %16phN", x, y);
 315
 316         memcpy(m, y, 16);
 317         memcpy(m + 16, v, 32);
 318         memcpy(m + 48, u, 32);
 319
 320         err = aes_cmac(tfm_cmac, x, m, sizeof(m), tmp);
 321         if (err)
 322                 return err;
 323
 324         *val = get_unaligned_le32(tmp);
 325         *val %= 1000000;
 326
 327         SMP_DBG("val %06u", *val);
 328
 329         return 0;
 330 }
 331
 332 static int smp_h6(struct crypto_hash *tfm_cmac, const u8 w[16],
 333                   const u8 key_id[4], u8 res[16])
 334 {
 335         int err;
 336
 337         SMP_DBG("w %16phN key_id %4phN", w, key_id);
 338
 339         err = aes_cmac(tfm_cmac, w, key_id, 4, res);
 340         if (err)
 341                 return err;
 342
 343         SMP_DBG("res %16phN", res);
 344
 345         return err;
 346 }
 347
 348 /* The following functions map to the legacy SMP crypto functions e, c1,
 349  * s1 and ah.
 350  */
 351
 352 static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
 353 {
 354         struct blkcipher_desc desc;
 355         struct scatterlist sg;
 356         uint8_t tmp[16], data[16];
 357         int err;
 358
 359         if (!tfm) {
 360                 BT_ERR("tfm %p", tfm);
 361                 return -EINVAL;
 362         }
 363
 364         desc.tfm = tfm;
 365         desc.flags = 0;
 366
 367         /* The most significant octet of key corresponds to k[0] */
 368         swap_buf(k, tmp, 16);
 369
 370         err = crypto_blkcipher_setkey(tfm, tmp, 16);
 371         if (err) {
 372                 BT_ERR("cipher setkey failed: %d", err);
 373                 return err;
 374         }
 375
 376         /* Most significant octet of plaintextData corresponds to data[0] */
 377         swap_buf(r, data, 16);
 378
 379         sg_init_one(&sg, data, 16);
 380
 381         err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
 382         if (err)
 383                 BT_ERR("Encrypt data error %d", err);
 384
 385         /* Most significant octet of encryptedData corresponds to data[0] */
 386         swap_buf(data, r, 16);
 387
 388         return err;
 389 }
 390
 391 static int smp_c1(struct crypto_blkcipher *tfm_aes, const u8 k[16],
 392                   const u8 r[16], const u8 preq[7], const u8 pres[7], u8 _iat,
 393                   const bdaddr_t *ia, u8 _rat, const bdaddr_t *ra, u8 res[16])
 394 {
 395         u8 p1[16], p2[16];
 396         int err;
 397
 398         memset(p1, 0, 16);
 399
 400         /* p1 = pres || preq || _rat || _iat */
 401         p1[0] = _iat;
 402         p1[1] = _rat;
 403         memcpy(p1 + 2, preq, 7);
 404         memcpy(p1 + 9, pres, 7);
 405
 406         /* p2 = padding || ia || ra */
 407         memcpy(p2, ra, 6);
 408         memcpy(p2 + 6, ia, 6);
 409         memset(p2 + 12, 0, 4);
 410
 411         /* res = r XOR p1 */
 412         u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
 413
 414         /* res = e(k, res) */
 415         err = smp_e(tfm_aes, k, res);
 416         if (err) {
 417                 BT_ERR("Encrypt data error");
 418                 return err;
 419         }
 420
 421         /* res = res XOR p2 */
 422         u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
 423
 424         /* res = e(k, res) */
 425         err = smp_e(tfm_aes, k, res);
 426         if (err)
 427                 BT_ERR("Encrypt data error");
 428
 429         return err;
 430 }
 431
 432 static int smp_s1(struct crypto_blkcipher *tfm_aes, const u8 k[16],
 433                   const u8 r1[16], const u8 r2[16], u8 _r[16])
 434 {
 435         int err;
 436
 437         /* Just least significant octets from r1 and r2 are considered */
 438         memcpy(_r, r2, 8);
 439         memcpy(_r + 8, r1, 8);
 440
 441         err = smp_e(tfm_aes, k, _r);
 442         if (err)
 443                 BT_ERR("Encrypt data error");
 444
 445         return err;
 446 }
 447
 448 static int smp_ah(struct crypto_blkcipher *tfm, const u8 irk[16],
 449                   const u8 r[3], u8 res[3])
 450 {
 451         u8 _res[16];
 452         int err;
 453
 454         /* r' = padding || r */
 455         memcpy(_res, r, 3);
 456         memset(_res + 3, 0, 13);
 457
 458         err = smp_e(tfm, irk, _res);
 459         if (err) {
 460                 BT_ERR("Encrypt error");
 461                 return err;
 462         }
 463
 464         /* The output of the random address function ah is:
 465          *      ah(h, r) = e(k, r') mod 2^24
 466          * The output of the security function e is then truncated to 24 bits
 467          * by taking the least significant 24 bits of the output of e as the
 468          * result of ah.
 469          */
 470         memcpy(res, _res, 3);
 471
 472         return 0;
 473 }
 474
 475 bool smp_irk_matches(struct hci_dev *hdev, const u8 irk[16],
 476                      const bdaddr_t *bdaddr)
 477 {
 478         struct l2cap_chan *chan = hdev->smp_data;
 479         struct crypto_blkcipher *tfm;
 480         u8 hash[3];
 481         int err;
 482
 483         if (!chan || !chan->data)
 484                 return false;
 485
 486         tfm = chan->data;
 487
 488         BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);
 489
 490         err = smp_ah(tfm, irk, &bdaddr->b[3], hash);
 491         if (err)
 492                 return false;
 493
 494         return !memcmp(bdaddr->b, hash, 3);
 495 }
 496
 497 int smp_generate_rpa(struct hci_dev *hdev, const u8 irk[16], bdaddr_t *rpa)
 498 {
 499         struct l2cap_chan *chan = hdev->smp_data;
 500         struct crypto_blkcipher *tfm;
 501         int err;
 502
 503         if (!chan || !chan->data)
 504                 return -EOPNOTSUPP;
 505
 506         tfm = chan->data;
 507
 508         get_random_bytes(&rpa->b[3], 3);
 509
 510         rpa->b[5] &= 0x3f;      /* Clear two most significant bits */
 511         rpa->b[5] |= 0x40;      /* Set second most significant bit */
 512
 513         err = smp_ah(tfm, irk, &rpa->b[3], rpa->b);
 514         if (err < 0)
 515                 return err;
 516
 517         BT_DBG("RPA %pMR", rpa);
 518
 519         return 0;
 520 }
 521
 522 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
 523 {
 524         struct l2cap_chan *chan = conn->smp;
 525         struct smp_chan *smp;
 526         struct kvec iv[2];
 527         struct msghdr msg;
 528
 529         if (!chan)
 530                 return;
 531
 532         BT_DBG("code 0x%2.2x", code);
 533
 534         iv[0].iov_base = &code;
 535         iv[0].iov_len = 1;
 536
 537         iv[1].iov_base = data;
 538         iv[1].iov_len = len;
 539
 540         memset(&msg, 0, sizeof(msg));
 541
 542         msg.msg_iov = (struct iovec *) &iv;
 543         msg.msg_iovlen = 2;
 544
 545         l2cap_chan_send(chan, &msg, 1 + len);
 546
 547         if (!chan->data)
 548                 return;
 549
 550         smp = chan->data;
 551
 552         cancel_delayed_work_sync(&smp->security_timer);
 553         schedule_delayed_work(&smp->security_timer, SMP_TIMEOUT);
 554 }
 555
 556 static u8 authreq_to_seclevel(u8 authreq)
 557 {
 558         if (authreq & SMP_AUTH_MITM) {
 559                 if (authreq & SMP_AUTH_SC)
 560                         return BT_SECURITY_FIPS;
 561                 else
 562                         return BT_SECURITY_HIGH;
 563         } else {
 564                 return BT_SECURITY_MEDIUM;
 565         }
 566 }
 567
 568 static __u8 seclevel_to_authreq(__u8 sec_level)
 569 {
 570         switch (sec_level) {
 571         case BT_SECURITY_FIPS:
 572         case BT_SECURITY_HIGH:
 573                 return SMP_AUTH_MITM | SMP_AUTH_BONDING;
 574         case BT_SECURITY_MEDIUM:
 575                 return SMP_AUTH_BONDING;
 576         default:
 577                 return SMP_AUTH_NONE;
 578         }
 579 }
 580
 581 static void build_pairing_cmd(struct l2cap_conn *conn,
 582                               struct smp_cmd_pairing *req,
 583                               struct smp_cmd_pairing *rsp, __u8 authreq)
 584 {
 585         struct l2cap_chan *chan = conn->smp;
 586         struct smp_chan *smp = chan->data;
 587         struct hci_conn *hcon = conn->hcon;
 588         struct hci_dev *hdev = hcon->hdev;
 589         u8 local_dist = 0, remote_dist = 0, oob_flag = SMP_OOB_NOT_PRESENT;
 590
 591         if (test_bit(HCI_BONDABLE, &conn->hcon->hdev->dev_flags)) {
 592                 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
 593                 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
 594                 authreq |= SMP_AUTH_BONDING;
 595         } else {
 596                 authreq &= ~SMP_AUTH_BONDING;
 597         }
 598
 599         if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
 600                 remote_dist |= SMP_DIST_ID_KEY;
 601
 602         if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
 603                 local_dist |= SMP_DIST_ID_KEY;
 604
 605         if (test_bit(HCI_SC_ENABLED, &hdev->dev_flags) &&
 606             (authreq & SMP_AUTH_SC)) {
 607                 struct oob_data *oob_data;
 608                 u8 bdaddr_type;
 609
 610                 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) {
 611                         local_dist |= SMP_DIST_LINK_KEY;
 612                         remote_dist |= SMP_DIST_LINK_KEY;
 613                 }
 614
 615                 if (hcon->dst_type == ADDR_LE_DEV_PUBLIC)
 616                         bdaddr_type = BDADDR_LE_PUBLIC;
 617                 else
 618                         bdaddr_type = BDADDR_LE_RANDOM;
 619
 620                 oob_data = hci_find_remote_oob_data(hdev, &hcon->dst,
 621                                                     bdaddr_type);
 622                 if (oob_data) {
 623                         set_bit(SMP_FLAG_OOB, &smp->flags);
 624                         oob_flag = SMP_OOB_PRESENT;
 625                         memcpy(smp->rr, oob_data->rand256, 16);
 626                         memcpy(smp->pcnf, oob_data->hash256, 16);
 627                 }
 628
 629         } else {
 630                 authreq &= ~SMP_AUTH_SC;
 631         }
 632
 633         if (rsp == NULL) {
 634                 req->io_capability = conn->hcon->io_capability;
 635                 req->oob_flag = oob_flag;
 636                 req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 637                 req->init_key_dist = local_dist;
 638                 req->resp_key_dist = remote_dist;
 639                 req->auth_req = (authreq & AUTH_REQ_MASK(hdev));
 640
 641                 smp->remote_key_dist = remote_dist;
 642                 return;
 643         }
 644
 645         rsp->io_capability = conn->hcon->io_capability;
 646         rsp->oob_flag = oob_flag;
 647         rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 648         rsp->init_key_dist = req->init_key_dist & remote_dist;
 649         rsp->resp_key_dist = req->resp_key_dist & local_dist;
 650         rsp->auth_req = (authreq & AUTH_REQ_MASK(hdev));
 651
 652         smp->remote_key_dist = rsp->init_key_dist;
 653 }
 654
 655 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
 656 {
 657         struct l2cap_chan *chan = conn->smp;
 658         struct smp_chan *smp = chan->data;
 659
 660         if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
 661             (max_key_size < SMP_MIN_ENC_KEY_SIZE))
 662                 return SMP_ENC_KEY_SIZE;
 663
 664         smp->enc_key_size = max_key_size;
 665
 666         return 0;
 667 }
 668
 669 static void smp_chan_destroy(struct l2cap_conn *conn)
 670 {
 671         struct l2cap_chan *chan = conn->smp;
 672         struct smp_chan *smp = chan->data;
 673         struct hci_conn *hcon = conn->hcon;
 674         bool complete;
 675
 676         BUG_ON(!smp);
 677
 678         cancel_delayed_work_sync(&smp->security_timer);
 679
 680         complete = test_bit(SMP_FLAG_COMPLETE, &smp->flags);
 681         mgmt_smp_complete(hcon, complete);
 682
 683         kfree(smp->csrk);
 684         kfree(smp->slave_csrk);
 685         kfree(smp->link_key);
 686
 687         crypto_free_blkcipher(smp->tfm_aes);
 688         crypto_free_hash(smp->tfm_cmac);
 689
 690         /* Ensure that we don't leave any debug key around if debug key
 691          * support hasn't been explicitly enabled.
 692          */
 693         if (smp->ltk && smp->ltk->type == SMP_LTK_P256_DEBUG &&
 694             !test_bit(HCI_KEEP_DEBUG_KEYS, &hcon->hdev->dev_flags)) {
 695                 list_del_rcu(&smp->ltk->list);
 696                 kfree_rcu(smp->ltk, rcu);
 697                 smp->ltk = NULL;
 698         }
 699
 700         /* If pairing failed clean up any keys we might have */
 701         if (!complete) {
 702                 if (smp->ltk) {
 703                         list_del_rcu(&smp->ltk->list);
 704                         kfree_rcu(smp->ltk, rcu);
 705                 }
 706
 707                 if (smp->slave_ltk) {
 708                         list_del_rcu(&smp->slave_ltk->list);
 709                         kfree_rcu(smp->slave_ltk, rcu);
 710                 }
 711
 712                 if (smp->remote_irk) {
 713                         list_del_rcu(&smp->remote_irk->list);
 714                         kfree_rcu(smp->remote_irk, rcu);
 715                 }
 716         }
 717
 718         chan->data = NULL;
 719         kfree(smp);
 720         hci_conn_drop(hcon);
 721 }
 722
 723 static void smp_failure(struct l2cap_conn *conn, u8 reason)
 724 {
 725         struct hci_conn *hcon = conn->hcon;
 726         struct l2cap_chan *chan = conn->smp;
 727
 728         if (reason)
 729                 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
 730                              &reason);
 731
 732         clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags);
 733         mgmt_auth_failed(hcon, HCI_ERROR_AUTH_FAILURE);
 734
 735         if (chan->data)
 736                 smp_chan_destroy(conn);
 737 }
 738
 739 #define JUST_WORKS      0x00
 740 #define JUST_CFM        0x01
 741 #define REQ_PASSKEY     0x02
 742 #define CFM_PASSKEY     0x03
 743 #define REQ_OOB         0x04
 744 #define DSP_PASSKEY     0x05
 745 #define OVERLAP         0xFF
 746
 747 static const u8 gen_method[5][5] = {
 748         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 749         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 750         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 751         { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
 752         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP     },
 753 };
 754
 755 static const u8 sc_method[5][5] = {
 756         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 757         { JUST_WORKS,  CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 758         { DSP_PASSKEY, DSP_PASSKEY, REQ_PASSKEY, JUST_WORKS, DSP_PASSKEY },
 759         { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
 760         { DSP_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 761 };
 762
 763 static u8 get_auth_method(struct smp_chan *smp, u8 local_io, u8 remote_io)
 764 {
 765         /* If either side has unknown io_caps, use JUST_CFM (which gets
 766          * converted later to JUST_WORKS if we're initiators.
 767          */
 768         if (local_io > SMP_IO_KEYBOARD_DISPLAY ||
 769             remote_io > SMP_IO_KEYBOARD_DISPLAY)
 770                 return JUST_CFM;
 771
 772         if (test_bit(SMP_FLAG_SC, &smp->flags))
 773                 return sc_method[remote_io][local_io];
 774
 775         return gen_method[remote_io][local_io];
 776 }
 777
 778 static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
 779                                                 u8 local_io, u8 remote_io)
 780 {
 781         struct hci_conn *hcon = conn->hcon;
 782         struct l2cap_chan *chan = conn->smp;
 783         struct smp_chan *smp = chan->data;
 784         u32 passkey = 0;
 785         int ret = 0;
 786
 787         /* Initialize key for JUST WORKS */
 788         memset(smp->tk, 0, sizeof(smp->tk));
 789         clear_bit(SMP_FLAG_TK_VALID, &smp->flags);
 790
 791         BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
 792
 793         /* If neither side wants MITM, either "just" confirm an incoming
 794          * request or use just-works for outgoing ones. The JUST_CFM
 795          * will be converted to JUST_WORKS if necessary later in this
 796          * function. If either side has MITM look up the method from the
 797          * table.
 798          */
 799         if (!(auth & SMP_AUTH_MITM))
 800                 smp->method = JUST_CFM;
 801         else
 802                 smp->method = get_auth_method(smp, local_io, remote_io);
 803
 804         /* Don't confirm locally initiated pairing attempts */
 805         if (smp->method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR,
 806                                                 &smp->flags))
 807                 smp->method = JUST_WORKS;
 808
 809         /* Don't bother user space with no IO capabilities */
 810         if (smp->method == JUST_CFM &&
 811             hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
 812                 smp->method = JUST_WORKS;
 813
 814         /* If Just Works, Continue with Zero TK */
 815         if (smp->method == JUST_WORKS) {
 816                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
 817                 return 0;
 818         }
 819
 820         /* Not Just Works/Confirm results in MITM Authentication */
 821         if (smp->method != JUST_CFM) {
 822                 set_bit(SMP_FLAG_MITM_AUTH, &smp->flags);
 823                 if (hcon->pending_sec_level < BT_SECURITY_HIGH)
 824                         hcon->pending_sec_level = BT_SECURITY_HIGH;
 825         }
 826
 827         /* If both devices have Keyoard-Display I/O, the master
 828          * Confirms and the slave Enters the passkey.
 829          */
 830         if (smp->method == OVERLAP) {
 831                 if (hcon->role == HCI_ROLE_MASTER)
 832                         smp->method = CFM_PASSKEY;
 833                 else
 834                         smp->method = REQ_PASSKEY;
 835         }
 836
 837         /* Generate random passkey. */
 838         if (smp->method == CFM_PASSKEY) {
 839                 memset(smp->tk, 0, sizeof(smp->tk));
 840                 get_random_bytes(&passkey, sizeof(passkey));
 841                 passkey %= 1000000;
 842                 put_unaligned_le32(passkey, smp->tk);
 843                 BT_DBG("PassKey: %d", passkey);
 844                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
 845         }
 846
 847         if (smp->method == REQ_PASSKEY)
 848                 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
 849                                                 hcon->type, hcon->dst_type);
 850         else if (smp->method == JUST_CFM)
 851                 ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
 852                                                 hcon->type, hcon->dst_type,
 853                                                 passkey, 1);
 854         else
 855                 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
 856                                                 hcon->type, hcon->dst_type,
 857                                                 passkey, 0);
 858
 859         return ret;
 860 }
 861
 862 static u8 smp_confirm(struct smp_chan *smp)
 863 {
 864         struct l2cap_conn *conn = smp->conn;
 865         struct smp_cmd_pairing_confirm cp;
 866         int ret;
 867
 868         BT_DBG("conn %p", conn);
 869
 870         ret = smp_c1(smp->tfm_aes, smp->tk, smp->prnd, smp->preq, smp->prsp,
 871                      conn->hcon->init_addr_type, &conn->hcon->init_addr,
 872                      conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
 873                      cp.confirm_val);
 874         if (ret)
 875                 return SMP_UNSPECIFIED;
 876
 877         clear_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
 878
 879         smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
 880
 881         if (conn->hcon->out)
 882                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
 883         else
 884                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
 885
 886         return 0;
 887 }
 888
 889 static u8 smp_random(struct smp_chan *smp)
 890 {
 891         struct l2cap_conn *conn = smp->conn;
 892         struct hci_conn *hcon = conn->hcon;
 893         u8 confirm[16];
 894         int ret;
 895
 896         if (IS_ERR_OR_NULL(smp->tfm_aes))
 897                 return SMP_UNSPECIFIED;
 898
 899         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 900
 901         ret = smp_c1(smp->tfm_aes, smp->tk, smp->rrnd, smp->preq, smp->prsp,
 902                      hcon->init_addr_type, &hcon->init_addr,
 903                      hcon->resp_addr_type, &hcon->resp_addr, confirm);
 904         if (ret)
 905                 return SMP_UNSPECIFIED;
 906
 907         if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
 908                 BT_ERR("Pairing failed (confirmation values mismatch)");
 909                 return SMP_CONFIRM_FAILED;
 910         }
 911
 912         if (hcon->out) {
 913                 u8 stk[16];
 914                 __le64 rand = 0;
 915                 __le16 ediv = 0;
 916
 917                 smp_s1(smp->tfm_aes, smp->tk, smp->rrnd, smp->prnd, stk);
 918
 919                 memset(stk + smp->enc_key_size, 0,
 920                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 921
 922                 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
 923                         return SMP_UNSPECIFIED;
 924
 925                 hci_le_start_enc(hcon, ediv, rand, stk);
 926                 hcon->enc_key_size = smp->enc_key_size;
 927                 set_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
 928         } else {
 929                 u8 stk[16], auth;
 930                 __le64 rand = 0;
 931                 __le16 ediv = 0;
 932
 933                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
 934                              smp->prnd);
 935
 936                 smp_s1(smp->tfm_aes, smp->tk, smp->prnd, smp->rrnd, stk);
 937
 938                 memset(stk + smp->enc_key_size, 0,
 939                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 940
 941                 if (hcon->pending_sec_level == BT_SECURITY_HIGH)
 942                         auth = 1;
 943                 else
 944                         auth = 0;
 945
 946                 /* Even though there's no _SLAVE suffix this is the
 947                  * slave STK we're adding for later lookup (the master
 948                  * STK never needs to be stored).
 949                  */
 950                 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
 951                             SMP_STK, auth, stk, smp->enc_key_size, ediv, rand);
 952         }
 953
 954         return 0;
 955 }
 956
 957 static void smp_notify_keys(struct l2cap_conn *conn)
 958 {
 959         struct l2cap_chan *chan = conn->smp;
 960         struct smp_chan *smp = chan->data;
 961         struct hci_conn *hcon = conn->hcon;
 962         struct hci_dev *hdev = hcon->hdev;
 963         struct smp_cmd_pairing *req = (void *) &smp->preq[1];
 964         struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
 965         bool persistent;
 966
 967         if (smp->remote_irk) {
 968                 mgmt_new_irk(hdev, smp->remote_irk);
 969                 /* Now that user space can be considered to know the
 970                  * identity address track the connection based on it
 971                  * from now on (assuming this is an LE link).
 972                  */
 973                 if (hcon->type == LE_LINK) {
 974                         bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
 975                         hcon->dst_type = smp->remote_irk->addr_type;
 976                         queue_work(hdev->workqueue, &conn->id_addr_update_work);
 977                 }
 978
 979                 /* When receiving an indentity resolving key for
 980                  * a remote device that does not use a resolvable
 981                  * private address, just remove the key so that
 982                  * it is possible to use the controller white
 983                  * list for scanning.
 984                  *
 985                  * Userspace will have been told to not store
 986                  * this key at this point. So it is safe to
 987                  * just remove it.
 988                  */
 989                 if (!bacmp(&smp->remote_irk->rpa, BDADDR_ANY)) {
 990                         list_del_rcu(&smp->remote_irk->list);
 991                         kfree_rcu(smp->remote_irk, rcu);
 992                         smp->remote_irk = NULL;
 993                 }
 994         }
 995
 996         if (hcon->type == ACL_LINK) {
 997                 if (hcon->key_type == HCI_LK_DEBUG_COMBINATION)
 998                         persistent = false;
 999                 else
1000                         persistent = !test_bit(HCI_CONN_FLUSH_KEY,
1001                                                &hcon->flags);
1002         } else {
1003                 /* The LTKs and CSRKs should be persistent only if both sides
1004                  * had the bonding bit set in their authentication requests.
1005                  */
1006                 persistent = !!((req->auth_req & rsp->auth_req) &
1007                                 SMP_AUTH_BONDING);
1008         }
1009
1010
1011         if (smp->csrk) {
1012                 smp->csrk->bdaddr_type = hcon->dst_type;
1013                 bacpy(&smp->csrk->bdaddr, &hcon->dst);
1014                 mgmt_new_csrk(hdev, smp->csrk, persistent);
1015         }
1016
1017         if (smp->slave_csrk) {
1018                 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1019                 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
1020                 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
1021         }
1022
1023         if (smp->ltk) {
1024                 smp->ltk->bdaddr_type = hcon->dst_type;
1025                 bacpy(&smp->ltk->bdaddr, &hcon->dst);
1026                 mgmt_new_ltk(hdev, smp->ltk, persistent);
1027         }
1028
1029         if (smp->slave_ltk) {
1030                 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1031                 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
1032                 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
1033         }
1034
1035         if (smp->link_key) {
1036                 struct link_key *key;
1037                 u8 type;
1038
1039                 if (test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags))
1040                         type = HCI_LK_DEBUG_COMBINATION;
1041                 else if (hcon->sec_level == BT_SECURITY_FIPS)
1042                         type = HCI_LK_AUTH_COMBINATION_P256;
1043                 else
1044                         type = HCI_LK_UNAUTH_COMBINATION_P256;
1045
1046                 key = hci_add_link_key(hdev, smp->conn->hcon, &hcon->dst,
1047                                        smp->link_key, type, 0, &persistent);
1048                 if (key) {
1049                         mgmt_new_link_key(hdev, key, persistent);
1050
1051                         /* Don't keep debug keys around if the relevant
1052                          * flag is not set.
1053                          */
1054                         if (!test_bit(HCI_KEEP_DEBUG_KEYS, &hdev->dev_flags) &&
1055                             key->type == HCI_LK_DEBUG_COMBINATION) {
1056                                 list_del_rcu(&key->list);
1057                                 kfree_rcu(key, rcu);
1058                         }
1059                 }
1060         }
1061 }
1062
1063 static void sc_add_ltk(struct smp_chan *smp)
1064 {
1065         struct hci_conn *hcon = smp->conn->hcon;
1066         u8 key_type, auth;
1067
1068         if (test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags))
1069                 key_type = SMP_LTK_P256_DEBUG;
1070         else
1071                 key_type = SMP_LTK_P256;
1072
1073         if (hcon->pending_sec_level == BT_SECURITY_FIPS)
1074                 auth = 1;
1075         else
1076                 auth = 0;
1077
1078         memset(smp->tk + smp->enc_key_size, 0,
1079                SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
1080
1081         smp->ltk = hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
1082                                key_type, auth, smp->tk, smp->enc_key_size,
1083                                0, 0);
1084 }
1085
1086 static void sc_generate_link_key(struct smp_chan *smp)
1087 {
1088         /* These constants are as specified in the core specification.
1089          * In ASCII they spell out to 'tmp1' and 'lebr'.
1090          */
1091         const u8 tmp1[4] = { 0x31, 0x70, 0x6d, 0x74 };
1092         const u8 lebr[4] = { 0x72, 0x62, 0x65, 0x6c };
1093
1094         smp->link_key = kzalloc(16, GFP_KERNEL);
1095         if (!smp->link_key)
1096                 return;
1097
1098         if (smp_h6(smp->tfm_cmac, smp->tk, tmp1, smp->link_key)) {
1099                 kfree(smp->link_key);
1100                 smp->link_key = NULL;
1101                 return;
1102         }
1103
1104         if (smp_h6(smp->tfm_cmac, smp->link_key, lebr, smp->link_key)) {
1105                 kfree(smp->link_key);
1106                 smp->link_key = NULL;
1107                 return;
1108         }
1109 }
1110
1111 static void smp_allow_key_dist(struct smp_chan *smp)
1112 {
1113         /* Allow the first expected phase 3 PDU. The rest of the PDUs
1114          * will be allowed in each PDU handler to ensure we receive
1115          * them in the correct order.
1116          */
1117         if (smp->remote_key_dist & SMP_DIST_ENC_KEY)
1118                 SMP_ALLOW_CMD(smp, SMP_CMD_ENCRYPT_INFO);
1119         else if (smp->remote_key_dist & SMP_DIST_ID_KEY)
1120                 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
1121         else if (smp->remote_key_dist & SMP_DIST_SIGN)
1122                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
1123 }
1124
1125 static void sc_generate_ltk(struct smp_chan *smp)
1126 {
1127         /* These constants are as specified in the core specification.
1128          * In ASCII they spell out to 'tmp2' and 'brle'.
1129          */
1130         const u8 tmp2[4] = { 0x32, 0x70, 0x6d, 0x74 };
1131         const u8 brle[4] = { 0x65, 0x6c, 0x72, 0x62 };
1132         struct hci_conn *hcon = smp->conn->hcon;
1133         struct hci_dev *hdev = hcon->hdev;
1134         struct link_key *key;
1135
1136         key = hci_find_link_key(hdev, &hcon->dst);
1137         if (!key) {
1138                 BT_ERR("%s No Link Key found to generate LTK", hdev->name);
1139                 return;
1140         }
1141
1142         if (key->type == HCI_LK_DEBUG_COMBINATION)
1143                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1144
1145         if (smp_h6(smp->tfm_cmac, key->val, tmp2, smp->tk))
1146                 return;
1147
1148         if (smp_h6(smp->tfm_cmac, smp->tk, brle, smp->tk))
1149                 return;
1150
1151         sc_add_ltk(smp);
1152 }
1153
1154 static void smp_distribute_keys(struct smp_chan *smp)
1155 {
1156         struct smp_cmd_pairing *req, *rsp;
1157         struct l2cap_conn *conn = smp->conn;
1158         struct hci_conn *hcon = conn->hcon;
1159         struct hci_dev *hdev = hcon->hdev;
1160         __u8 *keydist;
1161
1162         BT_DBG("conn %p", conn);
1163
1164         rsp = (void *) &smp->prsp[1];
1165
1166         /* The responder sends its keys first */
1167         if (hcon->out && (smp->remote_key_dist & KEY_DIST_MASK)) {
1168                 smp_allow_key_dist(smp);
1169                 return;
1170         }
1171
1172         req = (void *) &smp->preq[1];
1173
1174         if (hcon->out) {
1175                 keydist = &rsp->init_key_dist;
1176                 *keydist &= req->init_key_dist;
1177         } else {
1178                 keydist = &rsp->resp_key_dist;
1179                 *keydist &= req->resp_key_dist;
1180         }
1181
1182         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1183                 if (hcon->type == LE_LINK && (*keydist & SMP_DIST_LINK_KEY))
1184                         sc_generate_link_key(smp);
1185                 if (hcon->type == ACL_LINK && (*keydist & SMP_DIST_ENC_KEY))
1186                         sc_generate_ltk(smp);
1187
1188                 /* Clear the keys which are generated but not distributed */
1189                 *keydist &= ~SMP_SC_NO_DIST;
1190         }
1191
1192         BT_DBG("keydist 0x%x", *keydist);
1193
1194         if (*keydist & SMP_DIST_ENC_KEY) {
1195                 struct smp_cmd_encrypt_info enc;
1196                 struct smp_cmd_master_ident ident;
1197                 struct smp_ltk *ltk;
1198                 u8 authenticated;
1199                 __le16 ediv;
1200                 __le64 rand;
1201
1202                 get_random_bytes(enc.ltk, sizeof(enc.ltk));
1203                 get_random_bytes(&ediv, sizeof(ediv));
1204                 get_random_bytes(&rand, sizeof(rand));
1205
1206                 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1207
1208                 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
1209                 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
1210                                   SMP_LTK_SLAVE, authenticated, enc.ltk,
1211                                   smp->enc_key_size, ediv, rand);
1212                 smp->slave_ltk = ltk;
1213
1214                 ident.ediv = ediv;
1215                 ident.rand = rand;
1216
1217                 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1218
1219                 *keydist &= ~SMP_DIST_ENC_KEY;
1220         }
1221
1222         if (*keydist & SMP_DIST_ID_KEY) {
1223                 struct smp_cmd_ident_addr_info addrinfo;
1224                 struct smp_cmd_ident_info idinfo;
1225
1226                 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
1227
1228                 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1229
1230                 /* The hci_conn contains the local identity address
1231                  * after the connection has been established.
1232                  *
1233                  * This is true even when the connection has been
1234                  * established using a resolvable random address.
1235                  */
1236                 bacpy(&addrinfo.bdaddr, &hcon->src);
1237                 addrinfo.addr_type = hcon->src_type;
1238
1239                 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1240                              &addrinfo);
1241
1242                 *keydist &= ~SMP_DIST_ID_KEY;
1243         }
1244
1245         if (*keydist & SMP_DIST_SIGN) {
1246                 struct smp_cmd_sign_info sign;
1247                 struct smp_csrk *csrk;
1248
1249                 /* Generate a new random key */
1250                 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1251
1252                 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1253                 if (csrk) {
1254                         csrk->master = 0x00;
1255                         memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1256                 }
1257                 smp->slave_csrk = csrk;
1258
1259                 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1260
1261                 *keydist &= ~SMP_DIST_SIGN;
1262         }
1263
1264         /* If there are still keys to be received wait for them */
1265         if (smp->remote_key_dist & KEY_DIST_MASK) {
1266                 smp_allow_key_dist(smp);
1267                 return;
1268         }
1269
1270         set_bit(SMP_FLAG_COMPLETE, &smp->flags);
1271         smp_notify_keys(conn);
1272
1273         smp_chan_destroy(conn);
1274 }
1275
1276 static void smp_timeout(struct work_struct *work)
1277 {
1278         struct smp_chan *smp = container_of(work, struct smp_chan,
1279                                             security_timer.work);
1280         struct l2cap_conn *conn = smp->conn;
1281
1282         BT_DBG("conn %p", conn);
1283
1284         hci_disconnect(conn->hcon, HCI_ERROR_REMOTE_USER_TERM);
1285 }
1286
1287 static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
1288 {
1289         struct l2cap_chan *chan = conn->smp;
1290         struct smp_chan *smp;
1291
1292         smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
1293         if (!smp)
1294                 return NULL;
1295
1296         smp->tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
1297         if (IS_ERR(smp->tfm_aes)) {
1298                 BT_ERR("Unable to create ECB crypto context");
1299                 kfree(smp);
1300                 return NULL;
1301         }
1302
1303         smp->tfm_cmac = crypto_alloc_hash("cmac(aes)", 0, CRYPTO_ALG_ASYNC);
1304         if (IS_ERR(smp->tfm_cmac)) {
1305                 BT_ERR("Unable to create CMAC crypto context");
1306                 crypto_free_blkcipher(smp->tfm_aes);
1307                 kfree(smp);
1308                 return NULL;
1309         }
1310
1311         smp->conn = conn;
1312         chan->data = smp;
1313
1314         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_FAIL);
1315
1316         INIT_DELAYED_WORK(&smp->security_timer, smp_timeout);
1317
1318         hci_conn_hold(conn->hcon);
1319
1320         return smp;
1321 }
1322
1323 static int sc_mackey_and_ltk(struct smp_chan *smp, u8 mackey[16], u8 ltk[16])
1324 {
1325         struct hci_conn *hcon = smp->conn->hcon;
1326         u8 *na, *nb, a[7], b[7];
1327
1328         if (hcon->out) {
1329                 na   = smp->prnd;
1330                 nb   = smp->rrnd;
1331         } else {
1332                 na   = smp->rrnd;
1333                 nb   = smp->prnd;
1334         }
1335
1336         memcpy(a, &hcon->init_addr, 6);
1337         memcpy(b, &hcon->resp_addr, 6);
1338         a[6] = hcon->init_addr_type;
1339         b[6] = hcon->resp_addr_type;
1340
1341         return smp_f5(smp->tfm_cmac, smp->dhkey, na, nb, a, b, mackey, ltk);
1342 }
1343
1344 static void sc_dhkey_check(struct smp_chan *smp)
1345 {
1346         struct hci_conn *hcon = smp->conn->hcon;
1347         struct smp_cmd_dhkey_check check;
1348         u8 a[7], b[7], *local_addr, *remote_addr;
1349         u8 io_cap[3], r[16];
1350
1351         memcpy(a, &hcon->init_addr, 6);
1352         memcpy(b, &hcon->resp_addr, 6);
1353         a[6] = hcon->init_addr_type;
1354         b[6] = hcon->resp_addr_type;
1355
1356         if (hcon->out) {
1357                 local_addr = a;
1358                 remote_addr = b;
1359                 memcpy(io_cap, &smp->preq[1], 3);
1360         } else {
1361                 local_addr = b;
1362                 remote_addr = a;
1363                 memcpy(io_cap, &smp->prsp[1], 3);
1364         }
1365
1366         memset(r, 0, sizeof(r));
1367
1368         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1369                 put_unaligned_le32(hcon->passkey_notify, r);
1370
1371         if (smp->method == REQ_OOB)
1372                 memcpy(r, smp->rr, 16);
1373
1374         smp_f6(smp->tfm_cmac, smp->mackey, smp->prnd, smp->rrnd, r, io_cap,
1375                local_addr, remote_addr, check.e);
1376
1377         smp_send_cmd(smp->conn, SMP_CMD_DHKEY_CHECK, sizeof(check), &check);
1378 }
1379
1380 static u8 sc_passkey_send_confirm(struct smp_chan *smp)
1381 {
1382         struct l2cap_conn *conn = smp->conn;
1383         struct hci_conn *hcon = conn->hcon;
1384         struct smp_cmd_pairing_confirm cfm;
1385         u8 r;
1386
1387         r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
1388         r |= 0x80;
1389
1390         get_random_bytes(smp->prnd, sizeof(smp->prnd));
1391
1392         if (smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd, r,
1393                    cfm.confirm_val))
1394                 return SMP_UNSPECIFIED;
1395
1396         smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
1397
1398         return 0;
1399 }
1400
1401 static u8 sc_passkey_round(struct smp_chan *smp, u8 smp_op)
1402 {
1403         struct l2cap_conn *conn = smp->conn;
1404         struct hci_conn *hcon = conn->hcon;
1405         struct hci_dev *hdev = hcon->hdev;
1406         u8 cfm[16], r;
1407
1408         /* Ignore the PDU if we've already done 20 rounds (0 - 19) */
1409         if (smp->passkey_round >= 20)
1410                 return 0;
1411
1412         switch (smp_op) {
1413         case SMP_CMD_PAIRING_RANDOM:
1414                 r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
1415                 r |= 0x80;
1416
1417                 if (smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
1418                            smp->rrnd, r, cfm))
1419                         return SMP_UNSPECIFIED;
1420
1421                 if (memcmp(smp->pcnf, cfm, 16))
1422                         return SMP_CONFIRM_FAILED;
1423
1424                 smp->passkey_round++;
1425
1426                 if (smp->passkey_round == 20) {
1427                         /* Generate MacKey and LTK */
1428                         if (sc_mackey_and_ltk(smp, smp->mackey, smp->tk))
1429                                 return SMP_UNSPECIFIED;
1430                 }
1431
1432                 /* The round is only complete when the initiator
1433                  * receives pairing random.
1434                  */
1435                 if (!hcon->out) {
1436                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1437                                      sizeof(smp->prnd), smp->prnd);
1438                         if (smp->passkey_round == 20)
1439                                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1440                         else
1441                                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1442                         return 0;
1443                 }
1444
1445                 /* Start the next round */
1446                 if (smp->passkey_round != 20)
1447                         return sc_passkey_round(smp, 0);
1448
1449                 /* Passkey rounds are complete - start DHKey Check */
1450                 sc_dhkey_check(smp);
1451                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1452
1453                 break;
1454
1455         case SMP_CMD_PAIRING_CONFIRM:
1456                 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
1457                         set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
1458                         return 0;
1459                 }
1460
1461                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1462
1463                 if (hcon->out) {
1464                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1465                                      sizeof(smp->prnd), smp->prnd);
1466                         return 0;
1467                 }
1468
1469                 return sc_passkey_send_confirm(smp);
1470
1471         case SMP_CMD_PUBLIC_KEY:
1472         default:
1473                 /* Initiating device starts the round */
1474                 if (!hcon->out)
1475                         return 0;
1476
1477                 BT_DBG("%s Starting passkey round %u", hdev->name,
1478                        smp->passkey_round + 1);
1479
1480                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1481
1482                 return sc_passkey_send_confirm(smp);
1483         }
1484
1485         return 0;
1486 }
1487
1488 static int sc_user_reply(struct smp_chan *smp, u16 mgmt_op, __le32 passkey)
1489 {
1490         struct l2cap_conn *conn = smp->conn;
1491         struct hci_conn *hcon = conn->hcon;
1492         u8 smp_op;
1493
1494         clear_bit(SMP_FLAG_WAIT_USER, &smp->flags);
1495
1496         switch (mgmt_op) {
1497         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
1498                 smp_failure(smp->conn, SMP_PASSKEY_ENTRY_FAILED);
1499                 return 0;
1500         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
1501                 smp_failure(smp->conn, SMP_NUMERIC_COMP_FAILED);
1502                 return 0;
1503         case MGMT_OP_USER_PASSKEY_REPLY:
1504                 hcon->passkey_notify = le32_to_cpu(passkey);
1505                 smp->passkey_round = 0;
1506
1507                 if (test_and_clear_bit(SMP_FLAG_CFM_PENDING, &smp->flags))
1508                         smp_op = SMP_CMD_PAIRING_CONFIRM;
1509                 else
1510                         smp_op = 0;
1511
1512                 if (sc_passkey_round(smp, smp_op))
1513                         return -EIO;
1514
1515                 return 0;
1516         }
1517
1518         /* Initiator sends DHKey check first */
1519         if (hcon->out) {
1520                 sc_dhkey_check(smp);
1521                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1522         } else if (test_and_clear_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags)) {
1523                 sc_dhkey_check(smp);
1524                 sc_add_ltk(smp);
1525         }
1526
1527         return 0;
1528 }
1529
1530 int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
1531 {
1532         struct l2cap_conn *conn = hcon->l2cap_data;
1533         struct l2cap_chan *chan;
1534         struct smp_chan *smp;
1535         u32 value;
1536         int err;
1537
1538         BT_DBG("");
1539
1540         if (!conn)
1541                 return -ENOTCONN;
1542
1543         chan = conn->smp;
1544         if (!chan)
1545                 return -ENOTCONN;
1546
1547         l2cap_chan_lock(chan);
1548         if (!chan->data) {
1549                 err = -ENOTCONN;
1550                 goto unlock;
1551         }
1552
1553         smp = chan->data;
1554
1555         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1556                 err = sc_user_reply(smp, mgmt_op, passkey);
1557                 goto unlock;
1558         }
1559
1560         switch (mgmt_op) {
1561         case MGMT_OP_USER_PASSKEY_REPLY:
1562                 value = le32_to_cpu(passkey);
1563                 memset(smp->tk, 0, sizeof(smp->tk));
1564                 BT_DBG("PassKey: %d", value);
1565                 put_unaligned_le32(value, smp->tk);
1566                 /* Fall Through */
1567         case MGMT_OP_USER_CONFIRM_REPLY:
1568                 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
1569                 break;
1570         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
1571         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
1572                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
1573                 err = 0;
1574                 goto unlock;
1575         default:
1576                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
1577                 err = -EOPNOTSUPP;
1578                 goto unlock;
1579         }
1580
1581         err = 0;
1582
1583         /* If it is our turn to send Pairing Confirm, do so now */
1584         if (test_bit(SMP_FLAG_CFM_PENDING, &smp->flags)) {
1585                 u8 rsp = smp_confirm(smp);
1586                 if (rsp)
1587                         smp_failure(conn, rsp);
1588         }
1589
1590 unlock:
1591         l2cap_chan_unlock(chan);
1592         return err;
1593 }
1594
1595 static void build_bredr_pairing_cmd(struct smp_chan *smp,
1596                                     struct smp_cmd_pairing *req,
1597                                     struct smp_cmd_pairing *rsp)
1598 {
1599         struct l2cap_conn *conn = smp->conn;
1600         struct hci_dev *hdev = conn->hcon->hdev;
1601         u8 local_dist = 0, remote_dist = 0;
1602
1603         if (test_bit(HCI_BONDABLE, &hdev->dev_flags)) {
1604                 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
1605                 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
1606         }
1607
1608         if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
1609                 remote_dist |= SMP_DIST_ID_KEY;
1610
1611         if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
1612                 local_dist |= SMP_DIST_ID_KEY;
1613
1614         if (!rsp) {
1615                 memset(req, 0, sizeof(*req));
1616
1617                 req->init_key_dist   = local_dist;
1618                 req->resp_key_dist   = remote_dist;
1619                 req->max_key_size    = SMP_MAX_ENC_KEY_SIZE;
1620
1621                 smp->remote_key_dist = remote_dist;
1622
1623                 return;
1624         }
1625
1626         memset(rsp, 0, sizeof(*rsp));
1627
1628         rsp->max_key_size    = SMP_MAX_ENC_KEY_SIZE;
1629         rsp->init_key_dist   = req->init_key_dist & remote_dist;
1630         rsp->resp_key_dist   = req->resp_key_dist & local_dist;
1631
1632         smp->remote_key_dist = rsp->init_key_dist;
1633 }
1634
1635 static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
1636 {
1637         struct smp_cmd_pairing rsp, *req = (void *) skb->data;
1638         struct l2cap_chan *chan = conn->smp;
1639         struct hci_dev *hdev = conn->hcon->hdev;
1640         struct smp_chan *smp;
1641         u8 key_size, auth, sec_level;
1642         int ret;
1643
1644         BT_DBG("conn %p", conn);
1645
1646         if (skb->len < sizeof(*req))
1647                 return SMP_INVALID_PARAMS;
1648
1649         if (conn->hcon->role != HCI_ROLE_SLAVE)
1650                 return SMP_CMD_NOTSUPP;
1651
1652         if (!chan->data)
1653                 smp = smp_chan_create(conn);
1654         else
1655                 smp = chan->data;
1656
1657         if (!smp)
1658                 return SMP_UNSPECIFIED;
1659
1660         /* We didn't start the pairing, so match remote */
1661         auth = req->auth_req & AUTH_REQ_MASK(hdev);
1662
1663         if (!test_bit(HCI_BONDABLE, &hdev->dev_flags) &&
1664             (auth & SMP_AUTH_BONDING))
1665                 return SMP_PAIRING_NOTSUPP;
1666
1667         if (test_bit(HCI_SC_ONLY, &hdev->dev_flags) && !(auth & SMP_AUTH_SC))
1668                 return SMP_AUTH_REQUIREMENTS;
1669
1670         smp->preq[0] = SMP_CMD_PAIRING_REQ;
1671         memcpy(&smp->preq[1], req, sizeof(*req));
1672         skb_pull(skb, sizeof(*req));
1673
1674         /* SMP over BR/EDR requires special treatment */
1675         if (conn->hcon->type == ACL_LINK) {
1676                 /* We must have a BR/EDR SC link */
1677                 if (!test_bit(HCI_CONN_AES_CCM, &conn->hcon->flags))
1678                         return SMP_CROSS_TRANSP_NOT_ALLOWED;
1679
1680                 set_bit(SMP_FLAG_SC, &smp->flags);
1681
1682                 build_bredr_pairing_cmd(smp, req, &rsp);
1683
1684                 key_size = min(req->max_key_size, rsp.max_key_size);
1685                 if (check_enc_key_size(conn, key_size))
1686                         return SMP_ENC_KEY_SIZE;
1687
1688                 /* Clear bits which are generated but not distributed */
1689                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1690
1691                 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1692                 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
1693                 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
1694
1695                 smp_distribute_keys(smp);
1696                 return 0;
1697         }
1698
1699         build_pairing_cmd(conn, req, &rsp, auth);
1700
1701         if (rsp.auth_req & SMP_AUTH_SC)
1702                 set_bit(SMP_FLAG_SC, &smp->flags);
1703
1704         if (conn->hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
1705                 sec_level = BT_SECURITY_MEDIUM;
1706         else
1707                 sec_level = authreq_to_seclevel(auth);
1708
1709         if (sec_level > conn->hcon->pending_sec_level)
1710                 conn->hcon->pending_sec_level = sec_level;
1711
1712         /* If we need MITM check that it can be achieved */
1713         if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1714                 u8 method;
1715
1716                 method = get_auth_method(smp, conn->hcon->io_capability,
1717                                          req->io_capability);
1718                 if (method == JUST_WORKS || method == JUST_CFM)
1719                         return SMP_AUTH_REQUIREMENTS;
1720         }
1721
1722         key_size = min(req->max_key_size, rsp.max_key_size);
1723         if (check_enc_key_size(conn, key_size))
1724                 return SMP_ENC_KEY_SIZE;
1725
1726         get_random_bytes(smp->prnd, sizeof(smp->prnd));
1727
1728         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1729         memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
1730
1731         smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
1732
1733         clear_bit(SMP_FLAG_INITIATOR, &smp->flags);
1734
1735         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1736                 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1737                 /* Clear bits which are generated but not distributed */
1738                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1739                 /* Wait for Public Key from Initiating Device */
1740                 return 0;
1741         } else {
1742                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1743         }
1744
1745         /* Request setup of TK */
1746         ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
1747         if (ret)
1748                 return SMP_UNSPECIFIED;
1749
1750         return 0;
1751 }
1752
1753 static u8 sc_send_public_key(struct smp_chan *smp)
1754 {
1755         struct hci_dev *hdev = smp->conn->hcon->hdev;
1756
1757         BT_DBG("");
1758
1759         if (test_bit(HCI_USE_DEBUG_KEYS, &hdev->dev_flags)) {
1760                 BT_DBG("Using debug keys");
1761                 memcpy(smp->local_pk, debug_pk, 64);
1762                 memcpy(smp->local_sk, debug_sk, 32);
1763                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1764         } else {
1765                 while (true) {
1766                         /* Generate local key pair for Secure Connections */
1767                         if (!ecc_make_key(smp->local_pk, smp->local_sk))
1768                                 return SMP_UNSPECIFIED;
1769
1770                         /* This is unlikely, but we need to check that
1771                          * we didn't accidentially generate a debug key.
1772                          */
1773                         if (memcmp(smp->local_sk, debug_sk, 32))
1774                                 break;
1775                 }
1776         }
1777
1778         SMP_DBG("Local Public Key X: %32phN", smp->local_pk);
1779         SMP_DBG("Local Public Key Y: %32phN", &smp->local_pk[32]);
1780         SMP_DBG("Local Private Key:  %32phN", smp->local_sk);
1781
1782         smp_send_cmd(smp->conn, SMP_CMD_PUBLIC_KEY, 64, smp->local_pk);
1783
1784         return 0;
1785 }
1786
1787 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
1788 {
1789         struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
1790         struct l2cap_chan *chan = conn->smp;
1791         struct smp_chan *smp = chan->data;
1792         struct hci_dev *hdev = conn->hcon->hdev;
1793         u8 key_size, auth;
1794         int ret;
1795
1796         BT_DBG("conn %p", conn);
1797
1798         if (skb->len < sizeof(*rsp))
1799                 return SMP_INVALID_PARAMS;
1800
1801         if (conn->hcon->role != HCI_ROLE_MASTER)
1802                 return SMP_CMD_NOTSUPP;
1803
1804         skb_pull(skb, sizeof(*rsp));
1805
1806         req = (void *) &smp->preq[1];
1807
1808         key_size = min(req->max_key_size, rsp->max_key_size);
1809         if (check_enc_key_size(conn, key_size))
1810                 return SMP_ENC_KEY_SIZE;
1811
1812         auth = rsp->auth_req & AUTH_REQ_MASK(hdev);
1813
1814         if (test_bit(HCI_SC_ONLY, &hdev->dev_flags) && !(auth & SMP_AUTH_SC))
1815                 return SMP_AUTH_REQUIREMENTS;
1816
1817         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1818         memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
1819
1820         /* Update remote key distribution in case the remote cleared
1821          * some bits that we had enabled in our request.
1822          */
1823         smp->remote_key_dist &= rsp->resp_key_dist;
1824
1825         /* For BR/EDR this means we're done and can start phase 3 */
1826         if (conn->hcon->type == ACL_LINK) {
1827                 /* Clear bits which are generated but not distributed */
1828                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1829                 smp_distribute_keys(smp);
1830                 return 0;
1831         }
1832
1833         if ((req->auth_req & SMP_AUTH_SC) && (auth & SMP_AUTH_SC))
1834                 set_bit(SMP_FLAG_SC, &smp->flags);
1835         else if (conn->hcon->pending_sec_level > BT_SECURITY_HIGH)
1836                 conn->hcon->pending_sec_level = BT_SECURITY_HIGH;
1837
1838         /* If we need MITM check that it can be achieved */
1839         if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1840                 u8 method;
1841
1842                 method = get_auth_method(smp, req->io_capability,
1843                                          rsp->io_capability);
1844                 if (method == JUST_WORKS || method == JUST_CFM)
1845                         return SMP_AUTH_REQUIREMENTS;
1846         }
1847
1848         get_random_bytes(smp->prnd, sizeof(smp->prnd));
1849
1850         /* Update remote key distribution in case the remote cleared
1851          * some bits that we had enabled in our request.
1852          */
1853         smp->remote_key_dist &= rsp->resp_key_dist;
1854
1855         if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1856                 /* Clear bits which are generated but not distributed */
1857                 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1858                 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1859                 return sc_send_public_key(smp);
1860         }
1861
1862         auth |= req->auth_req;
1863
1864         ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
1865         if (ret)
1866                 return SMP_UNSPECIFIED;
1867
1868         set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
1869
1870         /* Can't compose response until we have been confirmed */
1871         if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
1872                 return smp_confirm(smp);
1873
1874         return 0;
1875 }
1876
1877 static u8 sc_check_confirm(struct smp_chan *smp)
1878 {
1879         struct l2cap_conn *conn = smp->conn;
1880
1881         BT_DBG("");
1882
1883         /* Public Key exchange must happen before any other steps */
1884         if (!test_bit(SMP_FLAG_REMOTE_PK, &smp->flags))
1885                 return SMP_UNSPECIFIED;
1886
1887         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1888                 return sc_passkey_round(smp, SMP_CMD_PAIRING_CONFIRM);
1889
1890         if (conn->hcon->out) {
1891                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1892                              smp->prnd);
1893                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1894         }
1895
1896         return 0;
1897 }
1898
1899 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
1900 {
1901         struct l2cap_chan *chan = conn->smp;
1902         struct smp_chan *smp = chan->data;
1903
1904         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
1905
1906         if (skb->len < sizeof(smp->pcnf))
1907                 return SMP_INVALID_PARAMS;
1908
1909         memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
1910         skb_pull(skb, sizeof(smp->pcnf));
1911
1912         if (test_bit(SMP_FLAG_SC, &smp->flags))
1913                 return sc_check_confirm(smp);
1914
1915         if (conn->hcon->out) {
1916                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1917                              smp->prnd);
1918                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1919                 return 0;
1920         }
1921
1922         if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
1923                 return smp_confirm(smp);
1924         else
1925                 set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
1926
1927         return 0;
1928 }
1929
1930 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
1931 {
1932         struct l2cap_chan *chan = conn->smp;
1933         struct smp_chan *smp = chan->data;
1934         struct hci_conn *hcon = conn->hcon;
1935         u8 *pkax, *pkbx, *na, *nb;
1936         u32 passkey;
1937         int err;
1938
1939         BT_DBG("conn %p", conn);
1940
1941         if (skb->len < sizeof(smp->rrnd))
1942                 return SMP_INVALID_PARAMS;
1943
1944         memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
1945         skb_pull(skb, sizeof(smp->rrnd));
1946
1947         if (!test_bit(SMP_FLAG_SC, &smp->flags))
1948                 return smp_random(smp);
1949
1950         if (hcon->out) {
1951                 pkax = smp->local_pk;
1952                 pkbx = smp->remote_pk;
1953                 na   = smp->prnd;
1954                 nb   = smp->rrnd;
1955         } else {
1956                 pkax = smp->remote_pk;
1957                 pkbx = smp->local_pk;
1958                 na   = smp->rrnd;
1959                 nb   = smp->prnd;
1960         }
1961
1962         if (smp->method == REQ_OOB) {
1963                 if (!hcon->out)
1964                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1965                                      sizeof(smp->prnd), smp->prnd);
1966                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1967                 goto mackey_and_ltk;
1968         }
1969
1970         /* Passkey entry has special treatment */
1971         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1972                 return sc_passkey_round(smp, SMP_CMD_PAIRING_RANDOM);
1973
1974         if (hcon->out) {
1975                 u8 cfm[16];
1976
1977                 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
1978                              smp->rrnd, 0, cfm);
1979                 if (err)
1980                         return SMP_UNSPECIFIED;
1981
1982                 if (memcmp(smp->pcnf, cfm, 16))
1983                         return SMP_CONFIRM_FAILED;
1984         } else {
1985                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1986                              smp->prnd);
1987                 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1988         }
1989
1990 mackey_and_ltk:
1991         /* Generate MacKey and LTK */
1992         err = sc_mackey_and_ltk(smp, smp->mackey, smp->tk);
1993         if (err)
1994                 return SMP_UNSPECIFIED;
1995
1996         if (smp->method == JUST_WORKS || smp->method == REQ_OOB) {
1997                 if (hcon->out) {
1998                         sc_dhkey_check(smp);
1999                         SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
2000                 }
2001                 return 0;
2002         }
2003
2004         err = smp_g2(smp->tfm_cmac, pkax, pkbx, na, nb, &passkey);
2005         if (err)
2006                 return SMP_UNSPECIFIED;
2007
2008         err = mgmt_user_confirm_request(hcon->hdev, &hcon->dst, hcon->type,
2009                                         hcon->dst_type, passkey, 0);
2010         if (err)
2011                 return SMP_UNSPECIFIED;
2012
2013         set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2014
2015         return 0;
2016 }
2017
2018 static bool smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
2019 {
2020         struct smp_ltk *key;
2021         struct hci_conn *hcon = conn->hcon;
2022
2023         key = hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role);
2024         if (!key)
2025                 return false;
2026
2027         if (smp_ltk_sec_level(key) < sec_level)
2028                 return false;
2029
2030         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
2031                 return true;
2032
2033         hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
2034         hcon->enc_key_size = key->enc_size;
2035
2036         /* We never store STKs for master role, so clear this flag */
2037         clear_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
2038
2039         return true;
2040 }
2041
2042 bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level,
2043                              enum smp_key_pref key_pref)
2044 {
2045         if (sec_level == BT_SECURITY_LOW)
2046                 return true;
2047
2048         /* If we're encrypted with an STK but the caller prefers using
2049          * LTK claim insufficient security. This way we allow the
2050          * connection to be re-encrypted with an LTK, even if the LTK
2051          * provides the same level of security. Only exception is if we
2052          * don't have an LTK (e.g. because of key distribution bits).
2053          */
2054         if (key_pref == SMP_USE_LTK &&
2055             test_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags) &&
2056             hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role))
2057                 return false;
2058
2059         if (hcon->sec_level >= sec_level)
2060                 return true;
2061
2062         return false;
2063 }
2064
2065 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
2066 {
2067         struct smp_cmd_security_req *rp = (void *) skb->data;
2068         struct smp_cmd_pairing cp;
2069         struct hci_conn *hcon = conn->hcon;
2070         struct hci_dev *hdev = hcon->hdev;
2071         struct smp_chan *smp;
2072         u8 sec_level, auth;
2073
2074         BT_DBG("conn %p", conn);
2075
2076         if (skb->len < sizeof(*rp))
2077                 return SMP_INVALID_PARAMS;
2078
2079         if (hcon->role != HCI_ROLE_MASTER)
2080                 return SMP_CMD_NOTSUPP;
2081
2082         auth = rp->auth_req & AUTH_REQ_MASK(hdev);
2083
2084         if (test_bit(HCI_SC_ONLY, &hdev->dev_flags) && !(auth & SMP_AUTH_SC))
2085                 return SMP_AUTH_REQUIREMENTS;
2086
2087         if (hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
2088                 sec_level = BT_SECURITY_MEDIUM;
2089         else
2090                 sec_level = authreq_to_seclevel(auth);
2091
2092         if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
2093                 return 0;
2094
2095         if (sec_level > hcon->pending_sec_level)
2096                 hcon->pending_sec_level = sec_level;
2097
2098         if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
2099                 return 0;
2100
2101         smp = smp_chan_create(conn);
2102         if (!smp)
2103                 return SMP_UNSPECIFIED;
2104
2105         if (!test_bit(HCI_BONDABLE, &hcon->hdev->dev_flags) &&
2106             (auth & SMP_AUTH_BONDING))
2107                 return SMP_PAIRING_NOTSUPP;
2108
2109         skb_pull(skb, sizeof(*rp));
2110
2111         memset(&cp, 0, sizeof(cp));
2112         build_pairing_cmd(conn, &cp, NULL, auth);
2113
2114         smp->preq[0] = SMP_CMD_PAIRING_REQ;
2115         memcpy(&smp->preq[1], &cp, sizeof(cp));
2116
2117         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
2118         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2119
2120         return 0;
2121 }
2122
2123 int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
2124 {
2125         struct l2cap_conn *conn = hcon->l2cap_data;
2126         struct l2cap_chan *chan;
2127         struct smp_chan *smp;
2128         __u8 authreq;
2129         int ret;
2130
2131         BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
2132
2133         /* This may be NULL if there's an unexpected disconnection */
2134         if (!conn)
2135                 return 1;
2136
2137         chan = conn->smp;
2138
2139         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
2140                 return 1;
2141
2142         if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
2143                 return 1;
2144
2145         if (sec_level > hcon->pending_sec_level)
2146                 hcon->pending_sec_level = sec_level;
2147
2148         if (hcon->role == HCI_ROLE_MASTER)
2149                 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
2150                         return 0;
2151
2152         l2cap_chan_lock(chan);
2153
2154         /* If SMP is already in progress ignore this request */
2155         if (chan->data) {
2156                 ret = 0;
2157                 goto unlock;
2158         }
2159
2160         smp = smp_chan_create(conn);
2161         if (!smp) {
2162                 ret = 1;
2163                 goto unlock;
2164         }
2165
2166         authreq = seclevel_to_authreq(sec_level);
2167
2168         if (test_bit(HCI_SC_ENABLED, &hcon->hdev->dev_flags))
2169                 authreq |= SMP_AUTH_SC;
2170
2171         /* Require MITM if IO Capability allows or the security level
2172          * requires it.
2173          */
2174         if (hcon->io_capability != HCI_IO_NO_INPUT_OUTPUT ||
2175             hcon->pending_sec_level > BT_SECURITY_MEDIUM)
2176                 authreq |= SMP_AUTH_MITM;
2177
2178         if (hcon->role == HCI_ROLE_MASTER) {
2179                 struct smp_cmd_pairing cp;
2180
2181                 build_pairing_cmd(conn, &cp, NULL, authreq);
2182                 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2183                 memcpy(&smp->preq[1], &cp, sizeof(cp));
2184
2185                 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
2186                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2187         } else {
2188                 struct smp_cmd_security_req cp;
2189                 cp.auth_req = authreq;
2190                 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
2191                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_REQ);
2192         }
2193
2194         set_bit(SMP_FLAG_INITIATOR, &smp->flags);
2195         ret = 0;
2196
2197 unlock:
2198         l2cap_chan_unlock(chan);
2199         return ret;
2200 }
2201
2202 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
2203 {
2204         struct smp_cmd_encrypt_info *rp = (void *) skb->data;
2205         struct l2cap_chan *chan = conn->smp;
2206         struct smp_chan *smp = chan->data;
2207
2208         BT_DBG("conn %p", conn);
2209
2210         if (skb->len < sizeof(*rp))
2211                 return SMP_INVALID_PARAMS;
2212
2213         SMP_ALLOW_CMD(smp, SMP_CMD_MASTER_IDENT);
2214
2215         skb_pull(skb, sizeof(*rp));
2216
2217         memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
2218
2219         return 0;
2220 }
2221
2222 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
2223 {
2224         struct smp_cmd_master_ident *rp = (void *) skb->data;
2225         struct l2cap_chan *chan = conn->smp;
2226         struct smp_chan *smp = chan->data;
2227         struct hci_dev *hdev = conn->hcon->hdev;
2228         struct hci_conn *hcon = conn->hcon;
2229         struct smp_ltk *ltk;
2230         u8 authenticated;
2231
2232         BT_DBG("conn %p", conn);
2233
2234         if (skb->len < sizeof(*rp))
2235                 return SMP_INVALID_PARAMS;
2236
2237         /* Mark the information as received */
2238         smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
2239
2240         if (smp->remote_key_dist & SMP_DIST_ID_KEY)
2241                 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
2242         else if (smp->remote_key_dist & SMP_DIST_SIGN)
2243                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
2244
2245         skb_pull(skb, sizeof(*rp));
2246
2247         authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
2248         ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, SMP_LTK,
2249                           authenticated, smp->tk, smp->enc_key_size,
2250                           rp->ediv, rp->rand);
2251         smp->ltk = ltk;
2252         if (!(smp->remote_key_dist & KEY_DIST_MASK))
2253                 smp_distribute_keys(smp);
2254
2255         return 0;
2256 }
2257
2258 static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
2259 {
2260         struct smp_cmd_ident_info *info = (void *) skb->data;
2261         struct l2cap_chan *chan = conn->smp;
2262         struct smp_chan *smp = chan->data;
2263
2264         BT_DBG("");
2265
2266         if (skb->len < sizeof(*info))
2267                 return SMP_INVALID_PARAMS;
2268
2269         SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_ADDR_INFO);
2270
2271         skb_pull(skb, sizeof(*info));
2272
2273         memcpy(smp->irk, info->irk, 16);
2274
2275         return 0;
2276 }
2277
2278 static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
2279                                    struct sk_buff *skb)
2280 {
2281         struct smp_cmd_ident_addr_info *info = (void *) skb->data;
2282         struct l2cap_chan *chan = conn->smp;
2283         struct smp_chan *smp = chan->data;
2284         struct hci_conn *hcon = conn->hcon;
2285         bdaddr_t rpa;
2286
2287         BT_DBG("");
2288
2289         if (skb->len < sizeof(*info))
2290                 return SMP_INVALID_PARAMS;
2291
2292         /* Mark the information as received */
2293         smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
2294
2295         if (smp->remote_key_dist & SMP_DIST_SIGN)
2296                 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
2297
2298         skb_pull(skb, sizeof(*info));
2299
2300         /* Strictly speaking the Core Specification (4.1) allows sending
2301          * an empty address which would force us to rely on just the IRK
2302          * as "identity information". However, since such
2303          * implementations are not known of and in order to not over
2304          * complicate our implementation, simply pretend that we never
2305          * received an IRK for such a device.
2306          */
2307         if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
2308                 BT_ERR("Ignoring IRK with no identity address");
2309                 goto distribute;
2310         }
2311
2312         bacpy(&smp->id_addr, &info->bdaddr);
2313         smp->id_addr_type = info->addr_type;
2314
2315         if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
2316                 bacpy(&rpa, &hcon->dst);
2317         else
2318                 bacpy(&rpa, BDADDR_ANY);
2319
2320         smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
2321                                       smp->id_addr_type, smp->irk, &rpa);
2322
2323 distribute:
2324         if (!(smp->remote_key_dist & KEY_DIST_MASK))
2325                 smp_distribute_keys(smp);
2326
2327         return 0;
2328 }
2329
2330 static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
2331 {
2332         struct smp_cmd_sign_info *rp = (void *) skb->data;
2333         struct l2cap_chan *chan = conn->smp;
2334         struct smp_chan *smp = chan->data;
2335         struct smp_csrk *csrk;
2336
2337         BT_DBG("conn %p", conn);
2338
2339         if (skb->len < sizeof(*rp))
2340                 return SMP_INVALID_PARAMS;
2341
2342         /* Mark the information as received */
2343         smp->remote_key_dist &= ~SMP_DIST_SIGN;
2344
2345         skb_pull(skb, sizeof(*rp));
2346
2347         csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
2348         if (csrk) {
2349                 csrk->master = 0x01;
2350                 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
2351         }
2352         smp->csrk = csrk;
2353         smp_distribute_keys(smp);
2354
2355         return 0;
2356 }
2357
2358 static u8 sc_select_method(struct smp_chan *smp)
2359 {
2360         struct l2cap_conn *conn = smp->conn;
2361         struct hci_conn *hcon = conn->hcon;
2362         struct smp_cmd_pairing *local, *remote;
2363         u8 local_mitm, remote_mitm, local_io, remote_io, method;
2364
2365         if (test_bit(SMP_FLAG_OOB, &smp->flags))
2366                 return REQ_OOB;
2367
2368         /* The preq/prsp contain the raw Pairing Request/Response PDUs
2369          * which are needed as inputs to some crypto functions. To get
2370          * the "struct smp_cmd_pairing" from them we need to skip the
2371          * first byte which contains the opcode.
2372          */
2373         if (hcon->out) {
2374                 local = (void *) &smp->preq[1];
2375                 remote = (void *) &smp->prsp[1];
2376         } else {
2377                 local = (void *) &smp->prsp[1];
2378                 remote = (void *) &smp->preq[1];
2379         }
2380
2381         local_io = local->io_capability;
2382         remote_io = remote->io_capability;
2383
2384         local_mitm = (local->auth_req & SMP_AUTH_MITM);
2385         remote_mitm = (remote->auth_req & SMP_AUTH_MITM);
2386
2387         /* If either side wants MITM, look up the method from the table,
2388          * otherwise use JUST WORKS.
2389          */
2390         if (local_mitm || remote_mitm)
2391                 method = get_auth_method(smp, local_io, remote_io);
2392         else
2393                 method = JUST_WORKS;
2394
2395         /* Don't confirm locally initiated pairing attempts */
2396         if (method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR, &smp->flags))
2397                 method = JUST_WORKS;
2398
2399         return method;
2400 }
2401
2402 static int smp_cmd_public_key(struct l2cap_conn *conn, struct sk_buff *skb)
2403 {
2404         struct smp_cmd_public_key *key = (void *) skb->data;
2405         struct hci_conn *hcon = conn->hcon;
2406         struct l2cap_chan *chan = conn->smp;
2407         struct smp_chan *smp = chan->data;
2408         struct hci_dev *hdev = hcon->hdev;
2409         struct smp_cmd_pairing_confirm cfm;
2410         int err;
2411
2412         BT_DBG("conn %p", conn);
2413
2414         if (skb->len < sizeof(*key))
2415                 return SMP_INVALID_PARAMS;
2416
2417         memcpy(smp->remote_pk, key, 64);
2418
2419         /* Non-initiating device sends its public key after receiving
2420          * the key from the initiating device.
2421          */
2422         if (!hcon->out) {
2423                 err = sc_send_public_key(smp);
2424                 if (err)
2425                         return err;
2426         }
2427
2428         SMP_DBG("Remote Public Key X: %32phN", smp->remote_pk);
2429         SMP_DBG("Remote Public Key Y: %32phN", &smp->remote_pk[32]);
2430
2431         if (!ecdh_shared_secret(smp->remote_pk, smp->local_sk, smp->dhkey))
2432                 return SMP_UNSPECIFIED;
2433
2434         SMP_DBG("DHKey %32phN", smp->dhkey);
2435
2436         set_bit(SMP_FLAG_REMOTE_PK, &smp->flags);
2437
2438         smp->method = sc_select_method(smp);
2439
2440         BT_DBG("%s selected method 0x%02x", hdev->name, smp->method);
2441
2442         /* JUST_WORKS and JUST_CFM result in an unauthenticated key */
2443         if (smp->method == JUST_WORKS || smp->method == JUST_CFM)
2444                 hcon->pending_sec_level = BT_SECURITY_MEDIUM;
2445         else
2446                 hcon->pending_sec_level = BT_SECURITY_FIPS;
2447
2448         if (!memcmp(debug_pk, smp->remote_pk, 64))
2449                 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
2450
2451         if (smp->method == DSP_PASSKEY) {
2452                 get_random_bytes(&hcon->passkey_notify,
2453                                  sizeof(hcon->passkey_notify));
2454                 hcon->passkey_notify %= 1000000;
2455                 hcon->passkey_entered = 0;
2456                 smp->passkey_round = 0;
2457                 if (mgmt_user_passkey_notify(hdev, &hcon->dst, hcon->type,
2458                                              hcon->dst_type,
2459                                              hcon->passkey_notify,
2460                                              hcon->passkey_entered))
2461                         return SMP_UNSPECIFIED;
2462                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2463                 return sc_passkey_round(smp, SMP_CMD_PUBLIC_KEY);
2464         }
2465
2466         if (smp->method == REQ_OOB) {
2467                 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->remote_pk,
2468                              smp->rr, 0, cfm.confirm_val);
2469                 if (err)
2470                         return SMP_UNSPECIFIED;
2471
2472                 if (memcmp(cfm.confirm_val, smp->pcnf, 16))
2473                         return SMP_CONFIRM_FAILED;
2474
2475                 if (hcon->out)
2476                         smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
2477                                      sizeof(smp->prnd), smp->prnd);
2478
2479                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2480
2481                 return 0;
2482         }
2483
2484         if (hcon->out)
2485                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2486
2487         if (smp->method == REQ_PASSKEY) {
2488                 if (mgmt_user_passkey_request(hdev, &hcon->dst, hcon->type,
2489                                               hcon->dst_type))
2490                         return SMP_UNSPECIFIED;
2491                 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2492                 set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2493                 return 0;
2494         }
2495
2496         /* The Initiating device waits for the non-initiating device to
2497          * send the confirm value.
2498          */
2499         if (conn->hcon->out)
2500                 return 0;
2501
2502         err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd,
2503                      0, cfm.confirm_val);
2504         if (err)
2505                 return SMP_UNSPECIFIED;
2506
2507         smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
2508         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2509
2510         return 0;
2511 }
2512
2513 static int smp_cmd_dhkey_check(struct l2cap_conn *conn, struct sk_buff *skb)
2514 {
2515         struct smp_cmd_dhkey_check *check = (void *) skb->data;
2516         struct l2cap_chan *chan = conn->smp;
2517         struct hci_conn *hcon = conn->hcon;
2518         struct smp_chan *smp = chan->data;
2519         u8 a[7], b[7], *local_addr, *remote_addr;
2520         u8 io_cap[3], r[16], e[16];
2521         int err;
2522
2523         BT_DBG("conn %p", conn);
2524
2525         if (skb->len < sizeof(*check))
2526                 return SMP_INVALID_PARAMS;
2527
2528         memcpy(a, &hcon->init_addr, 6);
2529         memcpy(b, &hcon->resp_addr, 6);
2530         a[6] = hcon->init_addr_type;
2531         b[6] = hcon->resp_addr_type;
2532
2533         if (hcon->out) {
2534                 local_addr = a;
2535                 remote_addr = b;
2536                 memcpy(io_cap, &smp->prsp[1], 3);
2537         } else {
2538                 local_addr = b;
2539                 remote_addr = a;
2540                 memcpy(io_cap, &smp->preq[1], 3);
2541         }
2542
2543         memset(r, 0, sizeof(r));
2544
2545         if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2546                 put_unaligned_le32(hcon->passkey_notify, r);
2547
2548         err = smp_f6(smp->tfm_cmac, smp->mackey, smp->rrnd, smp->prnd, r,
2549                      io_cap, remote_addr, local_addr, e);
2550         if (err)
2551                 return SMP_UNSPECIFIED;
2552
2553         if (memcmp(check->e, e, 16))
2554                 return SMP_DHKEY_CHECK_FAILED;
2555
2556         if (!hcon->out) {
2557                 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
2558                         set_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags);
2559                         return 0;
2560                 }
2561
2562                 /* Slave sends DHKey check as response to master */
2563                 sc_dhkey_check(smp);
2564         }
2565
2566         sc_add_ltk(smp);
2567
2568         if (hcon->out) {
2569                 hci_le_start_enc(hcon, 0, 0, smp->tk);
2570                 hcon->enc_key_size = smp->enc_key_size;
2571         }
2572
2573         return 0;
2574 }
2575
2576 static int smp_cmd_keypress_notify(struct l2cap_conn *conn,
2577                                    struct sk_buff *skb)
2578 {
2579         struct smp_cmd_keypress_notify *kp = (void *) skb->data;
2580
2581         BT_DBG("value 0x%02x", kp->value);
2582
2583         return 0;
2584 }
2585
2586 static int smp_sig_channel(struct l2cap_chan *chan, struct sk_buff *skb)
2587 {
2588         struct l2cap_conn *conn = chan->conn;
2589         struct hci_conn *hcon = conn->hcon;
2590         struct smp_chan *smp;
2591         __u8 code, reason;
2592         int err = 0;
2593
2594         if (skb->len < 1)
2595                 return -EILSEQ;
2596
2597         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
2598                 reason = SMP_PAIRING_NOTSUPP;
2599                 goto done;
2600         }
2601
2602         code = skb->data[0];
2603         skb_pull(skb, sizeof(code));
2604
2605         smp = chan->data;
2606
2607         if (code > SMP_CMD_MAX)
2608                 goto drop;
2609
2610         if (smp && !test_and_clear_bit(code, &smp->allow_cmd))
2611                 goto drop;
2612
2613         /* If we don't have a context the only allowed commands are
2614          * pairing request and security request.
2615          */
2616         if (!smp && code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ)
2617                 goto drop;
2618
2619         switch (code) {
2620         case SMP_CMD_PAIRING_REQ:
2621                 reason = smp_cmd_pairing_req(conn, skb);
2622                 break;
2623
2624         case SMP_CMD_PAIRING_FAIL:
2625                 smp_failure(conn, 0);
2626                 err = -EPERM;
2627                 break;
2628
2629         case SMP_CMD_PAIRING_RSP:
2630                 reason = smp_cmd_pairing_rsp(conn, skb);
2631                 break;
2632
2633         case SMP_CMD_SECURITY_REQ:
2634                 reason = smp_cmd_security_req(conn, skb);
2635                 break;
2636
2637         case SMP_CMD_PAIRING_CONFIRM:
2638                 reason = smp_cmd_pairing_confirm(conn, skb);
2639                 break;
2640
2641         case SMP_CMD_PAIRING_RANDOM:
2642                 reason = smp_cmd_pairing_random(conn, skb);
2643                 break;
2644
2645         case SMP_CMD_ENCRYPT_INFO:
2646                 reason = smp_cmd_encrypt_info(conn, skb);
2647                 break;
2648
2649         case SMP_CMD_MASTER_IDENT:
2650                 reason = smp_cmd_master_ident(conn, skb);
2651                 break;
2652
2653         case SMP_CMD_IDENT_INFO:
2654                 reason = smp_cmd_ident_info(conn, skb);
2655                 break;
2656
2657         case SMP_CMD_IDENT_ADDR_INFO:
2658                 reason = smp_cmd_ident_addr_info(conn, skb);
2659                 break;
2660
2661         case SMP_CMD_SIGN_INFO:
2662                 reason = smp_cmd_sign_info(conn, skb);
2663                 break;
2664
2665         case SMP_CMD_PUBLIC_KEY:
2666                 reason = smp_cmd_public_key(conn, skb);
2667                 break;
2668
2669         case SMP_CMD_DHKEY_CHECK:
2670                 reason = smp_cmd_dhkey_check(conn, skb);
2671                 break;
2672
2673         case SMP_CMD_KEYPRESS_NOTIFY:
2674                 reason = smp_cmd_keypress_notify(conn, skb);
2675                 break;
2676
2677         default:
2678                 BT_DBG("Unknown command code 0x%2.2x", code);
2679                 reason = SMP_CMD_NOTSUPP;
2680                 goto done;
2681         }
2682
2683 done:
2684         if (!err) {
2685                 if (reason)
2686                         smp_failure(conn, reason);
2687                 kfree_skb(skb);
2688         }
2689
2690         return err;
2691
2692 drop:
2693         BT_ERR("%s unexpected SMP command 0x%02x from %pMR", hcon->hdev->name,
2694                code, &hcon->dst);
2695         kfree_skb(skb);
2696         return 0;
2697 }
2698
2699 static void smp_teardown_cb(struct l2cap_chan *chan, int err)
2700 {
2701         struct l2cap_conn *conn = chan->conn;
2702
2703         BT_DBG("chan %p", chan);
2704
2705         if (chan->data)
2706                 smp_chan_destroy(conn);
2707
2708         conn->smp = NULL;
2709         l2cap_chan_put(chan);
2710 }
2711
2712 static void bredr_pairing(struct l2cap_chan *chan)
2713 {
2714         struct l2cap_conn *conn = chan->conn;
2715         struct hci_conn *hcon = conn->hcon;
2716         struct hci_dev *hdev = hcon->hdev;
2717         struct smp_cmd_pairing req;
2718         struct smp_chan *smp;
2719
2720         BT_DBG("chan %p", chan);
2721
2722         /* Only new pairings are interesting */
2723         if (!test_bit(HCI_CONN_NEW_LINK_KEY, &hcon->flags))
2724                 return;
2725
2726         /* Don't bother if we're not encrypted */
2727         if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2728                 return;
2729
2730         /* Only master may initiate SMP over BR/EDR */
2731         if (hcon->role != HCI_ROLE_MASTER)
2732                 return;
2733
2734         /* Secure Connections support must be enabled */
2735         if (!test_bit(HCI_SC_ENABLED, &hdev->dev_flags))
2736                 return;
2737
2738         /* BR/EDR must use Secure Connections for SMP */
2739         if (!test_bit(HCI_CONN_AES_CCM, &hcon->flags) &&
2740             !test_bit(HCI_FORCE_LESC, &hdev->dbg_flags))
2741                 return;
2742
2743         /* If our LE support is not enabled don't do anything */
2744         if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
2745                 return;
2746
2747         /* Don't bother if remote LE support is not enabled */
2748         if (!lmp_host_le_capable(hcon))
2749                 return;
2750
2751         /* Remote must support SMP fixed chan for BR/EDR */
2752         if (!(conn->remote_fixed_chan & L2CAP_FC_SMP_BREDR))
2753                 return;
2754
2755         /* Don't bother if SMP is already ongoing */
2756         if (chan->data)
2757                 return;
2758
2759         smp = smp_chan_create(conn);
2760         if (!smp) {
2761                 BT_ERR("%s unable to create SMP context for BR/EDR",
2762                        hdev->name);
2763                 return;
2764         }
2765
2766         set_bit(SMP_FLAG_SC, &smp->flags);
2767
2768         BT_DBG("%s starting SMP over BR/EDR", hdev->name);
2769
2770         /* Prepare and send the BR/EDR SMP Pairing Request */
2771         build_bredr_pairing_cmd(smp, &req, NULL);
2772
2773         smp->preq[0] = SMP_CMD_PAIRING_REQ;
2774         memcpy(&smp->preq[1], &req, sizeof(req));
2775
2776         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(req), &req);
2777         SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2778 }
2779
2780 static void smp_resume_cb(struct l2cap_chan *chan)
2781 {
2782         struct smp_chan *smp = chan->data;
2783         struct l2cap_conn *conn = chan->conn;
2784         struct hci_conn *hcon = conn->hcon;
2785
2786         BT_DBG("chan %p", chan);
2787
2788         if (hcon->type == ACL_LINK) {
2789                 bredr_pairing(chan);
2790                 return;
2791         }
2792
2793         if (!smp)
2794                 return;
2795
2796         if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2797                 return;
2798
2799         cancel_delayed_work(&smp->security_timer);
2800
2801         smp_distribute_keys(smp);
2802 }
2803
2804 static void smp_ready_cb(struct l2cap_chan *chan)
2805 {
2806         struct l2cap_conn *conn = chan->conn;
2807         struct hci_conn *hcon = conn->hcon;
2808
2809         BT_DBG("chan %p", chan);
2810
2811         conn->smp = chan;
2812         l2cap_chan_hold(chan);
2813
2814         if (hcon->type == ACL_LINK && test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2815                 bredr_pairing(chan);
2816 }
2817
2818 static int smp_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
2819 {
2820         int err;
2821
2822         BT_DBG("chan %p", chan);
2823
2824         err = smp_sig_channel(chan, skb);
2825         if (err) {
2826                 struct smp_chan *smp = chan->data;
2827
2828                 if (smp)
2829                         cancel_delayed_work_sync(&smp->security_timer);
2830
2831                 hci_disconnect(chan->conn->hcon, HCI_ERROR_AUTH_FAILURE);
2832         }
2833
2834         return err;
2835 }
2836
2837 static struct sk_buff *smp_alloc_skb_cb(struct l2cap_chan *chan,
2838                                         unsigned long hdr_len,
2839                                         unsigned long len, int nb)
2840 {
2841         struct sk_buff *skb;
2842
2843         skb = bt_skb_alloc(hdr_len + len, GFP_KERNEL);
2844         if (!skb)
2845                 return ERR_PTR(-ENOMEM);
2846
2847         skb->priority = HCI_PRIO_MAX;
2848         bt_cb(skb)->chan = chan;
2849
2850         return skb;
2851 }
2852
2853 static const struct l2cap_ops smp_chan_ops = {
2854         .name                   = "Security Manager",
2855         .ready                  = smp_ready_cb,
2856         .recv                   = smp_recv_cb,
2857         .alloc_skb              = smp_alloc_skb_cb,
2858         .teardown               = smp_teardown_cb,
2859         .resume                 = smp_resume_cb,
2860
2861         .new_connection         = l2cap_chan_no_new_connection,
2862         .state_change           = l2cap_chan_no_state_change,
2863         .close                  = l2cap_chan_no_close,
2864         .defer                  = l2cap_chan_no_defer,
2865         .suspend                = l2cap_chan_no_suspend,
2866         .set_shutdown           = l2cap_chan_no_set_shutdown,
2867         .get_sndtimeo           = l2cap_chan_no_get_sndtimeo,
2868         .memcpy_fromiovec       = l2cap_chan_no_memcpy_fromiovec,
2869 };
2870
2871 static inline struct l2cap_chan *smp_new_conn_cb(struct l2cap_chan *pchan)
2872 {
2873         struct l2cap_chan *chan;
2874
2875         BT_DBG("pchan %p", pchan);
2876
2877         chan = l2cap_chan_create();
2878         if (!chan)
2879                 return NULL;
2880
2881         chan->chan_type = pchan->chan_type;
2882         chan->ops       = &smp_chan_ops;
2883         chan->scid      = pchan->scid;
2884         chan->dcid      = chan->scid;
2885         chan->imtu      = pchan->imtu;
2886         chan->omtu      = pchan->omtu;
2887         chan->mode      = pchan->mode;
2888
2889         /* Other L2CAP channels may request SMP routines in order to
2890          * change the security level. This means that the SMP channel
2891          * lock must be considered in its own category to avoid lockdep
2892          * warnings.
2893          */
2894         atomic_set(&chan->nesting, L2CAP_NESTING_SMP);
2895
2896         BT_DBG("created chan %p", chan);
2897
2898         return chan;
2899 }
2900
2901 static const struct l2cap_ops smp_root_chan_ops = {
2902         .name                   = "Security Manager Root",
2903         .new_connection         = smp_new_conn_cb,
2904
2905         /* None of these are implemented for the root channel */
2906         .close                  = l2cap_chan_no_close,
2907         .alloc_skb              = l2cap_chan_no_alloc_skb,
2908         .recv                   = l2cap_chan_no_recv,
2909         .state_change           = l2cap_chan_no_state_change,
2910         .teardown               = l2cap_chan_no_teardown,
2911         .ready                  = l2cap_chan_no_ready,
2912         .defer                  = l2cap_chan_no_defer,
2913         .suspend                = l2cap_chan_no_suspend,
2914         .resume                 = l2cap_chan_no_resume,
2915         .set_shutdown           = l2cap_chan_no_set_shutdown,
2916         .get_sndtimeo           = l2cap_chan_no_get_sndtimeo,
2917         .memcpy_fromiovec       = l2cap_chan_no_memcpy_fromiovec,
2918 };
2919
2920 static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
2921 {
2922         struct l2cap_chan *chan;
2923         struct crypto_blkcipher *tfm_aes;
2924
2925         if (cid == L2CAP_CID_SMP_BREDR) {
2926                 tfm_aes = NULL;
2927                 goto create_chan;
2928         }
2929
2930         tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, 0);
2931         if (IS_ERR(tfm_aes)) {
2932                 BT_ERR("Unable to create crypto context");
2933                 return ERR_PTR(PTR_ERR(tfm_aes));
2934         }
2935
2936 create_chan:
2937         chan = l2cap_chan_create();
2938         if (!chan) {
2939                 crypto_free_blkcipher(tfm_aes);
2940                 return ERR_PTR(-ENOMEM);
2941         }
2942
2943         chan->data = tfm_aes;
2944
2945         l2cap_add_scid(chan, cid);
2946
2947         l2cap_chan_set_defaults(chan);
2948
2949         bacpy(&chan->src, &hdev->bdaddr);
2950         if (cid == L2CAP_CID_SMP)
2951                 chan->src_type = BDADDR_LE_PUBLIC;
2952         else
2953                 chan->src_type = BDADDR_BREDR;
2954         chan->state = BT_LISTEN;
2955         chan->mode = L2CAP_MODE_BASIC;
2956         chan->imtu = L2CAP_DEFAULT_MTU;
2957         chan->ops = &smp_root_chan_ops;
2958
2959         /* Set correct nesting level for a parent/listening channel */
2960         atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
2961
2962         return chan;
2963 }
2964
2965 static void smp_del_chan(struct l2cap_chan *chan)
2966 {
2967         struct crypto_blkcipher *tfm_aes;
2968
2969         BT_DBG("chan %p", chan);
2970
2971         tfm_aes = chan->data;
2972         if (tfm_aes) {
2973                 chan->data = NULL;
2974                 crypto_free_blkcipher(tfm_aes);
2975         }
2976
2977         l2cap_chan_put(chan);
2978 }
2979
2980 int smp_register(struct hci_dev *hdev)
2981 {
2982         struct l2cap_chan *chan;
2983
2984         BT_DBG("%s", hdev->name);
2985
2986         chan = smp_add_cid(hdev, L2CAP_CID_SMP);
2987         if (IS_ERR(chan))
2988                 return PTR_ERR(chan);
2989
2990         hdev->smp_data = chan;
2991
2992         if (!lmp_sc_capable(hdev) &&
2993             !test_bit(HCI_FORCE_LESC, &hdev->dbg_flags))
2994                 return 0;
2995
2996         chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
2997         if (IS_ERR(chan)) {
2998                 int err = PTR_ERR(chan);
2999                 chan = hdev->smp_data;
3000                 hdev->smp_data = NULL;
3001                 smp_del_chan(chan);
3002                 return err;
3003         }
3004
3005         hdev->smp_bredr_data = chan;
3006
3007         return 0;
3008 }
3009
3010 void smp_unregister(struct hci_dev *hdev)
3011 {
3012         struct l2cap_chan *chan;
3013
3014         if (hdev->smp_bredr_data) {
3015                 chan = hdev->smp_bredr_data;
3016                 hdev->smp_bredr_data = NULL;
3017                 smp_del_chan(chan);
3018         }
3019
3020         if (hdev->smp_data) {
3021                 chan = hdev->smp_data;
3022                 hdev->smp_data = NULL;
3023                 smp_del_chan(chan);
3024         }
3025 }