2 * Wireless USB Host Controller
3 * Security support: encryption enablement, etc
5 * Copyright (C) 2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 #include <linux/types.h>
26 #include <linux/usb/ch9.h>
27 #include <linux/random.h>
30 static void wusbhc_set_gtk_callback(struct urb
*urb
);
31 static void wusbhc_gtk_rekey_done_work(struct work_struct
*work
);
33 int wusbhc_sec_create(struct wusbhc
*wusbhc
)
35 wusbhc
->gtk
.descr
.bLength
= sizeof(wusbhc
->gtk
.descr
) + sizeof(wusbhc
->gtk
.data
);
36 wusbhc
->gtk
.descr
.bDescriptorType
= USB_DT_KEY
;
37 wusbhc
->gtk
.descr
.bReserved
= 0;
39 wusbhc
->gtk_index
= wusb_key_index(0, WUSB_KEY_INDEX_TYPE_GTK
,
40 WUSB_KEY_INDEX_ORIGINATOR_HOST
);
42 INIT_WORK(&wusbhc
->gtk_rekey_done_work
, wusbhc_gtk_rekey_done_work
);
48 /* Called when the HC is destroyed */
49 void wusbhc_sec_destroy(struct wusbhc
*wusbhc
)
55 * wusbhc_next_tkid - generate a new, currently unused, TKID
56 * @wusbhc: the WUSB host controller
57 * @wusb_dev: the device whose PTK the TKID is for
58 * (or NULL for a TKID for a GTK)
60 * The generated TKID consist of two parts: the device's authenicated
61 * address (or 0 or a GTK); and an incrementing number. This ensures
62 * that TKIDs cannot be shared between devices and by the time the
63 * incrementing number wraps around the older TKIDs will no longer be
64 * in use (a maximum of two keys may be active at any one time).
66 static u32
wusbhc_next_tkid(struct wusbhc
*wusbhc
, struct wusb_dev
*wusb_dev
)
71 if (wusb_dev
== NULL
) {
72 tkid
= &wusbhc
->gtk_tkid
;
75 tkid
= &wusb_port_by_idx(wusbhc
, wusb_dev
->port_idx
)->ptk_tkid
;
76 addr
= wusb_dev
->addr
& 0x7f;
79 *tkid
= (addr
<< 8) | ((*tkid
+ 1) & 0xff);
84 static void wusbhc_generate_gtk(struct wusbhc
*wusbhc
)
86 const size_t key_size
= sizeof(wusbhc
->gtk
.data
);
89 tkid
= wusbhc_next_tkid(wusbhc
, NULL
);
91 wusbhc
->gtk
.descr
.tTKID
[0] = (tkid
>> 0) & 0xff;
92 wusbhc
->gtk
.descr
.tTKID
[1] = (tkid
>> 8) & 0xff;
93 wusbhc
->gtk
.descr
.tTKID
[2] = (tkid
>> 16) & 0xff;
95 get_random_bytes(wusbhc
->gtk
.descr
.bKeyData
, key_size
);
99 * wusbhc_sec_start - start the security management process
100 * @wusbhc: the WUSB host controller
102 * Generate and set an initial GTK on the host controller.
104 * Called when the HC is started.
106 int wusbhc_sec_start(struct wusbhc
*wusbhc
)
108 const size_t key_size
= sizeof(wusbhc
->gtk
.data
);
111 wusbhc_generate_gtk(wusbhc
);
113 result
= wusbhc
->set_gtk(wusbhc
, wusbhc
->gtk_tkid
,
114 &wusbhc
->gtk
.descr
.bKeyData
, key_size
);
116 dev_err(wusbhc
->dev
, "cannot set GTK for the host: %d\n",
123 * wusbhc_sec_stop - stop the security management process
124 * @wusbhc: the WUSB host controller
126 * Wait for any pending GTK rekeys to stop.
128 void wusbhc_sec_stop(struct wusbhc
*wusbhc
)
130 cancel_work_sync(&wusbhc
->gtk_rekey_done_work
);
134 /** @returns encryption type name */
135 const char *wusb_et_name(u8 x
)
138 case USB_ENC_TYPE_UNSECURE
: return "unsecure";
139 case USB_ENC_TYPE_WIRED
: return "wired";
140 case USB_ENC_TYPE_CCM_1
: return "CCM-1";
141 case USB_ENC_TYPE_RSA_1
: return "RSA-1";
142 default: return "unknown";
145 EXPORT_SYMBOL_GPL(wusb_et_name
);
148 * Set the device encryption method
150 * We tell the device which encryption method to use; we do this when
151 * setting up the device's security.
153 static int wusb_dev_set_encryption(struct usb_device
*usb_dev
, int value
)
156 struct device
*dev
= &usb_dev
->dev
;
157 struct wusb_dev
*wusb_dev
= usb_dev
->wusb_dev
;
160 value
= wusb_dev
->ccm1_etd
.bEncryptionValue
;
162 /* FIXME: should be wusb_dev->etd[UNSECURE].bEncryptionValue */
166 result
= usb_control_msg(usb_dev
, usb_sndctrlpipe(usb_dev
, 0),
167 USB_REQ_SET_ENCRYPTION
,
168 USB_DIR_OUT
| USB_TYPE_STANDARD
| USB_RECIP_DEVICE
,
169 value
, 0, NULL
, 0, 1000 /* FIXME: arbitrary */);
171 dev_err(dev
, "Can't set device's WUSB encryption to "
172 "%s (value %d): %d\n",
173 wusb_et_name(wusb_dev
->ccm1_etd
.bEncryptionType
),
174 wusb_dev
->ccm1_etd
.bEncryptionValue
, result
);
179 * Set the GTK to be used by a device.
181 * The device must be authenticated.
183 static int wusb_dev_set_gtk(struct wusbhc
*wusbhc
, struct wusb_dev
*wusb_dev
)
185 struct usb_device
*usb_dev
= wusb_dev
->usb_dev
;
187 return usb_control_msg(
188 usb_dev
, usb_sndctrlpipe(usb_dev
, 0),
189 USB_REQ_SET_DESCRIPTOR
,
190 USB_DIR_OUT
| USB_TYPE_STANDARD
| USB_RECIP_DEVICE
,
191 USB_DT_KEY
<< 8 | wusbhc
->gtk_index
, 0,
192 &wusbhc
->gtk
.descr
, wusbhc
->gtk
.descr
.bLength
,
197 /* FIXME: prototype for adding security */
198 int wusb_dev_sec_add(struct wusbhc
*wusbhc
,
199 struct usb_device
*usb_dev
, struct wusb_dev
*wusb_dev
)
201 int result
, bytes
, secd_size
;
202 struct device
*dev
= &usb_dev
->dev
;
203 struct usb_security_descriptor
*secd
;
204 const struct usb_encryption_descriptor
*etd
, *ccm1_etd
= NULL
;
205 const void *itr
, *top
;
208 secd
= kmalloc(sizeof(struct usb_security_descriptor
), GFP_KERNEL
);
214 result
= usb_get_descriptor(usb_dev
, USB_DT_SECURITY
,
215 0, secd
, sizeof(struct usb_security_descriptor
));
216 if (result
< sizeof(secd
)) {
217 dev_err(dev
, "Can't read security descriptor or "
218 "not enough data: %d\n", result
);
221 secd_size
= le16_to_cpu(secd
->wTotalLength
);
222 secd
= krealloc(secd
, secd_size
, GFP_KERNEL
);
224 dev_err(dev
, "Can't allocate space for security descriptors\n");
227 result
= usb_get_descriptor(usb_dev
, USB_DT_SECURITY
,
229 if (result
< secd_size
) {
230 dev_err(dev
, "Can't read security descriptor or "
231 "not enough data: %d\n", result
);
236 top
= (void *)secd
+ result
;
239 if (top
- itr
< sizeof(*etd
)) {
240 dev_err(dev
, "BUG: bad device security descriptor; "
241 "not enough data (%zu vs %zu bytes left)\n",
242 top
- itr
, sizeof(*etd
));
245 if (etd
->bLength
< sizeof(*etd
)) {
246 dev_err(dev
, "BUG: bad device encryption descriptor; "
247 "descriptor is too short "
248 "(%u vs %zu needed)\n",
249 etd
->bLength
, sizeof(*etd
));
253 bytes
+= snprintf(buf
+ bytes
, sizeof(buf
) - bytes
,
255 wusb_et_name(etd
->bEncryptionType
),
256 etd
->bEncryptionValue
, etd
->bAuthKeyIndex
);
257 if (etd
->bEncryptionType
== USB_ENC_TYPE_CCM_1
)
260 /* This code only supports CCM1 as of now. */
261 /* FIXME: user has to choose which sec mode to use?
262 * In theory we want CCM */
263 if (ccm1_etd
== NULL
) {
264 dev_err(dev
, "WUSB device doesn't support CCM1 encryption, "
269 wusb_dev
->ccm1_etd
= *ccm1_etd
;
270 dev_dbg(dev
, "supported encryption: %s; using %s (0x%02x/%02x)\n",
271 buf
, wusb_et_name(ccm1_etd
->bEncryptionType
),
272 ccm1_etd
->bEncryptionValue
, ccm1_etd
->bAuthKeyIndex
);
279 void wusb_dev_sec_rm(struct wusb_dev
*wusb_dev
)
285 * Update the address of an unauthenticated WUSB device
287 * Once we have successfully authenticated, we take it to addr0 state
288 * and then to a normal address.
290 * Before the device's address (as known by it) was usb_dev->devnum |
291 * 0x80 (unauthenticated address). With this we update it to usb_dev->devnum.
293 int wusb_dev_update_address(struct wusbhc
*wusbhc
, struct wusb_dev
*wusb_dev
)
295 int result
= -ENOMEM
;
296 struct usb_device
*usb_dev
= wusb_dev
->usb_dev
;
297 struct device
*dev
= &usb_dev
->dev
;
298 u8 new_address
= wusb_dev
->addr
& 0x7F;
301 result
= usb_control_msg(usb_dev
, usb_sndctrlpipe(usb_dev
, 0),
302 USB_REQ_SET_ADDRESS
, 0,
303 0, 0, NULL
, 0, 1000 /* FIXME: arbitrary */);
305 dev_err(dev
, "auth failed: can't set address 0: %d\n",
309 result
= wusb_set_dev_addr(wusbhc
, wusb_dev
, 0);
312 usb_set_device_state(usb_dev
, USB_STATE_DEFAULT
);
313 usb_ep0_reinit(usb_dev
);
315 /* Set new (authenticated) address. */
316 result
= usb_control_msg(usb_dev
, usb_sndctrlpipe(usb_dev
, 0),
317 USB_REQ_SET_ADDRESS
, 0,
318 new_address
, 0, NULL
, 0,
319 1000 /* FIXME: arbitrary */);
321 dev_err(dev
, "auth failed: can't set address %u: %d\n",
322 new_address
, result
);
325 result
= wusb_set_dev_addr(wusbhc
, wusb_dev
, new_address
);
328 usb_set_device_state(usb_dev
, USB_STATE_ADDRESS
);
329 usb_ep0_reinit(usb_dev
);
330 usb_dev
->authenticated
= 1;
340 /* FIXME: split and cleanup */
341 int wusb_dev_4way_handshake(struct wusbhc
*wusbhc
, struct wusb_dev
*wusb_dev
,
342 struct wusb_ckhdid
*ck
)
344 int result
= -ENOMEM
;
345 struct usb_device
*usb_dev
= wusb_dev
->usb_dev
;
346 struct device
*dev
= &usb_dev
->dev
;
349 struct usb_handshake
*hs
;
350 struct aes_ccm_nonce ccm_n
;
352 struct wusb_keydvt_in keydvt_in
;
353 struct wusb_keydvt_out keydvt_out
;
355 hs
= kzalloc(3*sizeof(hs
[0]), GFP_KERNEL
);
357 dev_err(dev
, "can't allocate handshake data\n");
361 /* We need to turn encryption before beginning the 4way
362 * hshake (WUSB1.0[.3.2.2]) */
363 result
= wusb_dev_set_encryption(usb_dev
, 1);
365 goto error_dev_set_encryption
;
367 tkid
= wusbhc_next_tkid(wusbhc
, wusb_dev
);
368 tkid_le
= cpu_to_le32(tkid
);
370 hs
[0].bMessageNumber
= 1;
372 memcpy(hs
[0].tTKID
, &tkid_le
, sizeof(hs
[0].tTKID
));
374 memcpy(hs
[0].CDID
, &wusb_dev
->cdid
, sizeof(hs
[0].CDID
));
375 get_random_bytes(&hs
[0].nonce
, sizeof(hs
[0].nonce
));
376 memset(hs
[0].MIC
, 0, sizeof(hs
[0].MIC
)); /* Per WUSB1.0[T7-22] */
378 result
= usb_control_msg(
379 usb_dev
, usb_sndctrlpipe(usb_dev
, 0),
380 USB_REQ_SET_HANDSHAKE
,
381 USB_DIR_OUT
| USB_TYPE_STANDARD
| USB_RECIP_DEVICE
,
382 1, 0, &hs
[0], sizeof(hs
[0]), 1000 /* FIXME: arbitrary */);
384 dev_err(dev
, "Handshake1: request failed: %d\n", result
);
388 /* Handshake 2, from the device -- need to verify fields */
389 result
= usb_control_msg(
390 usb_dev
, usb_rcvctrlpipe(usb_dev
, 0),
391 USB_REQ_GET_HANDSHAKE
,
392 USB_DIR_IN
| USB_TYPE_STANDARD
| USB_RECIP_DEVICE
,
393 2, 0, &hs
[1], sizeof(hs
[1]), 1000 /* FIXME: arbitrary */);
395 dev_err(dev
, "Handshake2: request failed: %d\n", result
);
400 if (hs
[1].bMessageNumber
!= 2) {
401 dev_err(dev
, "Handshake2 failed: bad message number %u\n",
402 hs
[1].bMessageNumber
);
405 if (hs
[1].bStatus
!= 0) {
406 dev_err(dev
, "Handshake2 failed: bad status %u\n",
410 if (memcmp(hs
[0].tTKID
, hs
[1].tTKID
, sizeof(hs
[0].tTKID
))) {
411 dev_err(dev
, "Handshake2 failed: TKID mismatch "
412 "(#1 0x%02x%02x%02x vs #2 0x%02x%02x%02x)\n",
413 hs
[0].tTKID
[0], hs
[0].tTKID
[1], hs
[0].tTKID
[2],
414 hs
[1].tTKID
[0], hs
[1].tTKID
[1], hs
[1].tTKID
[2]);
417 if (memcmp(hs
[0].CDID
, hs
[1].CDID
, sizeof(hs
[0].CDID
))) {
418 dev_err(dev
, "Handshake2 failed: CDID mismatch\n");
422 /* Setup the CCM nonce */
423 memset(&ccm_n
.sfn
, 0, sizeof(ccm_n
.sfn
)); /* Per WUSB1.0[6.5.2] */
424 memcpy(ccm_n
.tkid
, &tkid_le
, sizeof(ccm_n
.tkid
));
425 ccm_n
.src_addr
= wusbhc
->uwb_rc
->uwb_dev
.dev_addr
;
426 ccm_n
.dest_addr
.data
[0] = wusb_dev
->addr
;
427 ccm_n
.dest_addr
.data
[1] = 0;
429 /* Derive the KCK and PTK from CK, the CCM, H and D nonces */
430 memcpy(keydvt_in
.hnonce
, hs
[0].nonce
, sizeof(keydvt_in
.hnonce
));
431 memcpy(keydvt_in
.dnonce
, hs
[1].nonce
, sizeof(keydvt_in
.dnonce
));
432 result
= wusb_key_derive(&keydvt_out
, ck
->data
, &ccm_n
, &keydvt_in
);
434 dev_err(dev
, "Handshake2 failed: cannot derive keys: %d\n",
439 /* Compute MIC and verify it */
440 result
= wusb_oob_mic(mic
, keydvt_out
.kck
, &ccm_n
, &hs
[1]);
442 dev_err(dev
, "Handshake2 failed: cannot compute MIC: %d\n",
447 if (memcmp(hs
[1].MIC
, mic
, sizeof(hs
[1].MIC
))) {
448 dev_err(dev
, "Handshake2 failed: MIC mismatch\n");
452 /* Send Handshake3 */
453 hs
[2].bMessageNumber
= 3;
455 memcpy(hs
[2].tTKID
, &tkid_le
, sizeof(hs
[2].tTKID
));
457 memcpy(hs
[2].CDID
, &wusb_dev
->cdid
, sizeof(hs
[2].CDID
));
458 memcpy(hs
[2].nonce
, hs
[0].nonce
, sizeof(hs
[2].nonce
));
459 result
= wusb_oob_mic(hs
[2].MIC
, keydvt_out
.kck
, &ccm_n
, &hs
[2]);
461 dev_err(dev
, "Handshake3 failed: cannot compute MIC: %d\n",
466 result
= usb_control_msg(
467 usb_dev
, usb_sndctrlpipe(usb_dev
, 0),
468 USB_REQ_SET_HANDSHAKE
,
469 USB_DIR_OUT
| USB_TYPE_STANDARD
| USB_RECIP_DEVICE
,
470 3, 0, &hs
[2], sizeof(hs
[2]), 1000 /* FIXME: arbitrary */);
472 dev_err(dev
, "Handshake3: request failed: %d\n", result
);
476 result
= wusbhc
->set_ptk(wusbhc
, wusb_dev
->port_idx
, tkid
,
477 keydvt_out
.ptk
, sizeof(keydvt_out
.ptk
));
479 goto error_wusbhc_set_ptk
;
481 result
= wusb_dev_set_gtk(wusbhc
, wusb_dev
);
483 dev_err(dev
, "Set GTK for device: request failed: %d\n",
485 goto error_wusbhc_set_gtk
;
488 /* Update the device's address from unauth to auth */
489 if (usb_dev
->authenticated
== 0) {
490 result
= wusb_dev_update_address(wusbhc
, wusb_dev
);
492 goto error_dev_update_address
;
495 dev_info(dev
, "device authenticated\n");
497 error_dev_update_address
:
498 error_wusbhc_set_gtk
:
499 error_wusbhc_set_ptk
:
503 memset(hs
, 0, 3*sizeof(hs
[0]));
504 memset(&keydvt_out
, 0, sizeof(keydvt_out
));
505 memset(&keydvt_in
, 0, sizeof(keydvt_in
));
506 memset(&ccm_n
, 0, sizeof(ccm_n
));
507 memset(mic
, 0, sizeof(mic
));
509 wusb_dev_set_encryption(usb_dev
, 0);
510 error_dev_set_encryption
:
517 * Once all connected and authenticated devices have received the new
518 * GTK, switch the host to using it.
520 static void wusbhc_gtk_rekey_done_work(struct work_struct
*work
)
522 struct wusbhc
*wusbhc
= container_of(work
, struct wusbhc
, gtk_rekey_done_work
);
523 size_t key_size
= sizeof(wusbhc
->gtk
.data
);
525 mutex_lock(&wusbhc
->mutex
);
527 if (--wusbhc
->pending_set_gtks
== 0)
528 wusbhc
->set_gtk(wusbhc
, wusbhc
->gtk_tkid
, &wusbhc
->gtk
.descr
.bKeyData
, key_size
);
530 mutex_unlock(&wusbhc
->mutex
);
533 static void wusbhc_set_gtk_callback(struct urb
*urb
)
535 struct wusbhc
*wusbhc
= urb
->context
;
537 queue_work(wusbd
, &wusbhc
->gtk_rekey_done_work
);
541 * wusbhc_gtk_rekey - generate and distribute a new GTK
542 * @wusbhc: the WUSB host controller
544 * Generate a new GTK and distribute it to all connected and
545 * authenticated devices. When all devices have the new GTK, the host
548 * This must be called after every device disconnect (see [WUSB]
551 void wusbhc_gtk_rekey(struct wusbhc
*wusbhc
)
553 static const size_t key_size
= sizeof(wusbhc
->gtk
.data
);
556 wusbhc_generate_gtk(wusbhc
);
558 for (p
= 0; p
< wusbhc
->ports_max
; p
++) {
559 struct wusb_dev
*wusb_dev
;
561 wusb_dev
= wusbhc
->port
[p
].wusb_dev
;
562 if (!wusb_dev
|| !wusb_dev
->usb_dev
|| !wusb_dev
->usb_dev
->authenticated
)
565 usb_fill_control_urb(wusb_dev
->set_gtk_urb
, wusb_dev
->usb_dev
,
566 usb_sndctrlpipe(wusb_dev
->usb_dev
, 0),
567 (void *)wusb_dev
->set_gtk_req
,
568 &wusbhc
->gtk
.descr
, wusbhc
->gtk
.descr
.bLength
,
569 wusbhc_set_gtk_callback
, wusbhc
);
570 if (usb_submit_urb(wusb_dev
->set_gtk_urb
, GFP_KERNEL
) == 0)
571 wusbhc
->pending_set_gtks
++;
573 if (wusbhc
->pending_set_gtks
== 0)
574 wusbhc
->set_gtk(wusbhc
, wusbhc
->gtk_tkid
, &wusbhc
->gtk
.descr
.bKeyData
, key_size
);