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 "smp.h"
  33
  34 #define SMP_TIMEOUT     msecs_to_jiffies(30000)
  35
  36 #define AUTH_REQ_MASK   0x07
  37
  38 static inline void swap128(u8 src[16], u8 dst[16])
  39 {
  40         int i;
  41         for (i = 0; i < 16; i++)
  42                 dst[15 - i] = src[i];
  43 }
  44
  45 static inline void swap56(u8 src[7], u8 dst[7])
  46 {
  47         int i;
  48         for (i = 0; i < 7; i++)
  49                 dst[6 - i] = src[i];
  50 }
  51
  52 static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
  53 {
  54         struct blkcipher_desc desc;
  55         struct scatterlist sg;
  56         int err;
  57
  58         if (tfm == NULL) {
  59                 BT_ERR("tfm %p", tfm);
  60                 return -EINVAL;
  61         }
  62
  63         desc.tfm = tfm;
  64         desc.flags = 0;
  65
  66         err = crypto_blkcipher_setkey(tfm, k, 16);
  67         if (err) {
  68                 BT_ERR("cipher setkey failed: %d", err);
  69                 return err;
  70         }
  71
  72         sg_init_one(&sg, r, 16);
  73
  74         err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
  75         if (err)
  76                 BT_ERR("Encrypt data error %d", err);
  77
  78         return err;
  79 }
  80
  81 static int smp_ah(struct crypto_blkcipher *tfm, u8 irk[16], u8 r[3], u8 res[3])
  82 {
  83         u8 _res[16], k[16];
  84         int err;
  85
  86         /* r' = padding || r */
  87         memset(_res, 0, 13);
  88         _res[13] = r[2];
  89         _res[14] = r[1];
  90         _res[15] = r[0];
  91
  92         swap128(irk, k);
  93         err = smp_e(tfm, k, _res);
  94         if (err) {
  95                 BT_ERR("Encrypt error");
  96                 return err;
  97         }
  98
  99         /* The output of the random address function ah is:
 100          *      ah(h, r) = e(k, r') mod 2^24
 101          * The output of the security function e is then truncated to 24 bits
 102          * by taking the least significant 24 bits of the output of e as the
 103          * result of ah.
 104          */
 105         res[0] = _res[15];
 106         res[1] = _res[14];
 107         res[2] = _res[13];
 108
 109         return 0;
 110 }
 111
 112 bool smp_irk_matches(struct crypto_blkcipher *tfm, u8 irk[16],
 113                      bdaddr_t *bdaddr)
 114 {
 115         u8 hash[3];
 116         int err;
 117
 118         BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);
 119
 120         err = smp_ah(tfm, irk, &bdaddr->b[3], hash);
 121         if (err)
 122                 return false;
 123
 124         return !memcmp(bdaddr->b, hash, 3);
 125 }
 126
 127 static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
 128                   u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
 129                   u8 _rat, bdaddr_t *ra, u8 res[16])
 130 {
 131         u8 p1[16], p2[16];
 132         int err;
 133
 134         memset(p1, 0, 16);
 135
 136         /* p1 = pres || preq || _rat || _iat */
 137         swap56(pres, p1);
 138         swap56(preq, p1 + 7);
 139         p1[14] = _rat;
 140         p1[15] = _iat;
 141
 142         memset(p2, 0, 16);
 143
 144         /* p2 = padding || ia || ra */
 145         baswap((bdaddr_t *) (p2 + 4), ia);
 146         baswap((bdaddr_t *) (p2 + 10), ra);
 147
 148         /* res = r XOR p1 */
 149         u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
 150
 151         /* res = e(k, res) */
 152         err = smp_e(tfm, k, res);
 153         if (err) {
 154                 BT_ERR("Encrypt data error");
 155                 return err;
 156         }
 157
 158         /* res = res XOR p2 */
 159         u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
 160
 161         /* res = e(k, res) */
 162         err = smp_e(tfm, k, res);
 163         if (err)
 164                 BT_ERR("Encrypt data error");
 165
 166         return err;
 167 }
 168
 169 static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], u8 r1[16],
 170                   u8 r2[16], u8 _r[16])
 171 {
 172         int err;
 173
 174         /* Just least significant octets from r1 and r2 are considered */
 175         memcpy(_r, r1 + 8, 8);
 176         memcpy(_r + 8, r2 + 8, 8);
 177
 178         err = smp_e(tfm, k, _r);
 179         if (err)
 180                 BT_ERR("Encrypt data error");
 181
 182         return err;
 183 }
 184
 185 static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
 186                                      u16 dlen, void *data)
 187 {
 188         struct sk_buff *skb;
 189         struct l2cap_hdr *lh;
 190         int len;
 191
 192         len = L2CAP_HDR_SIZE + sizeof(code) + dlen;
 193
 194         if (len > conn->mtu)
 195                 return NULL;
 196
 197         skb = bt_skb_alloc(len, GFP_ATOMIC);
 198         if (!skb)
 199                 return NULL;
 200
 201         lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
 202         lh->len = cpu_to_le16(sizeof(code) + dlen);
 203         lh->cid = __constant_cpu_to_le16(L2CAP_CID_SMP);
 204
 205         memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code));
 206
 207         memcpy(skb_put(skb, dlen), data, dlen);
 208
 209         return skb;
 210 }
 211
 212 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
 213 {
 214         struct sk_buff *skb = smp_build_cmd(conn, code, len, data);
 215
 216         BT_DBG("code 0x%2.2x", code);
 217
 218         if (!skb)
 219                 return;
 220
 221         skb->priority = HCI_PRIO_MAX;
 222         hci_send_acl(conn->hchan, skb, 0);
 223
 224         cancel_delayed_work_sync(&conn->security_timer);
 225         schedule_delayed_work(&conn->security_timer, SMP_TIMEOUT);
 226 }
 227
 228 static __u8 authreq_to_seclevel(__u8 authreq)
 229 {
 230         if (authreq & SMP_AUTH_MITM)
 231                 return BT_SECURITY_HIGH;
 232         else
 233                 return BT_SECURITY_MEDIUM;
 234 }
 235
 236 static __u8 seclevel_to_authreq(__u8 sec_level)
 237 {
 238         switch (sec_level) {
 239         case BT_SECURITY_HIGH:
 240                 return SMP_AUTH_MITM | SMP_AUTH_BONDING;
 241         case BT_SECURITY_MEDIUM:
 242                 return SMP_AUTH_BONDING;
 243         default:
 244                 return SMP_AUTH_NONE;
 245         }
 246 }
 247
 248 static void build_pairing_cmd(struct l2cap_conn *conn,
 249                               struct smp_cmd_pairing *req,
 250                               struct smp_cmd_pairing *rsp, __u8 authreq)
 251 {
 252         struct smp_chan *smp = conn->smp_chan;
 253         struct hci_conn *hcon = conn->hcon;
 254         struct hci_dev *hdev = hcon->hdev;
 255         u8 local_dist = 0, remote_dist = 0;
 256
 257         if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->dev_flags)) {
 258                 local_dist = SMP_DIST_ENC_KEY;
 259                 remote_dist = SMP_DIST_ENC_KEY;
 260                 authreq |= SMP_AUTH_BONDING;
 261         } else {
 262                 authreq &= ~SMP_AUTH_BONDING;
 263         }
 264
 265         if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
 266                 remote_dist |= SMP_DIST_ID_KEY;
 267
 268         if (rsp == NULL) {
 269                 req->io_capability = conn->hcon->io_capability;
 270                 req->oob_flag = SMP_OOB_NOT_PRESENT;
 271                 req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 272                 req->init_key_dist = local_dist;
 273                 req->resp_key_dist = remote_dist;
 274                 req->auth_req = (authreq & AUTH_REQ_MASK);
 275
 276                 smp->remote_key_dist = remote_dist;
 277                 return;
 278         }
 279
 280         rsp->io_capability = conn->hcon->io_capability;
 281         rsp->oob_flag = SMP_OOB_NOT_PRESENT;
 282         rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 283         rsp->init_key_dist = req->init_key_dist & remote_dist;
 284         rsp->resp_key_dist = req->resp_key_dist & local_dist;
 285         rsp->auth_req = (authreq & AUTH_REQ_MASK);
 286
 287         smp->remote_key_dist = rsp->init_key_dist;
 288 }
 289
 290 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
 291 {
 292         struct smp_chan *smp = conn->smp_chan;
 293
 294         if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
 295             (max_key_size < SMP_MIN_ENC_KEY_SIZE))
 296                 return SMP_ENC_KEY_SIZE;
 297
 298         smp->enc_key_size = max_key_size;
 299
 300         return 0;
 301 }
 302
 303 static void smp_failure(struct l2cap_conn *conn, u8 reason)
 304 {
 305         struct hci_conn *hcon = conn->hcon;
 306
 307         if (reason)
 308                 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
 309                              &reason);
 310
 311         clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags);
 312         mgmt_auth_failed(hcon->hdev, &hcon->dst, hcon->type, hcon->dst_type,
 313                          HCI_ERROR_AUTH_FAILURE);
 314
 315         cancel_delayed_work_sync(&conn->security_timer);
 316
 317         if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 318                 smp_chan_destroy(conn);
 319 }
 320
 321 #define JUST_WORKS      0x00
 322 #define JUST_CFM        0x01
 323 #define REQ_PASSKEY     0x02
 324 #define CFM_PASSKEY     0x03
 325 #define REQ_OOB         0x04
 326 #define OVERLAP         0xFF
 327
 328 static const u8 gen_method[5][5] = {
 329         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 330         { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
 331         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
 332         { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
 333         { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP     },
 334 };
 335
 336 static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
 337                                                 u8 local_io, u8 remote_io)
 338 {
 339         struct hci_conn *hcon = conn->hcon;
 340         struct smp_chan *smp = conn->smp_chan;
 341         u8 method;
 342         u32 passkey = 0;
 343         int ret = 0;
 344
 345         /* Initialize key for JUST WORKS */
 346         memset(smp->tk, 0, sizeof(smp->tk));
 347         clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 348
 349         BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
 350
 351         /* If neither side wants MITM, use JUST WORKS */
 352         /* If either side has unknown io_caps, use JUST WORKS */
 353         /* Otherwise, look up method from the table */
 354         if (!(auth & SMP_AUTH_MITM) ||
 355             local_io > SMP_IO_KEYBOARD_DISPLAY ||
 356             remote_io > SMP_IO_KEYBOARD_DISPLAY)
 357                 method = JUST_WORKS;
 358         else
 359                 method = gen_method[remote_io][local_io];
 360
 361         /* If not bonding, don't ask user to confirm a Zero TK */
 362         if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM)
 363                 method = JUST_WORKS;
 364
 365         /* If Just Works, Continue with Zero TK */
 366         if (method == JUST_WORKS) {
 367                 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 368                 return 0;
 369         }
 370
 371         /* Not Just Works/Confirm results in MITM Authentication */
 372         if (method != JUST_CFM)
 373                 set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags);
 374
 375         /* If both devices have Keyoard-Display I/O, the master
 376          * Confirms and the slave Enters the passkey.
 377          */
 378         if (method == OVERLAP) {
 379                 if (hcon->link_mode & HCI_LM_MASTER)
 380                         method = CFM_PASSKEY;
 381                 else
 382                         method = REQ_PASSKEY;
 383         }
 384
 385         /* Generate random passkey. Not valid until confirmed. */
 386         if (method == CFM_PASSKEY) {
 387                 u8 key[16];
 388
 389                 memset(key, 0, sizeof(key));
 390                 get_random_bytes(&passkey, sizeof(passkey));
 391                 passkey %= 1000000;
 392                 put_unaligned_le32(passkey, key);
 393                 swap128(key, smp->tk);
 394                 BT_DBG("PassKey: %d", passkey);
 395         }
 396
 397         hci_dev_lock(hcon->hdev);
 398
 399         if (method == REQ_PASSKEY)
 400                 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
 401                                                 hcon->type, hcon->dst_type);
 402         else
 403                 ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
 404                                                 hcon->type, hcon->dst_type,
 405                                                 cpu_to_le32(passkey), 0);
 406
 407         hci_dev_unlock(hcon->hdev);
 408
 409         return ret;
 410 }
 411
 412 static void confirm_work(struct work_struct *work)
 413 {
 414         struct smp_chan *smp = container_of(work, struct smp_chan, confirm);
 415         struct l2cap_conn *conn = smp->conn;
 416         struct crypto_blkcipher *tfm;
 417         struct smp_cmd_pairing_confirm cp;
 418         int ret;
 419         u8 res[16], reason;
 420
 421         BT_DBG("conn %p", conn);
 422
 423         tfm = crypto_alloc_blkcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
 424         if (IS_ERR(tfm)) {
 425                 reason = SMP_UNSPECIFIED;
 426                 goto error;
 427         }
 428
 429         smp->tfm = tfm;
 430
 431         if (conn->hcon->out)
 432                 ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
 433                              conn->hcon->src_type, &conn->hcon->src,
 434                              conn->hcon->dst_type, &conn->hcon->dst, res);
 435         else
 436                 ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
 437                              conn->hcon->dst_type, &conn->hcon->dst,
 438                              conn->hcon->src_type, &conn->hcon->src, res);
 439         if (ret) {
 440                 reason = SMP_UNSPECIFIED;
 441                 goto error;
 442         }
 443
 444         clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 445
 446         swap128(res, cp.confirm_val);
 447         smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
 448
 449         return;
 450
 451 error:
 452         smp_failure(conn, reason);
 453 }
 454
 455 static void random_work(struct work_struct *work)
 456 {
 457         struct smp_chan *smp = container_of(work, struct smp_chan, random);
 458         struct l2cap_conn *conn = smp->conn;
 459         struct hci_conn *hcon = conn->hcon;
 460         struct crypto_blkcipher *tfm = smp->tfm;
 461         u8 reason, confirm[16], res[16], key[16];
 462         int ret;
 463
 464         if (IS_ERR_OR_NULL(tfm)) {
 465                 reason = SMP_UNSPECIFIED;
 466                 goto error;
 467         }
 468
 469         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 470
 471         if (hcon->out)
 472                 ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
 473                              hcon->src_type, &hcon->src,
 474                              hcon->dst_type, &hcon->dst, res);
 475         else
 476                 ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
 477                              hcon->dst_type, &hcon->dst,
 478                              hcon->src_type, &hcon->src, res);
 479         if (ret) {
 480                 reason = SMP_UNSPECIFIED;
 481                 goto error;
 482         }
 483
 484         swap128(res, confirm);
 485
 486         if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
 487                 BT_ERR("Pairing failed (confirmation values mismatch)");
 488                 reason = SMP_CONFIRM_FAILED;
 489                 goto error;
 490         }
 491
 492         if (hcon->out) {
 493                 u8 stk[16], rand[8];
 494                 __le16 ediv;
 495
 496                 memset(rand, 0, sizeof(rand));
 497                 ediv = 0;
 498
 499                 smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, key);
 500                 swap128(key, stk);
 501
 502                 memset(stk + smp->enc_key_size, 0,
 503                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 504
 505                 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) {
 506                         reason = SMP_UNSPECIFIED;
 507                         goto error;
 508                 }
 509
 510                 hci_le_start_enc(hcon, ediv, rand, stk);
 511                 hcon->enc_key_size = smp->enc_key_size;
 512         } else {
 513                 u8 stk[16], r[16], rand[8];
 514                 __le16 ediv;
 515
 516                 memset(rand, 0, sizeof(rand));
 517                 ediv = 0;
 518
 519                 swap128(smp->prnd, r);
 520                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(r), r);
 521
 522                 smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, key);
 523                 swap128(key, stk);
 524
 525                 memset(stk + smp->enc_key_size, 0,
 526                        SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
 527
 528                 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
 529                             HCI_SMP_STK_SLAVE, 0, 0, stk, smp->enc_key_size,
 530                             ediv, rand);
 531         }
 532
 533         return;
 534
 535 error:
 536         smp_failure(conn, reason);
 537 }
 538
 539 static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
 540 {
 541         struct smp_chan *smp;
 542
 543         smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
 544         if (!smp)
 545                 return NULL;
 546
 547         INIT_WORK(&smp->confirm, confirm_work);
 548         INIT_WORK(&smp->random, random_work);
 549
 550         smp->conn = conn;
 551         conn->smp_chan = smp;
 552         conn->hcon->smp_conn = conn;
 553
 554         hci_conn_hold(conn->hcon);
 555
 556         return smp;
 557 }
 558
 559 void smp_chan_destroy(struct l2cap_conn *conn)
 560 {
 561         struct smp_chan *smp = conn->smp_chan;
 562
 563         BUG_ON(!smp);
 564
 565         if (smp->tfm)
 566                 crypto_free_blkcipher(smp->tfm);
 567
 568         kfree(smp);
 569         conn->smp_chan = NULL;
 570         conn->hcon->smp_conn = NULL;
 571         hci_conn_drop(conn->hcon);
 572 }
 573
 574 int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
 575 {
 576         struct l2cap_conn *conn = hcon->smp_conn;
 577         struct smp_chan *smp;
 578         u32 value;
 579         u8 key[16];
 580
 581         BT_DBG("");
 582
 583         if (!conn)
 584                 return -ENOTCONN;
 585
 586         smp = conn->smp_chan;
 587
 588         switch (mgmt_op) {
 589         case MGMT_OP_USER_PASSKEY_REPLY:
 590                 value = le32_to_cpu(passkey);
 591                 memset(key, 0, sizeof(key));
 592                 BT_DBG("PassKey: %d", value);
 593                 put_unaligned_le32(value, key);
 594                 swap128(key, smp->tk);
 595                 /* Fall Through */
 596         case MGMT_OP_USER_CONFIRM_REPLY:
 597                 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
 598                 break;
 599         case MGMT_OP_USER_PASSKEY_NEG_REPLY:
 600         case MGMT_OP_USER_CONFIRM_NEG_REPLY:
 601                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
 602                 return 0;
 603         default:
 604                 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
 605                 return -EOPNOTSUPP;
 606         }
 607
 608         /* If it is our turn to send Pairing Confirm, do so now */
 609         if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags))
 610                 queue_work(hcon->hdev->workqueue, &smp->confirm);
 611
 612         return 0;
 613 }
 614
 615 static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
 616 {
 617         struct smp_cmd_pairing rsp, *req = (void *) skb->data;
 618         struct smp_chan *smp;
 619         u8 key_size;
 620         u8 auth = SMP_AUTH_NONE;
 621         int ret;
 622
 623         BT_DBG("conn %p", conn);
 624
 625         if (skb->len < sizeof(*req))
 626                 return SMP_UNSPECIFIED;
 627
 628         if (conn->hcon->link_mode & HCI_LM_MASTER)
 629                 return SMP_CMD_NOTSUPP;
 630
 631         if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
 632                 smp = smp_chan_create(conn);
 633         else
 634                 smp = conn->smp_chan;
 635
 636         if (!smp)
 637                 return SMP_UNSPECIFIED;
 638
 639         smp->preq[0] = SMP_CMD_PAIRING_REQ;
 640         memcpy(&smp->preq[1], req, sizeof(*req));
 641         skb_pull(skb, sizeof(*req));
 642
 643         /* We didn't start the pairing, so match remote */
 644         if (req->auth_req & SMP_AUTH_BONDING)
 645                 auth = req->auth_req;
 646
 647         conn->hcon->pending_sec_level = authreq_to_seclevel(auth);
 648
 649         build_pairing_cmd(conn, req, &rsp, auth);
 650
 651         key_size = min(req->max_key_size, rsp.max_key_size);
 652         if (check_enc_key_size(conn, key_size))
 653                 return SMP_ENC_KEY_SIZE;
 654
 655         get_random_bytes(smp->prnd, sizeof(smp->prnd));
 656
 657         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
 658         memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
 659
 660         smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
 661
 662         /* Request setup of TK */
 663         ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
 664         if (ret)
 665                 return SMP_UNSPECIFIED;
 666
 667         return 0;
 668 }
 669
 670 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
 671 {
 672         struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
 673         struct smp_chan *smp = conn->smp_chan;
 674         struct hci_dev *hdev = conn->hcon->hdev;
 675         u8 key_size, auth = SMP_AUTH_NONE;
 676         int ret;
 677
 678         BT_DBG("conn %p", conn);
 679
 680         if (skb->len < sizeof(*rsp))
 681                 return SMP_UNSPECIFIED;
 682
 683         if (!(conn->hcon->link_mode & HCI_LM_MASTER))
 684                 return SMP_CMD_NOTSUPP;
 685
 686         skb_pull(skb, sizeof(*rsp));
 687
 688         req = (void *) &smp->preq[1];
 689
 690         key_size = min(req->max_key_size, rsp->max_key_size);
 691         if (check_enc_key_size(conn, key_size))
 692                 return SMP_ENC_KEY_SIZE;
 693
 694         get_random_bytes(smp->prnd, sizeof(smp->prnd));
 695
 696         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
 697         memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
 698
 699         if ((req->auth_req & SMP_AUTH_BONDING) &&
 700             (rsp->auth_req & SMP_AUTH_BONDING))
 701                 auth = SMP_AUTH_BONDING;
 702
 703         auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
 704
 705         ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
 706         if (ret)
 707                 return SMP_UNSPECIFIED;
 708
 709         set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 710
 711         /* Can't compose response until we have been confirmed */
 712         if (!test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
 713                 return 0;
 714
 715         queue_work(hdev->workqueue, &smp->confirm);
 716
 717         return 0;
 718 }
 719
 720 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
 721 {
 722         struct smp_chan *smp = conn->smp_chan;
 723         struct hci_dev *hdev = conn->hcon->hdev;
 724
 725         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 726
 727         if (skb->len < sizeof(smp->pcnf))
 728                 return SMP_UNSPECIFIED;
 729
 730         memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
 731         skb_pull(skb, sizeof(smp->pcnf));
 732
 733         if (conn->hcon->out) {
 734                 u8 random[16];
 735
 736                 swap128(smp->prnd, random);
 737                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(random),
 738                              random);
 739         } else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags)) {
 740                 queue_work(hdev->workqueue, &smp->confirm);
 741         } else {
 742                 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 743         }
 744
 745         return 0;
 746 }
 747
 748 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
 749 {
 750         struct smp_chan *smp = conn->smp_chan;
 751         struct hci_dev *hdev = conn->hcon->hdev;
 752
 753         BT_DBG("conn %p", conn);
 754
 755         if (skb->len < sizeof(smp->rrnd))
 756                 return SMP_UNSPECIFIED;
 757
 758         swap128(skb->data, smp->rrnd);
 759         skb_pull(skb, sizeof(smp->rrnd));
 760
 761         queue_work(hdev->workqueue, &smp->random);
 762
 763         return 0;
 764 }
 765
 766 static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
 767 {
 768         struct smp_ltk *key;
 769         struct hci_conn *hcon = conn->hcon;
 770
 771         key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type,
 772                                    hcon->out);
 773         if (!key)
 774                 return 0;
 775
 776         if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
 777                 return 0;
 778
 779         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
 780                 return 1;
 781
 782         hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
 783         hcon->enc_key_size = key->enc_size;
 784
 785         return 1;
 786 }
 787
 788 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
 789 {
 790         struct smp_cmd_security_req *rp = (void *) skb->data;
 791         struct smp_cmd_pairing cp;
 792         struct hci_conn *hcon = conn->hcon;
 793         struct smp_chan *smp;
 794
 795         BT_DBG("conn %p", conn);
 796
 797         if (skb->len < sizeof(*rp))
 798                 return SMP_UNSPECIFIED;
 799
 800         if (!(conn->hcon->link_mode & HCI_LM_MASTER))
 801                 return SMP_CMD_NOTSUPP;
 802
 803         hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
 804
 805         if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
 806                 return 0;
 807
 808         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 809                 return 0;
 810
 811         smp = smp_chan_create(conn);
 812
 813         skb_pull(skb, sizeof(*rp));
 814
 815         memset(&cp, 0, sizeof(cp));
 816         build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
 817
 818         smp->preq[0] = SMP_CMD_PAIRING_REQ;
 819         memcpy(&smp->preq[1], &cp, sizeof(cp));
 820
 821         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 822
 823         return 0;
 824 }
 825
 826 bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level)
 827 {
 828         if (sec_level == BT_SECURITY_LOW)
 829                 return true;
 830
 831         if (hcon->sec_level >= sec_level)
 832                 return true;
 833
 834         return false;
 835 }
 836
 837 int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
 838 {
 839         struct l2cap_conn *conn = hcon->l2cap_data;
 840         struct smp_chan *smp = conn->smp_chan;
 841         __u8 authreq;
 842
 843         BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
 844
 845         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
 846                 return 1;
 847
 848         if (smp_sufficient_security(hcon, sec_level))
 849                 return 1;
 850
 851         if (hcon->link_mode & HCI_LM_MASTER)
 852                 if (smp_ltk_encrypt(conn, sec_level))
 853                         goto done;
 854
 855         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 856                 return 0;
 857
 858         smp = smp_chan_create(conn);
 859         if (!smp)
 860                 return 1;
 861
 862         authreq = seclevel_to_authreq(sec_level);
 863
 864         if (hcon->link_mode & HCI_LM_MASTER) {
 865                 struct smp_cmd_pairing cp;
 866
 867                 build_pairing_cmd(conn, &cp, NULL, authreq);
 868                 smp->preq[0] = SMP_CMD_PAIRING_REQ;
 869                 memcpy(&smp->preq[1], &cp, sizeof(cp));
 870
 871                 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 872         } else {
 873                 struct smp_cmd_security_req cp;
 874                 cp.auth_req = authreq;
 875                 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
 876         }
 877
 878 done:
 879         hcon->pending_sec_level = sec_level;
 880
 881         return 0;
 882 }
 883
 884 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
 885 {
 886         struct smp_cmd_encrypt_info *rp = (void *) skb->data;
 887         struct smp_chan *smp = conn->smp_chan;
 888
 889         BT_DBG("conn %p", conn);
 890
 891         if (skb->len < sizeof(*rp))
 892                 return SMP_UNSPECIFIED;
 893
 894         /* Ignore this PDU if it wasn't requested */
 895         if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
 896                 return 0;
 897
 898         skb_pull(skb, sizeof(*rp));
 899
 900         memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
 901
 902         return 0;
 903 }
 904
 905 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
 906 {
 907         struct smp_cmd_master_ident *rp = (void *) skb->data;
 908         struct smp_chan *smp = conn->smp_chan;
 909         struct hci_dev *hdev = conn->hcon->hdev;
 910         struct hci_conn *hcon = conn->hcon;
 911         u8 authenticated;
 912
 913         BT_DBG("conn %p", conn);
 914
 915         if (skb->len < sizeof(*rp))
 916                 return SMP_UNSPECIFIED;
 917
 918         /* Ignore this PDU if it wasn't requested */
 919         if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
 920                 return 0;
 921
 922         skb_pull(skb, sizeof(*rp));
 923
 924         hci_dev_lock(hdev);
 925         authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
 926         hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK, 1,
 927                     authenticated, smp->tk, smp->enc_key_size,
 928                     rp->ediv, rp->rand);
 929         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
 930                 smp_distribute_keys(conn, 1);
 931         hci_dev_unlock(hdev);
 932
 933         return 0;
 934 }
 935
 936 static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
 937 {
 938         struct smp_cmd_ident_info *info = (void *) skb->data;
 939         struct smp_chan *smp = conn->smp_chan;
 940
 941         BT_DBG("");
 942
 943         if (skb->len < sizeof(*info))
 944                 return SMP_UNSPECIFIED;
 945
 946         /* Ignore this PDU if it wasn't requested */
 947         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
 948                 return 0;
 949
 950         skb_pull(skb, sizeof(*info));
 951
 952         memcpy(smp->irk, info->irk, 16);
 953
 954         return 0;
 955 }
 956
 957 static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
 958                                    struct sk_buff *skb)
 959 {
 960         struct smp_cmd_ident_addr_info *info = (void *) skb->data;
 961         struct smp_chan *smp = conn->smp_chan;
 962         struct hci_conn *hcon = conn->hcon;
 963         bdaddr_t rpa;
 964
 965         BT_DBG("");
 966
 967         if (skb->len < sizeof(*info))
 968                 return SMP_UNSPECIFIED;
 969
 970         /* Ignore this PDU if it wasn't requested */
 971         if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
 972                 return 0;
 973
 974         skb_pull(skb, sizeof(*info));
 975
 976         bacpy(&smp->id_addr, &info->bdaddr);
 977         smp->id_addr_type = info->addr_type;
 978
 979         if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
 980                 bacpy(&rpa, &hcon->dst);
 981         else
 982                 bacpy(&rpa, BDADDR_ANY);
 983
 984         hci_add_irk(conn->hcon->hdev, &smp->id_addr, smp->id_addr_type,
 985                     smp->irk, &rpa);
 986
 987         smp_distribute_keys(conn, 1);
 988
 989         return 0;
 990 }
 991
 992 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
 993 {
 994         struct hci_conn *hcon = conn->hcon;
 995         __u8 code, reason;
 996         int err = 0;
 997
 998         if (hcon->type != LE_LINK) {
 999                 kfree_skb(skb);
1000                 return 0;
1001         }
1002
1003         if (skb->len < 1) {
1004                 kfree_skb(skb);
1005                 return -EILSEQ;
1006         }
1007
1008         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
1009                 err = -ENOTSUPP;
1010                 reason = SMP_PAIRING_NOTSUPP;
1011                 goto done;
1012         }
1013
1014         code = skb->data[0];
1015         skb_pull(skb, sizeof(code));
1016
1017         /*
1018          * The SMP context must be initialized for all other PDUs except
1019          * pairing and security requests. If we get any other PDU when
1020          * not initialized simply disconnect (done if this function
1021          * returns an error).
1022          */
1023         if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
1024             !conn->smp_chan) {
1025                 BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
1026                 kfree_skb(skb);
1027                 return -ENOTSUPP;
1028         }
1029
1030         switch (code) {
1031         case SMP_CMD_PAIRING_REQ:
1032                 reason = smp_cmd_pairing_req(conn, skb);
1033                 break;
1034
1035         case SMP_CMD_PAIRING_FAIL:
1036                 smp_failure(conn, 0);
1037                 reason = 0;
1038                 err = -EPERM;
1039                 break;
1040
1041         case SMP_CMD_PAIRING_RSP:
1042                 reason = smp_cmd_pairing_rsp(conn, skb);
1043                 break;
1044
1045         case SMP_CMD_SECURITY_REQ:
1046                 reason = smp_cmd_security_req(conn, skb);
1047                 break;
1048
1049         case SMP_CMD_PAIRING_CONFIRM:
1050                 reason = smp_cmd_pairing_confirm(conn, skb);
1051                 break;
1052
1053         case SMP_CMD_PAIRING_RANDOM:
1054                 reason = smp_cmd_pairing_random(conn, skb);
1055                 break;
1056
1057         case SMP_CMD_ENCRYPT_INFO:
1058                 reason = smp_cmd_encrypt_info(conn, skb);
1059                 break;
1060
1061         case SMP_CMD_MASTER_IDENT:
1062                 reason = smp_cmd_master_ident(conn, skb);
1063                 break;
1064
1065         case SMP_CMD_IDENT_INFO:
1066                 reason = smp_cmd_ident_info(conn, skb);
1067                 break;
1068
1069         case SMP_CMD_IDENT_ADDR_INFO:
1070                 reason = smp_cmd_ident_addr_info(conn, skb);
1071                 break;
1072
1073         case SMP_CMD_SIGN_INFO:
1074                 /* Just ignored */
1075                 reason = 0;
1076                 break;
1077
1078         default:
1079                 BT_DBG("Unknown command code 0x%2.2x", code);
1080
1081                 reason = SMP_CMD_NOTSUPP;
1082                 err = -EOPNOTSUPP;
1083                 goto done;
1084         }
1085
1086 done:
1087         if (reason)
1088                 smp_failure(conn, reason);
1089
1090         kfree_skb(skb);
1091         return err;
1092 }
1093
1094 int smp_distribute_keys(struct l2cap_conn *conn, __u8 force)
1095 {
1096         struct smp_cmd_pairing *req, *rsp;
1097         struct smp_chan *smp = conn->smp_chan;
1098         __u8 *keydist;
1099
1100         BT_DBG("conn %p force %d", conn, force);
1101
1102         if (!test_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
1103                 return 0;
1104
1105         rsp = (void *) &smp->prsp[1];
1106
1107         /* The responder sends its keys first */
1108         if (!force && conn->hcon->out && (rsp->resp_key_dist & 0x07))
1109                 return 0;
1110
1111         req = (void *) &smp->preq[1];
1112
1113         if (conn->hcon->out) {
1114                 keydist = &rsp->init_key_dist;
1115                 *keydist &= req->init_key_dist;
1116         } else {
1117                 keydist = &rsp->resp_key_dist;
1118                 *keydist &= req->resp_key_dist;
1119         }
1120
1121         BT_DBG("keydist 0x%x", *keydist);
1122
1123         if (*keydist & SMP_DIST_ENC_KEY) {
1124                 struct smp_cmd_encrypt_info enc;
1125                 struct smp_cmd_master_ident ident;
1126                 struct hci_conn *hcon = conn->hcon;
1127                 u8 authenticated;
1128                 __le16 ediv;
1129
1130                 get_random_bytes(enc.ltk, sizeof(enc.ltk));
1131                 get_random_bytes(&ediv, sizeof(ediv));
1132                 get_random_bytes(ident.rand, sizeof(ident.rand));
1133
1134                 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1135
1136                 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
1137                 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
1138                             HCI_SMP_LTK_SLAVE, 1, authenticated,
1139                             enc.ltk, smp->enc_key_size, ediv, ident.rand);
1140
1141                 ident.ediv = ediv;
1142
1143                 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1144
1145                 *keydist &= ~SMP_DIST_ENC_KEY;
1146         }
1147
1148         if (*keydist & SMP_DIST_ID_KEY) {
1149                 struct smp_cmd_ident_addr_info addrinfo;
1150                 struct smp_cmd_ident_info idinfo;
1151
1152                 /* Send a dummy key */
1153                 get_random_bytes(idinfo.irk, sizeof(idinfo.irk));
1154
1155                 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1156
1157                 /* Just public address */
1158                 memset(&addrinfo, 0, sizeof(addrinfo));
1159                 bacpy(&addrinfo.bdaddr, &conn->hcon->src);
1160
1161                 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1162                              &addrinfo);
1163
1164                 *keydist &= ~SMP_DIST_ID_KEY;
1165         }
1166
1167         if (*keydist & SMP_DIST_SIGN) {
1168                 struct smp_cmd_sign_info sign;
1169
1170                 /* Send a dummy key */
1171                 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1172
1173                 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1174
1175                 *keydist &= ~SMP_DIST_SIGN;
1176         }
1177
1178         if (conn->hcon->out || force) {
1179                 clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags);
1180                 cancel_delayed_work_sync(&conn->security_timer);
1181                 smp_chan_destroy(conn);
1182         }
1183
1184         return 0;
1185 }