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