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