c09a8750df8743172265a86cfb69ab4ca22f5f86
[gnuk/gnuk.git] / tests / card_reader.py
1 """
2 card_reader.py - a library for smartcard reader
3
4 Copyright (C) 2016, 2017, 2019  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 import usb.core
24 from struct import pack
25 from usb.util import find_descriptor, claim_interface, get_string, \
26     endpoint_type, endpoint_direction, \
27     ENDPOINT_TYPE_BULK, ENDPOINT_OUT, ENDPOINT_IN
28 from binascii import hexlify
29
30 # USB class, subclass, protocol
31 CCID_CLASS = 0x0B
32 CCID_SUBCLASS = 0x00
33 CCID_PROTOCOL_0 = 0x00
34
35 def ccid_compose(msg_type, seq, slot=0, rsv=0, param=0, data=b""):
36     return pack('<BiBBBH', msg_type, len(data), slot, seq, rsv, param) + data
37
38 IFSC=254
39
40 def compute_edc(pcb, info):
41     edc = pcb
42     edc ^= len(info)
43     for i in range(len(info)):
44         edc ^= info[i]
45     return edc
46
47 def compose_i_block(ns, info, more):
48     pcb = 0x00
49     if ns:
50         pcb |= 0x40
51     if more:
52         pcb |= 0x20
53     edc = compute_edc(pcb, info)
54     return bytes([0, pcb, len(info)]) + info + bytes([edc])
55
56 def compose_r_block(nr, edc_error=0):
57     pcb = 0x80
58     if nr:
59         pcb |= 0x10
60     if edc_error:
61         pcb |= 0x01
62     return bytes([0, pcb, 0, pcb])
63
64 def is_r_block_no_error_or_other(blk):
65     return (((blk[1] & 0xC0) == 0x80 and (blk[1] & 0x2f) == 0x00)) or \
66         ((blk[1] & 0xC0) != 0x80)
67
68 def is_s_block_time_ext(blk):
69     return (blk[1] == 0xC3)
70
71 def is_i_block_last(blk):
72     return ((blk[1] & 0x80) == 0 and (blk[1] & 0x20) == 0)
73
74 def is_i_block_more(blk):
75     return ((blk[1] & 0x80) == 0 and (blk[1] & 0x20) == 0x20)
76
77 def is_edc_error(blk):
78     # to be implemented
79     return 0
80
81 def i_block_content(blk):
82     return blk[3:-1]
83
84 class CardReader(object):
85     def __init__(self, dev):
86         """
87         __init__(dev) -> None
88         Initialize the DEV of CCID.
89         device: usb.core.Device object.
90         """
91
92         cfg = dev.get_active_configuration()
93         intf = find_descriptor(cfg, bInterfaceClass=CCID_CLASS,
94                                bInterfaceSubClass=CCID_SUBCLASS,
95                                bInterfaceProtocol=CCID_PROTOCOL_0)
96         if intf is None:
97             raise ValueError("Not a CCID device")
98
99         claim_interface(dev, intf)
100
101         for ep in intf:
102             if endpoint_type(ep.bmAttributes) == ENDPOINT_TYPE_BULK and \
103                endpoint_direction(ep.bEndpointAddress) == ENDPOINT_OUT:
104                self.__bulkout = ep.bEndpointAddress
105             if endpoint_type(ep.bmAttributes) == ENDPOINT_TYPE_BULK and \
106                endpoint_direction(ep.bEndpointAddress) == ENDPOINT_IN:
107                self.__bulkin = ep.bEndpointAddress
108
109         assert len(intf.extra_descriptors) == 54
110         assert intf.extra_descriptors[1] == 33
111
112         if (intf.extra_descriptors[42] & 0x02):
113             # Short APDU level exchange
114             self.__use_APDU = True
115         elif (intf.extra_descriptors[42] & 0x04):
116             # Short and extended APDU level exchange
117             self.__use_APDU = True
118         elif (intf.extra_descriptors[42] & 0x01):
119             # TPDU level exchange
120             self.__use_APDU = False
121         else:
122             raise ValueError("Unknown exchange level")
123
124         # Check other bits???
125         #       intf.extra_descriptors[40]
126         #       intf.extra_descriptors[41]
127
128         self.__dev = dev
129         self.__timeout = 10000
130         self.__seq = 0
131
132     def get_string(self, num):
133         return get_string(self.__dev, num)
134
135     def increment_seq(self):
136         self.__seq = (self.__seq + 1) & 0xff
137
138     def reset_device(self):
139         try:
140             self.__dev.reset()
141         except:
142             pass
143
144     def is_tpdu_reader(self):
145         return not self.__use_APDU
146
147     def ccid_get_result(self):
148         msg = self.__dev.read(self.__bulkin, 1024, self.__timeout)
149         if len(msg) < 10:
150             print(msg)
151             raise ValueError("ccid_get_result")
152         msg_type = msg[0]
153         data_len = msg[1] + (msg[2]<<8) + (msg[3]<<16) + (msg[4]<<24)
154         slot = msg[5]
155         seq = msg[6]
156         status = msg[7]
157         error = msg[8]
158         chain = msg[9]
159         data = msg[10:]
160         # XXX: check msg_type, data_len, slot, seq, error
161         return (status, chain, data.tobytes())
162
163     def ccid_get_status(self):
164         msg = ccid_compose(0x65, self.__seq)
165         self.__dev.write(self.__bulkout, msg, self.__timeout)
166         self.increment_seq()
167         status, chain, data = self.ccid_get_result()
168         # XXX: check chain, data
169         return status
170
171     def ccid_power_on(self):
172         msg = ccid_compose(0x62, self.__seq, rsv=2) # Vcc=3.3V
173         self.__dev.write(self.__bulkout, msg, self.__timeout)
174         self.increment_seq()
175         status, chain, data = self.ccid_get_result()
176         # XXX: check status, chain
177         self.atr = data
178         #
179         if self.__use_APDU == False:
180             # TPDU reader configuration
181             self.ns = 0
182             self.nr = 0
183             # For Gemalto's SmartCard Reader(s)
184             if self.__dev.idVendor == 0x08E6:
185                 # Set PPS
186                 pps = b"\xFF\x11\x18\xF6"
187                 status, chain, ret_pps = self.ccid_send_data_block(pps)
188             # Set parameters
189             param = b"\x18\x10\xFF\x75\x00\xFE\x00"
190             # ^--- This shoud be adapted by ATR string, see update_param_by_atr
191             msg = ccid_compose(0x61, self.__seq, rsv=0x1, data=param)
192             self.__dev.write(self.__bulkout, msg, self.__timeout)
193             self.increment_seq()
194             status, chain, ret_param = self.ccid_get_result()
195             # Send an S-block of changing IFSD=254
196             sblk = b"\x00\xC1\x01\xFE\x3E"
197             status, chain, ret_sblk = self.ccid_send_data_block(sblk)
198         return self.atr
199
200     def ccid_power_off(self):
201         msg = ccid_compose(0x63, self.__seq)
202         self.__dev.write(self.__bulkout, msg, self.__timeout)
203         self.increment_seq()
204         status, chain, data = self.ccid_get_result()
205         # XXX: check chain, data
206         return status
207
208     def ccid_send_data_block(self, data):
209         msg = ccid_compose(0x6f, self.__seq, data=data)
210         self.__dev.write(self.__bulkout, msg, self.__timeout)
211         self.increment_seq()
212         return self.ccid_get_result()
213
214     def ccid_send_cmd(self, data):
215         status, chain, data_rcv = self.ccid_send_data_block(data)
216         if chain == 0:
217             while status == 0x80:
218                 status, chain, data_rcv = self.ccid_get_result()
219             return data_rcv
220         elif chain == 1:
221             d = data_rcv
222             while True:
223                 msg = ccid_compose(0x6f, self.__seq, param=0x10)
224                 self.__dev.write(self.__bulkout, msg, self.__timeout)
225                 self.increment_seq()
226                 status, chain, data_rcv = self.ccid_get_result()
227                 # XXX: check status
228                 d += data_rcv
229                 if chain == 2:
230                     break
231                 elif chain == 3:
232                     continue
233                 else:
234                     raise ValueError("ccid_send_cmd chain")
235             return d
236         else:
237             raise ValueError("ccid_send_cmd")
238
239     def send_tpdu(self, info=None, more=0, response_time_ext=0,
240                   edc_error=0, no_error=0):
241         if info:
242             data = compose_i_block(self.ns, info, more)
243         elif response_time_ext:
244             # compose S-block response
245             pcb = 0xe3
246             bwi_byte = pack('>B', response_time_ext)
247             edc = compute_edc(pcb, bwi_byte)
248             data = bytes([0, pcb, 1]) + bwi_byte + bytes([edc])
249         elif edc_error:
250             data = compose_r_block(self.nr, edc_error=1)
251         elif no_error:
252             data = compose_r_block(self.nr)
253         msg = ccid_compose(0x6f, self.__seq, data=data)
254         self.__dev.write(self.__bulkout, msg, self.__timeout)
255         self.increment_seq()
256
257     def recv_tpdu(self):
258         status, chain, data = self.ccid_get_result()
259         return data
260
261     def send_cmd(self, cmd):
262         # Simple APDU case
263         if self.__use_APDU:
264             return self.ccid_send_cmd(cmd)
265         # TPDU case
266         while len(cmd) > 254:
267             blk = cmd[0:254]
268             cmd = cmd[254:]
269             while True:
270                 self.send_tpdu(info=blk,more=1)
271                 rblk = self.recv_tpdu()
272                 if is_r_block_no_error_or_other(rblk):
273                     break
274             self.ns = self.ns ^ 1
275         while True:
276             self.send_tpdu(info=cmd)
277             blk = self.recv_tpdu()
278             if is_r_block_no_error_or_other(blk):
279                 break
280         self.ns = self.ns ^ 1
281         res = b""
282         while True:
283             if is_s_block_time_ext(blk):
284                 self.send_tpdu(response_time_ext=blk[3])
285             elif is_i_block_last(blk):
286                 self.nr = self.nr ^ 1
287                 if is_edc_error(blk):
288                     self.send_tpdu(edc_error=1)
289                 else:
290                     res += i_block_content(blk)
291                     break
292             elif is_i_block_more(blk):
293                 self.nr = self.nr ^ 1
294                 if is_edc_error(blk):
295                     self.send_tpdu(edc_error=1)
296                 else:
297                     res += i_block_content(blk)
298                     self.send_tpdu(no_error=1)
299             blk = self.recv_tpdu()
300         return res
301
302
303 class find_class(object):
304     def __init__(self, usb_class):
305         self.__class = usb_class
306     def __call__(self, device):
307         if device.bDeviceClass == self.__class:
308             return True
309         for cfg in device:
310             intf = find_descriptor(cfg, bInterfaceClass=self.__class)
311             if intf is not None:
312                 return True
313         return False
314
315 def get_ccid_device():
316     ccid = None
317     dev_list = usb.core.find(find_all=True, custom_match=find_class(CCID_CLASS))
318     for dev in dev_list:
319         try:
320             ccid = CardReader(dev)
321             print("CCID device: Bus %03d Device %03d" % (dev.bus, dev.address))
322             break
323         except:
324             pass
325     if not ccid:
326         raise ValueError("No CCID device present")
327     status = ccid.ccid_get_status()
328     if status == 0:
329         # It's ON already
330         atr = ccid.ccid_power_on()
331     elif status == 1:
332         atr = ccid.ccid_power_on()
333     else:
334         raise ValueError("Unknown CCID status", status)
335     return ccid