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