]> git.zerfleddert.de Git - proxmark3-svn/blob - client/pcsc.c
projects / proxmark3-svn / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix WaitForResponse (without timeout)
[proxmark3-svn] / client / pcsc.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2019 piwi
3 //
4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
5 // at your option, any later version. See the LICENSE.txt file for the text of
6 // the license.
7 //-----------------------------------------------------------------------------
8 // PCSC functions to use alternative Smartcard Readers
9 //-----------------------------------------------------------------------------
10
11 #include "pcsc.h"
12
13 #include <stdlib.h>
14 #include <stdbool.h>
15 #include <stdio.h>
16 #include <string.h>
17
18 #if defined (__APPLE__)
19 #include <PCSC/winscard.h>
20 #include <PCSC/wintypes.h>
21 #define SCARD_ATTR_VALUE(Class, Tag) ((((ULONG)(Class)) << 16) | ((ULONG)(Tag)))
22 #define SCARD_CLASS_ICC_STATE 9
23 #define SCARD_ATTR_ATR_STRING SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0303)
24 #elif defined (_WIN32)
25 #include <winscard.h>
26 #else
27 #include <winscard.h>
28 #include <reader.h>
29 #endif
30
31 #include "ui.h"
32 #include "util.h"
33 #include "cmdhw.h"
34
35 #define PM3_SMARTCARD_DEFAULT_NAME "PM3 RDV40 Smartcard Slot"
36
37 static SCARDCONTEXT SC_Context;
38 static SCARDHANDLE SC_Card;
39 static DWORD SC_Protocol;
40 static char* AlternativeSmartcardReader = NULL;
41
42 #define PCSC_MAX_TRACELEN 60000
43 static uint8_t pcsc_trace_buf[PCSC_MAX_TRACELEN];
44 static bool tracing = false;
45 static uint32_t traceLen = 0;
46
47
48 uint8_t *pcsc_get_trace_addr(void)
49 {
50 return pcsc_trace_buf;
51 }
52
53
54 uint32_t pcsc_get_traceLen(void)
55 {
56 return traceLen;
57 }
58
59
60 static void pcsc_clear_trace(void)
61 {
62 traceLen = 0;
63 }
64
65
66 static void pcsc_set_tracing(bool enable) {
67 tracing = enable;
68 }
69
70
71 static bool pcsc_LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, bool readerToTag)
72 {
73 if (!tracing) return false;
74
75 uint8_t *trace = pcsc_trace_buf;
76
77 uint32_t num_paritybytes = (iLen-1)/8 + 1; // number of paritybytes
78 uint32_t duration = timestamp_end - timestamp_start;
79
80 // Return when trace is full
81 if (traceLen + sizeof(iLen) + sizeof(timestamp_start) + sizeof(duration) + num_paritybytes + iLen >= PCSC_MAX_TRACELEN) {
82 tracing = false; // don't trace any more
83 return false;
84 }
85 // Traceformat:
86 // 32 bits timestamp (little endian)
87 // 16 bits duration (little endian)
88 // 16 bits data length (little endian, Highest Bit used as readerToTag flag)
89 // y Bytes data
90 // x Bytes parity (one byte per 8 bytes data)
91
92 // timestamp (start)
93 trace[traceLen++] = ((timestamp_start >> 0) & 0xff);
94 trace[traceLen++] = ((timestamp_start >> 8) & 0xff);
95 trace[traceLen++] = ((timestamp_start >> 16) & 0xff);
96 trace[traceLen++] = ((timestamp_start >> 24) & 0xff);
97
98 // duration
99 trace[traceLen++] = ((duration >> 0) & 0xff);
100 trace[traceLen++] = ((duration >> 8) & 0xff);
101
102 // data length
103 trace[traceLen++] = ((iLen >> 0) & 0xff);
104 trace[traceLen++] = ((iLen >> 8) & 0xff);
105
106 // readerToTag flag
107 if (!readerToTag) {
108 trace[traceLen - 1] |= 0x80;
109 }
110
111 // data bytes
112 if (btBytes != NULL && iLen != 0) {
113 for (int i = 0; i < iLen; i++) {
114 trace[traceLen++] = *btBytes++;
115 }
116 }
117
118 // dummy parity bytes
119 if (num_paritybytes != 0) {
120 for (int i = 0; i < num_paritybytes; i++) {
121 trace[traceLen++] = 0x00;
122 }
123 }
124
125 return true;
126 }
127
128
129 char *getAlternativeSmartcardReader(void)
130 {
131 return AlternativeSmartcardReader ? AlternativeSmartcardReader : PM3_SMARTCARD_DEFAULT_NAME;
132 }
133
134
135 bool pcscCheckForCardReaders(void)
136 {
137 LONG res = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &SC_Context);
138 if (res != SCARD_S_SUCCESS) {
139 return false;
140 }
141
142 DWORD pcchReaders;
143 res = SCardListReaders(SC_Context, NULL, NULL, &pcchReaders);
144 if (res != SCARD_S_SUCCESS) {
145 SCardReleaseContext(SC_Context);
146 return false;
147 }
148
149 if (res == SCARD_E_NO_READERS_AVAILABLE || res == SCARD_E_NO_SERVICE) {
150 SCardReleaseContext(SC_Context);
151 return false;
152 }
153
154 return true;
155 }
156
157
158 static char *pickReader(LPTSTR readerlist)
159 {
160 PrintAndLogEx(NORMAL, "Please select one of these:");
161 PrintAndLogEx(NORMAL, " [0] %s %s", PM3_SMARTCARD_DEFAULT_NAME, PM3hasSmartcardSlot() ? "(default)" : "(default, not available)");
162
163 int num = 1;
164 for (LPTSTR p = readerlist; *p != '\0'; ) {
165 PrintAndLogEx(NORMAL, " [%1d] %s", num++, p);
166 while (*p++ != '\0') ; // advance to next entry
167 }
168
169 num--;
170
171 if (num == 1) {
172 printf("Your choice (0 or 1)?");
173 } else {
174 printf("Your choice (0...%d)? ", num);
175 }
176 int selection = getch() - '0';
177 printf("\n");
178
179 if (selection == 0) {
180 PrintAndLogEx(INFO, "Selected %s", PM3_SMARTCARD_DEFAULT_NAME);
181 return NULL;
182 }
183
184 if (selection >= 1 && selection <= num) {
185 LPTSTR p = readerlist;
186 for (int i = 1; i < selection; i++) {
187 while (*p++ != '\0') ; // advance to next entry
188 }
189 PrintAndLogEx(INFO, "Selected %s", p);
190 return p;
191 }
192
193 PrintAndLogEx(INFO, "Invalid selection. Using %s", PM3_SMARTCARD_DEFAULT_NAME);
194 return NULL;
195
196 }
197
198
199 static bool matchString(char *string, const char *search)
200 {
201 if (search[0] == '*' && search[1] == '\0') { // the wildcard only string "*" matches everything
202 return true;
203 }
204
205 if (search[0] == '\0' && string[0] != '\0') { // string is longer than pattern. No match.
206 return false;
207 }
208
209 if (search[0] == '?' || search[0] == string[0]) { // wildcard '?' matches any character
210 return matchString(string + 1, search + 1);
211 }
212
213 if (search[0] == '*') { // wildcard '*' matches any sequence of characters
214 for (size_t i = 0; i < strlen(string); i++) {
215 if (matchString(string + i, search + 1)) {
216 return true;
217 }
218 }
219 }
220
221 return false;
222 }
223
224
225 static char *matchReader(LPTSTR readerlist, const char *readername)
226 {
227 if (matchString(PM3_SMARTCARD_DEFAULT_NAME, readername)) {
228 PrintAndLogEx(INFO, "Selected %s", PM3_SMARTCARD_DEFAULT_NAME);
229 return NULL;
230 }
231
232 for (LPTSTR p = readerlist; *p != '\0'; ) {
233 if (matchString(p, readername)) {
234 PrintAndLogEx(INFO, "Selected %s", p);
235 return p;
236 }
237 while (*p++ != '\0') ; // advance to next entry
238 }
239
240 PrintAndLogEx(INFO, "No match. Using %s", PM3_SMARTCARD_DEFAULT_NAME);
241 return NULL;
242 }
243
244
245 bool pcscSelectAlternativeCardReader(const char *readername)
246 {
247 DWORD readerlist_len;
248 LONG res = SCardListReaders(SC_Context, NULL, NULL, &readerlist_len);
249 if (res != SCARD_S_SUCCESS) {
250 return false;
251 }
252
253 LPTSTR readerlist = calloc(readerlist_len, sizeof(char));
254 res = SCardListReaders(SC_Context, NULL, readerlist, &readerlist_len);
255 if (res != SCARD_S_SUCCESS) {
256 free(readerlist);
257 return false;
258 }
259
260 char *selected_readername = NULL;
261 if (readername) {
262 selected_readername = matchReader(readerlist, readername);
263 } else {
264 selected_readername = pickReader(readerlist);
265 }
266
267 if (selected_readername == NULL) {
268 free(readerlist);
269 return false;
270 }
271
272 free(AlternativeSmartcardReader);
273 AlternativeSmartcardReader = malloc((strlen(selected_readername) + 1) * sizeof(char));
274 strcpy(AlternativeSmartcardReader, selected_readername);
275
276 free(readerlist);
277 return true;
278 }
279
280
281 bool pcscGetATR(smart_card_atr_t *card)
282 {
283 pcsc_clear_trace();
284 pcsc_set_tracing(true);
285
286 if (!card) {
287 return false;
288 }
289
290 card->atr_len = 0;
291 memset(card->atr, 0, sizeof(card->atr));
292
293 LONG res = SCardConnect(SC_Context, AlternativeSmartcardReader, SCARD_SHARE_SHARED,
294 SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &SC_Card, &SC_Protocol);
295 if (res != SCARD_S_SUCCESS) {
296 return false;
297 }
298
299 DWORD atr_len = sizeof(card->atr);
300 res = SCardGetAttrib(SC_Card, SCARD_ATTR_ATR_STRING, card->atr, &atr_len);
301 if (res != SCARD_S_SUCCESS) {
302 return false;
303 }
304 card->atr_len = atr_len;
305
306 pcsc_LogTrace(card->atr, card->atr_len, 0, 0, false);
307
308 pcsc_set_tracing(false);
309
310 return true;
311 }
312
313
314 void pcscTransmit(uint8_t *data, uint32_t data_len, uint32_t flags, uint8_t *response, int *response_len)
315 {
316 LPCSCARD_IO_REQUEST protocol;
317 if (flags & SC_RAW_T0) {
318 protocol = SCARD_PCI_T0;
319 } else {
320 protocol = SCARD_PCI_RAW;
321 }
322
323 if ((flags & SC_CONNECT))
324 pcsc_clear_trace();
325
326 pcsc_set_tracing(true);
327
328 if ((flags & SC_CONNECT || flags & SC_SELECT)) {
329 LONG res = SCardConnect(SC_Context, AlternativeSmartcardReader, SCARD_SHARE_SHARED,
330 SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &SC_Card, &SC_Protocol);
331 if (res != SCARD_S_SUCCESS) {
332 *response_len = -1;
333 return;
334 }
335 }
336
337 if ((flags & SC_RAW) || (flags & SC_RAW_T0)) {
338 pcsc_LogTrace(data, data_len, 0, 0, true);
339 DWORD len = *response_len;
340 LONG res = SCardTransmit(SC_Card, protocol, data, data_len, NULL, response, &len);
341 if (res != SCARD_S_SUCCESS) {
342 *response_len = -1;
343 } else {
344 pcsc_LogTrace(response, len, 0, 0, false);
345 *response_len = len;
346 }
347 }
348 pcsc_set_tracing(false);
349 }
Proxmark3 GIT tracking
Impressum, Datenschutz