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