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