Branch data Line data Source code
1 : : /*
2 : : * implement the applets for the CAC card.
3 : : *
4 : : * Adaptation to GSC-IS 2.1:
5 : : * https://nvlpubs.nist.gov/nistpubs/Legacy/IR/nistir6887e2003.pdf
6 : : *
7 : : * and NIST SP 800-73-4
8 : : * https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-73-4.pdf
9 : : *
10 : : * Copyright 2010 - 2018 Red Hat, Inc.
11 : : *
12 : : * Authors: Robert Relyea <rrelyea@redhat.com>
13 : : * Alon Levy <alevy@redhat.com>
14 : : * Jakub Jelen <jjelen@redhat.com>
15 : : *
16 : : * This code is licensed under the GNU LGPL, version 2.1 or later.
17 : : * See the COPYING file in the top-level directory.
18 : : */
19 : :
20 : : #include <glib.h>
21 : :
22 : : #include <string.h>
23 : : #include <stdbool.h>
24 : :
25 : : #include "cac.h"
26 : : #include "cac-aca.h"
27 : : #include "vcard.h"
28 : : #include "vcard_emul.h"
29 : : #include "vcardt_internal.h"
30 : : #include "card_7816.h"
31 : : #include "simpletlv.h"
32 : : #include "common.h"
33 : :
34 : : static const unsigned char cac_aca_aid[] = {
35 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x03, 0x00 };
36 : : static const unsigned char cac_ccc_aid[] = {
37 : : 0xa0, 0x00, 0x00, 0x01, 0x16, 0xDB, 0x00 };
38 : : static const unsigned char cac_02fb_aid[] = {
39 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x02, 0xFB };
40 : : static const unsigned char cac_1201_aid[] = {
41 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x12, 0x01 };
42 : : static const unsigned char cac_1202_aid[] = {
43 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x12, 0x02 };
44 : : static const unsigned char cac_02f0_aid[] = {
45 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x02, 0xF0 };
46 : : static const unsigned char cac_02f1_aid[] = {
47 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x02, 0xF1 };
48 : : static const unsigned char cac_02f2_aid[] = {
49 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x02, 0xF2 };
50 : : static const unsigned char cac_access_control_aid[] = {
51 : : 0xa0, 0x00, 0x00, 0x01, 0x16, 0x30, 0x00 };
52 : : static const unsigned char cac_pki_certificate_aid[] = {
53 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x02, 0xFE };
54 : : static const unsigned char cac_pki_credential_aid[] = {
55 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x02, 0xFD };
56 : : static const unsigned char cac_person_instance_aid[] = {
57 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x02, 0x00 };
58 : : static const unsigned char cac_personnel_aid[] = {
59 : : 0xa0, 0x00, 0x00, 0x00, 0x79, 0x02, 0x01 };
60 : :
61 : :
62 : : /* private data for PKI applets */
63 : : typedef struct CACPKIAppletDataStruct {
64 : : unsigned char *sign_buffer;
65 : : int sign_buffer_len;
66 : : VCardKey *key;
67 : : } CACPKIAppletData;
68 : :
69 : : /* private data for CCC container */
70 : : typedef struct CACCCCAppletDataStruct {
71 : : } CACCCCAppletData;
72 : :
73 : : /* private data for ACA container */
74 : : typedef struct CACACAAppletDataStruct {
75 : : unsigned int pki_applets;
76 : : /* At the moment mostly in cac-aca.c */
77 : : } CACACAAppletData;
78 : :
79 : : /* private data for passthrough applets */
80 : : typedef struct CACPTAppletDataStruct {
81 : : char *label;
82 : : } CACPTAppletData;
83 : :
84 : : struct coid {
85 : : unsigned char v[2];
86 : : };
87 : :
88 : : /*
89 : : * CAC applet private data
90 : : */
91 : : struct VCardAppletPrivateStruct {
92 : : /* common attributes */
93 : : unsigned char *tag_buffer;
94 : : int tag_buffer_len;
95 : : unsigned char *val_buffer;
96 : : int val_buffer_len;
97 : : struct simpletlv_member *properties;
98 : : unsigned int properties_len;
99 : : unsigned int long_properties_len;
100 : : /* TODO we should also keep a state, which OID is selected,
101 : : * but it does not matter now, because we do not have anything different
102 : : * in either buffer
103 : : */
104 : : struct coid *coids;
105 : : unsigned int coids_len;
106 : : /* applet-specific */
107 : : union {
108 : : CACPKIAppletData pki_data;
109 : : CACCCCAppletData ccc_data;
110 : : CACACAAppletData aca_data;
111 : : CACPTAppletData pt_data;
112 : : void *reserved;
113 : : } u;
114 : : };
115 : :
116 : : /*
117 : : * Encode SimpleTLV structures to file expected to be returned by the card.
118 : : * This means, data in SimpleTLV prefixed with 2B encoding the length of
119 : : * the whole buffer.
120 : : */
121 : : static int
122 : 32 : cac_create_file(struct simpletlv_member *tlv, size_t tlv_len,
123 : : unsigned char **out, int type)
124 : : {
125 : : int len, length;
126 : : unsigned char *buffer = NULL, *start;
127 : :
128 : 32 : len = simpletlv_get_length(tlv, tlv_len, type);
129 [ - + ]: 32 : if (len < 0)
130 : 0 : goto failure;
131 : :
132 : 32 : buffer = g_malloc(2 /*2B length*/ + len);
133 : :
134 : 32 : start = buffer + 2;
135 [ + + ]: 32 : if (type == SIMPLETLV_TL)
136 : 16 : length = simpletlv_encode_tl(tlv, tlv_len, &start, len, NULL);
137 [ + - ]: 16 : else if (type == SIMPLETLV_VALUE)
138 : 16 : length = simpletlv_encode_val(tlv, tlv_len, &start, len, NULL);
139 : : else
140 : 0 : goto failure;
141 : :
142 [ - + ]: 32 : if (length <= 0)
143 : 0 : goto failure;
144 : :
145 : 32 : ushort2lebytes(buffer, length);
146 : :
147 : 32 : *out = buffer;
148 : 32 : return len + 2;
149 : :
150 : 0 : failure:
151 : 0 : *out = NULL;
152 : 0 : g_free(buffer);
153 : 0 : return 0;
154 : : }
155 : :
156 : : static inline int
157 : : cac_create_tl_file(struct simpletlv_member *tlv, size_t tlv_len,
158 : : unsigned char **out)
159 : : {
160 : 16 : return cac_create_file(tlv, tlv_len, out, SIMPLETLV_TL);
161 : : }
162 : :
163 : : static inline int
164 : : cac_create_val_file(struct simpletlv_member *tlv, size_t tlv_len,
165 : : unsigned char **out)
166 : : {
167 : 16 : return cac_create_file(tlv, tlv_len, out, SIMPLETLV_VALUE);
168 : : }
169 : :
170 : : static inline int
171 : : cac_create_empty_file(unsigned char **out)
172 : : {
173 : 6 : *out = g_malloc_n(2, sizeof(unsigned char));
174 : :
175 : 12 : (*out)[0] = 0x00;
176 : 12 : (*out)[1] = 0x00;
177 : : return 2;
178 : : }
179 : :
180 : : /*
181 : : * This function returns properties of an applet encoded as SimpleTLV.
182 : : * If the tags argument is provided, only the tags in the passed list
183 : : * with respective values are returned.
184 : : * Otherwise, all the tags are returned.
185 : : */
186 : : static VCardResponse *
187 : 211 : get_properties(VCard *card,
188 : : struct simpletlv_member *properties, unsigned int properties_len,
189 : : unsigned char *tags, unsigned int tags_len,
190 : : unsigned int a_Le)
191 : : {
192 : : VCardResponse *r = NULL;
193 : : struct simpletlv_member *cp = NULL;
194 : : unsigned int cp_len = 0;
195 : 211 : unsigned char *properties_buffer = NULL;
196 : : unsigned int properties_buffer_len = 0;
197 : :
198 [ + + ]: 211 : if (tags_len > 0 && tags) {
199 : : unsigned int i, j, k = 0;
200 : :
201 : 71 : cp = g_malloc_n(tags_len, sizeof(struct simpletlv_member));
202 : :
203 : : /* show only matching */
204 [ + + ]: 211 : for (j = 0; j < tags_len; j++) {
205 : : int match = 0;
206 [ + + ]: 144 : for (i = 0; i < properties_len; i++) {
207 [ + + ]: 143 : if (properties[i].tag == tags[j]) {
208 : 140 : memcpy(&cp[k], &properties[i],
209 : : sizeof(struct simpletlv_member));
210 : : match++;
211 : 140 : k++;
212 : : break; // XXX do not allow more tags of the same ID
213 : : }
214 : : }
215 : : /* if this tag was not found, return */
216 : : if (!match) {
217 : 1 : r = vcard_make_response(VCARD7816_STATUS_ERROR_DATA_NOT_FOUND);
218 : 1 : goto cleanup;
219 : : }
220 : : }
221 : : cp_len = tags_len;
222 : : } else {
223 : : cp = properties;
224 : : cp_len = properties_len;
225 : : }
226 : :
227 : : /* Encode the SimpleTLV structure */
228 : 210 : properties_buffer_len = simpletlv_encode(cp, cp_len,
229 : : &properties_buffer, 0, NULL);
230 [ - + ]: 210 : if (properties_buffer_len <= 0) {
231 : 0 : g_debug("%s: Failed to encode properties buffer", __func__);
232 : 0 : goto cleanup;
233 : : }
234 : :
235 [ + + ]: 210 : if (a_Le > properties_buffer_len) {
236 : 105 : r = vcard_response_new_status_bytes(
237 : : VCARD7816_SW1_LE_ERROR, properties_buffer_len);
238 : 105 : goto cleanup;
239 : : }
240 : 105 : r = vcard_response_new(card, properties_buffer, properties_buffer_len,
241 : : a_Le, VCARD7816_STATUS_SUCCESS);
242 : :
243 : 211 : cleanup:
244 : 211 : g_free(properties_buffer);
245 [ + + ]: 211 : if (tags_len > 0 && tags)
246 : 71 : g_free(cp);
247 [ - + ]: 211 : if (r == NULL)
248 : 0 : r = vcard_make_response(VCARD7816_STATUS_ERROR_GENERAL);
249 : 211 : return r;
250 : : }
251 : :
252 : : /*
253 : : * handle all the APDU's that are common to all CAC applets
254 : : */
255 : : static VCardStatus
256 : 351 : cac_common_process_apdu(VCard *card, VCardAPDU *apdu, VCardResponse **response)
257 : : {
258 : : VCardAppletPrivate *applet_private;
259 : : VCardStatus ret = VCARD_FAIL;
260 : : int found = 0;
261 : : unsigned int i;
262 : :
263 : 351 : applet_private = vcard_get_current_applet_private(card, apdu->a_channel);
264 [ - + - + ]: 351 : g_assert(applet_private);
265 : :
266 [ + + + + ]: 351 : switch (apdu->a_ins) {
267 : : case CAC_GET_PROPERTIES:
268 : : /* 5.3.3.4: Get Properties APDU */
269 : : g_assert(applet_private);
270 : :
271 [ + + ]: 216 : if (apdu->a_p2 != 0x00) {
272 : : /* P2 needs to be 0x00 */
273 : 1 : *response = vcard_make_response(
274 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
275 : : ret = VCARD_DONE;
276 : 1 : break;
277 : : }
278 : :
279 [ + + + + : 215 : switch (apdu->a_p1) {
+ ]
280 : 1 : case 0x00:
281 : : /* Get a GSC-IS v2.0 compatible properties response message. */
282 : : /* If P1 = 0x00 cannot be supported by the smart card, SW1 = 0x6A and SW2 = 86. */
283 : 1 : *response = vcard_make_response(
284 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
285 : : ret = VCARD_DONE;
286 : 1 : break;
287 : 71 : case 0x01:
288 : : /* Get all the properties. */
289 [ + + ]: 71 : if (apdu->a_Lc != 0) {
290 : 1 : *response = vcard_make_response(
291 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
292 : : ret = VCARD_DONE;
293 : 1 : break;
294 : : }
295 : : /* TODO the properties buffer should be shorter for P1 = 0x01 */
296 : :
297 : 140 : *response = get_properties(card, applet_private->properties,
298 : 70 : applet_private->properties_len, NULL, 0, apdu->a_Le);
299 : : ret = VCARD_DONE;
300 : :
301 : 70 : break;
302 : 72 : case 0x02:
303 : : /* Get the properties of the tags provided in list of tags in
304 : : * the command data field. */
305 [ + + ]: 72 : if (apdu->a_Lc == 0) {
306 : 1 : *response = vcard_make_response(
307 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
308 : : ret = VCARD_DONE;
309 : 1 : break;
310 : : }
311 : 142 : *response = get_properties(card, applet_private->properties,
312 : 71 : applet_private->properties_len, apdu->a_body, apdu->a_Lc, apdu->a_Le);
313 : : ret = VCARD_DONE;
314 : 71 : break;
315 : 70 : case 0x40:
316 : : /* XXX This is undocumented P1 argument, which returns properties
317 : : * extended with some more values of unknown meaning.
318 : : */
319 : 140 : *response = get_properties(card, applet_private->properties,
320 : 70 : applet_private->long_properties_len, NULL, 0, apdu->a_Le);
321 : : ret = VCARD_DONE;
322 : 70 : break;
323 : 1 : default:
324 : : /* unknown params returns (SW1=0x6A, SW2=0x86) */
325 : 1 : *response = vcard_make_response(
326 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
327 : : ret = VCARD_DONE;
328 : 1 : break;
329 : : }
330 : :
331 : : break;
332 : 67 : case VCARD7816_INS_SELECT_FILE:
333 [ + + ]: 67 : if (apdu->a_p1 != 0x02) {
334 : : /* let the 7816 code handle applet switches */
335 : : ret = VCARD_NEXT;
336 : : break;
337 : : }
338 : :
339 : : g_assert(applet_private);
340 : :
341 : : /* handle file id setting */
342 [ + + ]: 7 : if (apdu->a_Lc != 2) {
343 : 2 : *response = vcard_make_response(
344 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
345 : : ret = VCARD_DONE;
346 : 2 : break;
347 : : }
348 : : /* CAC 2 Card Object ID needs to match one of the COID defined
349 : : * in the applet
350 : : */
351 [ + + ]: 19 : for (i = 0; i < applet_private->coids_len; i++) {
352 [ + + ]: 14 : if (memcmp(apdu->a_body, applet_private->coids[i].v, 2) == 0) {
353 : : found = 1;
354 : : }
355 : : }
356 [ + + ]: 5 : if (!found) {
357 : 2 : *response = vcard_make_response(
358 : : VCARD7816_STATUS_ERROR_FILE_NOT_FOUND);
359 : : ret = VCARD_DONE;
360 : 2 : break;
361 : : }
362 : 3 : *response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
363 : : ret = VCARD_DONE;
364 : 3 : break;
365 : : case VCARD7816_INS_GET_RESPONSE:
366 : : case VCARD7816_INS_VERIFY:
367 : : /* let the 7816 code handle these */
368 : : ret = VCARD_NEXT;
369 : : break;
370 : 1 : default:
371 : 1 : *response = vcard_make_response(
372 : : VCARD7816_STATUS_ERROR_INS_CODE_INVALID);
373 : : ret = VCARD_DONE;
374 : 1 : break;
375 : : }
376 : 351 : return ret;
377 : : }
378 : :
379 : : /*
380 : : * Handle READ BUFFER APDU and other common APDUs for CAC applets
381 : : */
382 : : static VCardStatus
383 : 357 : cac_common_process_apdu_read(VCard *card, VCardAPDU *apdu,
384 : : VCardResponse **response)
385 : : {
386 : : VCardAppletPrivate *applet_private;
387 : : VCardStatus ret = VCARD_FAIL;
388 : : int size, offset;
389 : :
390 : 357 : applet_private = vcard_get_current_applet_private(card, apdu->a_channel);
391 [ - + - + ]: 357 : g_assert(applet_private);
392 : :
393 [ + - + ]: 357 : switch (apdu->a_ins) {
394 : 65 : case CAC_READ_BUFFER:
395 : : /* Body contains exactly two bytes */
396 [ + + + + ]: 65 : if (!apdu->a_body || apdu->a_Lc != 2) {
397 : 8 : *response = vcard_make_response(
398 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
399 : : ret = VCARD_DONE;
400 : 8 : break;
401 : : }
402 : :
403 : : /* Second byte defines how many bytes should be read */
404 : 57 : size = apdu->a_body[1];
405 : :
406 : : /* P1 | P2 defines offset to read from */
407 : 57 : offset = (apdu->a_p1 << 8) | apdu->a_p2;
408 : 57 : g_debug("%s: Requested offset: %d bytes", __func__, offset);
409 : :
410 : : /* First byte selects TAG+LEN or VALUE buffer */
411 [ + + + ]: 57 : switch (apdu->a_body[0]) {
412 : 22 : case CAC_FILE_VALUE:
413 : 22 : size = MIN(size, applet_private->val_buffer_len - offset);
414 [ + + ]: 22 : if (size < 0) { /* Overrun returns (SW1=0x6A, SW2=0x86) */
415 : 4 : *response = vcard_make_response(
416 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
417 : 4 : break;
418 : : }
419 : 36 : *response = vcard_response_new_bytes(
420 : 18 : card, applet_private->val_buffer + offset, size,
421 : : apdu->a_Le, VCARD7816_SW1_SUCCESS, 0);
422 : 18 : break;
423 : 31 : case CAC_FILE_TAG:
424 : 31 : g_debug("%s: Requested: %d bytes", __func__, size);
425 : 31 : size = MIN(size, applet_private->tag_buffer_len - offset);
426 [ + + ]: 31 : if (size < 0) { /* Overrun returns (SW1=0x6A, SW2=0x86) */
427 : 4 : *response = vcard_make_response(
428 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
429 : 4 : break;
430 : : }
431 : 27 : g_debug("%s: Returning: %d bytes (have %d)", __func__, size,
432 : : applet_private->tag_buffer_len);
433 : 54 : *response = vcard_response_new_bytes(
434 : 27 : card, applet_private->tag_buffer + offset, size,
435 : : apdu->a_Le, VCARD7816_SW1_SUCCESS, 0);
436 : 27 : break;
437 : 4 : default:
438 : 4 : *response = vcard_make_response(
439 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
440 : 4 : break;
441 : : }
442 [ + - ]: 57 : if (*response == NULL) {
443 : 0 : *response = vcard_make_response(
444 : : VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
445 : : }
446 : : ret = VCARD_DONE;
447 : : break;
448 : 0 : case CAC_UPDATE_BUFFER:
449 : 0 : *response = vcard_make_response(
450 : : VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
451 : : ret = VCARD_DONE;
452 : 0 : break;
453 : 292 : default:
454 : 292 : ret = cac_common_process_apdu(card, apdu, response);
455 : 292 : break;
456 : : }
457 : 357 : return ret;
458 : : }
459 : :
460 : :
461 : : /*
462 : : * reset the inter call state between applet selects
463 : : */
464 : : static VCardStatus
465 : 13 : cac_applet_pki_reset(VCard *card, int channel)
466 : : {
467 : : VCardAppletPrivate *applet_private;
468 : : CACPKIAppletData *pki_applet;
469 : 13 : applet_private = vcard_get_current_applet_private(card, channel);
470 [ - + - + ]: 13 : g_assert(applet_private);
471 : : pki_applet = &(applet_private->u.pki_data);
472 : :
473 : 13 : g_free(pki_applet->sign_buffer);
474 : 13 : pki_applet->sign_buffer = NULL;
475 : 13 : pki_applet->sign_buffer_len = 0;
476 : 13 : return VCARD_DONE;
477 : : }
478 : :
479 : : static VCardStatus
480 : 6 : cac_applet_passthrough_reset(VCard *card, int channel)
481 : : {
482 : : VCardAppletPrivate *applet_private;
483 : 6 : applet_private = vcard_get_current_applet_private(card, channel);
484 [ - + - + ]: 6 : g_assert(applet_private);
485 : :
486 : 6 : g_free(applet_private->tag_buffer);
487 : 6 : applet_private->tag_buffer = NULL;
488 : 6 : applet_private->tag_buffer_len = 0;
489 : 6 : g_free(applet_private->val_buffer);
490 : 6 : applet_private->val_buffer = NULL;
491 : 6 : applet_private->val_buffer_len = 0;
492 : 6 : return VCARD_DONE;
493 : : }
494 : :
495 : : static VCardStatus
496 : 118 : cac_applet_pki_process_apdu(VCard *card, VCardAPDU *apdu,
497 : : VCardResponse **response)
498 : : {
499 : : CACPKIAppletData *pki_applet;
500 : : VCardAppletPrivate *applet_private;
501 : : int size;
502 : : unsigned char *sign_buffer = NULL;
503 : : bool retain_sign_buffer = FALSE;
504 : : vcard_7816_status_t status;
505 : : VCardStatus ret = VCARD_FAIL;
506 : :
507 : 118 : applet_private = vcard_get_current_applet_private(card, apdu->a_channel);
508 [ - + - + ]: 118 : g_assert(applet_private);
509 : : pki_applet = &(applet_private->u.pki_data);
510 : :
511 [ + + + ]: 118 : switch (apdu->a_ins) {
512 : 1 : case CAC_UPDATE_BUFFER:
513 : 1 : *response = vcard_make_response(
514 : : VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
515 : : ret = VCARD_DONE;
516 : 1 : break;
517 : 26 : case CAC_SIGN_DECRYPT:
518 [ - + ]: 26 : if (apdu->a_p2 != 0) {
519 : 0 : *response = vcard_make_response(
520 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
521 : : ret = VCARD_DONE;
522 : 0 : break;
523 : : }
524 : 26 : size = apdu->a_Lc;
525 : :
526 : 26 : sign_buffer = g_realloc(pki_applet->sign_buffer,
527 : 26 : pki_applet->sign_buffer_len + size);
528 : 26 : memcpy(sign_buffer + pki_applet->sign_buffer_len, apdu->a_body, size);
529 : 26 : size += pki_applet->sign_buffer_len;
530 [ + + - ]: 26 : switch (apdu->a_p1) {
531 : 7 : case 0x80:
532 : : /* p1 == 0x80 means we haven't yet sent the whole buffer, wait for
533 : : * the rest */
534 : 7 : pki_applet->sign_buffer = sign_buffer;
535 : 7 : pki_applet->sign_buffer_len = size;
536 : 7 : *response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
537 : : retain_sign_buffer = TRUE;
538 : : break;
539 : 19 : case 0x00:
540 : : /* we now have the whole buffer, do the operation, result will be
541 : : * in the sign_buffer */
542 : 19 : status = vcard_emul_rsa_op(card, pki_applet->key,
543 : : sign_buffer, size);
544 [ + + ]: 19 : if (status != VCARD7816_STATUS_SUCCESS) {
545 : 1 : *response = vcard_make_response(status);
546 : : break;
547 : : }
548 : 18 : *response = vcard_response_new(card, sign_buffer, size, apdu->a_Le,
549 : : VCARD7816_STATUS_SUCCESS);
550 [ - + ]: 18 : if (*response == NULL) {
551 : 0 : *response = vcard_make_response(
552 : : VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
553 : : }
554 : : break;
555 : 0 : default:
556 : 0 : *response = vcard_make_response(
557 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
558 : : break;
559 : : }
560 : : if (!retain_sign_buffer) {
561 : 19 : g_free(sign_buffer);
562 : 19 : pki_applet->sign_buffer = NULL;
563 : 19 : pki_applet->sign_buffer_len = 0;
564 : : }
565 : : ret = VCARD_DONE;
566 : : break;
567 : 91 : default:
568 : 91 : ret = cac_common_process_apdu_read(card, apdu, response);
569 : 91 : break;
570 : : }
571 : 118 : return ret;
572 : : }
573 : :
574 : : static VCardStatus
575 : 167 : cac_applet_aca_process_apdu(VCard *card, VCardAPDU *apdu,
576 : : VCardResponse **response)
577 : : {
578 : : VCardStatus ret = VCARD_FAIL;
579 : : CACACAAppletData *aca_applet;
580 : : VCardAppletPrivate *applet_private;
581 : : int format;
582 : :
583 : 167 : applet_private = vcard_get_current_applet_private(card, apdu->a_channel);
584 [ - + - + ]: 167 : g_assert(applet_private);
585 : : aca_applet = &(applet_private->u.aca_data);
586 : :
587 [ + + ]: 167 : switch (apdu->a_ins) {
588 : 108 : case CAC_GET_ACR:
589 : : /* generate some ACRs Chapter 5.3.3.5
590 : : * Works only on the ACA container, not the others!
591 : : */
592 [ + + ]: 108 : if (apdu->a_p2 != 0x00) {
593 : : /* P2 needs to be 0x00 */
594 : 1 : *response = vcard_make_response(
595 : : VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
596 : : ret = VCARD_DONE;
597 : 1 : break;
598 : : }
599 : :
600 : 107 : format = ((apdu->a_p1 & 0x40)
601 : : ? CAC_FORMAT_EXTENDED
602 [ + + ]: 107 : : CAC_FORMAT_SIMPLETLV);
603 : :
604 : : switch (apdu->a_p1) {
605 : 3 : case 0x00:
606 : : case 0x40:
607 : : case 0x41: /* This one returns the same as 0x40 for some reason */
608 : : /* All ACR table entries are to be extracted */
609 [ + + ]: 3 : if (apdu->a_Lc != 0) {
610 : 1 : *response = vcard_make_response(
611 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
612 : 1 : break;
613 : : }
614 : 2 : *response = cac_aca_get_acr_response(card, apdu->a_Le, NULL,
615 : : format);
616 : 2 : break;
617 : :
618 : 3 : case 0x01:
619 : : /* Only one entry of the ACR table is extracted based on ACRID */
620 [ + + ]: 3 : if (apdu->a_Lc != 1) { /* ACRID is one byte */
621 : 1 : *response = vcard_make_response(
622 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
623 : 1 : break;
624 : : }
625 : 2 : *response = cac_aca_get_acr_response(card, apdu->a_Le,
626 : : apdu->a_body, format);
627 : 2 : break;
628 : :
629 : 3 : case 0x10:
630 : : case 0x50:
631 : : case 0x51: /* returns the same as 0x50 for some reason */
632 : : case 0x52: /* returns the same as 0x50 for some reason */
633 : : /* All Applet/Object ACR table entries are to be extracted */
634 [ + + ]: 3 : if (apdu->a_Lc != 0) {
635 : 1 : *response = vcard_make_response(
636 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
637 : 1 : break;
638 : : }
639 : 2 : *response = cac_aca_get_applet_acr_response(card, apdu->a_Le,
640 : : aca_applet->pki_applets, NULL, 0, NULL, format);
641 : 2 : break;
642 : :
643 : 3 : case 0x11:
644 : : /* Only the entries of the Applet/Object ACR table for
645 : : * one applet are extracted based on applet AID */
646 [ + + ]: 3 : if (apdu->a_Lc != 7) {
647 : 1 : *response = vcard_make_response(
648 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
649 : 1 : break;
650 : : }
651 : 2 : *response = cac_aca_get_applet_acr_response(card, apdu->a_Le,
652 : : aca_applet->pki_applets, apdu->a_body, apdu->a_Lc, NULL,
653 : : format);
654 : 2 : break;
655 : :
656 : 3 : case 0x12:
657 : : /* Only one entry of the Applet/Object ACR table for
658 : : * an object is extracted based on object ID */
659 [ + + ]: 3 : if (apdu->a_Lc != 2) {
660 : 1 : *response = vcard_make_response(
661 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
662 : 1 : break;
663 : : }
664 : 2 : *response = cac_aca_get_applet_acr_response(card, apdu->a_Le,
665 : : aca_applet->pki_applets, NULL, 0, apdu->a_body, format);
666 : 2 : break;
667 : :
668 : 3 : case 0x20:
669 : : case 0x60:
670 : : /* The Access Method Provider table is extracted. */
671 [ + + ]: 3 : if (apdu->a_Lc != 0) {
672 : 1 : *response = vcard_make_response(
673 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
674 : 1 : break;
675 : : }
676 : 2 : *response = cac_aca_get_amp_response(card, apdu->a_Le, format);
677 : 2 : break;
678 : :
679 : 89 : case 0x21:
680 : : case 0x61:
681 : : /* The Service Applet table is extracted. */
682 [ + + ]: 89 : if (apdu->a_Lc != 0) {
683 : 1 : *response = vcard_make_response(
684 : : VCARD7816_STATUS_ERROR_DATA_INVALID);
685 : 1 : break;
686 : : }
687 : 88 : *response = cac_aca_get_service_response(card, apdu->a_Le,
688 : : aca_applet->pki_applets, format);
689 : 88 : break;
690 : :
691 : 0 : default:
692 : 0 : *response = vcard_make_response(
693 : : VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
694 : 0 : break;
695 : : }
696 : : ret = VCARD_DONE;
697 : : break;
698 : 59 : default:
699 : 59 : ret = cac_common_process_apdu(card, apdu, response);
700 : 59 : break;
701 : : }
702 : 167 : return ret;
703 : : }
704 : :
705 : : static VCardStatus
706 : 54 : cac_passthrough_container_process_apdu(VCard *card, VCardAPDU *apdu,
707 : : VCardResponse **response)
708 : : {
709 : : VCardStatus ret = VCARD_FAIL;
710 : : CACPTAppletData *pt_applet;
711 : : VCardAppletPrivate *applet_private;
712 : :
713 : 54 : applet_private = vcard_get_current_applet_private(card, apdu->a_channel);
714 [ - + - + ]: 54 : g_assert(applet_private);
715 : : pt_applet = &(applet_private->u.pt_data);
716 : :
717 [ + + ]: 54 : switch (apdu->a_ins) {
718 : 15 : case CAC_READ_BUFFER:
719 : : /* The data were not yet retrieved from the card -- do it now */
720 [ + + - + ]: 15 : if (applet_private->tag_buffer == NULL || applet_private->val_buffer == NULL) {
721 : : unsigned char *data;
722 : : unsigned int data_len;
723 : : size_t tlv_len;
724 : : struct simpletlv_member *tlv;
725 : :
726 : 6 : data = vcard_emul_read_object(card, pt_applet->label, &data_len);
727 [ - + ]: 6 : if (data) {
728 : 0 : tlv = simpletlv_parse(data, data_len, &tlv_len);
729 : 0 : g_free(data);
730 : :
731 : : /* break the data buffer to TL and V buffers */
732 : 0 : applet_private->tag_buffer_len = cac_create_tl_file(tlv, tlv_len,
733 : : &applet_private->tag_buffer);
734 : 0 : applet_private->val_buffer_len = cac_create_val_file(tlv, tlv_len,
735 : : &applet_private->val_buffer);
736 : :
737 : 0 : simpletlv_free(tlv, tlv_len);
738 : : } else {
739 : : /* there is not a CAC card in a slot ? */
740 : : /* Return an empty buffer so far */
741 : : /* TODO try to emulate the expected structures here */
742 : 6 : applet_private->tag_buffer_len = cac_create_empty_file(
743 : : &applet_private->tag_buffer);
744 : 6 : applet_private->val_buffer_len = cac_create_empty_file(
745 : : &applet_private->val_buffer);
746 : : }
747 : : }
748 : : /* fallthrough */
749 : : default:
750 : 54 : ret = cac_common_process_apdu_read(card, apdu, response);
751 : : break;
752 : : }
753 : 54 : return ret;
754 : : }
755 : :
756 : : /*
757 : : * utilities for creating and destroying the private applet data
758 : : */
759 : : static void
760 : 8 : cac_delete_pki_applet_private(VCardAppletPrivate *applet_private)
761 : : {
762 : : CACPKIAppletData *pki_applet_data;
763 : :
764 [ + - ]: 8 : if (applet_private == NULL) {
765 : : return;
766 : : }
767 : : pki_applet_data = &(applet_private->u.pki_data);
768 : 8 : g_free(pki_applet_data->sign_buffer);
769 : 8 : g_free(applet_private->tag_buffer);
770 : 8 : g_free(applet_private->val_buffer);
771 : 8 : g_free(applet_private->coids);
772 : : /* this one is cloned so needs to be freed */
773 : 8 : simpletlv_free(applet_private->properties, applet_private->long_properties_len);
774 [ + - ]: 8 : if (pki_applet_data->key != NULL) {
775 : 8 : vcard_emul_delete_key(pki_applet_data->key);
776 : : }
777 : 8 : g_free(applet_private);
778 : : }
779 : :
780 : : static void
781 : 4 : cac_delete_ccc_applet_private(VCardAppletPrivate *applet_private)
782 : : {
783 [ + - ]: 4 : if (applet_private == NULL) {
784 : : return;
785 : : }
786 : 4 : g_free(applet_private->tag_buffer);
787 : 4 : g_free(applet_private->val_buffer);
788 : 4 : g_free(applet_private->coids);
789 : 4 : g_free(applet_private);
790 : : }
791 : :
792 : : static void
793 : 4 : cac_delete_aca_applet_private(VCardAppletPrivate *applet_private)
794 : : {
795 [ + - ]: 4 : if (applet_private == NULL) {
796 : : return;
797 : : }
798 : 4 : g_free(applet_private->coids);
799 : 4 : g_free(applet_private);
800 : : }
801 : :
802 : : static void
803 : 36 : cac_delete_empty_applet_private(VCardAppletPrivate *applet_private)
804 : : {
805 [ + - ]: 36 : if (applet_private == NULL) {
806 : : return;
807 : : }
808 : 36 : g_free(applet_private->coids);
809 : 36 : g_free(applet_private->tag_buffer);
810 : 36 : g_free(applet_private->val_buffer);
811 : : /* this one is cloned so needs to be freed */
812 : 36 : simpletlv_free(applet_private->properties, applet_private->properties_len);
813 : 36 : g_free(applet_private);
814 : : }
815 : :
816 : : static void
817 : 8 : cac_delete_passthrough_applet_private(VCardAppletPrivate *applet_private)
818 : : {
819 : : CACPTAppletData *pt_applet_data;
820 : :
821 [ + - ]: 8 : if (applet_private == NULL) {
822 : : return;
823 : : }
824 : : pt_applet_data = &(applet_private->u.pt_data);
825 : 8 : g_free(pt_applet_data->label);
826 : 8 : g_free(applet_private->tag_buffer);
827 : 8 : g_free(applet_private->val_buffer);
828 : 8 : g_free(applet_private->coids);
829 : : /* this one is cloned so needs to be freed */
830 : 8 : simpletlv_free(applet_private->properties, applet_private->properties_len);
831 : 8 : g_free(applet_private);
832 : : }
833 : :
834 : : static VCardAppletPrivate *
835 : 11 : cac_new_pki_applet_private(int i, const unsigned char *cert,
836 : : int cert_len, VCardKey *key)
837 : : {
838 : : CACPKIAppletData *pki_applet_data = NULL;
839 : : VCardAppletPrivate *applet_private = NULL;
840 : : int bits;
841 : :
842 : : /* PKI applet Properies ex.:
843 : : * 01 Tag: Applet Information
844 : : * 05 Length
845 : : * 10 Applet family
846 : : * 02 06 02 03 Applet version
847 : : * 40 Tag: Number of objects managed by this instance
848 : : * 01 Length
849 : : * 01 One
850 : : * 51 Tag: First PKI object
851 : : * 11 Length
852 : : * 41 Tag: ObjectID
853 : : * 02 Length
854 : : * 01 01
855 : : * 42 Buffer properties
856 : : * 05 Length
857 : : * 00 Type of tag supported
858 : : * 1E 00 T-Buffer length (LSB, MSB)
859 : : * 54 05 V-Buffer length (LSB, MSB)
860 : : * 43 Tag: PKI properties
861 : : * 04 Length
862 : : * 06 Algorithm ID Table 5-6 in GSC-IS 2.1
863 : : * 10 Key length bytes /8
864 : : * 01 Private key initialized
865 : : * 01 Public key initialized
866 : : *
867 : : * Long Properties:
868 : : * PKI applet:
869 : : * 01 05 Applet Information
870 : : * 10 02 06 02 03
871 : : * 40 01 Number of objects
872 : : * 01
873 : : * 51 14 First PKI Object
874 : : * 41 02 Object ID
875 : : * 01 02
876 : : * 42 05 Buffer properties
877 : : * 00 1E 00 57 05
878 : : * 43 04 PKI Properties
879 : : * 06 10 01 00
880 : : * 26 01 ???
881 : : * 01
882 : : * 39 01
883 : : * 00
884 : : * 3A 07 ACA ???
885 : : * A0 00 00 00 79 03 00
886 : : */
887 : 11 : unsigned char object_id[] = "\x01\x00";
888 : 11 : unsigned char buffer_properties[] = "\x00\x00\x00\x00\x00";
889 : 11 : unsigned char pki_properties[] = "\x06\x10\x01\x01";
890 : 11 : unsigned char buffer_26[] = "\x01";
891 : : static struct simpletlv_member pki_object[] = {
892 : : {CAC_PROPERTIES_OBJECT_ID, 2, {/*.value = object_id*/},
893 : : SIMPLETLV_TYPE_LEAF},
894 : : {CAC_PROPERTIES_BUFFER_PROPERTIES, 5, {/*.value = buffer_properties*/},
895 : : SIMPLETLV_TYPE_LEAF},
896 : : {CAC_PROPERTIES_PKI_PROPERTIES, 4, {/*.value = pki_properties*/},
897 : : SIMPLETLV_TYPE_LEAF},
898 : : {0x26, 0x01, {/*.child = buffer_26*/}, SIMPLETLV_TYPE_LEAF},
899 : : };
900 : 11 : unsigned char applet_information[] = "\x10\x02\x06\x02\x03";
901 : 11 : unsigned char number_objects[] = "\x01";
902 : 11 : unsigned char buffer_39[] = "\x00";
903 : 11 : unsigned char aca_aid[] = "\xA0\x00\x00\x00\x79\x03\x00";
904 : : static struct simpletlv_member properties[] = {
905 : : {CAC_PROPERTIES_APPLET_INFORMATION, 5, {/*.value = applet_information*/},
906 : : SIMPLETLV_TYPE_LEAF},
907 : : {CAC_PROPERTIES_NUMBER_OBJECTS, 1, {/*.value = number_objects */},
908 : : SIMPLETLV_TYPE_LEAF},
909 : : {CAC_PROPERTIES_PKI_OBJECT, 4, {/*.child = pki_object*/},
910 : : SIMPLETLV_TYPE_COMPOUND},
911 : : {0x39, 0x01, {/*.child = buffer_39*/}, SIMPLETLV_TYPE_LEAF},
912 : : {0x3A, 0x07, {/*.child = aca_aid*/}, SIMPLETLV_TYPE_LEAF},
913 : : };
914 : : size_t properties_len = sizeof(properties)/sizeof(struct simpletlv_member);
915 : : /* if this would be 1, the certificate would be compressed */
916 : 11 : unsigned char certinfo[] = "\x00";
917 : 11 : struct simpletlv_member buffer[] = {
918 : : {CAC_PKI_TAG_CERTINFO, 1, {/*.value = certinfo*/},
919 : : SIMPLETLV_TYPE_LEAF},
920 : : {CAC_PKI_TAG_CERTIFICATE, cert_len, {/*.value = cert*/},
921 : : SIMPLETLV_TYPE_LEAF},
922 : : {CAC_PKI_TAG_MSCUID, 0, {/*.value = NULL*/}, SIMPLETLV_TYPE_LEAF},
923 : : {CAC_PKI_TAG_ERROR_DETECTION_CODE, 0, {/*.value = NULL*/},
924 : : SIMPLETLV_TYPE_LEAF},
925 : : };
926 : : size_t buffer_len = sizeof(buffer)/sizeof(struct simpletlv_member);
927 : :
928 : 11 : applet_private = g_new0(VCardAppletPrivate, 1);
929 : : pki_applet_data = &(applet_private->u.pki_data);
930 : : /*
931 : : * if we want to support compression, then we simply change the 0 to a 1
932 : : * in certinfo and compress the cert data with libz
933 : : */
934 : :
935 : : /* prepare the buffers to when READ_BUFFER will be called.
936 : : * Assuming VM card with (LSB first if > 255)
937 : : * separate Tag+Length, Value buffers as described in 8.4:
938 : : * 2 B 1 B 1-3 B 1 B 1-3 B
939 : : * [ T-Len ] [ Tag1 ] [ Len1 ] [ Tag2] [ Len2 ] [...]
940 : : *
941 : : * 2 B Len1 B Len2 B
942 : : * [ V-Len ] [ Value 1 ] [ Value 2 ] [...]
943 : : * */
944 : :
945 : : /* Tag+Len buffer */
946 : 11 : buffer[0].value.value = certinfo;
947 : 11 : buffer[1].value.value = (unsigned char *)cert;
948 : 11 : buffer[2].value.value = NULL;
949 : 11 : buffer[3].value.value = NULL;
950 : : /* Ex:
951 : : * 0A 00 Length of whole buffer
952 : : * 71 Tag: CertInfo
953 : : * 01 Length: 1B
954 : : * 70 Tag: Certificate
955 : : * FF B2 03 Length: (\x03 << 8) || \xB2
956 : : * 72 Tag: MSCUID
957 : : * 26 Length
958 : : */
959 : 11 : applet_private->tag_buffer_len = cac_create_tl_file(buffer, buffer_len,
960 : : &applet_private->tag_buffer);
961 [ - + ]: 11 : if (applet_private->tag_buffer_len == 0) {
962 : 0 : goto failure;
963 : : }
964 : 11 : g_debug("%s: applet_private->tag_buffer = %s", __func__,
965 : : hex_dump(applet_private->tag_buffer, applet_private->tag_buffer_len));
966 : :
967 : : /* Value buffer */
968 : : /* Ex:
969 : : * DA 03 Length of complete buffer
970 : : * 01 Value of CertInfo
971 : : * 78 [..] 6C Cert Value
972 : : * 7B 63 37 35 62 62 61 64 61 2D 35 32 39 38 2D 31
973 : : * 37 35 62 2D 39 32 64 63 2D 39 38 35 30 36 62 65
974 : : * 30 30 30 30 30 7D MSCUID Value
975 : : */
976 : 11 : applet_private->val_buffer_len = cac_create_val_file(buffer, buffer_len,
977 : : &applet_private->val_buffer);
978 [ - + ]: 11 : if (applet_private->val_buffer_len == 0) {
979 : 0 : goto failure;
980 : : }
981 : 11 : g_debug("%s: applet_private->val_buffer = %s", __func__,
982 : : hex_dump(applet_private->val_buffer, applet_private->val_buffer_len));
983 : :
984 : : /* Inject Object ID */
985 : 11 : object_id[1] = i;
986 : 11 : pki_object[0].value.value = object_id;
987 : :
988 : : /* Create Object ID list */
989 : 11 : applet_private->coids = g_malloc(sizeof(struct coid));
990 : 11 : memcpy(applet_private->coids[0].v, object_id, 2);
991 : 11 : applet_private->coids_len = 1;
992 : :
993 : : /* Inject T-Buffer and V-Buffer lengths in the properties buffer */
994 : 11 : ushort2lebytes(&buffer_properties[1], applet_private->tag_buffer_len);
995 : 11 : ushort2lebytes(&buffer_properties[3], applet_private->val_buffer_len);
996 : 11 : pki_object[1].value.value = buffer_properties;
997 : :
998 : : /* PKI properties needs adjustments based on the key sizes */
999 : 11 : bits = vcard_emul_rsa_bits(key);
1000 : 11 : g_debug("RSA bits = %d", bits);
1001 [ + - ]: 11 : if (bits > 0)
1002 : 11 : pki_properties[1] = 0xff & (bits / 8 / 8);
1003 : 11 : pki_object[2].value.value = pki_properties;
1004 : 11 : pki_object[3].value.value = buffer_26;
1005 : :
1006 : : /* Inject Applet Version */
1007 : 11 : properties[0].value.value = applet_information;
1008 : 11 : properties[1].value.value = number_objects;
1009 : 11 : properties[2].value.child = pki_object;
1010 : 11 : properties[3].value.value = buffer_39;
1011 : 11 : properties[4].value.value = aca_aid;
1012 : :
1013 : : /* Clone the properties */
1014 : 11 : applet_private->properties_len = 3;
1015 : 11 : applet_private->long_properties_len = properties_len;
1016 : 11 : applet_private->properties = simpletlv_clone(properties,
1017 : : applet_private->long_properties_len);
1018 [ - + ]: 11 : if (applet_private->properties == NULL) {
1019 : 0 : goto failure;
1020 : : }
1021 : 11 : pki_applet_data->key = key;
1022 : 11 : return applet_private;
1023 : :
1024 : 0 : failure:
1025 : 0 : cac_delete_pki_applet_private(applet_private);
1026 : 0 : return NULL;
1027 : : }
1028 : :
1029 : : /*
1030 : : * Other applets breakdown:
1031 : : *
1032 : : * A00000007902FB: ??? (generic container ??)
1033 : : * $ opensc-tool -s 00A4040007A00000007902FB -s 8056010000
1034 : : * PROPERTIES:
1035 : : * 01 05
1036 : : * 10 02 06 01 00
1037 : : * 40 01
1038 : : * 01
1039 : : * 50 0B
1040 : : * 41 02
1041 : : * 02 FB
1042 : : * 42 05
1043 : : * 01 <-- Inidicates that this is not SimpleTLV ?
1044 : : * 62 00 60 01
1045 : : * $ opensc-tool -s 00A4040007A00000007902FB -s 8052000002010202
1046 : : * $ opensc-tool -s 00A4040007A00000007902FB -s 8052000002020202
1047 : : * TAG, VALUE BUFFER:
1048 : : * empty
1049 : : *
1050 : : * A00000007902FE: PKI Certificate
1051 : : * $ opensc-tool -s 00A4040007A00000007902FE -s 8056010000
1052 : : * PROPERTIES:
1053 : : * 01 05
1054 : : * 10 02 06 02 03
1055 : : * 40 01
1056 : : * 01
1057 : : * 50 0B
1058 : : * 41 02
1059 : : * 02 FE
1060 : : * 42 05
1061 : : * 01 <-- Indicates that this is not SimpleTLV, but what?
1062 : : * B2 00 30 02
1063 : : * $ opensc-tool -s 00A4040007A00000007902FE -s 8052000002010202
1064 : : * $ opensc-tool -s 00A4040007A00000007902FE -s 8052000002020202
1065 : : * TAG BUFFER:
1066 : : * 36 00 <-- length
1067 : : * 00 00 14 01 DC 0B 00 00 14 01 DD 03 00 00 14 01 72 29
1068 : : * 01 00 14 01 DC 0B 01 00 14 01 DD 03 01 00 14 01 72 29
1069 : : * 02 00 14 01 DC 0B 02 00 14 01 DD 03 02 00 14 01 72 29
1070 : : * [ID?][same] [ID?][same] [ID?][same]
1071 : : *
1072 : : * VALUE BUFFER:
1073 : : * A5 00
1074 : : * 00 C8 C8 CE <-- same
1075 : : * A0 00 00 00 79 01 00 <-- PKI Applet AID
1076 : : * 00 01 00 <-- OID ???
1077 : : * 00 01 01 <-- same
1078 : : * 7B 62 30 37 39 32 32 64 61 2D 35 30 30 30 2D 31
1079 : : * 30 37 39 2D 39 32 64 39 2D 39 38 35 30 36 62 65
1080 : : * 30 30 30 30 30 7D <-- MSCUID ???
1081 : : *
1082 : : * 00 C8 C8 CE
1083 : : * A0 00 00 00 79 01 01
1084 : : * 00 01 01
1085 : : * 00 01 01
1086 : : * 7B 63 35 36 33 65 35 31 38 2D 34 32 63 31 2D 31
1087 : : * 35 36 33 2D 39 32 64 62 2D 39 38 35 30 36 62 65
1088 : : * 30 30 30 30 30 7D
1089 : : *
1090 : : * 00 C8 C8 CE
1091 : : * A0 00 00 00 79 01 02
1092 : : * 00 01 02
1093 : : * 00 01 01
1094 : : * 7B 64 37 62 33 63 38 63 38 2D 31 32 63 38 2D 31
1095 : : * 37 62 33 2D 39 32 64 64 2D 39 38 35 30 36 62 65
1096 : : * 30 30 30 30 30 7D
1097 : : *
1098 : : * Read from OpenSC PKCS#11:
1099 : : * XXX TODO OpenSC criples the data while attempting to parse it as a SimpleTLV buffers
1100 : : * 1401 << TL
1101 : : * 00 << V
1102 : : * DC0B << TL
1103 : : * C8 << V
1104 : : * C8CE << TL
1105 : : * A000000079010000140101DD03000001
1106 : : * 14010172297B62303739323264612D35
1107 : : * 3030302D313037392D393264392D3938
1108 : : * 353036626530303030307D00C8C80100
1109 : : * 1401CEDC0BA000000079010100010100
1110 : : * 0100140101DD03017B63010014013572
1111 : : * 293633653531382D343263312D313536
1112 : : * 332D393264622D393835303662653030
1113 : : * 3030307D00C8C8CEA0000200140100DC
1114 : : * 0B007901020001020001017B02001401
1115 : : * 64DD0337623302001401630000000000
1116 : : * 00000000000000000000000000000000
1117 : : * 00000000000000000000000000000000
1118 : : * 000000 << V
1119 : : *
1120 : : *
1121 : : * A00000007902FD: PKI Credential
1122 : : * $ opensc-tool -s 00A4040007A00000007902FD -s 8056010000
1123 : : * PROPERTIES:
1124 : : * 01 05
1125 : : * 10 02 06 02 03
1126 : : * 40 01
1127 : : * 01
1128 : : * 50 0B
1129 : : * 41 02
1130 : : * 02 FD
1131 : : * 42 05
1132 : : * 01 <-- Inidicates that this is not SimpleTLV ?
1133 : : * B2 00 58 07
1134 : : * $ opensc-tool -s 00A4040007A00000007902FD -s 8052000002010202
1135 : : * $ opensc-tool -s 00A4040007A00000007902FD -s00200000083737373737373737 -s 8052000002020202
1136 : : * TAG BUFFER:
1137 : : * 12 00
1138 : : * 00 00 14 01 64 A5
1139 : : * 01 00 14 01 64 A5
1140 : : * 02 00 14 01 64 B9
1141 : : *
1142 : : * VALUE BUFFER (after login):
1143 : : * 03 02
1144 : : * 00 02 01 00 00 14 00 00 00 CF 12 87 F7 D0 6B 10
1145 : : * 09 EF D5 A7 01 50 48 0D 44 60 7A 2E EC 20 01 00
1146 : : * 00 80 00 00 00 A9 A3 31 FA 76 D2 19 03 89 B8 6A
1147 : : * 7F 3C 06 EE DC 50 44 18 79 F1 F6 8B B1 A3 29 E8
1148 : : * 71 7A 39 4D 25 F6 0D 97 15 C6 D9 A3 34 AC E3 6B
1149 : : * 36 F6 F9 50 0C A9 ED 99 8B A9 0A EF EC 47 0B 46
1150 : : * 17 FE 4E 71 08 57 88 5D 76 F1 42 8F B9 77 43 2F
1151 : : * C7 80 AC F6 57 58 CB 1F 6F 3A 72 A3 8C 8A E2 8E
1152 : : * 63 5B C6 65 5F 37 9A 75 18 39 3B 32 35 A0 19 6E
1153 : : * 95 1D 86 A8 C4 AF E9 FC 0F 89 5D B0 98 EF C7 57
1154 : : * A5 8E A6 A7 39
1155 : : * 00 02 01 00 00 14 00 00 00 17 61 A8 36 F7 6D C8
1156 : : * 91 2D 8B 45 95 02 D7 8F E0 5C 5B A3 2A 20 01 00
1157 : : * 00 80 00 00 00 BF 8C CB 0B D0 9E 6A 70 18 45 1B
1158 : : * A8 2D B5 09 17 8B 1F AF 73 75 23 7B 33 A0 6D 5A
1159 : : * 8D 50 38 E8 1E 7B 5D 27 BD 72 A7 9A 60 BD F6 07
1160 : : * 19 C2 92 7A 64 F1 EF A6 AC AD 1A 12 6F 46 94 DA
1161 : : * D9 C4 BC B0 23 31 BC 29 88 19 3C E3 8F DB F2 64
1162 : : * 41 F2 B0 79 7B CC B1 AC E3 26 1D E3 7C 8C 3C 29
1163 : : * DD B2 41 58 F6 35 47 46 AE A8 D0 F2 AA 5F 7B 89
1164 : : * B5 D8 53 1C 5F FC EE 41 C8 5B B2 C6 64 33 63 30
1165 : : * F1 70 FA D4 C9
1166 : : * 00 02 01 00 00 28 00 00 00 37 36 30 33 31 37 43
1167 : : * 37 32 37 38 41 33 33 32 36 31 45 41 42 45 44 31
1168 : : * 34 44 39 37 31 42 37 34 46 32 31 46 45 43 45 45
1169 : : * 37 20 01 00 00 80 00 00 00 C6 18 34 B8 64 DF BF
1170 : : * 07 1D 1A 3C A2 81 2D 6E 63 FA 60 C2 D6 9F 28 8B
1171 : : * D8 FD 2B B4 E7 03 E2 75 D3 81 DB 24 A7 D5 14 D5
1172 : : * B6 C2 65 9F 14 40 A5 78 DB 15 79 A4 69 22 6F 9A
1173 : : * 83 A8 FC BF 39 D0 89 B5 21 1B 11 D7 31 2E 4C E9
1174 : : * B2 03 F8 74 3B EC B1 E1 6E 89 7D C1 32 82 16 B0
1175 : : * 53 36 90 B0 79 BF 4C F5 3E E1 9D 54 A9 AD 8B F5
1176 : : * 01 F1 39 55 D8 F3 AC 47 9A 7F 73 3D 3E C0 AE 65
1177 : : * F3 2B 60 F3 07 06 3D 61 5B
1178 : : *
1179 : : *
1180 : : * A0000000790200: Person Instance (D.1 CAC Data Model Specific)
1181 : : * $ opensc-tool -s 00A4040007A0000000790200 -s 8056010000
1182 : : * PROPERTIES:
1183 : : * 01 05
1184 : : * 10 02 06 02 03
1185 : : * 40 01
1186 : : * 01
1187 : : * 50 0B
1188 : : * 41 02
1189 : : * 02 00
1190 : : * 42 05
1191 : : * 00 42 00 42 01
1192 : : * $ opensc-tool -s 00A4040007A0000000790200 -s 8052000002010202
1193 : : * $ opensc-tool -s 00A4040007A0000000790200 -s 8052000002020202
1194 : : * TAG BUFFER:
1195 : : * 20 00
1196 : : * 01 05
1197 : : * 02 00
1198 : : * 03 06
1199 : : * 04 00
1200 : : * 05 09
1201 : : * 06 08
1202 : : * 07 01
1203 : : * 08 01
1204 : : * 11 01
1205 : : * 17 0A
1206 : : * 18 01
1207 : : * 62 08
1208 : : * 65 08
1209 : : * 63 08
1210 : : * 66 08
1211 : : * 67 01
1212 : : * VALUE BUFFER:
1213 : : * 4B 00
1214 : : * 4D 61 72 69 65 Person First Name
1215 : : * 54 75 72 6E 65 72 Person Last Name
1216 : : * 38 37 36 30 32 30 30 33 35 Person Identifier
1217 : : * 31 39 37 30 30 34 30 32 Date of Birth
1218 : : * 46 Sex Category Code
1219 : : * 54 Person Identifier Type Code
1220 : : * 39 Blood Type Code
1221 : : * 31 30 30 31 32 37 37 33 39 38 DoD EDI Person Identifier
1222 : : * 5A Organ Donor
1223 : : * 32 30 30 39 30 34 30 32 Identification Card Issue Date
1224 : : * 32 30 30 39 30 34 30 32 Date Demographic Data was Loaded on
1225 : : * 32 30 31 32 30 34 30 31 Identification Card Expiration Date
1226 : : * 32 30 31 32 30 34 30 31 Date Demographic Data on Chip Expires
1227 : : * 55 Card Instance Identifier
1228 : : *
1229 : : * For real cards, we could try to proxy this from original card,
1230 : : * OpenSC exposes this as a data object as SimpleLTV merged in one buffer
1231 : : * $ pkcs11-tool --login --read-object --application-label 'Person Instance' --type data
1232 : : * 01 05
1233 : : * 4d 61 72 69 65
1234 : : * 02 00
1235 : : * 03 06
1236 : : * 54 75 72 6e 65 72
1237 : : * 04 00
1238 : : * 05 09
1239 : : * 38 37 36 30 32 30 30 33 35
1240 : : * 06 08
1241 : : * 31 39 37 30 30 34 30 32
1242 : : * 07 01
1243 : : * 46
1244 : : * 08 01
1245 : : * 54
1246 : : * 11 01
1247 : : * 39
1248 : : * 17 0a
1249 : : * 31 30 30 31 32 37 37 33 39 38
1250 : : * 18 01
1251 : : * 5a
1252 : : * 62 08
1253 : : * 32 30 30 39 30 34 30 32
1254 : : * 65 08
1255 : : * 32 30 30 39 30 34 30 32
1256 : : * 63 08
1257 : : * 32 30 31 32 30 34 30 31
1258 : : * 66 08
1259 : : * 32 30 31 32 30 34 30 31
1260 : : * 2e 31 30 <-- this is also broken in OpenSC
1261 : : * should be
1262 : : * 67 01 55
1263 : : *
1264 : : *
1265 : : * A0000000790201: Personnel (D.1 CAC Data Model Specific)
1266 : : * $ opensc-tool -s 00A4040007A0000000790201 -s 8056010000
1267 : : * PROPERTIES:
1268 : : * 01 05
1269 : : * 10 02 06 02 03
1270 : : * 40 01
1271 : : * 01
1272 : : * 50 0B
1273 : : * 41 02
1274 : : * 02 01
1275 : : * 42 05
1276 : : * 00 22 00 62 00
1277 : : *
1278 : : * $ opensc-tool -s 00A4040007A0000000790201 -s 8052000002010202
1279 : : * $ opensc-tool -s 00A4040007A0000000790201 -s 8052000002020202
1280 : : * TAG BUFFER:
1281 : : * 16 00
1282 : : * 19 00
1283 : : * 20 00
1284 : : * 35 00
1285 : : * 24 01
1286 : : * 25 02
1287 : : * 26 04
1288 : : * 34 01
1289 : : * 36 02
1290 : : * D3 02
1291 : : * D4 00
1292 : : * D5 00
1293 : : * VALUE BUFFER:
1294 : : * 0C 00
1295 : : * 4E Branch of Service Code
1296 : : * 30 31 Pay Grade Code
1297 : : * 57 4F 2D 31 Rank Code
1298 : : * 41 Personnel Category Code
1299 : : * 4D 57 Pay Plan Code
1300 : : * 30 30 Personnel Entitlement Condition Code
1301 : : *
1302 : : * pkcs11-tool --pin 77777777 --read-object --application-label 'Personnel' --type data
1303 : : * OpenSC exposes this as a data object as SimpleLTV merged in one buffer:
1304 : : * 19 00
1305 : : * 20 00
1306 : : * 35 00
1307 : : * 24 01
1308 : : * 4e
1309 : : * 25 02
1310 : : * 30 31
1311 : : * 26 04
1312 : : * 57 4f 2d 31
1313 : : * 34 01
1314 : : * 41
1315 : : * 36 02
1316 : : * 4d 57
1317 : : * d3 02
1318 : : * 30 30
1319 : : * 00 00 fc bf <<< OpenSC bug (junk in the end instead of last encoded elements)
1320 : : *
1321 : : *
1322 : : *
1323 : : *
1324 : : * A0000000791201: Empty
1325 : : * $ opensc-tool -s 00A4040007A0000000791201 -s 8056010000
1326 : : * PROPERTIES:
1327 : : * 01 05
1328 : : * 10 02 06 02 03
1329 : : * 40 01
1330 : : * 01
1331 : : * 50 0B
1332 : : * 41 02
1333 : : * 12 01
1334 : : * 42 05
1335 : : * 00 42 02 C0 05
1336 : : * $ opensc-tool -s 00A4040007A0000000791201 -s 8052000002010202
1337 : : * $ opensc-tool -s 00A4040007A0000000791201 -s 8052000002020202
1338 : : * TAG, VALUE BUFFERS:
1339 : : * empty
1340 : : *
1341 : : * A0000000791202: Empty
1342 : : * $ opensc-tool -s 00A4040007A0000000791202 -s 8056010000
1343 : : * PROPERTIES:
1344 : : * 01 05
1345 : : * 10 02 06 02 03
1346 : : * 40 01
1347 : : * 01
1348 : : * 50 0B
1349 : : * 41 02
1350 : : * 12 02
1351 : : * 42 05
1352 : : * 00 42 01 40 06
1353 : : * $ opensc-tool -s 00A4040007A0000000791202 -s 8052000002010202
1354 : : * $ opensc-tool -s 00A4040007A0000000791202 -s 8052000002020202
1355 : : * TAG, VALUE BUFFERS:
1356 : : * empty
1357 : : *
1358 : : * A00000007902F0: Empty (no buffers)
1359 : : * $ opensc-tool -s 00A4040007A00000007902F0 -s 8056010000
1360 : : * PROPERTIES:
1361 : : * 01 05
1362 : : * 10 02 06 02 03
1363 : : * 40 01
1364 : : * 00
1365 : : *
1366 : : * A00000007902F1: Empty (no buffers)
1367 : : * $ opensc-tool -s 00A4040007A00000007902F1 -s 8056010000
1368 : : * PROPERTIES:
1369 : : * 01 05
1370 : : * 10 02 06 02 03
1371 : : * 40 01
1372 : : * 00
1373 : : *
1374 : : * A00000007902F2: Empty (no buffers)
1375 : : * $ opensc-tool -s 00A4040007A00000007902F2 -s 8056010000
1376 : : * PROPERTIES:
1377 : : * 01 05
1378 : : * 10 02 06 02 03
1379 : : * 40 01
1380 : : * 00
1381 : : *
1382 : : *
1383 : : * Access Control File
1384 : : * A0000001163000
1385 : : * PROPERTIES: shared among the OIDs
1386 : : * 01 05
1387 : : * 10 02 06 02 03
1388 : : * 40 01 Number of objects
1389 : : * 04
1390 : : * 50 0B TV Buffer
1391 : : * 41 02 Object ID
1392 : : * 30 00
1393 : : * 42 05
1394 : : * 00 <- These are SimpleTLV
1395 : : * 1A 00 D2 07
1396 : : * 50 0B TV Buffer
1397 : : * 41 02 Object ID
1398 : : * 60 10
1399 : : * 42 05
1400 : : * 00
1401 : : * 0E 00 BA 0B
1402 : : * 50 0B TV buffer
1403 : : * 41 02 Object ID
1404 : : * 60 30
1405 : : * 42 05
1406 : : * 00
1407 : : * 0A 00 EE 2C
1408 : : * 50 0B TV Buffer
1409 : : * 41 02 Object ID
1410 : : * 90 00
1411 : : * 42 05
1412 : : * 00
1413 : : * 0E 00 4E 04
1414 : : *
1415 : : * OID buffers (from NIST SP 800-73-4)
1416 : : * :3000: Card Holder Unique Identifier
1417 : : * Tag buffer:
1418 : : * 0C 00
1419 : : * 30 19 FASC
1420 : : * 34 10 GUID
1421 : : * 35 08 Expiration Date
1422 : : * 3E FF 1A 06 Issuer Asymmetric Signature
1423 : : * FE 00 Error detection code
1424 : : * Value buffer:
1425 : : * D4 F8 10 DA 08 26 6C 10 A2 04 E5 83 60 DA 01 0C
1426 : : * 11 CE 66 62 84 38 10 93 E1 <-- SEIWG data
1427 : : *
1428 : : * :6010: Cardholder Fingerprints
1429 : : * Tag buffer:
1430 : : * 06 00
1431 : : * BC FF CF 04 Fingerprint I & II
1432 : : * FE 00 Error Detection Code
1433 : : *
1434 : : * :6030: Cardholder Facial Image
1435 : : * Tag buffer:
1436 : : * 06 00
1437 : : * BC FF A9 29 Image for Visual Verification
1438 : : * FE 00 Error Detection Code
1439 : : *
1440 : : * :9000: Security Object
1441 : : * 08 00
1442 : : * BB FF 38 02 Security Object
1443 : : * BA 30 Mapping of DG to ContainerID
1444 : : * FE 00 Error Detectionc Code
1445 : : *
1446 : : * we should do this as passthrough too
1447 : : */
1448 : :
1449 : :
1450 : : static VCardAppletPrivate *
1451 : 5 : cac_new_ccc_applet_private(int cert_count)
1452 : : {
1453 : : VCardAppletPrivate *applet_private = NULL;
1454 : :
1455 : : /* CCC applet Properties ex.:
1456 : : * 01 Tag: Applet Information
1457 : : * 05 Length
1458 : : * 10 Applet family
1459 : : * 02 06 02 03 Applet version
1460 : : * 40 Tag: Number of objects managed by this instance
1461 : : * 01 Length
1462 : : * 01 One
1463 : : * 50 Tag: First TV-Buffer Object
1464 : : * 0B Length
1465 : : * 41 Tag: ObjectID
1466 : : * 02 Length
1467 : : * DB 00
1468 : : * 42 Tag: Buffer Properties
1469 : : * 05 Length
1470 : : * 00 Type of Tag Supported
1471 : : * F6 00 T-Buffer length (LSB, MSB)
1472 : : * 04 02 V-Buffer length (LSB, MSB)
1473 : : */
1474 : : static unsigned char object_id[] = "\xDB\x00";
1475 : : static unsigned char buffer_properties[] = "\x00\x00\x00\x00\x00";
1476 : : static unsigned char buffer_26[] = "\x01";
1477 : : static struct simpletlv_member tv_object[3] = {
1478 : : {CAC_PROPERTIES_OBJECT_ID, 2, {/*.value = object_id*/},
1479 : : SIMPLETLV_TYPE_LEAF},
1480 : : {CAC_PROPERTIES_BUFFER_PROPERTIES, 5, {/*.value = buffer_properties*/},
1481 : : SIMPLETLV_TYPE_LEAF},
1482 : : {0x26, 0x01, {/*.value = buffer_26*/}, SIMPLETLV_TYPE_LEAF},
1483 : : };
1484 : : static unsigned char applet_information[] = "\x10\x02\x06\x02\x03";
1485 : : static unsigned char number_objects[] = "\x01";
1486 : : static unsigned char buffer_39[] = "\x00";
1487 : : static unsigned char aca_aid[] = "\xA0\x00\x00\x00\x79\x03\x00";
1488 : : static struct simpletlv_member properties[] = {
1489 : : {CAC_PROPERTIES_APPLET_INFORMATION, 5, {/*.value = applet_information*/},
1490 : : SIMPLETLV_TYPE_LEAF},
1491 : : {CAC_PROPERTIES_NUMBER_OBJECTS, 1, {/*.value = number_objects */},
1492 : : SIMPLETLV_TYPE_LEAF},
1493 : : {CAC_PROPERTIES_TV_OBJECT, 2, {/*.child = tv_object*/},
1494 : : SIMPLETLV_TYPE_COMPOUND},
1495 : : {0x39, 0x01, {/*.child = buffer_39*/}, SIMPLETLV_TYPE_LEAF},
1496 : : {0x3A, 0x07, {/*.child = aca_aid*/}, SIMPLETLV_TYPE_LEAF},
1497 : : };
1498 : : size_t properties_len = sizeof(properties)/sizeof(struct simpletlv_member);
1499 : :
1500 : 5 : unsigned char card_identifier[] = "\xA0\x00\x00\x00\x79\x03\x02\x40\x70\x50"
1501 : : "\x72\x36\x0E\x00\x00\x58\xBD\x00\x2C\x19\xB5";
1502 : 5 : unsigned char cc_version[] = "\x21";
1503 : 5 : unsigned char cg_version[] = "\x21";
1504 : 5 : unsigned char cardurl[21][16] = {
1505 : : /* common CardURLs */
1506 : : "\xA0\x00\x00\x00\x79\x01\x02\xFB\x02\xFB\x00\x00\x00\x00\x00\x00", /* ??? */
1507 : : "\xA0\x00\x00\x00\x79\x01\x02\xFE\x02\xFE\x00\x00\x00\x00\x00\x00", /* PKI Certificate */
1508 : : "\xA0\x00\x00\x00\x79\x01\x02\xFD\x02\xFD\x00\x00\x00\x00\x00\x00", /* PKI Credential */
1509 : : "\xA0\x00\x00\x00\x79\x01\x02\x00\x02\x00\x00\x00\x00\x00\x00\x00", /* Person Instance */
1510 : : "\xA0\x00\x00\x00\x79\x01\x02\x01\x02\x01\x00\x00\x00\x00\x00\x00", /* Personel */
1511 : : "\xA0\x00\x00\x01\x16\x01\x30\x00\x30\x00\x00\x00\x00\x00\x00\x00", /* Access Control F. */
1512 : : "\xA0\x00\x00\x01\x16\x01\x60\x10\x30\x00\x00\x00\x00\x00\x00\x00", /* -//- */
1513 : : "\xA0\x00\x00\x01\x16\x01\x60\x30\x30\x00\x00\x00\x00\x00\x00\x00", /* -//- */
1514 : : "\xA0\x00\x00\x01\x16\x01\x90\x00\x30\x00\x00\x00\x00\x00\x00\x00", /* -//- */
1515 : : "\xA0\x00\x00\x00\x79\x01\x12\x01\x12\x01\x00\x00\x00\x00\x00\x00", /* ?? */
1516 : : "\xA0\x00\x00\x00\x79\x01\x12\x02\x12\x02\x00\x00\x00\x00\x00\x00", /* ?? */
1517 : : /* dynamic list of all possible PKI objects CardURLs */
1518 : : "\xA0\x00\x00\x00\x79\x04\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00", /* PKI */
1519 : : "\xA0\x00\x00\x00\x79\x04\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00", /* PKI */
1520 : : "\xA0\x00\x00\x00\x79\x04\x01\x02\x01\x02\x00\x00\x00\x00\x00\x00", /* PKI */
1521 : : "\xA0\x00\x00\x00\x79\x04\x01\x03\x01\x03\x00\x00\x00\x00\x00\x00", /* PKI */
1522 : : "\xA0\x00\x00\x00\x79\x04\x01\x04\x01\x04\x00\x00\x00\x00\x00\x00", /* PKI */
1523 : : "\xA0\x00\x00\x00\x79\x04\x01\x05\x01\x05\x00\x00\x00\x00\x00\x00", /* PKI */
1524 : : "\xA0\x00\x00\x00\x79\x04\x01\x06\x01\x06\x00\x00\x00\x00\x00\x00", /* PKI */
1525 : : "\xA0\x00\x00\x00\x79\x04\x01\x07\x01\x07\x00\x00\x00\x00\x00\x00", /* PKI */
1526 : : "\xA0\x00\x00\x00\x79\x04\x01\x08\x01\x08\x00\x00\x00\x00\x00\x00", /* PKI */
1527 : : "\xA0\x00\x00\x00\x79\x04\x01\x09\x01\x09\x00\x00\x00\x00\x00\x00", /* PKI */
1528 : : /*
1529 : : * [ Empty for VM cards! ]
1530 : : * [ RID 5B ][T ][ OID ][ AID ] [ P][AccessKeyInfo ][ K]
1531 : : * CardApplicationType-^ ^ ^- Pin ID ^
1532 : : * AccessProfile is empty --------------' |
1533 : : * Key Crypto Algorithm ---------------------------------------'
1534 : : *
1535 : : * AID -- the "address" of the container
1536 : : * Object ID = object type
1537 : : *
1538 : : * 7.3 The Applications CardURL
1539 : : */
1540 : : };
1541 : 5 : unsigned char pkcs15[] = "\x00";
1542 : : /* NIST SP 800-73-4: The data model of the PIV Card Application shall
1543 : : * be identified by data model number 0x10 */
1544 : 5 : unsigned char reg_data_model[] = "\x10";
1545 : 5 : unsigned char acr_table[] = "\x07\xA0\x00\x00\x00\x79\x03\x00\x00\x00\x00"
1546 : : "\x00\x00\x00\x00\x00\x00";
1547 : : static struct simpletlv_member buffer[] = {
1548 : : {CAC_CCC_CARD_IDENTIFIER, 0x15, {/*.value = card_identifier*/},
1549 : : SIMPLETLV_TYPE_LEAF},
1550 : : {CAC_CCC_CAPABILITY_CONTAINER_VERSION, 1, {/*.value = cc_version*/},
1551 : : SIMPLETLV_TYPE_LEAF},
1552 : : {CAC_CCC_CAPABILITY_GRAMMAR_VERSION, 1, {/*.value = cg_version*/},
1553 : : SIMPLETLV_TYPE_LEAF},
1554 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[0]*/},
1555 : : SIMPLETLV_TYPE_LEAF},
1556 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[1]*/},
1557 : : SIMPLETLV_TYPE_LEAF},
1558 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[2]*/},
1559 : : SIMPLETLV_TYPE_LEAF},
1560 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[3]*/},
1561 : : SIMPLETLV_TYPE_LEAF},
1562 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[4]*/},
1563 : : SIMPLETLV_TYPE_LEAF},
1564 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[5]*/},
1565 : : SIMPLETLV_TYPE_LEAF},
1566 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[6]*/},
1567 : : SIMPLETLV_TYPE_LEAF},
1568 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[7]*/},
1569 : : SIMPLETLV_TYPE_LEAF},
1570 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[8]*/},
1571 : : SIMPLETLV_TYPE_LEAF},
1572 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[9]*/},
1573 : : SIMPLETLV_TYPE_LEAF},
1574 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[10]*/},
1575 : : SIMPLETLV_TYPE_LEAF},
1576 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[11]*/},
1577 : : SIMPLETLV_TYPE_NONE},
1578 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[12]*/},
1579 : : SIMPLETLV_TYPE_NONE},
1580 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[13]*/},
1581 : : SIMPLETLV_TYPE_NONE},
1582 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[14]*/},
1583 : : SIMPLETLV_TYPE_NONE},
1584 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[15]*/},
1585 : : SIMPLETLV_TYPE_NONE},
1586 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[16]*/},
1587 : : SIMPLETLV_TYPE_NONE},
1588 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[17]*/},
1589 : : SIMPLETLV_TYPE_NONE},
1590 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[18]*/},
1591 : : SIMPLETLV_TYPE_NONE},
1592 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[19]*/},
1593 : : SIMPLETLV_TYPE_NONE},
1594 : : {CAC_CCC_APPLICATION_CARDURL, 16, {/*.value = cardurl[20]*/},
1595 : : SIMPLETLV_TYPE_NONE},
1596 : : {CAC_CCC_PKCS15, 1, {/*.value = pkcs15 */},
1597 : : SIMPLETLV_TYPE_LEAF},
1598 : : {CAC_CCC_REGISTERED_DATA_MODEL_NUMBER, 1, {/*.value = reg_data_model */},
1599 : : SIMPLETLV_TYPE_LEAF},
1600 : : {CAC_CCC_ACCESS_CONTROL_RULE_TABLE, 17, {/*.value = acr_table */},
1601 : : SIMPLETLV_TYPE_LEAF},
1602 : : {CAC_CCC_CARD_APDUS, 0, {}, SIMPLETLV_TYPE_LEAF},
1603 : : {CAC_CCC_REDIRECTION_TAG, 0, {}, SIMPLETLV_TYPE_LEAF},
1604 : : {CAC_CCC_CAPABILITY_TUPLES, 0, {}, SIMPLETLV_TYPE_LEAF},
1605 : : {CAC_CCC_STATUS_TUPLES, 0, {}, SIMPLETLV_TYPE_LEAF},
1606 : : {CAC_CCC_NEXT_CCC, 0, {}, SIMPLETLV_TYPE_LEAF},
1607 : : {CAC_CCC_ERROR_DETECTION_CODE, 0, {}, SIMPLETLV_TYPE_LEAF},
1608 : : };
1609 : : size_t buffer_len = sizeof(buffer)/sizeof(struct simpletlv_member);
1610 : : int i;
1611 : :
1612 : 5 : applet_private = g_new0(VCardAppletPrivate, 1);
1613 : :
1614 : : /* prepare the buffers to when READ_BUFFER will be called.
1615 : : * Assuming VM card with (LSB first if > 255)
1616 : : * separate Tag+Length, Value buffers as described in 8.4:
1617 : : * 2 B 1 B 1-3 B 1 B 1-3 B
1618 : : * [ T-Len ] [ Tag1 ] [ Len1 ] [ Tag2] [ Len2 ] [...]
1619 : : *
1620 : : * 2 B Len1 B Len2 B
1621 : : * [ V-Len ] [ Value 1 ] [ Value 2 ] [...]
1622 : : * */
1623 : :
1624 : 5 : buffer[0].value.value = card_identifier;
1625 : 5 : buffer[1].value.value = cc_version;
1626 : 5 : buffer[2].value.value = cg_version;
1627 : : /* common CardURLs */
1628 [ + + ]: 60 : for (i = 0; i < 11; i++) {
1629 : 55 : buffer[3+i].value.value = cardurl[i];
1630 : : }
1631 : :
1632 [ - + ]: 5 : if (cert_count > 10) {
1633 : : // XXX too many objects for now
1634 : 0 : g_debug("Too many PKI objects");
1635 : 0 : return NULL;
1636 : : }
1637 : : /* Generate card URLs for PKI applets */
1638 [ + + ]: 16 : for (i = 0; i < cert_count; i++) {
1639 : 11 : buffer[i+14].value.value = cardurl[i+11];
1640 : 11 : buffer[i+14].type = SIMPLETLV_TYPE_LEAF;
1641 : : }
1642 : :
1643 : 5 : buffer[24].value.value = pkcs15;
1644 : 5 : buffer[25].value.value = reg_data_model;
1645 : 5 : buffer[26].value.value = acr_table;
1646 : : /* CCC Tag+Len buffer */
1647 : : /* Ex:
1648 : : * 34 00 Length of complete buffer
1649 : : * F0 15 Card Identifier
1650 : : * F1 01 Capability Container version number
1651 : : * F2 01 Capability Grammar version number
1652 : : * F3 10 Applications CardURL
1653 : : * F3 10 Applications CardURL
1654 : : * F3 10 Applications CardURL
1655 : : * F3 10 Applications CardURL
1656 : : * F3 10 Applications CardURL
1657 : : * F3 10 Applications CardURL
1658 : : * F3 10 Applications CardURL
1659 : : * F3 10 Applications CardURL
1660 : : * F3 10 Applications CardURL
1661 : : * F3 10 Applications CardURL
1662 : : * F3 10 Applications CardURL
1663 : : * F3 10 Applications CardURL
1664 : : * F3 10 Applications CardURL
1665 : : * F3 10 Applications CardURL
1666 : : * F4 01 PKCS#15
1667 : : * F5 01 Registered Data Model number
1668 : : * F6 11 Access Control Rule Table
1669 : : * F7 00 CARD APDUs
1670 : : * FA 00 Redirection Tag
1671 : : * FB 00 Capability Tuples (CTs)
1672 : : * FC 00 Status Tuples (STs)
1673 : : * FD 00 Next CCC
1674 : : * FE 00 Error Detection Code
1675 : : */
1676 : 5 : applet_private->tag_buffer_len = cac_create_tl_file(buffer, buffer_len,
1677 : : &applet_private->tag_buffer);
1678 [ - + ]: 5 : if (applet_private->tag_buffer_len == 0)
1679 : 0 : goto failure;
1680 : 5 : g_debug("%s: applet_private->tag_buffer = %s", __func__,
1681 : : hex_dump(applet_private->tag_buffer, applet_private->tag_buffer_len));
1682 : :
1683 : : /* Value buffer */
1684 : : /* Ex:
1685 : : * 0A 01 Length of complete buffer
1686 : : * A0 00 00 00 79 03 02 40 70 50 72 36 0E 00 00 58 BD 00 2C 19 B5
1687 : : * [ GSC-RID ] [] [] [ Card ID ]
1688 : : * Manufacturer ID-' '- Card Type = javaCard
1689 : : * Card Identifier
1690 : : * 21 CC version
1691 : : * 21 Capability Grammar version
1692 : : * A0 00 00 00 79 01 02 FB 02 FB 00 00 00 00 00 00
1693 : : * A0 00 00 00 79 01 02 FE 02 FE 00 00 00 00 00 00
1694 : : * A0 00 00 00 79 01 02 FD 02 FD 00 00 00 00 00 00
1695 : : * A0 00 00 00 79 01 02 00 02 00 00 00 00 00 00 00
1696 : : * A0 00 00 00 79 01 02 01 02 01 00 00 00 00 00 00
1697 : : * A0 00 00 00 79 04 01 00 01 00 00 00 00 00 00 00
1698 : : * A0 00 00 00 79 04 01 01 01 01 00 00 00 00 00 00
1699 : : * A0 00 00 00 79 04 01 02 01 02 00 00 00 00 00 00
1700 : : * A0 00 00 01 16 01 30 00 30 00 00 00 00 00 00 00
1701 : : * A0 00 00 01 16 01 60 10 30 00 00 00 00 00 00 00
1702 : : * A0 00 00 01 16 01 60 30 30 00 00 00 00 00 00 00
1703 : : * A0 00 00 01 16 01 90 00 30 00 00 00 00 00 00 00
1704 : : * A0 00 00 00 79 01 12 01 12 01 00 00 00 00 00 00
1705 : : * A0 00 00 00 79 01 12 02 12 02 00 00 00 00 00 00
1706 : : * [ RID ] [] [OID] [AID] [ unused in VM? ]
1707 : : * Appl. Type -'
1708 : : * 0x01 generic
1709 : : * 0x02 ski
1710 : : * 0x04 pki
1711 : : * CardURLs
1712 : : * 00 PKCS#15
1713 : : * 10 Reg. data model number
1714 : : * 07 A0 00 00 00 79 03 00 00 00 00 00 00 00 00 00 00
1715 : : * [] [ ACA AID ] [ ???? ]
1716 : : * Access Control Rule table
1717 : : */
1718 : 5 : applet_private->val_buffer_len = cac_create_val_file(buffer, buffer_len,
1719 : : &applet_private->val_buffer);
1720 [ - + ]: 5 : if (applet_private->val_buffer_len == 0)
1721 : 0 : goto failure;
1722 : 5 : g_debug("%s: applet_private->val_buffer = %s", __func__,
1723 : : hex_dump(applet_private->val_buffer, applet_private->val_buffer_len));
1724 : :
1725 : : /* Inject Object ID */
1726 : 5 : tv_object[0].value.value = object_id;
1727 : :
1728 : : /* Create Object ID list */
1729 : 5 : applet_private->coids = g_malloc(sizeof(struct coid));
1730 : 5 : memcpy(applet_private->coids[0].v, object_id, 2);
1731 : 5 : applet_private->coids_len = 1;
1732 : :
1733 : : /* Inject T-Buffer and V-Buffer lengths in the properties buffer */
1734 : 5 : ushort2lebytes(&buffer_properties[1], applet_private->tag_buffer_len);
1735 : 5 : ushort2lebytes(&buffer_properties[3], applet_private->val_buffer_len);
1736 : 5 : tv_object[1].value.value = buffer_properties;
1737 : 5 : tv_object[2].value.value = buffer_26;
1738 : :
1739 : : /* Inject Applet Version */
1740 : 5 : properties[0].value.value = applet_information;
1741 : 5 : properties[1].value.value = number_objects;
1742 : 5 : properties[2].value.child = tv_object;
1743 : 5 : properties[3].value.value = buffer_39;
1744 : 5 : properties[4].value.value = aca_aid;
1745 : :
1746 : : /* Link the properties */
1747 : 5 : applet_private->properties = properties;
1748 : 5 : applet_private->properties_len = 3;
1749 : 5 : applet_private->long_properties_len = properties_len;
1750 : :
1751 : 5 : return applet_private;
1752 : :
1753 : 0 : failure:
1754 : 0 : cac_delete_ccc_applet_private(applet_private);
1755 : 0 : return NULL;
1756 : : }
1757 : :
1758 : :
1759 : : /*
1760 : : * create a new CCC applet
1761 : : */
1762 : : static VCardApplet *
1763 : 5 : cac_new_ccc_applet(int cert_count)
1764 : : {
1765 : : VCardAppletPrivate *applet_private;
1766 : : VCardApplet *applet;
1767 : :
1768 : 5 : applet_private = cac_new_ccc_applet_private(cert_count);
1769 [ - + ]: 5 : if (applet_private == NULL) {
1770 : 0 : goto failure;
1771 : : }
1772 : 5 : applet = vcard_new_applet(cac_common_process_apdu_read, NULL,
1773 : : cac_ccc_aid, sizeof(cac_ccc_aid));
1774 [ - + ]: 5 : if (applet == NULL) {
1775 : 0 : goto failure;
1776 : : }
1777 : 5 : vcard_set_applet_private(applet, applet_private,
1778 : : cac_delete_ccc_applet_private);
1779 : : applet_private = NULL;
1780 : :
1781 : 5 : return applet;
1782 : :
1783 : : failure:
1784 : : if (applet_private != NULL) {
1785 : 0 : cac_delete_ccc_applet_private(applet_private);
1786 : : }
1787 : : return NULL;
1788 : : }
1789 : :
1790 : : static VCardAppletPrivate *
1791 : 5 : cac_new_aca_applet_private(int cert_count)
1792 : : {
1793 : : CACACAAppletData *aca_applet_data = NULL;
1794 : : VCardAppletPrivate *applet_private = NULL;
1795 : :
1796 : : /* ACA applet Properties ex.:
1797 : : * 01 Tag: Applet Information
1798 : : * 05 Length
1799 : : * 10 Applet family
1800 : : * 02 06 02 02 Applet version
1801 : : */
1802 : :
1803 : : /* 0x40 Long properties (?):
1804 : : * 01 05 Applet Information
1805 : : * 10 02 06 02 02
1806 : : * 23 0C
1807 : : * 20 11 00 00 00 00 00 00 00 00 00 58
1808 : : * 2A 02
1809 : : * 02 00
1810 : : * 2B 05 RID ???
1811 : : * A0 00 00 00 79
1812 : : * 22 10
1813 : : * 00 00 00 DA 01 B4 03 30 00 00 00 70 00 51 02 9D
1814 : : * 2C 01
1815 : : * 00
1816 : : * 20 02
1817 : : * 08 01
1818 : : * 21 01
1819 : : * 0F
1820 : : * 32 04
1821 : : * 03 03 03 03
1822 : : * 30 01
1823 : : * 08
1824 : : * 31 04
1825 : : * 06 08 00 00
1826 : : * 24 01
1827 : : * FF
1828 : : * 25 02
1829 : : * 01 00
1830 : : * 26 01
1831 : : * 01
1832 : : */
1833 : :
1834 : : static unsigned char applet_information[] = "\x10\x02\x06\x02\x02";
1835 : : static unsigned char buffer_23[] = "\x20\x11\x00\x00\x00\x00\x00\x00\x00"
1836 : : "\x00\x00\x58";
1837 : : static unsigned char buffer_2A[] = "\x02\x00";
1838 : : static unsigned char rid[] = "\xA0\x00\x00\x00\x79";
1839 : : static unsigned char buffer_22[] = "\x00\x00\x00\xDA\x01\xB4\x03\x30\x00"
1840 : : "\x00\x00\x70\x00\x51\x02\x9D";
1841 : : static unsigned char buffer_2C[] = "\x00";
1842 : : static unsigned char buffer_20[] = "\x08\x01";
1843 : : static unsigned char buffer_21[] = "\x0F";
1844 : : static unsigned char buffer_32[] = "\x03\x03\x03\x03";
1845 : : static unsigned char buffer_30[] = "\x08";
1846 : : static unsigned char buffer_31[] = "\x06\x08\x00\x00";
1847 : : static unsigned char buffer_24[] = "\xFF";
1848 : : static unsigned char buffer_25[] = "\x01\x00";
1849 : : static unsigned char buffer_26[] = "\x01";
1850 : : static struct simpletlv_member properties[] = {
1851 : : {CAC_PROPERTIES_APPLET_INFORMATION, 5, {/*.value = applet_information*/},
1852 : : SIMPLETLV_TYPE_LEAF},
1853 : : {0x23, 0x0C, {/*.value = buffer_23*/}, SIMPLETLV_TYPE_LEAF},
1854 : : {0x2A, 0x02, {/*.value = buffer_2A*/}, SIMPLETLV_TYPE_LEAF},
1855 : : {0x2B, 0x05, {/*.value = rid*/}, SIMPLETLV_TYPE_LEAF},
1856 : : {0x22, 0x10, {/*.value = buffer_22*/}, SIMPLETLV_TYPE_LEAF},
1857 : : {0x2C, 0x01, {/*.value = buffer_2C*/}, SIMPLETLV_TYPE_LEAF},
1858 : : {0x20, 0x02, {/*.value = buffer_20*/}, SIMPLETLV_TYPE_LEAF},
1859 : : {0x21, 0x01, {/*.value = buffer_21*/}, SIMPLETLV_TYPE_LEAF},
1860 : : {0x32, 0x04, {/*.value = buffer_32*/}, SIMPLETLV_TYPE_LEAF},
1861 : : {0x30, 0x01, {/*.value = buffer_30*/}, SIMPLETLV_TYPE_LEAF},
1862 : : {0x31, 0x04, {/*.value = buffer_31*/}, SIMPLETLV_TYPE_LEAF},
1863 : : {0x24, 0x01, {/*.value = buffer_24*/}, SIMPLETLV_TYPE_LEAF},
1864 : : {0x25, 0x02, {/*.value = buffer_25*/}, SIMPLETLV_TYPE_LEAF},
1865 : : {0x26, 0x01, {/*.value = buffer_26*/}, SIMPLETLV_TYPE_LEAF},
1866 : : };
1867 : :
1868 : : /* Inject Applet Version into Applet information */
1869 : 5 : properties[0].value.value = applet_information;
1870 : 5 : properties[1].value.value = buffer_23;
1871 : 5 : properties[2].value.value = buffer_2A;
1872 : 5 : properties[3].value.value = rid;
1873 : 5 : properties[4].value.value = buffer_22;
1874 : 5 : properties[5].value.value = buffer_2C;
1875 : 5 : properties[6].value.value = buffer_20;
1876 : 5 : properties[7].value.value = buffer_21;
1877 : 5 : properties[8].value.value = buffer_32;
1878 : 5 : properties[9].value.value = buffer_30;
1879 : 5 : properties[10].value.value = buffer_31;
1880 : 5 : properties[11].value.value = buffer_24;
1881 : 5 : properties[12].value.value = buffer_25;
1882 : 5 : properties[13].value.value = buffer_26;
1883 : :
1884 : : /* Create the private data structure */
1885 : 5 : applet_private = g_new0(VCardAppletPrivate, 1);
1886 : : aca_applet_data = &(applet_private->u.aca_data);
1887 : :
1888 : : /* store the applet OID */
1889 : 5 : applet_private->coids = g_malloc(sizeof(struct coid));
1890 : 5 : applet_private->coids[0].v[0] = 0x03;
1891 : 5 : applet_private->coids[0].v[1] = 0x00;
1892 : 5 : applet_private->coids_len = 1;
1893 : :
1894 : : /* Link the properties */
1895 : 5 : applet_private->properties = properties;
1896 : 5 : applet_private->properties_len = 1;
1897 : 5 : applet_private->long_properties_len = 14;
1898 : :
1899 : 5 : aca_applet_data->pki_applets = cert_count;
1900 : :
1901 : 5 : return applet_private;
1902 : : }
1903 : :
1904 : : static VCardAppletPrivate *
1905 : 45 : cac_new_empty_applet_private(unsigned char objects[][2], unsigned int objects_len)
1906 : : {
1907 : : VCardAppletPrivate *applet_private = NULL;
1908 : :
1909 : 45 : unsigned char object_id[] = "\x00\x00";
1910 : 45 : unsigned char buffer_properties[] = "\x00\x00\x00\x00\x00";
1911 : : static unsigned char buffer_26[] = "\x01";
1912 : : static struct simpletlv_member tv_buffer[] = {
1913 : : {CAC_PROPERTIES_OBJECT_ID, 2, {/*.value = object_id*/},
1914 : : SIMPLETLV_TYPE_LEAF},
1915 : : {CAC_PROPERTIES_BUFFER_PROPERTIES, 5, {/*.value = buffer_properties*/},
1916 : : SIMPLETLV_TYPE_LEAF},
1917 : : {0x26, 0x01, {/*.value = buffer_26*/}, SIMPLETLV_TYPE_LEAF},
1918 : : };
1919 : 45 : unsigned char applet_information[] = "\x10\x02\x06\x02\x03";
1920 : 45 : unsigned char number_objects = 0;
1921 : : static struct simpletlv_member properties[7] = {
1922 : : {CAC_PROPERTIES_APPLET_INFORMATION, 5, {/*.value = applet_information*/},
1923 : : SIMPLETLV_TYPE_LEAF},
1924 : : {CAC_PROPERTIES_NUMBER_OBJECTS, 1, {/*.value = number_objects*/},
1925 : : SIMPLETLV_TYPE_LEAF},
1926 : : {CAC_PROPERTIES_TV_OBJECT, 3, {.child = NULL},
1927 : : SIMPLETLV_TYPE_COMPOUND},
1928 : : {CAC_PROPERTIES_TV_OBJECT, 3, {.child = NULL},
1929 : : SIMPLETLV_TYPE_COMPOUND},
1930 : : {CAC_PROPERTIES_TV_OBJECT, 3, {.child = NULL},
1931 : : SIMPLETLV_TYPE_COMPOUND},
1932 : : {CAC_PROPERTIES_TV_OBJECT, 3, {.child = NULL},
1933 : : SIMPLETLV_TYPE_COMPOUND},
1934 : : {CAC_PROPERTIES_TV_OBJECT, 3, {.child = NULL},
1935 : : SIMPLETLV_TYPE_COMPOUND},
1936 : : };
1937 : : unsigned properties_len = 2;
1938 : : unsigned int i;
1939 : :
1940 [ + + ]: 90 : for (i = 0; i < objects_len; i++) {
1941 : : /* Adjust Object ID based on the AID */
1942 : 45 : object_id[0] = objects[i][0];
1943 : 45 : object_id[1] = objects[i][1];
1944 : :
1945 : : /* Create arbitrary sized buffers */
1946 : 45 : buffer_properties[0] = 0x01; // not a SimpleTLV
1947 : 45 : buffer_properties[1] = 0x60;
1948 : 45 : buffer_properties[2] = 0x00;
1949 : 45 : buffer_properties[3] = 0x60;
1950 : 45 : buffer_properties[4] = 0x00;
1951 : :
1952 : : /* Inject Object ID */
1953 : 45 : tv_buffer[0].value.value = object_id;
1954 : 45 : tv_buffer[1].value.value = buffer_properties;
1955 : 45 : tv_buffer[2].value.value = buffer_26;
1956 : :
1957 : : /* clone the object to the structure */
1958 : 45 : properties[2+i].value.child = simpletlv_clone(tv_buffer, 3);
1959 [ - + ]: 45 : if (properties[2+i].value.child == NULL)
1960 : 0 : goto failure;
1961 : :
1962 : 45 : properties_len++;
1963 : 45 : number_objects++;
1964 : : }
1965 : :
1966 : : /* Inject Applet Version */
1967 : 45 : properties[0].value.value = applet_information;
1968 : 45 : properties[1].value.value = &number_objects;
1969 : :
1970 : : /* Create the private data structure */
1971 : 45 : applet_private = g_new0(VCardAppletPrivate, 1);
1972 : :
1973 : : /* Create Object ID list */
1974 [ + + ]: 45 : if (objects_len > 0) {
1975 : 30 : applet_private->coids = g_memdup2(objects, sizeof(struct coid) * objects_len);
1976 : 30 : applet_private->coids_len = objects_len;
1977 : : }
1978 : :
1979 : : /* Clone the properties */
1980 : 45 : applet_private->properties_len = properties_len;
1981 : 45 : applet_private->long_properties_len = properties_len; /*TODO*/
1982 : 45 : applet_private->properties = simpletlv_clone(properties, properties_len);
1983 : :
1984 : : /* Avoid dangling pointers in the static structure */
1985 : 45 : properties[0].value.value = NULL;
1986 : 45 : properties[1].value.value = NULL;
1987 : :
1988 [ + - ]: 45 : if (applet_private->properties == NULL)
1989 : 0 : goto failure;
1990 : :
1991 : : /* clean up the allocated properties */
1992 [ + + ]: 90 : for (i = 0; i < number_objects; i++) {
1993 : 45 : simpletlv_free(properties[2+i].value.child, 3);
1994 : : }
1995 : :
1996 : : /* tag/value buffers */
1997 : 45 : applet_private->tag_buffer = g_malloc0(2);
1998 : 45 : applet_private->tag_buffer_len = 2;
1999 : 45 : applet_private->val_buffer = g_malloc0(2);
2000 : 45 : applet_private->val_buffer_len = 2;
2001 : :
2002 : 45 : return applet_private;
2003 : :
2004 : 0 : failure:
2005 [ # # ]: 0 : for (i = 0; i < number_objects; i++) {
2006 : 0 : simpletlv_free(properties[2+i].value.child, 3);
2007 : : }
2008 [ # # ]: 0 : if (applet_private != NULL) {
2009 : 0 : cac_delete_aca_applet_private(applet_private);
2010 : : }
2011 : : return NULL;
2012 : : }
2013 : :
2014 : : static VCardAppletPrivate *
2015 : 10 : cac_new_passthrough_applet_private(G_GNUC_UNUSED VCard *card, const char *label,
2016 : : const unsigned char *aid, unsigned int aid_len)
2017 : : {
2018 : : CACPTAppletData *pt_applet_data;
2019 : : VCardAppletPrivate *applet_private;
2020 : :
2021 : 10 : unsigned char object_id[] = "\x00\x00";
2022 : 10 : unsigned char buffer_properties[] = "\x00\x00\x00\x00\x00";
2023 : : static unsigned char buffer_26[] = "\x01";
2024 : : static struct simpletlv_member tv_buffer[3] = {
2025 : : {CAC_PROPERTIES_OBJECT_ID, 2, {/*.value = object_id*/},
2026 : : SIMPLETLV_TYPE_LEAF},
2027 : : {CAC_PROPERTIES_BUFFER_PROPERTIES, 5, {/*.value = buffer_properties*/},
2028 : : SIMPLETLV_TYPE_LEAF},
2029 : : {0x26, 0x01, {/*.value = buffer_26*/}, SIMPLETLV_TYPE_LEAF},
2030 : : };
2031 : 10 : unsigned char applet_information[] = "\x10\x02\x06\x02\x03";
2032 : 10 : unsigned char number_objects[] = "\x01";
2033 : : static struct simpletlv_member properties[3] = {
2034 : : {CAC_PROPERTIES_APPLET_INFORMATION, 5, {/*.value = applet_information*/},
2035 : : SIMPLETLV_TYPE_LEAF},
2036 : : {CAC_PROPERTIES_NUMBER_OBJECTS, 1, {/*.value = number_objects*/},
2037 : : SIMPLETLV_TYPE_LEAF},
2038 : : {CAC_PROPERTIES_TV_OBJECT, 3, {/*.child = tv_buffer*/},
2039 : : SIMPLETLV_TYPE_COMPOUND},
2040 : : };
2041 : :
2042 : : /* Adjust Object ID based on the AID */
2043 : 10 : object_id[0] = aid[aid_len-2];
2044 : 10 : object_id[1] = aid[aid_len-1];
2045 : :
2046 : : /* Create the private data structure */
2047 : 10 : applet_private = g_new0(VCardAppletPrivate, 1);
2048 : : pt_applet_data = &(applet_private->u.pt_data);
2049 [ - + ]: 10 : if (applet_private == NULL)
2050 : 0 : goto failure;
2051 : :
2052 : : /* Create Object ID list */
2053 : 10 : applet_private->coids = g_malloc(sizeof(struct coid));
2054 : 10 : memcpy(applet_private->coids[0].v, object_id, 2);
2055 : 10 : applet_private->coids_len = 1;
2056 : :
2057 : 10 : pt_applet_data->label = strdup(label);
2058 : :
2059 : : /* Create arbitrary sized buffers */
2060 : 10 : buffer_properties[0] = 0x00; // SimpleTLV
2061 : 10 : buffer_properties[1] = 0x60;
2062 : 10 : buffer_properties[2] = 0x00;
2063 : 10 : buffer_properties[3] = 0x60;
2064 : 10 : buffer_properties[4] = 0x00;
2065 : :
2066 : : /* Inject Object ID */
2067 : 10 : tv_buffer[0].value.value = object_id;
2068 : 10 : tv_buffer[1].value.value = buffer_properties;
2069 : 10 : tv_buffer[2].value.value = buffer_26;
2070 : :
2071 : : /* Inject Applet Version */
2072 : 10 : properties[0].value.value = applet_information;
2073 : 10 : properties[1].value.value = number_objects;
2074 : 10 : properties[2].value.child = tv_buffer;
2075 : :
2076 : : /* Clone the properties */
2077 : 10 : applet_private->properties_len = 3;
2078 : 10 : applet_private->long_properties_len = 3; /*TODO*/
2079 : 10 : applet_private->properties = simpletlv_clone(properties,
2080 : : applet_private->long_properties_len);
2081 [ - + ]: 10 : if (applet_private->properties == NULL)
2082 : 0 : goto failure;
2083 : :
2084 : : return applet_private;
2085 : :
2086 : : failure:
2087 : : if (applet_private != NULL) {
2088 : 0 : cac_delete_passthrough_applet_private(applet_private);
2089 : : }
2090 : : return NULL;
2091 : : }
2092 : :
2093 : : /*
2094 : : * create a new ACA applet
2095 : : */
2096 : : static VCardApplet *
2097 : 5 : cac_new_aca_applet(int cert_count)
2098 : : {
2099 : : VCardAppletPrivate *applet_private;
2100 : : VCardApplet *applet;
2101 : :
2102 : 5 : applet_private = cac_new_aca_applet_private(cert_count);
2103 [ - + ]: 5 : if (applet_private == NULL) {
2104 : 0 : goto failure;
2105 : : }
2106 : 5 : applet = vcard_new_applet(cac_applet_aca_process_apdu, NULL,
2107 : : cac_aca_aid, sizeof(cac_aca_aid));
2108 [ - + ]: 5 : if (applet == NULL) {
2109 : 0 : goto failure;
2110 : : }
2111 : 5 : vcard_set_applet_private(applet, applet_private,
2112 : : cac_delete_aca_applet_private);
2113 : : applet_private = NULL;
2114 : :
2115 : 5 : return applet;
2116 : :
2117 : : failure:
2118 : : if (applet_private != NULL) {
2119 : 0 : cac_delete_aca_applet_private(applet_private);
2120 : : }
2121 : : return NULL;
2122 : : }
2123 : :
2124 : :
2125 : : /*
2126 : : * create a new cac applet which links to a given cert
2127 : : */
2128 : : static VCardApplet *
2129 : 11 : cac_new_pki_applet(int i, const unsigned char *cert,
2130 : : int cert_len, VCardKey *key)
2131 : : {
2132 : : VCardAppletPrivate *applet_private;
2133 : : VCardApplet *applet;
2134 : 11 : unsigned char pki_aid[] = { 0xa0, 0x00, 0x00, 0x00, 0x79, 0x01, 0x00 };
2135 : : int pki_aid_len = sizeof(pki_aid);
2136 : :
2137 : 11 : g_debug("%s: called", __func__);
2138 : :
2139 : 11 : pki_aid[pki_aid_len-1] = i;
2140 : :
2141 : 11 : applet_private = cac_new_pki_applet_private(i, cert, cert_len, key);
2142 [ - + ]: 11 : if (applet_private == NULL) {
2143 : 0 : goto failure;
2144 : : }
2145 : 11 : applet = vcard_new_applet(cac_applet_pki_process_apdu, cac_applet_pki_reset,
2146 : : pki_aid, pki_aid_len);
2147 [ - + ]: 11 : if (applet == NULL) {
2148 : 0 : goto failure;
2149 : : }
2150 : 11 : vcard_set_applet_private(applet, applet_private,
2151 : : cac_delete_pki_applet_private);
2152 : : applet_private = NULL;
2153 : :
2154 : 11 : return applet;
2155 : :
2156 : : failure:
2157 : : if (applet_private != NULL) {
2158 : 0 : cac_delete_pki_applet_private(applet_private);
2159 : : }
2160 : : return NULL;
2161 : : }
2162 : :
2163 : : static VCardApplet *
2164 : 45 : cac_new_empty_applet(const unsigned char *aid, unsigned int aid_len,
2165 : : unsigned char coids[][2], unsigned int coids_len)
2166 : : {
2167 : : VCardAppletPrivate *applet_private;
2168 : : VCardApplet *applet;
2169 : :
2170 : 45 : applet_private = cac_new_empty_applet_private(coids, coids_len);
2171 [ - + ]: 45 : if (applet_private == NULL) {
2172 : 0 : goto failure;
2173 : : }
2174 : :
2175 : 45 : applet = vcard_new_applet(cac_common_process_apdu_read,
2176 : : NULL, aid, aid_len);
2177 [ - + ]: 45 : if (applet == NULL) {
2178 : 0 : goto failure;
2179 : : }
2180 : :
2181 : 45 : vcard_set_applet_private(applet, applet_private,
2182 : : cac_delete_empty_applet_private);
2183 : : applet_private = NULL;
2184 : :
2185 : 45 : return applet;
2186 : :
2187 : : failure:
2188 : : if (applet_private != NULL) {
2189 : 0 : cac_delete_empty_applet_private(applet_private);
2190 : : }
2191 : : return NULL;
2192 : : }
2193 : :
2194 : : static VCardApplet *
2195 : 10 : cac_new_passthrough_applet(VCard *card, const char *label,
2196 : : const unsigned char *aid, unsigned int aid_len)
2197 : : {
2198 : : VCardAppletPrivate *applet_private;
2199 : : VCardApplet *applet;
2200 : :
2201 : 10 : applet_private = cac_new_passthrough_applet_private(card, label,
2202 : : aid, aid_len);
2203 [ - + ]: 10 : if (applet_private == NULL) {
2204 : 0 : goto failure;
2205 : : }
2206 : :
2207 : 10 : applet = vcard_new_applet(cac_passthrough_container_process_apdu,
2208 : : cac_applet_passthrough_reset, aid, aid_len);
2209 [ - + ]: 10 : if (applet == NULL) {
2210 : 0 : goto failure;
2211 : : }
2212 : :
2213 : 10 : vcard_set_applet_private(applet, applet_private,
2214 : : cac_delete_passthrough_applet_private);
2215 : : applet_private = NULL;
2216 : :
2217 : 10 : return applet;
2218 : :
2219 : : failure:
2220 : : if (applet_private != NULL) {
2221 : 0 : cac_delete_empty_applet_private(applet_private);
2222 : : }
2223 : : return NULL;
2224 : : }
2225 : :
2226 : : /*
2227 : : * Get ATR of CAC card since some application might be picky about out
2228 : : * virtual one
2229 : : */
2230 : : static unsigned char cac_atr[] = {
2231 : : /* The older CAC card from official CAC document */
2232 : : 0x3B, 0x7A, 0x18, 0x00, 0x00, 0x73, 0x66, 0x74, 0x65, 0x20, 0x63, 0x64, 0x31, 0x34, 0x34
2233 : : };
2234 : : static int cac_atr_len = sizeof(cac_atr);
2235 : :
2236 : : static void
2237 : 1 : cac_get_atr(G_GNUC_UNUSED VCard *card, unsigned char *atr, int *atr_len)
2238 : : {
2239 : : int len;
2240 [ - + ]: 1 : assert(atr != NULL);
2241 : :
2242 : 1 : len = MIN(cac_atr_len, *atr_len);
2243 : 1 : memcpy(atr, cac_atr, len);
2244 : 1 : *atr_len = len;
2245 : 1 : }
2246 : :
2247 : : /*
2248 : : * Initialize the cac card. This is the only public function in this file. All
2249 : : * the rest are connected through function pointers.
2250 : : */
2251 : : VCardStatus
2252 : 5 : cac_card_init(G_GNUC_UNUSED VReader *reader, VCard *card,
2253 : : unsigned char * const *cert,
2254 : : int cert_len[],
2255 : : VCardKey *key[] /* adopt the keys*/,
2256 : : int cert_count)
2257 : : {
2258 : : int i;
2259 : : VCardApplet *applet;
2260 : 5 : unsigned char coids[][2] = {{0x02, 0xfb}};
2261 : 5 : unsigned char acf_coids[][2] = {
2262 : : {0x30, 0x00},
2263 : : {0x60, 0x10},
2264 : : {0x60, 0x30},
2265 : : {0x90, 0x00},
2266 : : };
2267 : :
2268 : 5 : g_debug("%s: called", __func__);
2269 : :
2270 : : /* CAC Cards are VM Cards */
2271 : 5 : vcard_set_type(card, VCARD_VM);
2272 : :
2273 [ + - ]: 5 : if (cert_count > 10) {
2274 : 0 : g_debug("Too many PKI objects");
2275 : 0 : goto failure;
2276 : : }
2277 : :
2278 : : /* create one PKI applet for each cert */
2279 [ + + ]: 16 : for (i = 0; i < cert_count; i++) {
2280 : 11 : applet = cac_new_pki_applet(i, cert[i], cert_len[i], key[i]);
2281 [ - + ]: 11 : if (applet == NULL) {
2282 : 0 : goto failure;
2283 : : }
2284 : 11 : vcard_add_applet(card, applet);
2285 : : }
2286 : :
2287 : : /* create a ACA applet, to list access rules */
2288 : 5 : applet = cac_new_aca_applet(cert_count);
2289 [ - + ]: 5 : if (applet == NULL) {
2290 : 0 : goto failure;
2291 : : }
2292 : 5 : vcard_add_applet(card, applet);
2293 : :
2294 : : /* create a CCC container, which is need for CAC recognition,
2295 : : * which should be default
2296 : : */
2297 : 5 : applet = cac_new_ccc_applet(cert_count);
2298 [ - + ]: 5 : if (applet == NULL) {
2299 : 0 : goto failure;
2300 : : }
2301 : 5 : vcard_add_applet(card, applet);
2302 : :
2303 : : /* Three more empty applets without buffer */
2304 : : /* 02 F0 */
2305 : 5 : applet = cac_new_empty_applet(cac_02f0_aid, sizeof(cac_02f0_aid), NULL, 0);
2306 [ - + ]: 5 : if (applet == NULL) {
2307 : 0 : goto failure;
2308 : : }
2309 : 5 : vcard_add_applet(card, applet);
2310 : :
2311 : : /* 02 F1 */
2312 : 5 : applet = cac_new_empty_applet(cac_02f1_aid, sizeof(cac_02f1_aid), NULL, 0);
2313 [ - + ]: 5 : if (applet == NULL) {
2314 : 0 : goto failure;
2315 : : }
2316 : 5 : vcard_add_applet(card, applet);
2317 : :
2318 : : /* 02 F2 */
2319 : 5 : applet = cac_new_empty_applet(cac_02f2_aid, sizeof(cac_02f2_aid), NULL, 0);
2320 [ - + ]: 5 : if (applet == NULL) {
2321 : 0 : goto failure;
2322 : : }
2323 : 5 : vcard_add_applet(card, applet);
2324 : :
2325 : : /* Empty generic applet (0x02FB) */
2326 : 5 : applet = cac_new_empty_applet(cac_02fb_aid, sizeof(cac_02fb_aid),
2327 : : coids, 1);
2328 [ - + ]: 5 : if (applet == NULL) {
2329 : 0 : goto failure;
2330 : : }
2331 : 5 : vcard_add_applet(card, applet);
2332 : :
2333 : : /* PKI Certificate passthrough applet (0x02FE)
2334 : : * TODO: Find a way how to expose generic non-SimpleTLV buffers
2335 : : * from OpenSC in sane manner
2336 : : */
2337 : : /*applet = cac_new_passthrough_applet(card, "PKI Certificate",
2338 : : cac_pki_certificate_aid, sizeof(cac_pki_certificate_aid));*/
2339 : 5 : coids[0][1] = 0xfe;
2340 : 5 : applet = cac_new_empty_applet(cac_pki_certificate_aid,
2341 : : sizeof(cac_pki_certificate_aid), coids, 1);
2342 [ - + ]: 5 : if (applet == NULL) {
2343 : 0 : goto failure;
2344 : : }
2345 : 5 : vcard_add_applet(card, applet);
2346 : :
2347 : : /* PKI Credential passthrough applet (0x02FD)
2348 : : * TODO: Find a way how to expose generic non-SimpleTLV buffers
2349 : : * from OpenSC in sane manner
2350 : : */
2351 : : /*applet = cac_new_passthrough_applet(card, "PKI Credential",
2352 : : cac_pki_credential_aid, sizeof(cac_pki_credential_aid));*/
2353 : 5 : coids[0][1] = 0xfd;
2354 : 5 : applet = cac_new_empty_applet(cac_pki_credential_aid,
2355 : : sizeof(cac_pki_credential_aid), coids, 1);
2356 [ - + ]: 5 : if (applet == NULL) {
2357 : 0 : goto failure;
2358 : : }
2359 : 5 : vcard_add_applet(card, applet);
2360 : :
2361 : : /* Person Instance passthrough applet (0x0200) */
2362 : 5 : applet = cac_new_passthrough_applet(card, "Person Instance",
2363 : : cac_person_instance_aid, sizeof(cac_person_instance_aid));
2364 [ - + ]: 5 : if (applet == NULL) {
2365 : 0 : goto failure;
2366 : : }
2367 : 5 : vcard_add_applet(card, applet);
2368 : :
2369 : : /* Personnel passthrough applet (0x0200) */
2370 : 5 : applet = cac_new_passthrough_applet(card, "Personnel",
2371 : : cac_personnel_aid, sizeof(cac_personnel_aid));
2372 [ - + ]: 5 : if (applet == NULL) {
2373 : 0 : goto failure;
2374 : : }
2375 : 5 : vcard_add_applet(card, applet);
2376 : :
2377 : : /* Empty generic applet (0x1201) */
2378 : 5 : coids[0][0] = 0x12;
2379 : 5 : coids[0][1] = 0x01;
2380 : 5 : applet = cac_new_empty_applet(cac_1201_aid, sizeof(cac_1201_aid), coids, 1);
2381 [ - + ]: 5 : if (applet == NULL) {
2382 : 0 : goto failure;
2383 : : }
2384 : 5 : vcard_add_applet(card, applet);
2385 : :
2386 : : /* Empty generic applet (0x1202) */
2387 : 5 : coids[0][1] = 0x02;
2388 : 5 : applet = cac_new_empty_applet(cac_1202_aid, sizeof(cac_1202_aid), coids, 1);
2389 [ - + ]: 5 : if (applet == NULL) {
2390 : 0 : goto failure;
2391 : : }
2392 : 5 : vcard_add_applet(card, applet);
2393 : :
2394 : : /* Access Control File */
2395 : 5 : applet = cac_new_empty_applet(cac_access_control_aid,
2396 : : sizeof(cac_access_control_aid), acf_coids, 4);
2397 [ - + ]: 5 : if (applet == NULL) {
2398 : 0 : goto failure;
2399 : : }
2400 : 5 : vcard_add_applet(card, applet);
2401 : :
2402 : : /* GP applet is created from vcard_emul_type() */
2403 : :
2404 : : /* Modify ATR to match existing cards */
2405 : 5 : vcard_set_atr_func(card, cac_get_atr);
2406 : :
2407 : 5 : return VCARD_DONE;
2408 : :
2409 : : failure:
2410 : : return VCARD_FAIL;
2411 : : }
2412 : :
2413 : : /* vim: set ts=4 sw=4 tw=0 noet expandtab: */
|
