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