smp.c 15.5 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 23 24 25 26
/*
   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.
*/

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include <net/bluetooth/l2cap.h>
#include <net/bluetooth/smp.h>
27
#include <linux/crypto.h>
28
#include <linux/scatterlist.h>
29 30
#include <crypto/b128ops.h>

31 32
#define SMP_TIMEOUT 30000 /* 30 seconds */

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
static inline void swap128(u8 src[16], u8 dst[16])
{
	int i;
	for (i = 0; i < 16; i++)
		dst[15 - i] = src[i];
}

static inline void swap56(u8 src[7], u8 dst[7])
{
	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;
	int err, iv_len;
	unsigned char iv[128];

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

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

	err = crypto_blkcipher_setkey(tfm, k, 16);
	if (err) {
		BT_ERR("cipher setkey failed: %d", err);
		return err;
	}

	sg_init_one(&sg, r, 16);

	iv_len = crypto_blkcipher_ivsize(tfm);
	if (iv_len) {
		memset(&iv, 0xff, iv_len);
		crypto_blkcipher_set_iv(tfm, iv, iv_len);
	}

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

	return err;
}

static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
		u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
		u8 _rat, bdaddr_t *ra, u8 res[16])
{
	u8 p1[16], p2[16];
	int err;

	memset(p1, 0, 16);

	/* p1 = pres || preq || _rat || _iat */
	swap56(pres, p1);
	swap56(preq, p1 + 7);
	p1[14] = _rat;
	p1[15] = _iat;

	memset(p2, 0, 16);

	/* p2 = padding || ia || ra */
	baswap((bdaddr_t *) (p2 + 4), ia);
	baswap((bdaddr_t *) (p2 + 10), ra);

	/* 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;
}

static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16],
			u8 r1[16], u8 r2[16], u8 _r[16])
{
	int err;

	/* Just least significant octets from r1 and r2 are considered */
	memcpy(_r, r1 + 8, 8);
	memcpy(_r + 8, r2 + 8, 8);

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

	return err;
}

static int smp_rand(u8 *buf)
{
	get_random_bytes(buf, 16);

	return 0;
}
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186

static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
						u16 dlen, void *data)
{
	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);
	lh->cid = cpu_to_le16(L2CAP_CID_SMP);

	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;

	hci_send_acl(conn->hcon, skb, 0);
}

187 188 189 190 191 192 193 194 195 196 197 198
static __u8 seclevel_to_authreq(__u8 level)
{
	switch (level) {
	case BT_SECURITY_HIGH:
		/* Right now we don't support bonding */
		return SMP_AUTH_MITM;

	default:
		return SMP_AUTH_NONE;
	}
}

199
static void build_pairing_cmd(struct l2cap_conn *conn,
200 201 202
				struct smp_cmd_pairing *req,
				struct smp_cmd_pairing *rsp,
				__u8 authreq)
203
{
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
	u8 dist_keys;

	dist_keys = 0;
	if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->flags)) {
		dist_keys = SMP_DIST_ENC_KEY | SMP_DIST_ID_KEY | SMP_DIST_SIGN;
		authreq |= SMP_AUTH_BONDING;
	}

	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;
		req->init_key_dist = dist_keys;
		req->resp_key_dist = dist_keys;
		req->auth_req = authreq;
		return;
	}

	rsp->io_capability = conn->hcon->io_capability;
	rsp->oob_flag = SMP_OOB_NOT_PRESENT;
	rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
	rsp->init_key_dist = req->init_key_dist & dist_keys;
	rsp->resp_key_dist = req->resp_key_dist & dist_keys;
	rsp->auth_req = authreq;
228 229
}

230 231 232 233 234 235 236 237 238 239 240
static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
{
	if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
			(max_key_size < SMP_MIN_ENC_KEY_SIZE))
		return SMP_ENC_KEY_SIZE;

	conn->smp_key_size = max_key_size;

	return 0;
}

241
static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
242
{
243 244
	struct smp_cmd_pairing rsp, *req = (void *) skb->data;
	u8 key_size;
245 246 247

	BT_DBG("conn %p", conn);

248
	conn->preq[0] = SMP_CMD_PAIRING_REQ;
249 250
	memcpy(&conn->preq[1], req, sizeof(*req));
	skb_pull(skb, sizeof(*req));
251

252
	if (req->oob_flag)
253 254 255
		return SMP_OOB_NOT_AVAIL;

	/* We didn't start the pairing, so no requirements */
256
	build_pairing_cmd(conn, req, &rsp, SMP_AUTH_NONE);
257 258 259 260

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

262 263 264
	/* Just works */
	memset(conn->tk, 0, sizeof(conn->tk));

265
	conn->prsp[0] = SMP_CMD_PAIRING_RSP;
266
	memcpy(&conn->prsp[1], &rsp, sizeof(rsp));
267

268
	smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
269

270 271 272
	mod_timer(&conn->security_timer, jiffies +
					msecs_to_jiffies(SMP_TIMEOUT));

273
	return 0;
274 275
}

276
static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
277
{
278
	struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
279
	struct smp_cmd_pairing_confirm cp;
280 281
	struct crypto_blkcipher *tfm = conn->hcon->hdev->tfm;
	int ret;
282
	u8 res[16], key_size;
283 284 285

	BT_DBG("conn %p", conn);

286 287 288
	skb_pull(skb, sizeof(*rsp));

	req = (void *) &conn->preq[1];
289

290 291 292 293 294
	key_size = min(req->max_key_size, rsp->max_key_size);
	if (check_enc_key_size(conn, key_size))
		return SMP_ENC_KEY_SIZE;

	if (rsp->oob_flag)
295 296
		return SMP_OOB_NOT_AVAIL;

297 298
	/* Just works */
	memset(conn->tk, 0, sizeof(conn->tk));
299

300
	conn->prsp[0] = SMP_CMD_PAIRING_RSP;
301
	memcpy(&conn->prsp[1], rsp, sizeof(*rsp));
302

303 304
	ret = smp_rand(conn->prnd);
	if (ret)
305
		return SMP_UNSPECIFIED;
306 307 308 309

	ret = smp_c1(tfm, conn->tk, conn->prnd, conn->preq, conn->prsp, 0,
			conn->src, conn->hcon->dst_type, conn->dst, res);
	if (ret)
310
		return SMP_UNSPECIFIED;
311 312 313

	swap128(res, cp.confirm_val);

314
	smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
315 316

	return 0;
317 318
}

319
static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
320
{
321 322
	struct crypto_blkcipher *tfm = conn->hcon->hdev->tfm;

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

325 326
	memcpy(conn->pcnf, skb->data, sizeof(conn->pcnf));
	skb_pull(skb, sizeof(conn->pcnf));
327

328 329
	if (conn->hcon->out) {
		u8 random[16];
330

331
		swap128(conn->prnd, random);
332
		smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(random),
333
								random);
334
	} else {
335 336 337
		struct smp_cmd_pairing_confirm cp;
		int ret;
		u8 res[16];
338

339 340
		ret = smp_rand(conn->prnd);
		if (ret)
341
			return SMP_UNSPECIFIED;
342

343 344 345 346
		ret = smp_c1(tfm, conn->tk, conn->prnd, conn->preq, conn->prsp,
						conn->hcon->dst_type, conn->dst,
						0, conn->src, res);
		if (ret)
347
			return SMP_CONFIRM_FAILED;
348 349 350 351

		swap128(res, cp.confirm_val);

		smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
352
	}
353

354 355 356
	mod_timer(&conn->security_timer, jiffies +
					msecs_to_jiffies(SMP_TIMEOUT));

357
	return 0;
358 359
}

360
static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
361
{
362 363
	struct hci_conn *hcon = conn->hcon;
	struct crypto_blkcipher *tfm = hcon->hdev->tfm;
364
	int ret;
365
	u8 key[16], res[16], random[16], confirm[16];
366 367 368 369 370 371 372 373 374 375 376 377 378

	swap128(skb->data, random);
	skb_pull(skb, sizeof(random));

	if (conn->hcon->out)
		ret = smp_c1(tfm, conn->tk, random, conn->preq, conn->prsp, 0,
				conn->src, conn->hcon->dst_type, conn->dst,
				res);
	else
		ret = smp_c1(tfm, conn->tk, random, conn->preq, conn->prsp,
				conn->hcon->dst_type, conn->dst, 0, conn->src,
				res);
	if (ret)
379
		return SMP_UNSPECIFIED;
380 381 382

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

383 384 385 386
	swap128(res, confirm);

	if (memcmp(conn->pcnf, confirm, sizeof(conn->pcnf)) != 0) {
		BT_ERR("Pairing failed (confirmation values mismatch)");
387
		return SMP_CONFIRM_FAILED;
388
	}
389 390

	if (conn->hcon->out) {
391
		u8 stk[16], rand[8];
392
		__le16 ediv;
393 394 395

		memset(rand, 0, sizeof(rand));
		ediv = 0;
396

397
		smp_s1(tfm, conn->tk, random, conn->prnd, key);
398
		swap128(key, stk);
399

400
		memset(stk + conn->smp_key_size, 0,
401 402
				SMP_MAX_ENC_KEY_SIZE - conn->smp_key_size);

403 404 405 406 407
		hci_le_start_enc(hcon, ediv, rand, stk);
	} else {
		u8 stk[16], r[16], rand[8];
		__le16 ediv;

408 409
		memset(rand, 0, sizeof(rand));
		ediv = 0;
410 411 412 413 414

		swap128(conn->prnd, r);
		smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(r), r);

		smp_s1(tfm, conn->tk, conn->prnd, random, key);
415
		swap128(key, stk);
416

417
		memset(stk + conn->smp_key_size, 0,
418
				SMP_MAX_ENC_KEY_SIZE - conn->smp_key_size);
419 420

		hci_add_ltk(conn->hcon->hdev, 0, conn->dst, ediv, rand, stk);
421
	}
422 423

	return 0;
424 425
}

426
static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
427 428 429
{
	struct smp_cmd_security_req *rp = (void *) skb->data;
	struct smp_cmd_pairing cp;
430
	struct hci_conn *hcon = conn->hcon;
431 432 433

	BT_DBG("conn %p", conn);

434
	if (test_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend))
435
		return 0;
436

437 438
	skb_pull(skb, sizeof(*rp));

439
	memset(&cp, 0, sizeof(cp));
440
	build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
441

442 443 444
	conn->preq[0] = SMP_CMD_PAIRING_REQ;
	memcpy(&conn->preq[1], &cp, sizeof(cp));

445
	smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
446

447 448 449
	mod_timer(&conn->security_timer, jiffies +
					msecs_to_jiffies(SMP_TIMEOUT));

450 451
	set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend);

452
	return 0;
453 454
}

455 456
int smp_conn_security(struct l2cap_conn *conn, __u8 sec_level)
{
457
	struct hci_conn *hcon = conn->hcon;
458 459
	__u8 authreq;

460 461
	BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);

462 463 464
	if (!lmp_host_le_capable(hcon->hdev))
		return 1;

465 466
	if (IS_ERR(hcon->hdev->tfm))
		return 1;
467

468 469
	if (test_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend))
		return 0;
470

471 472
	if (sec_level == BT_SECURITY_LOW)
		return 1;
473

474
	if (hcon->sec_level >= sec_level)
475
		return 1;
476 477

	authreq = seclevel_to_authreq(sec_level);
478

479
	if (hcon->link_mode & HCI_LM_MASTER) {
480
		struct smp_cmd_pairing cp;
481 482 483 484 485 486 487 488 489 490 491
		struct link_key *key;

		key = hci_find_link_key_type(hcon->hdev, conn->dst,
							HCI_LK_SMP_LTK);
		if (key) {
			struct key_master_id *master = (void *) key->data;

			hci_le_start_enc(hcon, master->ediv, master->rand,
								key->val);
			goto done;
		}
492

493
		build_pairing_cmd(conn, &cp, NULL, authreq);
494 495 496
		conn->preq[0] = SMP_CMD_PAIRING_REQ;
		memcpy(&conn->preq[1], &cp, sizeof(cp));

497 498 499
		mod_timer(&conn->security_timer, jiffies +
					msecs_to_jiffies(SMP_TIMEOUT));

500 501 502 503 504 505 506
		smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
	} else {
		struct smp_cmd_security_req cp;
		cp.auth_req = authreq;
		smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
	}

507
done:
508 509 510
	hcon->pending_sec_level = sec_level;
	set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend);

511 512 513
	return 0;
}

514 515
static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
{
516 517 518 519 520 521
	struct smp_cmd_encrypt_info *rp = (void *) skb->data;

	skb_pull(skb, sizeof(*rp));

	memcpy(conn->tk, rp->ltk, sizeof(conn->tk));

522 523 524 525 526
	return 0;
}

static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
{
527 528 529
	struct smp_cmd_master_ident *rp = (void *) skb->data;

	skb_pull(skb, sizeof(*rp));
530

531 532
	hci_add_ltk(conn->hcon->hdev, 1, conn->src, rp->ediv,
						rp->rand, conn->tk);
533 534 535 536 537 538

	smp_distribute_keys(conn, 1);

	return 0;
}

539 540 541 542 543 544
int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
{
	__u8 code = skb->data[0];
	__u8 reason;
	int err = 0;

545 546 547 548 549 550
	if (!lmp_host_le_capable(conn->hcon->hdev)) {
		err = -ENOTSUPP;
		reason = SMP_PAIRING_NOTSUPP;
		goto done;
	}

551 552 553 554 555 556
	if (IS_ERR(conn->hcon->hdev->tfm)) {
		err = PTR_ERR(conn->hcon->hdev->tfm);
		reason = SMP_PAIRING_NOTSUPP;
		goto done;
	}

557 558 559 560
	skb_pull(skb, sizeof(code));

	switch (code) {
	case SMP_CMD_PAIRING_REQ:
561
		reason = smp_cmd_pairing_req(conn, skb);
562 563 564
		break;

	case SMP_CMD_PAIRING_FAIL:
565 566
		reason = 0;
		err = -EPERM;
567 568 569
		break;

	case SMP_CMD_PAIRING_RSP:
570
		reason = smp_cmd_pairing_rsp(conn, skb);
571 572 573
		break;

	case SMP_CMD_SECURITY_REQ:
574
		reason = smp_cmd_security_req(conn, skb);
575 576
		break;

577
	case SMP_CMD_PAIRING_CONFIRM:
578
		reason = smp_cmd_pairing_confirm(conn, skb);
579 580
		break;

581
	case SMP_CMD_PAIRING_RANDOM:
582
		reason = smp_cmd_pairing_random(conn, skb);
583 584
		break;

585
	case SMP_CMD_ENCRYPT_INFO:
586 587 588
		reason = smp_cmd_encrypt_info(conn, skb);
		break;

589
	case SMP_CMD_MASTER_IDENT:
590 591 592
		reason = smp_cmd_master_ident(conn, skb);
		break;

593 594 595
	case SMP_CMD_IDENT_INFO:
	case SMP_CMD_IDENT_ADDR_INFO:
	case SMP_CMD_SIGN_INFO:
596 597 598 599
		/* Just ignored */
		reason = 0;
		break;

600 601 602 603 604
	default:
		BT_DBG("Unknown command code 0x%2.2x", code);

		reason = SMP_CMD_NOTSUPP;
		err = -EOPNOTSUPP;
605
		goto done;
606 607
	}

608 609 610 611 612
done:
	if (reason)
		smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
								&reason);

613 614 615
	kfree_skb(skb);
	return err;
}
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656

int smp_distribute_keys(struct l2cap_conn *conn, __u8 force)
{
	struct smp_cmd_pairing *req, *rsp;
	__u8 *keydist;

	BT_DBG("conn %p force %d", conn, force);

	if (IS_ERR(conn->hcon->hdev->tfm))
		return PTR_ERR(conn->hcon->hdev->tfm);

	rsp = (void *) &conn->prsp[1];

	/* The responder sends its keys first */
	if (!force && conn->hcon->out && (rsp->resp_key_dist & 0x07))
		return 0;

	req = (void *) &conn->preq[1];

	if (conn->hcon->out) {
		keydist = &rsp->init_key_dist;
		*keydist &= req->init_key_dist;
	} else {
		keydist = &rsp->resp_key_dist;
		*keydist &= req->resp_key_dist;
	}


	BT_DBG("keydist 0x%x", *keydist);

	if (*keydist & SMP_DIST_ENC_KEY) {
		struct smp_cmd_encrypt_info enc;
		struct smp_cmd_master_ident ident;
		__le16 ediv;

		get_random_bytes(enc.ltk, sizeof(enc.ltk));
		get_random_bytes(&ediv, sizeof(ediv));
		get_random_bytes(ident.rand, sizeof(ident.rand));

		smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);

657 658 659
		hci_add_ltk(conn->hcon->hdev, 1, conn->dst, ediv,
							ident.rand, enc.ltk);

660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
		ident.ediv = cpu_to_le16(ediv);

		smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);

		*keydist &= ~SMP_DIST_ENC_KEY;
	}

	if (*keydist & SMP_DIST_ID_KEY) {
		struct smp_cmd_ident_addr_info addrinfo;
		struct smp_cmd_ident_info idinfo;

		/* Send a dummy key */
		get_random_bytes(idinfo.irk, sizeof(idinfo.irk));

		smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);

		/* Just public address */
		memset(&addrinfo, 0, sizeof(addrinfo));
		bacpy(&addrinfo.bdaddr, conn->src);

		smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
								&addrinfo);

		*keydist &= ~SMP_DIST_ID_KEY;
	}

	if (*keydist & SMP_DIST_SIGN) {
		struct smp_cmd_sign_info sign;

		/* Send a dummy key */
		get_random_bytes(sign.csrk, sizeof(sign.csrk));

		smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);

		*keydist &= ~SMP_DIST_SIGN;
	}

	return 0;
}