root / libcacard / card_7816.c @ fc27eefe
History | View | Annotate | Download (27.3 kB)
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 *)qemu_malloc(sizeof(VCardResponse));
|
55 |
new_response->b_data = qemu_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 Reponse 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 *)qemu_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 *)qemu_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 |
qemu_free(response->b_data); |
177 |
} |
178 |
qemu_free(response); |
179 |
break;
|
180 |
case VCARD_MALLOC_DATA:
|
181 |
/* only the data buffer was malloc'ed */
|
182 |
if (response->b_data) {
|
183 |
qemu_free(response->b_data); |
184 |
} |
185 |
break;
|
186 |
case VCARD_MALLOC_STRUCT:
|
187 |
/* only the structure was malloc'ed */
|
188 |
qemu_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 fiels 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 *)qemu_malloc(sizeof(VCardAPDU));
|
340 |
new_apdu->a_data = qemu_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 |
qemu_free(new_apdu); |
346 |
return NULL; |
347 |
} |
348 |
*status = vcard_apdu_set_length(new_apdu); |
349 |
if (*status != VCARD7816_STATUS_SUCCESS) {
|
350 |
qemu_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 |
qemu_free(apdu->a_data); |
364 |
} |
365 |
qemu_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 |
} |