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