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