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