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