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