GNU Linux-libre 4.19.286-gnu1
[releases.git] / drivers / usb / wusbcore / security.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Wireless USB Host Controller
4  * Security support: encryption enablement, etc
5  *
6  * Copyright (C) 2006 Intel Corporation
7  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8  *
9  * FIXME: docs
10  */
11 #include <linux/types.h>
12 #include <linux/slab.h>
13 #include <linux/usb/ch9.h>
14 #include <linux/random.h>
15 #include <linux/export.h>
16 #include "wusbhc.h"
17 #include <asm/unaligned.h>
18
19 static void wusbhc_gtk_rekey_work(struct work_struct *work);
20
21 int wusbhc_sec_create(struct wusbhc *wusbhc)
22 {
23         /*
24          * WQ is singlethread because we need to serialize rekey operations.
25          * Use a separate workqueue for security operations instead of the
26          * wusbd workqueue because security operations may need to communicate
27          * directly with downstream wireless devices using synchronous URBs.
28          * If a device is not responding, this could block other host
29          * controller operations.
30          */
31         wusbhc->wq_security = create_singlethread_workqueue("wusbd_security");
32         if (wusbhc->wq_security == NULL) {
33                 pr_err("WUSB-core: Cannot create wusbd_security workqueue\n");
34                 return -ENOMEM;
35         }
36
37         wusbhc->gtk.descr.bLength = sizeof(wusbhc->gtk.descr) +
38                 sizeof(wusbhc->gtk.data);
39         wusbhc->gtk.descr.bDescriptorType = USB_DT_KEY;
40         wusbhc->gtk.descr.bReserved = 0;
41         wusbhc->gtk_index = 0;
42
43         INIT_WORK(&wusbhc->gtk_rekey_work, wusbhc_gtk_rekey_work);
44
45         return 0;
46 }
47
48
49 /* Called when the HC is destroyed */
50 void wusbhc_sec_destroy(struct wusbhc *wusbhc)
51 {
52         destroy_workqueue(wusbhc->wq_security);
53 }
54
55
56 /**
57  * wusbhc_next_tkid - generate a new, currently unused, TKID
58  * @wusbhc:   the WUSB host controller
59  * @wusb_dev: the device whose PTK the TKID is for
60  *            (or NULL for a TKID for a GTK)
61  *
62  * The generated TKID consists of two parts: the device's authenticated
63  * address (or 0 or a GTK); and an incrementing number.  This ensures
64  * that TKIDs cannot be shared between devices and by the time the
65  * incrementing number wraps around the older TKIDs will no longer be
66  * in use (a maximum of two keys may be active at any one time).
67  */
68 static u32 wusbhc_next_tkid(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
69 {
70         u32 *tkid;
71         u32 addr;
72
73         if (wusb_dev == NULL) {
74                 tkid = &wusbhc->gtk_tkid;
75                 addr = 0;
76         } else {
77                 tkid = &wusb_port_by_idx(wusbhc, wusb_dev->port_idx)->ptk_tkid;
78                 addr = wusb_dev->addr & 0x7f;
79         }
80
81         *tkid = (addr << 8) | ((*tkid + 1) & 0xff);
82
83         return *tkid;
84 }
85
86 static void wusbhc_generate_gtk(struct wusbhc *wusbhc)
87 {
88         const size_t key_size = sizeof(wusbhc->gtk.data);
89         u32 tkid;
90
91         tkid = wusbhc_next_tkid(wusbhc, NULL);
92
93         wusbhc->gtk.descr.tTKID[0] = (tkid >>  0) & 0xff;
94         wusbhc->gtk.descr.tTKID[1] = (tkid >>  8) & 0xff;
95         wusbhc->gtk.descr.tTKID[2] = (tkid >> 16) & 0xff;
96
97         get_random_bytes(wusbhc->gtk.descr.bKeyData, key_size);
98 }
99
100 /**
101  * wusbhc_sec_start - start the security management process
102  * @wusbhc: the WUSB host controller
103  *
104  * Generate and set an initial GTK on the host controller.
105  *
106  * Called when the HC is started.
107  */
108 int wusbhc_sec_start(struct wusbhc *wusbhc)
109 {
110         const size_t key_size = sizeof(wusbhc->gtk.data);
111         int result;
112
113         wusbhc_generate_gtk(wusbhc);
114
115         result = wusbhc->set_gtk(wusbhc, wusbhc->gtk_tkid,
116                                 &wusbhc->gtk.descr.bKeyData, key_size);
117         if (result < 0)
118                 dev_err(wusbhc->dev, "cannot set GTK for the host: %d\n",
119                         result);
120
121         return result;
122 }
123
124 /**
125  * wusbhc_sec_stop - stop the security management process
126  * @wusbhc: the WUSB host controller
127  *
128  * Wait for any pending GTK rekeys to stop.
129  */
130 void wusbhc_sec_stop(struct wusbhc *wusbhc)
131 {
132         cancel_work_sync(&wusbhc->gtk_rekey_work);
133 }
134
135
136 /** @returns encryption type name */
137 const char *wusb_et_name(u8 x)
138 {
139         switch (x) {
140         case USB_ENC_TYPE_UNSECURE:     return "unsecure";
141         case USB_ENC_TYPE_WIRED:        return "wired";
142         case USB_ENC_TYPE_CCM_1:        return "CCM-1";
143         case USB_ENC_TYPE_RSA_1:        return "RSA-1";
144         default:                        return "unknown";
145         }
146 }
147 EXPORT_SYMBOL_GPL(wusb_et_name);
148
149 /*
150  * Set the device encryption method
151  *
152  * We tell the device which encryption method to use; we do this when
153  * setting up the device's security.
154  */
155 static int wusb_dev_set_encryption(struct usb_device *usb_dev, int value)
156 {
157         int result;
158         struct device *dev = &usb_dev->dev;
159         struct wusb_dev *wusb_dev = usb_dev->wusb_dev;
160
161         if (value) {
162                 value = wusb_dev->ccm1_etd.bEncryptionValue;
163         } else {
164                 /* FIXME: should be wusb_dev->etd[UNSECURE].bEncryptionValue */
165                 value = 0;
166         }
167         /* Set device's */
168         result = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
169                         USB_REQ_SET_ENCRYPTION,
170                         USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
171                         value, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
172         if (result < 0)
173                 dev_err(dev, "Can't set device's WUSB encryption to "
174                         "%s (value %d): %d\n",
175                         wusb_et_name(wusb_dev->ccm1_etd.bEncryptionType),
176                         wusb_dev->ccm1_etd.bEncryptionValue,  result);
177         return result;
178 }
179
180 /*
181  * Set the GTK to be used by a device.
182  *
183  * The device must be authenticated.
184  */
185 static int wusb_dev_set_gtk(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
186 {
187         struct usb_device *usb_dev = wusb_dev->usb_dev;
188         u8 key_index = wusb_key_index(wusbhc->gtk_index,
189                 WUSB_KEY_INDEX_TYPE_GTK, WUSB_KEY_INDEX_ORIGINATOR_HOST);
190
191         return usb_control_msg(
192                 usb_dev, usb_sndctrlpipe(usb_dev, 0),
193                 USB_REQ_SET_DESCRIPTOR,
194                 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
195                 USB_DT_KEY << 8 | key_index, 0,
196                 &wusbhc->gtk.descr, wusbhc->gtk.descr.bLength,
197                 USB_CTRL_SET_TIMEOUT);
198 }
199
200
201 /* FIXME: prototype for adding security */
202 int wusb_dev_sec_add(struct wusbhc *wusbhc,
203                      struct usb_device *usb_dev, struct wusb_dev *wusb_dev)
204 {
205         int result, bytes, secd_size;
206         struct device *dev = &usb_dev->dev;
207         struct usb_security_descriptor *secd, *new_secd;
208         const struct usb_encryption_descriptor *etd, *ccm1_etd = NULL;
209         const void *itr, *top;
210         char buf[64];
211
212         secd = kmalloc(sizeof(*secd), GFP_KERNEL);
213         if (secd == NULL) {
214                 result = -ENOMEM;
215                 goto out;
216         }
217
218         result = usb_get_descriptor(usb_dev, USB_DT_SECURITY,
219                                     0, secd, sizeof(*secd));
220         if (result < (int)sizeof(*secd)) {
221                 dev_err(dev, "Can't read security descriptor or "
222                         "not enough data: %d\n", result);
223                 goto out;
224         }
225         secd_size = le16_to_cpu(secd->wTotalLength);
226         new_secd = krealloc(secd, secd_size, GFP_KERNEL);
227         if (new_secd == NULL) {
228                 dev_err(dev,
229                         "Can't allocate space for security descriptors\n");
230                 result = -ENOMEM;
231                 goto out;
232         }
233         secd = new_secd;
234         result = usb_get_descriptor(usb_dev, USB_DT_SECURITY,
235                                     0, secd, secd_size);
236         if (result < secd_size) {
237                 dev_err(dev, "Can't read security descriptor or "
238                         "not enough data: %d\n", result);
239                 goto out;
240         }
241         bytes = 0;
242         itr = &secd[1];
243         top = (void *)secd + result;
244         while (itr < top) {
245                 etd = itr;
246                 if (top - itr < sizeof(*etd)) {
247                         dev_err(dev, "BUG: bad device security descriptor; "
248                                 "not enough data (%zu vs %zu bytes left)\n",
249                                 top - itr, sizeof(*etd));
250                         break;
251                 }
252                 if (etd->bLength < sizeof(*etd)) {
253                         dev_err(dev, "BUG: bad device encryption descriptor; "
254                                 "descriptor is too short "
255                                 "(%u vs %zu needed)\n",
256                                 etd->bLength, sizeof(*etd));
257                         break;
258                 }
259                 itr += etd->bLength;
260                 bytes += snprintf(buf + bytes, sizeof(buf) - bytes,
261                                   "%s (0x%02x/%02x) ",
262                                   wusb_et_name(etd->bEncryptionType),
263                                   etd->bEncryptionValue, etd->bAuthKeyIndex);
264                 if (etd->bEncryptionType == USB_ENC_TYPE_CCM_1)
265                         ccm1_etd = etd;
266         }
267         /* This code only supports CCM1 as of now. */
268         /* FIXME: user has to choose which sec mode to use?
269          * In theory we want CCM */
270         if (ccm1_etd == NULL) {
271                 dev_err(dev, "WUSB device doesn't support CCM1 encryption, "
272                         "can't use!\n");
273                 result = -EINVAL;
274                 goto out;
275         }
276         wusb_dev->ccm1_etd = *ccm1_etd;
277         dev_dbg(dev, "supported encryption: %s; using %s (0x%02x/%02x)\n",
278                 buf, wusb_et_name(ccm1_etd->bEncryptionType),
279                 ccm1_etd->bEncryptionValue, ccm1_etd->bAuthKeyIndex);
280         result = 0;
281 out:
282         kfree(secd);
283         return result;
284 }
285
286 void wusb_dev_sec_rm(struct wusb_dev *wusb_dev)
287 {
288         /* Nothing so far */
289 }
290
291 /**
292  * Update the address of an unauthenticated WUSB device
293  *
294  * Once we have successfully authenticated, we take it to addr0 state
295  * and then to a normal address.
296  *
297  * Before the device's address (as known by it) was usb_dev->devnum |
298  * 0x80 (unauthenticated address). With this we update it to usb_dev->devnum.
299  */
300 int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
301 {
302         int result = -ENOMEM;
303         struct usb_device *usb_dev = wusb_dev->usb_dev;
304         struct device *dev = &usb_dev->dev;
305         u8 new_address = wusb_dev->addr & 0x7F;
306
307         /* Set address 0 */
308         result = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
309                         USB_REQ_SET_ADDRESS,
310                         USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
311                          0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
312         if (result < 0) {
313                 dev_err(dev, "auth failed: can't set address 0: %d\n",
314                         result);
315                 goto error_addr0;
316         }
317         result = wusb_set_dev_addr(wusbhc, wusb_dev, 0);
318         if (result < 0)
319                 goto error_addr0;
320         usb_set_device_state(usb_dev, USB_STATE_DEFAULT);
321         usb_ep0_reinit(usb_dev);
322
323         /* Set new (authenticated) address. */
324         result = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
325                         USB_REQ_SET_ADDRESS,
326                         USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
327                         new_address, 0, NULL, 0,
328                         USB_CTRL_SET_TIMEOUT);
329         if (result < 0) {
330                 dev_err(dev, "auth failed: can't set address %u: %d\n",
331                         new_address, result);
332                 goto error_addr;
333         }
334         result = wusb_set_dev_addr(wusbhc, wusb_dev, new_address);
335         if (result < 0)
336                 goto error_addr;
337         usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
338         usb_ep0_reinit(usb_dev);
339         usb_dev->authenticated = 1;
340 error_addr:
341 error_addr0:
342         return result;
343 }
344
345 /*
346  *
347  *
348  */
349 /* FIXME: split and cleanup */
350 int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
351                             struct wusb_ckhdid *ck)
352 {
353         int result = -ENOMEM;
354         struct usb_device *usb_dev = wusb_dev->usb_dev;
355         struct device *dev = &usb_dev->dev;
356         u32 tkid;
357         struct usb_handshake *hs;
358         struct aes_ccm_nonce ccm_n;
359         u8 mic[8];
360         struct wusb_keydvt_in keydvt_in;
361         struct wusb_keydvt_out keydvt_out;
362
363         hs = kcalloc(3, sizeof(hs[0]), GFP_KERNEL);
364         if (!hs)
365                 goto error_kzalloc;
366
367         /* We need to turn encryption before beginning the 4way
368          * hshake (WUSB1.0[.3.2.2]) */
369         result = wusb_dev_set_encryption(usb_dev, 1);
370         if (result < 0)
371                 goto error_dev_set_encryption;
372
373         tkid = wusbhc_next_tkid(wusbhc, wusb_dev);
374
375         hs[0].bMessageNumber = 1;
376         hs[0].bStatus = 0;
377         put_unaligned_le32(tkid, hs[0].tTKID);
378         hs[0].bReserved = 0;
379         memcpy(hs[0].CDID, &wusb_dev->cdid, sizeof(hs[0].CDID));
380         get_random_bytes(&hs[0].nonce, sizeof(hs[0].nonce));
381         memset(hs[0].MIC, 0, sizeof(hs[0].MIC)); /* Per WUSB1.0[T7-22] */
382
383         result = usb_control_msg(
384                 usb_dev, usb_sndctrlpipe(usb_dev, 0),
385                 USB_REQ_SET_HANDSHAKE,
386                 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
387                 1, 0, &hs[0], sizeof(hs[0]), USB_CTRL_SET_TIMEOUT);
388         if (result < 0) {
389                 dev_err(dev, "Handshake1: request failed: %d\n", result);
390                 goto error_hs1;
391         }
392
393         /* Handshake 2, from the device -- need to verify fields */
394         result = usb_control_msg(
395                 usb_dev, usb_rcvctrlpipe(usb_dev, 0),
396                 USB_REQ_GET_HANDSHAKE,
397                 USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
398                 2, 0, &hs[1], sizeof(hs[1]), USB_CTRL_GET_TIMEOUT);
399         if (result < 0) {
400                 dev_err(dev, "Handshake2: request failed: %d\n", result);
401                 goto error_hs2;
402         }
403
404         result = -EINVAL;
405         if (hs[1].bMessageNumber != 2) {
406                 dev_err(dev, "Handshake2 failed: bad message number %u\n",
407                         hs[1].bMessageNumber);
408                 goto error_hs2;
409         }
410         if (hs[1].bStatus != 0) {
411                 dev_err(dev, "Handshake2 failed: bad status %u\n",
412                         hs[1].bStatus);
413                 goto error_hs2;
414         }
415         if (memcmp(hs[0].tTKID, hs[1].tTKID, sizeof(hs[0].tTKID))) {
416                 dev_err(dev, "Handshake2 failed: TKID mismatch "
417                         "(#1 0x%02x%02x%02x vs #2 0x%02x%02x%02x)\n",
418                         hs[0].tTKID[0], hs[0].tTKID[1], hs[0].tTKID[2],
419                         hs[1].tTKID[0], hs[1].tTKID[1], hs[1].tTKID[2]);
420                 goto error_hs2;
421         }
422         if (memcmp(hs[0].CDID, hs[1].CDID, sizeof(hs[0].CDID))) {
423                 dev_err(dev, "Handshake2 failed: CDID mismatch\n");
424                 goto error_hs2;
425         }
426
427         /* Setup the CCM nonce */
428         memset(&ccm_n.sfn, 0, sizeof(ccm_n.sfn)); /* Per WUSB1.0[6.5.2] */
429         put_unaligned_le32(tkid, ccm_n.tkid);
430         ccm_n.src_addr = wusbhc->uwb_rc->uwb_dev.dev_addr;
431         ccm_n.dest_addr.data[0] = wusb_dev->addr;
432         ccm_n.dest_addr.data[1] = 0;
433
434         /* Derive the KCK and PTK from CK, the CCM, H and D nonces */
435         memcpy(keydvt_in.hnonce, hs[0].nonce, sizeof(keydvt_in.hnonce));
436         memcpy(keydvt_in.dnonce, hs[1].nonce, sizeof(keydvt_in.dnonce));
437         result = wusb_key_derive(&keydvt_out, ck->data, &ccm_n, &keydvt_in);
438         if (result < 0) {
439                 dev_err(dev, "Handshake2 failed: cannot derive keys: %d\n",
440                         result);
441                 goto error_hs2;
442         }
443
444         /* Compute MIC and verify it */
445         result = wusb_oob_mic(mic, keydvt_out.kck, &ccm_n, &hs[1]);
446         if (result < 0) {
447                 dev_err(dev, "Handshake2 failed: cannot compute MIC: %d\n",
448                         result);
449                 goto error_hs2;
450         }
451
452         if (memcmp(hs[1].MIC, mic, sizeof(hs[1].MIC))) {
453                 dev_err(dev, "Handshake2 failed: MIC mismatch\n");
454                 goto error_hs2;
455         }
456
457         /* Send Handshake3 */
458         hs[2].bMessageNumber = 3;
459         hs[2].bStatus = 0;
460         put_unaligned_le32(tkid, hs[2].tTKID);
461         hs[2].bReserved = 0;
462         memcpy(hs[2].CDID, &wusb_dev->cdid, sizeof(hs[2].CDID));
463         memcpy(hs[2].nonce, hs[0].nonce, sizeof(hs[2].nonce));
464         result = wusb_oob_mic(hs[2].MIC, keydvt_out.kck, &ccm_n, &hs[2]);
465         if (result < 0) {
466                 dev_err(dev, "Handshake3 failed: cannot compute MIC: %d\n",
467                         result);
468                 goto error_hs2;
469         }
470
471         result = usb_control_msg(
472                 usb_dev, usb_sndctrlpipe(usb_dev, 0),
473                 USB_REQ_SET_HANDSHAKE,
474                 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
475                 3, 0, &hs[2], sizeof(hs[2]), USB_CTRL_SET_TIMEOUT);
476         if (result < 0) {
477                 dev_err(dev, "Handshake3: request failed: %d\n", result);
478                 goto error_hs3;
479         }
480
481         result = wusbhc->set_ptk(wusbhc, wusb_dev->port_idx, tkid,
482                                  keydvt_out.ptk, sizeof(keydvt_out.ptk));
483         if (result < 0)
484                 goto error_wusbhc_set_ptk;
485
486         result = wusb_dev_set_gtk(wusbhc, wusb_dev);
487         if (result < 0) {
488                 dev_err(dev, "Set GTK for device: request failed: %d\n",
489                         result);
490                 goto error_wusbhc_set_gtk;
491         }
492
493         /* Update the device's address from unauth to auth */
494         if (usb_dev->authenticated == 0) {
495                 result = wusb_dev_update_address(wusbhc, wusb_dev);
496                 if (result < 0)
497                         goto error_dev_update_address;
498         }
499         result = 0;
500         dev_info(dev, "device authenticated\n");
501
502 error_dev_update_address:
503 error_wusbhc_set_gtk:
504 error_wusbhc_set_ptk:
505 error_hs3:
506 error_hs2:
507 error_hs1:
508         memset(hs, 0, 3*sizeof(hs[0]));
509         memzero_explicit(&keydvt_out, sizeof(keydvt_out));
510         memzero_explicit(&keydvt_in, sizeof(keydvt_in));
511         memzero_explicit(&ccm_n, sizeof(ccm_n));
512         memzero_explicit(mic, sizeof(mic));
513         if (result < 0)
514                 wusb_dev_set_encryption(usb_dev, 0);
515 error_dev_set_encryption:
516         kfree(hs);
517 error_kzalloc:
518         return result;
519 }
520
521 /*
522  * Once all connected and authenticated devices have received the new
523  * GTK, switch the host to using it.
524  */
525 static void wusbhc_gtk_rekey_work(struct work_struct *work)
526 {
527         struct wusbhc *wusbhc = container_of(work,
528                                         struct wusbhc, gtk_rekey_work);
529         size_t key_size = sizeof(wusbhc->gtk.data);
530         int port_idx;
531         struct wusb_dev *wusb_dev, *wusb_dev_next;
532         LIST_HEAD(rekey_list);
533
534         mutex_lock(&wusbhc->mutex);
535         /* generate the new key */
536         wusbhc_generate_gtk(wusbhc);
537         /* roll the gtk index. */
538         wusbhc->gtk_index = (wusbhc->gtk_index + 1) % (WUSB_KEY_INDEX_MAX + 1);
539         /*
540          * Save all connected devices on a list while holding wusbhc->mutex and
541          * take a reference to each one.  Then submit the set key request to
542          * them after releasing the lock in order to avoid a deadlock.
543          */
544         for (port_idx = 0; port_idx < wusbhc->ports_max; port_idx++) {
545                 wusb_dev = wusbhc->port[port_idx].wusb_dev;
546                 if (!wusb_dev || !wusb_dev->usb_dev
547                         || !wusb_dev->usb_dev->authenticated)
548                         continue;
549
550                 wusb_dev_get(wusb_dev);
551                 list_add_tail(&wusb_dev->rekey_node, &rekey_list);
552         }
553         mutex_unlock(&wusbhc->mutex);
554
555         /* Submit the rekey requests without holding wusbhc->mutex. */
556         list_for_each_entry_safe(wusb_dev, wusb_dev_next, &rekey_list,
557                 rekey_node) {
558                 list_del_init(&wusb_dev->rekey_node);
559                 dev_dbg(&wusb_dev->usb_dev->dev,
560                         "%s: rekey device at port %d\n",
561                         __func__, wusb_dev->port_idx);
562
563                 if (wusb_dev_set_gtk(wusbhc, wusb_dev) < 0) {
564                         dev_err(&wusb_dev->usb_dev->dev,
565                                 "%s: rekey device at port %d failed\n",
566                                 __func__, wusb_dev->port_idx);
567                 }
568                 wusb_dev_put(wusb_dev);
569         }
570
571         /* Switch the host controller to use the new GTK. */
572         mutex_lock(&wusbhc->mutex);
573         wusbhc->set_gtk(wusbhc, wusbhc->gtk_tkid,
574                 &wusbhc->gtk.descr.bKeyData, key_size);
575         mutex_unlock(&wusbhc->mutex);
576 }
577
578 /**
579  * wusbhc_gtk_rekey - generate and distribute a new GTK
580  * @wusbhc: the WUSB host controller
581  *
582  * Generate a new GTK and distribute it to all connected and
583  * authenticated devices.  When all devices have the new GTK, the host
584  * starts using it.
585  *
586  * This must be called after every device disconnect (see [WUSB]
587  * section 6.2.11.2).
588  */
589 void wusbhc_gtk_rekey(struct wusbhc *wusbhc)
590 {
591         /*
592          * We need to submit a URB to the downstream WUSB devices in order to
593          * change the group key.  This can't be done while holding the
594          * wusbhc->mutex since that is also taken in the urb_enqueue routine
595          * and will cause a deadlock.  Instead, queue a work item to do
596          * it when the lock is not held
597          */
598         queue_work(wusbhc->wq_security, &wusbhc->gtk_rekey_work);
599 }