blob: f672be2d44fbd9c858a106b1febfaf99c2d87c44 [file] [log] [blame]
Sylvain Munaut76504e02010-12-07 00:24:32 +01001#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3
4""" pySim: Transport Link for serial (RS232) based readers included with simcard
5"""
6
7#
8# Copyright (C) 2009-2010 Sylvain Munaut <tnt@246tNt.com>
9#
10# This program is free software: you can redistribute it and/or modify
11# it under the terms of the GNU General Public License as published by
12# the Free Software Foundation, either version 2 of the License, or
13# (at your option) any later version.
14#
15# This program is distributed in the hope that it will be useful,
16# but WITHOUT ANY WARRANTY; without even the implied warranty of
17# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18# GNU General Public 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
24from __future__ import absolute_import
25
26import serial
27import time
28
29from pySim.exceptions import NoCardError, ProtocolError
Sylvain Munaute7c15cd2010-12-07 10:01:55 +010030from pySim.transport import LinkBase
Sylvain Munaut76504e02010-12-07 00:24:32 +010031from pySim.utils import h2b, b2h
32
33
Sylvain Munaute7c15cd2010-12-07 10:01:55 +010034class SerialSimLink(LinkBase):
Sylvain Munaut76504e02010-12-07 00:24:32 +010035
36 def __init__(self, device='/dev/ttyUSB0', baudrate=9600, rst='-rts', debug=False):
37 self._sl = serial.Serial(
38 port = device,
39 parity = serial.PARITY_EVEN,
40 bytesize = serial.EIGHTBITS,
41 stopbits = serial.STOPBITS_TWO,
42 timeout = 1,
43 xonxoff = 0,
44 rtscts = 0,
45 baudrate = baudrate,
46 )
47 self._rst_pin = rst
48 self._debug = debug
Alexander Chemerisd2d660a2017-07-18 16:52:25 +030049 self._atr = None
Sylvain Munaut76504e02010-12-07 00:24:32 +010050
Sylvain Munautbdca2522010-12-09 13:31:58 +010051 def __del__(self):
52 self._sl.close()
53
54 def wait_for_card(self, timeout=None, newcardonly=False):
55 # Direct try
56 existing = False
57
58 try:
59 self.reset_card()
60 if not newcardonly:
61 return
62 else:
63 existing = True
64 except NoCardError:
65 pass
66
67 # Poll ...
68 mt = time.time() + timeout if timeout is not None else None
69 pe = 0
70
71 while (mt is None) or (time.time() < mt):
72 try:
73 time.sleep(0.5)
74 self.reset_card()
75 if not existing:
76 return
77 except NoCardError:
78 existing = False
79 except ProtocolError:
80 if existing:
81 existing = False
82 else:
83 # Tolerate a couple of protocol error ... can happen if
84 # we try when the card is 'half' inserted
85 pe += 1
86 if (pe > 2):
87 raise
88
89 # Timed out ...
90 raise NoCardError()
91
92 def connect(self):
93 self.reset_card()
94
Alexander Chemerisd2d660a2017-07-18 16:52:25 +030095 def get_atr(self):
96 return self._atr
97
Sylvain Munautbdca2522010-12-09 13:31:58 +010098 def disconnect(self):
99 pass # Nothing to do really ...
100
101 def reset_card(self):
102 rv = self._reset_card()
Sylvain Munaut76504e02010-12-07 00:24:32 +0100103 if rv == 0:
104 raise NoCardError()
105 elif rv < 0:
106 raise ProtocolError()
107
Sylvain Munautbdca2522010-12-09 13:31:58 +0100108 def _reset_card(self):
Alexander Chemerisd2d660a2017-07-18 16:52:25 +0300109 self._atr = None
Sylvain Munaut76504e02010-12-07 00:24:32 +0100110 rst_meth_map = {
111 'rts': self._sl.setRTS,
112 'dtr': self._sl.setDTR,
113 }
114 rst_val_map = { '+':0, '-':1 }
115
116 try:
117 rst_meth = rst_meth_map[self._rst_pin[1:]]
118 rst_val = rst_val_map[self._rst_pin[0]]
119 except:
120 raise ValueError('Invalid reset pin %s' % self._rst_pin);
121
122 rst_meth(rst_val)
123 time.sleep(0.1) # 100 ms
124 self._sl.flushInput()
125 rst_meth(rst_val ^ 1)
126
127 b = self._rx_byte()
128 if not b:
129 return 0
130 if ord(b) != 0x3b:
131 return -1;
132 self._dbg_print("TS: 0x%x Direct convention" % ord(b))
133
134 while ord(b) == 0x3b:
135 b = self._rx_byte()
136
137 if not b:
138 return -1
139 t0 = ord(b)
140 self._dbg_print("T0: 0x%x" % t0)
Alexander Chemerisd2d660a2017-07-18 16:52:25 +0300141 self._atr = [0x3b, ord(b)]
Sylvain Munaut76504e02010-12-07 00:24:32 +0100142
143 for i in range(4):
144 if t0 & (0x10 << i):
Alexander Chemerisd2d660a2017-07-18 16:52:25 +0300145 b = self._rx_byte()
Martin Hauke6cbecaa2018-02-18 17:04:50 +0100146 self._atr.append(ord(b))
Alexander Chemerisd2d660a2017-07-18 16:52:25 +0300147 self._dbg_print("T%si = %x" % (chr(ord('A')+i), ord(b)))
Sylvain Munaut76504e02010-12-07 00:24:32 +0100148
149 for i in range(0, t0 & 0xf):
Alexander Chemerisd2d660a2017-07-18 16:52:25 +0300150 b = self._rx_byte()
Martin Hauke6cbecaa2018-02-18 17:04:50 +0100151 self._atr.append(ord(b))
Alexander Chemerisd2d660a2017-07-18 16:52:25 +0300152 self._dbg_print("Historical = %x" % ord(b))
Sylvain Munaut76504e02010-12-07 00:24:32 +0100153
154 while True:
155 x = self._rx_byte()
156 if not x:
157 break
Martin Hauke6cbecaa2018-02-18 17:04:50 +0100158 self._atr.append(ord(x))
Sylvain Munaut76504e02010-12-07 00:24:32 +0100159 self._dbg_print("Extra: %x" % ord(x))
160
161 return 1
162
163 def _dbg_print(self, s):
164 if self._debug:
Vadim Yanitskiy6727f0c2020-01-22 23:38:24 +0700165 print(s)
Sylvain Munaut76504e02010-12-07 00:24:32 +0100166
167 def _tx_byte(self, b):
168 self._sl.write(b)
169 r = self._sl.read()
170 if r != b: # TX and RX are tied, so we must clear the echo
171 raise ProtocolError("Bad echo value. Expected %02x, got %s)" % (ord(b), '%02x'%ord(r) if r else '(nil)'))
172
173 def _tx_string(self, s):
174 """This is only safe if it's guaranteed the card won't send any data
175 during the time of tx of the string !!!"""
176 self._sl.write(s)
177 r = self._sl.read(len(s))
178 if r != s: # TX and RX are tied, so we must clear the echo
179 raise ProtocolError("Bad echo value (Expected: %s, got %s)" % (b2h(s), b2h(r)))
180
181 def _rx_byte(self):
182 return self._sl.read()
183
184 def send_apdu_raw(self, pdu):
Sylvain Munaute7c15cd2010-12-07 10:01:55 +0100185 """see LinkBase.send_apdu_raw"""
Sylvain Munaut76504e02010-12-07 00:24:32 +0100186
187 pdu = h2b(pdu)
188 data_len = ord(pdu[4]) # P3
189
190 # Send first CLASS,INS,P1,P2,P3
191 self._tx_string(pdu[0:5])
192
193 # Wait ack which can be
194 # - INS: Command acked -> go ahead
195 # - 0x60: NULL, just wait some more
196 # - SW1: The card can apparently proceed ...
197 while True:
198 b = self._rx_byte()
199 if b == pdu[1]:
200 break
201 elif b != '\x60':
202 # Ok, it 'could' be SW1
203 sw1 = b
204 sw2 = self._rx_byte()
205 nil = self._rx_byte()
206 if (sw2 and not nil):
207 return '', b2h(sw1+sw2)
208
209 raise ProtocolError()
210
211 # Send data (if any)
212 if len(pdu) > 5:
213 self._tx_string(pdu[5:])
214
215 # Receive data (including SW !)
216 # length = [P3 - tx_data (=len(pdu)-len(hdr)) + 2 (SW1/2) ]
217 to_recv = data_len - len(pdu) + 5 + 2
218
219 data = ''
220 while (len(data) < to_recv):
221 b = self._rx_byte()
222 if (to_recv == 2) and (b == '\x60'): # Ignore NIL if we have no RX data (hack ?)
223 continue
224 if not b:
225 break;
226 data += b
227
228 # Split datafield from SW
229 if len(data) < 2:
230 return None, None
231 sw = data[-2:]
232 data = data[0:-2]
233
234 # Return value
235 return b2h(data), b2h(sw)