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