Branch data Line data Source code
1 : : /*
2 : : * Implement the 7816 portion of the card spec
3 : : *
4 : : * This code is licensed under the GNU LGPL, version 2.1 or later.
5 : : * See the COPYING file in the top-level directory.
6 : : */
7 : :
8 : : #include <glib.h>
9 : :
10 : : #include <string.h>
11 : :
12 : : #include "vcard.h"
13 : : #include "vcard_emul.h"
14 : : #include "card_7816.h"
15 : : #include "common.h"
16 : :
17 : :
18 : : /* Global Platform Card Manager applet AID */
19 : : static const unsigned char gp_aid[] = {
20 : : 0xa0, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00 };
21 : : /* Global Platform Card Manager response on select applet */
22 : : static const unsigned char gp_response[] = {
23 : : 0x6F, 0x19, 0x84, 0x08, 0xA0, 0x00, 0x00, 0x00,
24 : : 0x03, 0x00, 0x00, 0x00, 0xA5, 0x0D, 0x9F, 0x6E,
25 : : 0x06, 0x12, 0x91, 0x51, 0x81, 0x01, 0x00, 0x9F,
26 : : 0x65, 0x01, 0xFF};
27 : :
28 : :
29 : : /*
30 : : * set the status bytes based on the status word
31 : : */
32 : : static void
33 : : vcard_response_set_status(VCardResponse *response, vcard_7816_status_t status)
34 : : {
35 : : unsigned char sw1, sw2;
36 : 119 : response->b_status = status; /* make sure the status and swX representations
37 : : * are consistent */
38 : 119 : sw1 = (status >> 8) & 0xff;
39 : 119 : sw2 = status & 0xff;
40 : 119 : response->b_sw1 = sw1;
41 : 119 : response->b_sw2 = sw2;
42 : 119 : response->b_data[response->b_len] = sw1;
43 : 119 : response->b_data[response->b_len+1] = sw2;
44 : : }
45 : :
46 : : /*
47 : : * set the status bytes in a response buffer
48 : : */
49 : : void
50 : 355 : vcard_response_set_status_bytes(VCardResponse *response,
51 : : unsigned char sw1, unsigned char sw2)
52 : : {
53 : 355 : response->b_status = sw1 << 8 | sw2;
54 : 355 : response->b_sw1 = sw1;
55 : 355 : response->b_sw2 = sw2;
56 : 355 : response->b_data[response->b_len] = sw1;
57 : 355 : response->b_data[response->b_len+1] = sw2;
58 : 355 : }
59 : :
60 : : /*
61 : : * allocate a VCardResponse structure, plus space for the data buffer, and
62 : : * set up everything but the resonse bytes.
63 : : */
64 : : VCardResponse *
65 : 183 : vcard_response_new_data(const unsigned char *buf, int len)
66 : : {
67 : : VCardResponse *new_response;
68 : :
69 : 183 : new_response = g_new(VCardResponse, 1);
70 : 183 : new_response->b_data = g_malloc(len + 2);
71 : 183 : memcpy(new_response->b_data, buf, len);
72 : 183 : new_response->b_total_len = len+2;
73 : 183 : new_response->b_len = len;
74 : 183 : new_response->b_type = VCARD_MALLOC;
75 : 183 : return new_response;
76 : : }
77 : :
78 : : static VCardResponse *
79 : 186 : vcard_init_buffer_response(VCard *card, const unsigned char *buf, int len)
80 : : {
81 : : VCardResponse *response;
82 : : VCardBufferResponse *buffer_response;
83 : :
84 : 186 : buffer_response = vcard_get_buffer_response(card);
85 [ - + ]: 186 : if (buffer_response) {
86 : 0 : vcard_set_buffer_response(card, NULL);
87 : 0 : vcard_buffer_response_delete(buffer_response);
88 : : }
89 : 186 : buffer_response = vcard_buffer_response_new(buf, len);
90 [ - + ]: 186 : if (buffer_response == NULL) {
91 : : return NULL;
92 : : }
93 [ + + ]: 367 : response = vcard_response_new_status_bytes(VCARD7816_SW1_RESPONSE_BYTES,
94 : : len > 255 ? 0 : len);
95 [ - + ]: 186 : if (response == NULL) {
96 : : return NULL;
97 : : }
98 : 186 : vcard_set_buffer_response(card, buffer_response);
99 : 186 : return response;
100 : : }
101 : :
102 : : /*
103 : : * general buffer to hold results from APDU calls
104 : : */
105 : : VCardResponse *
106 : 296 : vcard_response_new(VCard *card, const unsigned char *buf,
107 : : int len, int Le, vcard_7816_status_t status)
108 : : {
109 : : VCardResponse *new_response;
110 : :
111 : 296 : g_debug("%s: Sending response (len = %d, Le = %d)", __func__, len, Le);
112 [ + + ]: 296 : if (len > Le) {
113 : 177 : return vcard_init_buffer_response(card, buf, len);
114 : : }
115 : 119 : new_response = vcard_response_new_data(buf, len);
116 [ + - ]: 119 : if (new_response == NULL) {
117 : : return NULL;
118 : : }
119 : : vcard_response_set_status(new_response, status);
120 : 119 : return new_response;
121 : : }
122 : :
123 : : /*
124 : : * general buffer to hold results from APDU calls
125 : : */
126 : : VCardResponse *
127 : 73 : vcard_response_new_bytes(VCard *card, unsigned char *buf, int len, int Le,
128 : : unsigned char sw1, unsigned char sw2)
129 : : {
130 : : VCardResponse *new_response;
131 : :
132 : 73 : g_debug("%s: Sending response (len = %d, Le = %d)", __func__, len, Le);
133 [ + + ]: 73 : if (len > Le) {
134 : 9 : return vcard_init_buffer_response(card, buf, len);
135 : : }
136 : 64 : new_response = vcard_response_new_data(buf, len);
137 [ + - ]: 64 : if (new_response == NULL) {
138 : : return NULL;
139 : : }
140 : 64 : vcard_response_set_status_bytes(new_response, sw1, sw2);
141 : 64 : return new_response;
142 : : }
143 : :
144 : : /*
145 : : * get a new Response buffer that only has a status.
146 : : */
147 : : static VCardResponse *
148 : 0 : vcard_response_new_status(vcard_7816_status_t status)
149 : : {
150 : : VCardResponse *new_response;
151 : :
152 : 0 : new_response = g_new(VCardResponse, 1);
153 : 0 : new_response->b_data = &new_response->b_sw1;
154 : 0 : new_response->b_len = 0;
155 : 0 : new_response->b_total_len = 2;
156 : 0 : new_response->b_type = VCARD_MALLOC_STRUCT;
157 : : vcard_response_set_status(new_response, status);
158 : 0 : return new_response;
159 : : }
160 : :
161 : : /*
162 : : * same as above, but specify the status as separate bytes
163 : : */
164 : : VCardResponse *
165 : 291 : vcard_response_new_status_bytes(unsigned char sw1, unsigned char sw2)
166 : : {
167 : : VCardResponse *new_response;
168 : :
169 : 291 : new_response = g_new(VCardResponse, 1);
170 : 291 : new_response->b_data = &new_response->b_sw1;
171 : 291 : new_response->b_len = 0;
172 : 291 : new_response->b_total_len = 2;
173 : 291 : new_response->b_type = VCARD_MALLOC_STRUCT;
174 : 291 : vcard_response_set_status_bytes(new_response, sw1, sw2);
175 : 291 : return new_response;
176 : : }
177 : :
178 : :
179 : : /*
180 : : * free the response buffer. The Buffer has a type to handle the buffer
181 : : * allocated in other ways than through malloc.
182 : : */
183 : : void
184 : 583 : vcard_response_delete(VCardResponse *response)
185 : : {
186 [ + - ]: 583 : if (response == NULL) {
187 : : return;
188 : : }
189 [ + - + - : 583 : switch (response->b_type) {
+ ]
190 : 183 : case VCARD_MALLOC:
191 : : /* everything was malloc'ed */
192 : 183 : g_free(response->b_data);
193 : 183 : g_free(response);
194 : 183 : break;
195 : 0 : case VCARD_MALLOC_DATA:
196 : : /* only the data buffer was malloc'ed */
197 : 0 : g_free(response->b_data);
198 : 0 : break;
199 : 291 : case VCARD_MALLOC_STRUCT:
200 : : /* only the structure was malloc'ed */
201 : 291 : g_free(response);
202 : 291 : break;
203 : : case VCARD_STATIC:
204 : : break;
205 : 0 : default:
206 : 0 : g_warn_if_reached();
207 : : }
208 : : }
209 : :
210 : : /*
211 : : * decode the class bit and set our generic type field, channel, and
212 : : * secure messaging values.
213 : : */
214 : : static vcard_7816_status_t
215 : 583 : vcard_apdu_set_class(VCardAPDU *apdu) {
216 : 583 : apdu->a_channel = 0;
217 : 583 : apdu->a_secure_messaging = 0;
218 : 583 : apdu->a_type = apdu->a_cla & 0xf0;
219 : 583 : apdu->a_gen_type = VCARD_7816_ISO;
220 : :
221 : : /* parse the class tables 8 & 9 of the 7816-4 Part 4 spec */
222 [ + + - + ]: 583 : switch (apdu->a_type) {
223 : : /* we only support the basic types */
224 : 558 : case 0x00:
225 : : case 0x80:
226 : : case 0x90:
227 : : case 0xa0:
228 : 558 : apdu->a_channel = apdu->a_cla & 3;
229 : 558 : apdu->a_secure_messaging = apdu->a_cla & 0xe;
230 : 558 : break;
231 : : case 0xb0:
232 : : case 0xc0:
233 : : break;
234 : :
235 : 23 : case 0x10:
236 : : case 0x20:
237 : : case 0x30:
238 : : case 0x40:
239 : : case 0x50:
240 : : case 0x60:
241 : : case 0x70:
242 : : /* Reserved for future use */
243 : 23 : apdu->a_gen_type = VCARD_7816_RFU;
244 : 23 : break;
245 : 0 : case 0xd0:
246 : : case 0xe0:
247 : : case 0xf0:
248 : : default:
249 : 0 : apdu->a_gen_type =
250 [ # # ]: 0 : (apdu->a_cla == 0xff) ? VCARD_7816_PTS : VCARD_7816_PROPRIETARY;
251 : 0 : break;
252 : : }
253 : 583 : return VCARD7816_STATUS_SUCCESS;
254 : : }
255 : :
256 : : /*
257 : : * set the Le and Lc fields according to table 5 of the
258 : : * 7816-4 part 4 spec
259 : : */
260 : : static vcard_7816_status_t
261 : 583 : vcard_apdu_set_length(VCardAPDU *apdu)
262 : : {
263 : : int L, Le;
264 : :
265 : : /* process according to table 5 of the 7816-4 Part 4 spec.
266 : : * variable names match the variables in the spec */
267 : 583 : L = apdu->a_len-4; /* fixed APDU header */
268 : 583 : apdu->a_Lc = 0;
269 : 583 : apdu->a_Le = 0;
270 : 583 : apdu->a_body = NULL;
271 [ + + + ]: 583 : switch (L) {
272 : : case 0:
273 : : /* 1 minimal apdu */
274 : : return VCARD7816_STATUS_SUCCESS;
275 : 226 : case 1:
276 : : /* 2S only return values apdu */
277 : : /* zero maps to 256 here */
278 : 452 : apdu->a_Le = apdu->a_header->ah_Le ?
279 [ + + ]: 226 : apdu->a_header->ah_Le : 256;
280 : 226 : return VCARD7816_STATUS_SUCCESS;
281 : 271 : default:
282 : : /* if the ah_Le byte is zero and we have more than
283 : : * 1 byte in the header, then we must be using extended Le and Lc.
284 : : * process the extended now. */
285 [ + + ]: 271 : if (apdu->a_header->ah_Le == 0) {
286 [ + - ]: 2 : if (L < 3) {
287 : : /* coding error, need at least 3 bytes */
288 : : return VCARD7816_STATUS_ERROR_WRONG_LENGTH;
289 : : }
290 : : /* calculate the first extended value. Could be either Le or Lc */
291 : 2 : Le = (apdu->a_header->ah_body[0] << 8)
292 : 2 : | apdu->a_header->ah_body[1];
293 [ - + ]: 2 : if (L == 3) {
294 : : /* 2E extended, return data only */
295 : : /* zero maps to 65536 */
296 [ # # ]: 0 : apdu->a_Le = Le ? Le : 65536;
297 : 0 : return VCARD7816_STATUS_SUCCESS;
298 : : }
299 [ + - ]: 2 : if (Le == 0) {
300 : : /* reserved for future use, probably for next time we need
301 : : * to extend the lengths */
302 : : return VCARD7816_STATUS_ERROR_WRONG_LENGTH;
303 : : }
304 : : /* we know that the first extended value is Lc now */
305 : 2 : apdu->a_Lc = Le;
306 : 2 : apdu->a_body = &apdu->a_header->ah_body[2];
307 [ + - ]: 2 : if (L == Le+3) {
308 : : /* 3E extended, only body parameters */
309 : : return VCARD7816_STATUS_SUCCESS;
310 : : }
311 [ # # ]: 0 : if (L == Le+5) {
312 : : /* 4E extended, parameters and return data */
313 : 0 : Le = (apdu->a_data[apdu->a_len-2] << 8)
314 : 0 : | apdu->a_data[apdu->a_len-1];
315 [ # # ]: 0 : apdu->a_Le = Le ? Le : 65536;
316 : 0 : return VCARD7816_STATUS_SUCCESS;
317 : : }
318 : : return VCARD7816_STATUS_ERROR_WRONG_LENGTH;
319 : : }
320 : : /* not extended */
321 : 269 : apdu->a_Lc = apdu->a_header->ah_Le;
322 : 269 : apdu->a_body = &apdu->a_header->ah_body[0];
323 [ + + ]: 269 : if (L == apdu->a_Lc + 1) {
324 : : /* 3S only body parameters */
325 : : return VCARD7816_STATUS_SUCCESS;
326 : : }
327 [ + - ]: 114 : if (L == apdu->a_Lc + 2) {
328 : : /* 4S parameters and return data */
329 : 114 : Le = apdu->a_data[apdu->a_len-1];
330 [ + + ]: 114 : apdu->a_Le = Le ? Le : 256;
331 : 114 : return VCARD7816_STATUS_SUCCESS;
332 : : }
333 : : break;
334 : : }
335 : : return VCARD7816_STATUS_ERROR_WRONG_LENGTH;
336 : : }
337 : :
338 : : /*
339 : : * create a new APDU from a raw set of bytes. This will decode all the
340 : : * above fields. users of VCARDAPDU's can then depend on the already decoded
341 : : * values.
342 : : */
343 : : VCardAPDU *
344 : 583 : vcard_apdu_new(unsigned char *raw_apdu, int len, vcard_7816_status_t *status)
345 : : {
346 : : VCardAPDU *new_apdu;
347 : :
348 : 583 : *status = VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE;
349 [ - + ]: 583 : if (len < 4) {
350 : 0 : *status = VCARD7816_STATUS_ERROR_WRONG_LENGTH;
351 : 0 : return NULL;
352 : : }
353 : :
354 : 583 : new_apdu = g_new(VCardAPDU, 1);
355 : 583 : new_apdu->a_data = g_memdup2(raw_apdu, len);
356 : 583 : new_apdu->a_len = len;
357 : 583 : *status = vcard_apdu_set_class(new_apdu);
358 [ - + ]: 583 : if (*status != VCARD7816_STATUS_SUCCESS) {
359 : 0 : vcard_apdu_delete(new_apdu);
360 : 0 : return NULL;
361 : : }
362 : 583 : *status = vcard_apdu_set_length(new_apdu);
363 [ - + ]: 583 : if (*status != VCARD7816_STATUS_SUCCESS) {
364 : 0 : vcard_apdu_delete(new_apdu);
365 : : new_apdu = NULL;
366 : : }
367 : : return new_apdu;
368 : : }
369 : :
370 : : void
371 : 583 : vcard_apdu_delete(VCardAPDU *apdu)
372 : : {
373 [ + - ]: 583 : if (apdu == NULL) {
374 : : return;
375 : : }
376 : 583 : g_free(apdu->a_data);
377 : 583 : g_free(apdu);
378 : : }
379 : :
380 : :
381 : : /*
382 : : * declare response buffers for all the 7816 defined error codes
383 : : */
384 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_SUCCESS)
385 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING)
386 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_RET_CORUPT)
387 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_BUF_END_BEFORE_LE)
388 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_INVALID_FILE_SELECTED)
389 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_FCI_FORMAT_INVALID)
390 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_CHANGE)
391 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_FILE_FILLED)
392 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_EXC_ERROR)
393 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_EXC_ERROR_CHANGE)
394 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE)
395 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_WRONG_LENGTH)
396 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_CLA_NOT_SUPPORTED)
397 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_CHANNEL_NOT_SUPPORTED)
398 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED)
399 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED)
400 : : VCARD_RESPONSE_NEW_STATIC_STATUS(
401 : : VCARD7816_STATUS_ERROR_COMMAND_INCOMPATIBLE_WITH_FILE)
402 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_SECURITY_NOT_SATISFIED)
403 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_AUTHENTICATION_BLOCKED)
404 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_DATA_INVALID)
405 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED)
406 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_DATA_NO_EF)
407 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_SM_OBJECT_MISSING)
408 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_SM_OBJECT_INCORRECT)
409 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_WRONG_PARAMETERS)
410 : : VCARD_RESPONSE_NEW_STATIC_STATUS(
411 : : VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_IN_DATA)
412 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED)
413 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_FILE_NOT_FOUND)
414 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_RECORD_NOT_FOUND)
415 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_NO_SPACE_FOR_FILE)
416 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_LC_TLV_INCONSISTENT)
417 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_P1_P2_INCORRECT)
418 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_LC_P1_P2_INCONSISTENT)
419 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_DATA_NOT_FOUND)
420 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_2)
421 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_INS_CODE_INVALID)
422 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_CLA_INVALID)
423 : : VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_GENERAL)
424 : :
425 : : /*
426 : : * return a single response code. This function cannot fail. It will always
427 : : * return a response.
428 : : */
429 : : VCardResponse *
430 : 109 : vcard_make_response(vcard_7816_status_t status)
431 : : {
432 : : VCardResponse *response;
433 : :
434 [ - - - - : 109 : switch (status) {
- - - - -
- - - - -
- - - - +
+ - - - +
+ - + - -
- + - + -
+ - - -
+ ]
435 : : /* known 7816 response codes */
436 : : case VCARD7816_STATUS_SUCCESS:
437 : : return VCARD_RESPONSE_GET_STATIC(
438 : : VCARD7816_STATUS_SUCCESS);
439 : 0 : case VCARD7816_STATUS_WARNING:
440 : 0 : return VCARD_RESPONSE_GET_STATIC(
441 : : VCARD7816_STATUS_WARNING);
442 : 0 : case VCARD7816_STATUS_WARNING_RET_CORUPT:
443 : 0 : return VCARD_RESPONSE_GET_STATIC(
444 : : VCARD7816_STATUS_WARNING_RET_CORUPT);
445 : 0 : case VCARD7816_STATUS_WARNING_BUF_END_BEFORE_LE:
446 : 0 : return VCARD_RESPONSE_GET_STATIC(
447 : : VCARD7816_STATUS_WARNING_BUF_END_BEFORE_LE);
448 : 0 : case VCARD7816_STATUS_WARNING_INVALID_FILE_SELECTED:
449 : 0 : return VCARD_RESPONSE_GET_STATIC(
450 : : VCARD7816_STATUS_WARNING_INVALID_FILE_SELECTED);
451 : 0 : case VCARD7816_STATUS_WARNING_FCI_FORMAT_INVALID:
452 : 0 : return VCARD_RESPONSE_GET_STATIC(
453 : : VCARD7816_STATUS_WARNING_FCI_FORMAT_INVALID);
454 : 0 : case VCARD7816_STATUS_WARNING_CHANGE:
455 : 0 : return VCARD_RESPONSE_GET_STATIC(
456 : : VCARD7816_STATUS_WARNING_CHANGE);
457 : 0 : case VCARD7816_STATUS_WARNING_FILE_FILLED:
458 : 0 : return VCARD_RESPONSE_GET_STATIC(
459 : : VCARD7816_STATUS_WARNING_FILE_FILLED);
460 : 0 : case VCARD7816_STATUS_EXC_ERROR:
461 : 0 : return VCARD_RESPONSE_GET_STATIC(
462 : : VCARD7816_STATUS_EXC_ERROR);
463 : 0 : case VCARD7816_STATUS_EXC_ERROR_CHANGE:
464 : 0 : return VCARD_RESPONSE_GET_STATIC(
465 : : VCARD7816_STATUS_EXC_ERROR_CHANGE);
466 : : case VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE:
467 : : return VCARD_RESPONSE_GET_STATIC(
468 : : VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
469 : 0 : case VCARD7816_STATUS_ERROR_WRONG_LENGTH:
470 : 0 : return VCARD_RESPONSE_GET_STATIC(
471 : : VCARD7816_STATUS_ERROR_WRONG_LENGTH);
472 : 0 : case VCARD7816_STATUS_ERROR_CLA_NOT_SUPPORTED:
473 : 0 : return VCARD_RESPONSE_GET_STATIC(
474 : : VCARD7816_STATUS_ERROR_CLA_NOT_SUPPORTED);
475 : 0 : case VCARD7816_STATUS_ERROR_CHANNEL_NOT_SUPPORTED:
476 : 0 : return VCARD_RESPONSE_GET_STATIC(
477 : : VCARD7816_STATUS_ERROR_CHANNEL_NOT_SUPPORTED);
478 : 0 : case VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED:
479 : 0 : return VCARD_RESPONSE_GET_STATIC(
480 : : VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED);
481 : 0 : case VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED:
482 : 0 : return VCARD_RESPONSE_GET_STATIC(
483 : : VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
484 : 0 : case VCARD7816_STATUS_ERROR_COMMAND_INCOMPATIBLE_WITH_FILE:
485 : 0 : return VCARD_RESPONSE_GET_STATIC(
486 : : VCARD7816_STATUS_ERROR_COMMAND_INCOMPATIBLE_WITH_FILE);
487 : 0 : case VCARD7816_STATUS_ERROR_SECURITY_NOT_SATISFIED:
488 : 0 : return VCARD_RESPONSE_GET_STATIC(
489 : : VCARD7816_STATUS_ERROR_SECURITY_NOT_SATISFIED);
490 : 0 : case VCARD7816_STATUS_ERROR_AUTHENTICATION_BLOCKED:
491 : 0 : return VCARD_RESPONSE_GET_STATIC(
492 : : VCARD7816_STATUS_ERROR_AUTHENTICATION_BLOCKED);
493 : 24 : case VCARD7816_STATUS_ERROR_DATA_INVALID:
494 : 24 : return VCARD_RESPONSE_GET_STATIC(
495 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
496 : 1 : case VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED:
497 : 1 : return VCARD_RESPONSE_GET_STATIC(
498 : : VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
499 : 0 : case VCARD7816_STATUS_ERROR_DATA_NO_EF:
500 : 0 : return VCARD_RESPONSE_GET_STATIC(
501 : : VCARD7816_STATUS_ERROR_DATA_NO_EF);
502 : 0 : case VCARD7816_STATUS_ERROR_SM_OBJECT_MISSING:
503 : 0 : return VCARD_RESPONSE_GET_STATIC(
504 : : VCARD7816_STATUS_ERROR_SM_OBJECT_MISSING);
505 : 0 : case VCARD7816_STATUS_ERROR_SM_OBJECT_INCORRECT:
506 : 0 : return VCARD_RESPONSE_GET_STATIC(
507 : : VCARD7816_STATUS_ERROR_SM_OBJECT_INCORRECT);
508 : 5 : case VCARD7816_STATUS_ERROR_WRONG_PARAMETERS:
509 : 5 : return VCARD_RESPONSE_GET_STATIC(
510 : : VCARD7816_STATUS_ERROR_WRONG_PARAMETERS);
511 : 1 : case VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_IN_DATA:
512 : 1 : return VCARD_RESPONSE_GET_STATIC(
513 : : VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_IN_DATA);
514 : 0 : case VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED:
515 : 0 : return VCARD_RESPONSE_GET_STATIC(
516 : : VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED);
517 : 3 : case VCARD7816_STATUS_ERROR_FILE_NOT_FOUND:
518 : 3 : return VCARD_RESPONSE_GET_STATIC(
519 : : VCARD7816_STATUS_ERROR_FILE_NOT_FOUND);
520 : 0 : case VCARD7816_STATUS_ERROR_RECORD_NOT_FOUND:
521 : 0 : return VCARD_RESPONSE_GET_STATIC(
522 : : VCARD7816_STATUS_ERROR_RECORD_NOT_FOUND);
523 : 0 : case VCARD7816_STATUS_ERROR_NO_SPACE_FOR_FILE:
524 : 0 : return VCARD_RESPONSE_GET_STATIC(
525 : : VCARD7816_STATUS_ERROR_NO_SPACE_FOR_FILE);
526 : 0 : case VCARD7816_STATUS_ERROR_LC_TLV_INCONSISTENT:
527 : 0 : return VCARD_RESPONSE_GET_STATIC(
528 : : VCARD7816_STATUS_ERROR_LC_TLV_INCONSISTENT);
529 : 12 : case VCARD7816_STATUS_ERROR_P1_P2_INCORRECT:
530 : 12 : return VCARD_RESPONSE_GET_STATIC(
531 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
532 : 0 : case VCARD7816_STATUS_ERROR_LC_P1_P2_INCONSISTENT:
533 : 0 : return VCARD_RESPONSE_GET_STATIC(
534 : : VCARD7816_STATUS_ERROR_LC_P1_P2_INCONSISTENT);
535 : 10 : case VCARD7816_STATUS_ERROR_DATA_NOT_FOUND:
536 : 10 : return VCARD_RESPONSE_GET_STATIC(
537 : : VCARD7816_STATUS_ERROR_DATA_NOT_FOUND);
538 : 0 : case VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_2:
539 : 0 : return VCARD_RESPONSE_GET_STATIC(
540 : : VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_2);
541 : 1 : case VCARD7816_STATUS_ERROR_INS_CODE_INVALID:
542 : 1 : return VCARD_RESPONSE_GET_STATIC(
543 : : VCARD7816_STATUS_ERROR_INS_CODE_INVALID);
544 : 0 : case VCARD7816_STATUS_ERROR_CLA_INVALID:
545 : 0 : return VCARD_RESPONSE_GET_STATIC(
546 : : VCARD7816_STATUS_ERROR_CLA_INVALID);
547 : 0 : case VCARD7816_STATUS_ERROR_GENERAL:
548 : 0 : return VCARD_RESPONSE_GET_STATIC(
549 : : VCARD7816_STATUS_ERROR_GENERAL);
550 : 0 : default:
551 : : /* we don't know this status code, create a response buffer to
552 : : * hold it */
553 : 0 : response = vcard_response_new_status(status);
554 [ # # ]: 0 : if (response == NULL) {
555 : : /* couldn't allocate the buffer, return memmory error */
556 : : return VCARD_RESPONSE_GET_STATIC(
557 : : VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
558 : : }
559 : : return response;
560 : : }
561 : : }
562 : :
563 : : /*
564 : : * Add File card support here if you need it.
565 : : */
566 : : static VCardStatus
567 : : vcard7816_file_system_process_apdu(G_GNUC_UNUSED VCard *card,
568 : : G_GNUC_UNUSED VCardAPDU *apdu,
569 : : VCardResponse **response)
570 : : {
571 : : /* TODO: if we want to support a virtual file system card, we do it here.
572 : : * It would probably be a pkcs #15 card type */
573 : 0 : *response = vcard_make_response(
574 : : VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
575 : : return VCARD_DONE;
576 : : }
577 : :
578 : : /*
579 : : * VM card (including java cards)
580 : : */
581 : : static VCardStatus
582 : 155 : vcard7816_vm_process_apdu(VCard *card, VCardAPDU *apdu,
583 : : VCardResponse **response)
584 : : {
585 : : int bytes_to_copy, next_byte_count, count;
586 : : VCardApplet *current_applet;
587 : : VCardBufferResponse *buffer_response;
588 : : vcard_7816_status_t status;
589 : :
590 : : /* parse the class first */
591 [ - + ]: 155 : if (apdu->a_gen_type != VCARD_7816_ISO) {
592 : 0 : *response = vcard_make_response(
593 : : VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
594 : 0 : return VCARD_DONE;
595 : : }
596 : :
597 : : /* use a switch so that if we need to support secure channel stuff later,
598 : : * we know where to put it */
599 [ - + ]: 155 : switch (apdu->a_secure_messaging) {
600 : : case 0x0: /* no SM */
601 : : break;
602 : 0 : case 0x4: /* proprietary SM */
603 : : case 0x8: /* header not authenticated */
604 : : case 0xc: /* header authenticated */
605 : : default:
606 : : /* for now, don't try to support secure channel stuff in the
607 : : * virtual card. */
608 : 0 : *response = vcard_make_response(
609 : : VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED);
610 : 0 : return VCARD_DONE;
611 : : }
612 : :
613 : : /* now parse the instruction */
614 [ - + + + : 155 : switch (apdu->a_ins) {
- - ]
615 : 0 : case VCARD7816_INS_MANAGE_CHANNEL: /* secure channel op */
616 : : case VCARD7816_INS_EXTERNAL_AUTHENTICATE: /* secure channel op */
617 : : case VCARD7816_INS_GET_CHALLENGE: /* secure channel op */
618 : : case VCARD7816_INS_INTERNAL_AUTHENTICATE: /* secure channel op */
619 : : case VCARD7816_INS_ERASE_BINARY: /* applet control op */
620 : : case VCARD7816_INS_READ_BINARY: /* applet control op */
621 : : case VCARD7816_INS_WRITE_BINARY: /* applet control op */
622 : : case VCARD7816_INS_UPDATE_BINARY: /* applet control op */
623 : : case VCARD7816_INS_READ_RECORD: /* file op */
624 : : case VCARD7816_INS_WRITE_RECORD: /* file op */
625 : : case VCARD7816_INS_UPDATE_RECORD: /* file op */
626 : : case VCARD7816_INS_APPEND_RECORD: /* file op */
627 : : case VCARD7816_INS_ENVELOPE:
628 : : case VCARD7816_INS_PUT_DATA:
629 : 0 : *response = vcard_make_response(
630 : : VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
631 : 0 : break;
632 : :
633 : 73 : case VCARD7816_INS_SELECT_FILE:
634 : : /* GSC-IS: 5.3.3.2 Select Applet APDU: P1 = 0x04 */
635 [ - + ]: 73 : if (apdu->a_p1 != 0x04) {
636 : 0 : *response = vcard_make_response(
637 : : VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED);
638 : 0 : break;
639 : : }
640 : 73 : g_debug("%s: Selecting file %s", __func__, hex_dump(apdu->a_body, apdu->a_Lc));
641 : :
642 : : /* side effect, deselect the current applet if no applet has been found
643 : : */
644 : 73 : current_applet = vcard_find_applet(card, apdu->a_body, apdu->a_Lc);
645 : 73 : vcard_select_applet(card, apdu->a_channel, current_applet);
646 [ + + ]: 73 : if (current_applet) {
647 : 72 : VCardApplet *gp_applet = vcard_find_applet(card,
648 : : gp_aid, sizeof(gp_aid));
649 [ + + ]: 72 : if (current_applet == gp_applet) {
650 : : /* if the new applet is Global Platform Card Manager, we need to
651 : : * return a response (from Card Specification v2.3.1):
652 : : *
653 : : * 6F 19 : FCI Template
654 : : * 84 08 : Application / file AID
655 : : * A0 00 00 00 03 00 00 00
656 : : * A5 0D : Proprietary data
657 : : * 9F 6E 06 : Application Producution Life Cycle
658 : : * 12 91 51 81 01 00
659 : : * 9F 65 01 : Maximum Length of data field in comand message
660 : : * FF
661 : : */
662 : 3 : *response = vcard_response_new(card, gp_response,
663 : : sizeof(gp_response), apdu->a_Le, VCARD7816_STATUS_SUCCESS);
664 : : } else {
665 : 69 : unsigned char fci_template[] = {
666 : : 0x6F, 0x0B, /* Outer lenght to be replaced later */
667 : : 0x84, 0x07, /* AID length to be replaced later */
668 : : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* AID */
669 : : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
670 : : 0xA5, 0x00}; /* The rest */
671 : 69 : size_t fci_template_len = 6 + apdu->a_Lc;
672 : : /* with GSC-IS 2 applets, we do not need to return anything
673 : : * for select applet, but cards generally do, at least this
674 : : * FCI template stub:
675 : : *
676 : : * 6F 0B : FCI Template
677 : : * 84 07 : Application / file AID
678 : : * A0 00 00 00 79 03 00
679 : : * A5 00 : Proprietary data
680 : : */
681 : : /* Insert the correct AID in the structure */
682 [ - + ]: 69 : g_assert_cmpint(fci_template_len, <=, sizeof(fci_template));
683 : 69 : fci_template[1] = apdu->a_Lc + 4;
684 : 69 : fci_template[3] = apdu->a_Lc;
685 : 69 : memcpy(&fci_template[4], apdu->a_body, apdu->a_Lc);
686 : 69 : fci_template[apdu->a_Lc + 4] = 0xA5;
687 : 69 : fci_template[apdu->a_Lc + 5] = 0x00;
688 : 69 : *response = vcard_response_new(card, fci_template,
689 : : fci_template_len, apdu->a_Le, VCARD7816_STATUS_SUCCESS);
690 : : }
691 : : } else {
692 : : /* the real CAC returns (SW1=0x6A, SW2=0x82) */
693 : 1 : *response = vcard_make_response(
694 : : VCARD7816_STATUS_ERROR_FILE_NOT_FOUND);
695 : : }
696 : : break;
697 : :
698 : 51 : case VCARD7816_INS_VERIFY:
699 [ + + - + ]: 51 : if ((apdu->a_p1 != 0x00) || (apdu->a_p2 != 0x00)) {
700 : 5 : *response = vcard_make_response(
701 : : VCARD7816_STATUS_ERROR_WRONG_PARAMETERS);
702 : : } else {
703 [ + + ]: 46 : if (apdu->a_Lc == 0) {
704 : : /* If we are already logged in, we should succeed just now */
705 [ + + ]: 26 : if (vcard_emul_is_logged_in(card)) {
706 : 22 : *response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
707 : 22 : break;
708 : : }
709 : : /* handle pin count if possible (not possible now) */
710 : 4 : count = vcard_get_login_count(card);
711 [ + - ]: 4 : if (count < 0) {
712 : 4 : *response = vcard_make_response(
713 : : VCARD7816_STATUS_ERROR_DATA_NOT_FOUND);
714 : : } else {
715 : 0 : if (count > 0xf) {
716 : : count = 0xf;
717 : : }
718 : 0 : *response = vcard_response_new_status_bytes(
719 : : VCARD7816_SW1_WARNING_CHANGE,
720 : 0 : 0xc0 | count);
721 [ # # ]: 0 : if (*response == NULL) {
722 : 0 : *response = vcard_make_response(
723 : : VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
724 : : }
725 : : }
726 : : } else {
727 : 20 : status = vcard_emul_login(card, apdu->a_body, apdu->a_Lc);
728 : 20 : *response = vcard_make_response(status);
729 : : }
730 : : }
731 : : break;
732 : :
733 : 31 : case VCARD7816_INS_GET_RESPONSE:
734 : 31 : buffer_response = vcard_get_buffer_response(card);
735 [ + + ]: 31 : if (!buffer_response) {
736 : 3 : *response = vcard_make_response(
737 : : VCARD7816_STATUS_ERROR_DATA_NOT_FOUND);
738 : : /* handle error */
739 : 3 : break;
740 : : }
741 : 28 : bytes_to_copy = MIN(buffer_response->len, apdu->a_Le);
742 : 28 : next_byte_count = MIN(256, buffer_response->len - bytes_to_copy);
743 [ + + ]: 55 : *response = vcard_response_new_bytes(
744 : : card, buffer_response->current, bytes_to_copy,
745 : : apdu->a_Le,
746 : : next_byte_count ?
747 : : VCARD7816_SW1_RESPONSE_BYTES : VCARD7816_SW1_SUCCESS,
748 : : next_byte_count);
749 : 28 : buffer_response->current += bytes_to_copy;
750 : 28 : buffer_response->len -= bytes_to_copy;
751 [ + - + + ]: 28 : if (*response == NULL || (next_byte_count == 0)) {
752 : 27 : vcard_set_buffer_response(card, NULL);
753 : 27 : vcard_buffer_response_delete(buffer_response);
754 : : }
755 [ - + ]: 28 : if (*response == NULL) {
756 : 0 : *response =
757 : 0 : vcard_make_response(VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
758 : : }
759 : : break;
760 : :
761 : 0 : case VCARD7816_INS_GET_DATA:
762 : 0 : *response =
763 : 0 : vcard_make_response(VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
764 : 0 : break;
765 : :
766 : 0 : default:
767 : 0 : *response =
768 : 0 : vcard_make_response(VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
769 : 0 : break;
770 : : }
771 : :
772 : : /* response should have been set somewhere */
773 [ - + - + ]: 155 : g_assert(*response != NULL);
774 : : return VCARD_DONE;
775 : : }
776 : :
777 : :
778 : : /*
779 : : * APDU processing starts here. This routes the card processing stuff to the
780 : : * right location.
781 : : */
782 : : VCardStatus
783 : 583 : vcard_process_apdu(VCard *card, VCardAPDU *apdu, VCardResponse **response)
784 : : {
785 : : VCardStatus status;
786 : : VCardBufferResponse *buffer_response;
787 : :
788 : : /* first handle any PTS commands, which aren't really APDU's */
789 [ - + ]: 583 : if (apdu->a_type == VCARD_7816_PTS) {
790 : : /* the PTS responses aren't really responses either */
791 : 0 : *response = vcard_response_new_data(apdu->a_data, apdu->a_len);
792 : : /* PTS responses have no status bytes */
793 : 0 : (*response)->b_total_len = (*response)->b_len;
794 : 0 : return VCARD_DONE;
795 : : }
796 : 583 : buffer_response = vcard_get_buffer_response(card);
797 [ + + + + ]: 583 : if (buffer_response && apdu->a_ins != VCARD7816_INS_GET_RESPONSE) {
798 : : /* clear out buffer_response, do not return an error */
799 : 158 : vcard_set_buffer_response(card, NULL);
800 : 158 : vcard_buffer_response_delete(buffer_response);
801 : : }
802 : :
803 : 583 : status = vcard_process_applet_apdu(card, apdu, response);
804 [ + + ]: 583 : if (status != VCARD_NEXT) {
805 : : return status;
806 : : }
807 [ - + - - ]: 155 : switch (vcard_get_type(card)) {
808 : : case VCARD_FILE_SYSTEM:
809 : 0 : return vcard7816_file_system_process_apdu(card, apdu, response);
810 : 155 : case VCARD_VM:
811 : 155 : return vcard7816_vm_process_apdu(card, apdu, response);
812 : : case VCARD_DIRECT:
813 : : /* if we are type direct, then the applet should handle everything */
814 : 0 : g_assert(!"VCARD_DIRECT: applet failure");
815 : : break;
816 : 0 : default:
817 : 0 : g_warn_if_reached();
818 : : }
819 : 0 : *response =
820 : 0 : vcard_make_response(VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
821 : 0 : return VCARD_DONE;
822 : : }
823 : :
824 : : /* vim: set ts=4 sw=4 tw=0 noet expandtab: */
|
