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