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