tool: Improve tool/*.py.
[gnuk/gnuk.git] / tool / gnuk_token.py
1 """
2 gnuk_token.py - a library for Gnuk Token
3
4 Copyright (C) 2011, 2012, 2013, 2015, 2017
5               Free Software Initiative of Japan
6 Author: NIIBE Yutaka <gniibe@fsij.org>
7
8 This file is a part of Gnuk, a GnuPG USB Token implementation.
9
10 Gnuk is free software: you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by
12 the Free Software Foundation, either version 3 of the License, or
13 (at your option) any later version.
14
15 Gnuk is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
18 License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 """
23
24 from struct import *
25 import binascii
26 import usb, time
27 from array import array
28
29 # Possible Gnuk Token products
30 USB_PRODUCT_LIST=[
31     { 'vendor' : 0x234b, 'product' : 0x0000 }, # FSIJ Gnuk Token
32     { 'vendor' : 0x20a0, 'product' : 0x4211 }, # Nitrokey Start
33 ]
34
35 # USB class, subclass, protocol
36 CCID_CLASS = 0x0B
37 CCID_SUBCLASS = 0x00
38 CCID_PROTOCOL_0 = 0x00
39
40 HID_CLASS = 0x03
41 HID_SUBCLASS_NO_BOOT = 0x00
42 HID_PROTOCOL_0 = 0x00
43
44 def icc_compose(msg_type, data_len, slot, seq, param, data):
45     return pack('<BiBBBH', msg_type, data_len, slot, seq, 0, param) + data
46
47 def iso7816_compose(ins, p1, p2, data, cls=0x00, le=None):
48     data_len = len(data)
49     if data_len == 0:
50         if not le:
51             return pack('>BBBB', cls, ins, p1, p2)
52         else:
53             return pack('>BBBBB', cls, ins, p1, p2, le)
54     else:
55         if not le:
56             return pack('>BBBBB', cls, ins, p1, p2, data_len) + data
57         else:
58             return pack('>BBBBB', cls, ins, p1, p2, data_len) \
59                 + data + pack('>B', le)
60
61 # This class only supports Gnuk (for now) 
62 class gnuk_token(object):
63     def __init__(self, device, configuration, interface):
64         """
65         __init__(device, configuration, interface) -> None
66         Initialize the device.
67         device: usb.Device object.
68         configuration: configuration number.
69         interface: usb.Interface object representing the interface and altenate setting.
70         """
71         if interface.interfaceClass != CCID_CLASS:
72             raise ValueError("Wrong interface class")
73         if interface.interfaceSubClass != CCID_SUBCLASS:
74             raise ValueError("Wrong interface sub class")
75         self.__devhandle = device.open()
76         self.__devhandle.claimInterface(interface)
77
78         self.__intf = interface.interfaceNumber
79         self.__alt = interface.alternateSetting
80         self.__conf = configuration
81
82         self.__hid_intf = None
83         for intf in configuration.interfaces:
84             for alt in intf:
85                 if alt.interfaceClass == HID_CLASS and \
86                         alt.interfaceSubClass == HID_SUBCLASS_NO_BOOT and \
87                         alt.interfaceProtocol == HID_PROTOCOL_0:
88                     self.__hid_intf = alt.interfaceNumber
89
90         self.__bulkout = 1
91         self.__bulkin  = 0x81
92
93         self.__timeout = 10000
94         self.__seq = 0
95
96     def get_string(self, num):
97         return self.__devhandle.getString(num, 512)
98
99     def increment_seq(self):
100         self.__seq = (self.__seq + 1) & 0xff
101
102     def reset_device(self):
103         try:
104             self.__devhandle.reset()
105         except:
106             pass
107
108     def release_gnuk(self):
109         self.__devhandle.releaseInterface()
110
111     def stop_gnuk(self):
112         self.__devhandle.releaseInterface()
113         if self.__hid_intf:
114             self.__devhandle.detachKernelDriver(self.__hid_intf)
115         self.__devhandle.setConfiguration(0)
116         return
117
118     def mem_info(self):
119         mem = self.__devhandle.controlMsg(requestType = 0xc0, request = 0,
120                                           buffer = 8, value = 0, index = 0,
121                                           timeout = 10)
122         start = ((mem[3]*256 + mem[2])*256 + mem[1])*256 + mem[0]
123         end = ((mem[7]*256 + mem[6])*256 + mem[5])*256 + mem[4]
124         return (start, end)
125
126     def download(self, start, data, verbose=False):
127         addr = start
128         addr_end = (start + len(data)) & 0xffffff00
129         i = int((addr - 0x20000000) / 0x100)
130         j = 0
131         print("start %08x" % addr)
132         print("end   %08x" % addr_end)
133         while addr < addr_end:
134             if verbose:
135                 print("# %08x: %d : %d" % (addr, i, 256))
136             self.__devhandle.controlMsg(requestType = 0x40, request = 1,
137                                         buffer = data[j*256:j*256+256],
138                                         value = i, index = 0, timeout = 10)
139             i = i+1
140             j = j+1
141             addr = addr + 256
142         residue = len(data) % 256
143         if residue != 0:
144             if verbose:
145                 print("# %08x: %d : %d" % (addr, i, residue))
146             self.__devhandle.controlMsg(requestType = 0x40, request = 1,
147                                         buffer = data[j*256:],
148                                         value = i, index = 0, timeout = 10)
149
150     def execute(self, last_addr):
151         i = int((last_addr - 0x20000000) / 0x100)
152         o = (last_addr - 0x20000000) % 0x100
153         self.__devhandle.controlMsg(requestType = 0x40, request = 2,
154                                     buffer = None, value = i, index = o, 
155                                     timeout = 10)
156
157     def icc_get_result(self):
158         usbmsg = self.__devhandle.bulkRead(self.__bulkin, 1024, self.__timeout)
159         if len(usbmsg) < 10:
160             print(usbmsg)
161             raise ValueError("icc_get_result")
162         msg = array('B', usbmsg)
163         msg_type = msg[0]
164         data_len = msg[1] + (msg[2]<<8) + (msg[3]<<16) + (msg[4]<<24)
165         slot = msg[5]
166         seq = msg[6]
167         status = msg[7]
168         error = msg[8]
169         chain = msg[9]
170         data = msg[10:]
171         # XXX: check msg_type, data_len, slot, seq, error
172         return (status, chain, data)
173
174     def icc_get_status(self):
175         msg = icc_compose(0x65, 0, 0, self.__seq, 0, b"")
176         self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
177         self.increment_seq()
178         status, chain, data = self.icc_get_result()
179         # XXX: check chain, data
180         return status
181
182     def icc_power_on(self):
183         msg = icc_compose(0x62, 0, 0, self.__seq, 0, b"")
184         self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
185         self.increment_seq()
186         status, chain, data = self.icc_get_result()
187         # XXX: check status, chain
188         self.atr = data
189         return self.atr
190
191     def icc_power_off(self):
192         msg = icc_compose(0x63, 0, 0, self.__seq, 0, b"")
193         self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
194         self.increment_seq()
195         status, chain, data = self.icc_get_result()
196         # XXX: check chain, data
197         return status
198
199     def icc_send_data_block(self, data):
200         msg = icc_compose(0x6f, len(data), 0, self.__seq, 0, data)
201         self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
202         self.increment_seq()
203         return self.icc_get_result()
204
205     def icc_send_cmd(self, data):
206         status, chain, data_rcv = self.icc_send_data_block(data)
207         if chain == 0:
208             while status == 0x80:
209                 status, chain, data_rcv = self.icc_get_result()
210             return data_rcv
211         elif chain == 1:
212             d = data_rcv
213             while True:
214                 msg = icc_compose(0x6f, 0, 0, self.__seq, 0x10, b"")
215                 self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
216                 self.increment_seq()
217                 status, chain, data_rcv = self.icc_get_result()
218                 # XXX: check status
219                 d += data_rcv
220                 if chain == 2:
221                     break
222                 elif chain == 3:
223                     continue
224                 else:
225                     raise ValueError("icc_send_cmd chain")
226             return d
227         else:
228             raise ValueError("icc_send_cmd")
229
230     def cmd_get_response(self, expected_len):
231         result = array('B')
232         while True:
233             cmd_data = iso7816_compose(0xc0, 0x00, 0x00, b'') + pack('>B', expected_len)
234             response = self.icc_send_cmd(cmd_data)
235             result += response[:-2]
236             sw = response[-2:]
237             if sw[0] == 0x90 and sw[1] == 0x00:
238                 return result
239             elif sw[0] != 0x61:
240                 raise ValueError("%02x%02x" % (sw[0], sw[1]))
241             else:
242                 expected_len = sw[1]
243
244     def cmd_verify(self, who, passwd):
245         cmd_data = iso7816_compose(0x20, 0x00, 0x80+who, passwd)
246         sw = self.icc_send_cmd(cmd_data)
247         if len(sw) != 2:
248             raise ValueError(sw)
249         if not (sw[0] == 0x90 and sw[1] == 0x00):
250             raise ValueError("%02x%02x" % (sw[0], sw[1]))
251         return True
252
253     def cmd_read_binary(self, fileid):
254         cmd_data = iso7816_compose(0xb0, 0x80+fileid, 0x00, b'')
255         sw = self.icc_send_cmd(cmd_data)
256         if len(sw) != 2:
257             raise ValueError(sw)
258         if sw[0] != 0x61:
259             raise ValueError("%02x%02x" % (sw[0], sw[1]))
260         return self.cmd_get_response(sw[1])
261
262     def cmd_write_binary(self, fileid, data, is_update):
263         count = 0
264         data_len = len(data)
265         if is_update:
266             ins = 0xd6
267         else:
268             ins = 0xd0
269         while count*256 < data_len:
270             if count == 0:
271                 if len(data) < 128:
272                     cmd_data0 = iso7816_compose(ins, 0x80+fileid, 0x00, data[:128])
273                     cmd_data1 = None
274                 else:
275                     cmd_data0 = iso7816_compose(ins, 0x80+fileid, 0x00, data[:128], 0x10)
276                     cmd_data1 = iso7816_compose(ins, 0x80+fileid, 0x00, data[128:256])
277             else:
278                 if len(data[256*count:256*count+128]) < 128:
279                     cmd_data0 = iso7816_compose(ins, count, 0x00, data[256*count:256*count+128])
280                     cmd_data1 = None
281                 else:
282                     cmd_data0 = iso7816_compose(ins, count, 0x00, data[256*count:256*count+128], 0x10)
283                     cmd_data1 = iso7816_compose(ins, count, 0x00, data[256*count+128:256*(count+1)])
284             sw = self.icc_send_cmd(cmd_data0)
285             if len(sw) != 2:
286                 raise ValueError("cmd_write_binary 0")
287             if not (sw[0] == 0x90 and sw[1] == 0x00):
288                 raise ValueError("cmd_write_binary 0", "%02x%02x" % (sw[0], sw[1]))
289             if cmd_data1:
290                 sw = self.icc_send_cmd(cmd_data1)
291                 if len(sw) != 2:
292                     raise ValueError("cmd_write_binary 1", sw)
293                 if not (sw[0] == 0x90 and sw[1] == 0x00):
294                     raise ValueError("cmd_write_binary 1", "%02x%02x" % (sw[0], sw[1]))
295             count += 1
296
297     def cmd_select_openpgp(self):
298         cmd_data = iso7816_compose(0xa4, 0x04, 0x00, b"\xD2\x76\x00\x01\x24\x01")
299         r = self.icc_send_cmd(cmd_data)
300         if len(r) < 2:
301             raise ValueError(r)
302         sw = r[-2:]
303         r = r[0:-2]
304         if sw[0] == 0x61:
305             self.cmd_get_response(sw[1])
306             return True
307         elif sw[0] == 0x90 and sw[1] == 0x00:
308             return True
309         else:
310             raise ValueError("%02x%02x" % (sw[0], sw[1]))
311
312     def cmd_get_data(self, tagh, tagl):
313         cmd_data = iso7816_compose(0xca, tagh, tagl, b"")
314         sw = self.icc_send_cmd(cmd_data)
315         if len(sw) != 2:
316             raise ValueError(sw)
317         if sw[0] == 0x90 and sw[1] == 0x00:
318             return array('B')
319         elif sw[0] != 0x61:
320             raise ValueError("%02x%02x" % (sw[0], sw[1]))
321         return self.cmd_get_response(sw[1])
322
323     def cmd_change_reference_data(self, who, data):
324         cmd_data = iso7816_compose(0x24, 0x00, 0x80+who, data)
325         sw = self.icc_send_cmd(cmd_data)
326         if len(sw) != 2:
327             raise ValueError(sw)
328         if not (sw[0] == 0x90 and sw[1] == 0x00):
329             raise ValueError("%02x%02x" % (sw[0], sw[1]))
330         return True
331
332     def cmd_put_data(self, tagh, tagl, content):
333         cmd_data = iso7816_compose(0xda, tagh, tagl, content)
334         sw = self.icc_send_cmd(cmd_data)
335         if len(sw) != 2:
336             raise ValueError(sw)
337         if not (sw[0] == 0x90 and sw[1] == 0x00):
338             raise ValueError("%02x%02x" % (sw[0], sw[1]))
339         return True
340
341     def cmd_put_data_odd(self, tagh, tagl, content):
342         cmd_data0 = iso7816_compose(0xdb, tagh, tagl, content[:128], 0x10)
343         cmd_data1 = iso7816_compose(0xdb, tagh, tagl, content[128:])
344         sw = self.icc_send_cmd(cmd_data0)
345         if len(sw) != 2:
346             raise ValueError(sw)
347         if not (sw[0] == 0x90 and sw[1] == 0x00):
348             raise ValueError("%02x%02x" % (sw[0], sw[1]))
349         sw = self.icc_send_cmd(cmd_data1)
350         if len(sw) != 2:
351             raise ValueError(sw)
352         if not (sw[0] == 0x90 and sw[1] == 0x00):
353             raise ValueError("%02x%02x" % (sw[0], sw[1]))
354         return True
355
356     def cmd_reset_retry_counter(self, how, who, data):
357         cmd_data = iso7816_compose(0x2c, how, who, data)
358         sw = self.icc_send_cmd(cmd_data)
359         if len(sw) != 2:
360             raise ValueError(sw)
361         if not (sw[0] == 0x90 and sw[1] == 0x00):
362             raise ValueError("%02x%02x" % (sw[0], sw[1]))
363         return True
364
365     def cmd_pso(self, p1, p2, data):
366         cmd_data = iso7816_compose(0x2a, p1, p2, data)
367         sw = self.icc_send_cmd(cmd_data)
368         if len(sw) != 2:
369             raise ValueError(sw)
370         if sw[0] == 0x90 and sw[1] == 0x00:
371             return array('B')
372         elif sw[0] != 0x61:
373             raise ValueError("%02x%02x" % (sw[0], sw[1]))
374         return self.cmd_get_response(sw[1])
375
376     def cmd_pso_longdata(self, p1, p2, data):
377         cmd_data0 = iso7816_compose(0x2a, p1, p2, data[:128], 0x10)
378         cmd_data1 = iso7816_compose(0x2a, p1, p2, data[128:])
379         sw = self.icc_send_cmd(cmd_data0)
380         if len(sw) != 2:
381             raise ValueError(sw)
382         if not (sw[0] == 0x90 and sw[1] == 0x00):
383             raise ValueError("%02x%02x" % (sw[0], sw[1]))
384         sw = self.icc_send_cmd(cmd_data1)
385         if len(sw) != 2:
386             raise ValueError(sw)
387         elif sw[0] != 0x61:
388             raise ValueError("%02x%02x" % (sw[0], sw[1]))
389         return self.cmd_get_response(sw[1])
390
391     def cmd_internal_authenticate(self, data):
392         cmd_data = iso7816_compose(0x88, 0, 0, data)
393         sw = self.icc_send_cmd(cmd_data)
394         if len(sw) != 2:
395             raise ValueError(sw)
396         if sw[0] == 0x90 and sw[1] == 0x00:
397             return array('B')
398         elif sw[0] != 0x61:
399             raise ValueError("%02x%02x" % (sw[0], sw[1]))
400         return self.cmd_get_response(sw[1])
401
402     def cmd_genkey(self, keyno):
403         if keyno == 1:
404             data = b'\xb6\x00'
405         elif keyno == 2:
406             data = b'\xb8\x00'
407         else:
408             data = b'\xa4\x00'
409         cmd_data = iso7816_compose(0x47, 0x80, 0, data)
410         sw = self.icc_send_cmd(cmd_data)
411         if len(sw) != 2:
412             raise ValueError(sw)
413         if sw[0] == 0x90 and sw[1] == 0x00:
414             return array('B')
415         elif sw[0] != 0x61:
416             raise ValueError("%02x%02x" % (sw[0], sw[1]))
417         pk = self.cmd_get_response(sw[1])
418         return (pk[9:9+256], pk[9+256+2:9+256+2+3])
419
420     def cmd_get_public_key(self, keyno):
421         if keyno == 1:
422             data = b'\xb6\x00'
423         elif keyno == 2:
424             data = b'\xb8\x00'
425         else:
426             data = b'\xa4\x00'
427         cmd_data = iso7816_compose(0x47, 0x81, 0, data)
428         sw = self.icc_send_cmd(cmd_data)
429         if len(sw) != 2:
430             raise ValueError(sw)
431         elif sw[0] != 0x61:
432             raise ValueError("%02x%02x" % (sw[0], sw[1]))
433         pk = self.cmd_get_response(sw[1])
434         return (pk[9:9+256], pk[9+256+2:9+256+2+3])
435
436     def cmd_put_data_remove(self, tagh, tagl):
437         cmd_data = iso7816_compose(0xda, tagh, tagl, b"")
438         sw = self.icc_send_cmd(cmd_data)
439         if sw[0] != 0x90 and sw[1] != 0x00:
440             raise ValueError("%02x%02x" % (sw[0], sw[1]))
441
442     def cmd_put_data_key_import_remove(self, keyno):
443         if keyno == 1:
444             keyspec = b"\xb6\x00"      # SIG
445         elif keyno == 2:
446             keyspec = b"\xb8\x00"      # DEC
447         else:
448             keyspec = b"\xa4\x00"      # AUT
449         cmd_data = iso7816_compose(0xdb, 0x3f, 0xff, b"\x4d\x02" +  keyspec)
450         sw = self.icc_send_cmd(cmd_data)
451         if sw[0] != 0x90 and sw[1] != 0x00:
452             raise ValueError("%02x%02x" % (sw[0], sw[1]))
453
454     def cmd_get_challenge(self):
455         cmd_data = iso7816_compose(0x84, 0x00, 0x00, '')
456         sw = self.icc_send_cmd(cmd_data)
457         if len(sw) != 2:
458             raise ValueError(sw)
459         if sw[0] != 0x61:
460             raise ValueError("%02x%02x" % (sw[0], sw[1]))
461         return self.cmd_get_response(sw[1])
462
463     def cmd_external_authenticate(self, keyno, signed):
464         cmd_data = iso7816_compose(0x82, 0x00, keyno, signed[0:128], cls=0x10)
465         sw = self.icc_send_cmd(cmd_data)
466         if len(sw) != 2:
467             raise ValueError(sw)
468         if not (sw[0] == 0x90 and sw[1] == 0x00):
469             raise ValueError("%02x%02x" % (sw[0], sw[1]))
470         cmd_data = iso7816_compose(0x82, 0x00, keyno, signed[128:])
471         sw = self.icc_send_cmd(cmd_data)
472         if len(sw) != 2:
473             raise ValueError(sw)
474         if not (sw[0] == 0x90 and sw[1] == 0x00):
475             raise ValueError("%02x%02x" % (sw[0], sw[1]))
476
477
478 class regnual(object):
479     def __init__(self, dev):
480         conf = dev.configurations[0]
481         intf_alt = conf.interfaces[0]
482         intf = intf_alt[0]
483         if intf.interfaceClass != 0xff:
484             raise ValueError("Wrong interface class")
485         self.__devhandle = dev.open()
486         self.__devhandle.claimInterface(intf)
487
488     def mem_info(self):
489         mem = self.__devhandle.controlMsg(requestType = 0xc0, request = 0,
490                                           buffer = 8, value = 0, index = 0,
491                                           timeout = 10000)
492         start = ((mem[3]*256 + mem[2])*256 + mem[1])*256 + mem[0]
493         end = ((mem[7]*256 + mem[6])*256 + mem[5])*256 + mem[4]
494         return (start, end)
495
496     def download(self, start, data, verbose=False):
497         addr = start
498         addr_end = (start + len(data)) & 0xffffff00
499         i = int((addr - 0x08000000) / 0x100)
500         j = 0
501         print("start %08x" % addr)
502         print("end   %08x" % addr_end)
503         while addr < addr_end:
504             if verbose:
505                 print("# %08x: %d: %d : %d" % (addr, i, j, 256))
506             self.__devhandle.controlMsg(requestType = 0x40, request = 1,
507                                         buffer = data[j*256:j*256+256],
508                                         value = 0, index = 0, timeout = 10000)
509             crc32code = crc32(data[j*256:j*256+256])
510             res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
511                                               buffer = 4, value = 0, index = 0,
512                                               timeout = 10000)
513             r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
514             if (crc32code ^ r_value) != 0xffffffff:
515                 print("failure")
516             self.__devhandle.controlMsg(requestType = 0x40, request = 3,
517                                         buffer = None,
518                                         value = i, index = 0, timeout = 10000)
519             time.sleep(0.010)
520             res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
521                                               buffer = 4, value = 0, index = 0,
522                                               timeout = 10000)
523             r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
524             if r_value == 0:
525                 print("failure")
526             i = i+1
527             j = j+1
528             addr = addr + 256
529         residue = len(data) % 256
530         if residue != 0:
531             if verbose:
532                 print("# %08x: %d : %d" % (addr, i, residue))
533             self.__devhandle.controlMsg(requestType = 0x40, request = 1,
534                                         buffer = data[j*256:],
535                                         value = 0, index = 0, timeout = 10000)
536             crc32code = crc32(data[j*256:].ljust(256,b'\xff'))
537             res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
538                                               buffer = 4, value = 0, index = 0,
539                                               timeout = 10000)
540             r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
541             if (crc32code ^ r_value) != 0xffffffff:
542                 print("failure")
543             self.__devhandle.controlMsg(requestType = 0x40, request = 3,
544                                         buffer = None,
545                                         value = i, index = 0, timeout = 10000)
546             time.sleep(0.010)
547             res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
548                                               buffer = 4, value = 0, index = 0, 
549                                               timeout = 10000)
550             r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
551             if r_value == 0:
552                 print("failure")
553
554     def protect(self):
555         self.__devhandle.controlMsg(requestType = 0x40, request = 4,
556                                     buffer = None, value = 0, index = 0, 
557                                     timeout = 10000)
558         time.sleep(0.100)
559         res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
560                                           buffer = 4, value = 0, index = 0, 
561                                           timeout = 10000)
562         r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
563         if r_value == 0:
564             print("protection failure")
565
566     def finish(self):
567         self.__devhandle.controlMsg(requestType = 0x40, request = 5,
568                                     buffer = None, value = 0, index = 0, 
569                                     timeout = 10000)
570
571     def reset_device(self):
572         try:
573             self.__devhandle.reset()
574         except:
575             pass
576
577 def compare(data_original, data_in_device):
578     if data_original == data_in_device:
579         return True
580     raise ValueError("verify failed")
581
582 def gnuk_devices():
583     busses = usb.busses()
584     for bus in busses:
585         devices = bus.devices
586         for dev in devices:
587             for config in dev.configurations:
588                 for intf in config.interfaces:
589                     for alt in intf:
590                         if alt.interfaceClass == CCID_CLASS and \
591                                 alt.interfaceSubClass == CCID_SUBCLASS and \
592                                 alt.interfaceProtocol == CCID_PROTOCOL_0:
593                             yield dev, config, alt
594
595 def gnuk_devices_by_vidpid():
596     busses = usb.busses()
597     for bus in busses:
598         devices = bus.devices
599         for dev in devices:
600             for cand in USB_PRODUCT_LIST:
601                 if dev.idVendor != cand['vendor']:
602                     continue
603                 if dev.idProduct != cand['product']:
604                     continue
605                 yield dev
606                 break
607
608 def get_gnuk_device():
609     icc = None
610     for (dev, config, intf) in gnuk_devices():
611         try:
612             icc = gnuk_token(dev, config, intf)
613             print("Device: %s" % dev.filename)
614             print("Configuration: %d" % config.value)
615             print("Interface: %d" % intf.interfaceNumber)
616             break
617         except:
618             pass
619     if not icc:
620         raise ValueError("No ICC present")
621     status = icc.icc_get_status()
622     if status == 0:
623         pass                    # It's ON already
624     elif status == 1:
625         icc.icc_power_on()
626     else:
627         raise ValueError("Unknown ICC status", status)
628     return icc
629
630 SHA256_OID_PREFIX="3031300d060960864801650304020105000420"
631
632 def UNSIGNED(n):
633     return n & 0xffffffff
634
635 def crc32(bytestr):
636     crc = binascii.crc32(bytestr)
637     return UNSIGNED(crc)