version 1.1.5
[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         try:
72             self.__devhandle.setConfiguration(configuration)
73         except:
74             pass
75         self.__devhandle.claimInterface(interface)
76         self.__devhandle.setAltInterface(0)
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                                           value = 0, index = 0, buffer = 8,
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 = (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                                         value = i, index = 0,
138                                         buffer = data[j*256:j*256+256],
139                                         timeout = 10)
140             i = i+1
141             j = j+1
142             addr = addr + 256
143         residue = len(data) % 256
144         if residue != 0:
145             if verbose:
146                 print("# %08x: %d : %d" % (addr, i, residue))
147             self.__devhandle.controlMsg(requestType = 0x40, request = 1,
148                                         value = i, index = 0,
149                                         buffer = data[j*256:],
150                                         timeout = 10)
151
152     def execute(self, last_addr):
153         i = (last_addr - 0x20000000) / 0x100
154         o = (last_addr - 0x20000000) % 0x100
155         self.__devhandle.controlMsg(requestType = 0x40, request = 2,
156                                     value = i, index = o, buffer = None,
157                                     timeout = 10)
158
159     def icc_get_result(self):
160         msg = self.__devhandle.bulkRead(self.__bulkin, 1024, self.__timeout)
161         if len(msg) < 10:
162             print(msg)
163             raise ValueError("icc_get_result")
164         msg_type = msg[0]
165         data_len = msg[1] + (msg[2]<<8) + (msg[3]<<16) + (msg[4]<<24)
166         slot = msg[5]
167         seq = msg[6]
168         status = msg[7]
169         error = msg[8]
170         chain = msg[9]
171         data = msg[10:]
172         # XXX: check msg_type, data_len, slot, seq, error
173         return (status, chain, data)
174
175     def icc_get_status(self):
176         msg = icc_compose(0x65, 0, 0, self.__seq, 0, "")
177         self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
178         self.increment_seq()
179         status, chain, data = self.icc_get_result()
180         # XXX: check chain, data
181         return status
182
183     def icc_power_on(self):
184         msg = icc_compose(0x62, 0, 0, self.__seq, 0, "")
185         self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
186         self.increment_seq()
187         status, chain, data = self.icc_get_result()
188         # XXX: check status, chain
189         self.atr = list_to_string(data) # ATR
190         return self.atr
191
192     def icc_power_off(self):
193         msg = icc_compose(0x63, 0, 0, self.__seq, 0, "")
194         self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
195         self.increment_seq()
196         status, chain, data = self.icc_get_result()
197         # XXX: check chain, data
198         return status
199
200     def icc_send_data_block(self, data):
201         msg = icc_compose(0x6f, len(data), 0, self.__seq, 0, data)
202         self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
203         self.increment_seq()
204         return self.icc_get_result()
205
206     def icc_send_cmd(self, data):
207         status, chain, data_rcv = self.icc_send_data_block(data)
208         if chain == 0:
209             while status == 0x80:
210                 status, chain, data_rcv = self.icc_get_result()
211             return data_rcv
212         elif chain == 1:
213             d = data_rcv
214             while True:
215                 msg = icc_compose(0x6f, 0, 0, self.__seq, 0x10, "")
216                 self.__devhandle.bulkWrite(self.__bulkout, msg, self.__timeout)
217                 self.increment_seq()
218                 status, chain, data_rcv = self.icc_get_result()
219                 # XXX: check status
220                 d += data_rcv
221                 if chain == 2:
222                     break
223                 elif chain == 3:
224                     continue
225                 else:
226                     raise ValueError("icc_send_cmd chain")
227             return d
228         else:
229             raise ValueError("icc_send_cmd")
230
231     def cmd_get_response(self, expected_len):
232         result = []
233         while True:
234             cmd_data = iso7816_compose(0xc0, 0x00, 0x00, '') + pack('>B', expected_len)
235             response = self.icc_send_cmd(cmd_data)
236             result += response[:-2]
237             sw = response[-2:]
238             if sw[0] == 0x90 and sw[1] == 0x00:
239                 return list_to_string(result)
240             elif sw[0] != 0x61:
241                 raise ValueError("%02x%02x" % (sw[0], sw[1]))
242             else:
243                 expected_len = sw[1]
244
245     def cmd_verify(self, who, passwd):
246         cmd_data = iso7816_compose(0x20, 0x00, 0x80+who, passwd)
247         sw = self.icc_send_cmd(cmd_data)
248         if len(sw) != 2:
249             raise ValueError(sw)
250         if not (sw[0] == 0x90 and sw[1] == 0x00):
251             raise ValueError("%02x%02x" % (sw[0], sw[1]))
252         return True
253
254     def cmd_read_binary(self, fileid):
255         cmd_data = iso7816_compose(0xb0, 0x80+fileid, 0x00, '')
256         sw = self.icc_send_cmd(cmd_data)
257         if len(sw) != 2:
258             raise ValueError(sw)
259         if sw[0] != 0x61:
260             raise ValueError("%02x%02x" % (sw[0], sw[1]))
261         return self.cmd_get_response(sw[1])
262
263     def cmd_write_binary(self, fileid, data, is_update):
264         count = 0
265         data_len = len(data)
266         if is_update:
267             ins = 0xd6
268         else:
269             ins = 0xd0
270         while count*256 < data_len:
271             if count == 0:
272                 if len(data) < 128:
273                     cmd_data0 = iso7816_compose(ins, 0x80+fileid, 0x00, data[:128])
274                     cmd_data1 = None
275                 else:
276                     cmd_data0 = iso7816_compose(ins, 0x80+fileid, 0x00, data[:128], 0x10)
277                     cmd_data1 = iso7816_compose(ins, 0x80+fileid, 0x00, data[128:256])
278             else:
279                 if len(data[256*count:256*count+128]) < 128:
280                     cmd_data0 = iso7816_compose(ins, count, 0x00, data[256*count:256*count+128])
281                     cmd_data1 = None
282                 else:
283                     cmd_data0 = iso7816_compose(ins, count, 0x00, data[256*count:256*count+128], 0x10)
284                     cmd_data1 = iso7816_compose(ins, count, 0x00, data[256*count+128:256*(count+1)])
285             sw = self.icc_send_cmd(cmd_data0)
286             if len(sw) != 2:
287                 raise ValueError("cmd_write_binary 0")
288             if not (sw[0] == 0x90 and sw[1] == 0x00):
289                 raise ValueError("cmd_write_binary 0", "%02x%02x" % (sw[0], sw[1]))
290             if cmd_data1:
291                 sw = self.icc_send_cmd(cmd_data1)
292                 if len(sw) != 2:
293                     raise ValueError("cmd_write_binary 1", sw)
294                 if not (sw[0] == 0x90 and sw[1] == 0x00):
295                     raise ValueError("cmd_write_binary 1", "%02x%02x" % (sw[0], sw[1]))
296             count += 1
297
298     def cmd_select_openpgp(self):
299         cmd_data = iso7816_compose(0xa4, 0x04, 0x0c, "\xD2\x76\x00\x01\x24\x01")
300         sw = self.icc_send_cmd(cmd_data)
301         if len(sw) != 2:
302             raise ValueError, sw
303         if not (sw[0] == 0x90 and sw[1] == 0x00):
304             raise ValueError("%02x%02x" % (sw[0], sw[1]))
305         return True
306
307     def cmd_get_data(self, tagh, tagl):
308         cmd_data = iso7816_compose(0xca, tagh, tagl, "")
309         sw = self.icc_send_cmd(cmd_data)
310         if len(sw) != 2:
311             raise ValueError, sw
312         if sw[0] == 0x90 and sw[1] == 0x00:
313             return ""
314         elif sw[0] != 0x61:
315             raise ValueError("%02x%02x" % (sw[0], sw[1]))
316         return self.cmd_get_response(sw[1])
317
318     def cmd_change_reference_data(self, who, data):
319         cmd_data = iso7816_compose(0x24, 0x00, 0x80+who, data)
320         sw = self.icc_send_cmd(cmd_data)
321         if len(sw) != 2:
322             raise ValueError(sw)
323         if not (sw[0] == 0x90 and sw[1] == 0x00):
324             raise ValueError("%02x%02x" % (sw[0], sw[1]))
325         return True
326
327     def cmd_put_data(self, tagh, tagl, content):
328         cmd_data = iso7816_compose(0xda, tagh, tagl, content)
329         sw = self.icc_send_cmd(cmd_data)
330         if len(sw) != 2:
331             raise ValueError(sw)
332         if not (sw[0] == 0x90 and sw[1] == 0x00):
333             raise ValueError("%02x%02x" % (sw[0], sw[1]))
334         return True
335
336     def cmd_put_data_odd(self, tagh, tagl, content):
337         cmd_data0 = iso7816_compose(0xdb, tagh, tagl, content[:128], 0x10)
338         cmd_data1 = iso7816_compose(0xdb, tagh, tagl, content[128:])
339         sw = self.icc_send_cmd(cmd_data0)
340         if len(sw) != 2:
341             raise ValueError(sw)
342         if not (sw[0] == 0x90 and sw[1] == 0x00):
343             raise ValueError("%02x%02x" % (sw[0], sw[1]))
344         sw = self.icc_send_cmd(cmd_data1)
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         return True
350
351     def cmd_reset_retry_counter(self, how, data):
352         cmd_data = iso7816_compose(0x2c, how, 0x00, data)
353         sw = self.icc_send_cmd(cmd_data)
354         if len(sw) != 2:
355             raise ValueError(sw)
356         if not (sw[0] == 0x90 and sw[1] == 0x00):
357             raise ValueError("%02x%02x" % (sw[0], sw[1]))
358         return True
359
360     def cmd_pso(self, p1, p2, data):
361         cmd_data = iso7816_compose(0x2a, p1, p2, data)
362         sw = self.icc_send_cmd(cmd_data)
363         if len(sw) != 2:
364             raise ValueError(sw)
365         if sw[0] == 0x90 and sw[1] == 0x00:
366             return ""
367         elif sw[0] != 0x61:
368             raise ValueError("%02x%02x" % (sw[0], sw[1]))
369         return self.cmd_get_response(sw[1])
370
371     def cmd_pso_longdata(self, p1, p2, data):
372         cmd_data0 = iso7816_compose(0x2a, p1, p2, data[:128], 0x10)
373         cmd_data1 = iso7816_compose(0x2a, p1, p2, data[128:])
374         sw = self.icc_send_cmd(cmd_data0)
375         if len(sw) != 2:
376             raise ValueError(sw)
377         if not (sw[0] == 0x90 and sw[1] == 0x00):
378             raise ValueError("%02x%02x" % (sw[0], sw[1]))
379         sw = self.icc_send_cmd(cmd_data1)
380         if len(sw) != 2:
381             raise ValueError(sw)
382         elif sw[0] != 0x61:
383             raise ValueError("%02x%02x" % (sw[0], sw[1]))
384         return self.cmd_get_response(sw[1])
385
386     def cmd_internal_authenticate(self, data):
387         cmd_data = iso7816_compose(0x88, 0, 0, data)
388         sw = self.icc_send_cmd(cmd_data)
389         if len(sw) != 2:
390             raise ValueError(sw)
391         if sw[0] == 0x90 and sw[1] == 0x00:
392             return ""
393         elif sw[0] != 0x61:
394             raise ValueError("%02x%02x" % (sw[0], sw[1]))
395         return self.cmd_get_response(sw[1])
396
397     def cmd_genkey(self, keyno):
398         if keyno == 1:
399             data = '\xb6\x00'
400         elif keyno == 2:
401             data = '\xb8\x00'
402         else:
403             data = '\xa4\x00'
404         cmd_data = iso7816_compose(0x47, 0x80, 0, data)
405         sw = self.icc_send_cmd(cmd_data)
406         if len(sw) != 2:
407             raise ValueError(sw)
408         if sw[0] == 0x90 and sw[1] == 0x00:
409             return ""
410         elif sw[0] != 0x61:
411             raise ValueError("%02x%02x" % (sw[0], sw[1]))
412         pk = self.cmd_get_response(sw[1])
413         return (pk[9:9+256], pk[9+256+2:9+256+2+3])
414
415     def cmd_get_public_key(self, keyno):
416         if keyno == 1:
417             data = '\xb6\x00'
418         elif keyno == 2:
419             data = '\xb8\x00'
420         else:
421             data = '\xa4\x00'
422         cmd_data = iso7816_compose(0x47, 0x81, 0, data)
423         sw = self.icc_send_cmd(cmd_data)
424         if len(sw) != 2:
425             raise ValueError(sw)
426         elif sw[0] != 0x61:
427             raise ValueError("%02x%02x" % (sw[0], sw[1]))
428         pk = self.cmd_get_response(sw[1])
429         return (pk[9:9+256], pk[9+256+2:9+256+2+3])
430
431     def cmd_put_data_remove(self, tagh, tagl):
432         cmd_data = iso7816_compose(0xda, tagh, tagl, "")
433         sw = self.icc_send_cmd(cmd_data)
434         if sw[0] != 0x90 and sw[1] != 0x00:
435             raise ValueError, ("%02x%02x" % (sw[0], sw[1]))
436
437     def cmd_put_data_key_import_remove(self, keyno):
438         if keyno == 1:
439             keyspec = "\xb6\x00"      # SIG
440         elif keyno == 2:
441             keyspec = "\xb8\x00"      # DEC
442         else:
443             keyspec = "\xa4\x00"      # AUT
444         cmd_data = iso7816_compose(0xdb, 0x3f, 0xff, "\x4d\x02" +  keyspec)
445         sw = self.icc_send_cmd(cmd_data)
446         if sw[0] != 0x90 and sw[1] != 0x00:
447             raise ValueError, ("%02x%02x" % (sw[0], sw[1]))
448
449     def cmd_get_challenge(self):
450         cmd_data = iso7816_compose(0x84, 0x00, 0x00, '')
451         sw = self.icc_send_cmd(cmd_data)
452         if len(sw) != 2:
453             raise ValueError(sw)
454         if sw[0] != 0x61:
455             raise ValueError("%02x%02x" % (sw[0], sw[1]))
456         return self.cmd_get_response(sw[1])
457
458     def cmd_external_authenticate(self, keyno, signed):
459         cmd_data = iso7816_compose(0x82, 0x00, keyno, signed[0:128], cls=0x10)
460         sw = self.icc_send_cmd(cmd_data)
461         if len(sw) != 2:
462             raise ValueError(sw)
463         if not (sw[0] == 0x90 and sw[1] == 0x00):
464             raise ValueError("%02x%02x" % (sw[0], sw[1]))
465         cmd_data = iso7816_compose(0x82, 0x00, keyno, signed[128:])
466         sw = self.icc_send_cmd(cmd_data)
467         if len(sw) != 2:
468             raise ValueError(sw)
469         if not (sw[0] == 0x90 and sw[1] == 0x00):
470             raise ValueError("%02x%02x" % (sw[0], sw[1]))
471
472
473 class regnual(object):
474     def __init__(self, dev):
475         conf = dev.configurations[0]
476         intf_alt = conf.interfaces[0]
477         intf = intf_alt[0]
478         if intf.interfaceClass != 0xff:
479             raise ValueError("Wrong interface class")
480         self.__devhandle = dev.open()
481         try:
482             self.__devhandle.setConfiguration(conf)
483         except:
484             pass
485         self.__devhandle.claimInterface(intf)
486         self.__devhandle.setAltInterface(0)
487
488     def mem_info(self):
489         mem = self.__devhandle.controlMsg(requestType = 0xc0, request = 0,
490                                           value = 0, index = 0, buffer = 8,
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 = (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                                         value = 0, index = 0,
508                                         buffer = data[j*256:j*256+256],
509                                         timeout = 10000)
510             crc32code = crc32(data[j*256:j*256+256])
511             res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
512                                               value = 0, index = 0, buffer = 4,
513                                               timeout = 10000)
514             r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
515             if (crc32code ^ r_value) != 0xffffffff:
516                 print("failure")
517             self.__devhandle.controlMsg(requestType = 0x40, request = 3,
518                                         value = i, index = 0,
519                                         buffer = None,
520                                         timeout = 10000)
521             time.sleep(0.010)
522             res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
523                                               value = 0, index = 0, buffer = 4,
524                                               timeout = 10000)
525             r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
526             if r_value == 0:
527                 print("failure")
528             i = i+1
529             j = j+1
530             addr = addr + 256
531         residue = len(data) % 256
532         if residue != 0:
533             if verbose:
534                 print("# %08x: %d : %d" % (addr, i, residue))
535             self.__devhandle.controlMsg(requestType = 0x40, request = 1,
536                                         value = 0, index = 0,
537                                         buffer = data[j*256:],
538                                         timeout = 10000)
539             crc32code = crc32(data[j*256:].ljust(256,chr(255)))
540             res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
541                                               value = 0, index = 0, buffer = 4,
542                                               timeout = 10000)
543             r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
544             if (crc32code ^ r_value) != 0xffffffff:
545                 print("failure")
546             self.__devhandle.controlMsg(requestType = 0x40, request = 3,
547                                         value = i, index = 0,
548                                         buffer = None,
549                                         timeout = 10000)
550             time.sleep(0.010)
551             res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
552                                               value = 0, index = 0, buffer = 4,
553                                               timeout = 10000)
554             r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
555             if r_value == 0:
556                 print("failure")
557
558     def protect(self):
559         self.__devhandle.controlMsg(requestType = 0x40, request = 4,
560                                     value = 0, index = 0, buffer = None,
561                                     timeout = 10000)
562         time.sleep(0.100)
563         res = self.__devhandle.controlMsg(requestType = 0xc0, request = 2,
564                                           value = 0, index = 0, buffer = 4,
565                                           timeout = 10000)
566         r_value = ((res[3]*256 + res[2])*256 + res[1])*256 + res[0]
567         if r_value == 0:
568             print("protection failure")
569
570     def finish(self):
571         self.__devhandle.controlMsg(requestType = 0x40, request = 5,
572                                     value = 0, index = 0, buffer = None,
573                                     timeout = 10000)
574
575     def reset_device(self):
576         try:
577             self.__devhandle.reset()
578         except:
579             pass
580
581 def compare(data_original, data_in_device):
582     if data_original == data_in_device:
583         return True
584     raise ValueError("verify failed")
585
586 def gnuk_devices():
587     busses = usb.busses()
588     for bus in busses:
589         devices = bus.devices
590         for dev in devices:
591             for config in dev.configurations:
592                 for intf in config.interfaces:
593                     for alt in intf:
594                         if alt.interfaceClass == CCID_CLASS and \
595                                 alt.interfaceSubClass == CCID_SUBCLASS and \
596                                 alt.interfaceProtocol == CCID_PROTOCOL_0:
597                             yield dev, config, alt
598
599 USB_VENDOR_FSIJ=0x234b
600 USB_PRODUCT_GNUK=0x0000
601
602 def gnuk_devices_by_vidpid():
603     busses = usb.busses()
604     for bus in busses:
605         devices = bus.devices
606         for dev in devices:
607             if dev.idVendor != USB_VENDOR_FSIJ:
608                 continue
609             if dev.idProduct != USB_PRODUCT_GNUK:
610                 continue
611             yield dev
612
613 def get_gnuk_device():
614     icc = None
615     for (dev, config, intf) in gnuk_devices():
616         try:
617             icc = gnuk_token(dev, config, intf)
618             print("Device: %s" % dev.filename)
619             print("Configuration: %d" % config.value)
620             print("Interface: %d" % intf.interfaceNumber)
621             break
622         except:
623             pass
624     if not icc:
625         raise ValueError("No ICC present")
626     status = icc.icc_get_status()
627     if status == 0:
628         pass                    # It's ON already
629     elif status == 1:
630         icc.icc_power_on()
631     else:
632         raise ValueError("Unknown ICC status", status)
633     return icc
634
635 SHA256_OID_PREFIX="3031300d060960864801650304020105000420"
636
637 def UNSIGNED(n):
638     return n & 0xffffffff
639
640 def crc32(bytestr):
641     crc = binascii.crc32(bytestr)
642     return UNSIGNED(crc)