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