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