smp.c 33.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

23 24 25 26
#include <linux/crypto.h>
#include <linux/scatterlist.h>
#include <crypto/b128ops.h>

27 28 29
#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#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 37
#define AUTH_REQ_MASK   0x07

38
static inline void swap128(const u8 src[16], u8 dst[16])
39 40 41 42 43 44
{
	int i;
	for (i = 0; i < 16; i++)
		dst[15 - i] = src[i];
}

45
static inline void swap56(const u8 src[7], u8 dst[7])
46 47 48 49 50 51 52 53 54 55
{
	int i;
	for (i = 0; i < 7; i++)
		dst[6 - i] = src[i];
}

static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
{
	struct blkcipher_desc desc;
	struct scatterlist sg;
56
	uint8_t tmp[16], data[16];
57
	int err;
58 59 60 61 62 63 64 65 66

	if (tfm == NULL) {
		BT_ERR("tfm %p", tfm);
		return -EINVAL;
	}

	desc.tfm = tfm;
	desc.flags = 0;

67 68 69 70
	/* The most significant octet of key corresponds to k[0] */
	swap128(k, tmp);

	err = crypto_blkcipher_setkey(tfm, tmp, 16);
71 72 73 74 75
	if (err) {
		BT_ERR("cipher setkey failed: %d", err);
		return err;
	}

76 77 78 79
	/* Most significant octet of plaintextData corresponds to data[0] */
	swap128(r, data);

	sg_init_one(&sg, data, 16);
80 81 82 83 84

	err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
	if (err)
		BT_ERR("Encrypt data error %d", err);

85 86 87
	/* Most significant octet of encryptedData corresponds to data[0] */
	swap128(data, r);

88 89 90
	return err;
}

91 92
static int smp_ah(struct crypto_blkcipher *tfm, u8 irk[16], u8 r[3], u8 res[3])
{
93
	u8 _res[16];
94 95 96
	int err;

	/* r' = padding || r */
97 98
	memcpy(_res, r, 3);
	memset(_res + 3, 0, 13);
99

100
	err = smp_e(tfm, irk, _res);
101 102 103 104 105 106 107 108 109 110 111
	if (err) {
		BT_ERR("Encrypt error");
		return err;
	}

	/* The output of the random address function ah is:
	 *	ah(h, r) = e(k, r') mod 2^24
	 * The output of the security function e is then truncated to 24 bits
	 * by taking the least significant 24 bits of the output of e as the
	 * result of ah.
	 */
112
	memcpy(res, _res, 3);
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131

	return 0;
}

bool smp_irk_matches(struct crypto_blkcipher *tfm, u8 irk[16],
		     bdaddr_t *bdaddr)
{
	u8 hash[3];
	int err;

	BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);

	err = smp_ah(tfm, irk, &bdaddr->b[3], hash);
	if (err)
		return false;

	return !memcmp(bdaddr->b, hash, 3);
}

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
int smp_generate_rpa(struct crypto_blkcipher *tfm, u8 irk[16], bdaddr_t *rpa)
{
	int err;

	get_random_bytes(&rpa->b[3], 3);

	rpa->b[5] &= 0x3f;	/* Clear two most significant bits */
	rpa->b[5] |= 0x40;	/* Set second most significant bit */

	err = smp_ah(tfm, irk, &rpa->b[3], rpa->b);
	if (err < 0)
		return err;

	BT_DBG("RPA %pMR", rpa);

	return 0;
}

150
static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
151 152
		  u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
		  u8 _rat, bdaddr_t *ra, u8 res[16])
153 154 155 156 157 158 159
{
	u8 p1[16], p2[16];
	int err;

	memset(p1, 0, 16);

	/* p1 = pres || preq || _rat || _iat */
160 161 162 163
	p1[0] = _iat;
	p1[1] = _rat;
	memcpy(p1 + 2, preq, 7);
	memcpy(p1 + 9, pres, 7);
164 165

	/* p2 = padding || ia || ra */
166 167 168
	memcpy(p2, ra, 6);
	memcpy(p2 + 6, ia, 6);
	memset(p2 + 12, 0, 4);
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190

	/* res = r XOR p1 */
	u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);

	/* res = e(k, res) */
	err = smp_e(tfm, k, res);
	if (err) {
		BT_ERR("Encrypt data error");
		return err;
	}

	/* res = res XOR p2 */
	u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);

	/* res = e(k, res) */
	err = smp_e(tfm, k, res);
	if (err)
		BT_ERR("Encrypt data error");

	return err;
}

191 192
static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], u8 r1[16],
		  u8 r2[16], u8 _r[16])
193 194 195 196
{
	int err;

	/* Just least significant octets from r1 and r2 are considered */
197 198
	memcpy(_r, r2, 8);
	memcpy(_r + 8, r1, 8);
199 200 201 202 203 204 205 206

	err = smp_e(tfm, k, _r);
	if (err)
		BT_ERR("Encrypt data error");

	return err;
}

207
static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
208
				     u16 dlen, void *data)
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
{
	struct sk_buff *skb;
	struct l2cap_hdr *lh;
	int len;

	len = L2CAP_HDR_SIZE + sizeof(code) + dlen;

	if (len > conn->mtu)
		return NULL;

	skb = bt_skb_alloc(len, GFP_ATOMIC);
	if (!skb)
		return NULL;

	lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
	lh->len = cpu_to_le16(sizeof(code) + dlen);
225
	lh->cid = cpu_to_le16(L2CAP_CID_SMP);
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242

	memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code));

	memcpy(skb_put(skb, dlen), data, dlen);

	return skb;
}

static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
{
	struct sk_buff *skb = smp_build_cmd(conn, code, len, data);

	BT_DBG("code 0x%2.2x", code);

	if (!skb)
		return;

243 244
	skb->priority = HCI_PRIO_MAX;
	hci_send_acl(conn->hchan, skb, 0);
245

246
	cancel_delayed_work_sync(&conn->security_timer);
247
	schedule_delayed_work(&conn->security_timer, SMP_TIMEOUT);
248 249
}

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
static __u8 authreq_to_seclevel(__u8 authreq)
{
	if (authreq & SMP_AUTH_MITM)
		return BT_SECURITY_HIGH;
	else
		return BT_SECURITY_MEDIUM;
}

static __u8 seclevel_to_authreq(__u8 sec_level)
{
	switch (sec_level) {
	case BT_SECURITY_HIGH:
		return SMP_AUTH_MITM | SMP_AUTH_BONDING;
	case BT_SECURITY_MEDIUM:
		return SMP_AUTH_BONDING;
	default:
		return SMP_AUTH_NONE;
	}
}

270
static void build_pairing_cmd(struct l2cap_conn *conn,
271 272
			      struct smp_cmd_pairing *req,
			      struct smp_cmd_pairing *rsp, __u8 authreq)
273
{
274 275 276 277
	struct smp_chan *smp = conn->smp_chan;
	struct hci_conn *hcon = conn->hcon;
	struct hci_dev *hdev = hcon->hdev;
	u8 local_dist = 0, remote_dist = 0;
278

279
	if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->dev_flags)) {
280 281
		local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
		remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
282
		authreq |= SMP_AUTH_BONDING;
283 284
	} else {
		authreq &= ~SMP_AUTH_BONDING;
285 286
	}

287 288 289
	if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
		remote_dist |= SMP_DIST_ID_KEY;

290 291 292
	if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
		local_dist |= SMP_DIST_ID_KEY;

293 294 295 296
	if (rsp == NULL) {
		req->io_capability = conn->hcon->io_capability;
		req->oob_flag = SMP_OOB_NOT_PRESENT;
		req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
297 298
		req->init_key_dist = local_dist;
		req->resp_key_dist = remote_dist;
299
		req->auth_req = (authreq & AUTH_REQ_MASK);
300 301

		smp->remote_key_dist = remote_dist;
302 303 304 305 306 307
		return;
	}

	rsp->io_capability = conn->hcon->io_capability;
	rsp->oob_flag = SMP_OOB_NOT_PRESENT;
	rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
308 309
	rsp->init_key_dist = req->init_key_dist & remote_dist;
	rsp->resp_key_dist = req->resp_key_dist & local_dist;
310
	rsp->auth_req = (authreq & AUTH_REQ_MASK);
311 312

	smp->remote_key_dist = rsp->init_key_dist;
313 314
}

315 316
static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
{
317 318
	struct smp_chan *smp = conn->smp_chan;

319
	if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
320
	    (max_key_size < SMP_MIN_ENC_KEY_SIZE))
321 322
		return SMP_ENC_KEY_SIZE;

323
	smp->enc_key_size = max_key_size;
324 325 326 327

	return 0;
}

328
static void smp_failure(struct l2cap_conn *conn, u8 reason)
329
{
330 331
	struct hci_conn *hcon = conn->hcon;

332
	if (reason)
333
		smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
334
			     &reason);
335

336 337 338
	clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags);
	mgmt_auth_failed(hcon->hdev, &hcon->dst, hcon->type, hcon->dst_type,
			 HCI_ERROR_AUTH_FAILURE);
339

340 341
	cancel_delayed_work_sync(&conn->security_timer);

342
	if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
343
		smp_chan_destroy(conn);
344 345
}

346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
#define JUST_WORKS	0x00
#define JUST_CFM	0x01
#define REQ_PASSKEY	0x02
#define CFM_PASSKEY	0x03
#define REQ_OOB		0x04
#define OVERLAP		0xFF

static const u8 gen_method[5][5] = {
	{ JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
	{ JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
	{ CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
	{ JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
	{ CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP     },
};

static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
						u8 local_io, u8 remote_io)
{
	struct hci_conn *hcon = conn->hcon;
	struct smp_chan *smp = conn->smp_chan;
	u8 method;
	u32 passkey = 0;
	int ret = 0;

	/* Initialize key for JUST WORKS */
	memset(smp->tk, 0, sizeof(smp->tk));
	clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);

	BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);

	/* If neither side wants MITM, use JUST WORKS */
	/* If either side has unknown io_caps, use JUST WORKS */
	/* Otherwise, look up method from the table */
	if (!(auth & SMP_AUTH_MITM) ||
380 381
	    local_io > SMP_IO_KEYBOARD_DISPLAY ||
	    remote_io > SMP_IO_KEYBOARD_DISPLAY)
382 383
		method = JUST_WORKS;
	else
384
		method = gen_method[remote_io][local_io];
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409

	/* If not bonding, don't ask user to confirm a Zero TK */
	if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM)
		method = JUST_WORKS;

	/* If Just Works, Continue with Zero TK */
	if (method == JUST_WORKS) {
		set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
		return 0;
	}

	/* Not Just Works/Confirm results in MITM Authentication */
	if (method != JUST_CFM)
		set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags);

	/* If both devices have Keyoard-Display I/O, the master
	 * Confirms and the slave Enters the passkey.
	 */
	if (method == OVERLAP) {
		if (hcon->link_mode & HCI_LM_MASTER)
			method = CFM_PASSKEY;
		else
			method = REQ_PASSKEY;
	}

410
	/* Generate random passkey. */
411
	if (method == CFM_PASSKEY) {
412
		memset(smp->tk, 0, sizeof(smp->tk));
413 414
		get_random_bytes(&passkey, sizeof(passkey));
		passkey %= 1000000;
415
		put_unaligned_le32(passkey, smp->tk);
416
		BT_DBG("PassKey: %d", passkey);
417
		set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
418 419 420 421 422
	}

	hci_dev_lock(hcon->hdev);

	if (method == REQ_PASSKEY)
423
		ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
424
						hcon->type, hcon->dst_type);
425 426 427 428
	else if (method == JUST_CFM)
		ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
						hcon->type, hcon->dst_type,
						passkey, 1);
429
	else
430
		ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
431
						hcon->type, hcon->dst_type,
432
						passkey, 0);
433 434 435 436 437 438

	hci_dev_unlock(hcon->hdev);

	return ret;
}

439 440 441 442
static void confirm_work(struct work_struct *work)
{
	struct smp_chan *smp = container_of(work, struct smp_chan, confirm);
	struct l2cap_conn *conn = smp->conn;
443 444
	struct hci_dev *hdev = conn->hcon->hdev;
	struct crypto_blkcipher *tfm = hdev->tfm_aes;
445 446
	struct smp_cmd_pairing_confirm cp;
	int ret;
447
	u8 reason;
448 449 450

	BT_DBG("conn %p", conn);

451 452
	/* Prevent mutual access to hdev->tfm_aes */
	hci_dev_lock(hdev);
453

454 455
	ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
		     conn->hcon->init_addr_type, &conn->hcon->init_addr,
456 457
		     conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
		     cp.confirm_val);
458 459 460

	hci_dev_unlock(hdev);

461 462 463 464 465
	if (ret) {
		reason = SMP_UNSPECIFIED;
		goto error;
	}

466 467
	clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);

468 469 470 471 472
	smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);

	return;

error:
473
	smp_failure(conn, reason);
474 475 476 477 478 479 480
}

static void random_work(struct work_struct *work)
{
	struct smp_chan *smp = container_of(work, struct smp_chan, random);
	struct l2cap_conn *conn = smp->conn;
	struct hci_conn *hcon = conn->hcon;
481 482
	struct hci_dev *hdev = hcon->hdev;
	struct crypto_blkcipher *tfm = hdev->tfm_aes;
483
	u8 reason, confirm[16];
484 485 486 487 488 489 490 491 492
	int ret;

	if (IS_ERR_OR_NULL(tfm)) {
		reason = SMP_UNSPECIFIED;
		goto error;
	}

	BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");

493 494 495
	/* Prevent mutual access to hdev->tfm_aes */
	hci_dev_lock(hdev);

496 497
	ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
		     hcon->init_addr_type, &hcon->init_addr,
498
		     hcon->resp_addr_type, &hcon->resp_addr, confirm);
499 500 501

	hci_dev_unlock(hdev);

502 503 504 505 506 507 508 509 510 511 512 513
	if (ret) {
		reason = SMP_UNSPECIFIED;
		goto error;
	}

	if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
		BT_ERR("Pairing failed (confirmation values mismatch)");
		reason = SMP_CONFIRM_FAILED;
		goto error;
	}

	if (hcon->out) {
514 515 516
		u8 stk[16];
		__le64 rand = 0;
		__le16 ediv = 0;
517

518
		smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, stk);
519

520
		memset(stk + smp->enc_key_size, 0,
521
		       SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
522

523
		if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) {
524 525 526 527 528
			reason = SMP_UNSPECIFIED;
			goto error;
		}

		hci_le_start_enc(hcon, ediv, rand, stk);
529
		hcon->enc_key_size = smp->enc_key_size;
530
	} else {
531
		u8 stk[16];
532 533
		__le64 rand = 0;
		__le16 ediv = 0;
534

535 536
		smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
			     smp->prnd);
537

538
		smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, stk);
539

540
		memset(stk + smp->enc_key_size, 0,
541
		       SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
542

543
		hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
544
			    HCI_SMP_STK_SLAVE, 0, stk, smp->enc_key_size,
545
			    ediv, rand);
546 547 548 549 550
	}

	return;

error:
551
	smp_failure(conn, reason);
552 553
}

554 555 556 557 558 559 560 561 562 563 564 565 566 567
static void smp_reencrypt(struct work_struct *work)
{
	struct smp_chan *smp = container_of(work, struct smp_chan,
					    reencrypt.work);
	struct l2cap_conn *conn = smp->conn;
	struct hci_conn *hcon = conn->hcon;
	struct smp_ltk *ltk = smp->ltk;

	BT_DBG("");

	hci_le_start_enc(hcon, ltk->ediv, ltk->rand, ltk->val);
	hcon->enc_key_size = ltk->enc_size;
}

568 569 570 571
static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
{
	struct smp_chan *smp;

572
	smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
573 574 575 576 577
	if (!smp)
		return NULL;

	INIT_WORK(&smp->confirm, confirm_work);
	INIT_WORK(&smp->random, random_work);
578
	INIT_DELAYED_WORK(&smp->reencrypt, smp_reencrypt);
579 580 581

	smp->conn = conn;
	conn->smp_chan = smp;
582
	conn->hcon->smp_conn = conn;
583 584 585 586 587 588 589 590

	hci_conn_hold(conn->hcon);

	return smp;
}

void smp_chan_destroy(struct l2cap_conn *conn)
{
591
	struct smp_chan *smp = conn->smp_chan;
592
	bool complete;
593

594
	BUG_ON(!smp);
595

596 597
	cancel_delayed_work_sync(&smp->reencrypt);

598 599 600
	complete = test_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
	mgmt_smp_complete(conn->hcon, complete);

601 602 603
	kfree(smp->csrk);
	kfree(smp->slave_csrk);

604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
	/* If pairing failed clean up any keys we might have */
	if (!complete) {
		if (smp->ltk) {
			list_del(&smp->ltk->list);
			kfree(smp->ltk);
		}

		if (smp->slave_ltk) {
			list_del(&smp->slave_ltk->list);
			kfree(smp->slave_ltk);
		}

		if (smp->remote_irk) {
			list_del(&smp->remote_irk->list);
			kfree(smp->remote_irk);
		}
	}

622 623
	kfree(smp);
	conn->smp_chan = NULL;
624
	conn->hcon->smp_conn = NULL;
625
	hci_conn_drop(conn->hcon);
626 627
}

628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
{
	struct l2cap_conn *conn = hcon->smp_conn;
	struct smp_chan *smp;
	u32 value;

	BT_DBG("");

	if (!conn)
		return -ENOTCONN;

	smp = conn->smp_chan;

	switch (mgmt_op) {
	case MGMT_OP_USER_PASSKEY_REPLY:
		value = le32_to_cpu(passkey);
644
		memset(smp->tk, 0, sizeof(smp->tk));
645
		BT_DBG("PassKey: %d", value);
646
		put_unaligned_le32(value, smp->tk);
647 648 649 650 651 652
		/* Fall Through */
	case MGMT_OP_USER_CONFIRM_REPLY:
		set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
		break;
	case MGMT_OP_USER_PASSKEY_NEG_REPLY:
	case MGMT_OP_USER_CONFIRM_NEG_REPLY:
653
		smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
654 655
		return 0;
	default:
656
		smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
657 658 659 660 661 662 663 664 665 666
		return -EOPNOTSUPP;
	}

	/* If it is our turn to send Pairing Confirm, do so now */
	if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags))
		queue_work(hcon->hdev->workqueue, &smp->confirm);

	return 0;
}

667
static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
668
{
669
	struct smp_cmd_pairing rsp, *req = (void *) skb->data;
670
	struct smp_chan *smp;
671
	u8 key_size;
672
	u8 auth = SMP_AUTH_NONE;
673
	int ret;
674 675 676

	BT_DBG("conn %p", conn);

677 678 679
	if (skb->len < sizeof(*req))
		return SMP_UNSPECIFIED;

680 681 682
	if (conn->hcon->link_mode & HCI_LM_MASTER)
		return SMP_CMD_NOTSUPP;

683
	if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
684
		smp = smp_chan_create(conn);
685 686
	else
		smp = conn->smp_chan;
687

688 689
	if (!smp)
		return SMP_UNSPECIFIED;
690

691 692
	smp->preq[0] = SMP_CMD_PAIRING_REQ;
	memcpy(&smp->preq[1], req, sizeof(*req));
693
	skb_pull(skb, sizeof(*req));
694

695 696 697
	/* We didn't start the pairing, so match remote */
	if (req->auth_req & SMP_AUTH_BONDING)
		auth = req->auth_req;
698

699 700
	conn->hcon->pending_sec_level = authreq_to_seclevel(auth);

701
	build_pairing_cmd(conn, req, &rsp, auth);
702 703 704 705

	key_size = min(req->max_key_size, rsp.max_key_size);
	if (check_enc_key_size(conn, key_size))
		return SMP_ENC_KEY_SIZE;
706

707
	get_random_bytes(smp->prnd, sizeof(smp->prnd));
708

709 710
	smp->prsp[0] = SMP_CMD_PAIRING_RSP;
	memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
711

712
	smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
713

714 715 716 717 718
	/* Request setup of TK */
	ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
	if (ret)
		return SMP_UNSPECIFIED;

719 720
	clear_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);

721
	return 0;
722 723
}

724
static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
725
{
726
	struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
727
	struct smp_chan *smp = conn->smp_chan;
728
	struct hci_dev *hdev = conn->hcon->hdev;
729
	u8 key_size, auth = SMP_AUTH_NONE;
730
	int ret;
731 732 733

	BT_DBG("conn %p", conn);

734 735 736
	if (skb->len < sizeof(*rsp))
		return SMP_UNSPECIFIED;

737 738 739
	if (!(conn->hcon->link_mode & HCI_LM_MASTER))
		return SMP_CMD_NOTSUPP;

740 741
	skb_pull(skb, sizeof(*rsp));

742
	req = (void *) &smp->preq[1];
743

744 745 746 747
	key_size = min(req->max_key_size, rsp->max_key_size);
	if (check_enc_key_size(conn, key_size))
		return SMP_ENC_KEY_SIZE;

748
	get_random_bytes(smp->prnd, sizeof(smp->prnd));
749

750 751
	smp->prsp[0] = SMP_CMD_PAIRING_RSP;
	memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
752

753 754 755 756 757
	/* Update remote key distribution in case the remote cleared
	 * some bits that we had enabled in our request.
	 */
	smp->remote_key_dist &= rsp->resp_key_dist;

758
	if ((req->auth_req & SMP_AUTH_BONDING) &&
759
	    (rsp->auth_req & SMP_AUTH_BONDING))
760 761 762 763
		auth = SMP_AUTH_BONDING;

	auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;

764
	ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
765 766 767 768 769 770
	if (ret)
		return SMP_UNSPECIFIED;

	set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);

	/* Can't compose response until we have been confirmed */
771 772
	if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
		queue_work(hdev->workqueue, &smp->confirm);
773 774

	return 0;
775 776
}

777
static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
778
{
779
	struct smp_chan *smp = conn->smp_chan;
780
	struct hci_dev *hdev = conn->hcon->hdev;
781

782 783
	BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");

784 785 786
	if (skb->len < sizeof(smp->pcnf))
		return SMP_UNSPECIFIED;

787 788
	memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
	skb_pull(skb, sizeof(smp->pcnf));
789

790 791 792 793
	if (conn->hcon->out)
		smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
			     smp->prnd);
	else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
794
		queue_work(hdev->workqueue, &smp->confirm);
795
	else
796
		set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
797 798

	return 0;
799 800
}

801
static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
802
{
803
	struct smp_chan *smp = conn->smp_chan;
804
	struct hci_dev *hdev = conn->hcon->hdev;
805

806
	BT_DBG("conn %p", conn);
807

808 809 810
	if (skb->len < sizeof(smp->rrnd))
		return SMP_UNSPECIFIED;

811
	memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
812
	skb_pull(skb, sizeof(smp->rrnd));
813

814
	queue_work(hdev->workqueue, &smp->random);
815 816

	return 0;
817 818
}

819
static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
820
{
821
	struct smp_ltk *key;
822 823
	struct hci_conn *hcon = conn->hcon;

824 825
	key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type,
				   hcon->out);
826 827 828
	if (!key)
		return 0;

829 830 831
	if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
		return 0;

832
	if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
833 834
		return 1;

835 836
	hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
	hcon->enc_key_size = key->enc_size;
837 838 839

	return 1;
}
840

841
static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
842 843 844
{
	struct smp_cmd_security_req *rp = (void *) skb->data;
	struct smp_cmd_pairing cp;
845
	struct hci_conn *hcon = conn->hcon;
846
	struct smp_chan *smp;
847 848 849

	BT_DBG("conn %p", conn);

850 851 852
	if (skb->len < sizeof(*rp))
		return SMP_UNSPECIFIED;

853 854 855
	if (!(conn->hcon->link_mode & HCI_LM_MASTER))
		return SMP_CMD_NOTSUPP;

856
	hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
857

858
	if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
859 860
		return 0;

861
	if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
862
		return 0;
863

864
	smp = smp_chan_create(conn);
865

866 867
	skb_pull(skb, sizeof(*rp));

868
	memset(&cp, 0, sizeof(cp));
869
	build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
870

871 872
	smp->preq[0] = SMP_CMD_PAIRING_REQ;
	memcpy(&smp->preq[1], &cp, sizeof(cp));
873

874
	smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
875

876 877
	clear_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);

878
	return 0;
879 880
}

881 882 883 884 885 886 887 888 889 890 891
bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level)
{
	if (sec_level == BT_SECURITY_LOW)
		return true;

	if (hcon->sec_level >= sec_level)
		return true;

	return false;
}

892
int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
893
{
894
	struct l2cap_conn *conn = hcon->l2cap_data;
895
	struct smp_chan *smp;
896
	__u8 authreq;
897

898 899
	BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);

900 901 902 903 904 905
	/* This may be NULL if there's an unexpected disconnection */
	if (!conn)
		return 1;

	smp = conn->smp_chan;

906
	if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
907 908
		return 1;

909
	if (smp_sufficient_security(hcon, sec_level))
910
		return 1;
911

912
	if (hcon->link_mode & HCI_LM_MASTER)
913
		if (smp_ltk_encrypt(conn, sec_level))
914
			goto done;
915

916
	if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
917 918
		return 0;

919
	smp = smp_chan_create(conn);
920 921 922 923
	if (!smp)
		return 1;

	authreq = seclevel_to_authreq(sec_level);
924

925 926 927 928 929 930
	/* hcon->auth_type is set by pair_device in mgmt.c. If the MITM
	 * flag is set we should also set it for the SMP request.
	 */
	if ((hcon->auth_type & 0x01))
		authreq |= SMP_AUTH_MITM;

931 932
	if (hcon->link_mode & HCI_LM_MASTER) {
		struct smp_cmd_pairing cp;
933

934
		build_pairing_cmd(conn, &cp, NULL, authreq);
935 936
		smp->preq[0] = SMP_CMD_PAIRING_REQ;
		memcpy(&smp->preq[1], &cp, sizeof(cp));
937

938 939 940
		smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
	} else {
		struct smp_cmd_security_req cp;
941
		cp.auth_req = authreq;
942 943 944
		smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
	}

945
done:
946 947
	set_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);

948 949
	hcon->pending_sec_level = sec_level;

950 951 952
	return 0;
}

953 954
static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
{
955
	struct smp_cmd_encrypt_info *rp = (void *) skb->data;
956
	struct smp_chan *smp = conn->smp_chan;
957

958 959 960 961 962
	BT_DBG("conn %p", conn);

	if (skb->len < sizeof(*rp))
		return SMP_UNSPECIFIED;

963 964 965 966
	/* Ignore this PDU if it wasn't requested */
	if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
		return 0;

967 968
	skb_pull(skb, sizeof(*rp));

969
	memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
970

971 972 973 974 975
	return 0;
}

static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
{
976
	struct smp_cmd_master_ident *rp = (void *) skb->data;
977
	struct smp_chan *smp = conn->smp_chan;
978 979
	struct hci_dev *hdev = conn->hcon->hdev;
	struct hci_conn *hcon = conn->hcon;
980
	struct smp_ltk *ltk;
981
	u8 authenticated;
982

983 984 985 986 987
	BT_DBG("conn %p", conn);

	if (skb->len < sizeof(*rp))
		return SMP_UNSPECIFIED;

988 989 990 991
	/* Ignore this PDU if it wasn't requested */
	if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
		return 0;

992 993 994
	/* Mark the information as received */
	smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;

995
	skb_pull(skb, sizeof(*rp));
996

997
	hci_dev_lock(hdev);
998
	authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
999
	ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK,
1000 1001 1002
			  authenticated, smp->tk, smp->enc_key_size,
			  rp->ediv, rp->rand);
	smp->ltk = ltk;
1003
	if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1004
		smp_distribute_keys(conn);
1005
	hci_dev_unlock(hdev);
1006 1007 1008 1009

	return 0;
}

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
{
	struct smp_cmd_ident_info *info = (void *) skb->data;
	struct smp_chan *smp = conn->smp_chan;

	BT_DBG("");

	if (skb->len < sizeof(*info))
		return SMP_UNSPECIFIED;

1020 1021 1022 1023
	/* Ignore this PDU if it wasn't requested */
	if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
		return 0;

1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
	skb_pull(skb, sizeof(*info));

	memcpy(smp->irk, info->irk, 16);

	return 0;
}

static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
				   struct sk_buff *skb)
{
	struct smp_cmd_ident_addr_info *info = (void *) skb->data;
	struct smp_chan *smp = conn->smp_chan;
	struct hci_conn *hcon = conn->hcon;
	bdaddr_t rpa;

	BT_DBG("");

	if (skb->len < sizeof(*info))
		return SMP_UNSPECIFIED;

1044 1045 1046 1047
	/* Ignore this PDU if it wasn't requested */
	if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
		return 0;

1048 1049 1050
	/* Mark the information as received */
	smp->remote_key_dist &= ~SMP_DIST_ID_KEY;

1051 1052
	skb_pull(skb, sizeof(*info));

1053 1054 1055 1056 1057 1058 1059 1060 1061
	/* Strictly speaking the Core Specification (4.1) allows sending
	 * an empty address which would force us to rely on just the IRK
	 * as "identity information". However, since such
	 * implementations are not known of and in order to not over
	 * complicate our implementation, simply pretend that we never
	 * received an IRK for such a device.
	 */
	if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
		BT_ERR("Ignoring IRK with no identity address");
1062
		smp_distribute_keys(conn);
1063 1064 1065
		return 0;
	}

1066 1067 1068 1069 1070 1071 1072 1073
	bacpy(&smp->id_addr, &info->bdaddr);
	smp->id_addr_type = info->addr_type;

	if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
		bacpy(&rpa, &hcon->dst);
	else
		bacpy(&rpa, BDADDR_ANY);

1074 1075
	smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
				      smp->id_addr_type, smp->irk, &rpa);
1076

1077
	smp_distribute_keys(conn);
1078 1079 1080 1081

	return 0;
}

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
{
	struct smp_cmd_sign_info *rp = (void *) skb->data;
	struct smp_chan *smp = conn->smp_chan;
	struct hci_dev *hdev = conn->hcon->hdev;
	struct smp_csrk *csrk;

	BT_DBG("conn %p", conn);

	if (skb->len < sizeof(*rp))
		return SMP_UNSPECIFIED;

	/* Ignore this PDU if it wasn't requested */
	if (!(smp->remote_key_dist & SMP_DIST_SIGN))
		return 0;

	/* Mark the information as received */
	smp->remote_key_dist &= ~SMP_DIST_SIGN;

	skb_pull(skb, sizeof(*rp));

	hci_dev_lock(hdev);
	csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
	if (csrk) {
		csrk->master = 0x01;
		memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
	}
	smp->csrk = csrk;
	if (!(smp->remote_key_dist & SMP_DIST_SIGN))
		smp_distribute_keys(conn);
	hci_dev_unlock(hdev);

	return 0;
}

1117 1118
int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
{
1119
	struct hci_conn *hcon = conn->hcon;
1120
	__u8 code, reason;
1121 1122
	int err = 0;

1123 1124
	if (hcon->type != LE_LINK) {
		kfree_skb(skb);
1125
		return 0;
1126 1127
	}

1128 1129 1130 1131 1132
	if (skb->len < 1) {
		kfree_skb(skb);
		return -EILSEQ;
	}

1133
	if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
1134 1135 1136 1137 1138
		err = -ENOTSUPP;
		reason = SMP_PAIRING_NOTSUPP;
		goto done;
	}

1139
	code = skb->data[0];
1140 1141
	skb_pull(skb, sizeof(code));

1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
	/*
	 * The SMP context must be initialized for all other PDUs except
	 * pairing and security requests. If we get any other PDU when
	 * not initialized simply disconnect (done if this function
	 * returns an error).
	 */
	if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
	    !conn->smp_chan) {
		BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
		kfree_skb(skb);
		return -ENOTSUPP;
	}

1155 1156
	switch (code) {
	case SMP_CMD_PAIRING_REQ:
1157
		reason = smp_cmd_pairing_req(conn, skb);
1158 1159 1160
		break;

	case SMP_CMD_PAIRING_FAIL:
1161
		smp_failure(conn, 0);
1162 1163
		reason = 0;
		err = -EPERM;
1164 1165 1166
		break;

	case SMP_CMD_PAIRING_RSP:
1167
		reason = smp_cmd_pairing_rsp(conn, skb);
1168 1169 1170
		break;

	case SMP_CMD_SECURITY_REQ:
1171
		reason = smp_cmd_security_req(conn, skb);