build: Build gpg-pair-tool only when there is newer libgcrypt.
[gnupg.git] / scd / app-sc-hsm.c
1 /* app-sc-hsm.c - The SmartCard-HSM card application (www.smartcard-hsm.com).
2  *      Copyright (C) 2005 Free Software Foundation, Inc.
3  *      Copyright (C) 2014 Andreas Schwier <andreas.schwier@cardcontact.de>
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 /*
22    Code in this driver is based on app-p15.c with modifications.
23  */
24
25 #include <config.h>
26 #include <errno.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <assert.h>
31 #include <time.h>
32
33 #include "scdaemon.h"
34
35 #include "iso7816.h"
36 #include "../common/tlv.h"
37 #include "apdu.h"
38
39
40 /* The AID of the SmartCard-HSM applet. */
41 static char const sc_hsm_aid[] = { 0xE8, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x81,
42                                    0xC3, 0x1F, 0x02, 0x01  };
43
44
45 /* Special file identifier for SmartCard-HSM */
46 typedef enum
47 {
48     SC_HSM_PRKD_PREFIX = 0xC4,
49     SC_HSM_CD_PREFIX = 0xC8,
50     SC_HSM_DCOD_PREFIX = 0xC9,
51     SC_HSM_CA_PREFIX = 0xCA,
52     SC_HSM_KEY_PREFIX = 0xCC,
53     SC_HSM_EE_PREFIX = 0xCE
54 } fid_prefix_type_t;
55
56
57 /* The key types supported by the SmartCard-HSM */
58 typedef enum
59   {
60     KEY_TYPE_RSA,
61     KEY_TYPE_ECC
62   } key_type_t;
63
64
65 /* A bit array with for the key usage flags from the
66    commonKeyAttributes. */
67 struct keyusage_flags_s
68 {
69     unsigned int encrypt: 1;
70     unsigned int decrypt: 1;
71     unsigned int sign: 1;
72     unsigned int sign_recover: 1;
73     unsigned int wrap: 1;
74     unsigned int unwrap: 1;
75     unsigned int verify: 1;
76     unsigned int verify_recover: 1;
77     unsigned int derive: 1;
78     unsigned int non_repudiation: 1;
79 };
80 typedef struct keyusage_flags_s keyusage_flags_t;
81
82
83
84 /* This is an object to store information about a Certificate
85    Directory File (CDF) in a format suitable for further processing by
86    us. To keep memory management, simple we use a linked list of
87    items; i.e. one such object represents one certificate and the list
88    the entire CDF. */
89 struct cdf_object_s
90 {
91   /* Link to next item when used in a linked list. */
92   struct cdf_object_s *next;
93
94   /* Length and allocated buffer with the Id of this object. */
95   size_t objidlen;
96   unsigned char *objid;
97
98   /* To avoid reading a certificate more than once, we cache it in an
99      allocated memory IMAGE of IMAGELEN. */
100   size_t imagelen;
101   unsigned char *image;
102
103   /* EF containing certificate */
104   unsigned short fid;
105 };
106 typedef struct cdf_object_s *cdf_object_t;
107
108
109
110 /* This is an object to store information about a Private Key
111    Directory File (PrKDF) in a format suitable for further processing
112    by us. To keep memory management, simple we use a linked list of
113    items; i.e. one such object represents one certificate and the list
114    the entire PrKDF. */
115 struct prkdf_object_s
116 {
117   /* Link to next item when used in a linked list. */
118   struct prkdf_object_s *next;
119
120   /* Key type */
121   key_type_t keytype;
122
123   /* Key size in bits or 0 if unknown */
124   size_t keysize;
125
126   /* Length and allocated buffer with the Id of this object. */
127   size_t objidlen;
128   unsigned char *objid;
129
130   /* The key's usage flags. */
131   keyusage_flags_t usageflags;
132
133   /* The keyReference */
134   unsigned char key_reference;
135 };
136 typedef struct prkdf_object_s *prkdf_object_t;
137
138
139
140 /* Context local to this application. */
141 struct app_local_s
142 {
143   /* Information on all certificates. */
144   cdf_object_t certificate_info;
145   /* Information on all trusted certificates. */
146   cdf_object_t trusted_certificate_info;
147   /* Information on all private keys. */
148   prkdf_object_t private_key_info;
149 };
150
151
152
153 /*** Local prototypes.  ***/
154 static gpg_error_t readcert_by_cdf (app_t app, cdf_object_t cdf,
155                                     unsigned char **r_cert, size_t *r_certlen);
156
157
158
159 /* Release the CDF object A  */
160 static void
161 release_cdflist (cdf_object_t a)
162 {
163   while (a)
164     {
165       cdf_object_t tmp = a->next;
166       xfree (a->image);
167       xfree (a->objid);
168       xfree (a);
169       a = tmp;
170     }
171 }
172
173
174
175 /* Release the PrKDF object A.  */
176 static void
177 release_prkdflist (prkdf_object_t a)
178 {
179   while (a)
180     {
181       prkdf_object_t tmp = a->next;
182       xfree (a->objid);
183       xfree (a);
184       a = tmp;
185     }
186 }
187
188
189
190 /* Release all local resources.  */
191 static void
192 do_deinit (app_t app)
193 {
194   if (app && app->app_local)
195     {
196       release_cdflist (app->app_local->certificate_info);
197       release_cdflist (app->app_local->trusted_certificate_info);
198       release_prkdflist (app->app_local->private_key_info);
199       xfree (app->app_local);
200       app->app_local = NULL;
201     }
202 }
203
204
205
206 /* Get the list of EFs from the SmartCard-HSM.
207  * On success a dynamically buffer containing the EF list is returned.
208  * The caller is responsible for freeing the buffer.
209  */
210 static gpg_error_t
211 list_ef (int slot, unsigned char **result, size_t *resultlen)
212 {
213   int sw;
214
215   if (!result || !resultlen)
216     return gpg_error (GPG_ERR_INV_VALUE);
217   *result = NULL;
218   *resultlen = 0;
219
220   sw = apdu_send_le (slot, 1, 0x80, 0x58, 0x00, 0x00, -1, NULL, 65536,
221                      result, resultlen);
222   if (sw != SW_SUCCESS)
223     {
224       /* Make sure that pending buffers are released. */
225       xfree (*result);
226       *result = NULL;
227       *resultlen = 0;
228     }
229   return iso7816_map_sw (sw);
230 }
231
232
233
234 /* Do a select and a read for the file with EFID.  EFID_DESC is a
235    description of the EF to be used with error messages.  On success
236    BUFFER and BUFLEN contain the entire content of the EF.  The caller
237    must free BUFFER only on success. */
238 static gpg_error_t
239 select_and_read_binary (int slot, unsigned short efid, const char *efid_desc,
240                         unsigned char **buffer, size_t *buflen, int maxread)
241 {
242   gpg_error_t err;
243   unsigned char cdata[4];
244   int sw;
245
246   cdata[0] = 0x54;      /* Create ISO 7861-4 odd ins READ BINARY */
247   cdata[1] = 0x02;
248   cdata[2] = 0x00;
249   cdata[3] = 0x00;
250
251   sw = apdu_send_le(slot, 1, 0x00, 0xB1, efid >> 8, efid & 0xFF,
252                     4, cdata, maxread, buffer, buflen);
253
254   if (sw == SW_EOF_REACHED)
255     sw = SW_SUCCESS;
256
257   err = iso7816_map_sw (sw);
258   if (err)
259     {
260       log_error ("error reading %s (0x%04X): %s\n",
261                  efid_desc, efid, gpg_strerror (err));
262       return err;
263     }
264   return 0;
265 }
266
267
268
269 /* Parse a cert Id string (or a key Id string) and return the binary
270    object Id string in a newly allocated buffer stored at R_OBJID and
271    R_OBJIDLEN.  On Error NULL will be stored there and an error code
272    returned. On success caller needs to free the buffer at R_OBJID. */
273 static gpg_error_t
274 parse_certid (const char *certid, unsigned char **r_objid, size_t *r_objidlen)
275 {
276   const char *s;
277   size_t objidlen;
278   unsigned char *objid;
279   int i;
280
281   *r_objid = NULL;
282   *r_objidlen = 0;
283
284   if (strncmp (certid, "HSM.", 4))
285     return gpg_error (GPG_ERR_INV_ID);
286   certid += 4;
287
288   for (s=certid, objidlen=0; hexdigitp (s); s++, objidlen++)
289     ;
290   if (*s || !objidlen || (objidlen%2))
291     return gpg_error (GPG_ERR_INV_ID);
292   objidlen /= 2;
293   objid = xtrymalloc (objidlen);
294   if (!objid)
295     return gpg_error_from_syserror ();
296   for (s=certid, i=0; i < objidlen; i++, s+=2)
297     objid[i] = xtoi_2 (s);
298   *r_objid = objid;
299   *r_objidlen = objidlen;
300   return 0;
301 }
302
303
304
305 /* Find a certificate object by the certificate ID CERTID and store a
306    pointer to it at R_CDF. */
307 static gpg_error_t
308 cdf_object_from_certid (app_t app, const char *certid, cdf_object_t *r_cdf)
309 {
310   gpg_error_t err;
311   size_t objidlen;
312   unsigned char *objid;
313   cdf_object_t cdf;
314
315   err = parse_certid (certid, &objid, &objidlen);
316   if (err)
317     return err;
318
319   for (cdf = app->app_local->certificate_info; cdf; cdf = cdf->next)
320     if (cdf->objidlen == objidlen && !memcmp (cdf->objid, objid, objidlen))
321       break;
322   if (!cdf)
323     for (cdf = app->app_local->trusted_certificate_info; cdf; cdf = cdf->next)
324       if (cdf->objidlen == objidlen && !memcmp (cdf->objid, objid, objidlen))
325         break;
326   xfree (objid);
327   if (!cdf)
328     return gpg_error (GPG_ERR_NOT_FOUND);
329   *r_cdf = cdf;
330   return 0;
331 }
332
333
334
335 /* Find a private key object by the key Id string KEYIDSTR and store a
336    pointer to it at R_PRKDF. */
337 static gpg_error_t
338 prkdf_object_from_keyidstr (app_t app, const char *keyidstr,
339                             prkdf_object_t *r_prkdf)
340 {
341   gpg_error_t err;
342   size_t objidlen;
343   unsigned char *objid;
344   prkdf_object_t prkdf;
345
346   err = parse_certid (keyidstr, &objid, &objidlen);
347   if (err)
348     return err;
349
350   for (prkdf = app->app_local->private_key_info; prkdf; prkdf = prkdf->next)
351     if (prkdf->objidlen == objidlen && !memcmp (prkdf->objid, objid, objidlen))
352       break;
353   xfree (objid);
354   if (!prkdf)
355     return gpg_error (GPG_ERR_NOT_FOUND);
356   *r_prkdf = prkdf;
357   return 0;
358 }
359
360
361
362 /* Parse the BIT STRING with the keyUsageFlags from the
363    CommonKeyAttributes. */
364 static gpg_error_t
365 parse_keyusage_flags (const unsigned char *der, size_t derlen,
366                       keyusage_flags_t *usageflags)
367 {
368   unsigned int bits, mask;
369   int i, unused, full;
370
371   memset (usageflags, 0, sizeof *usageflags);
372   if (!derlen)
373     return gpg_error (GPG_ERR_INV_OBJ);
374
375   unused = *der++; derlen--;
376   if ((!derlen && unused) || unused/8 > derlen)
377     return gpg_error (GPG_ERR_ENCODING_PROBLEM);
378   full = derlen - (unused+7)/8;
379   unused %= 8;
380   mask = 0;
381   for (i=1; unused; i <<= 1, unused--)
382     mask |= i;
383
384   /* First octet */
385   if (derlen)
386     {
387       bits = *der++; derlen--;
388       if (full)
389         full--;
390       else
391         {
392           bits &= ~mask;
393           mask = 0;
394         }
395     }
396   else
397     bits = 0;
398   if ((bits & 0x80)) usageflags->encrypt = 1;
399   if ((bits & 0x40)) usageflags->decrypt = 1;
400   if ((bits & 0x20)) usageflags->sign = 1;
401   if ((bits & 0x10)) usageflags->sign_recover = 1;
402   if ((bits & 0x08)) usageflags->wrap = 1;
403   if ((bits & 0x04)) usageflags->unwrap = 1;
404   if ((bits & 0x02)) usageflags->verify = 1;
405   if ((bits & 0x01)) usageflags->verify_recover = 1;
406
407   /* Second octet. */
408   if (derlen)
409     {
410       bits = *der++; derlen--;
411       if (full)
412         full--;
413       else
414         {
415           bits &= ~mask;
416         }
417     }
418   else
419     bits = 0;
420   if ((bits & 0x80)) usageflags->derive = 1;
421   if ((bits & 0x40)) usageflags->non_repudiation = 1;
422
423   return 0;
424 }
425
426
427
428 /* Read and parse a Private Key Directory File containing a single key
429    description in PKCS#15 format.  For each private key a matching
430    certificate description is created, if the certificate EF exists
431    and contains a X.509 certificate.
432
433    Example data:
434
435 0000  30 2A 30 13 0C 11 4A 6F 65 20 44 6F 65 20 28 52  0*0...Joe Doe (R
436 0010  53 41 32 30 34 38 29 30 07 04 01 01 03 02 02 74  SA2048)0.......t
437 0020  A1 0A 30 08 30 02 04 00 02 02 08 00              ..0.0.......
438
439    Decoded example:
440
441 SEQUENCE SIZE( 42 )
442   SEQUENCE SIZE( 19 )
443     UTF8-STRING SIZE( 17 )                -- label
444       0000  4A 6F 65 20 44 6F 65 20 28 52 53 41 32 30 34 38  Joe Doe (RSA2048
445       0010  29                                               )
446   SEQUENCE SIZE( 7 )
447     OCTET-STRING SIZE( 1 )                -- id
448       0000  01
449     BIT-STRING SIZE( 2 )                  -- key usage
450       0000  02 74
451   A1 [ CONTEXT 1 ] IMPLICIT SEQUENCE SIZE( 10 )
452     SEQUENCE SIZE( 8 )
453       SEQUENCE SIZE( 2 )
454         OCTET-STRING SIZE( 0 )            -- empty path, req object in PKCS#15
455       INTEGER SIZE( 2 )                   -- modulus size in bits
456         0000  08 00
457 */
458 static gpg_error_t
459 read_ef_prkd (app_t app, unsigned short fid, prkdf_object_t *prkdresult,
460               cdf_object_t *cdresult)
461 {
462   gpg_error_t err;
463   unsigned char *buffer = NULL;
464   size_t buflen;
465   const unsigned char *p;
466   size_t n, objlen, hdrlen;
467   int class, tag, constructed, ndef;
468   int i;
469   const unsigned char *pp;
470   size_t nn;
471   int where;
472   const char *errstr = NULL;
473   prkdf_object_t prkdf = NULL;
474   cdf_object_t cdf = NULL;
475   unsigned long ul;
476   const unsigned char *objid;
477   size_t objidlen;
478   keyusage_flags_t usageflags;
479   const char *s;
480   key_type_t keytype;
481   size_t keysize;
482
483   if (!fid)
484     return gpg_error (GPG_ERR_NO_DATA); /* No private keys. */
485
486   err = select_and_read_binary (app_get_slot (app),
487                                 fid, "PrKDF", &buffer, &buflen, 255);
488   if (err)
489     return err;
490
491   p = buffer;
492   n = buflen;
493
494   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
495                           &ndef, &objlen, &hdrlen);
496   if (!err && (objlen > n || (tag != TAG_SEQUENCE && tag != 0x00)))
497     err = gpg_error (GPG_ERR_INV_OBJ);
498   if (err)
499     {
500       log_error ("error parsing PrKDF record: %s\n", gpg_strerror (err));
501       goto leave;
502     }
503
504   keytype = tag == 0x00 ? KEY_TYPE_ECC : KEY_TYPE_RSA;
505
506   pp = p;
507   nn = objlen;
508   p += objlen;
509   n -= objlen;
510
511   /* Parse the commonObjectAttributes.  */
512   where = __LINE__;
513   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
514                           &ndef, &objlen, &hdrlen);
515   if (!err && (objlen > nn || tag != TAG_SEQUENCE))
516     err = gpg_error (GPG_ERR_INV_OBJ);
517   if (err)
518     goto parse_error;
519
520   {
521     const unsigned char *ppp = pp;
522     size_t nnn = objlen;
523
524     pp += objlen;
525     nn -= objlen;
526
527     /* Search the optional AuthId.  We need to skip the optional Label
528        (UTF8STRING) and the optional CommonObjectFlags (BITSTRING). */
529     where = __LINE__;
530     err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
531                             &ndef, &objlen, &hdrlen);
532     if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
533       err = gpg_error (GPG_ERR_INV_OBJ);
534     if (gpg_err_code (err) == GPG_ERR_EOF)
535       goto no_authid;
536     if (err)
537       goto parse_error;
538
539     if (tag == TAG_UTF8_STRING)
540       {
541         ppp += objlen; /* Skip the Label. */
542         nnn -= objlen;
543
544         where = __LINE__;
545         err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
546                                 &ndef, &objlen, &hdrlen);
547         if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
548           err = gpg_error (GPG_ERR_INV_OBJ);
549         if (gpg_err_code (err) == GPG_ERR_EOF)
550           goto no_authid;
551         if (err)
552           goto parse_error;
553       }
554     if (tag == TAG_BIT_STRING)
555       {
556         ppp += objlen; /* Skip the CommonObjectFlags.  */
557         nnn -= objlen;
558
559         where = __LINE__;
560         err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
561                                 &ndef, &objlen, &hdrlen);
562         if (!err && (objlen > nnn || class != CLASS_UNIVERSAL))
563           err = gpg_error (GPG_ERR_INV_OBJ);
564         if (gpg_err_code (err) == GPG_ERR_EOF)
565           goto no_authid;
566         if (err)
567           goto parse_error;
568       }
569     if (tag == TAG_OCTET_STRING && objlen)
570       {
571         /* AuthId ignored */
572       }
573   no_authid:
574     ;
575   }
576
577   /* Parse the commonKeyAttributes.  */
578   where = __LINE__;
579   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
580       &ndef, &objlen, &hdrlen);
581   if (!err && (objlen > nn || tag != TAG_SEQUENCE))
582     err = gpg_error (GPG_ERR_INV_OBJ);
583   if (err)
584     goto parse_error;
585
586   {
587     const unsigned char *ppp = pp;
588     size_t nnn = objlen;
589
590     pp += objlen;
591     nn -= objlen;
592
593     /* Get the Id. */
594     where = __LINE__;
595     err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
596                             &ndef, &objlen, &hdrlen);
597     if (!err && (objlen > nnn
598                  || class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING))
599       err = gpg_error (GPG_ERR_INV_OBJ);
600     if (err)
601       goto parse_error;
602
603     objid = ppp;
604     objidlen = objlen;
605     ppp += objlen;
606     nnn -= objlen;
607
608     /* Get the KeyUsageFlags. */
609     where = __LINE__;
610     err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
611                             &ndef, &objlen, &hdrlen);
612     if (!err && (objlen > nnn
613                  || class != CLASS_UNIVERSAL || tag != TAG_BIT_STRING))
614       err = gpg_error (GPG_ERR_INV_OBJ);
615     if (err)
616       goto parse_error;
617
618     err = parse_keyusage_flags (ppp, objlen, &usageflags);
619     if (err)
620       goto parse_error;
621
622     ppp += objlen;
623     nnn -= objlen;
624
625     /* Find the keyReference */
626     where = __LINE__;
627     err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
628                             &ndef, &objlen, &hdrlen);
629     if (gpg_err_code (err) == GPG_ERR_EOF)
630       goto leave_cki;
631     if (!err && objlen > nnn)
632       err = gpg_error (GPG_ERR_INV_OBJ);
633     if (err)
634       goto parse_error;
635
636     if (class == CLASS_UNIVERSAL && tag == TAG_BOOLEAN)
637       {
638         /* Skip the native element. */
639         ppp += objlen;
640         nnn -= objlen;
641
642         err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
643                                 &ndef, &objlen, &hdrlen);
644         if (gpg_err_code (err) == GPG_ERR_EOF)
645           goto leave_cki;
646         if (!err && objlen > nnn)
647           err = gpg_error (GPG_ERR_INV_OBJ);
648         if (err)
649           goto parse_error;
650       }
651     if (class == CLASS_UNIVERSAL && tag == TAG_BIT_STRING)
652       {
653         /* Skip the accessFlags. */
654         ppp += objlen;
655         nnn -= objlen;
656
657         err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
658                                 &ndef, &objlen, &hdrlen);
659         if (gpg_err_code (err) == GPG_ERR_EOF)
660           goto leave_cki;
661         if (!err && objlen > nnn)
662           err = gpg_error (GPG_ERR_INV_OBJ);
663         if (err)
664           goto parse_error;
665       }
666     if (class == CLASS_UNIVERSAL && tag == TAG_INTEGER)
667       {
668         /* Yep, this is the keyReference.
669            Note: UL is currently not used. */
670         for (ul=0; objlen; objlen--)
671           {
672             ul <<= 8;
673             ul |= (*ppp++) & 0xff;
674             nnn--;
675           }
676       }
677
678   leave_cki:
679     ;
680   }
681
682
683   /* Skip subClassAttributes.  */
684   where = __LINE__;
685   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
686                           &ndef, &objlen, &hdrlen);
687   if (!err && objlen > nn)
688     err = gpg_error (GPG_ERR_INV_OBJ);
689   if (err)
690     goto parse_error;
691   if (class == CLASS_CONTEXT && tag == 0)
692     {
693       pp += objlen;
694       nn -= objlen;
695
696       where = __LINE__;
697       err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
698                               &ndef, &objlen, &hdrlen);
699     }
700
701   /* Parse the keyAttributes.  */
702   if (!err && (objlen > nn || class != CLASS_CONTEXT || tag != 1))
703     err = gpg_error (GPG_ERR_INV_OBJ);
704   if (err)
705     goto parse_error;
706
707   nn = objlen;
708
709   where = __LINE__;
710   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
711                           &ndef, &objlen, &hdrlen);
712   if (!err && objlen > nn)
713     err = gpg_error (GPG_ERR_INV_OBJ);
714   if (err)
715     goto parse_error;
716
717   nn = objlen;
718
719   /* Check that the reference is a Path object.  */
720   where = __LINE__;
721   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
722                           &ndef, &objlen, &hdrlen);
723   if (!err && objlen > nn)
724     err = gpg_error (GPG_ERR_INV_OBJ);
725   if (err)
726     goto parse_error;
727   if (class != CLASS_UNIVERSAL || tag != TAG_SEQUENCE)
728     {
729       errstr = "unsupported reference type";
730       goto parse_error;
731     }
732
733   pp += objlen;
734   nn -= objlen;
735
736   /* Parse the key size object. */
737   where = __LINE__;
738   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
739                           &ndef, &objlen, &hdrlen);
740   if (!err && objlen > nn)
741     err = gpg_error (GPG_ERR_INV_OBJ);
742   if (err)
743     goto parse_error;
744   keysize = 0;
745   if (class == CLASS_UNIVERSAL && tag == TAG_INTEGER && objlen == 2)
746     {
747       keysize  = *pp++ << 8;
748       keysize += *pp++;
749     }
750
751   /* Create a new PrKDF list item. */
752   prkdf = xtrycalloc (1, sizeof *prkdf);
753   if (!prkdf)
754     {
755       err = gpg_error_from_syserror ();
756       goto leave;
757     }
758   prkdf->keytype = keytype;
759   prkdf->keysize = keysize;
760   prkdf->objidlen = objidlen;
761   prkdf->objid = xtrymalloc (objidlen);
762   if (!prkdf->objid)
763     {
764       err = gpg_error_from_syserror ();
765       xfree (prkdf);
766       prkdf = NULL;
767       goto leave;
768     }
769   memcpy (prkdf->objid, objid, objidlen);
770
771   prkdf->usageflags = usageflags;
772   prkdf->key_reference = fid & 0xFF;
773
774   log_debug ("PrKDF %04hX: id=", fid);
775   for (i=0; i < prkdf->objidlen; i++)
776     log_printf ("%02X", prkdf->objid[i]);
777   log_printf (" keyref=0x%02X", prkdf->key_reference);
778   log_printf (" keysize=%zu", prkdf->keysize);
779   log_printf (" usage=");
780   s = "";
781   if (prkdf->usageflags.encrypt)
782     {
783       log_printf ("%sencrypt", s);
784       s = ",";
785     }
786   if (prkdf->usageflags.decrypt)
787     {
788       log_printf ("%sdecrypt", s);
789       s = ",";
790     }
791   if (prkdf->usageflags.sign)
792     {
793       log_printf ("%ssign", s);
794       s = ",";
795     }
796   if (prkdf->usageflags.sign_recover)
797     {
798       log_printf ("%ssign_recover", s);
799       s = ",";
800     }
801   if (prkdf->usageflags.wrap   )
802     {
803       log_printf ("%swrap", s);
804       s = ",";
805     }
806   if (prkdf->usageflags.unwrap )
807     {
808       log_printf ("%sunwrap", s);
809       s = ",";
810     }
811   if (prkdf->usageflags.verify )
812     {
813       log_printf ("%sverify", s);
814       s = ",";
815     }
816   if (prkdf->usageflags.verify_recover)
817     {
818       log_printf ("%sverify_recover", s);
819       s = ",";
820     }
821   if (prkdf->usageflags.derive )
822     {
823       log_printf ("%sderive", s);
824       s = ",";
825     }
826   if (prkdf->usageflags.non_repudiation)
827     {
828       log_printf ("%snon_repudiation", s);
829     }
830   log_printf ("\n");
831
832   xfree (buffer);
833   buffer = NULL;
834   buflen = 0;
835   err = select_and_read_binary (app_get_slot (app),
836                                 ((SC_HSM_EE_PREFIX << 8) | (fid & 0xFF)),
837                                 "CertEF", &buffer, &buflen, 1);
838   if (!err && buffer[0] == 0x30)
839     {
840       /* Create a matching CDF list item. */
841       cdf = xtrycalloc (1, sizeof *cdf);
842       if (!cdf)
843         {
844           err = gpg_error_from_syserror ();
845           goto leave;
846         }
847       cdf->objidlen = prkdf->objidlen;
848       cdf->objid = xtrymalloc (cdf->objidlen);
849       if (!cdf->objid)
850         {
851           err = gpg_error_from_syserror ();
852           xfree (cdf);
853           cdf = NULL;
854           goto leave;
855         }
856       memcpy (cdf->objid, prkdf->objid, objidlen);
857
858       cdf->fid = (SC_HSM_EE_PREFIX << 8) | (fid & 0xFF);
859
860       log_debug ("CDF %04hX: id=", fid);
861       for (i=0; i < cdf->objidlen; i++)
862         log_printf ("%02X", cdf->objid[i]);
863       log_printf (" fid=%04X\n", cdf->fid);
864     }
865
866   goto leave; /* Ready. */
867
868  parse_error:
869   log_error ("error parsing PrKDF record (%d): %s - skipped\n",
870              where, errstr? errstr : gpg_strerror (err));
871   err = 0;
872
873  leave:
874   xfree (buffer);
875   if (err)
876     {
877       if (prkdf)
878         {
879           if (prkdf->objid)
880             xfree (prkdf->objid);
881           xfree (prkdf);
882         }
883       if (cdf)
884         {
885           if (cdf->objid)
886             xfree (cdf->objid);
887           xfree (cdf);
888         }
889     }
890   else
891     {
892       if (prkdf)
893         prkdf->next = *prkdresult;
894       *prkdresult = prkdf;
895       if (cdf)
896         {
897           cdf->next = *cdresult;
898           *cdresult = cdf;
899         }
900     }
901   return err;
902 }
903
904
905
906 /* Read and parse the Certificate Description File identified by FID.
907    On success a the CDF list gets stored at RESULT and the caller is
908    then responsible of releasing the object.
909
910    Example data:
911
912 0000  30 35 30 11 0C 0B 43 65 72 74 69 66 69 63 61 74  050...Certificat
913 0010  65 03 02 06 40 30 16 04 14 C2 01 7C 2F BA A4 4A  e...@0.....|/..J
914 0020  4A BB B8 49 11 DB 4A CA AA 7E 6A 2D 1B A1 08 30  J..I..J..~j-...0
915 0030  06 30 04 04 02 CA 00                             .0.....
916
917    Decoded example:
918
919 SEQUENCE SIZE( 53 )
920   SEQUENCE SIZE( 17 )
921     UTF8-STRING SIZE( 11 )                      -- label
922       0000  43 65 72 74 69 66 69 63 61 74 65                 Certificate
923     BIT-STRING SIZE( 2 )                        -- common object attributes
924       0000  06 40
925   SEQUENCE SIZE( 22 )
926     OCTET-STRING SIZE( 20 )                     -- id
927       0000  C2 01 7C 2F BA A4 4A 4A BB B8 49 11 DB 4A CA AA
928       0010  7E 6A 2D 1B
929   A1 [ CONTEXT 1 ] IMPLICIT SEQUENCE SIZE( 8 )
930     SEQUENCE SIZE( 6 )
931       SEQUENCE SIZE( 4 )
932         OCTET-STRING SIZE( 2 )                  -- path
933           0000  CA 00                                            ..
934  */
935 static gpg_error_t
936 read_ef_cd (app_t app, unsigned short fid, cdf_object_t *result)
937 {
938   gpg_error_t err;
939   unsigned char *buffer = NULL;
940   size_t buflen;
941   const unsigned char *p;
942   size_t n, objlen, hdrlen;
943   int class, tag, constructed, ndef;
944   int i;
945   const unsigned char *pp;
946   size_t nn;
947   int where;
948   const char *errstr = NULL;
949   cdf_object_t cdf = NULL;
950   const unsigned char *objid;
951   size_t objidlen;
952
953   if (!fid)
954     return gpg_error (GPG_ERR_NO_DATA); /* No certificates. */
955
956   err = select_and_read_binary (app_get_slot (app), fid, "CDF",
957                                 &buffer, &buflen, 255);
958   if (err)
959     return err;
960
961   p = buffer;
962   n = buflen;
963
964   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
965                           &ndef, &objlen, &hdrlen);
966   if (!err && (objlen > n || tag != TAG_SEQUENCE))
967     err = gpg_error (GPG_ERR_INV_OBJ);
968   if (err)
969     {
970       log_error ("error parsing CDF record: %s\n", gpg_strerror (err));
971       goto leave;
972     }
973   pp = p;
974   nn = objlen;
975   p += objlen;
976   n -= objlen;
977
978   /* Skip the commonObjectAttributes.  */
979   where = __LINE__;
980   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
981                           &ndef, &objlen, &hdrlen);
982   if (!err && (objlen > nn || tag != TAG_SEQUENCE))
983     err = gpg_error (GPG_ERR_INV_OBJ);
984   if (err)
985     goto parse_error;
986   pp += objlen;
987   nn -= objlen;
988
989   /* Parse the commonCertificateAttributes.  */
990   where = __LINE__;
991   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
992                           &ndef, &objlen, &hdrlen);
993   if (!err && (objlen > nn || tag != TAG_SEQUENCE))
994     err = gpg_error (GPG_ERR_INV_OBJ);
995   if (err)
996     goto parse_error;
997
998   {
999     const unsigned char *ppp = pp;
1000     size_t nnn = objlen;
1001
1002     pp += objlen;
1003     nn -= objlen;
1004
1005     /* Get the Id. */
1006     where = __LINE__;
1007     err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1008                             &ndef, &objlen, &hdrlen);
1009     if (!err && (objlen > nnn
1010                  || class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING))
1011       err = gpg_error (GPG_ERR_INV_OBJ);
1012     if (err)
1013       goto parse_error;
1014
1015     objid = ppp;
1016     objidlen = objlen;
1017   }
1018
1019   /* Parse the certAttribute.  */
1020   where = __LINE__;
1021   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1022                           &ndef, &objlen, &hdrlen);
1023   if (!err && (objlen > nn || class != CLASS_CONTEXT || tag != 1))
1024     err = gpg_error (GPG_ERR_INV_OBJ);
1025   if (err)
1026     goto parse_error;
1027   nn = objlen;
1028
1029   where = __LINE__;
1030   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1031                           &ndef, &objlen, &hdrlen);
1032   if (!err && (objlen > nn
1033                || class != CLASS_UNIVERSAL || tag != TAG_SEQUENCE))
1034     err = gpg_error (GPG_ERR_INV_OBJ);
1035   if (err)
1036     goto parse_error;
1037   nn = objlen;
1038
1039   /* Check that the reference is a Path object.  */
1040   where = __LINE__;
1041   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1042                           &ndef, &objlen, &hdrlen);
1043   if (!err && objlen > nn)
1044     err = gpg_error (GPG_ERR_INV_OBJ);
1045   if (err)
1046     goto parse_error;
1047   if (class != CLASS_UNIVERSAL || tag != TAG_SEQUENCE)
1048     {
1049       err = gpg_error (GPG_ERR_INV_OBJ);
1050       goto parse_error;
1051     }
1052   nn = objlen;
1053
1054   /* Parse the Path object. */
1055   where = __LINE__;
1056   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1057                           &ndef, &objlen, &hdrlen);
1058   if (!err && objlen > nn)
1059     err = gpg_error (GPG_ERR_INV_OBJ);
1060   if (err)
1061     goto parse_error;
1062
1063   /* Make sure that the next element is a non zero path and of
1064      even length (FID are two bytes each). */
1065   if (class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING
1066       || (objlen & 1) )
1067     {
1068       errstr = "invalid path reference";
1069       goto parse_error;
1070     }
1071   /* Create a new CDF list item. */
1072   cdf = xtrycalloc (1, sizeof *cdf);
1073   if (!cdf)
1074     {
1075       err = gpg_error_from_syserror ();
1076       goto leave;
1077     }
1078   cdf->objidlen = objidlen;
1079   cdf->objid = xtrymalloc (objidlen);
1080   if (!cdf->objid)
1081     {
1082       err = gpg_error_from_syserror ();
1083       xfree (cdf);
1084       cdf = NULL;
1085       goto leave;
1086     }
1087   memcpy (cdf->objid, objid, objidlen);
1088
1089   cdf->fid = (SC_HSM_CA_PREFIX << 8) | (fid & 0xFF);
1090
1091   log_debug ("CDF %04hX: id=", fid);
1092   for (i=0; i < cdf->objidlen; i++)
1093     log_printf ("%02X", cdf->objid[i]);
1094
1095   goto leave;
1096
1097  parse_error:
1098   log_error ("error parsing CDF record (%d): %s - skipped\n",
1099              where, errstr? errstr : gpg_strerror (err));
1100   err = 0;
1101
1102  leave:
1103   xfree (buffer);
1104   if (err)
1105     {
1106       if (cdf)
1107         {
1108           if (cdf->objid)
1109             xfree (cdf->objid);
1110           xfree (cdf);
1111         }
1112     }
1113   else
1114     {
1115       if (cdf)
1116         cdf->next = *result;
1117       *result = cdf;
1118     }
1119   return err;
1120 }
1121
1122
1123
1124 /* Read the device certificate and extract the serial number.
1125
1126    EF.C_DevAut (2F02) contains two CVCs, the first is the device
1127    certificate, the second is the issuer certificate.
1128
1129    Example data:
1130
1131 0000  7F 21 81 E2 7F 4E 81 9B 5F 29 01 00 42 0B 55 54  .!...N.._)..B.UT
1132 0010  43 43 30 32 30 30 30 30 32 7F 49 4F 06 0A 04 00  CC0200002.IO....
1133 0020  7F 00 07 02 02 02 02 03 86 41 04 6D FF D6 85 57  .........A.m...W
1134 0030  40 FB 10 5D 94 71 8A 94 D2 5E 50 33 E7 1E C0 6C  @..].q...^P3...l
1135 0040  63 D5 C8 FC BA F3 02 1D 70 23 F6 47 E8 35 48 EF  c.......p#.G.5H.
1136 0050  B5 94 72 3C 6F BE C0 EB 9A C7 FB 06 59 26 CF 65  ..r<o.......Y&.e
1137 0060  EF A1 72 E0 98 F3 F0 44 1B B7 71 5F 20 10 55 54  ..r....D..q_ .UT
1138 0070  43 43 30 32 30 30 30 31 33 30 30 30 30 30 7F 4C  CC020001300000.L
1139 0080  10 06 0B 2B 06 01 04 01 81 C3 1F 03 01 01 53 01  ...+..........S.
1140 0090  00 5F 25 06 01 04 00 07 01 01 5F 24 06 02 01 00  ._%......._$....
1141 00A0  03 02 07 5F 37 40 7F 73 04 3B 06 63 79 41 BE 1A  ..._7@.s.;.cyA..
1142 00B0  9F FC F6 77 67 2B 8A 41 D1 11 F6 9B 54 44 AD 19  ...wg+.A....TD..
1143 00C0  FB B8 0C C6 2F 34 71 8E 4F F6 92 59 34 61 D9 4F  ..../4q.O..Y4a.O
1144 00D0  4A 86 36 A8 D8 9A C6 3C 17 7E 71 CE A8 26 D0 C5  J.6....<.~q..&..
1145 00E0  25 61 78 9D 01 F8 7F 21 81 E0 7F 4E 81 99 5F 29  %ax....!...N.._)
1146 00F0  01 00 42 0E 55 54 53 52 43 41 43 43 31 30 30 30  ..B.UTSRCACC1000
1147 0100  30 31 7F 49 4F 06 0A 04 00 7F 00 07 02 02 02 02  01.IO...........
1148 0110  03 86 41 04 2F EA 33 47 7F 45 81 E2 FC CB 66 87  ..A./.3G.E....f.
1149 0120  4B 96 21 1D 68 81 73 F2 9F 8F 6B 91 F0 DE 4B 54  K.!.h.s...k...KT
1150 0130  8E D8 F0 82 3D CB BE 10 98 A3 1E 4F F0 72 5C E5  ....=......O.r\.
1151 0140  7B 1E F7 3C 68 09 03 E8 A0 3F 3E 06 C1 B0 3C 18  {..<h....?>...<.
1152 0150  6B AC 06 EA 5F 20 0B 55 54 43 43 30 32 30 30 30  k..._ .UTCC02000
1153 0160  30 32 7F 4C 10 06 0B 2B 06 01 04 01 81 C3 1F 03  02.L...+........
1154 0170  01 01 53 01 80 5F 25 06 01 03 00 03 02 08 5F 24  ..S.._%......._$
1155 0180  06 02 01 00 03 02 07 5F 37 40 93 C1 42 8B B3 8E  ......._7@..B...
1156 0190  42 61 6F 2C 19 E6 98 41 BD AA 60 BD E0 DD 4E F0  Bao,...A..`...N.
1157 01A0  15 D5 4F 71 B7 BB C3 3A F2 AD 27 5E DD EE 6D 12  ..Oq...:..'^..m.
1158 01B0  76 E6 2B A0 4C 01 CA C1 26 0C 45 6D C6 CB EC 92  v.+.L...&.Em....
1159 01C0  BF 38 18 AD 8F B2 29 40 A9 51                    .8....)@.Q
1160
1161    The certificate format is defined in BSI TR-03110:
1162
1163 7F21 [ APPLICATION 33 ] IMPLICIT SEQUENCE SIZE( 226 )
1164   7F4E [ APPLICATION 78 ] IMPLICIT SEQUENCE SIZE( 155 )
1165     5F29 [ APPLICATION 41 ] SIZE( 1 )                           -- profile id
1166       0000  00
1167     42 [ APPLICATION 2 ] SIZE( 11 )                             -- CAR
1168       0000  55 54 43 43 30 32 30 30 30 30 32                 UTCC0200002
1169     7F49 [ APPLICATION 73 ] IMPLICIT SEQUENCE SIZE( 79 )        -- public key
1170       OBJECT IDENTIFIER = { id-TA-ECDSA-SHA-256 }
1171       86 [ CONTEXT 6 ] SIZE( 65 )
1172         0000  04 6D FF D6 85 57 40 FB 10 5D 94 71 8A 94 D2 5E
1173         0010  50 33 E7 1E C0 6C 63 D5 C8 FC BA F3 02 1D 70 23
1174         0020  F6 47 E8 35 48 EF B5 94 72 3C 6F BE C0 EB 9A C7
1175         0030  FB 06 59 26 CF 65 EF A1 72 E0 98 F3 F0 44 1B B7
1176         0040  71
1177     5F20 [ APPLICATION 32 ] SIZE( 16 )                          -- CHR
1178       0000  55 54 43 43 30 32 30 30 30 31 33 30 30 30 30 30  UTCC020001300000
1179     7F4C [ APPLICATION 76 ] IMPLICIT SEQUENCE SIZE( 16 )        -- CHAT
1180       OBJECT IDENTIFIER = { 1 3 6 1 4 1 24991 3 1 1 }
1181       53 [ APPLICATION 19 ] SIZE( 1 )
1182         0000  00
1183     5F25 [ APPLICATION 37 ] SIZE( 6 )                           -- Valid from
1184       0000  01 04 00 07 01 01
1185     5F24 [ APPLICATION 36 ] SIZE( 6 )                           -- Valid to
1186       0000  02 01 00 03 02 07
1187   5F37 [ APPLICATION 55 ] SIZE( 64 )                            -- Signature
1188     0000  7F 73 04 3B 06 63 79 41 BE 1A 9F FC F6 77 67 2B
1189     0010  8A 41 D1 11 F6 9B 54 44 AD 19 FB B8 0C C6 2F 34
1190     0020  71 8E 4F F6 92 59 34 61 D9 4F 4A 86 36 A8 D8 9A
1191     0030  C6 3C 17 7E 71 CE A8 26 D0 C5 25 61 78 9D 01 F8
1192
1193    The serial number is contained in tag 5F20, while the last 5 digits
1194    are truncated.
1195  */
1196 static gpg_error_t
1197 read_serialno(app_t app)
1198 {
1199   gpg_error_t err;
1200   unsigned char *buffer = NULL;
1201   size_t buflen;
1202   const unsigned char *p,*chr;
1203   size_t n, objlen, hdrlen, chrlen;
1204   int class, tag, constructed, ndef;
1205
1206   err = select_and_read_binary (app_get_slot (app), 0x2F02, "EF.C_DevAut",
1207                                 &buffer, &buflen, 512);
1208   if (err)
1209     return err;
1210
1211   p = buffer;
1212   n = buflen;
1213
1214   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1215                           &ndef, &objlen, &hdrlen);
1216   if (!err && (objlen > n || tag != 0x21))
1217     err = gpg_error (GPG_ERR_INV_OBJ);
1218   if (err)
1219     {
1220       log_error ("error parsing C_DevAut: %s\n", gpg_strerror (err));
1221       goto leave;
1222     }
1223
1224   chr = find_tlv (p, objlen, 0x5F20, &chrlen);
1225   if (!chr || chrlen <= 5)
1226     {
1227       err = gpg_error (GPG_ERR_INV_OBJ);
1228       log_error ("CHR not found in CVC\n");
1229       goto leave;
1230     }
1231   chrlen -= 5;
1232
1233   app->card->serialno = xtrymalloc (chrlen);
1234   if (!app->card->serialno)
1235     {
1236       err = gpg_error_from_syserror ();
1237       goto leave;
1238     }
1239
1240   app->card->serialnolen = chrlen;
1241   memcpy (app->card->serialno, chr, chrlen);
1242
1243  leave:
1244   xfree (buffer);
1245   return err;
1246 }
1247
1248
1249 /* Get all the basic information from the SmartCard-HSM, check the
1250    structure and initialize our local context.  This is used once at
1251    application initialization.  */
1252 static gpg_error_t
1253 read_meta (app_t app)
1254 {
1255   gpg_error_t err;
1256   unsigned char *eflist = NULL;
1257   size_t eflistlen = 0;
1258   int i;
1259
1260   err = read_serialno(app);
1261   if (err)
1262     return err;
1263
1264   err = list_ef (app_get_slot (app), &eflist, &eflistlen);
1265   if (err)
1266     return err;
1267
1268   for (i = 0; i < eflistlen; i += 2)
1269     {
1270       switch(eflist[i])
1271         {
1272         case SC_HSM_KEY_PREFIX:
1273           if (eflist[i + 1] == 0)    /* No key with ID=0 */
1274             break;
1275           err = read_ef_prkd (app, ((SC_HSM_PRKD_PREFIX << 8) | eflist[i + 1]),
1276                               &app->app_local->private_key_info,
1277                               &app->app_local->certificate_info);
1278           if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1279             err = 0;
1280           if (err)
1281             return err;
1282           break;
1283         case SC_HSM_CD_PREFIX:
1284           err = read_ef_cd (app, ((eflist[i] << 8) | eflist[i + 1]),
1285                             &app->app_local->trusted_certificate_info);
1286           if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1287             err = 0;
1288           if (err)
1289             return err;
1290           break;
1291         }
1292     }
1293
1294   xfree (eflist);
1295
1296   return err;
1297 }
1298
1299
1300
1301 /* Helper to do_learn_status: Send information about all certificates
1302    listed in CERTINFO back.  Use CERTTYPE as type of the
1303    certificate. */
1304 static gpg_error_t
1305 send_certinfo (ctrl_t ctrl, const char *certtype, cdf_object_t certinfo)
1306 {
1307   for (; certinfo; certinfo = certinfo->next)
1308     {
1309       char *buf, *p;
1310
1311       buf = xtrymalloc (4 + certinfo->objidlen*2 + 1);
1312       if (!buf)
1313         return gpg_error_from_syserror ();
1314       p = stpcpy (buf, "HSM.");
1315       bin2hex (certinfo->objid, certinfo->objidlen, p);
1316
1317       send_status_info (ctrl, "CERTINFO",
1318                         certtype, strlen (certtype),
1319                         buf, strlen (buf),
1320                         NULL, (size_t)0);
1321       xfree (buf);
1322     }
1323   return 0;
1324 }
1325
1326
1327
1328 /* Get the keygrip of the private key object PRKDF.  On success the
1329    keygrip gets returned in the caller provided 41 byte buffer
1330    R_GRIPSTR. */
1331 static gpg_error_t
1332 keygripstr_from_prkdf (app_t app, prkdf_object_t prkdf, char *r_gripstr)
1333 {
1334   gpg_error_t err;
1335   cdf_object_t cdf;
1336   unsigned char *der;
1337   size_t derlen;
1338   ksba_cert_t cert;
1339
1340   /* Look for a matching certificate. A certificate matches if the Id
1341      matches the one of the private key info. */
1342   for (cdf = app->app_local->certificate_info; cdf; cdf = cdf->next)
1343     if (cdf->objidlen == prkdf->objidlen
1344         && !memcmp (cdf->objid, prkdf->objid, prkdf->objidlen))
1345       break;
1346   if (!cdf)
1347     return gpg_error (GPG_ERR_NOT_FOUND);
1348
1349   err = readcert_by_cdf (app, cdf, &der, &derlen);
1350   if (err)
1351     return err;
1352
1353   err = ksba_cert_new (&cert);
1354   if (!err)
1355     err = ksba_cert_init_from_mem (cert, der, derlen);
1356   xfree (der);
1357   if (!err)
1358     err = app_help_get_keygrip_string (cert, r_gripstr);
1359   ksba_cert_release (cert);
1360
1361   return err;
1362 }
1363
1364
1365
1366 /* Helper to do_learn_status: Send information about all known
1367    keypairs back. */
1368 static gpg_error_t
1369 send_keypairinfo (app_t app, ctrl_t ctrl, prkdf_object_t keyinfo)
1370 {
1371   gpg_error_t err;
1372
1373   for (; keyinfo; keyinfo = keyinfo->next)
1374     {
1375       char gripstr[40+1];
1376       char *buf, *p;
1377
1378       buf = xtrymalloc (4 + keyinfo->objidlen*2 + 1);
1379       if (!buf)
1380         return gpg_error_from_syserror ();
1381       p = stpcpy (buf, "HSM.");
1382       bin2hex (keyinfo->objid, keyinfo->objidlen, p);
1383
1384       err = keygripstr_from_prkdf (app, keyinfo, gripstr);
1385       if (err)
1386         {
1387           log_error ("can't get keygrip from %04X\n", keyinfo->key_reference);
1388         }
1389       else
1390         {
1391           assert (strlen (gripstr) == 40);
1392           send_status_info (ctrl, "KEYPAIRINFO",
1393                             gripstr, 40,
1394                             buf, strlen (buf),
1395                             NULL, (size_t)0);
1396         }
1397       xfree (buf);
1398     }
1399   return 0;
1400 }
1401
1402
1403
1404 /* This is the handler for the LEARN command. */
1405 static gpg_error_t
1406 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1407 {
1408   gpg_error_t err;
1409
1410   if ((flags & APP_LEARN_FLAG_KEYPAIRINFO))
1411     err = 0;
1412   else
1413     {
1414       err = send_certinfo (ctrl, "100", app->app_local->certificate_info);
1415       if (!err)
1416         err = send_certinfo (ctrl, "101",
1417             app->app_local->trusted_certificate_info);
1418     }
1419
1420   if (!err)
1421     err = send_keypairinfo (app, ctrl, app->app_local->private_key_info);
1422
1423   return err;
1424 }
1425
1426
1427
1428 /* Read a certificate using the information in CDF and return the
1429    certificate in a newly allocated buffer R_CERT and its length
1430    R_CERTLEN. */
1431 static gpg_error_t
1432 readcert_by_cdf (app_t app, cdf_object_t cdf,
1433                  unsigned char **r_cert, size_t *r_certlen)
1434 {
1435   gpg_error_t err;
1436   unsigned char *buffer = NULL;
1437   const unsigned char *p, *save_p;
1438   size_t buflen, n;
1439   int class, tag, constructed, ndef;
1440   size_t totobjlen, objlen, hdrlen;
1441   int rootca;
1442   int i;
1443
1444   *r_cert = NULL;
1445   *r_certlen = 0;
1446
1447   /* First check whether it has been cached. */
1448   if (cdf->image)
1449     {
1450       *r_cert = xtrymalloc (cdf->imagelen);
1451       if (!*r_cert)
1452         return gpg_error_from_syserror ();
1453       memcpy (*r_cert, cdf->image, cdf->imagelen);
1454       *r_certlen = cdf->imagelen;
1455       return 0;
1456     }
1457
1458   err = select_and_read_binary (app_get_slot (app), cdf->fid, "CD",
1459                                 &buffer, &buflen, 4096);
1460   if (err)
1461     {
1462       log_error ("error reading certificate with Id ");
1463       for (i=0; i < cdf->objidlen; i++)
1464         log_printf ("%02X", cdf->objid[i]);
1465       log_printf (": %s\n", gpg_strerror (err));
1466       goto leave;
1467     }
1468
1469   /* Check whether this is really a certificate.  */
1470   p = buffer;
1471   n = buflen;
1472   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1473                           &ndef, &objlen, &hdrlen);
1474   if (err)
1475     goto leave;
1476
1477   if (class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed)
1478     rootca = 0;
1479   else if ( class == CLASS_UNIVERSAL && tag == TAG_SET && constructed )
1480     rootca = 1;
1481   else
1482     {
1483       err = gpg_error (GPG_ERR_INV_OBJ);
1484       goto leave;
1485     }
1486   totobjlen = objlen + hdrlen;
1487   assert (totobjlen <= buflen);
1488
1489   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1490                           &ndef, &objlen, &hdrlen);
1491   if (err)
1492     goto leave;
1493
1494   if (!rootca
1495       && class == CLASS_UNIVERSAL && tag == TAG_OBJECT_ID && !constructed)
1496     {
1497       /* The certificate seems to be contained in a userCertificate
1498          container.  Skip this and assume the following sequence is
1499          the certificate. */
1500       if (n < objlen)
1501         {
1502           err = gpg_error (GPG_ERR_INV_OBJ);
1503           goto leave;
1504         }
1505       p += objlen;
1506       n -= objlen;
1507       save_p = p;
1508       err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1509                               &ndef, &objlen, &hdrlen);
1510       if (err)
1511         goto leave;
1512       if ( !(class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed) )
1513         {
1514           err = gpg_error (GPG_ERR_INV_OBJ);
1515           goto leave;
1516         }
1517       totobjlen = objlen + hdrlen;
1518       assert (save_p + totobjlen <= buffer + buflen);
1519       memmove (buffer, save_p, totobjlen);
1520     }
1521
1522   *r_cert = buffer;
1523   buffer = NULL;
1524   *r_certlen = totobjlen;
1525
1526   /* Try to cache it. */
1527   if (!cdf->image && (cdf->image = xtrymalloc (*r_certlen)))
1528     {
1529       memcpy (cdf->image, *r_cert, *r_certlen);
1530       cdf->imagelen = *r_certlen;
1531     }
1532
1533
1534  leave:
1535   xfree (buffer);
1536   return err;
1537 }
1538
1539
1540
1541 /* Handler for the READCERT command.
1542
1543    Read the certificate with id CERTID (as returned by learn_status in
1544    the CERTINFO status lines) and return it in the freshly allocated
1545    buffer to be stored at R_CERT and its length at R_CERTLEN.  A error
1546    code will be returned on failure and R_CERT and R_CERTLEN will be
1547    set to (NULL,0). */
1548 static gpg_error_t
1549 do_readcert (app_t app, const char *certid,
1550              unsigned char **r_cert, size_t *r_certlen)
1551 {
1552   gpg_error_t err;
1553   cdf_object_t cdf;
1554
1555   *r_cert = NULL;
1556   *r_certlen = 0;
1557   err = cdf_object_from_certid (app, certid, &cdf);
1558   if (!err)
1559     err = readcert_by_cdf (app, cdf, r_cert, r_certlen);
1560   return err;
1561 }
1562
1563
1564
1565 /* Implement the GETATTR command.  This is similar to the LEARN
1566    command but returns just one value via the status interface. */
1567 static gpg_error_t
1568 do_getattr (app_t app, ctrl_t ctrl, const char *name)
1569 {
1570   if (!strcmp (name, "$AUTHKEYID"))
1571     {
1572       char *buf, *p;
1573       prkdf_object_t prkdf;
1574
1575       /* We return the ID of the first private key capable of
1576          signing. */
1577       for (prkdf = app->app_local->private_key_info; prkdf;
1578            prkdf = prkdf->next)
1579         if (prkdf->usageflags.sign)
1580           break;
1581       if (prkdf)
1582         {
1583           buf = xtrymalloc (4 + prkdf->objidlen*2 + 1);
1584           if (!buf)
1585             return gpg_error_from_syserror ();
1586           p = stpcpy (buf, "HSM.");
1587           bin2hex (prkdf->objid, prkdf->objidlen, p);
1588
1589           send_status_info (ctrl, name, buf, strlen (buf), NULL, 0);
1590           xfree (buf);
1591           return 0;
1592         }
1593     }
1594   else if (!strcmp (name, "$DISPSERIALNO"))
1595     {
1596       send_status_info (ctrl, name,
1597                         app->card->serialno, app->card->serialnolen, NULL, 0);
1598       return 0;
1599     }
1600
1601   return gpg_error (GPG_ERR_INV_NAME);
1602 }
1603
1604
1605
1606 /* Apply PKCS#1 V1.5 padding for signature operation.  The function
1607  * combines padding, digest info and the hash value.  The buffer must
1608  * be allocated by the caller matching the key size.  */
1609 static void
1610 apply_PKCS_padding(const unsigned char *dig, int diglen,
1611                    const unsigned char *prefix, int prefixlen,
1612                    unsigned char *buff, int bufflen)
1613 {
1614   int i, n_ff;
1615
1616   /* Caller must ensure a sufficient buffer.  */
1617   if (diglen + prefixlen + 4 > bufflen)
1618     return;
1619   n_ff = bufflen - diglen - prefixlen - 3;
1620
1621   *buff++ = 0x00;
1622   *buff++ = 0x01;
1623   for (i=0; i < n_ff; i++)
1624     *buff++ = 0xFF;
1625   *buff++ = 0x00;
1626
1627   if (prefix)
1628     memcpy (buff, prefix, prefixlen);
1629   buff += prefixlen;
1630   memcpy (buff, dig, diglen);
1631 }
1632
1633
1634
1635 /* Decode a digest info structure (DI,DILEN) to extract the hash
1636  * value.  The buffer HASH to receive the digest must be provided by
1637  * the caller with HASHLEN pointing to the inbound length.  HASHLEN is
1638  * updated to the outbound length.  */
1639 static int
1640 hash_from_digestinfo (const unsigned char *di, size_t dilen,
1641                       unsigned char *hash, size_t *hashlen)
1642 {
1643   const unsigned char *p,*pp;
1644   size_t n, nn, objlen, hdrlen;
1645   int class, tag, constructed, ndef;
1646   gpg_error_t err;
1647
1648   p = di;
1649   n = dilen;
1650
1651   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1652                           &ndef, &objlen, &hdrlen);
1653   if (!err && (objlen > n || tag != TAG_SEQUENCE))
1654     err = gpg_error (GPG_ERR_INV_OBJ);
1655   if ( err )
1656     return err;
1657
1658   pp = p;
1659   nn = objlen;
1660
1661   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1662                           &ndef, &objlen, &hdrlen);
1663   if (!err && (objlen > nn || tag != TAG_SEQUENCE))
1664     err = gpg_error (GPG_ERR_INV_OBJ);
1665   if ( err )
1666     return err;
1667
1668   pp += objlen;
1669   nn -= objlen;
1670
1671   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1672                           &ndef, &objlen, &hdrlen);
1673   if (!err && (objlen > nn || tag != TAG_OCTET_STRING))
1674     err = gpg_error (GPG_ERR_INV_OBJ);
1675   if ( err )
1676     return err;
1677
1678   if (*hashlen < objlen)
1679     return gpg_error (GPG_ERR_TOO_SHORT);
1680   memcpy (hash, pp, objlen);
1681   *hashlen = objlen;
1682   return 0;
1683 }
1684
1685
1686 /* Perform PIN verification
1687  */
1688 static gpg_error_t
1689 verify_pin (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
1690             void *pincb_arg)
1691 {
1692   gpg_error_t err;
1693   pininfo_t pininfo;
1694   char *pinvalue;
1695   char *prompt;
1696   int sw;
1697
1698   sw = apdu_send_simple (app_get_slot (app),
1699                          0, 0x00, ISO7816_VERIFY, 0x00, 0x81, -1, NULL);
1700
1701   if (sw == SW_SUCCESS)
1702     return 0;                   /* PIN already verified */
1703
1704   if (sw == SW_REF_DATA_INV)
1705     {
1706       log_error ("SmartCard-HSM not initialized. Run sc-hsm-tool first\n");
1707       return gpg_error (GPG_ERR_NO_PIN);
1708     }
1709
1710   if (sw == SW_CHV_BLOCKED)
1711     {
1712       log_error ("PIN Blocked\n");
1713       return gpg_error (GPG_ERR_PIN_BLOCKED);
1714     }
1715
1716   memset (&pininfo, 0, sizeof pininfo);
1717   pininfo.fixedlen = 0;
1718   pininfo.minlen = 6;
1719   pininfo.maxlen = 15;
1720
1721   prompt = "||Please enter the PIN";
1722
1723   if (!opt.disable_pinpad
1724       && !iso7816_check_pinpad (app_get_slot (app), ISO7816_VERIFY, &pininfo) )
1725     {
1726       err = pincb (pincb_arg, prompt, NULL);
1727       if (err)
1728         {
1729           log_info ("PIN callback returned error: %s\n", gpg_strerror (err));
1730           return err;
1731         }
1732
1733       err = iso7816_verify_kp (app_get_slot (app), 0x81, &pininfo);
1734       pincb (pincb_arg, NULL, NULL);  /* Dismiss the prompt. */
1735     }
1736   else
1737     {
1738       err = pincb (pincb_arg, prompt, &pinvalue);
1739       if (err)
1740         {
1741           log_info ("PIN callback returned error: %s\n", gpg_strerror (err));
1742           return err;
1743         }
1744
1745       err = iso7816_verify (app_get_slot (app),
1746                             0x81, pinvalue, strlen(pinvalue));
1747       xfree (pinvalue);
1748     }
1749   if (err)
1750     {
1751       log_error ("PIN verification failed: %s\n", gpg_strerror (err));
1752       return err;
1753     }
1754   log_debug ("PIN verification succeeded\n");
1755   return err;
1756 }
1757
1758
1759
1760 /* Handler for the PKSIGN command.
1761
1762    Create the signature and return the allocated result in OUTDATA.
1763    If a PIN is required, the PINCB will be used to ask for the PIN;
1764    that callback should return the PIN in an allocated buffer and
1765    store that as the 3rd argument.
1766
1767    The API is somewhat inconsistent: The caller can either supply
1768    a plain hash and the algorithm in hashalgo or a complete
1769    DigestInfo structure. The former is detect by characteristic length
1770    of the provided data (20,28,32,48 or 64 byte).
1771
1772    The function returns the RSA block in the size of the modulus or
1773    the ECDSA signature in X9.62 format (SEQ/INT(r)/INT(s))
1774 */
1775 static gpg_error_t
1776 do_sign (app_t app, const char *keyidstr, int hashalgo,
1777          gpg_error_t (*pincb)(void*, const char *, char **),
1778          void *pincb_arg,
1779          const void *indata, size_t indatalen,
1780          unsigned char **outdata, size_t *outdatalen )
1781 {
1782   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
1783     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
1784       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
1785   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
1786     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
1787       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
1788   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
1789     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
1790       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
1791       0x1C  };
1792   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
1793     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
1794       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
1795       0x00, 0x04, 0x20  };
1796   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
1797     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
1798       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
1799       0x00, 0x04, 0x30  };
1800   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
1801     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
1802       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
1803       0x00, 0x04, 0x40  };
1804
1805   gpg_error_t err;
1806   unsigned char cdsblk[256]; /* Raw PKCS#1 V1.5 block with padding
1807                                 (RSA) or hash.  */
1808   prkdf_object_t prkdf;      /* The private key object. */
1809   size_t cdsblklen;
1810   unsigned char algoid;
1811   int sw;
1812
1813   if (!keyidstr || !*keyidstr)
1814     return gpg_error (GPG_ERR_INV_VALUE);
1815
1816   if (indatalen > 124)          /* Limit for 1024 bit key */
1817     return gpg_error (GPG_ERR_INV_VALUE);
1818
1819   err = prkdf_object_from_keyidstr (app, keyidstr, &prkdf);
1820   if (err)
1821     return err;
1822   if (!(prkdf->usageflags.sign || prkdf->usageflags.sign_recover
1823         ||prkdf->usageflags.non_repudiation))
1824     {
1825       log_error ("key %s may not be used for signing\n", keyidstr);
1826       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1827     }
1828
1829   if (prkdf->keytype == KEY_TYPE_RSA)
1830     {
1831       algoid = 0x20;
1832
1833       cdsblklen = prkdf->keysize >> 3;
1834       if (!cdsblklen)
1835         cdsblklen = 256;
1836
1837       if (hashalgo == GCRY_MD_SHA1 && indatalen == 20)
1838         apply_PKCS_padding (indata, indatalen,
1839                             sha1_prefix, sizeof(sha1_prefix),
1840                             cdsblk, cdsblklen);
1841       else if (hashalgo == GCRY_MD_MD5 && indatalen == 20)
1842         apply_PKCS_padding (indata, indatalen,
1843                             rmd160_prefix, sizeof(rmd160_prefix),
1844                             cdsblk, cdsblklen);
1845       else if (hashalgo == GCRY_MD_SHA224 && indatalen == 28)
1846         apply_PKCS_padding (indata, indatalen,
1847                             sha224_prefix, sizeof(sha224_prefix),
1848                             cdsblk, cdsblklen);
1849       else if (hashalgo == GCRY_MD_SHA256 && indatalen == 32)
1850         apply_PKCS_padding (indata, indatalen,
1851                             sha256_prefix, sizeof(sha256_prefix),
1852                             cdsblk, cdsblklen);
1853       else if (hashalgo == GCRY_MD_SHA384 && indatalen == 48)
1854         apply_PKCS_padding (indata, indatalen,
1855                             sha384_prefix, sizeof(sha384_prefix),
1856                             cdsblk, cdsblklen);
1857       else if (hashalgo == GCRY_MD_SHA512 && indatalen == 64)
1858         apply_PKCS_padding (indata, indatalen,
1859                             sha512_prefix, sizeof(sha512_prefix),
1860                             cdsblk, cdsblklen);
1861       else  /* Assume it's already a digest info or TLS_MD5SHA1 */
1862         apply_PKCS_padding (indata, indatalen, NULL, 0, cdsblk, cdsblklen);
1863     }
1864   else
1865     {
1866       algoid = 0x70;
1867       if (indatalen != 20 && indatalen != 28 && indatalen != 32
1868           && indatalen != 48 && indatalen != 64)
1869         {
1870           cdsblklen = sizeof(cdsblk);
1871           err = hash_from_digestinfo (indata, indatalen, cdsblk, &cdsblklen);
1872           if (err)
1873             {
1874               log_error ("DigestInfo invalid: %s\n", gpg_strerror (err));
1875               return err;
1876             }
1877         }
1878       else
1879         {
1880           memcpy (cdsblk, indata, indatalen);
1881           cdsblklen = indatalen;
1882         }
1883     }
1884
1885   err = verify_pin (app, pincb, pincb_arg);
1886   if (err)
1887     return err;
1888
1889   sw = apdu_send_le (app_get_slot (app),
1890                      1, 0x80, 0x68, prkdf->key_reference, algoid,
1891                      cdsblklen, cdsblk, 0, outdata, outdatalen);
1892   return iso7816_map_sw (sw);
1893 }
1894
1895
1896
1897 /* Handler for the PKAUTH command.
1898
1899    This is basically the same as the PKSIGN command but we first check
1900    that the requested key is suitable for authentication; that is, it
1901    must match the criteria used for the attribute $AUTHKEYID.  See
1902    do_sign for calling conventions; there is no HASHALGO, though. */
1903 static gpg_error_t
1904 do_auth (app_t app, const char *keyidstr,
1905          gpg_error_t (*pincb)(void*, const char *, char **),
1906          void *pincb_arg,
1907          const void *indata, size_t indatalen,
1908          unsigned char **outdata, size_t *outdatalen )
1909 {
1910   gpg_error_t err;
1911   prkdf_object_t prkdf;
1912   int algo;
1913
1914   if (!keyidstr || !*keyidstr)
1915     return gpg_error (GPG_ERR_INV_VALUE);
1916
1917   err = prkdf_object_from_keyidstr (app, keyidstr, &prkdf);
1918   if (err)
1919     return err;
1920   if (!prkdf->usageflags.sign)
1921     {
1922       log_error ("key %s may not be used for authentication\n", keyidstr);
1923       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1924     }
1925
1926   algo = indatalen == 36? MD_USER_TLS_MD5SHA1 : GCRY_MD_SHA1;
1927   return do_sign (app, keyidstr, algo, pincb, pincb_arg,
1928                   indata, indatalen, outdata, outdatalen);
1929 }
1930
1931
1932
1933 /* Check PKCS#1 V1.5 padding and extract plain text.  The function
1934  * allocates a buffer for the plain text.  The caller must release the
1935  * buffer.  */
1936 static gpg_error_t
1937 strip_PKCS15_padding(unsigned char *src, int srclen, unsigned char **dst,
1938                      size_t *dstlen)
1939 {
1940   unsigned char *p;
1941
1942   if (srclen < 2)
1943     return gpg_error (GPG_ERR_DECRYPT_FAILED);
1944   if (*src++ != 0x00)
1945     return gpg_error (GPG_ERR_DECRYPT_FAILED);
1946   if (*src++ != 0x02)
1947     return gpg_error (GPG_ERR_DECRYPT_FAILED);
1948   srclen -= 2;
1949   while ((srclen > 0) && *src)
1950     {
1951       src++;
1952       srclen--;
1953     }
1954
1955   if (srclen < 2)
1956     return gpg_error (GPG_ERR_DECRYPT_FAILED);
1957
1958   src++;
1959   srclen--;
1960
1961   p = xtrymalloc (srclen);
1962   if (!p)
1963     return gpg_error_from_syserror ();
1964
1965   memcpy (p, src, srclen);
1966   *dst = p;
1967   *dstlen = srclen;
1968
1969   return 0;
1970 }
1971
1972
1973 /* Decrypt a PKCS#1 V1.5 formatted cryptogram using the referenced
1974    key.  */
1975 static gpg_error_t
1976 do_decipher (app_t app, const char *keyidstr,
1977              gpg_error_t (*pincb)(void*, const char *, char **),
1978              void *pincb_arg,
1979              const void *indata, size_t indatalen,
1980              unsigned char **outdata, size_t *outdatalen,
1981              unsigned int *r_info)
1982 {
1983   gpg_error_t err;
1984   unsigned char p1blk[256]; /* Enciphered P1 block */
1985   prkdf_object_t prkdf;     /* The private key object. */
1986   unsigned char *rspdata;
1987   size_t rspdatalen;
1988   size_t p1blklen;
1989   int sw;
1990
1991   if (!keyidstr || !*keyidstr || !indatalen)
1992     return gpg_error (GPG_ERR_INV_VALUE);
1993
1994   err = prkdf_object_from_keyidstr (app, keyidstr, &prkdf);
1995   if (err)
1996     return err;
1997   if (!(prkdf->usageflags.decrypt || prkdf->usageflags.unwrap))
1998     {
1999       log_error ("key %s may not be used for deciphering\n", keyidstr);
2000       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
2001     }
2002
2003   if (prkdf->keytype != KEY_TYPE_RSA)
2004     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2005
2006   p1blklen = prkdf->keysize >> 3;
2007   if (!p1blklen)
2008     p1blklen = 256;
2009
2010   /* The input may be shorter (due to MPIs not storing leading zeroes)
2011      or longer than the block size.  We put INDATA right aligned into
2012      the buffer.  If INDATA is longer than the block size we truncate
2013      it on the left. */
2014   memset (p1blk, 0, sizeof(p1blk));
2015   if (indatalen > p1blklen)
2016     memcpy (p1blk, (unsigned char *)indata + (indatalen - p1blklen), p1blklen);
2017   else
2018     memcpy (p1blk + (p1blklen - indatalen), indata, indatalen);
2019
2020
2021   err = verify_pin(app, pincb, pincb_arg);
2022   if (err)
2023     return err;
2024
2025   sw = apdu_send_le (app_get_slot (app),
2026                      1, 0x80, 0x62, prkdf->key_reference, 0x21,
2027                      p1blklen, p1blk, 0, &rspdata, &rspdatalen);
2028   err = iso7816_map_sw (sw);
2029   if (err)
2030     {
2031       log_error ("Decrypt failed: %s\n", gpg_strerror (err));
2032       return err;
2033     }
2034
2035   err = strip_PKCS15_padding (rspdata, rspdatalen, outdata, outdatalen);
2036   xfree (rspdata);
2037
2038   if (!err)
2039     *r_info |= APP_DECIPHER_INFO_NOPAD;
2040
2041   return err;
2042 }
2043
2044
2045
2046 /*
2047  * Select the SmartCard-HSM application on the card in SLOT.
2048  */
2049 gpg_error_t
2050 app_select_sc_hsm (app_t app)
2051 {
2052   int slot = app_get_slot (app);
2053   int rc;
2054
2055   rc = iso7816_select_application (slot, sc_hsm_aid, sizeof sc_hsm_aid, 0);
2056   if (!rc)
2057     {
2058       app->apptype = APPTYPE_SC_HSM;
2059
2060       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2061       if (!app->app_local)
2062         {
2063           rc = gpg_error_from_syserror ();
2064           goto leave;
2065         }
2066
2067       rc = read_meta (app);
2068       if (rc)
2069         goto leave;
2070
2071       app->fnc.deinit = do_deinit;
2072       app->fnc.reselect = NULL;
2073       app->fnc.learn_status = do_learn_status;
2074       app->fnc.readcert = do_readcert;
2075       app->fnc.getattr = do_getattr;
2076       app->fnc.setattr = NULL;
2077       app->fnc.genkey = NULL;
2078       app->fnc.sign = do_sign;
2079       app->fnc.auth = do_auth;
2080       app->fnc.decipher = do_decipher;
2081       app->fnc.change_pin = NULL;
2082       app->fnc.check_pin = NULL;
2083
2084     leave:
2085       if (rc)
2086         do_deinit (app);
2087    }
2088
2089   return rc;
2090 }