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