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