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 = 0;
 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 = 0;
 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 (conn->hcon->link_mode & HCI_LM_MASTER)
 569                 return SMP_CMD_NOTSUPP;
 570
 571         if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
 572                 smp = smp_chan_create(conn);
 573         else
 574                 smp = conn->smp_chan;
 575
 576         if (!smp)
 577                 return SMP_UNSPECIFIED;
 578
 579         smp->preq[0] = SMP_CMD_PAIRING_REQ;
 580         memcpy(&smp->preq[1], req, sizeof(*req));
 581         skb_pull(skb, sizeof(*req));
 582
 583         /* We didn't start the pairing, so match remote */
 584         if (req->auth_req & SMP_AUTH_BONDING)
 585                 auth = req->auth_req;
 586
 587         conn->hcon->pending_sec_level = authreq_to_seclevel(auth);
 588
 589         build_pairing_cmd(conn, req, &rsp, auth);
 590
 591         key_size = min(req->max_key_size, rsp.max_key_size);
 592         if (check_enc_key_size(conn, key_size))
 593                 return SMP_ENC_KEY_SIZE;
 594
 595         get_random_bytes(smp->prnd, sizeof(smp->prnd));
 596
 597         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
 598         memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
 599
 600         smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
 601
 602         /* Request setup of TK */
 603         ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
 604         if (ret)
 605                 return SMP_UNSPECIFIED;
 606
 607         return 0;
 608 }
 609
 610 static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
 611 {
 612         struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
 613         struct smp_chan *smp = conn->smp_chan;
 614         struct hci_dev *hdev = conn->hcon->hdev;
 615         u8 key_size, auth = SMP_AUTH_NONE;
 616         int ret;
 617
 618         BT_DBG("conn %p", conn);
 619
 620         if (!(conn->hcon->link_mode & HCI_LM_MASTER))
 621                 return SMP_CMD_NOTSUPP;
 622
 623         skb_pull(skb, sizeof(*rsp));
 624
 625         req = (void *) &smp->preq[1];
 626
 627         key_size = min(req->max_key_size, rsp->max_key_size);
 628         if (check_enc_key_size(conn, key_size))
 629                 return SMP_ENC_KEY_SIZE;
 630
 631         get_random_bytes(smp->prnd, sizeof(smp->prnd));
 632
 633         smp->prsp[0] = SMP_CMD_PAIRING_RSP;
 634         memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
 635
 636         if ((req->auth_req & SMP_AUTH_BONDING) &&
 637             (rsp->auth_req & SMP_AUTH_BONDING))
 638                 auth = SMP_AUTH_BONDING;
 639
 640         auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
 641
 642         ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
 643         if (ret)
 644                 return SMP_UNSPECIFIED;
 645
 646         set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 647
 648         /* Can't compose response until we have been confirmed */
 649         if (!test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
 650                 return 0;
 651
 652         queue_work(hdev->workqueue, &smp->confirm);
 653
 654         return 0;
 655 }
 656
 657 static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
 658 {
 659         struct smp_chan *smp = conn->smp_chan;
 660         struct hci_dev *hdev = conn->hcon->hdev;
 661
 662         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 663
 664         memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
 665         skb_pull(skb, sizeof(smp->pcnf));
 666
 667         if (conn->hcon->out) {
 668                 u8 random[16];
 669
 670                 swap128(smp->prnd, random);
 671                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(random),
 672                              random);
 673         } else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags)) {
 674                 queue_work(hdev->workqueue, &smp->confirm);
 675         } else {
 676                 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
 677         }
 678
 679         return 0;
 680 }
 681
 682 static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
 683 {
 684         struct smp_chan *smp = conn->smp_chan;
 685         struct hci_dev *hdev = conn->hcon->hdev;
 686
 687         BT_DBG("conn %p", conn);
 688
 689         swap128(skb->data, smp->rrnd);
 690         skb_pull(skb, sizeof(smp->rrnd));
 691
 692         queue_work(hdev->workqueue, &smp->random);
 693
 694         return 0;
 695 }
 696
 697 static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
 698 {
 699         struct smp_ltk *key;
 700         struct hci_conn *hcon = conn->hcon;
 701
 702         key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type);
 703         if (!key)
 704                 return 0;
 705
 706         if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
 707                 return 0;
 708
 709         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
 710                 return 1;
 711
 712         hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
 713         hcon->enc_key_size = key->enc_size;
 714
 715         return 1;
 716 }
 717
 718 static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
 719 {
 720         struct smp_cmd_security_req *rp = (void *) skb->data;
 721         struct smp_cmd_pairing cp;
 722         struct hci_conn *hcon = conn->hcon;
 723         struct smp_chan *smp;
 724
 725         BT_DBG("conn %p", conn);
 726
 727         if (!(conn->hcon->link_mode & HCI_LM_MASTER))
 728                 return SMP_CMD_NOTSUPP;
 729
 730         hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
 731
 732         if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
 733                 return 0;
 734
 735         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 736                 return 0;
 737
 738         smp = smp_chan_create(conn);
 739
 740         skb_pull(skb, sizeof(*rp));
 741
 742         memset(&cp, 0, sizeof(cp));
 743         build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
 744
 745         smp->preq[0] = SMP_CMD_PAIRING_REQ;
 746         memcpy(&smp->preq[1], &cp, sizeof(cp));
 747
 748         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 749
 750         return 0;
 751 }
 752
 753 bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level)
 754 {
 755         if (sec_level == BT_SECURITY_LOW)
 756                 return true;
 757
 758         if (hcon->sec_level >= sec_level)
 759                 return true;
 760
 761         return false;
 762 }
 763
 764 int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
 765 {
 766         struct l2cap_conn *conn = hcon->l2cap_data;
 767         struct smp_chan *smp = conn->smp_chan;
 768         __u8 authreq;
 769
 770         BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
 771
 772         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
 773                 return 1;
 774
 775         if (smp_sufficient_security(hcon, sec_level))
 776                 return 1;
 777
 778         if (hcon->link_mode & HCI_LM_MASTER)
 779                 if (smp_ltk_encrypt(conn, sec_level))
 780                         goto done;
 781
 782         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
 783                 return 0;
 784
 785         smp = smp_chan_create(conn);
 786         if (!smp)
 787                 return 1;
 788
 789         authreq = seclevel_to_authreq(sec_level);
 790
 791         if (hcon->link_mode & HCI_LM_MASTER) {
 792                 struct smp_cmd_pairing cp;
 793
 794                 build_pairing_cmd(conn, &cp, NULL, authreq);
 795                 smp->preq[0] = SMP_CMD_PAIRING_REQ;
 796                 memcpy(&smp->preq[1], &cp, sizeof(cp));
 797
 798                 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 799         } else {
 800                 struct smp_cmd_security_req cp;
 801                 cp.auth_req = authreq;
 802                 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
 803         }
 804
 805 done:
 806         hcon->pending_sec_level = sec_level;
 807
 808         return 0;
 809 }
 810
 811 static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
 812 {
 813         struct smp_cmd_encrypt_info *rp = (void *) skb->data;
 814         struct smp_chan *smp = conn->smp_chan;
 815
 816         skb_pull(skb, sizeof(*rp));
 817
 818         memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
 819
 820         return 0;
 821 }
 822
 823 static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
 824 {
 825         struct smp_cmd_master_ident *rp = (void *) skb->data;
 826         struct smp_chan *smp = conn->smp_chan;
 827         struct hci_dev *hdev = conn->hcon->hdev;
 828         struct hci_conn *hcon = conn->hcon;
 829         u8 authenticated;
 830
 831         skb_pull(skb, sizeof(*rp));
 832
 833         hci_dev_lock(hdev);
 834         authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
 835         hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK, 1,
 836                     authenticated, smp->tk, smp->enc_key_size,
 837                     rp->ediv, rp->rand);
 838         smp_distribute_keys(conn, 1);
 839         hci_dev_unlock(hdev);
 840
 841         return 0;
 842 }
 843
 844 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
 845 {
 846         struct hci_conn *hcon = conn->hcon;
 847         __u8 code, reason;
 848         int err = 0;
 849
 850         if (hcon->type != LE_LINK) {
 851                 kfree_skb(skb);
 852                 return 0;
 853         }
 854
 855         if (skb->len < 1) {
 856                 kfree_skb(skb);
 857                 return -EILSEQ;
 858         }
 859
 860         if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
 861                 err = -ENOTSUPP;
 862                 reason = SMP_PAIRING_NOTSUPP;
 863                 goto done;
 864         }
 865
 866         code = skb->data[0];
 867         skb_pull(skb, sizeof(code));
 868
 869         /*
 870          * The SMP context must be initialized for all other PDUs except
 871          * pairing and security requests. If we get any other PDU when
 872          * not initialized simply disconnect (done if this function
 873          * returns an error).
 874          */
 875         if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
 876             !conn->smp_chan) {
 877                 BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
 878                 kfree_skb(skb);
 879                 return -ENOTSUPP;
 880         }
 881
 882         switch (code) {
 883         case SMP_CMD_PAIRING_REQ:
 884                 reason = smp_cmd_pairing_req(conn, skb);
 885                 break;
 886
 887         case SMP_CMD_PAIRING_FAIL:
 888                 smp_failure(conn, 0);
 889                 reason = 0;
 890                 err = -EPERM;
 891                 break;
 892
 893         case SMP_CMD_PAIRING_RSP:
 894                 reason = smp_cmd_pairing_rsp(conn, skb);
 895                 break;
 896
 897         case SMP_CMD_SECURITY_REQ:
 898                 reason = smp_cmd_security_req(conn, skb);
 899                 break;
 900
 901         case SMP_CMD_PAIRING_CONFIRM:
 902                 reason = smp_cmd_pairing_confirm(conn, skb);
 903                 break;
 904
 905         case SMP_CMD_PAIRING_RANDOM:
 906                 reason = smp_cmd_pairing_random(conn, skb);
 907                 break;
 908
 909         case SMP_CMD_ENCRYPT_INFO:
 910                 reason = smp_cmd_encrypt_info(conn, skb);
 911                 break;
 912
 913         case SMP_CMD_MASTER_IDENT:
 914                 reason = smp_cmd_master_ident(conn, skb);
 915                 break;
 916
 917         case SMP_CMD_IDENT_INFO:
 918         case SMP_CMD_IDENT_ADDR_INFO:
 919         case SMP_CMD_SIGN_INFO:
 920                 /* Just ignored */
 921                 reason = 0;
 922                 break;
 923
 924         default:
 925                 BT_DBG("Unknown command code 0x%2.2x", code);
 926
 927                 reason = SMP_CMD_NOTSUPP;
 928                 err = -EOPNOTSUPP;
 929                 goto done;
 930         }
 931
 932 done:
 933         if (reason)
 934                 smp_failure(conn, reason);
 935
 936         kfree_skb(skb);
 937         return err;
 938 }
 939
 940 int smp_distribute_keys(struct l2cap_conn *conn, __u8 force)
 941 {
 942         struct smp_cmd_pairing *req, *rsp;
 943         struct smp_chan *smp = conn->smp_chan;
 944         __u8 *keydist;
 945
 946         BT_DBG("conn %p force %d", conn, force);
 947
 948         if (!test_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
 949                 return 0;
 950
 951         rsp = (void *) &smp->prsp[1];
 952
 953         /* The responder sends its keys first */
 954         if (!force && conn->hcon->out && (rsp->resp_key_dist & 0x07))
 955                 return 0;
 956
 957         req = (void *) &smp->preq[1];
 958
 959         if (conn->hcon->out) {
 960                 keydist = &rsp->init_key_dist;
 961                 *keydist &= req->init_key_dist;
 962         } else {
 963                 keydist = &rsp->resp_key_dist;
 964                 *keydist &= req->resp_key_dist;
 965         }
 966
 967
 968         BT_DBG("keydist 0x%x", *keydist);
 969
 970         if (*keydist & SMP_DIST_ENC_KEY) {
 971                 struct smp_cmd_encrypt_info enc;
 972                 struct smp_cmd_master_ident ident;
 973                 struct hci_conn *hcon = conn->hcon;
 974                 u8 authenticated;
 975                 __le16 ediv;
 976
 977                 get_random_bytes(enc.ltk, sizeof(enc.ltk));
 978                 get_random_bytes(&ediv, sizeof(ediv));
 979                 get_random_bytes(ident.rand, sizeof(ident.rand));
 980
 981                 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
 982
 983                 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
 984                 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
 985                             HCI_SMP_LTK_SLAVE, 1, authenticated,
 986                             enc.ltk, smp->enc_key_size, ediv, ident.rand);
 987
 988                 ident.ediv = ediv;
 989
 990                 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
 991
 992                 *keydist &= ~SMP_DIST_ENC_KEY;
 993         }
 994
 995         if (*keydist & SMP_DIST_ID_KEY) {
 996                 struct smp_cmd_ident_addr_info addrinfo;
 997                 struct smp_cmd_ident_info idinfo;
 998
 999                 /* Send a dummy key */
1000                 get_random_bytes(idinfo.irk, sizeof(idinfo.irk));
1001
1002                 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1003
1004                 /* Just public address */
1005                 memset(&addrinfo, 0, sizeof(addrinfo));
1006                 bacpy(&addrinfo.bdaddr, &conn->hcon->src);
1007
1008                 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1009                              &addrinfo);
1010
1011                 *keydist &= ~SMP_DIST_ID_KEY;
1012         }
1013
1014         if (*keydist & SMP_DIST_SIGN) {
1015                 struct smp_cmd_sign_info sign;
1016
1017                 /* Send a dummy key */
1018                 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1019
1020                 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1021
1022                 *keydist &= ~SMP_DIST_SIGN;
1023         }
1024
1025         if (conn->hcon->out || force) {
1026                 clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags);
1027                 cancel_delayed_work_sync(&conn->security_timer);
1028                 smp_chan_destroy(conn);
1029         }
1030
1031         return 0;
1032 }