?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
agent/
[gnupg.git] / scd / app-p15.c
blob7d8329366e8b2e1710ea43a4b1ba4361a0a7bd55
1 /* app-p15.c - The pkcs#15 card application.
2 * Copyright (C) 2005 Free Software Foundation, Inc.
3 *
4 * This file is part of GnuPG.
5 *
6 * GnuPG is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * GnuPG is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 /* Information pertaining to the BELPIC developer card samples:
21
22 Unblock PUK: "222222111111"
23 Reset PIN: "333333111111")
24
25 e.g. the APDUs 00:20:00:02:08:2C:33:33:33:11:11:11:FF
26 and 00:24:01:01:08:24:12:34:FF:FF:FF:FF:FF
27 should change the PIN into 1234.
28 */
29
30 #include <config.h>
31 #include <errno.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <assert.h>
36 #include <time.h>
37
38 #include "scdaemon.h"
39
40 #include "iso7816.h"
41 #include "app-common.h"
42 #include "tlv.h"
43 #include "apdu.h" /* fixme: we should move the card detection to a
44 separate file */
45
46 /* Types of cards we know and which needs special treatment. */
47 typedef enum
48 {
49 CARD_TYPE_UNKNOWN,
50 CARD_TYPE_TCOS,
51 CARD_TYPE_MICARDO,
52 CARD_TYPE_BELPIC /* Belgian eID card specs. */
53 }
54 card_type_t;
55
56 /* A list card types with ATRs noticed with these cards. */
57 #define X(a) ((unsigned char const *)(a))
58 static struct
59 {
60 size_t atrlen;
61 unsigned char const *atr;
62 card_type_t type;
63 } card_atr_list[] = {
64 { 19, X("\x3B\xBA\x13\x00\x81\x31\x86\x5D\x00\x64\x05\x0A\x02\x01\x31\x80"
65 "\x90\x00\x8B"),
66 CARD_TYPE_TCOS }, /* SLE44 */
67 { 19, X("\x3B\xBA\x14\x00\x81\x31\x86\x5D\x00\x64\x05\x14\x02\x02\x31\x80"
68 "\x90\x00\x91"),
69 CARD_TYPE_TCOS }, /* SLE66S */
70 { 19, X("\x3B\xBA\x96\x00\x81\x31\x86\x5D\x00\x64\x05\x60\x02\x03\x31\x80"
71 "\x90\x00\x66"),
72 CARD_TYPE_TCOS }, /* SLE66P */
73 { 27, X("\x3B\xFF\x94\x00\xFF\x80\xB1\xFE\x45\x1F\x03\x00\x68\xD2\x76\x00"
74 "\x00\x28\xFF\x05\x1E\x31\x80\x00\x90\x00\x23"),
75 CARD_TYPE_MICARDO }, /* German BMI card */
76 { 19, X("\x3B\x6F\x00\xFF\x00\x68\xD2\x76\x00\x00\x28\xFF\x05\x1E\x31\x80"
77 "\x00\x90\x00"),
78 CARD_TYPE_MICARDO }, /* German BMI card (ATR due to reader problem) */
79 { 26, X("\x3B\xFE\x94\x00\xFF\x80\xB1\xFA\x45\x1F\x03\x45\x73\x74\x45\x49"
80 "\x44\x20\x76\x65\x72\x20\x31\x2E\x30\x43"),
81 CARD_TYPE_MICARDO }, /* EstEID (Estonian Big Brother card) */
82
83 { 0 }
84 };
85 #undef X
86
87
88 /* The AID of PKCS15. */
89 static char const pkcs15_aid[] = { 0xA0, 0, 0, 0, 0x63,
90 0x50, 0x4B, 0x43, 0x53, 0x2D, 0x31, 0x35 };
91
92 /* The Belgian eID variant - they didn't understood why a shared AID
93 is useful for a standard. Oh well. */
94 static char const pkcs15be_aid[] = { 0xA0, 0, 0, 0x01, 0x77,
95 0x50, 0x4B, 0x43, 0x53, 0x2D, 0x31, 0x35 };
96
97
98 /* The PIN types as defined in pkcs#15 v1.1 */
99 typedef enum
100 {
101 PIN_TYPE_BCD = 0,
102 PIN_TYPE_ASCII_NUMERIC = 1,
103 PIN_TYPE_UTF8 = 2,
104 PIN_TYPE_HALF_NIBBLE_BCD = 3,
105 PIN_TYPE_ISO9564_1 = 4
106 } pin_type_t;
107
108
109 /* A bit array with for the key usage flags from the
110 commonKeyAttributes. */
111 struct keyusage_flags_s
112 {
113 unsigned int encrypt: 1;
114 unsigned int decrypt: 1;
115 unsigned int sign: 1;
116 unsigned int sign_recover: 1;
117 unsigned int wrap: 1;
118 unsigned int unwrap: 1;
119 unsigned int verify: 1;
120 unsigned int verify_recover: 1;
121 unsigned int derive: 1;
122 unsigned int non_repudiation: 1;
123 };
124 typedef struct keyusage_flags_s keyusage_flags_t;
125
126
127
128 /* This is an object to store information about a Certificate
129 Directory File (CDF) in a format suitable for further processing by
130 us. To keep memory management, simple we use a linked list of
131 items; i.e. one such object represents one certificate and the list
132 the entire CDF. */
133 struct cdf_object_s
134 {
135 /* Link to next item when used in a linked list. */
136 struct cdf_object_s *next;
137
138 /* Length and allocated buffer with the Id of this object. */
139 size_t objidlen;
140 unsigned char *objid;
141
142 /* To avoid reading a certificate more than once, we cache it in an
143 allocated memory IMAGE of IMAGELEN. */
144 size_t imagelen;
145 unsigned char *image;
146
147 /* Set to true if a length and offset is available. */
148 int have_off;
149 /* The offset and length of the object. They are only valid if
150 HAVE_OFF is true and set to 0 if HAVE_OFF is false. */
151 unsigned long off, len;
152
153 /* The length of the path as given in the CDF and the path itself.
154 path[0] is the top DF (usually 0x3f00). The path will never be
155 empty. */
156 size_t pathlen;
157 unsigned short path[1];
158 };
159 typedef struct cdf_object_s *cdf_object_t;
160
161
162 /* This is an object to store information about a Private Key
163 Directory File (PrKDF) in a format suitable for further processing
164 by us. To keep memory management, simple we use a linked list of
165 items; i.e. one such object represents one certificate and the list
166 the entire PrKDF. */
167 struct prkdf_object_s
168 {
169 /* Link to next item when used in a linked list. */
170 struct prkdf_object_s *next;
171
172 /* Length and allocated buffer with the Id of this object. */
173 size_t objidlen;
174 unsigned char *objid;
175
176 /* Length and allocated buffer with the authId of this object or
177 NULL if no authID is known. */
178 size_t authidlen;
179 unsigned char *authid;
180
181 /* The key's usage flags. */
182 keyusage_flags_t usageflags;
183
184 /* The keyReference and a flag telling whether it is valid. */
185 unsigned long key_reference;
186 int key_reference_valid;
187
188 /* Set to true if a length and offset is available. */
189 int have_off;
190 /* The offset and length of the object. They are only valid if
191 HAVE_OFF is true and set to 0 if HAVE_OFF is false. */
192 unsigned long off, len;
193
194 /* The length of the path as given in the PrKDF and the path itself.
195 path[0] is the top DF (usually 0x3f00). */
196 size_t pathlen;
197 unsigned short path[1];
198 };
199 typedef struct prkdf_object_s *prkdf_object_t;
200
201
202 /* This is an object to store information about a Authentication
203 Object Directory File (AODF) in a format suitable for further
204 processing by us. To keep memory management, simple we use a linked
205 list of items; i.e. one such object represents one authentication
206 object and the list the entire AOKDF. */
207 struct aodf_object_s
208 {
209 /* Link to next item when used in a linked list. */
210 struct aodf_object_s *next;
211
212 /* Length and allocated buffer with the Id of this object. */
213 size_t objidlen;
214 unsigned char *objid;
215
216 /* Length and allocated buffer with the authId of this object or
217 NULL if no authID is known. */
218 size_t authidlen;
219 unsigned char *authid;
220
221 /* The PIN Flags. */
222 struct
223 {
224 unsigned int case_sensitive: 1;
225 unsigned int local: 1;
226 unsigned int change_disabled: 1;
227 unsigned int unblock_disabled: 1;
228 unsigned int initialized: 1;
229 unsigned int needs_padding: 1;
230 unsigned int unblocking_pin: 1;
231 unsigned int so_pin: 1;
232 unsigned int disable_allowed: 1;
233 unsigned int integrity_protected: 1;
234 unsigned int confidentiality_protected: 1;
235 unsigned int exchange_ref_data: 1;
236 } pinflags;
237
238 /* The PIN Type. */
239 pin_type_t pintype;
240
241 /* The minimum length of a PIN. */
242 unsigned long min_length;
243
244 /* The stored length of a PIN. */
245 unsigned long stored_length;
246
247 /* The maximum length of a PIN and a flag telling whether it is valid. */
248 unsigned long max_length;
249 int max_length_valid;
250
251 /* The pinReference and a flag telling whether it is valid. */
252 unsigned long pin_reference;
253 int pin_reference_valid;
254
255 /* The padChar and a flag telling whether it is valid. */
256 char pad_char;
257 int pad_char_valid;
258
259
260 /* Set to true if a length and offset is available. */
261 int have_off;
262 /* The offset and length of the object. They are only valid if
263 HAVE_OFF is true and set to 0 if HAVE_OFF is false. */
264 unsigned long off, len;
265
266 /* The length of the path as given in the Aodf and the path itself.
267 path[0] is the top DF (usually 0x3f00). PATH is optional and thus
268 may be NULL. Malloced.*/
269 size_t pathlen;
270 unsigned short *path;
271 };
272 typedef struct aodf_object_s *aodf_object_t;
273
274
275 /* Context local to this application. */
276 struct app_local_s
277 {
278 /* The home DF. Note, that we don't yet support a multilevel
279 hierachy. Thus we assume this is directly below the MF. */
280 unsigned short home_df;
281
282 /* The type of the card. */
283 card_type_t card_type;
284
285 /* Flag indicating whether we may use direct path selection. */
286 int direct_path_selection;
287
288 /* Structure with the EFIDs of the objects described in the ODF
289 file. */
290 struct
291 {
292 unsigned short private_keys;
293 unsigned short public_keys;
294 unsigned short trusted_public_keys;
295 unsigned short secret_keys;
296 unsigned short certificates;
297 unsigned short trusted_certificates;
298 unsigned short useful_certificates;
299 unsigned short data_objects;
300 unsigned short auth_objects;
301 } odf;
302
303 /* The PKCS#15 serialnumber from EF(TokeiNFo) or NULL. Malloced. */
304 unsigned char *serialno;
305 size_t serialnolen;
306
307 /* Information on all certificates. */
308 cdf_object_t certificate_info;
309 /* Information on all trusted certificates. */
310 cdf_object_t trusted_certificate_info;
311 /* Information on all useful certificates. */
312 cdf_object_t useful_certificate_info;
313
314 /* Information on all private keys. */
315 prkdf_object_t private_key_info;
316
317 /* Information on all authentication objects. */
318 aodf_object_t auth_object_info;
319
320 };
321
322
323 /*** Local prototypes. ***/
324 static gpg_error_t readcert_by_cdf (app_t app, cdf_object_t cdf,
325 unsigned char **r_cert, size_t *r_certlen);
326
327
328
329 /* Release the CDF object A */
330 static void
331 release_cdflist (cdf_object_t a)
332 {
333 while (a)
334 {
335 cdf_object_t tmp = a->next;
336 xfree (a->image);
337 xfree (a->objid);
338 xfree (a);
339 a = tmp;
340 }
341 }
342
343 /* Release the PrKDF object A. */
344 static void
345 release_prkdflist (prkdf_object_t a)
346 {
347 while (a)
348 {
349 prkdf_object_t tmp = a->next;
350 xfree (a->objid);
351 xfree (a->authid);
352 xfree (a);
353 a = tmp;
354 }
355 }
356
357 /* Release just one aodf object. */
358 void
359 release_aodf_object (aodf_object_t a)
360 {
361 if (a)
362 {
363 xfree (a->objid);
364 xfree (a->authid);
365 xfree (a->path);
366 xfree (a);
367 }
368 }
369
370 /* Release the AODF list A. */
371 static void
372 release_aodflist (aodf_object_t a)
373 {
374 while (a)
375 {
376 aodf_object_t tmp = a->next;
377 release_aodf_object (a);
378 a = tmp;
379 }
380 }
381
382
383 /* Release all local resources. */
384 static void
385 do_deinit (app_t app)
386 {
387 if (app && app->app_local)
388 {
389 release_cdflist (app->app_local->certificate_info);
390 release_cdflist (app->app_local->trusted_certificate_info);
391 release_cdflist (app->app_local->useful_certificate_info);
392 release_prkdflist (app->app_local->private_key_info);
393 release_aodflist (app->app_local->auth_object_info);
394 xfree (app->app_local->serialno);
395 xfree (app->app_local);
396 app->app_local = NULL;
397 }
398 }
399
400
401
402 /* Do a select and a read for the file with EFID. EFID_DESC is a
403 desctription of the EF to be used with error messages. On success
404 BUFFER and BUFLEN contain the entire content of the EF. The caller
405 must free BUFFER only on success. */
406 static gpg_error_t
407 select_and_read_binary (int slot, unsigned short efid, const char *efid_desc,
408 unsigned char **buffer, size_t *buflen)
409 {
410 gpg_error_t err;
411
412 err = iso7816_select_file (slot, efid, 0, NULL, NULL);
413 if (err)
414 {
415 log_error ("error selecting %s (0x%04X): %s\n",
416 efid_desc, efid, gpg_strerror (err));
417 return err;
418 }
419 err = iso7816_read_binary (slot, 0, 0, buffer, buflen);
420 if (err)
421 {
422 log_error ("error reading %s (0x%04X): %s\n",
423 efid_desc, efid, gpg_strerror (err));
424 return err;
425 }
426 return 0;
427 }
428
429
430 /* This function calls select file to read a file using a complete
431 path which may or may not start at the master file (MF). */
432 static gpg_error_t
433 select_ef_by_path (app_t app, const unsigned short *path, size_t pathlen)
434 {
435 gpg_error_t err;
436 int i, j;
437
438 if (!pathlen)
439 return gpg_error (GPG_ERR_INV_VALUE);
440
441 if (pathlen && *path != 0x3f00 )
442 log_debug ("WARNING: relative path selection not yet implemented\n");
443
444 if (app->app_local->direct_path_selection)
445 {
446 err = iso7816_select_path (app->slot, path+1, pathlen-1, NULL, NULL);
447 if (err)
448 {
449 log_error ("error selecting path ");
450 for (j=0; j < pathlen; j++)
451 log_printf ("%04hX", path[j]);
452 log_printf (": %s\n", gpg_strerror (err));
453 return err;
454 }
455 }
456 else
457 {
458 /* FIXME: Need code to remember the last PATH so that we can decide
459 what select commands to send in case the path does not start off
460 with 3F00. We might also want to use direct path selection if
461 supported by the card. */
462 for (i=0; i < pathlen; i++)
463 {
464 err = iso7816_select_file (app->slot, path[i],
465 !(i+1 == pathlen), NULL, NULL);
466 if (err)
467 {
468 log_error ("error selecting part %d from path ", i);
469 for (j=0; j < pathlen; j++)
470 log_printf ("%04hX", path[j]);
471 log_printf (": %s\n", gpg_strerror (err));
472 return err;
473 }
474 }
475 }
476 return 0;
477 }
478
479 /* Parse a cert Id string (or a key Id string) and return the binary
480 object Id string in a newly allocated buffer stored at R_OBJID and
481 R_OBJIDLEN. On Error NULL will be stored there and an error code
482 returned. On success caller needs to free the buffer at R_OBJID. */
483 static gpg_error_t
484 parse_certid (app_t app, const char *certid,
485 unsigned char **r_objid, size_t *r_objidlen)
486 {
487 char tmpbuf[10];
488 const char *s;
489 size_t objidlen;
490 unsigned char *objid;
491 int i;
492
493 *r_objid = NULL;
494 *r_objidlen = 0;
495
496 if (app->app_local->home_df)
497 sprintf (tmpbuf, "P15-%04hX.", (app->app_local->home_df & 0xffff));
498 else
499 strcpy (tmpbuf, "P15.");
500 if (strncmp (certid, tmpbuf, strlen (tmpbuf)) )
501 {
502 if (!strncmp (certid, "P15.", 4)
503 || (!strncmp (certid, "P15-", 4)
504 && hexdigitp (certid+4)
505 && hexdigitp (certid+5)
506 && hexdigitp (certid+6)
507 && hexdigitp (certid+7)
508 && certid[8] == '.'))
509 return gpg_error (GPG_ERR_NOT_FOUND);
510 return gpg_error (GPG_ERR_INV_ID);
511 }
512 certid += strlen (tmpbuf);
513
514 for (s=certid, objidlen=0; hexdigitp (s); s++, objidlen++)
515 ;
516 if (*s || !objidlen || (objidlen%2))
517 return gpg_error (GPG_ERR_INV_ID);
518 objidlen /= 2;
519 objid = xtrymalloc (objidlen);
520 if (!objid)
521 return gpg_error_from_syserror ();
522 for (s=certid, i=0; i < objidlen; i++, s+=2)
523 objid[i] = xtoi_2 (s);
524 *r_objid = objid;
525 *r_objidlen = objidlen;
526 return 0;
527 }
528
529
530 /* Find a certificate object by the certificate ID CERTID and store a
531 pointer to it at R_CDF. */
532 static gpg_error_t
533 cdf_object_from_certid (app_t app, const char *certid, cdf_object_t *r_cdf)
534 {
535 gpg_error_t err;
536 size_t objidlen;
537 unsigned char *objid;
538 cdf_object_t cdf;
539
540 err = parse_certid (app, certid, &objid, &objidlen);
541 if (err)
542 return err;
543
544 for (cdf = app->app_local->certificate_info; cdf; cdf = cdf->next)
545 if (cdf->objidlen == objidlen && !memcmp (cdf->objid, objid, objidlen))
546 break;
547 if (!cdf)
548 for (cdf = app->app_local->trusted_certificate_info; cdf; cdf = cdf->next)
549 if (cdf->objidlen == objidlen && !memcmp (cdf->objid, objid, objidlen))
550 break;
551 if (!cdf)
552 for (cdf = app->app_local->useful_certificate_info; cdf; cdf = cdf->next)
553 if (cdf->objidlen == objidlen && !memcmp (cdf->objid, objid, objidlen))
554 break;
555 xfree (objid);
556 if (!cdf)
557 return gpg_error (GPG_ERR_NOT_FOUND);
558 *r_cdf = cdf;
559 return 0;
560 }
561
562
563 /* Find a private key object by the key Id string KEYIDSTR and store a
564 pointer to it at R_PRKDF. */
565 static gpg_error_t
566 prkdf_object_from_keyidstr (app_t app, const char *keyidstr,
567 prkdf_object_t *r_prkdf)
568 {
569 gpg_error_t err;
570 size_t objidlen;
571 unsigned char *objid;
572 prkdf_object_t prkdf;
573
574 err = parse_certid (app, keyidstr, &objid, &objidlen);
575 if (err)
576 return err;
577
578 for (prkdf = app->app_local->private_key_info; prkdf; prkdf = prkdf->next)
579 if (prkdf->objidlen == objidlen && !memcmp (prkdf->objid, objid, objidlen))
580 break;
581 xfree (objid);
582 if (!prkdf)
583 return gpg_error (GPG_ERR_NOT_FOUND);
584 *r_prkdf = prkdf;
585 return 0;
586 }
587
588
589
590 \f
591 /* Read and parse the Object Directory File and store away the
592 pointers. ODF_FID shall contain the FID of the ODF.
593
594 Example of such a file:
595
596 A0 06 30 04 04 02 60 34 = Private Keys
597 A4 06 30 04 04 02 60 35 = Certificates
598 A5 06 30 04 04 02 60 36 = TrustedCertificates
599 A7 06 30 04 04 02 60 37 = DataObjects
600 A8 06 30 04 04 02 60 38 = AuthObjects
601
602 These are all PathOrObjects using the path CHOICE element. The
603 paths are octet strings of length 2. Using this Path CHOICE
604 element is recommended, so we only implement that for now.
605 */
606 static gpg_error_t
607 read_ef_odf (app_t app, unsigned short odf_fid)
608 {
609 gpg_error_t err;
610 unsigned char *buffer, *p;
611 size_t buflen;
612 unsigned short value;
613 size_t offset;
614
615 err = select_and_read_binary (app->slot, odf_fid, "ODF", &buffer, &buflen);
616 if (err)
617 return err;
618
619 if (buflen < 8)
620 {
621 log_error ("error: ODF too short\n");
622 xfree (buffer);
623 return gpg_error (GPG_ERR_INV_OBJ);
624 }
625 p = buffer;
626 while (buflen && *p && *p != 0xff)
627 {
628 if ( buflen >= 8
629 && (p[0] & 0xf0) == 0xA0
630 && !memcmp (p+1, "\x06\x30\x04\x04\x02", 5) )
631 {
632 offset = 6;
633 }
634 else if ( buflen >= 12
635 && (p[0] & 0xf0) == 0xA0
636 && !memcmp (p+1, "\x0a\x30\x08\x04\x06\x3F\x00", 7)
637 && app->app_local->home_df == ((p[8]<<8)|p[9]) )
638 {
639 /* We only allow a full path if all files are at the same
640 level and below the home directory. The extend this we
641 would need to make use of new data type capable of
642 keeping a full path. */
643 offset = 10;
644 }
645 else
646 {
647 log_error ("ODF format is not supported by us\n");
648 xfree (buffer);
649 return gpg_error (GPG_ERR_INV_OBJ);
650 }
651 switch ((p[0] & 0x0f))
652 {
653 case 0: value = app->app_local->odf.private_keys; break;
654 case 1: value = app->app_local->odf.public_keys; break;
655 case 2: value = app->app_local->odf.trusted_public_keys; break;
656 case 3: value = app->app_local->odf.secret_keys; break;
657 case 4: value = app->app_local->odf.certificates; break;
658 case 5: value = app->app_local->odf.trusted_certificates; break;
659 case 6: value = app->app_local->odf.useful_certificates; break;
660 case 7: value = app->app_local->odf.data_objects; break;
661 case 8: value = app->app_local->odf.auth_objects; break;
662 default: value = 0; break;
663 }
664 if (value)
665 {
666 log_error ("duplicate object type %d in ODF ignored\n",(p[0]&0x0f));
667 continue;
668 }
669 value = ((p[offset] << 8) | p[offset+1]);
670 switch ((p[0] & 0x0f))
671 {
672 case 0: app->app_local->odf.private_keys = value; break;
673 case 1: app->app_local->odf.public_keys = value; break;
674 case 2: app->app_local->odf.trusted_public_keys = value; break;
675 case 3: app->app_local->odf.secret_keys = value; break;
676 case 4: app->app_local->odf.certificates = value; break;
677 case 5: app->app_local->odf.trusted_certificates = value; break;
678 case 6: app->app_local->odf.useful_certificates = value; break;
679 case 7: app->app_local->odf.data_objects = value; break;
680 case 8: app->app_local->odf.auth_objects = value; break;
681 default:
682 log_error ("unknown object type %d in ODF ignored\n", (p[0]&0x0f));
683 }
684 offset += 2;
685
686 if (buflen < offset)
687 break;
688 p += offset;
689 buflen -= offset;
690 }
691
692 if (buflen)
693 log_info ("warning: %u bytes of garbage detected at end of ODF\n",
694 (unsigned int)buflen);
695
696 xfree (buffer);
697 return 0;
698 }
699
700
701 /* Parse the BIT STRING with the keyUsageFlags from teh
702 CommonKeyAttributes. */
703 static gpg_error_t
704 parse_keyusage_flags (const unsigned char *der, size_t derlen,
705 keyusage_flags_t *usageflags)
706 {
707 unsigned int bits, mask;
708 int i, unused, full;
709
710 memset (usageflags, 0, sizeof *usageflags);
711 if (!derlen)
712 return gpg_error (GPG_ERR_INV_OBJ);
713
714 unused = *der++; derlen--;
715 if ((!derlen && unused) || unused/8 > derlen)
716 return gpg_error (GPG_ERR_ENCODING_PROBLEM);
717 full = derlen - (unused+7)/8;
718 unused %= 8;
719 mask = 0;
720 for (i=1; unused; i <<= 1, unused--)
721 mask |= i;
722
723 /* First octet */
724 if (derlen)
725 {
726 bits = *der++; derlen--;
727 if (full)
728 full--;
729 else
730 {
731 bits &= ~mask;
732 mask = 0;
733 }
734 }
735 else
736 bits = 0;
737 if ((bits & 0x80)) usageflags->encrypt = 1;
738 if ((bits & 0x40)) usageflags->decrypt = 1;
739 if ((bits & 0x20)) usageflags->sign = 1;
740 if ((bits & 0x10)) usageflags->sign_recover = 1;
741 if ((bits & 0x08)) usageflags->wrap = 1;
742 if ((bits & 0x04)) usageflags->unwrap = 1;
743 if ((bits & 0x02)) usageflags->verify = 1;
744 if ((bits & 0x01)) usageflags->verify_recover = 1;
745
746 /* Second octet. */
747 if (derlen)
748 {
749 bits = *der++; derlen--;
750 if (full)
751 full--;
752 else
753 {
754 bits &= ~mask;
755 mask = 0;
756 }
757 }
758 else
759 bits = 0;
760 if ((bits & 0x80)) usageflags->derive = 1;
761 if ((bits & 0x40)) usageflags->non_repudiation = 1;
762
763 return 0;
764 }
765
766 /* Read and parse the Private Key Directory Files. */
767 /*
768 6034 (privatekeys)
769
770 30 33 30 11 0C 08 53 4B 2E 43 48 2E 44 53 03 02 030...SK.CH.DS..
771 06 80 04 01 07 30 0C 04 01 01 03 03 06 00 40 02 .....0........@.
772 02 00 50 A1 10 30 0E 30 08 04 06 3F 00 40 16 00 ..P..0.0...?.@..
773 50 02 02 04 00 30 33 30 11 0C 08 53 4B 2E 43 48 P....030...SK.CH
774 2E 4B 45 03 02 06 80 04 01 0A 30 0C 04 01 0C 03 .KE.......0.....
775 03 06 44 00 02 02 00 52 A1 10 30 0E 30 08 04 06 ..D....R..0.0...
776 3F 00 40 16 00 52 02 02 04 00 30 34 30 12 0C 09 ?.@..R....040...
777 53 4B 2E 43 48 2E 41 55 54 03 02 06 80 04 01 0A SK.CH.AUT.......
778 30 0C 04 01 0D 03 03 06 20 00 02 02 00 51 A1 10 0....... ....Q..
779 30 0E 30 08 04 06 3F 00 40 16 00 51 02 02 04 00 0.0...?.@..Q....
780 30 37 30 15 0C 0C 53 4B 2E 43 48 2E 44 53 2D 53 070...SK.CH.DS-S
781 50 58 03 02 06 80 04 01 0A 30 0C 04 01 02 03 03 PX.......0......
782 06 20 00 02 02 00 53 A1 10 30 0E 30 08 04 06 3F . ....S..0.0...?
783 00 40 16 00 53 02 02 04 00 00 00 00 00 00 00 00 .@..S...........
784 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
785 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
786
787 0 30 51: SEQUENCE {
788 2 30 17: SEQUENCE { -- commonObjectAttributes
789 4 0C 8: UTF8String 'SK.CH.DS'
790 14 03 2: BIT STRING 6 unused bits
791 : '01'B (bit 0)
792 18 04 1: OCTET STRING --authid
793 : 07
794 : }
795 21 30 12: SEQUENCE { -- commonKeyAttributes
796 23 04 1: OCTET STRING
797 : 01
798 26 03 3: BIT STRING 6 unused bits
799 : '1000000000'B (bit 9)
800 31 02 2: INTEGER 80 -- keyReference (optional)
801 : }
802 35 A1 16: [1] { -- keyAttributes
803 37 30 14: SEQUENCE { -- privateRSAKeyAttributes
804 39 30 8: SEQUENCE { -- objectValue
805 41 04 6: OCTET STRING --path
806 : 3F 00 40 16 00 50
807 : }
808 49 02 2: INTEGER 1024 -- modulus
809 : }
810 : }
811 : }
812
813
814 */
815 static gpg_error_t
816 read_ef_prkdf (app_t app, unsigned short fid, prkdf_object_t *result)
817 {
818 gpg_error_t err;
819 unsigned char *buffer = NULL;
820 size_t buflen;
821 const unsigned char *p;
822 size_t n, objlen, hdrlen;
823 int class, tag, constructed, ndef;
824 prkdf_object_t prkdflist = NULL;
825 int i;
826
827 if (!fid)
828 return gpg_error (GPG_ERR_NO_DATA); /* No private keys. */
829
830 err = select_and_read_binary (app->slot, fid, "PrKDF", &buffer, &buflen);
831 if (err)
832 return err;
833
834 p = buffer;
835 n = buflen;
836
837 /* FIXME: This shares a LOT of code with read_ef_cdf! */
838
839 /* Loop over the records. We stop as soon as we detect a new record
840 starting with 0x00 or 0xff as these values are commonly used to
841 pad data blocks and are no valid ASN.1 encoding. */
842 while (n && *p && *p != 0xff)
843 {
844 const unsigned char *pp;
845 size_t nn;
846 int where;
847 const char *errstr = NULL;
848 prkdf_object_t prkdf = NULL;
849 unsigned long ul;
850 const unsigned char *objid;
851 size_t objidlen;
852 const unsigned char *authid = NULL;
853 size_t authidlen = 0;
854 keyusage_flags_t usageflags;
855 unsigned long key_reference = 0;
856 int key_reference_valid = 0;
857 const char *s;
858
859 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
860 &ndef, &objlen, &hdrlen);
861 if (!err && (objlen > n || tag != TAG_SEQUENCE))
862 err = gpg_error (GPG_ERR_INV_OBJ);
863 if (err)
864 {
865 log_error ("error parsing PrKDF record: %s\n", gpg_strerror (err));
866 goto leave;
867 }
868 pp = p;
869 nn = objlen;
870 p += objlen;
871 n -= objlen;
872
873 /* Parse the commonObjectAttributes. */
874 where = __LINE__;
875 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
876 &ndef, &objlen, &hdrlen);
877 if (!err && (objlen > nn || tag != TAG_SEQUENCE))
878 err = gpg_error (GPG_ERR_INV_OBJ);
879 if (err)
880 goto parse_error;
881 {
882 const unsigned char *ppp = pp;
883 size_t nnn = objlen;
884
885 pp += objlen;
886 nn -= objlen;
887
888 /* Search the optional AuthId. We need to skip the optional
889 Label (UTF8STRING) and the optional CommonObjectFlags
890 (BITSTRING). */
891 where = __LINE__;
892 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
893 &ndef, &objlen, &hdrlen);
894 if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
895 err = gpg_error (GPG_ERR_INV_OBJ);
896 if (gpg_err_code (err) == GPG_ERR_EOF)
897 goto no_authid;
898 if (err)
899 goto parse_error;
900 if (tag == TAG_UTF8_STRING)
901 {
902 ppp += objlen; /* Skip the Label. */
903 nnn -= objlen;
904
905 where = __LINE__;
906 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
907 &ndef, &objlen, &hdrlen);
908 if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
909 err = gpg_error (GPG_ERR_INV_OBJ);
910 if (gpg_err_code (err) == GPG_ERR_EOF)
911 goto no_authid;
912 if (err)
913 goto parse_error;
914 }
915 if (tag == TAG_BIT_STRING)
916 {
917 ppp += objlen; /* Skip the CommonObjectFlags. */
918 nnn -= objlen;
919
920 where = __LINE__;
921 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
922 &ndef, &objlen, &hdrlen);
923 if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
924 err = gpg_error (GPG_ERR_INV_OBJ);
925 if (gpg_err_code (err) == GPG_ERR_EOF)
926 goto no_authid;
927 if (err)
928 goto parse_error;
929 }
930 if (tag == TAG_OCTET_STRING && objlen)
931 {
932 authid = ppp;
933 authidlen = objlen;
934 }
935 no_authid:
936 ;
937 }
938
939 /* Parse the commonKeyAttributes. */
940 where = __LINE__;
941 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
942 &ndef, &objlen, &hdrlen);
943 if (!err && (objlen > nn || tag != TAG_SEQUENCE))
944 err = gpg_error (GPG_ERR_INV_OBJ);
945 if (err)
946 goto parse_error;
947 {
948 const unsigned char *ppp = pp;
949 size_t nnn = objlen;
950
951 pp += objlen;
952 nn -= objlen;
953
954 /* Get the Id. */
955 where = __LINE__;
956 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
957 &ndef, &objlen, &hdrlen);
958 if (!err && (objlen > nnn
959 || class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING))
960 err = gpg_error (GPG_ERR_INV_OBJ);
961 if (err)
962 goto parse_error;
963 objid = ppp;
964 objidlen = objlen;
965 ppp += objlen;
966 nnn -= objlen;
967
968 /* Get the KeyUsageFlags. */
969 where = __LINE__;
970 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
971 &ndef, &objlen, &hdrlen);
972 if (!err && (objlen > nnn
973 || class != CLASS_UNIVERSAL || tag != TAG_BIT_STRING))
974 err = gpg_error (GPG_ERR_INV_OBJ);
975 if (err)
976 goto parse_error;
977 err = parse_keyusage_flags (ppp, objlen, &usageflags);
978 if (err)
979 goto parse_error;
980 ppp += objlen;
981 nnn -= objlen;
982
983 /* Find the keyReference */
984 where = __LINE__;
985 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
986 &ndef, &objlen, &hdrlen);
987 if (gpg_err_code (err) == GPG_ERR_EOF)
988 goto leave_cki;
989 if (!err && objlen > nnn)
990 err = gpg_error (GPG_ERR_INV_OBJ);
991 if (err)
992 goto parse_error;
993 if (class == CLASS_UNIVERSAL && tag == TAG_BOOLEAN)
994 {
995 /* Skip the native element. */
996 ppp += objlen;
997 nnn -= objlen;
998
999 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1000 &ndef, &objlen, &hdrlen);
1001 if (gpg_err_code (err) == GPG_ERR_EOF)
1002 goto leave_cki;
1003 if (!err && objlen > nnn)
1004 err = gpg_error (GPG_ERR_INV_OBJ);
1005 if (err)
1006 goto parse_error;
1007 }
1008 if (class == CLASS_UNIVERSAL && tag == TAG_BIT_STRING)
1009 {
1010 /* Skip the accessFlags. */
1011 ppp += objlen;
1012 nnn -= objlen;
1013
1014 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1015 &ndef, &objlen, &hdrlen);
1016 if (gpg_err_code (err) == GPG_ERR_EOF)
1017 goto leave_cki;
1018 if (!err && objlen > nnn)
1019 err = gpg_error (GPG_ERR_INV_OBJ);
1020 if (err)
1021 goto parse_error;
1022 }
1023 if (class == CLASS_UNIVERSAL && tag == TAG_INTEGER)
1024 {
1025 /* Yep, this is the keyReference. */
1026 for (ul=0; objlen; objlen--)
1027 {
1028 ul <<= 8;
1029 ul |= (*ppp++) & 0xff;
1030 nnn--;
1031 }
1032 key_reference = ul;
1033 key_reference_valid = 1;
1034 }
1035
1036 leave_cki:
1037 ;
1038 }
1039
1040
1041 /* Skip subClassAttributes. */
1042 where = __LINE__;
1043 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1044 &ndef, &objlen, &hdrlen);
1045 if (!err && objlen > nn)
1046 err = gpg_error (GPG_ERR_INV_OBJ);
1047 if (err)
1048 goto parse_error;
1049 if (class == CLASS_CONTEXT && tag == 0)
1050 {
1051 pp += objlen;
1052 nn -= objlen;
1053
1054 where = __LINE__;
1055 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1056 &ndef, &objlen, &hdrlen);
1057 }
1058 /* Parse the keyAttributes. */
1059 if (!err && (objlen > nn || class != CLASS_CONTEXT || tag != 1))
1060 err = gpg_error (GPG_ERR_INV_OBJ);
1061 if (err)
1062 goto parse_error;
1063 nn = objlen;
1064
1065 where = __LINE__;
1066 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1067 &ndef, &objlen, &hdrlen);
1068 if (!err && objlen > nn)
1069 err = gpg_error (GPG_ERR_INV_OBJ);
1070 if (err)
1071 goto parse_error;
1072 if (class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE)
1073 ; /* RSA */
1074 else if (class == CLASS_CONTEXT)
1075 {
1076 switch (tag)
1077 {
1078 case 0: errstr = "EC key objects are not supported"; break;
1079 case 1: errstr = "DH key objects are not supported"; break;
1080 case 2: errstr = "DSA key objects are not supported"; break;
1081 case 3: errstr = "KEA key objects are not supported"; break;
1082 default: errstr = "unknown privateKeyObject"; break;
1083 }
1084 goto parse_error;
1085 }
1086 else
1087 {
1088 err = gpg_error (GPG_ERR_INV_OBJ);
1089 goto parse_error;
1090 }
1091
1092 nn = objlen;
1093
1094 /* Check that the reference is a Path object. */
1095 where = __LINE__;
1096 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1097 &ndef, &objlen, &hdrlen);
1098 if (!err && objlen > nn)
1099 err = gpg_error (GPG_ERR_INV_OBJ);
1100 if (err)
1101 goto parse_error;
1102 if (class != CLASS_UNIVERSAL || tag != TAG_SEQUENCE)
1103 {
1104 errstr = "unsupported reference type";
1105 goto parse_error;
1106 }
1107 nn = objlen;
1108
1109 /* Parse the Path object. */
1110 where = __LINE__;
1111 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1112 &ndef, &objlen, &hdrlen);
1113 if (!err && objlen > nn)
1114 err = gpg_error (GPG_ERR_INV_OBJ);
1115 if (err)
1116 goto parse_error;
1117
1118 /* Make sure that the next element is a non zero path and of
1119 even length (FID are two bytes each). */
1120 if (class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING
1121 || !objlen || (objlen & 1) )
1122 {
1123 errstr = "invalid path reference";
1124 goto parse_error;
1125 }
1126 /* Create a new PrKDF list item. */
1127 prkdf = xtrycalloc (1, (sizeof *prkdf
1128 - sizeof(unsigned short)
1129 + objlen/2 * sizeof(unsigned short)));
1130 if (!prkdf)
1131 {
1132 err = gpg_error_from_syserror ();
1133 goto leave;
1134 }
1135 prkdf->objidlen = objidlen;
1136 prkdf->objid = xtrymalloc (objidlen);
1137 if (!prkdf->objid)
1138 {
1139 err = gpg_error_from_syserror ();
1140 xfree (prkdf);
1141 goto leave;
1142 }
1143 memcpy (prkdf->objid, objid, objidlen);
1144 if (authid)
1145 {
1146 prkdf->authidlen = authidlen;
1147 prkdf->authid = xtrymalloc (authidlen);
1148 if (!prkdf->authid)
1149 {
1150 err = gpg_error_from_syserror ();
1151 xfree (prkdf->objid);
1152 xfree (prkdf);
1153 goto leave;
1154 }
1155 memcpy (prkdf->authid, authid, authidlen);
1156 }
1157
1158 prkdf->pathlen = objlen/2;
1159 for (i=0; i < prkdf->pathlen; i++, pp += 2, nn -= 2)
1160 prkdf->path[i] = ((pp[0] << 8) | pp[1]);
1161
1162 prkdf->usageflags = usageflags;
1163 prkdf->key_reference = key_reference;
1164 prkdf->key_reference_valid = key_reference_valid;
1165
1166 if (nn)
1167 {
1168 /* An index and length follows. */
1169 prkdf->have_off = 1;
1170 where = __LINE__;
1171 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1172 &ndef, &objlen, &hdrlen);
1173 if (!err && (objlen > nn
1174 || class != CLASS_UNIVERSAL || tag != TAG_INTEGER))
1175 err = gpg_error (GPG_ERR_INV_OBJ);
1176 if (err)
1177 goto parse_error;
1178
1179 for (ul=0; objlen; objlen--)
1180 {
1181 ul <<= 8;
1182 ul |= (*pp++) & 0xff;
1183 nn--;
1184 }
1185 prkdf->off = ul;
1186
1187 where = __LINE__;
1188 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1189 &ndef, &objlen, &hdrlen);
1190 if (!err && (objlen > nn
1191 || class != CLASS_CONTEXT || tag != 0))
1192 err = gpg_error (GPG_ERR_INV_OBJ);
1193 if (err)
1194 goto parse_error;
1195
1196 for (ul=0; objlen; objlen--)
1197 {
1198 ul <<= 8;
1199 ul |= (*pp++) & 0xff;
1200 nn--;
1201 }
1202 prkdf->len = ul;
1203 }
1204
1205
1206 log_debug ("PrKDF %04hX: id=", fid);
1207 for (i=0; i < prkdf->objidlen; i++)
1208 log_printf ("%02X", prkdf->objid[i]);
1209 log_printf (" path=");
1210 for (i=0; i < prkdf->pathlen; i++)
1211 log_printf ("%04hX", prkdf->path[i]);
1212 if (prkdf->have_off)
1213 log_printf ("[%lu/%lu]", prkdf->off, prkdf->len);
1214 if (prkdf->authid)
1215 {
1216 log_printf (" authid=");
1217 for (i=0; i < prkdf->authidlen; i++)
1218 log_printf ("%02X", prkdf->authid[i]);
1219 }
1220 if (prkdf->key_reference_valid)
1221 log_printf (" keyref=0x%02lX", prkdf->key_reference);
1222 log_printf (" usage=");
1223 s = "";
1224 if (prkdf->usageflags.encrypt) log_printf ("%sencrypt", s), s = ",";
1225 if (prkdf->usageflags.decrypt) log_printf ("%sdecrypt", s), s = ",";
1226 if (prkdf->usageflags.sign ) log_printf ("%ssign", s), s = ",";
1227 if (prkdf->usageflags.sign_recover)
1228 log_printf ("%ssign_recover", s), s = ",";
1229 if (prkdf->usageflags.wrap ) log_printf ("%swrap", s), s = ",";
1230 if (prkdf->usageflags.unwrap ) log_printf ("%sunwrap", s), s = ",";
1231 if (prkdf->usageflags.verify ) log_printf ("%sverify", s), s = ",";
1232 if (prkdf->usageflags.verify_recover)
1233 log_printf ("%sverify_recover", s), s = ",";
1234 if (prkdf->usageflags.derive ) log_printf ("%sderive", s), s = ",";
1235 if (prkdf->usageflags.non_repudiation)
1236 log_printf ("%snon_repudiation", s), s = ",";
1237 log_printf ("\n");
1238
1239 /* Put it into the list. */
1240 prkdf->next = prkdflist;
1241 prkdflist = prkdf;
1242 prkdf = NULL;
1243 continue; /* Ready. */
1244
1245 parse_error:
1246 log_error ("error parsing PrKDF record (%d): %s - skipped\n",
1247 where, errstr? errstr : gpg_strerror (err));
1248 if (prkdf)
1249 {
1250 xfree (prkdf->objid);
1251 xfree (prkdf->authid);
1252 xfree (prkdf);
1253 }
1254 err = 0;
1255 } /* End looping over all records. */
1256
1257 leave:
1258 xfree (buffer);
1259 if (err)
1260 release_prkdflist (prkdflist);
1261 else
1262 *result = prkdflist;
1263 return err;
1264 }
1265
1266
1267 /* Read and parse the Certificate Directory Files identified by FID.
1268 On success a newlist of CDF object gets stored at RESULT and the
1269 caller is then responsible of releasing this list. On error a
1270 error code is returned and RESULT won't get changed. */
1271 static gpg_error_t
1272 read_ef_cdf (app_t app, unsigned short fid, cdf_object_t *result)
1273 {
1274 gpg_error_t err;
1275 unsigned char *buffer = NULL;
1276 size_t buflen;
1277 const unsigned char *p;
1278 size_t n, objlen, hdrlen;
1279 int class, tag, constructed, ndef;
1280 cdf_object_t cdflist = NULL;
1281 int i;
1282
1283 if (!fid)
1284 return gpg_error (GPG_ERR_NO_DATA); /* No certificates. */
1285
1286 err = select_and_read_binary (app->slot, fid, "CDF", &buffer, &buflen);
1287 if (err)
1288 return err;
1289
1290 p = buffer;
1291 n = buflen;
1292
1293 /* Loop over the records. We stop as soon as we detect a new record
1294 starting with 0x00 or 0xff as these values are commonly used to
1295 pad data blocks and are no valid ASN.1 encoding. */
1296 while (n && *p && *p != 0xff)
1297 {
1298 const unsigned char *pp;
1299 size_t nn;
1300 int where;
1301 const char *errstr = NULL;
1302 cdf_object_t cdf = NULL;
1303 unsigned long ul;
1304 const unsigned char *objid;
1305 size_t objidlen;
1306
1307 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1308 &ndef, &objlen, &hdrlen);
1309 if (!err && (objlen > n || tag != TAG_SEQUENCE))
1310 err = gpg_error (GPG_ERR_INV_OBJ);
1311 if (err)
1312 {
1313 log_error ("error parsing CDF record: %s\n", gpg_strerror (err));
1314 goto leave;
1315 }
1316 pp = p;
1317 nn = objlen;
1318 p += objlen;
1319 n -= objlen;
1320
1321 /* Skip the commonObjectAttributes. */
1322 where = __LINE__;
1323 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1324 &ndef, &objlen, &hdrlen);
1325 if (!err && (objlen > nn || tag != TAG_SEQUENCE))
1326 err = gpg_error (GPG_ERR_INV_OBJ);
1327 if (err)
1328 goto parse_error;
1329 pp += objlen;
1330 nn -= objlen;
1331
1332 /* Parse the commonCertificateAttributes. */
1333 where = __LINE__;
1334 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1335 &ndef, &objlen, &hdrlen);
1336 if (!err && (objlen > nn || tag != TAG_SEQUENCE))
1337 err = gpg_error (GPG_ERR_INV_OBJ);
1338 if (err)
1339 goto parse_error;
1340 {
1341 const unsigned char *ppp = pp;
1342 size_t nnn = objlen;
1343
1344 pp += objlen;
1345 nn -= objlen;
1346
1347 /* Get the Id. */
1348 where = __LINE__;
1349 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1350 &ndef, &objlen, &hdrlen);
1351 if (!err && (objlen > nnn
1352 || class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING))
1353 err = gpg_error (GPG_ERR_INV_OBJ);
1354 if (err)
1355 goto parse_error;
1356 objid = ppp;
1357 objidlen = objlen;
1358 }
1359
1360 /* Parse the certAttribute. */
1361 where = __LINE__;
1362 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1363 &ndef, &objlen, &hdrlen);
1364 if (!err && (objlen > nn || class != CLASS_CONTEXT || tag != 1))
1365 err = gpg_error (GPG_ERR_INV_OBJ);
1366 if (err)
1367 goto parse_error;
1368 nn = objlen;
1369
1370 where = __LINE__;
1371 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1372 &ndef, &objlen, &hdrlen);
1373 if (!err && (objlen > nn
1374 || class != CLASS_UNIVERSAL || tag != TAG_SEQUENCE))
1375 err = gpg_error (GPG_ERR_INV_OBJ);
1376 if (err)
1377 goto parse_error;
1378 nn = objlen;
1379
1380 /* Check that the reference is a Path object. */
1381 where = __LINE__;
1382 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1383 &ndef, &objlen, &hdrlen);
1384 if (!err && objlen > nn)
1385 err = gpg_error (GPG_ERR_INV_OBJ);
1386 if (err)
1387 goto parse_error;
1388 if (class != CLASS_UNIVERSAL || tag != TAG_SEQUENCE)
1389 {
1390 errstr = "unsupported reference type";
1391 continue;
1392 }
1393 nn = objlen;
1394
1395 /* Parse the Path object. */
1396 where = __LINE__;
1397 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1398 &ndef, &objlen, &hdrlen);
1399 if (!err && objlen > nn)
1400 err = gpg_error (GPG_ERR_INV_OBJ);
1401 if (err)
1402 goto parse_error;
1403
1404 /* Make sure that the next element is a non zero path and of
1405 even length (FID are two bytes each). */
1406 if (class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING
1407 || !objlen || (objlen & 1) )
1408 {
1409 errstr = "invalid path reference";
1410 goto parse_error;
1411 }
1412 /* Create a new CDF list item. */
1413 cdf = xtrycalloc (1, (sizeof *cdf
1414 - sizeof(unsigned short)
1415 + objlen/2 * sizeof(unsigned short)));
1416 if (!cdf)
1417 {
1418 err = gpg_error_from_syserror ();
1419 goto leave;
1420 }
1421 cdf->objidlen = objidlen;
1422 cdf->objid = xtrymalloc (objidlen);
1423 if (!cdf->objid)
1424 {
1425 err = gpg_error_from_syserror ();
1426 xfree (cdf);
1427 goto leave;
1428 }
1429 memcpy (cdf->objid, objid, objidlen);
1430
1431 cdf->pathlen = objlen/2;
1432 for (i=0; i < cdf->pathlen; i++, pp += 2, nn -= 2)
1433 cdf->path[i] = ((pp[0] << 8) | pp[1]);
1434
1435 if (nn)
1436 {
1437 /* An index and length follows. */
1438 cdf->have_off = 1;
1439 where = __LINE__;
1440 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1441 &ndef, &objlen, &hdrlen);
1442 if (!err && (objlen > nn
1443 || class != CLASS_UNIVERSAL || tag != TAG_INTEGER))
1444 err = gpg_error (GPG_ERR_INV_OBJ);
1445 if (err)
1446 goto parse_error;
1447
1448 for (ul=0; objlen; objlen--)
1449 {
1450 ul <<= 8;
1451 ul |= (*pp++) & 0xff;
1452 nn--;
1453 }
1454 cdf->off = ul;
1455
1456 where = __LINE__;
1457 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1458 &ndef, &objlen, &hdrlen);
1459 if (!err && (objlen > nn
1460 || class != CLASS_CONTEXT || tag != 0))
1461 err = gpg_error (GPG_ERR_INV_OBJ);
1462 if (err)
1463 goto parse_error;
1464
1465 for (ul=0; objlen; objlen--)
1466 {
1467 ul <<= 8;
1468 ul |= (*pp++) & 0xff;
1469 nn--;
1470 }
1471 cdf->len = ul;
1472 }
1473
1474 log_debug ("CDF %04hX: id=", fid);
1475 for (i=0; i < cdf->objidlen; i++)
1476 log_printf ("%02X", cdf->objid[i]);
1477 log_printf (" path=");
1478 for (i=0; i < cdf->pathlen; i++)
1479 log_printf ("%04hX", cdf->path[i]);
1480 if (cdf->have_off)
1481 log_printf ("[%lu/%lu]", cdf->off, cdf->len);
1482 log_printf ("\n");
1483
1484 /* Put it into the list. */
1485 cdf->next = cdflist;
1486 cdflist = cdf;
1487 cdf = NULL;
1488 continue; /* Ready. */
1489
1490 parse_error:
1491 log_error ("error parsing CDF record (%d): %s - skipped\n",
1492 where, errstr? errstr : gpg_strerror (err));
1493 xfree (cdf);
1494 err = 0;
1495 } /* End looping over all records. */
1496
1497 leave:
1498 xfree (buffer);
1499 if (err)
1500 release_cdflist (cdflist);
1501 else
1502 *result = cdflist;
1503 return err;
1504 }
1505
1506
1507 /*
1508 SEQUENCE {
1509 SEQUENCE { -- CommonObjectAttributes
1510 UTF8String 'specific PIN for DS'
1511 BIT STRING 0 unused bits
1512 '00000011'B
1513 }
1514 SEQUENCE { -- CommonAuthenticationObjectAttributes
1515 OCTET STRING
1516 07 -- iD
1517 }
1518
1519 [1] { -- typeAttributes
1520 SEQUENCE { -- PinAttributes
1521 BIT STRING 0 unused bits
1522 '0000100000110010'B -- local,initialized,needs-padding
1523 -- exchangeRefData
1524 ENUMERATED 1 -- ascii-numeric
1525 INTEGER 6 -- minLength
1526 INTEGER 6 -- storedLength
1527 INTEGER 8 -- maxLength
1528 [0]
1529 02 -- pinReference
1530 GeneralizedTime 19/04/2002 12:12 GMT -- lastPinChange
1531 SEQUENCE {
1532 OCTET STRING
1533 3F 00 40 16 -- path to DF of PIN
1534 }
1535 }
1536 }
1537 }
1538
1539 */
1540 /* Read and parse an Authentication Object Directory File identified
1541 by FID. On success a newlist of AODF objects gets stored at RESULT
1542 and the caller is responsible of releasing this list. On error a
1543 error code is returned and RESULT won't get changed. */
1544 static gpg_error_t
1545 read_ef_aodf (app_t app, unsigned short fid, aodf_object_t *result)
1546 {
1547 gpg_error_t err;
1548 unsigned char *buffer = NULL;
1549 size_t buflen;
1550 const unsigned char *p;
1551 size_t n, objlen, hdrlen;
1552 int class, tag, constructed, ndef;
1553 aodf_object_t aodflist = NULL;
1554 int i;
1555
1556 if (!fid)
1557 return gpg_error (GPG_ERR_NO_DATA); /* No authentication objects. */
1558
1559 err = select_and_read_binary (app->slot, fid, "AODF", &buffer, &buflen);
1560 if (err)
1561 return err;
1562
1563 p = buffer;
1564 n = buflen;
1565
1566 /* FIXME: This shares a LOT of code with read_ef_prkdf! */
1567
1568 /* Loop over the records. We stop as soon as we detect a new record
1569 starting with 0x00 or 0xff as these values are commonly used to
1570 pad data blocks and are no valid ASN.1 encoding. */
1571 while (n && *p && *p != 0xff)
1572 {
1573 const unsigned char *pp;
1574 size_t nn;
1575 int where;
1576 const char *errstr = NULL;
1577 aodf_object_t aodf = NULL;
1578 unsigned long ul;
1579 const char *s;
1580
1581 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1582 &ndef, &objlen, &hdrlen);
1583 if (!err && (objlen > n || tag != TAG_SEQUENCE))
1584 err = gpg_error (GPG_ERR_INV_OBJ);
1585 if (err)
1586 {
1587 log_error ("error parsing AODF record: %s\n", gpg_strerror (err));
1588 goto leave;
1589 }
1590 pp = p;
1591 nn = objlen;
1592 p += objlen;
1593 n -= objlen;
1594
1595 /* Allocate memory for a new AODF list item. */
1596 aodf = xtrycalloc (1, sizeof *aodf);
1597 if (!aodf)
1598 goto no_core;
1599
1600 /* Parse the commonObjectAttributes. */
1601 where = __LINE__;
1602 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1603 &ndef, &objlen, &hdrlen);
1604 if (!err && (objlen > nn || tag != TAG_SEQUENCE))
1605 err = gpg_error (GPG_ERR_INV_OBJ);
1606 if (err)
1607 goto parse_error;
1608 {
1609 const unsigned char *ppp = pp;
1610 size_t nnn = objlen;
1611
1612 pp += objlen;
1613 nn -= objlen;
1614
1615 /* Search the optional AuthId. We need to skip the optional
1616 Label (UTF8STRING) and the optional CommonObjectFlags
1617 (BITSTRING). */
1618 where = __LINE__;
1619 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1620 &ndef, &objlen, &hdrlen);
1621 if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
1622 err = gpg_error (GPG_ERR_INV_OBJ);
1623 if (gpg_err_code (err) == GPG_ERR_EOF)
1624 goto no_authid;
1625 if (err)
1626 goto parse_error;
1627 if (tag == TAG_UTF8_STRING)
1628 {
1629 ppp += objlen; /* Skip the Label. */
1630 nnn -= objlen;
1631
1632 where = __LINE__;
1633 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1634 &ndef, &objlen, &hdrlen);
1635 if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
1636 err = gpg_error (GPG_ERR_INV_OBJ);
1637 if (gpg_err_code (err) == GPG_ERR_EOF)
1638 goto no_authid;
1639 if (err)
1640 goto parse_error;
1641 }
1642 if (tag == TAG_BIT_STRING)
1643 {
1644 ppp += objlen; /* Skip the CommonObjectFlags. */
1645 nnn -= objlen;
1646
1647 where = __LINE__;
1648 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1649 &ndef, &objlen, &hdrlen);
1650 if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
1651 err = gpg_error (GPG_ERR_INV_OBJ);
1652 if (gpg_err_code (err) == GPG_ERR_EOF)
1653 goto no_authid;
1654 if (err)
1655 goto parse_error;
1656 }
1657 if (tag == TAG_OCTET_STRING && objlen)
1658 {
1659 aodf->authidlen = objlen;
1660 aodf->authid = xtrymalloc (objlen);
1661 if (!aodf->authid)
1662 goto no_core;
1663 memcpy (aodf->authid, ppp, objlen);
1664 }
1665 no_authid:
1666 ;
1667 }
1668
1669 /* Parse the CommonAuthenticationObjectAttributes. */
1670 where = __LINE__;
1671 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1672 &ndef, &objlen, &hdrlen);
1673 if (!err && (objlen > nn || tag != TAG_SEQUENCE))
1674 err = gpg_error (GPG_ERR_INV_OBJ);
1675 if (err)
1676 goto parse_error;
1677 {
1678 const unsigned char *ppp = pp;
1679 size_t nnn = objlen;
1680
1681 pp += objlen;
1682 nn -= objlen;
1683
1684 /* Get the Id. */
1685 where = __LINE__;
1686 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1687 &ndef, &objlen, &hdrlen);
1688 if (!err && (objlen > nnn
1689 || class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING))
1690 err = gpg_error (GPG_ERR_INV_OBJ);
1691 if (err)
1692 goto parse_error;
1693
1694 aodf->objidlen = objlen;
1695 aodf->objid = xtrymalloc (objlen);
1696 if (!aodf->objid)
1697 goto no_core;
1698 memcpy (aodf->objid, ppp, objlen);
1699 }
1700
1701 /* Parse the typeAttributes. */
1702 where = __LINE__;
1703 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1704 &ndef, &objlen, &hdrlen);
1705 if (!err && (objlen > nn || class != CLASS_CONTEXT || tag != 1))
1706 err = gpg_error (GPG_ERR_INV_OBJ);
1707 if (err)
1708 goto parse_error;
1709 nn = objlen;
1710
1711 where = __LINE__;
1712 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1713 &ndef, &objlen, &hdrlen);
1714 if (!err && objlen > nn)
1715 err = gpg_error (GPG_ERR_INV_OBJ);
1716 if (err)
1717 goto parse_error;
1718 if (class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE)
1719 ; /* PinAttributes */
1720 else if (class == CLASS_CONTEXT)
1721 {
1722 switch (tag)
1723 {
1724 case 0: errstr = "biometric auth types are not supported"; break;
1725 case 1: errstr = "authKey auth types are not supported"; break;
1726 case 2: errstr = "external auth type are not supported"; break;
1727 default: errstr = "unknown privateKeyObject"; break;
1728 }
1729 goto parse_error;
1730 }
1731 else
1732 {
1733 err = gpg_error (GPG_ERR_INV_OBJ);
1734 goto parse_error;
1735 }
1736
1737 nn = objlen;
1738
1739 /* PinFlags */
1740 where = __LINE__;
1741 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1742 &ndef, &objlen, &hdrlen);
1743 if (!err && (objlen > nn || !objlen
1744 || class != CLASS_UNIVERSAL || tag != TAG_BIT_STRING))
1745 err = gpg_error (GPG_ERR_INV_OBJ);
1746 if (err)
1747 goto parse_error;
1748
1749 {
1750 unsigned int bits, mask;
1751 int unused, full;
1752
1753 unused = *pp++; nn--; objlen--;
1754 if ((!objlen && unused) || unused/8 > objlen)
1755 {
1756 err = gpg_error (GPG_ERR_ENCODING_PROBLEM);
1757 goto parse_error;
1758 }
1759 full = objlen - (unused+7)/8;
1760 unused %= 8;
1761 mask = 0;
1762 for (i=1; unused; i <<= 1, unused--)
1763 mask |= i;
1764
1765 /* The first octet */
1766 bits = 0;
1767 if (objlen)
1768 {
1769 bits = *pp++; nn--; objlen--;
1770 if (full)
1771 full--;
1772 else
1773 {
1774 bits &= ~mask;
1775 mask = 0;
1776 }
1777 }
1778 if ((bits & 0x80)) /* ASN.1 bit 0. */
1779 aodf->pinflags.case_sensitive = 1;
1780 if ((bits & 0x40)) /* ASN.1 bit 1. */
1781 aodf->pinflags.local = 1;
1782 if ((bits & 0x20))
1783 aodf->pinflags.change_disabled = 1;
1784 if ((bits & 0x10))
1785 aodf->pinflags.unblock_disabled = 1;
1786 if ((bits & 0x08))
1787 aodf->pinflags.initialized = 1;
1788 if ((bits & 0x04))
1789 aodf->pinflags.needs_padding = 1;
1790 if ((bits & 0x02))
1791 aodf->pinflags.unblocking_pin = 1;
1792 if ((bits & 0x01))
1793 aodf->pinflags.so_pin = 1;
1794 /* The second octet. */
1795 bits = 0;
1796 if (objlen)
1797 {
1798 bits = *pp++; nn--; objlen--;
1799 if (full)
1800 full--;
1801 else
1802 {
1803 bits &= ~mask;
1804 mask = 0;
1805 }
1806 }
1807 if ((bits & 0x80))
1808 aodf->pinflags.disable_allowed = 1;
1809 if ((bits & 0x40))
1810 aodf->pinflags.integrity_protected = 1;
1811 if ((bits & 0x20))
1812 aodf->pinflags.confidentiality_protected = 1;
1813 if ((bits & 0x10))
1814 aodf->pinflags.exchange_ref_data = 1;
1815 /* Skip remaining bits. */
1816 pp += objlen;
1817 nn -= objlen;
1818 }
1819
1820
1821 /* PinType */
1822 where = __LINE__;
1823 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1824 &ndef, &objlen, &hdrlen);
1825 if (!err && (objlen > nn
1826 || class != CLASS_UNIVERSAL || tag != TAG_ENUMERATED))
1827 err = gpg_error (GPG_ERR_INV_OBJ);
1828 if (!err && (objlen > sizeof (pin_type_t) || objlen > sizeof (ul)))
1829 err = gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
1830 if (err)
1831 goto parse_error;
1832
1833 for (ul=0; objlen; objlen--)
1834 {
1835 ul <<= 8;
1836 ul |= (*pp++) & 0xff;
1837 nn--;
1838 }
1839 aodf->pintype = ul;
1840
1841
1842 /* minLength */
1843 where = __LINE__;
1844 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1845 &ndef, &objlen, &hdrlen);
1846 if (!err && (objlen > nn
1847 || class != CLASS_UNIVERSAL || tag != TAG_INTEGER))
1848 err = gpg_error (GPG_ERR_INV_OBJ);
1849 if (!err && objlen > sizeof (ul))
1850 err = gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
1851 if (err)
1852 goto parse_error;
1853 for (ul=0; objlen; objlen--)
1854 {
1855 ul <<= 8;
1856 ul |= (*pp++) & 0xff;
1857 nn--;
1858 }
1859 aodf->min_length = ul;
1860
1861
1862 /* storedLength */
1863 where = __LINE__;
1864 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1865 &ndef, &objlen, &hdrlen);
1866 if (!err && (objlen > nn
1867 || class != CLASS_UNIVERSAL || tag != TAG_INTEGER))
1868 err = gpg_error (GPG_ERR_INV_OBJ);
1869 if (!err && objlen > sizeof (ul))
1870 err = gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
1871 if (err)
1872 goto parse_error;
1873 for (ul=0; objlen; objlen--)
1874 {
1875 ul <<= 8;
1876 ul |= (*pp++) & 0xff;
1877 nn--;
1878 }
1879 aodf->stored_length = ul;
1880
1881 /* optional maxLength */
1882 where = __LINE__;
1883 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1884 &ndef, &objlen, &hdrlen);
1885 if (gpg_err_code (err) == GPG_ERR_EOF)
1886 goto ready;
1887 if (!err && objlen > nn)
1888 err = gpg_error (GPG_ERR_INV_OBJ);
1889 if (err)
1890 goto parse_error;
1891 if (class == CLASS_UNIVERSAL && tag == TAG_INTEGER)
1892 {
1893 if (objlen > sizeof (ul))
1894 {
1895 err = gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
1896 goto parse_error;
1897 }
1898 for (ul=0; objlen; objlen--)
1899 {
1900 ul <<= 8;
1901 ul |= (*pp++) & 0xff;
1902 nn--;
1903 }
1904 aodf->max_length = ul;
1905 aodf->max_length_valid = 1;
1906
1907 where = __LINE__;
1908 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1909 &ndef, &objlen, &hdrlen);
1910 if (gpg_err_code (err) == GPG_ERR_EOF)
1911 goto ready;
1912 if (!err && objlen > nn)
1913 err = gpg_error (GPG_ERR_INV_OBJ);
1914 if (err)
1915 goto parse_error;
1916 }
1917
1918 /* Optional pinReference. */
1919 if (class == CLASS_CONTEXT && tag == 0)
1920 {
1921 if (objlen > sizeof (ul))
1922 {
1923 err = gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
1924 goto parse_error;
1925 }
1926 for (ul=0; objlen; objlen--)
1927 {
1928 ul <<= 8;
1929 ul |= (*pp++) & 0xff;
1930 nn--;
1931 }
1932 aodf->pin_reference = ul;
1933 aodf->pin_reference_valid = 1;
1934
1935 where = __LINE__;
1936 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1937 &ndef, &objlen, &hdrlen);
1938 if (gpg_err_code (err) == GPG_ERR_EOF)
1939 goto ready;
1940 if (!err && objlen > nn)
1941 err = gpg_error (GPG_ERR_INV_OBJ);
1942 if (err)
1943 goto parse_error;
1944 }
1945
1946 /* Optional padChar. */
1947 if (class == CLASS_UNIVERSAL && tag == TAG_OCTET_STRING)
1948 {
1949 if (objlen != 1)
1950 {
1951 errstr = "padChar is not of size(1)";
1952 goto parse_error;
1953 }
1954 aodf->pad_char = *pp++; nn--;
1955 aodf->pad_char_valid = 1;
1956
1957 where = __LINE__;
1958 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1959 &ndef, &objlen, &hdrlen);
1960 if (gpg_err_code (err) == GPG_ERR_EOF)
1961 goto ready;
1962 if (!err && objlen > nn)
1963 err = gpg_error (GPG_ERR_INV_OBJ);
1964 if (err)
1965 goto parse_error;
1966 }
1967
1968 /* Skip optional lastPinChange. */
1969 if (class == CLASS_UNIVERSAL && tag == TAG_GENERALIZED_TIME)
1970 {
1971 pp += objlen;
1972 nn -= objlen;
1973
1974 where = __LINE__;
1975 err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1976 &ndef, &objlen, &hdrlen);
1977 if (gpg_err_code (err) == GPG_ERR_EOF)
1978 goto ready;
1979 if (!err && objlen > nn)
1980 err = gpg_error (GPG_ERR_INV_OBJ);
1981 if (err)
1982 goto parse_error;
1983 }
1984
1985 /* Optional Path object. */
1986 if (class == CLASS_UNIVERSAL || tag == TAG_SEQUENCE)
1987 {
1988 const unsigned char *ppp = pp;
1989 size_t nnn = objlen;
1990
1991 pp += objlen;
1992 nn -= objlen;
1993
1994 where = __LINE__;
1995 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1996 &ndef, &objlen, &hdrlen);
1997 if (!err && objlen > nnn)
1998 err = gpg_error (GPG_ERR_INV_OBJ);
1999 if (err)
2000 goto parse_error;
2001
2002 /* Make sure that the next element is a non zero FID and of
2003 even length (FID are two bytes each). */
2004 if (class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING
2005 || !objlen || (objlen & 1) )
2006 {
2007 errstr = "invalid path reference";
2008 goto parse_error;
2009 }
2010
2011 aodf->pathlen = objlen/2;
2012 aodf->path = xtrymalloc (aodf->pathlen);
2013 if (!aodf->path)
2014 goto no_core;
2015 for (i=0; i < aodf->pathlen; i++, ppp += 2, nnn -= 2)
2016 aodf->path[i] = ((ppp[0] << 8) | ppp[1]);
2017
2018 if (nnn)
2019 {
2020 /* An index and length follows. */
2021 aodf->have_off = 1;
2022 where = __LINE__;
2023 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
2024 &ndef, &objlen, &hdrlen);
2025 if (!err && (objlen > nnn
2026 || class != CLASS_UNIVERSAL || tag != TAG_INTEGER))
2027 err = gpg_error (GPG_ERR_INV_OBJ);
2028 if (err)
2029 goto parse_error;
2030
2031 for (ul=0; objlen; objlen--)
2032 {
2033 ul <<= 8;
2034 ul |= (*ppp++) & 0xff;
2035 nnn--;
2036 }
2037 aodf->off = ul;
2038
2039 where = __LINE__;
2040 err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
2041 &ndef, &objlen, &hdrlen);
2042 if (!err && (objlen > nnn
2043 || class != CLASS_CONTEXT || tag != 0))
2044 err = gpg_error (GPG_ERR_INV_OBJ);
2045 if (err)
2046 goto parse_error;
2047
2048 for (ul=0; objlen; objlen--)
2049 {
2050 ul <<= 8;
2051 ul |= (*ppp++) & 0xff;
2052 nnn--;
2053 }
2054 aodf->len = ul;
2055 }
2056 }
2057
2058 /* Igonore further objects which might be there due to future
2059 extensions of pkcs#15. */
2060
2061 ready:
2062 log_debug ("AODF %04hX: id=", fid);
2063 for (i=0; i < aodf->objidlen; i++)
2064 log_printf ("%02X", aodf->objid[i]);
2065 if (aodf->authid)
2066 {
2067 log_printf (" authid=");
2068 for (i=0; i < aodf->authidlen; i++)
2069 log_printf ("%02X", aodf->authid[i]);
2070 }
2071 log_printf (" flags=");
2072 s = "";
2073 if (aodf->pinflags.case_sensitive)
2074 log_printf ("%scase_sensitive", s), s = ",";
2075 if (aodf->pinflags.local)
2076 log_printf ("%slocal", s), s = ",";
2077 if (aodf->pinflags.change_disabled)
2078 log_printf ("%schange_disabled", s), s = ",";
2079 if (aodf->pinflags.unblock_disabled)
2080 log_printf ("%sunblock_disabled", s), s = ",";
2081 if (aodf->pinflags.initialized)
2082 log_printf ("%sinitialized", s), s = ",";
2083 if (aodf->pinflags.needs_padding)
2084 log_printf ("%sneeds_padding", s), s = ",";
2085 if (aodf->pinflags.unblocking_pin)
2086 log_printf ("%sunblocking_pin", s), s = ",";
2087 if (aodf->pinflags.so_pin)
2088 log_printf ("%sso_pin", s), s = ",";
2089 if (aodf->pinflags.disable_allowed)
2090 log_printf ("%sdisable_allowed", s), s = ",";
2091 if (aodf->pinflags.integrity_protected)
2092 log_printf ("%sintegrity_protected", s), s = ",";
2093 if (aodf->pinflags.confidentiality_protected)
2094 log_printf ("%sconfidentiality_protected", s), s = ",";
2095 if (aodf->pinflags.exchange_ref_data)
2096 log_printf ("%sexchange_ref_data", s), s = ",";
2097 {
2098 char numbuf[50];
2099 switch (aodf->pintype)
2100 {
2101 case PIN_TYPE_BCD: s = "bcd"; break;
2102 case PIN_TYPE_ASCII_NUMERIC: s = "ascii-numeric"; break;
2103 case PIN_TYPE_UTF8: s = "utf8"; break;
2104 case PIN_TYPE_HALF_NIBBLE_BCD: s = "half-nibble-bcd"; break;
2105 case PIN_TYPE_ISO9564_1: s = "iso9564-1"; break;
2106 default:
2107 sprintf (numbuf, "%lu", (unsigned long)aodf->pintype);
2108 s = numbuf;
2109 }
2110 log_printf (" type=%s", s);
2111 }
2112 log_printf (" min=%lu", aodf->min_length);
2113 log_printf (" stored=%lu", aodf->stored_length);
2114 if (aodf->max_length_valid)
2115 log_printf (" max=%lu", aodf->max_length);
2116 if (aodf->pad_char_valid)
2117 log_printf (" pad=0x%02x", aodf->pad_char);
2118 if (aodf->pin_reference_valid)
2119 log_printf (" pinref=0x%02lX", aodf->pin_reference);
2120 if (aodf->pathlen)
2121 {
2122 log_printf (" path=");
2123 for (i=0; i < aodf->pathlen; i++)
2124 log_printf ("%04hX", aodf->path[i]);
2125 if (aodf->have_off)
2126 log_printf ("[%lu/%lu]", aodf->off, aodf->len);
2127 }
2128 log_printf ("\n");
2129
2130 /* Put it into the list. */
2131 aodf->next = aodflist;
2132 aodflist = aodf;
2133 aodf = NULL;
2134 continue; /* Ready. */
2135
2136 no_core:
2137 err = gpg_error_from_syserror ();
2138 release_aodf_object (aodf);
2139 goto leave;
2140
2141 parse_error:
2142 log_error ("error parsing AODF record (%d): %s - skipped\n",
2143 where, errstr? errstr : gpg_strerror (err));
2144 err = 0;
2145 release_aodf_object (aodf);
2146 } /* End looping over all records. */
2147
2148 leave:
2149 xfree (buffer);
2150 if (err)
2151 release_aodflist (aodflist);
2152 else
2153 *result = aodflist;
2154 return err;
2155 }
2156
2157
2158
2159
2160
2161 /* Read and parse the EF(TokenInfo).
2162
2163 TokenInfo ::= SEQUENCE {
2164 version INTEGER {v1(0)} (v1,...),
2165 serialNumber OCTET STRING,
2166 manufacturerID Label OPTIONAL,
2167 label [0] Label OPTIONAL,
2168 tokenflags TokenFlags,
2169 seInfo SEQUENCE OF SecurityEnvironmentInfo OPTIONAL,
2170 recordInfo [1] RecordInfo OPTIONAL,
2171 supportedAlgorithms [2] SEQUENCE OF AlgorithmInfo OPTIONAL,
2172 ...,
2173 issuerId [3] Label OPTIONAL,
2174 holderId [4] Label OPTIONAL,
2175 lastUpdate [5] LastUpdate OPTIONAL,
2176 preferredLanguage PrintableString OPTIONAL -- In accordance with
2177 -- IETF RFC 1766
2178 } (CONSTRAINED BY { -- Each AlgorithmInfo.reference value must be unique --})
2179
2180 TokenFlags ::= BIT STRING {
2181 readonly (0),
2182 loginRequired (1),
2183 prnGeneration (2),
2184 eidCompliant (3)
2185 }
2186
2187
2188 5032:
2189
2190 30 31 02 01 00 04 04 05 45 36 9F 0C 0C 44 2D 54 01......E6...D-T
2191 72 75 73 74 20 47 6D 62 48 80 14 4F 66 66 69 63 rust GmbH..Offic
2192 65 20 69 64 65 6E 74 69 74 79 20 63 61 72 64 03 e identity card.
2193 02 00 40 20 63 61 72 64 03 02 00 40 00 00 00 00 ..@ card...@....
2194 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
2195
2196 0 49: SEQUENCE {
2197 2 1: INTEGER 0
2198 5 4: OCTET STRING 05 45 36 9F
2199 11 12: UTF8String 'D-Trust GmbH'
2200 25 20: [0] 'Office identity card'
2201 47 2: BIT STRING
2202 : '00000010'B (bit 1)
2203 : Error: Spurious zero bits in bitstring.
2204 : }
2205
2206
2207
2208
2209 */
2210 static gpg_error_t
2211 read_ef_tokeninfo (app_t app)
2212 {
2213 gpg_error_t err;
2214 unsigned char *buffer = NULL;
2215 size_t buflen;
2216 const unsigned char *p;
2217 size_t n, objlen, hdrlen;
2218 int class, tag, constructed, ndef;
2219 unsigned long ul;
2220
2221 err = select_and_read_binary (app->slot, 0x5032, "TokenInfo",
2222 &buffer, &buflen);
2223 if (err)
2224 return err;
2225
2226 p = buffer;
2227 n = buflen;
2228
2229 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
2230 &ndef, &objlen, &hdrlen);
2231 if (!err && (objlen > n || tag != TAG_SEQUENCE))
2232 err = gpg_error (GPG_ERR_INV_OBJ);
2233 if (err)
2234 {
2235 log_error ("error parsing TokenInfo: %s\n", gpg_strerror (err));
2236 goto leave;
2237 }
2238
2239 n = objlen;
2240
2241 /* Version. */
2242 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
2243 &ndef, &objlen, &hdrlen);
2244 if (!err && (objlen > n || tag != TAG_INTEGER))
2245 err = gpg_error (GPG_ERR_INV_OBJ);
2246 if (err)
2247 goto leave;
2248
2249 for (ul=0; objlen; objlen--)
2250 {
2251 ul <<= 8;
2252 ul |= (*p++) & 0xff;
2253 n--;
2254 }
2255 if (ul)
2256 {
2257 log_error ("invalid version %lu in TokenInfo\n", ul);
2258 err = gpg_error (GPG_ERR_INV_OBJ);
2259 goto leave;
2260 }
2261
2262 /* serialNumber. */
2263 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
2264 &ndef, &objlen, &hdrlen);
2265 if (!err && (objlen > n || tag != TAG_OCTET_STRING || !objlen))
2266 err = gpg_error (GPG_ERR_INV_OBJ);
2267 if (err)
2268 goto leave;
2269
2270 xfree (app->app_local->serialno);
2271 app->app_local->serialno = xtrymalloc (objlen);
2272 if (!app->app_local->serialno)
2273 {
2274 err = gpg_error_from_syserror ();
2275 goto leave;
2276 }
2277 memcpy (app->app_local->serialno, p, objlen);
2278 app->app_local->serialnolen = objlen;
2279 log_printhex ("Serialnumber from EF(TokenInfo) is:", p, objlen);
2280
2281 leave:
2282 xfree (buffer);
2283 return err;
2284 }
2285
2286
2287 /* Get all the basic information from the pkcs#15 card, check the
2288 structure and initialize our local context. This is used once at
2289 application initialization. */
2290 static gpg_error_t
2291 read_p15_info (app_t app)
2292 {
2293 gpg_error_t err;
2294
2295 if (!read_ef_tokeninfo (app))
2296 {
2297 /* If we don't have a serial number yet but the TokenInfo provides
2298 one, use that. */
2299 if (!app->serialno && app->app_local->serialno)
2300 {
2301 app->serialno = app->app_local->serialno;
2302 app->serialnolen = app->app_local->serialnolen;
2303 app->app_local->serialno = NULL;
2304 app->app_local->serialnolen = 0;
2305 err = app_munge_serialno (app);
2306 if (err)
2307 return err;
2308 }
2309 }
2310
2311 /* Read the ODF so that we know the location of all directory
2312 files. */
2313 /* Fixme: We might need to get a non-standard ODF FID from TokenInfo. */
2314 err = read_ef_odf (app, 0x5031);
2315 if (err)
2316 return err;
2317
2318 /* Read certificate information. */
2319 assert (!app->app_local->certificate_info);
2320 assert (!app->app_local->trusted_certificate_info);
2321 assert (!app->app_local->useful_certificate_info);
2322 err = read_ef_cdf (app, app->app_local->odf.certificates,
2323 &app->app_local->certificate_info);
2324 if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
2325 err = read_ef_cdf (app, app->app_local->odf.trusted_certificates,
2326 &app->app_local->trusted_certificate_info);
2327 if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
2328 err = read_ef_cdf (app, app->app_local->odf.useful_certificates,
2329 &app->app_local->useful_certificate_info);
2330 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
2331 err = 0;
2332 if (err)
2333 return err;
2334
2335 /* Read information about private keys. */
2336 assert (!app->app_local->private_key_info);
2337 err = read_ef_prkdf (app, app->app_local->odf.private_keys,
2338 &app->app_local->private_key_info);
2339 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
2340 err = 0;
2341 if (err)
2342 return err;
2343
2344 /* Read information about authentication objects. */
2345 assert (!app->app_local->auth_object_info);
2346 err = read_ef_aodf (app, app->app_local->odf.auth_objects,
2347 &app->app_local->auth_object_info);
2348 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
2349 err = 0;
2350
2351
2352 return err;
2353 }
2354
2355
2356 /* Helper to do_learn_status: Send information about all certificates
2357 listed in CERTINFO back. Use CERTTYPE as type of the
2358 certificate. */
2359 static gpg_error_t
2360 send_certinfo (app_t app, ctrl_t ctrl, const char *certtype,
2361 cdf_object_t certinfo)
2362 {
2363 for (; certinfo; certinfo = certinfo->next)
2364 {
2365 char *buf, *p;
2366
2367 buf = xtrymalloc (9 + certinfo->objidlen*2 + 1);
2368 if (!buf)
2369 return gpg_error_from_syserror ();
2370 p = stpcpy (buf, "P15");
2371 if (app->app_local->home_df)
2372 {
2373 sprintf (p, "-%04hX", (app->app_local->home_df & 0xffff));
2374 p += 5;
2375 }
2376 p = stpcpy (p, ".");
2377 bin2hex (certinfo->objid, certinfo->objidlen, p);
2378
2379 send_status_info (ctrl, "CERTINFO",
2380 certtype, strlen (certtype),
2381 buf, strlen (buf),
2382 NULL, (size_t)0);
2383 xfree (buf);
2384 }
2385 return 0;
2386 }
2387
2388
2389 /* Get the keygrip of the private key object PRKDF. On success the
2390 keygrip gets returned in the caller provided 41 byte buffer
2391 R_GRIPSTR. */
2392 static gpg_error_t
2393 keygripstr_from_prkdf (app_t app, prkdf_object_t prkdf, char *r_gripstr)
2394 {
2395 gpg_error_t err;
2396 cdf_object_t cdf;
2397 unsigned char *der;
2398 size_t derlen;
2399 ksba_cert_t cert;
2400
2401 /* FIXME: We should check whether a public key directory file and a
2402 matching public key for PRKDF is available. This should make
2403 extraction of the key much easier. My current test card doesn't
2404 have one, so we can only use the fallback solution bu looking for
2405 a matching certificate and extract the key from there. */
2406
2407 /* Look for a matching certificate. A certificate matches if the Id
2408 matches the obne of the private key info. */
2409 for (cdf = app->app_local->certificate_info; cdf; cdf = cdf->next)
2410 if (cdf->objidlen == prkdf->objidlen
2411 && !memcmp (cdf->objid, prkdf->objid, prkdf->objidlen))
2412 break;
2413 if (!cdf)
2414 for (cdf = app->app_local->trusted_certificate_info; cdf; cdf = cdf->next)
2415 if (cdf->objidlen == prkdf->objidlen
2416 && !memcmp (cdf->objid, prkdf->objid, prkdf->objidlen))
2417 break;
2418 if (!cdf)
2419 for (cdf = app->app_local->useful_certificate_info; cdf; cdf = cdf->next)
2420 if (cdf->objidlen == prkdf->objidlen
2421 && !memcmp (cdf->objid, prkdf->objid, prkdf->objidlen))
2422 break;
2423 if (!cdf)
2424 return gpg_error (GPG_ERR_NOT_FOUND);
2425
2426 err = readcert_by_cdf (app, cdf, &der, &derlen);
2427 if (err)
2428 return err;
2429
2430 err = ksba_cert_new (&cert);
2431 if (!err)
2432 err = ksba_cert_init_from_mem (cert, der, derlen);
2433 xfree (der);
2434 if (!err)
2435 err = app_help_get_keygrip_string (cert, r_gripstr);
2436 ksba_cert_release (cert);
2437
2438 return err;
2439 }
2440
2441
2442
2443
2444 /* Helper to do_learn_status: Send information about all known
2445 keypairs back. FIXME: much code duplication from
2446 send_sertinfo(). */
2447 static gpg_error_t
2448 send_keypairinfo (app_t app, ctrl_t ctrl, prkdf_object_t keyinfo)
2449 {
2450 gpg_error_t err;
2451
2452 for (; keyinfo; keyinfo = keyinfo->next)
2453 {
2454 char gripstr[40+1];
2455 char *buf, *p;
2456 int j;
2457
2458 buf = xtrymalloc (9 + keyinfo->objidlen*2 + 1);
2459 if (!buf)
2460 return gpg_error_from_syserror ();
2461 p = stpcpy (buf, "P15");
2462 if (app->app_local->home_df)
2463 {
2464 sprintf (p, "-%04hX", (app->app_local->home_df & 0xffff));
2465 p += 5;
2466 }
2467 p = stpcpy (p, ".");
2468 bin2hex (keyinfo->objid, keyinfo->objidlen, p);
2469
2470 err = keygripstr_from_prkdf (app, keyinfo, gripstr);
2471 if (err)
2472 {
2473 log_error ("can't get keygrip from ");
2474 for (j=0; j < keyinfo->pathlen; j++)
2475 log_printf ("%04hX", keyinfo->path[j]);
2476 log_printf (": %s\n", gpg_strerror (err));
2477 }
2478 else
2479 {
2480 assert (strlen (gripstr) == 40);
2481 send_status_info (ctrl, "KEYPAIRINFO",
2482 gripstr, 40,
2483 buf, strlen (buf),
2484 NULL, (size_t)0);
2485 }
2486 xfree (buf);
2487 }
2488 return 0;
2489 }
2490
2491
2492
2493 /* This is the handler for the LEARN command. */
2494 static gpg_error_t
2495 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
2496 {
2497 gpg_error_t err;
2498
2499 if ((flags & 1))
2500 err = 0;
2501 else
2502 {
2503 err = send_certinfo (app, ctrl, "100", app->app_local->certificate_info);
2504 if (!err)
2505 err = send_certinfo (app, ctrl, "101",
2506 app->app_local->trusted_certificate_info);
2507 if (!err)
2508 err = send_certinfo (app, ctrl, "102",
2509 app->app_local->useful_certificate_info);
2510 }
2511
2512 if (!err)
2513 err = send_keypairinfo (app, ctrl, app->app_local->private_key_info);
2514
2515 return err;
2516 }
2517
2518
2519 /* Read a certifciate using the information in CDF and return the
2520 certificate in a newly llocated buffer R_CERT and its length
2521 R_CERTLEN. */
2522 static gpg_error_t
2523 readcert_by_cdf (app_t app, cdf_object_t cdf,
2524 unsigned char **r_cert, size_t *r_certlen)
2525 {
2526 gpg_error_t err;
2527 unsigned char *buffer = NULL;
2528 const unsigned char *p, *save_p;
2529 size_t buflen, n;
2530 int class, tag, constructed, ndef;
2531 size_t totobjlen, objlen, hdrlen;
2532 int rootca;
2533 int i;
2534
2535 *r_cert = NULL;
2536 *r_certlen = 0;
2537
2538 /* First check whether it has been cached. */
2539 if (cdf->image)
2540 {
2541 *r_cert = xtrymalloc (cdf->imagelen);
2542 if (!*r_cert)
2543 return gpg_error_from_syserror ();
2544 memcpy (*r_cert, cdf->image, cdf->imagelen);
2545 *r_certlen = cdf->imagelen;
2546 return 0;
2547 }
2548
2549 /* Read the entire file. fixme: This could be optimized by first
2550 reading the header to figure out how long the certificate
2551 actually is. */
2552 err = select_ef_by_path (app, cdf->path, cdf->pathlen);
2553 if (err)
2554 goto leave;
2555
2556 err = iso7816_read_binary (app->slot, cdf->off, cdf->len, &buffer, &buflen);
2557 if (!err && (!buflen || *buffer == 0xff))
2558 err = gpg_error (GPG_ERR_NOT_FOUND);
2559 if (err)
2560 {
2561 log_error ("error reading certificate with Id ");
2562 for (i=0; i < cdf->objidlen; i++)
2563 log_printf ("%02X", cdf->objid[i]);
2564 log_printf (": %s\n", gpg_strerror (err));
2565 goto leave;
2566 }
2567
2568 /* Check whether this is really a certificate. */
2569 p = buffer;
2570 n = buflen;
2571 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
2572 &ndef, &objlen, &hdrlen);
2573 if (err)
2574 goto leave;
2575
2576 if (class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed)
2577 rootca = 0;
2578 else if ( class == CLASS_UNIVERSAL && tag == TAG_SET && constructed )
2579 rootca = 1;
2580 else
2581 {
2582 err = gpg_error (GPG_ERR_INV_OBJ);
2583 goto leave;
2584 }
2585 totobjlen = objlen + hdrlen;
2586 assert (totobjlen <= buflen);
2587
2588 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
2589 &ndef, &objlen, &hdrlen);
2590 if (err)
2591 goto leave;
2592
2593 if (!rootca
2594 && class == CLASS_UNIVERSAL && tag == TAG_OBJECT_ID && !constructed)
2595 {
2596 /* The certificate seems to be contained in a userCertificate
2597 container. Skip this and assume the following sequence is
2598 the certificate. */
2599 if (n < objlen)
2600 {
2601 err = gpg_error (GPG_ERR_INV_OBJ);
2602 goto leave;
2603 }
2604 p += objlen;
2605 n -= objlen;
2606 save_p = p;
2607 err = parse_ber_header (&p, &n, &class, &tag, &constructed,
2608 &ndef, &objlen, &hdrlen);
2609 if (err)
2610 goto leave;
2611 if ( !(class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed) )
2612 {
2613 err = gpg_error (GPG_ERR_INV_OBJ);
2614 goto leave;
2615 }
2616 totobjlen = objlen + hdrlen;
2617 assert (save_p + totobjlen <= buffer + buflen);
2618 memmove (buffer, save_p, totobjlen);
2619 }
2620
2621 *r_cert = buffer;
2622 buffer = NULL;
2623 *r_certlen = totobjlen;
2624
2625 /* Try to cache it. */
2626 if (!cdf->image && (cdf->image = xtrymalloc (*r_certlen)))
2627 {
2628 memcpy (cdf->image, *r_cert, *r_certlen);
2629 cdf->imagelen = *r_certlen;
2630 }
2631
2632
2633 leave:
2634 xfree (buffer);
2635 return err;
2636 }
2637
2638
2639 /* Handler for the READCERT command.
2640
2641 Read the certificate with id CERTID (as returned by learn_status in
2642 the CERTINFO status lines) and return it in the freshly allocated
2643 buffer to be stored at R_CERT and its length at R_CERTLEN. A error
2644 code will be returned on failure and R_CERT and R_CERTLEN will be
2645 set to NULL/0. */
2646 static gpg_error_t
2647 do_readcert (app_t app, const char *certid,
2648 unsigned char **r_cert, size_t *r_certlen)
2649 {
2650 gpg_error_t err;
2651 cdf_object_t cdf;
2652
2653 *r_cert = NULL;
2654 *r_certlen = 0;
2655 err = cdf_object_from_certid (app, certid, &cdf);
2656 if (!err)
2657 err =readcert_by_cdf (app, cdf, r_cert, r_certlen);
2658 return err;
2659 }
2660
2661
2662
2663 /* Implement the GETATTR command. This is similar to the LEARN
2664 command but returns just one value via the status interface. */
2665 static gpg_error_t
2666 do_getattr (app_t app, ctrl_t ctrl, const char *name)
2667 {
2668 gpg_error_t err;
2669
2670 if (!strcmp (name, "$AUTHKEYID"))
2671 {
2672 char *buf, *p;
2673 prkdf_object_t prkdf;
2674
2675 /* We return the ID of the first private keycapable of
2676 signing. */
2677 for (prkdf = app->app_local->private_key_info; prkdf;
2678 prkdf = prkdf->next)
2679 if (prkdf->usageflags.sign)
2680 break;
2681 if (prkdf)
2682 {
2683 buf = xtrymalloc (9 + prkdf->objidlen*2 + 1);
2684 if (!buf)
2685 return gpg_error_from_syserror ();
2686 p = stpcpy (buf, "P15");
2687 if (app->app_local->home_df)
2688 {
2689 sprintf (p, "-%04hX", (app->app_local->home_df & 0xffff));
2690 p += 5;
2691 }
2692 p = stpcpy (p, ".");
2693 bin2hex (prkdf->objid, prkdf->objidlen, p);
2694
2695 send_status_info (ctrl, name, buf, strlen (buf), NULL, 0);
2696 xfree (buf);
2697 return 0;
2698 }
2699 }
2700 else if (!strcmp (name, "$DISPSERIALNO"))
2701 {
2702 /* For certain cards we return special IDs. There is no
2703 general rule for it so we need to decide case by case. */
2704 if (app->app_local->card_type == CARD_TYPE_BELPIC)
2705 {
2706 /* The eID card has a card number printed on the front matter
2707 which seems to be a good indication. */
2708 unsigned char *buffer;
2709 const unsigned char *p;
2710 size_t buflen, n;
2711 unsigned short path[] = { 0x3F00, 0xDF01, 0x4031 };
2712
2713 err = select_ef_by_path (app, path, DIM(path) );
2714 if (!err)
2715 err = iso7816_read_binary (app->slot, 0, 0, &buffer, &buflen);
2716 if (err)
2717 {
2718 log_error ("error accessing EF(ID): %s\n", gpg_strerror (err));
2719 return err;
2720 }
2721
2722 p = find_tlv (buffer, buflen, 1, &n);
2723 if (p && n == 12)
2724 {
2725 char tmp[12+2+1];
2726 memcpy (tmp, p, 3);
2727 tmp[3] = '-';
2728 memcpy (tmp+4, p+3, 7);
2729 tmp[11] = '-';
2730 memcpy (tmp+12, p+10, 2);
2731 tmp[14] = 0;
2732 send_status_info (ctrl, name, tmp, strlen (tmp), NULL, 0);
2733 xfree (buffer);
2734 return 0;
2735 }
2736 xfree (buffer);
2737 }
2738
2739 }
2740 return gpg_error (GPG_ERR_INV_NAME);
2741 }
2742
2743
2744
2745
2746 /* Micardo cards require special treatment. This is a helper for the
2747 crypto functions to manage the security environment. We expect that
2748 the key file has already been selected. FID is the one of the
2749 selected key. */
2750 static gpg_error_t
2751 micardo_mse (app_t app, unsigned short fid)
2752 {
2753 gpg_error_t err;
2754 int recno;
2755 unsigned short refdata = 0;
2756 int se_num;
2757 unsigned char msebuf[10];
2758
2759 /* Read the KeyD file containing extra information on keys. */
2760 err = iso7816_select_file (app->slot, 0x0013, 0, NULL, NULL);
2761 if (err)
2762 {
2763 log_error ("error reading EF_keyD: %s\n", gpg_strerror (err));
2764 return err;
2765 }
2766
2767 for (recno = 1, se_num = -1; ; recno++)
2768 {
2769 unsigned char *buffer;
2770 size_t buflen;
2771 size_t n, nn;
2772 const unsigned char *p, *pp;
2773
2774 err = iso7816_read_record (app->slot, recno, 1, 0, &buffer, &buflen);
2775 if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2776 break; /* ready */
2777 if (err)
2778 {
2779 log_error ("error reading EF_keyD record: %s\n",
2780 gpg_strerror (err));
2781 return err;
2782 }
2783 log_printhex ("keyD record:", buffer, buflen);
2784 p = find_tlv (buffer, buflen, 0x83, &n);
2785 if (p && n == 4 && ((p[2]<<8)|p[3]) == fid)
2786 {
2787 refdata = ((p[0]<<8)|p[1]);
2788 /* Locate the SE DO and the there included sec env number. */
2789 p = find_tlv (buffer, buflen, 0x7b, &n);
2790 if (p && n)
2791 {
2792 pp = find_tlv (p, n, 0x80, &nn);
2793 if (pp && nn == 1)
2794 {
2795 se_num = *pp;
2796 xfree (buffer);
2797 break; /* found. */
2798 }
2799 }
2800 }
2801 xfree (buffer);
2802 }
2803 if (se_num == -1)
2804 {
2805 log_error ("CRT for keyfile %04hX not found\n", fid);
2806 return gpg_error (GPG_ERR_NOT_FOUND);
2807 }
2808
2809
2810 /* Restore the security environment to SE_NUM if needed */
2811 if (se_num)
2812 {
2813 err = iso7816_manage_security_env (app->slot, 0xf3, se_num, NULL, 0);
2814 if (err)
2815 {
2816 log_error ("restoring SE to %d failed: %s\n",
2817 se_num, gpg_strerror (err));
2818 return err;
2819 }
2820 }
2821
2822 /* Set the DST reference data. */
2823 msebuf[0] = 0x83;
2824 msebuf[1] = 0x03;
2825 msebuf[2] = 0x80;
2826 msebuf[3] = (refdata >> 8);
2827 msebuf[4] = refdata;
2828 err = iso7816_manage_security_env (app->slot, 0x41, 0xb6, msebuf, 5);
2829 if (err)
2830 {
2831 log_error ("setting SE to reference file %04hX failed: %s\n",
2832 refdata, gpg_strerror (err));
2833 return err;
2834 }
2835 return 0;
2836 }
2837
2838
2839
2840 /* Handler for the PKSIGN command.
2841
2842 Create the signature and return the allocated result in OUTDATA.
2843 If a PIN is required, the PINCB will be used to ask for the PIN;
2844 that callback should return the PIN in an allocated buffer and
2845 store that as the 3rd argument. */
2846 static gpg_error_t
2847 do_sign (app_t app, const char *keyidstr, int hashalgo,
2848 gpg_error_t (*pincb)(void*, const char *, char **),
2849 void *pincb_arg,
2850 const void *indata, size_t indatalen,
2851 unsigned char **outdata, size_t *outdatalen )
2852 {
2853 static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
2854 { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2855 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
2856 static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2857 { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2858 0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
2859
2860 gpg_error_t err;
2861 int i;
2862 unsigned char data[36]; /* Must be large enough for a SHA-1 digest
2863 + the largest OID prefix above and also
2864 fit the 36 bytes of md5sha1. */
2865 prkdf_object_t prkdf; /* The private key object. */
2866 aodf_object_t aodf; /* The associated authentication object. */
2867 int no_data_padding = 0; /* True if the card want the data without padding.*/
2868 int mse_done = 0; /* Set to true if the MSE has been done. */
2869
2870 if (!keyidstr || !*keyidstr)
2871 return gpg_error (GPG_ERR_INV_VALUE);
2872 if (indatalen != 20 && indatalen != 16 && indatalen != 35 && indatalen != 36)
2873 return gpg_error (GPG_ERR_INV_VALUE);
2874
2875 err = prkdf_object_from_keyidstr (app, keyidstr, &prkdf);
2876 if (err)
2877 return err;
2878 if (!(prkdf->usageflags.sign || prkdf->usageflags.sign_recover
2879 ||prkdf->usageflags.non_repudiation))
2880 {
2881 log_error ("key %s may not be used for signing\n", keyidstr);
2882 return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
2883 }
2884
2885 if (!prkdf->authid)
2886 {
2887 log_error ("no authentication object defined for %s\n", keyidstr);
2888 /* fixme: we might want to go ahead and do without PIN
2889 verification. */
2890 return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
2891 }
2892
2893 /* Find the authentication object to this private key object. */
2894 for (aodf = app->app_local->auth_object_info; aodf; aodf = aodf->next)
2895 if (aodf->objidlen == prkdf->authidlen
2896 && !memcmp (aodf->objid, prkdf->authid, prkdf->authidlen))
2897 break;
2898 if (!aodf)
2899 {
2900 log_error ("authentication object for %s missing\n", keyidstr);
2901 return gpg_error (GPG_ERR_INV_CARD);
2902 }
2903 if (aodf->authid)
2904 {
2905 log_error ("PIN verification is protected by an "
2906 "additional authentication token\n");
2907 return gpg_error (GPG_ERR_BAD_PIN_METHOD);
2908 }
2909 if (aodf->pinflags.integrity_protected
2910 || aodf->pinflags.confidentiality_protected)
2911 {
2912 log_error ("PIN verification requires unsupported protecion method\n");
2913 return gpg_error (GPG_ERR_BAD_PIN_METHOD);
2914 }
2915 if (!aodf->stored_length && aodf->pinflags.needs_padding)
2916 {
2917 log_error ("PIN verification requires padding but no length known\n");
2918 return gpg_error (GPG_ERR_INV_CARD);
2919 }
2920
2921 /* Select the key file. Note that this may change the security
2922 environment thus we do it before PIN verification. */
2923 err = select_ef_by_path (app, prkdf->path, prkdf->pathlen);
2924 if (err)
2925 {
2926 log_error ("error selecting file for key %s: %s\n",
2927 keyidstr, gpg_strerror (errno));
2928 return err;
2929 }
2930
2931
2932 /* Due to the fact that the non-repudiation signature on a BELPIC
2933 card requires a verify immediately before the DSO we set the
2934 MSE before we do the verification. Other cards might allow to do
2935 this also but I don't want to break anything, thus we do it only
2936 for the BELPIC card here. */
2937 if (app->app_local->card_type == CARD_TYPE_BELPIC)
2938 {
2939 unsigned char mse[5];
2940
2941 mse[0] = 4; /* Length of the template. */
2942 mse[1] = 0x80; /* Algorithm reference tag. */
2943 if (hashalgo == MD_USER_TLS_MD5SHA1)
2944 mse[2] = 0x01; /* Let card do pkcs#1 0xFF padding. */
2945 else
2946 mse[2] = 0x02; /* RSASSA-PKCS1-v1.5 using SHA1. */
2947 mse[3] = 0x84; /* Private key reference tag. */
2948 mse[4] = prkdf->key_reference_valid? prkdf->key_reference : 0x82;
2949
2950 err = iso7816_manage_security_env (app->slot,
2951 0x41, 0xB6,
2952 mse, sizeof mse);
2953 no_data_padding = 1;
2954 mse_done = 1;
2955 }
2956 if (err)
2957 {
2958 log_error ("MSE failed: %s\n", gpg_strerror (err));
2959 return err;
2960 }
2961
2962
2963 /* Now that we have all the information available, prepare and run
2964 the PIN verification.*/
2965 if (1)
2966 {
2967 char *pinvalue;
2968 size_t pinvaluelen;
2969 const char *errstr;
2970 const char *s;
2971
2972 if (prkdf->usageflags.non_repudiation
2973 && app->app_local->card_type == CARD_TYPE_BELPIC)
2974 err = pincb (pincb_arg, "PIN (qualified signature!)", &pinvalue);
2975 else
2976 err = pincb (pincb_arg, "PIN", &pinvalue);
2977 if (err)
2978 {
2979 log_info ("PIN callback returned error: %s\n", gpg_strerror (err));
2980 return err;
2981 }
2982
2983 /* We might need to cope with UTF8 things here. Not sure how
2984 min_length etc. are exactly defined, for now we take them as
2985 a plain octet count. */
2986
2987 if (strlen (pinvalue) < aodf->min_length)
2988 {
2989 log_error ("PIN is too short; minimum length is %lu\n",
2990 aodf->min_length);
2991 err = gpg_error (GPG_ERR_BAD_PIN);
2992 }
2993 else if (aodf->stored_length && strlen (pinvalue) > aodf->stored_length)
2994 {
2995 /* This would otherwise truncate the PIN silently. */
2996 log_error ("PIN is too large; maximum length is %lu\n",
2997 aodf->stored_length);
2998 err = gpg_error (GPG_ERR_BAD_PIN);
2999 }
3000 else if (aodf->max_length_valid && strlen (pinvalue) > aodf->max_length)
3001 {
3002 log_error ("PIN is too large; maximum length is %lu\n",
3003 aodf->max_length);
3004 err = gpg_error (GPG_ERR_BAD_PIN);
3005 }
3006
3007 if (err)
3008 {
3009 xfree (pinvalue);
3010 return err;
3011 }
3012
3013 errstr = NULL;
3014 err = 0;
3015 switch (aodf->pintype)
3016 {
3017 case PIN_TYPE_BCD:
3018 case PIN_TYPE_ASCII_NUMERIC:
3019 for (s=pinvalue; digitp (s); s++)
3020 ;
3021 if (*s)
3022 {
3023 errstr = "Non-numeric digits found in PIN";
3024 err = gpg_error (GPG_ERR_BAD_PIN);
3025 }
3026 break;
3027 case PIN_TYPE_UTF8:
3028 break;
3029 case PIN_TYPE_HALF_NIBBLE_BCD:
3030 errstr = "PIN type Half-Nibble-BCD is not supported";
3031 break;
3032 case PIN_TYPE_ISO9564_1:
3033 errstr = "PIN type ISO9564-1 is not supported";
3034 break;
3035 default:
3036 errstr = "Unknown PIN type";
3037 break;
3038 }
3039 if (errstr)
3040 {
3041 log_error ("can't verify PIN: %s\n", errstr);
3042 xfree (pinvalue);
3043 return err? err : gpg_error (GPG_ERR_BAD_PIN_METHOD);
3044 }
3045
3046
3047 if (aodf->pintype == PIN_TYPE_BCD )
3048 {
3049 char *paddedpin;
3050 int ndigits;
3051
3052 for (ndigits=0, s=pinvalue; *s; ndigits++, s++)
3053 ;
3054 paddedpin = xtrymalloc (aodf->stored_length+1);
3055 if (!paddedpin)
3056 {
3057 err = gpg_error_from_syserror ();
3058 xfree (pinvalue);
3059 return err;
3060 }
3061
3062 i = 0;
3063 paddedpin[i++] = 0x20 | (ndigits & 0x0f);
3064 for (s=pinvalue; i < aodf->stored_length && *s && s[1]; s = s+2 )
3065 paddedpin[i++] = (((*s - '0') << 4) | ((s[1] - '0') & 0x0f));
3066 if (i < aodf->stored_length && *s)
3067 paddedpin[i++] = (((*s - '0') << 4)
3068 |((aodf->pad_char_valid?aodf->pad_char:0)&0x0f));
3069
3070 if (aodf->pinflags.needs_padding)
3071 while (i < aodf->stored_length)
3072 paddedpin[i++] = aodf->pad_char_valid? aodf->pad_char : 0;
3073
3074 xfree (pinvalue);
3075 pinvalue = paddedpin;
3076 pinvaluelen = i;
3077 }
3078 else if (aodf->pinflags.needs_padding)
3079 {
3080 char *paddedpin;
3081
3082 paddedpin = xtrymalloc (aodf->stored_length+1);
3083 if (!paddedpin)
3084 {
3085 err = gpg_error_from_syserror ();
3086 xfree (pinvalue);
3087 return err;
3088 }
3089 for (i=0, s=pinvalue; i < aodf->stored_length && *s; i++, s++)
3090 paddedpin[i] = *s;
3091 /* Not sure what padding char to use if none has been set.
3092 For now we use 0x00; maybe a space would be better. */
3093 for (; i < aodf->stored_length; i++)
3094 paddedpin[i] = aodf->pad_char_valid? aodf->pad_char : 0;
3095 paddedpin[i] = 0;
3096 pinvaluelen = i;
3097 xfree (pinvalue);
3098 pinvalue = paddedpin;
3099 }
3100 else
3101 pinvaluelen = strlen (pinvalue);
3102
3103 err = iso7816_verify (app->slot,
3104 aodf->pin_reference_valid? aodf->pin_reference : 0,
3105 pinvalue, pinvaluelen);
3106 xfree (pinvalue);
3107 if (err)
3108 {
3109 log_error ("PIN verification failed: %s\n", gpg_strerror (err));
3110 return err;
3111 }
3112 log_debug ("PIN verification succeeded\n");
3113 }
3114
3115 /* Prepare the DER object from INDATA. */
3116 if (indatalen == 36)
3117 {
3118 /* No ASN.1 container used. */
3119 if (hashalgo != MD_USER_TLS_MD5SHA1)
3120 return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3121 memcpy (data, indata, indatalen);
3122 }
3123 else if (indatalen == 35)
3124 {
3125 /* Alright, the caller was so kind to send us an already
3126 prepared DER object. Check that it is what we want and that
3127 it matches the hash algorithm. */
3128 if (hashalgo == GCRY_MD_SHA1 && !memcmp (indata, sha1_prefix, 15))
3129 ;
3130 else if (hashalgo == GCRY_MD_RMD160
3131 && !memcmp (indata, rmd160_prefix, 15))
3132 ;
3133 else
3134 return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3135 memcpy (data, indata, indatalen);
3136 }
3137 else
3138 {
3139 /* Need to prepend the prefix. */
3140 if (hashalgo == GCRY_MD_SHA1)
3141 memcpy (data, sha1_prefix, 15);
3142 else if (hashalgo == GCRY_MD_RMD160)
3143 memcpy (data, rmd160_prefix, 15);
3144 else
3145 return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3146 memcpy (data+15, indata, indatalen);
3147 }
3148
3149 /* Manage security environment needs to be weaked for certain cards. */
3150 if (mse_done)
3151 err = 0;
3152 else if (app->app_local->card_type == CARD_TYPE_TCOS)
3153 {
3154 /* TCOS creates signatures always using the local key 0. MSE
3155 may not be used. */
3156 }
3157 else if (app->app_local->card_type == CARD_TYPE_MICARDO)
3158 {
3159 if (!prkdf->pathlen)
3160 err = gpg_error (GPG_ERR_BUG);
3161 else
3162 err = micardo_mse (app, prkdf->path[prkdf->pathlen-1]);
3163 }
3164 else if (prkdf->key_reference_valid)
3165 {
3166 unsigned char mse[3];
3167
3168 mse[0] = 0x84; /* Select asym. key. */
3169 mse[1] = 1;
3170 mse[2] = prkdf->key_reference;
3171
3172 err = iso7816_manage_security_env (app->slot,
3173 0x41, 0xB6,
3174 mse, sizeof mse);
3175 }
3176 if (err)
3177 {
3178 log_error ("MSE failed: %s\n", gpg_strerror (err));
3179 return err;
3180 }
3181
3182 if (hashalgo == MD_USER_TLS_MD5SHA1)
3183 err = iso7816_compute_ds (app->slot, 0, data, 36, 0, outdata, outdatalen);
3184 else if (no_data_padding)
3185 err = iso7816_compute_ds (app->slot, 0, data+15, 20, 0,outdata,outdatalen);
3186 else
3187 err = iso7816_compute_ds (app->slot, 0, data, 35, 0, outdata, outdatalen);
3188 return err;
3189 }
3190
3191
3192 /* Handler for the PKAUTH command.
3193
3194 This is basically the same as the PKSIGN command but we first check
3195 that the requested key is suitable for authentication; that is, it
3196 must match the criteria used for the attribute $AUTHKEYID. See
3197 do_sign for calling conventions; there is no HASHALGO, though. */
3198 static gpg_error_t
3199 do_auth (app_t app, const char *keyidstr,
3200 gpg_error_t (*pincb)(void*, const char *, char **),
3201 void *pincb_arg,
3202 const void *indata, size_t indatalen,
3203 unsigned char **outdata, size_t *outdatalen )
3204 {
3205 gpg_error_t err;
3206 prkdf_object_t prkdf;
3207 int algo;
3208
3209 if (!keyidstr || !*keyidstr)
3210 return gpg_error (GPG_ERR_INV_VALUE);
3211
3212 err = prkdf_object_from_keyidstr (app, keyidstr, &prkdf);
3213 if (err)
3214 return err;
3215 if (!prkdf->usageflags.sign)
3216 {
3217 log_error ("key %s may not be used for authentication\n", keyidstr);
3218 return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
3219 }
3220
3221 algo = indatalen == 36? MD_USER_TLS_MD5SHA1 : GCRY_MD_SHA1;
3222 return do_sign (app, keyidstr, algo, pincb, pincb_arg,
3223 indata, indatalen, outdata, outdatalen);
3224 }
3225
3226
3227 \f
3228 /* Assume that EF(DIR) has been selected. Read its content and figure
3229 out the home EF of pkcs#15. Return that home DF or 0 if not found
3230 and the value at the address of BELPIC indicates whether it was
3231 found by the belpic aid. */
3232 static unsigned short
3233 read_home_df (int slot, int *r_belpic)
3234 {
3235 gpg_error_t err;
3236 unsigned char *buffer;
3237 const unsigned char *p, *pp;
3238 size_t buflen, n, nn;
3239 unsigned short result = 0;
3240
3241 *r_belpic = 0;
3242
3243 err = iso7816_read_binary (slot, 0, 0, &buffer, &buflen);
3244 if (err)
3245 {
3246 log_error ("error reading EF{DIR}: %s\n", gpg_strerror (err));
3247 return 0;
3248 }
3249
3250 /* FIXME: We need to scan all records. */
3251 p = find_tlv (buffer, buflen, 0x61, &n);
3252 if (p && n)
3253 {
3254 pp = find_tlv (p, n, 0x4f, &nn);
3255 if (pp && ((nn == sizeof pkcs15_aid && !memcmp (pp, pkcs15_aid, nn))
3256 || (*r_belpic = (nn == sizeof pkcs15be_aid
3257 && !memcmp (pp, pkcs15be_aid, nn)))))
3258 {
3259 pp = find_tlv (p, n, 0x50, &nn);
3260 if (pp) /* fixme: Filter log value? */
3261 log_info ("pkcs#15 application label from EF(DIR) is `%.*s'\n",
3262 (int)nn, pp);
3263 pp = find_tlv (p, n, 0x51, &nn);
3264 if (pp && nn == 4 && *pp == 0x3f && !pp[1])
3265 {
3266 result = ((pp[2] << 8) | pp[3]);
3267 log_info ("pkcs#15 application directory is 0x%04hX\n", result);
3268 }
3269 }
3270 }
3271 xfree (buffer);
3272 return result;
3273 }
3274
3275
3276 /*
3277 Select the PKCS#15 application on the card in SLOT.
3278 */
3279 gpg_error_t
3280 app_select_p15 (app_t app)
3281 {
3282 int slot = app->slot;
3283 int rc;
3284 unsigned short def_home_df = 0;
3285 card_type_t card_type = CARD_TYPE_UNKNOWN;
3286 int direct = 0;
3287 int is_belpic = 0;
3288
3289 rc = iso7816_select_application (slot, pkcs15_aid, sizeof pkcs15_aid, 0);
3290 if (rc)
3291 { /* Not found: Try to locate it from 2F00. We use direct path
3292 selection here because it seems that the Belgian eID card
3293 does only allow for that. Many other cards supports this
3294 selection method too. Note, that we don't use
3295 select_application above for the Belgian card - the call
3296 works but it seems that it did not switch to the correct DF.
3297 Using the 2f02 just works. */
3298 unsigned short path[1] = { 0x2f00 };
3299
3300 rc = iso7816_select_path (app->slot, path, 1, NULL, NULL);
3301 if (!rc)
3302 {
3303 direct = 1;
3304 def_home_df = read_home_df (slot, &is_belpic);
3305 if (def_home_df)
3306 {
3307 path[0] = def_home_df;
3308 rc = iso7816_select_path (app->slot, path, 1, NULL, NULL);
3309 }
3310 }
3311 }
3312 if (rc)
3313 { /* Still not found: Try the default DF. */
3314 def_home_df = 0x5015;
3315 rc = iso7816_select_file (slot, def_home_df, 1, NULL, NULL);
3316 }
3317 if (!rc)
3318 {
3319 /* Determine the type of the card. The general case is to look
3320 it up from the ATR table. For the Belgian eID card we know
3321 it instantly from the AID. */
3322 if (is_belpic)
3323 {
3324 card_type = CARD_TYPE_BELPIC;
3325 }
3326 else
3327 {
3328 unsigned char *atr;
3329 size_t atrlen;
3330 int i;
3331
3332 atr = apdu_get_atr (app->slot, &atrlen);
3333 if (!atr)
3334 rc = gpg_error (GPG_ERR_INV_CARD);
3335 else
3336 {
3337 for (i=0; card_atr_list[i].atrlen; i++)
3338 if (card_atr_list[i].atrlen == atrlen
3339 && !memcmp (card_atr_list[i].atr, atr, atrlen))
3340 {
3341 card_type = card_atr_list[i].type;
3342 break;
3343 }
3344 xfree (atr);
3345 }
3346 }
3347 }
3348 if (!rc)
3349 {
3350 app->apptype = "P15";
3351
3352 app->app_local = xtrycalloc (1, sizeof *app->app_local);
3353 if (!app->app_local)
3354 {
3355 rc = gpg_error_from_syserror ();
3356 goto leave;
3357 }
3358
3359 /* Set the home DF. Note that we currently can't do that if the
3360 selection via application ID worked. This will store 0 there
3361 instead. FIXME: We either need to figure the home_df via the
3362 DIR file or using the return values from the select file
3363 APDU. */
3364 app->app_local->home_df = def_home_df;
3365
3366 /* Store the card type. FIXME: We might want to put this into
3367 the common APP structure. */
3368 app->app_local->card_type = card_type;
3369
3370 /* Store whether we may and should use direct path selection. */
3371 app->app_local->direct_path_selection = direct;
3372
3373 /* Read basic information and thus check whether this is a real
3374 card. */
3375 rc = read_p15_info (app);
3376 if (rc)
3377 goto leave;
3378
3379 /* Special serial number munging. We need to check for a German
3380 prototype card right here because we need to access to
3381 EF(TokenInfo). We mark such a serial number by the using a
3382 prefix of FF0100. */
3383 if (app->serialnolen == 12
3384 && !memcmp (app->serialno, "\xD2\x76\0\0\0\0\0\0\0\0\0\0", 12))
3385 {
3386 /* This is a German card with a silly serial number. Try to get
3387 the serial number from the EF(TokenInfo). . */
3388 unsigned char *p;
3389
3390 /* FIXME: actually get it from EF(TokenInfo). */
3391
3392 p = xtrymalloc (3 + app->serialnolen);
3393 if (!p)
3394 rc = gpg_error (gpg_err_code_from_errno (errno));
3395 else
3396 {
3397 memcpy (p, "\xff\x01", 3);
3398 memcpy (p+3, app->serialno, app->serialnolen);
3399 app->serialnolen += 3;
3400 xfree (app->serialno);
3401 app->serialno = p;
3402 }
3403 }
3404
3405 app->fnc.deinit = do_deinit;
3406 app->fnc.learn_status = do_learn_status;
3407 app->fnc.readcert = do_readcert;
3408 app->fnc.getattr = do_getattr;
3409 app->fnc.setattr = NULL;
3410 app->fnc.genkey = NULL;
3411 app->fnc.sign = do_sign;
3412 app->fnc.auth = do_auth;
3413 app->fnc.decipher = NULL;
3414 app->fnc.change_pin = NULL;
3415 app->fnc.check_pin = NULL;
3416
3417 leave:
3418 if (rc)
3419 do_deinit (app);
3420 }
3421
3422 return rc;
3423 }
gnupg svn clone