projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Fix passkey endianess in user_confirm and notify_passkey
[linux-2.6-block.git] / net / bluetooth / smp.c
CommitLineData
eb492e01
AB		 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
8c520a59
GP		 23#include <linux/crypto.h>
24#include <linux/scatterlist.h>
25#include <crypto/b128ops.h>
26
eb492e01
AB		 27#include <net/bluetooth/bluetooth.h>
28#include <net/bluetooth/hci_core.h>
29#include <net/bluetooth/l2cap.h>
2b64d153 30#include <net/bluetooth/mgmt.h>
ac4b7236
MH		 31
32#include "smp.h"
d22ef0bc 33
17b02e62 34#define SMP_TIMEOUT msecs_to_jiffies(30000)
5d3de7df 35
065a13e2
JH		 36#define AUTH_REQ_MASK 0x07
37
66bed1a2 38static inline void swap128(const u8 src[16], u8 dst[16])
d22ef0bc
AB		 39{
40 int i;
41 for (i = 0; i < 16; i++)
42 dst[15 - i] = src[i];
43}
44
66bed1a2 45static inline void swap56(const u8 src[7], u8 dst[7])
d22ef0bc
AB		 46{
47 int i;
48 for (i = 0; i < 7; i++)
49 dst[6 - i] = src[i];
50}
51
52static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
53{
54 struct blkcipher_desc desc;
55 struct scatterlist sg;
943a732a 56 uint8_t tmp[16], data[16];
201a5929 57 int err;
d22ef0bc
AB		 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
943a732a
JH		 67 /* The most significant octet of key corresponds to k[0] */
68 swap128(k, tmp);
69
70 err = crypto_blkcipher_setkey(tfm, tmp, 16);
d22ef0bc
AB		 71 if (err) {
72 BT_ERR("cipher setkey failed: %d", err);
73 return err;
74 }
75
943a732a
JH		 76 /* Most significant octet of plaintextData corresponds to data[0] */
77 swap128(r, data);
78
79 sg_init_one(&sg, data, 16);
d22ef0bc 80
d22ef0bc
AB		 81 err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
82 if (err)
83 BT_ERR("Encrypt data error %d", err);
84
943a732a
JH		 85 /* Most significant octet of encryptedData corresponds to data[0] */
86 swap128(data, r);
87
d22ef0bc
AB		 88 return err;
89}
90
60478054
JH		 91static int smp_ah(struct crypto_blkcipher *tfm, u8 irk[16], u8 r[3], u8 res[3])
92{
943a732a 93 u8 _res[16];
60478054
JH		 94 int err;
95
96 /* r' = padding || r */
943a732a
JH		 97 memcpy(_res, r, 3);
98 memset(_res + 3, 0, 13);
60478054 99
943a732a 100 err = smp_e(tfm, irk, _res);
60478054
JH		 101 if (err) {
102 BT_ERR("Encrypt error");
103 return err;
104 }
105
106 /* The output of the random address function ah is:
107 * ah(h, r) = e(k, r') mod 2^24
108 * The output of the security function e is then truncated to 24 bits
109 * by taking the least significant 24 bits of the output of e as the
110 * result of ah.
111 */
943a732a 112 memcpy(res, _res, 3);
60478054
JH		 113
114 return 0;
115}
116
117bool smp_irk_matches(struct crypto_blkcipher *tfm, u8 irk[16],
118 bdaddr_t *bdaddr)
119{
120 u8 hash[3];
121 int err;
122
123 BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);
124
125 err = smp_ah(tfm, irk, &bdaddr->b[3], hash);
126 if (err)
127 return false;
128
129 return !memcmp(bdaddr->b, hash, 3);
130}
131
b1e2b3ae
JH		 132int smp_generate_rpa(struct crypto_blkcipher *tfm, u8 irk[16], bdaddr_t *rpa)
133{
134 int err;
135
136 get_random_bytes(&rpa->b[3], 3);
137
138 rpa->b[5] &= 0x3f; /* Clear two most significant bits */
139 rpa->b[5] |= 0x40; /* Set second most significant bit */
140
141 err = smp_ah(tfm, irk, &rpa->b[3], rpa->b);
142 if (err < 0)
143 return err;
144
145 BT_DBG("RPA %pMR", rpa);
146
147 return 0;
148}
149
d22ef0bc 150static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
f1560463
MH		 151 u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
152 u8 _rat, bdaddr_t *ra, u8 res[16])
d22ef0bc
AB		 153{
154 u8 p1[16], p2[16];
155 int err;
156
157 memset(p1, 0, 16);
158
159 /* p1 = pres || preq || _rat || _iat */
943a732a
JH		 160 p1[0] = _iat;
161 p1[1] = _rat;
162 memcpy(p1 + 2, preq, 7);
163 memcpy(p1 + 9, pres, 7);
d22ef0bc
AB		 164
165 /* p2 = padding || ia || ra */
943a732a
JH		 166 memcpy(p2, ra, 6);
167 memcpy(p2 + 6, ia, 6);
168 memset(p2 + 12, 0, 4);
d22ef0bc
AB		 169
170 /* res = r XOR p1 */
171 u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
172
173 /* res = e(k, res) */
174 err = smp_e(tfm, k, res);
175 if (err) {
176 BT_ERR("Encrypt data error");
177 return err;
178 }
179
180 /* res = res XOR p2 */
181 u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
182
183 /* res = e(k, res) */
184 err = smp_e(tfm, k, res);
185 if (err)
186 BT_ERR("Encrypt data error");
187
188 return err;
189}
190
f1560463
MH		 191static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], u8 r1[16],
192 u8 r2[16], u8 _r[16])
d22ef0bc
AB		 193{
194 int err;
195
196 /* Just least significant octets from r1 and r2 are considered */
943a732a
JH		 197 memcpy(_r, r2, 8);
198 memcpy(_r + 8, r1, 8);
d22ef0bc
AB		 199
200 err = smp_e(tfm, k, _r);
201 if (err)
202 BT_ERR("Encrypt data error");
203
204 return err;
205}
206
eb492e01 207static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
f1560463 208 u16 dlen, void *data)
eb492e01
AB		 209{
210 struct sk_buff *skb;
211 struct l2cap_hdr *lh;
212 int len;
213
214 len = L2CAP_HDR_SIZE + sizeof(code) + dlen;
215
216 if (len > conn->mtu)
217 return NULL;
218
219 skb = bt_skb_alloc(len, GFP_ATOMIC);
220 if (!skb)
221 return NULL;
222
223 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
224 lh->len = cpu_to_le16(sizeof(code) + dlen);
dcf4adbf 225 lh->cid = cpu_to_le16(L2CAP_CID_SMP);
eb492e01
AB		 226
227 memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code));
228
229 memcpy(skb_put(skb, dlen), data, dlen);
230
231 return skb;
232}
233
234static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
235{
236 struct sk_buff *skb = smp_build_cmd(conn, code, len, data);
237
238 BT_DBG("code 0x%2.2x", code);
239
240 if (!skb)
241 return;
242
73d80deb
LAD		 243 skb->priority = HCI_PRIO_MAX;
244 hci_send_acl(conn->hchan, skb, 0);
e2dcd113 245
6c9d42a1 246 cancel_delayed_work_sync(&conn->security_timer);
17b02e62 247 schedule_delayed_work(&conn->security_timer, SMP_TIMEOUT);
eb492e01
AB		 248}
249
2b64d153
BG		 250static __u8 authreq_to_seclevel(__u8 authreq)
251{
252 if (authreq & SMP_AUTH_MITM)
253 return BT_SECURITY_HIGH;
254 else
255 return BT_SECURITY_MEDIUM;
256}
257
258static __u8 seclevel_to_authreq(__u8 sec_level)
259{
260 switch (sec_level) {
261 case BT_SECURITY_HIGH:
262 return SMP_AUTH_MITM | SMP_AUTH_BONDING;
263 case BT_SECURITY_MEDIUM:
264 return SMP_AUTH_BONDING;
265 default:
266 return SMP_AUTH_NONE;
267 }
268}
269
b8e66eac 270static void build_pairing_cmd(struct l2cap_conn *conn,
f1560463
MH		 271 struct smp_cmd_pairing *req,
272 struct smp_cmd_pairing *rsp, __u8 authreq)
b8e66eac 273{
fd349c02
JH		 274 struct smp_chan *smp = conn->smp_chan;
275 struct hci_conn *hcon = conn->hcon;
276 struct hci_dev *hdev = hcon->hdev;
277 u8 local_dist = 0, remote_dist = 0;
54790f73 278
a8b2d5c2 279 if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->dev_flags)) {
7ee4ea36
MH		 280 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
281 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
54790f73 282 authreq |= SMP_AUTH_BONDING;
2b64d153
BG		 283 } else {
284 authreq &= ~SMP_AUTH_BONDING;
54790f73
VCG		 285 }
286
fd349c02
JH		 287 if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
288 remote_dist |= SMP_DIST_ID_KEY;
289
863efaf2
JH		 290 if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
291 local_dist |= SMP_DIST_ID_KEY;
292
54790f73
VCG		 293 if (rsp == NULL) {
294 req->io_capability = conn->hcon->io_capability;
295 req->oob_flag = SMP_OOB_NOT_PRESENT;
296 req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
fd349c02
JH		 297 req->init_key_dist = local_dist;
298 req->resp_key_dist = remote_dist;
065a13e2 299 req->auth_req = (authreq & AUTH_REQ_MASK);
fd349c02
JH		 300
301 smp->remote_key_dist = remote_dist;
54790f73
VCG		 302 return;
303 }
304
305 rsp->io_capability = conn->hcon->io_capability;
306 rsp->oob_flag = SMP_OOB_NOT_PRESENT;
307 rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
fd349c02
JH		 308 rsp->init_key_dist = req->init_key_dist & remote_dist;
309 rsp->resp_key_dist = req->resp_key_dist & local_dist;
065a13e2 310 rsp->auth_req = (authreq & AUTH_REQ_MASK);
fd349c02
JH		 311
312 smp->remote_key_dist = rsp->init_key_dist;
b8e66eac
VCG		 313}
314
3158c50c
VCG		 315static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
316{
1c1def09
VCG		 317 struct smp_chan *smp = conn->smp_chan;
318
3158c50c 319 if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
f1560463 320 (max_key_size < SMP_MIN_ENC_KEY_SIZE))
3158c50c
VCG		 321 return SMP_ENC_KEY_SIZE;
322
f7aa611a 323 smp->enc_key_size = max_key_size;
3158c50c
VCG		 324
325 return 0;
326}
327
84794e11 328static void smp_failure(struct l2cap_conn *conn, u8 reason)
4f957a76 329{
bab73cb6
JH		 330 struct hci_conn *hcon = conn->hcon;
331
84794e11 332 if (reason)
4f957a76 333 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
f1560463 334 &reason);
4f957a76 335
ce39fb4e
MH		 336 clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags);
337 mgmt_auth_failed(hcon->hdev, &hcon->dst, hcon->type, hcon->dst_type,
338 HCI_ERROR_AUTH_FAILURE);
f1c09c07 339
61a0cfb0
AG		 340 cancel_delayed_work_sync(&conn->security_timer);
341
ce39fb4e 342 if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
f1c09c07 343 smp_chan_destroy(conn);
4f957a76
BG		 344}
345
2b64d153
BG		 346#define JUST_WORKS 0x00
347#define JUST_CFM 0x01
348#define REQ_PASSKEY 0x02
349#define CFM_PASSKEY 0x03
350#define REQ_OOB 0x04
351#define OVERLAP 0xFF
352
353static const u8 gen_method[5][5] = {
354 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
355 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
356 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
357 { JUST_WORKS, JUST_CFM, JUST_WORKS, JUST_WORKS, JUST_CFM },
358 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP },
359};
360
361static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
362 u8 local_io, u8 remote_io)
363{
364 struct hci_conn *hcon = conn->hcon;
365 struct smp_chan *smp = conn->smp_chan;
366 u8 method;
367 u32 passkey = 0;
368 int ret = 0;
369
370 /* Initialize key for JUST WORKS */
371 memset(smp->tk, 0, sizeof(smp->tk));
372 clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
373
374 BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
375
376 /* If neither side wants MITM, use JUST WORKS */
377 /* If either side has unknown io_caps, use JUST WORKS */
378 /* Otherwise, look up method from the table */
379 if (!(auth & SMP_AUTH_MITM) ||
f1560463
MH		 380 local_io > SMP_IO_KEYBOARD_DISPLAY ||
381 remote_io > SMP_IO_KEYBOARD_DISPLAY)
2b64d153
BG		 382 method = JUST_WORKS;
383 else
b3ff53ff 384 method = gen_method[remote_io][local_io];
2b64d153
BG		 385
386 /* If not bonding, don't ask user to confirm a Zero TK */
387 if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM)
388 method = JUST_WORKS;
389
390 /* If Just Works, Continue with Zero TK */
391 if (method == JUST_WORKS) {
392 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
393 return 0;
394 }
395
396 /* Not Just Works/Confirm results in MITM Authentication */
397 if (method != JUST_CFM)
398 set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags);
399
400 /* If both devices have Keyoard-Display I/O, the master
401 * Confirms and the slave Enters the passkey.
402 */
403 if (method == OVERLAP) {
404 if (hcon->link_mode & HCI_LM_MASTER)
405 method = CFM_PASSKEY;
406 else
407 method = REQ_PASSKEY;
408 }
409
01ad34d2 410 /* Generate random passkey. */
2b64d153 411 if (method == CFM_PASSKEY) {
943a732a 412 memset(smp->tk, 0, sizeof(smp->tk));
2b64d153
BG		 413 get_random_bytes(&passkey, sizeof(passkey));
414 passkey %= 1000000;
943a732a 415 put_unaligned_le32(passkey, smp->tk);
2b64d153 416 BT_DBG("PassKey: %d", passkey);
01ad34d2 417 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
2b64d153
BG		 418 }
419
420 hci_dev_lock(hcon->hdev);
421
422 if (method == REQ_PASSKEY)
ce39fb4e 423 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
272d90df 424 hcon->type, hcon->dst_type);
2b64d153 425 else
01ad34d2 426 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
272d90df 427 hcon->type, hcon->dst_type,
39adbffe 428 passkey, 0);
2b64d153
BG		 429
430 hci_dev_unlock(hcon->hdev);
431
432 return ret;
433}
434
8aab4757
VCG		 435static void confirm_work(struct work_struct *work)
436{
437 struct smp_chan *smp = container_of(work, struct smp_chan, confirm);
438 struct l2cap_conn *conn = smp->conn;
893ce8b1
JH		 439 struct hci_dev *hdev = conn->hcon->hdev;
440 struct crypto_blkcipher *tfm = hdev->tfm_aes;
8aab4757
VCG		 441 struct smp_cmd_pairing_confirm cp;
442 int ret;
943a732a 443 u8 reason;
8aab4757
VCG		 444
445 BT_DBG("conn %p", conn);
446
893ce8b1
JH		 447 /* Prevent mutual access to hdev->tfm_aes */
448 hci_dev_lock(hdev);
8aab4757 449
b1cd5fd9
JH		 450 ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
451 conn->hcon->init_addr_type, &conn->hcon->init_addr,
943a732a
JH		 452 conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
453 cp.confirm_val);
893ce8b1
JH		 454
455 hci_dev_unlock(hdev);
456
8aab4757
VCG		 457 if (ret) {
458 reason = SMP_UNSPECIFIED;
459 goto error;
460 }
461
2b64d153
BG		 462 clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
463
8aab4757
VCG		 464 smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
465
466 return;
467
468error:
84794e11 469 smp_failure(conn, reason);
8aab4757
VCG		 470}
471
472static void random_work(struct work_struct *work)
473{
474 struct smp_chan *smp = container_of(work, struct smp_chan, random);
475 struct l2cap_conn *conn = smp->conn;
476 struct hci_conn *hcon = conn->hcon;
893ce8b1
JH		 477 struct hci_dev *hdev = hcon->hdev;
478 struct crypto_blkcipher *tfm = hdev->tfm_aes;
943a732a 479 u8 reason, confirm[16];
8aab4757
VCG		 480 int ret;
481
482 if (IS_ERR_OR_NULL(tfm)) {
483 reason = SMP_UNSPECIFIED;
484 goto error;
485 }
486
487 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
488
893ce8b1
JH		 489 /* Prevent mutual access to hdev->tfm_aes */
490 hci_dev_lock(hdev);
491
b1cd5fd9
JH		 492 ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
493 hcon->init_addr_type, &hcon->init_addr,
943a732a 494 hcon->resp_addr_type, &hcon->resp_addr, confirm);
893ce8b1
JH		 495
496 hci_dev_unlock(hdev);
497
8aab4757
VCG		 498 if (ret) {
499 reason = SMP_UNSPECIFIED;
500 goto error;
501 }
502
8aab4757
VCG		 503 if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
504 BT_ERR("Pairing failed (confirmation values mismatch)");
505 reason = SMP_CONFIRM_FAILED;
506 goto error;
507 }
508
509 if (hcon->out) {
fe39c7b2
MH		 510 u8 stk[16];
511 __le64 rand = 0;
512 __le16 ediv = 0;
8aab4757 513
943a732a 514 smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, stk);
8aab4757 515
f7aa611a 516 memset(stk + smp->enc_key_size, 0,
04124681 517 SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
8aab4757 518
51a8efd7 519 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) {
8aab4757
VCG		 520 reason = SMP_UNSPECIFIED;
521 goto error;
522 }
523
524 hci_le_start_enc(hcon, ediv, rand, stk);
f7aa611a 525 hcon->enc_key_size = smp->enc_key_size;
8aab4757 526 } else {
943a732a 527 u8 stk[16];
fe39c7b2
MH		 528 __le64 rand = 0;
529 __le16 ediv = 0;
8aab4757 530
943a732a
JH		 531 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
532 smp->prnd);
8aab4757 533
943a732a 534 smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, stk);
8aab4757 535
f7aa611a 536 memset(stk + smp->enc_key_size, 0,
f1560463 537 SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
8aab4757 538
ce39fb4e 539 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
35d70271 540 HCI_SMP_STK_SLAVE, 0, stk, smp->enc_key_size,
04124681 541 ediv, rand);
8aab4757
VCG		 542 }
543
544 return;
545
546error:
84794e11 547 smp_failure(conn, reason);
8aab4757
VCG		 548}
549
e3098be4
JH		 550static void smp_reencrypt(struct work_struct *work)
551{
552 struct smp_chan *smp = container_of(work, struct smp_chan,
553 reencrypt.work);
554 struct l2cap_conn *conn = smp->conn;
555 struct hci_conn *hcon = conn->hcon;
556 struct smp_ltk *ltk = smp->ltk;
557
558 BT_DBG("");
559
560 hci_le_start_enc(hcon, ltk->ediv, ltk->rand, ltk->val);
561 hcon->enc_key_size = ltk->enc_size;
562}
563
8aab4757
VCG		 564static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
565{
566 struct smp_chan *smp;
567
f1560463 568 smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
8aab4757
VCG		 569 if (!smp)
570 return NULL;
571
572 INIT_WORK(&smp->confirm, confirm_work);
573 INIT_WORK(&smp->random, random_work);
e3098be4 574 INIT_DELAYED_WORK(&smp->reencrypt, smp_reencrypt);
8aab4757
VCG		 575
576 smp->conn = conn;
577 conn->smp_chan = smp;
2b64d153 578 conn->hcon->smp_conn = conn;
8aab4757
VCG		 579
580 hci_conn_hold(conn->hcon);
581
582 return smp;
583}
584
585void smp_chan_destroy(struct l2cap_conn *conn)
586{
c8eb9690 587 struct smp_chan *smp = conn->smp_chan;
f4a407be 588 bool complete;
c8eb9690 589
f1c09c07 590 BUG_ON(!smp);
c8eb9690 591
e3098be4
JH		 592 cancel_delayed_work_sync(&smp->reencrypt);
593
f4a407be
JH		 594 complete = test_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
595 mgmt_smp_complete(conn->hcon, complete);
596
7ee4ea36
MH		 597 kfree(smp->csrk);
598 kfree(smp->slave_csrk);
599
759331d7
JH		 600 /* If pairing failed clean up any keys we might have */
601 if (!complete) {
602 if (smp->ltk) {
603 list_del(&smp->ltk->list);
604 kfree(smp->ltk);
605 }
606
607 if (smp->slave_ltk) {
608 list_del(&smp->slave_ltk->list);
609 kfree(smp->slave_ltk);
610 }
611
612 if (smp->remote_irk) {
613 list_del(&smp->remote_irk->list);
614 kfree(smp->remote_irk);
615 }
616 }
617
c8eb9690
BG		 618 kfree(smp);
619 conn->smp_chan = NULL;
2b64d153 620 conn->hcon->smp_conn = NULL;
76a68ba0 621 hci_conn_drop(conn->hcon);
8aab4757
VCG		 622}
623
2b64d153
BG		 624int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
625{
626 struct l2cap_conn *conn = hcon->smp_conn;
627 struct smp_chan *smp;
628 u32 value;
2b64d153
BG		 629
630 BT_DBG("");
631
632 if (!conn)
633 return -ENOTCONN;
634
635 smp = conn->smp_chan;
636
637 switch (mgmt_op) {
638 case MGMT_OP_USER_PASSKEY_REPLY:
639 value = le32_to_cpu(passkey);
943a732a 640 memset(smp->tk, 0, sizeof(smp->tk));
2b64d153 641 BT_DBG("PassKey: %d", value);
943a732a 642 put_unaligned_le32(value, smp->tk);
2b64d153
BG		 643 /* Fall Through */
644 case MGMT_OP_USER_CONFIRM_REPLY:
645 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
646 break;
647 case MGMT_OP_USER_PASSKEY_NEG_REPLY:
648 case MGMT_OP_USER_CONFIRM_NEG_REPLY:
84794e11 649 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
2b64d153
BG		 650 return 0;
651 default:
84794e11 652 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
2b64d153
BG		 653 return -EOPNOTSUPP;
654 }
655
656 /* If it is our turn to send Pairing Confirm, do so now */
657 if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags))
658 queue_work(hcon->hdev->workqueue, &smp->confirm);
659
660 return 0;
661}
662
da85e5e5 663static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 664{
3158c50c 665 struct smp_cmd_pairing rsp, *req = (void *) skb->data;
8aab4757 666 struct smp_chan *smp;
3158c50c 667 u8 key_size;
2b64d153 668 u8 auth = SMP_AUTH_NONE;
8aab4757 669 int ret;
88ba43b6
AB		 670
671 BT_DBG("conn %p", conn);
672
c46b98be
JH		 673 if (skb->len < sizeof(*req))
674 return SMP_UNSPECIFIED;
675
2b64d153
BG		 676 if (conn->hcon->link_mode & HCI_LM_MASTER)
677 return SMP_CMD_NOTSUPP;
678
51a8efd7 679 if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
8aab4757 680 smp = smp_chan_create(conn);
d08fd0e7
AE		 681 else
682 smp = conn->smp_chan;
8aab4757 683
d08fd0e7
AE		 684 if (!smp)
685 return SMP_UNSPECIFIED;
d26a2345 686
1c1def09
VCG		 687 smp->preq[0] = SMP_CMD_PAIRING_REQ;
688 memcpy(&smp->preq[1], req, sizeof(*req));
3158c50c 689 skb_pull(skb, sizeof(*req));
88ba43b6 690
2b64d153
BG		 691 /* We didn't start the pairing, so match remote */
692 if (req->auth_req & SMP_AUTH_BONDING)
693 auth = req->auth_req;
da85e5e5 694
fdde0a26
IY		 695 conn->hcon->pending_sec_level = authreq_to_seclevel(auth);
696
2b64d153 697 build_pairing_cmd(conn, req, &rsp, auth);
3158c50c
VCG		 698
699 key_size = min(req->max_key_size, rsp.max_key_size);
700 if (check_enc_key_size(conn, key_size))
701 return SMP_ENC_KEY_SIZE;
88ba43b6 702
e84a6b13 703 get_random_bytes(smp->prnd, sizeof(smp->prnd));
8aab4757 704
1c1def09
VCG		 705 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
706 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
f01ead31 707
3158c50c 708 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
da85e5e5 709
2b64d153
BG		 710 /* Request setup of TK */
711 ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
712 if (ret)
713 return SMP_UNSPECIFIED;
714
da85e5e5 715 return 0;
88ba43b6
AB		 716}
717
da85e5e5 718static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 719{
3158c50c 720 struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
1c1def09 721 struct smp_chan *smp = conn->smp_chan;
8aab4757 722 struct hci_dev *hdev = conn->hcon->hdev;
2b64d153 723 u8 key_size, auth = SMP_AUTH_NONE;
7d24ddcc 724 int ret;
88ba43b6
AB		 725
726 BT_DBG("conn %p", conn);
727
c46b98be
JH		 728 if (skb->len < sizeof(*rsp))
729 return SMP_UNSPECIFIED;
730
2b64d153
BG		 731 if (!(conn->hcon->link_mode & HCI_LM_MASTER))
732 return SMP_CMD_NOTSUPP;
733
3158c50c
VCG		 734 skb_pull(skb, sizeof(*rsp));
735
1c1def09 736 req = (void *) &smp->preq[1];
da85e5e5 737
3158c50c
VCG		 738 key_size = min(req->max_key_size, rsp->max_key_size);
739 if (check_enc_key_size(conn, key_size))
740 return SMP_ENC_KEY_SIZE;
741
e84a6b13 742 get_random_bytes(smp->prnd, sizeof(smp->prnd));
7d24ddcc 743
8aab4757
VCG		 744 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
745 memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
7d24ddcc 746
fdcc4bec
JH		 747 /* Update remote key distribution in case the remote cleared
748 * some bits that we had enabled in our request.
749 */
750 smp->remote_key_dist &= rsp->resp_key_dist;
751
2b64d153 752 if ((req->auth_req & SMP_AUTH_BONDING) &&
f1560463 753 (rsp->auth_req & SMP_AUTH_BONDING))
2b64d153
BG		 754 auth = SMP_AUTH_BONDING;
755
756 auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
757
476585ec 758 ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
2b64d153
BG		 759 if (ret)
760 return SMP_UNSPECIFIED;
761
762 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
763
764 /* Can't compose response until we have been confirmed */
18e4aeb9
JH		 765 if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
766 queue_work(hdev->workqueue, &smp->confirm);
da85e5e5
VCG		 767
768 return 0;
88ba43b6
AB		 769}
770
da85e5e5 771static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 772{
1c1def09 773 struct smp_chan *smp = conn->smp_chan;
8aab4757 774 struct hci_dev *hdev = conn->hcon->hdev;
7d24ddcc 775
88ba43b6
AB		 776 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
777
c46b98be
JH		 778 if (skb->len < sizeof(smp->pcnf))
779 return SMP_UNSPECIFIED;
780
1c1def09
VCG		 781 memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
782 skb_pull(skb, sizeof(smp->pcnf));
88ba43b6 783
943a732a
JH		 784 if (conn->hcon->out)
785 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
786 smp->prnd);
787 else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
8aab4757 788 queue_work(hdev->workqueue, &smp->confirm);
943a732a 789 else
2b64d153 790 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
da85e5e5
VCG		 791
792 return 0;
88ba43b6
AB		 793}
794
da85e5e5 795static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 796{
1c1def09 797 struct smp_chan *smp = conn->smp_chan;
8aab4757 798 struct hci_dev *hdev = conn->hcon->hdev;
7d24ddcc 799
8aab4757 800 BT_DBG("conn %p", conn);
3158c50c 801
c46b98be
JH		 802 if (skb->len < sizeof(smp->rrnd))
803 return SMP_UNSPECIFIED;
804
943a732a 805 memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
8aab4757 806 skb_pull(skb, sizeof(smp->rrnd));
e7e62c85 807
8aab4757 808 queue_work(hdev->workqueue, &smp->random);
da85e5e5
VCG		 809
810 return 0;
88ba43b6
AB		 811}
812
4dab7864 813static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
988c5997 814{
c9839a11 815 struct smp_ltk *key;
988c5997
VCG		 816 struct hci_conn *hcon = conn->hcon;
817
98a0b845
JH		 818 key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type,
819 hcon->out);
988c5997
VCG		 820 if (!key)
821 return 0;
822
4dab7864
JH		 823 if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
824 return 0;
825
51a8efd7 826 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
988c5997
VCG		 827 return 1;
828
c9839a11
VCG		 829 hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
830 hcon->enc_key_size = key->enc_size;
988c5997
VCG		 831
832 return 1;
988c5997 833}
f1560463 834
da85e5e5 835static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6
AB		 836{
837 struct smp_cmd_security_req *rp = (void *) skb->data;
838 struct smp_cmd_pairing cp;
f1cb9af5 839 struct hci_conn *hcon = conn->hcon;
8aab4757 840 struct smp_chan *smp;
88ba43b6
AB		 841
842 BT_DBG("conn %p", conn);
843
c46b98be
JH		 844 if (skb->len < sizeof(*rp))
845 return SMP_UNSPECIFIED;
846
86ca9eac
JH		 847 if (!(conn->hcon->link_mode & HCI_LM_MASTER))
848 return SMP_CMD_NOTSUPP;
849
2b64d153 850 hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
feb45eb5 851
4dab7864 852 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
988c5997
VCG		 853 return 0;
854
51a8efd7 855 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
da85e5e5 856 return 0;
f1cb9af5 857
8aab4757 858 smp = smp_chan_create(conn);
d26a2345 859
88ba43b6 860 skb_pull(skb, sizeof(*rp));
88ba43b6 861
da85e5e5 862 memset(&cp, 0, sizeof(cp));
54790f73 863 build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
88ba43b6 864
1c1def09
VCG		 865 smp->preq[0] = SMP_CMD_PAIRING_REQ;
866 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 867
88ba43b6 868 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
f1cb9af5 869
da85e5e5 870 return 0;
88ba43b6
AB		 871}
872
ad32a2f5
JH		 873bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level)
874{
875 if (sec_level == BT_SECURITY_LOW)
876 return true;
877
878 if (hcon->sec_level >= sec_level)
879 return true;
880
881 return false;
882}
883
cc110922 884int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
eb492e01 885{
cc110922 886 struct l2cap_conn *conn = hcon->l2cap_data;
1c1def09 887 struct smp_chan *smp = conn->smp_chan;
2b64d153 888 __u8 authreq;
eb492e01 889
3a0259bb
VCG		 890 BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
891
757aee0f 892 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
2e65c9d2
AG		 893 return 1;
894
ad32a2f5 895 if (smp_sufficient_security(hcon, sec_level))
eb492e01 896 return 1;
f1cb9af5 897
988c5997 898 if (hcon->link_mode & HCI_LM_MASTER)
4dab7864 899 if (smp_ltk_encrypt(conn, sec_level))
02bc7455 900 goto done;
d26a2345 901
51a8efd7 902 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
d26a2345
VCG		 903 return 0;
904
8aab4757 905 smp = smp_chan_create(conn);
2b64d153
BG		 906 if (!smp)
907 return 1;
908
909 authreq = seclevel_to_authreq(sec_level);
d26a2345 910
2e233644
JH		 911 /* hcon->auth_type is set by pair_device in mgmt.c. If the MITM
912 * flag is set we should also set it for the SMP request.
913 */
914 if ((hcon->auth_type & 0x01))
915 authreq |= SMP_AUTH_MITM;
916
d26a2345
VCG		 917 if (hcon->link_mode & HCI_LM_MASTER) {
918 struct smp_cmd_pairing cp;
f01ead31 919
2b64d153 920 build_pairing_cmd(conn, &cp, NULL, authreq);
1c1def09
VCG		 921 smp->preq[0] = SMP_CMD_PAIRING_REQ;
922 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 923
eb492e01
AB		 924 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
925 } else {
926 struct smp_cmd_security_req cp;
2b64d153 927 cp.auth_req = authreq;
eb492e01
AB		 928 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
929 }
930
02bc7455 931done:
f1cb9af5 932 hcon->pending_sec_level = sec_level;
f1cb9af5 933
eb492e01
AB		 934 return 0;
935}
936
7034b911
VCG		 937static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
938{
16b90839 939 struct smp_cmd_encrypt_info *rp = (void *) skb->data;
1c1def09 940 struct smp_chan *smp = conn->smp_chan;
16b90839 941
c46b98be
JH		 942 BT_DBG("conn %p", conn);
943
944 if (skb->len < sizeof(*rp))
945 return SMP_UNSPECIFIED;
946
6131ddc8
JH		 947 /* Ignore this PDU if it wasn't requested */
948 if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
949 return 0;
950
16b90839
VCG		 951 skb_pull(skb, sizeof(*rp));
952
1c1def09 953 memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
16b90839 954
7034b911
VCG		 955 return 0;
956}
957
958static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
959{
16b90839 960 struct smp_cmd_master_ident *rp = (void *) skb->data;
1c1def09 961 struct smp_chan *smp = conn->smp_chan;
c9839a11
VCG		 962 struct hci_dev *hdev = conn->hcon->hdev;
963 struct hci_conn *hcon = conn->hcon;
23d0e128 964 struct smp_ltk *ltk;
c9839a11 965 u8 authenticated;
16b90839 966
c46b98be
JH		 967 BT_DBG("conn %p", conn);
968
969 if (skb->len < sizeof(*rp))
970 return SMP_UNSPECIFIED;
971
6131ddc8
JH		 972 /* Ignore this PDU if it wasn't requested */
973 if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
974 return 0;
975
9747a9f3
JH		 976 /* Mark the information as received */
977 smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
978
16b90839 979 skb_pull(skb, sizeof(*rp));
7034b911 980
c9839a11 981 hci_dev_lock(hdev);
ce39fb4e 982 authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
35d70271 983 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK,
23d0e128
JH		 984 authenticated, smp->tk, smp->enc_key_size,
985 rp->ediv, rp->rand);
986 smp->ltk = ltk;
fd349c02 987 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
4bd6d38e 988 smp_distribute_keys(conn);
c9839a11 989 hci_dev_unlock(hdev);
7034b911
VCG		 990
991 return 0;
992}
993
fd349c02
JH		 994static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
995{
996 struct smp_cmd_ident_info *info = (void *) skb->data;
997 struct smp_chan *smp = conn->smp_chan;
998
999 BT_DBG("");
1000
1001 if (skb->len < sizeof(*info))
1002 return SMP_UNSPECIFIED;
1003
6131ddc8
JH		 1004 /* Ignore this PDU if it wasn't requested */
1005 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1006 return 0;
1007
fd349c02
JH		 1008 skb_pull(skb, sizeof(*info));
1009
1010 memcpy(smp->irk, info->irk, 16);
1011
1012 return 0;
1013}
1014
1015static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
1016 struct sk_buff *skb)
1017{
1018 struct smp_cmd_ident_addr_info *info = (void *) skb->data;
1019 struct smp_chan *smp = conn->smp_chan;
1020 struct hci_conn *hcon = conn->hcon;
1021 bdaddr_t rpa;
1022
1023 BT_DBG("");
1024
1025 if (skb->len < sizeof(*info))
1026 return SMP_UNSPECIFIED;
1027
6131ddc8
JH		 1028 /* Ignore this PDU if it wasn't requested */
1029 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1030 return 0;
1031
9747a9f3
JH		 1032 /* Mark the information as received */
1033 smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
1034
fd349c02
JH		 1035 skb_pull(skb, sizeof(*info));
1036
a9a58f86
JH		 1037 /* Strictly speaking the Core Specification (4.1) allows sending
1038 * an empty address which would force us to rely on just the IRK
1039 * as "identity information". However, since such
1040 * implementations are not known of and in order to not over
1041 * complicate our implementation, simply pretend that we never
1042 * received an IRK for such a device.
1043 */
1044 if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
1045 BT_ERR("Ignoring IRK with no identity address");
4bd6d38e 1046 smp_distribute_keys(conn);
a9a58f86
JH		 1047 return 0;
1048 }
1049
fd349c02
JH		 1050 bacpy(&smp->id_addr, &info->bdaddr);
1051 smp->id_addr_type = info->addr_type;
1052
1053 if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
1054 bacpy(&rpa, &hcon->dst);
1055 else
1056 bacpy(&rpa, BDADDR_ANY);
1057
23d0e128
JH		 1058 smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
1059 smp->id_addr_type, smp->irk, &rpa);
fd349c02 1060
68d6f6de
JH		 1061 /* Track the connection based on the Identity Address from now on */
1062 bacpy(&hcon->dst, &smp->id_addr);
1063 hcon->dst_type = smp->id_addr_type;
1064
387a33e3
JH		 1065 l2cap_conn_update_id_addr(hcon);
1066
4bd6d38e 1067 smp_distribute_keys(conn);
fd349c02
JH		 1068
1069 return 0;
1070}
1071
7ee4ea36
MH		 1072static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
1073{
1074 struct smp_cmd_sign_info *rp = (void *) skb->data;
1075 struct smp_chan *smp = conn->smp_chan;
1076 struct hci_dev *hdev = conn->hcon->hdev;
1077 struct smp_csrk *csrk;
1078
1079 BT_DBG("conn %p", conn);
1080
1081 if (skb->len < sizeof(*rp))
1082 return SMP_UNSPECIFIED;
1083
1084 /* Ignore this PDU if it wasn't requested */
1085 if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1086 return 0;
1087
1088 /* Mark the information as received */
1089 smp->remote_key_dist &= ~SMP_DIST_SIGN;
1090
1091 skb_pull(skb, sizeof(*rp));
1092
1093 hci_dev_lock(hdev);
1094 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1095 if (csrk) {
1096 csrk->master = 0x01;
1097 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
1098 }
1099 smp->csrk = csrk;
1100 if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1101 smp_distribute_keys(conn);
1102 hci_dev_unlock(hdev);
1103
1104 return 0;
1105}
1106
eb492e01
AB		 1107int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
1108{
7b9899db 1109 struct hci_conn *hcon = conn->hcon;
92381f5c 1110 __u8 code, reason;
eb492e01
AB		 1111 int err = 0;
1112
7b9899db
MH		 1113 if (hcon->type != LE_LINK) {
1114 kfree_skb(skb);
3432711f 1115 return 0;
7b9899db
MH		 1116 }
1117
92381f5c
MH		 1118 if (skb->len < 1) {
1119 kfree_skb(skb);
1120 return -EILSEQ;
1121 }
1122
06ae3314 1123 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
2e65c9d2
AG		 1124 err = -ENOTSUPP;
1125 reason = SMP_PAIRING_NOTSUPP;
1126 goto done;
1127 }
1128
92381f5c 1129 code = skb->data[0];
eb492e01
AB		 1130 skb_pull(skb, sizeof(code));
1131
8cf9fa12
JH		 1132 /*
1133 * The SMP context must be initialized for all other PDUs except
1134 * pairing and security requests. If we get any other PDU when
1135 * not initialized simply disconnect (done if this function
1136 * returns an error).
1137 */
1138 if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
1139 !conn->smp_chan) {
1140 BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
1141 kfree_skb(skb);
1142 return -ENOTSUPP;
1143 }
1144
eb492e01
AB		 1145 switch (code) {
1146 case SMP_CMD_PAIRING_REQ:
da85e5e5 1147 reason = smp_cmd_pairing_req(conn, skb);
eb492e01
AB		 1148 break;
1149
1150 case SMP_CMD_PAIRING_FAIL:
84794e11 1151 smp_failure(conn, 0);
da85e5e5
VCG		 1152 reason = 0;
1153 err = -EPERM;
eb492e01
AB		 1154 break;
1155
1156 case SMP_CMD_PAIRING_RSP:
da85e5e5 1157 reason = smp_cmd_pairing_rsp(conn, skb);
88ba43b6
AB		 1158 break;
1159
1160 case SMP_CMD_SECURITY_REQ:
da85e5e5 1161 reason = smp_cmd_security_req(conn, skb);
88ba43b6
AB		 1162 break;
1163
eb492e01 1164 case SMP_CMD_PAIRING_CONFIRM:
da85e5e5 1165 reason = smp_cmd_pairing_confirm(conn, skb);
88ba43b6
AB		 1166 break;
1167
eb492e01 1168 case SMP_CMD_PAIRING_RANDOM:
da85e5e5 1169 reason = smp_cmd_pairing_random(conn, skb);
88ba43b6
AB		 1170 break;
1171
eb492e01 1172 case SMP_CMD_ENCRYPT_INFO:
7034b911
VCG		 1173 reason = smp_cmd_encrypt_info(conn, skb);
1174 break;
1175
eb492e01 1176 case SMP_CMD_MASTER_IDENT:
7034b911
VCG		 1177 reason = smp_cmd_master_ident(conn, skb);
1178 break;
1179
eb492e01 1180 case SMP_CMD_IDENT_INFO:
fd349c02
JH		 1181 reason = smp_cmd_ident_info(conn, skb);
1182 break;
1183
eb492e01 1184 case SMP_CMD_IDENT_ADDR_INFO:
fd349c02
JH		 1185 reason = smp_cmd_ident_addr_info(conn, skb);
1186 break;
1187
eb492e01 1188 case SMP_CMD_SIGN_INFO:
7ee4ea36 1189 reason = smp_cmd_sign_info(conn, skb);
7034b911
VCG		 1190 break;
1191
eb492e01
AB		 1192 default:
1193 BT_DBG("Unknown command code 0x%2.2x", code);
1194
1195 reason = SMP_CMD_NOTSUPP;
eb492e01 1196 err = -EOPNOTSUPP;
3a0259bb 1197 goto done;
eb492e01
AB		 1198 }
1199
3a0259bb
VCG		 1200done:
1201 if (reason)
84794e11 1202 smp_failure(conn, reason);
3a0259bb 1203
eb492e01
AB		 1204 kfree_skb(skb);
1205 return err;
1206}
7034b911 1207
35d70271
JH		 1208static void smp_notify_keys(struct l2cap_conn *conn)
1209{
1210 struct smp_chan *smp = conn->smp_chan;
1211 struct hci_conn *hcon = conn->hcon;
1212 struct hci_dev *hdev = hcon->hdev;
53ac6ab6
MH		 1213 struct smp_cmd_pairing *req = (void *) &smp->preq[1];
1214 struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
1215 bool persistent;
35d70271 1216
95fbac8a
JH		 1217 if (smp->remote_irk)
1218 mgmt_new_irk(hdev, smp->remote_irk);
1219
53ac6ab6
MH		 1220 /* The LTKs and CSRKs should be persistent only if both sides
1221 * had the bonding bit set in their authentication requests.
1222 */
1223 persistent = !!((req->auth_req & rsp->auth_req) & SMP_AUTH_BONDING);
1224
7ee4ea36
MH		 1225 if (smp->csrk) {
1226 smp->csrk->bdaddr_type = hcon->dst_type;
1227 bacpy(&smp->csrk->bdaddr, &hcon->dst);
53ac6ab6 1228 mgmt_new_csrk(hdev, smp->csrk, persistent);
7ee4ea36
MH		 1229 }
1230
1231 if (smp->slave_csrk) {
1232 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1233 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
53ac6ab6 1234 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
7ee4ea36
MH		 1235 }
1236
35d70271
JH		 1237 if (smp->ltk) {
1238 smp->ltk->bdaddr_type = hcon->dst_type;
1239 bacpy(&smp->ltk->bdaddr, &hcon->dst);
53ac6ab6 1240 mgmt_new_ltk(hdev, smp->ltk, persistent);
35d70271
JH		 1241 }
1242
1243 if (smp->slave_ltk) {
1244 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1245 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
53ac6ab6 1246 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
35d70271
JH		 1247 }
1248}
1249
4bd6d38e 1250int smp_distribute_keys(struct l2cap_conn *conn)
7034b911
VCG		 1251{
1252 struct smp_cmd_pairing *req, *rsp;
1c1def09 1253 struct smp_chan *smp = conn->smp_chan;
524237cb
JH		 1254 struct hci_conn *hcon = conn->hcon;
1255 struct hci_dev *hdev = hcon->hdev;
38ccdc93 1256 bool ltk_encrypt;
7034b911
VCG		 1257 __u8 *keydist;
1258
4bd6d38e 1259 BT_DBG("conn %p", conn);
7034b911 1260
524237cb 1261 if (!test_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
d26a2345
VCG		 1262 return 0;
1263
1c1def09 1264 rsp = (void *) &smp->prsp[1];
7034b911
VCG		 1265
1266 /* The responder sends its keys first */
efabba37 1267 if (hcon->out && (smp->remote_key_dist & 0x07))
7034b911
VCG		 1268 return 0;
1269
1c1def09 1270 req = (void *) &smp->preq[1];
7034b911 1271
524237cb 1272 if (hcon->out) {
7034b911
VCG		 1273 keydist = &rsp->init_key_dist;
1274 *keydist &= req->init_key_dist;
1275 } else {
1276 keydist = &rsp->resp_key_dist;
1277 *keydist &= req->resp_key_dist;
1278 }
1279
7034b911
VCG		 1280 BT_DBG("keydist 0x%x", *keydist);
1281
1282 if (*keydist & SMP_DIST_ENC_KEY) {
1283 struct smp_cmd_encrypt_info enc;
1284 struct smp_cmd_master_ident ident;
23d0e128 1285 struct smp_ltk *ltk;
c9839a11 1286 u8 authenticated;
7034b911 1287 __le16 ediv;
fe39c7b2 1288 __le64 rand;
7034b911
VCG		 1289
1290 get_random_bytes(enc.ltk, sizeof(enc.ltk));
1291 get_random_bytes(&ediv, sizeof(ediv));
fe39c7b2 1292 get_random_bytes(&rand, sizeof(rand));
7034b911
VCG		 1293
1294 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1295
c9839a11 1296 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
524237cb 1297 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
35d70271 1298 HCI_SMP_LTK_SLAVE, authenticated, enc.ltk,
fe39c7b2 1299 smp->enc_key_size, ediv, rand);
23d0e128 1300 smp->slave_ltk = ltk;
16b90839 1301
58115373 1302 ident.ediv = ediv;
fe39c7b2 1303 ident.rand = rand;
7034b911
VCG		 1304
1305 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1306
1307 *keydist &= ~SMP_DIST_ENC_KEY;
1308 }
1309
1310 if (*keydist & SMP_DIST_ID_KEY) {
1311 struct smp_cmd_ident_addr_info addrinfo;
1312 struct smp_cmd_ident_info idinfo;
1313
863efaf2 1314 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
7034b911
VCG		 1315
1316 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1317
82d4b359
JH		 1318 /* The hci_conn contains the local identity address
1319 * after the connection has been established.
1320 *
1321 * This is true even when the connection has been
1322 * established using a resolvable random address.
1323 */
524237cb 1324 bacpy(&addrinfo.bdaddr, &hcon->src);
82d4b359 1325 addrinfo.addr_type = hcon->src_type;
7034b911
VCG		 1326
1327 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
f1560463 1328 &addrinfo);
7034b911
VCG		 1329
1330 *keydist &= ~SMP_DIST_ID_KEY;
1331 }
1332
1333 if (*keydist & SMP_DIST_SIGN) {
1334 struct smp_cmd_sign_info sign;
7ee4ea36 1335 struct smp_csrk *csrk;
7034b911 1336
7ee4ea36 1337 /* Generate a new random key */
7034b911
VCG		 1338 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1339
7ee4ea36
MH		 1340 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1341 if (csrk) {
1342 csrk->master = 0x00;
1343 memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1344 }
1345 smp->slave_csrk = csrk;
1346
7034b911
VCG		 1347 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1348
1349 *keydist &= ~SMP_DIST_SIGN;
1350 }
1351
efabba37
JH		 1352 /* If there are still keys to be received wait for them */
1353 if ((smp->remote_key_dist & 0x07))
1354 return 0;
1355
38ccdc93
JH		 1356 /* Check if we should try to re-encrypt the link with the LTK.
1357 * SMP_FLAG_LTK_ENCRYPT flag is used to track whether we've
1358 * already tried this (in which case we shouldn't try again).
1359 *
1360 * The request will trigger an encryption key refresh event
1361 * which will cause a call to auth_cfm and eventually lead to
1362 * l2cap_core.c calling this smp_distribute_keys function again
1363 * and thereby completing the process.
1364 */
1365 if (smp->ltk)
1366 ltk_encrypt = !test_and_set_bit(SMP_FLAG_LTK_ENCRYPT,
1367 &smp->smp_flags);
1368 else
1369 ltk_encrypt = false;
efabba37 1370
38ccdc93
JH		 1371 /* Re-encrypt the link with LTK if possible */
1372 if (ltk_encrypt && hcon->out) {
e3098be4
JH		 1373 queue_delayed_work(hdev->req_workqueue, &smp->reencrypt,
1374 SMP_REENCRYPT_TIMEOUT);
38ccdc93
JH		 1375 } else {
1376 clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags);
1377 cancel_delayed_work_sync(&conn->security_timer);
1378 set_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
1379 smp_notify_keys(conn);
1380 smp_chan_destroy(conn);
1381 }
d26a2345 1382
7034b911
VCG		 1383 return 0;
1384}
Linux 6.x block layer and io_uring tree(s)