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