po: Update Russian translation
[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 "app-common.h"
37 #include "../common/tlv.h"
38 #include "apdu.h"
39
40
41 /* The AID of the SmartCard-HSM applet. */
42 static char const sc_hsm_aid[] = { 0xE8, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x81,
43                                    0xC3, 0x1F, 0x02, 0x01  };
44
45
46 /* Special file identifier for SmartCard-HSM */
47 typedef enum
48 {
49     SC_HSM_PRKD_PREFIX = 0xC4,
50     SC_HSM_CD_PREFIX = 0xC8,
51     SC_HSM_DCOD_PREFIX = 0xC9,
52     SC_HSM_CA_PREFIX = 0xCA,
53     SC_HSM_KEY_PREFIX = 0xCC,
54     SC_HSM_EE_PREFIX = 0xCE
55 } fid_prefix_type_t;
56
57
58 /* The key types supported by the SmartCard-HSM */
59 typedef enum
60   {
61     KEY_TYPE_RSA,
62     KEY_TYPE_ECC
63   } key_type_t;
64
65
66 /* A bit array with for the key usage flags from the
67    commonKeyAttributes. */
68 struct keyusage_flags_s
69 {
70     unsigned int encrypt: 1;
71     unsigned int decrypt: 1;
72     unsigned int sign: 1;
73     unsigned int sign_recover: 1;
74     unsigned int wrap: 1;
75     unsigned int unwrap: 1;
76     unsigned int verify: 1;
77     unsigned int verify_recover: 1;
78     unsigned int derive: 1;
79     unsigned int non_repudiation: 1;
80 };
81 typedef struct keyusage_flags_s keyusage_flags_t;
82
83
84
85 /* This is an object to store information about a Certificate
86    Directory File (CDF) in a format suitable for further processing by
87    us. To keep memory management, simple we use a linked list of
88    items; i.e. one such object represents one certificate and the list
89    the entire CDF. */
90 struct cdf_object_s
91 {
92   /* Link to next item when used in a linked list. */
93   struct cdf_object_s *next;
94
95   /* Length and allocated buffer with the Id of this object. */
96   size_t objidlen;
97   unsigned char *objid;
98
99   /* To avoid reading a certificate more than once, we cache it in an
100      allocated memory IMAGE of IMAGELEN. */
101   size_t imagelen;
102   unsigned char *image;
103
104   /* EF containing certificate */
105   unsigned short fid;
106 };
107 typedef struct cdf_object_s *cdf_object_t;
108
109
110
111 /* This is an object to store information about a Private Key
112    Directory File (PrKDF) in a format suitable for further processing
113    by us. To keep memory management, simple we use a linked list of
114    items; i.e. one such object represents one certificate and the list
115    the entire PrKDF. */
116 struct prkdf_object_s
117 {
118   /* Link to next item when used in a linked list. */
119   struct prkdf_object_s *next;
120
121   /* Key type */
122   key_type_t keytype;
123
124   /* Key size in bits or 0 if unknown */
125   size_t keysize;
126
127   /* Length and allocated buffer with the Id of this object. */
128   size_t objidlen;
129   unsigned char *objid;
130
131   /* The key's usage flags. */
132   keyusage_flags_t usageflags;
133
134   /* The keyReference */
135   unsigned char key_reference;
136 };
137 typedef struct prkdf_object_s *prkdf_object_t;
138
139
140
141 /* Context local to this application. */
142 struct app_local_s
143 {
144   /* Information on all certificates. */
145   cdf_object_t certificate_info;
146   /* Information on all trusted certificates. */
147   cdf_object_t trusted_certificate_info;
148   /* Information on all private keys. */
149   prkdf_object_t private_key_info;
150 };
151
152
153
154 /*** Local prototypes.  ***/
155 static gpg_error_t readcert_by_cdf (app_t app, cdf_object_t cdf,
156                                     unsigned char **r_cert, size_t *r_certlen);
157
158
159
160 /* Release the CDF object A  */
161 static void
162 release_cdflist (cdf_object_t a)
163 {
164   while (a)
165     {
166       cdf_object_t tmp = a->next;
167       xfree (a->image);
168       xfree (a->objid);
169       xfree (a);
170       a = tmp;
171     }
172 }
173
174
175
176 /* Release the PrKDF object A.  */
177 static void
178 release_prkdflist (prkdf_object_t a)
179 {
180   while (a)
181     {
182       prkdf_object_t tmp = a->next;
183       xfree (a->objid);
184       xfree (a);
185       a = tmp;
186     }
187 }
188
189
190
191 /* Release all local resources.  */
192 static void
193 do_deinit (app_t app)
194 {
195   if (app && app->app_local)
196     {
197       release_cdflist (app->app_local->certificate_info);
198       release_cdflist (app->app_local->trusted_certificate_info);
199       release_prkdflist (app->app_local->private_key_info);
200       xfree (app->app_local);
201       app->app_local = NULL;
202     }
203 }
204
205
206
207 /* Get the list of EFs from the SmartCard-HSM.
208  * On success a dynamically buffer containing the EF list is returned.
209  * The caller is responsible for freeing the buffer.
210  */
211 static gpg_error_t
212 list_ef (int slot, unsigned char **result, size_t *resultlen)
213 {
214   int sw;
215
216   if (!result || !resultlen)
217     return gpg_error (GPG_ERR_INV_VALUE);
218   *result = NULL;
219   *resultlen = 0;
220
221   sw = apdu_send_le (slot, 1, 0x80, 0x58, 0x00, 0x00, -1, NULL, 65536,
222                      result, resultlen);
223   if (sw != SW_SUCCESS)
224     {
225       /* Make sure that pending buffers are released. */
226       xfree (*result);
227       *result = NULL;
228       *resultlen = 0;
229     }
230   return iso7816_map_sw (sw);
231 }
232
233
234
235 /* Do a select and a read for the file with EFID.  EFID_DESC is a
236    description of the EF to be used with error messages.  On success
237    BUFFER and BUFLEN contain the entire content of the EF.  The caller
238    must free BUFFER only on success. */
239 static gpg_error_t
240 select_and_read_binary (int slot, unsigned short efid, const char *efid_desc,
241                         unsigned char **buffer, size_t *buflen, int maxread)
242 {
243   gpg_error_t err;
244   unsigned char cdata[4];
245   int sw;
246
247   cdata[0] = 0x54;      /* Create ISO 7861-4 odd ins READ BINARY */
248   cdata[1] = 0x02;
249   cdata[2] = 0x00;
250   cdata[3] = 0x00;
251
252   sw = apdu_send_le(slot, 1, 0x00, 0xB1, efid >> 8, efid & 0xFF,
253                     4, cdata, maxread, buffer, buflen);
254
255   if (sw == SW_EOF_REACHED)
256     sw = SW_SUCCESS;
257
258   err = iso7816_map_sw (sw);
259   if (err)
260     {
261       log_error ("error reading %s (0x%04X): %s\n",
262                  efid_desc, efid, gpg_strerror (err));
263       return err;
264     }
265   return 0;
266 }
267
268
269
270 /* Parse a cert Id string (or a key Id string) and return the binary
271    object Id string in a newly allocated buffer stored at R_OBJID and
272    R_OBJIDLEN.  On Error NULL will be stored there and an error code
273    returned. On success caller needs to free the buffer at R_OBJID. */
274 static gpg_error_t
275 parse_certid (const char *certid, unsigned char **r_objid, size_t *r_objidlen)
276 {
277   const char *s;
278   size_t objidlen;
279   unsigned char *objid;
280   int i;
281
282   *r_objid = NULL;
283   *r_objidlen = 0;
284
285   if (strncmp (certid, "HSM.", 4))
286     return gpg_error (GPG_ERR_INV_ID);
287   certid += 4;
288
289   for (s=certid, objidlen=0; hexdigitp (s); s++, objidlen++)
290     ;
291   if (*s || !objidlen || (objidlen%2))
292     return gpg_error (GPG_ERR_INV_ID);
293   objidlen /= 2;
294   objid = xtrymalloc (objidlen);
295   if (!objid)
296     return gpg_error_from_syserror ();
297   for (s=certid, i=0; i < objidlen; i++, s+=2)
298     objid[i] = xtoi_2 (s);
299   *r_objid = objid;
300   *r_objidlen = objidlen;
301   return 0;
302 }
303
304
305
306 /* Find a certificate object by the certificate ID CERTID and store a
307    pointer to it at R_CDF. */
308 static gpg_error_t
309 cdf_object_from_certid (app_t app, const char *certid, cdf_object_t *r_cdf)
310 {
311   gpg_error_t err;
312   size_t objidlen;
313   unsigned char *objid;
314   cdf_object_t cdf;
315
316   err = parse_certid (certid, &objid, &objidlen);
317   if (err)
318     return err;
319
320   for (cdf = app->app_local->certificate_info; cdf; cdf = cdf->next)
321     if (cdf->objidlen == objidlen && !memcmp (cdf->objid, objid, objidlen))
322       break;
323   if (!cdf)
324     for (cdf = app->app_local->trusted_certificate_info; cdf; cdf = cdf->next)
325       if (cdf->objidlen == objidlen && !memcmp (cdf->objid, objid, objidlen))
326         break;
327   xfree (objid);
328   if (!cdf)
329     return gpg_error (GPG_ERR_NOT_FOUND);
330   *r_cdf = cdf;
331   return 0;
332 }
333
334
335
336 /* Find a private key object by the key Id string KEYIDSTR and store a
337    pointer to it at R_PRKDF. */
338 static gpg_error_t
339 prkdf_object_from_keyidstr (app_t app, const char *keyidstr,
340                             prkdf_object_t *r_prkdf)
341 {
342   gpg_error_t err;
343   size_t objidlen;
344   unsigned char *objid;
345   prkdf_object_t prkdf;
346
347   err = parse_certid (keyidstr, &objid, &objidlen);
348   if (err)
349     return err;
350
351   for (prkdf = app->app_local->private_key_info; prkdf; prkdf = prkdf->next)
352     if (prkdf->objidlen == objidlen && !memcmp (prkdf->objid, objid, objidlen))
353       break;
354   xfree (objid);
355   if (!prkdf)
356     return gpg_error (GPG_ERR_NOT_FOUND);
357   *r_prkdf = prkdf;
358   return 0;
359 }
360
361
362
363 /* Parse the BIT STRING with the keyUsageFlags from the
364    CommonKeyAttributes. */
365 static gpg_error_t
366 parse_keyusage_flags (const unsigned char *der, size_t derlen,
367                       keyusage_flags_t *usageflags)
368 {
369   unsigned int bits, mask;
370   int i, unused, full;
371
372   memset (usageflags, 0, sizeof *usageflags);
373   if (!derlen)
374     return gpg_error (GPG_ERR_INV_OBJ);
375
376   unused = *der++; derlen--;
377   if ((!derlen && unused) || unused/8 > derlen)
378     return gpg_error (GPG_ERR_ENCODING_PROBLEM);
379   full = derlen - (unused+7)/8;
380   unused %= 8;
381   mask = 0;
382   for (i=1; unused; i <<= 1, unused--)
383     mask |= i;
384
385   /* First octet */
386   if (derlen)
387     {
388       bits = *der++; derlen--;
389       if (full)
390         full--;
391       else
392         {
393           bits &= ~mask;
394           mask = 0;
395         }
396     }
397   else
398     bits = 0;
399   if ((bits & 0x80)) usageflags->encrypt = 1;
400   if ((bits & 0x40)) usageflags->decrypt = 1;
401   if ((bits & 0x20)) usageflags->sign = 1;
402   if ((bits & 0x10)) usageflags->sign_recover = 1;
403   if ((bits & 0x08)) usageflags->wrap = 1;
404   if ((bits & 0x04)) usageflags->unwrap = 1;
405   if ((bits & 0x02)) usageflags->verify = 1;
406   if ((bits & 0x01)) usageflags->verify_recover = 1;
407
408   /* Second octet. */
409   if (derlen)
410     {
411       bits = *der++; derlen--;
412       if (full)
413         full--;
414       else
415         {
416           bits &= ~mask;
417         }
418     }
419   else
420     bits = 0;
421   if ((bits & 0x80)) usageflags->derive = 1;
422   if ((bits & 0x40)) usageflags->non_repudiation = 1;
423
424   return 0;
425 }
426
427
428
429 /* Read and parse a Private Key Directory File containing a single key
430    description in PKCS#15 format.  For each private key a matching
431    certificate description is created, if the certificate EF exists
432    and contains a X.509 certificate.
433
434    Example data:
435
436 0000  30 2A 30 13 0C 11 4A 6F 65 20 44 6F 65 20 28 52  0*0...Joe Doe (R
437 0010  53 41 32 30 34 38 29 30 07 04 01 01 03 02 02 74  SA2048)0.......t
438 0020  A1 0A 30 08 30 02 04 00 02 02 08 00              ..0.0.......
439
440    Decoded example:
441
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
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   {
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->slot,
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->slot, fid, "CDF", &buffer, &buflen, 255);
957   if (err)
958     return err;
959
960   p = buffer;
961   n = buflen;
962
963   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
964                           &ndef, &objlen, &hdrlen);
965   if (!err && (objlen > n || tag != TAG_SEQUENCE))
966     err = gpg_error (GPG_ERR_INV_OBJ);
967   if (err)
968     {
969       log_error ("error parsing CDF record: %s\n", gpg_strerror (err));
970       goto leave;
971     }
972   pp = p;
973   nn = objlen;
974   p += objlen;
975   n -= objlen;
976
977   /* Skip the commonObjectAttributes.  */
978   where = __LINE__;
979   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
980                           &ndef, &objlen, &hdrlen);
981   if (!err && (objlen > nn || tag != TAG_SEQUENCE))
982     err = gpg_error (GPG_ERR_INV_OBJ);
983   if (err)
984     goto parse_error;
985   pp += objlen;
986   nn -= objlen;
987
988   /* Parse the commonCertificateAttributes.  */
989   where = __LINE__;
990   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
991                           &ndef, &objlen, &hdrlen);
992   if (!err && (objlen > nn || tag != TAG_SEQUENCE))
993     err = gpg_error (GPG_ERR_INV_OBJ);
994   if (err)
995     goto parse_error;
996
997   {
998     const unsigned char *ppp = pp;
999     size_t nnn = objlen;
1000
1001     pp += objlen;
1002     nn -= objlen;
1003
1004     /* Get the Id. */
1005     where = __LINE__;
1006     err = parse_ber_header (&ppp, &nnn, &class, &tag, &constructed,
1007                             &ndef, &objlen, &hdrlen);
1008     if (!err && (objlen > nnn
1009                  || class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING))
1010       err = gpg_error (GPG_ERR_INV_OBJ);
1011     if (err)
1012       goto parse_error;
1013
1014     objid = ppp;
1015     objidlen = objlen;
1016   }
1017
1018   /* Parse the certAttribute.  */
1019   where = __LINE__;
1020   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1021                           &ndef, &objlen, &hdrlen);
1022   if (!err && (objlen > nn || class != CLASS_CONTEXT || tag != 1))
1023     err = gpg_error (GPG_ERR_INV_OBJ);
1024   if (err)
1025     goto parse_error;
1026   nn = objlen;
1027
1028   where = __LINE__;
1029   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1030                           &ndef, &objlen, &hdrlen);
1031   if (!err && (objlen > nn
1032                || class != CLASS_UNIVERSAL || tag != TAG_SEQUENCE))
1033     err = gpg_error (GPG_ERR_INV_OBJ);
1034   if (err)
1035     goto parse_error;
1036   nn = objlen;
1037
1038   /* Check that the reference is a Path object.  */
1039   where = __LINE__;
1040   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1041                           &ndef, &objlen, &hdrlen);
1042   if (!err && objlen > nn)
1043     err = gpg_error (GPG_ERR_INV_OBJ);
1044   if (err)
1045     goto parse_error;
1046   if (class != CLASS_UNIVERSAL || tag != TAG_SEQUENCE)
1047     {
1048       err = gpg_error (GPG_ERR_INV_OBJ);
1049       goto parse_error;
1050     }
1051   nn = objlen;
1052
1053   /* Parse the Path object. */
1054   where = __LINE__;
1055   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1056                           &ndef, &objlen, &hdrlen);
1057   if (!err && objlen > nn)
1058     err = gpg_error (GPG_ERR_INV_OBJ);
1059   if (err)
1060     goto parse_error;
1061
1062   /* Make sure that the next element is a non zero path and of
1063      even length (FID are two bytes each). */
1064   if (class != CLASS_UNIVERSAL || tag != TAG_OCTET_STRING
1065       || (objlen & 1) )
1066     {
1067       errstr = "invalid path reference";
1068       goto parse_error;
1069     }
1070   /* Create a new CDF list item. */
1071   cdf = xtrycalloc (1, sizeof *cdf);
1072   if (!cdf)
1073     {
1074       err = gpg_error_from_syserror ();
1075       goto leave;
1076     }
1077   cdf->objidlen = objidlen;
1078   cdf->objid = xtrymalloc (objidlen);
1079   if (!cdf->objid)
1080     {
1081       err = gpg_error_from_syserror ();
1082       xfree (cdf);
1083       cdf = NULL;
1084       goto leave;
1085     }
1086   memcpy (cdf->objid, objid, objidlen);
1087
1088   cdf->fid = (SC_HSM_CA_PREFIX << 8) | (fid & 0xFF);
1089
1090   log_debug ("CDF %04hX: id=", fid);
1091   for (i=0; i < cdf->objidlen; i++)
1092     log_printf ("%02X", cdf->objid[i]);
1093
1094   goto leave;
1095
1096  parse_error:
1097   log_error ("error parsing CDF record (%d): %s - skipped\n",
1098              where, errstr? errstr : gpg_strerror (err));
1099   err = 0;
1100
1101  leave:
1102   xfree (buffer);
1103   if (err)
1104     {
1105       if (cdf)
1106         {
1107           if (cdf->objid)
1108             xfree (cdf->objid);
1109           xfree (cdf);
1110         }
1111     }
1112   else
1113     {
1114       if (cdf)
1115         cdf->next = *result;
1116       *result = cdf;
1117     }
1118   return err;
1119 }
1120
1121
1122
1123 /* Read the device certificate and extract the serial number.
1124
1125    EF.C_DevAut (2F02) contains two CVCs, the first is the device
1126    certificate, the second is the issuer certificate.
1127
1128    Example data:
1129
1130 0000  7F 21 81 E2 7F 4E 81 9B 5F 29 01 00 42 0B 55 54  .!...N.._)..B.UT
1131 0010  43 43 30 32 30 30 30 30 32 7F 49 4F 06 0A 04 00  CC0200002.IO....
1132 0020  7F 00 07 02 02 02 02 03 86 41 04 6D FF D6 85 57  .........A.m...W
1133 0030  40 FB 10 5D 94 71 8A 94 D2 5E 50 33 E7 1E C0 6C  @..].q...^P3...l
1134 0040  63 D5 C8 FC BA F3 02 1D 70 23 F6 47 E8 35 48 EF  c.......p#.G.5H.
1135 0050  B5 94 72 3C 6F BE C0 EB 9A C7 FB 06 59 26 CF 65  ..r<o.......Y&.e
1136 0060  EF A1 72 E0 98 F3 F0 44 1B B7 71 5F 20 10 55 54  ..r....D..q_ .UT
1137 0070  43 43 30 32 30 30 30 31 33 30 30 30 30 30 7F 4C  CC020001300000.L
1138 0080  10 06 0B 2B 06 01 04 01 81 C3 1F 03 01 01 53 01  ...+..........S.
1139 0090  00 5F 25 06 01 04 00 07 01 01 5F 24 06 02 01 00  ._%......._$....
1140 00A0  03 02 07 5F 37 40 7F 73 04 3B 06 63 79 41 BE 1A  ..._7@.s.;.cyA..
1141 00B0  9F FC F6 77 67 2B 8A 41 D1 11 F6 9B 54 44 AD 19  ...wg+.A....TD..
1142 00C0  FB B8 0C C6 2F 34 71 8E 4F F6 92 59 34 61 D9 4F  ..../4q.O..Y4a.O
1143 00D0  4A 86 36 A8 D8 9A C6 3C 17 7E 71 CE A8 26 D0 C5  J.6....<.~q..&..
1144 00E0  25 61 78 9D 01 F8 7F 21 81 E0 7F 4E 81 99 5F 29  %ax....!...N.._)
1145 00F0  01 00 42 0E 55 54 53 52 43 41 43 43 31 30 30 30  ..B.UTSRCACC1000
1146 0100  30 31 7F 49 4F 06 0A 04 00 7F 00 07 02 02 02 02  01.IO...........
1147 0110  03 86 41 04 2F EA 33 47 7F 45 81 E2 FC CB 66 87  ..A./.3G.E....f.
1148 0120  4B 96 21 1D 68 81 73 F2 9F 8F 6B 91 F0 DE 4B 54  K.!.h.s...k...KT
1149 0130  8E D8 F0 82 3D CB BE 10 98 A3 1E 4F F0 72 5C E5  ....=......O.r\.
1150 0140  7B 1E F7 3C 68 09 03 E8 A0 3F 3E 06 C1 B0 3C 18  {..<h....?>...<.
1151 0150  6B AC 06 EA 5F 20 0B 55 54 43 43 30 32 30 30 30  k..._ .UTCC02000
1152 0160  30 32 7F 4C 10 06 0B 2B 06 01 04 01 81 C3 1F 03  02.L...+........
1153 0170  01 01 53 01 80 5F 25 06 01 03 00 03 02 08 5F 24  ..S.._%......._$
1154 0180  06 02 01 00 03 02 07 5F 37 40 93 C1 42 8B B3 8E  ......._7@..B...
1155 0190  42 61 6F 2C 19 E6 98 41 BD AA 60 BD E0 DD 4E F0  Bao,...A..`...N.
1156 01A0  15 D5 4F 71 B7 BB C3 3A F2 AD 27 5E DD EE 6D 12  ..Oq...:..'^..m.
1157 01B0  76 E6 2B A0 4C 01 CA C1 26 0C 45 6D C6 CB EC 92  v.+.L...&.Em....
1158 01C0  BF 38 18 AD 8F B2 29 40 A9 51                    .8....)@.Q
1159
1160    The certificate format is defined in BSI TR-03110:
1161
1162 7F21 [ APPLICATION 33 ] IMPLICIT SEQUENCE SIZE( 226 )
1163   7F4E [ APPLICATION 78 ] IMPLICIT SEQUENCE SIZE( 155 )
1164     5F29 [ APPLICATION 41 ] SIZE( 1 )                           -- profile id
1165       0000  00
1166     42 [ APPLICATION 2 ] SIZE( 11 )                             -- CAR
1167       0000  55 54 43 43 30 32 30 30 30 30 32                 UTCC0200002
1168     7F49 [ APPLICATION 73 ] IMPLICIT SEQUENCE SIZE( 79 )        -- public key
1169       OBJECT IDENTIFIER = { id-TA-ECDSA-SHA-256 }
1170       86 [ CONTEXT 6 ] SIZE( 65 )
1171         0000  04 6D FF D6 85 57 40 FB 10 5D 94 71 8A 94 D2 5E
1172         0010  50 33 E7 1E C0 6C 63 D5 C8 FC BA F3 02 1D 70 23
1173         0020  F6 47 E8 35 48 EF B5 94 72 3C 6F BE C0 EB 9A C7
1174         0030  FB 06 59 26 CF 65 EF A1 72 E0 98 F3 F0 44 1B B7
1175         0040  71
1176     5F20 [ APPLICATION 32 ] SIZE( 16 )                          -- CHR
1177       0000  55 54 43 43 30 32 30 30 30 31 33 30 30 30 30 30  UTCC020001300000
1178     7F4C [ APPLICATION 76 ] IMPLICIT SEQUENCE SIZE( 16 )        -- CHAT
1179       OBJECT IDENTIFIER = { 1 3 6 1 4 1 24991 3 1 1 }
1180       53 [ APPLICATION 19 ] SIZE( 1 )
1181         0000  00
1182     5F25 [ APPLICATION 37 ] SIZE( 6 )                           -- Valid from
1183       0000  01 04 00 07 01 01
1184     5F24 [ APPLICATION 36 ] SIZE( 6 )                           -- Valid to
1185       0000  02 01 00 03 02 07
1186   5F37 [ APPLICATION 55 ] SIZE( 64 )                            -- Signature
1187     0000  7F 73 04 3B 06 63 79 41 BE 1A 9F FC F6 77 67 2B
1188     0010  8A 41 D1 11 F6 9B 54 44 AD 19 FB B8 0C C6 2F 34
1189     0020  71 8E 4F F6 92 59 34 61 D9 4F 4A 86 36 A8 D8 9A
1190     0030  C6 3C 17 7E 71 CE A8 26 D0 C5 25 61 78 9D 01 F8
1191
1192    The serial number is contained in tag 5F20, while the last 5 digits
1193    are truncated.
1194  */
1195 static gpg_error_t
1196 read_serialno(app_t app)
1197 {
1198   gpg_error_t err;
1199   unsigned char *buffer = NULL;
1200   size_t buflen;
1201   const unsigned char *p,*chr;
1202   size_t n, objlen, hdrlen, chrlen;
1203   int class, tag, constructed, ndef;
1204
1205   err = select_and_read_binary (app->slot, 0x2F02, "EF.C_DevAut",
1206                                 &buffer, &buflen, 512);
1207   if (err)
1208     return err;
1209
1210   p = buffer;
1211   n = buflen;
1212
1213   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1214                           &ndef, &objlen, &hdrlen);
1215   if (!err && (objlen > n || tag != 0x21))
1216     err = gpg_error (GPG_ERR_INV_OBJ);
1217   if (err)
1218     {
1219       log_error ("error parsing C_DevAut: %s\n", gpg_strerror (err));
1220       goto leave;
1221     }
1222
1223   chr = find_tlv (p, objlen, 0x5F20, &chrlen);
1224   if (!chr || chrlen <= 5)
1225     {
1226       err = gpg_error (GPG_ERR_INV_OBJ);
1227       log_error ("CHR not found in CVC\n");
1228       goto leave;
1229     }
1230   chrlen -= 5;
1231
1232   app->serialno = xtrymalloc (chrlen);
1233   if (!app->serialno)
1234     {
1235       err = gpg_error_from_syserror ();
1236       goto leave;
1237     }
1238
1239   app->serialnolen = chrlen;
1240   memcpy (app->serialno, chr, chrlen);
1241
1242  leave:
1243   xfree (buffer);
1244   return err;
1245 }
1246
1247
1248 /* Get all the basic information from the SmartCard-HSM, check the
1249    structure and initialize our local context.  This is used once at
1250    application initialization.  */
1251 static gpg_error_t
1252 read_meta (app_t app)
1253 {
1254   gpg_error_t err;
1255   unsigned char *eflist = NULL;
1256   size_t eflistlen = 0;
1257   int i;
1258
1259   err = read_serialno(app);
1260   if (err)
1261     return err;
1262
1263   err = list_ef (app->slot, &eflist, &eflistlen);
1264   if (err)
1265     return err;
1266
1267   for (i = 0; i < eflistlen; i += 2)
1268     {
1269       switch(eflist[i])
1270         {
1271         case SC_HSM_KEY_PREFIX:
1272           if (eflist[i + 1] == 0)    /* No key with ID=0 */
1273             break;
1274           err = read_ef_prkd (app, ((SC_HSM_PRKD_PREFIX << 8) | eflist[i + 1]),
1275                               &app->app_local->private_key_info,
1276                               &app->app_local->certificate_info);
1277           if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1278             err = 0;
1279           if (err)
1280             return err;
1281           break;
1282         case SC_HSM_CD_PREFIX:
1283           err = read_ef_cd (app, ((eflist[i] << 8) | eflist[i + 1]),
1284                             &app->app_local->trusted_certificate_info);
1285           if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1286             err = 0;
1287           if (err)
1288             return err;
1289           break;
1290         }
1291     }
1292
1293   xfree (eflist);
1294
1295   return err;
1296 }
1297
1298
1299
1300 /* Helper to do_learn_status: Send information about all certificates
1301    listed in CERTINFO back.  Use CERTTYPE as type of the
1302    certificate. */
1303 static gpg_error_t
1304 send_certinfo (ctrl_t ctrl, const char *certtype, cdf_object_t certinfo)
1305 {
1306   for (; certinfo; certinfo = certinfo->next)
1307     {
1308       char *buf, *p;
1309
1310       buf = xtrymalloc (4 + certinfo->objidlen*2 + 1);
1311       if (!buf)
1312         return gpg_error_from_syserror ();
1313       p = stpcpy (buf, "HSM.");
1314       bin2hex (certinfo->objid, certinfo->objidlen, p);
1315
1316       send_status_info (ctrl, "CERTINFO",
1317                         certtype, strlen (certtype),
1318                         buf, strlen (buf),
1319                         NULL, (size_t)0);
1320       xfree (buf);
1321     }
1322   return 0;
1323 }
1324
1325
1326
1327 /* Get the keygrip of the private key object PRKDF.  On success the
1328    keygrip gets returned in the caller provided 41 byte buffer
1329    R_GRIPSTR. */
1330 static gpg_error_t
1331 keygripstr_from_prkdf (app_t app, prkdf_object_t prkdf, char *r_gripstr)
1332 {
1333   gpg_error_t err;
1334   cdf_object_t cdf;
1335   unsigned char *der;
1336   size_t derlen;
1337   ksba_cert_t cert;
1338
1339   /* Look for a matching certificate. A certificate matches if the Id
1340      matches the one of the private key info. */
1341   for (cdf = app->app_local->certificate_info; cdf; cdf = cdf->next)
1342     if (cdf->objidlen == prkdf->objidlen
1343         && !memcmp (cdf->objid, prkdf->objid, prkdf->objidlen))
1344       break;
1345   if (!cdf)
1346     return gpg_error (GPG_ERR_NOT_FOUND);
1347
1348   err = readcert_by_cdf (app, cdf, &der, &derlen);
1349   if (err)
1350     return err;
1351
1352   err = ksba_cert_new (&cert);
1353   if (!err)
1354     err = ksba_cert_init_from_mem (cert, der, derlen);
1355   xfree (der);
1356   if (!err)
1357     err = app_help_get_keygrip_string (cert, r_gripstr);
1358   ksba_cert_release (cert);
1359
1360   return err;
1361 }
1362
1363
1364
1365 /* Helper to do_learn_status: Send information about all known
1366    keypairs back. */
1367 static gpg_error_t
1368 send_keypairinfo (app_t app, ctrl_t ctrl, prkdf_object_t keyinfo)
1369 {
1370   gpg_error_t err;
1371
1372   for (; keyinfo; keyinfo = keyinfo->next)
1373     {
1374       char gripstr[40+1];
1375       char *buf, *p;
1376
1377       buf = xtrymalloc (4 + keyinfo->objidlen*2 + 1);
1378       if (!buf)
1379         return gpg_error_from_syserror ();
1380       p = stpcpy (buf, "HSM.");
1381       bin2hex (keyinfo->objid, keyinfo->objidlen, p);
1382
1383       err = keygripstr_from_prkdf (app, keyinfo, gripstr);
1384       if (err)
1385         {
1386           log_error ("can't get keygrip from %04X\n", keyinfo->key_reference);
1387         }
1388       else
1389         {
1390           assert (strlen (gripstr) == 40);
1391           send_status_info (ctrl, "KEYPAIRINFO",
1392                             gripstr, 40,
1393                             buf, strlen (buf),
1394                             NULL, (size_t)0);
1395         }
1396       xfree (buf);
1397     }
1398   return 0;
1399 }
1400
1401
1402
1403 /* This is the handler for the LEARN command. */
1404 static gpg_error_t
1405 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1406 {
1407   gpg_error_t err;
1408
1409   if ((flags & 1))
1410     err = 0;
1411   else
1412     {
1413       err = send_certinfo (ctrl, "100", app->app_local->certificate_info);
1414       if (!err)
1415         err = send_certinfo (ctrl, "101",
1416             app->app_local->trusted_certificate_info);
1417     }
1418
1419   if (!err)
1420     err = send_keypairinfo (app, ctrl, app->app_local->private_key_info);
1421
1422   return err;
1423 }
1424
1425
1426
1427 /* Read a certificate using the information in CDF and return the
1428    certificate in a newly allocated buffer R_CERT and its length
1429    R_CERTLEN. */
1430 static gpg_error_t
1431 readcert_by_cdf (app_t app, cdf_object_t cdf,
1432                  unsigned char **r_cert, size_t *r_certlen)
1433 {
1434   gpg_error_t err;
1435   unsigned char *buffer = NULL;
1436   const unsigned char *p, *save_p;
1437   size_t buflen, n;
1438   int class, tag, constructed, ndef;
1439   size_t totobjlen, objlen, hdrlen;
1440   int rootca;
1441   int i;
1442
1443   *r_cert = NULL;
1444   *r_certlen = 0;
1445
1446   /* First check whether it has been cached. */
1447   if (cdf->image)
1448     {
1449       *r_cert = xtrymalloc (cdf->imagelen);
1450       if (!*r_cert)
1451         return gpg_error_from_syserror ();
1452       memcpy (*r_cert, cdf->image, cdf->imagelen);
1453       *r_certlen = cdf->imagelen;
1454       return 0;
1455     }
1456
1457   err = select_and_read_binary (app->slot, cdf->fid, "CD",
1458                                 &buffer, &buflen, 4096);
1459   if (err)
1460     {
1461       log_error ("error reading certificate with Id ");
1462       for (i=0; i < cdf->objidlen; i++)
1463         log_printf ("%02X", cdf->objid[i]);
1464       log_printf (": %s\n", gpg_strerror (err));
1465       goto leave;
1466     }
1467
1468   /* Check whether this is really a certificate.  */
1469   p = buffer;
1470   n = buflen;
1471   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1472                           &ndef, &objlen, &hdrlen);
1473   if (err)
1474     goto leave;
1475
1476   if (class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed)
1477     rootca = 0;
1478   else if ( class == CLASS_UNIVERSAL && tag == TAG_SET && constructed )
1479     rootca = 1;
1480   else
1481     {
1482       err = gpg_error (GPG_ERR_INV_OBJ);
1483       goto leave;
1484     }
1485   totobjlen = objlen + hdrlen;
1486   assert (totobjlen <= buflen);
1487
1488   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1489                           &ndef, &objlen, &hdrlen);
1490   if (err)
1491     goto leave;
1492
1493   if (!rootca
1494       && class == CLASS_UNIVERSAL && tag == TAG_OBJECT_ID && !constructed)
1495     {
1496       /* The certificate seems to be contained in a userCertificate
1497          container.  Skip this and assume the following sequence is
1498          the certificate. */
1499       if (n < objlen)
1500         {
1501           err = gpg_error (GPG_ERR_INV_OBJ);
1502           goto leave;
1503         }
1504       p += objlen;
1505       n -= objlen;
1506       save_p = p;
1507       err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1508                               &ndef, &objlen, &hdrlen);
1509       if (err)
1510         goto leave;
1511       if ( !(class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed) )
1512         {
1513           err = gpg_error (GPG_ERR_INV_OBJ);
1514           goto leave;
1515         }
1516       totobjlen = objlen + hdrlen;
1517       assert (save_p + totobjlen <= buffer + buflen);
1518       memmove (buffer, save_p, totobjlen);
1519     }
1520
1521   *r_cert = buffer;
1522   buffer = NULL;
1523   *r_certlen = totobjlen;
1524
1525   /* Try to cache it. */
1526   if (!cdf->image && (cdf->image = xtrymalloc (*r_certlen)))
1527     {
1528       memcpy (cdf->image, *r_cert, *r_certlen);
1529       cdf->imagelen = *r_certlen;
1530     }
1531
1532
1533  leave:
1534   xfree (buffer);
1535   return err;
1536 }
1537
1538
1539
1540 /* Handler for the READCERT command.
1541
1542    Read the certificate with id CERTID (as returned by learn_status in
1543    the CERTINFO status lines) and return it in the freshly allocated
1544    buffer to be stored at R_CERT and its length at R_CERTLEN.  A error
1545    code will be returned on failure and R_CERT and R_CERTLEN will be
1546    set to (NULL,0). */
1547 static gpg_error_t
1548 do_readcert (app_t app, const char *certid,
1549              unsigned char **r_cert, size_t *r_certlen)
1550 {
1551   gpg_error_t err;
1552   cdf_object_t cdf;
1553
1554   *r_cert = NULL;
1555   *r_certlen = 0;
1556   err = cdf_object_from_certid (app, certid, &cdf);
1557   if (!err)
1558     err = readcert_by_cdf (app, cdf, r_cert, r_certlen);
1559   return err;
1560 }
1561
1562
1563
1564 /* Implement the GETATTR command.  This is similar to the LEARN
1565    command but returns just one value via the status interface. */
1566 static gpg_error_t
1567 do_getattr (app_t app, ctrl_t ctrl, const char *name)
1568 {
1569   if (!strcmp (name, "$AUTHKEYID"))
1570     {
1571       char *buf, *p;
1572       prkdf_object_t prkdf;
1573
1574       /* We return the ID of the first private key capable of
1575          signing. */
1576       for (prkdf = app->app_local->private_key_info; prkdf;
1577            prkdf = prkdf->next)
1578         if (prkdf->usageflags.sign)
1579           break;
1580       if (prkdf)
1581         {
1582           buf = xtrymalloc (4 + prkdf->objidlen*2 + 1);
1583           if (!buf)
1584             return gpg_error_from_syserror ();
1585           p = stpcpy (buf, "HSM.");
1586           bin2hex (prkdf->objid, prkdf->objidlen, p);
1587
1588           send_status_info (ctrl, name, buf, strlen (buf), NULL, 0);
1589           xfree (buf);
1590           return 0;
1591         }
1592     }
1593   else if (!strcmp (name, "$DISPSERIALNO"))
1594     {
1595       send_status_info (ctrl, name, app->serialno, app->serialnolen, NULL, 0);
1596       return 0;
1597     }
1598
1599   return gpg_error (GPG_ERR_INV_NAME);
1600 }
1601
1602
1603
1604 /* Apply PKCS#1 V1.5 padding for signature operation.  The function
1605  * combines padding, digest info and the hash value.  The buffer must
1606  * be allocated by the caller matching the key size.  */
1607 static void
1608 apply_PKCS_padding(const unsigned char *dig, int diglen,
1609                    const unsigned char *prefix, int prefixlen,
1610                    unsigned char *buff, int bufflen)
1611 {
1612   int i, n_ff;
1613
1614   /* Caller must ensure a sufficient buffer.  */
1615   if (diglen + prefixlen + 4 > bufflen)
1616     return;
1617   n_ff = bufflen - diglen - prefixlen - 3;
1618
1619   *buff++ = 0x00;
1620   *buff++ = 0x01;
1621   for (i=0; i < n_ff; i++)
1622     *buff++ = 0xFF;
1623   *buff++ = 0x00;
1624
1625   if (prefix)
1626     memcpy (buff, prefix, prefixlen);
1627   buff += prefixlen;
1628   memcpy (buff, dig, diglen);
1629 }
1630
1631
1632
1633 /* Decode a digest info structure (DI,DILEN) to extract the hash
1634  * value.  The buffer HASH to receive the digest must be provided by
1635  * the caller with HASHLEN pointing to the inbound length.  HASHLEN is
1636  * updated to the outbound length.  */
1637 static int
1638 hash_from_digestinfo (const unsigned char *di, size_t dilen,
1639                       unsigned char *hash, size_t *hashlen)
1640 {
1641   const unsigned char *p,*pp;
1642   size_t n, nn, objlen, hdrlen;
1643   int class, tag, constructed, ndef;
1644   gpg_error_t err;
1645
1646   p = di;
1647   n = dilen;
1648
1649   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
1650                           &ndef, &objlen, &hdrlen);
1651   if (!err && (objlen > n || tag != TAG_SEQUENCE))
1652     err = gpg_error (GPG_ERR_INV_OBJ);
1653   if ( err )
1654     return err;
1655
1656   pp = p;
1657   nn = objlen;
1658
1659   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1660                           &ndef, &objlen, &hdrlen);
1661   if (!err && (objlen > nn || tag != TAG_SEQUENCE))
1662     err = gpg_error (GPG_ERR_INV_OBJ);
1663   if ( err )
1664     return err;
1665
1666   pp += objlen;
1667   nn -= objlen;
1668
1669   err = parse_ber_header (&pp, &nn, &class, &tag, &constructed,
1670                           &ndef, &objlen, &hdrlen);
1671   if (!err && (objlen > nn || tag != TAG_OCTET_STRING))
1672     err = gpg_error (GPG_ERR_INV_OBJ);
1673   if ( err )
1674     return err;
1675
1676   if (*hashlen < objlen)
1677     return gpg_error (GPG_ERR_TOO_SHORT);
1678   memcpy (hash, pp, objlen);
1679   *hashlen = objlen;
1680   return 0;
1681 }
1682
1683
1684 /* Perform PIN verification
1685  */
1686 static gpg_error_t
1687 verify_pin (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
1688             void *pincb_arg)
1689 {
1690   gpg_error_t err;
1691   pininfo_t pininfo;
1692   char *pinvalue;
1693   char *prompt;
1694   int sw;
1695
1696   sw = apdu_send_simple (app->slot, 0, 0x00, ISO7816_VERIFY, 0x00, 0x81,
1697                          -1, NULL);
1698
1699   if (sw == SW_SUCCESS)
1700     return 0;                   /* PIN already verified */
1701
1702   if (sw == SW_REF_DATA_INV)
1703     {
1704       log_error ("SmartCard-HSM not initialized. Run sc-hsm-tool first\n");
1705       return gpg_error (GPG_ERR_NO_PIN);
1706     }
1707
1708   if (sw == SW_CHV_BLOCKED)
1709     {
1710       log_error ("PIN Blocked\n");
1711       return gpg_error (GPG_ERR_PIN_BLOCKED);
1712     }
1713
1714   memset (&pininfo, 0, sizeof pininfo);
1715   pininfo.fixedlen = 0;
1716   pininfo.minlen = 6;
1717   pininfo.maxlen = 15;
1718
1719   prompt = "||Please enter the PIN";
1720
1721   if (!opt.disable_pinpad
1722       && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo) )
1723     {
1724       err = pincb (pincb_arg, prompt, NULL);
1725       if (err)
1726         {
1727           log_info ("PIN callback returned error: %s\n", gpg_strerror (err));
1728           return err;
1729         }
1730
1731       err = iso7816_verify_kp (app->slot, 0x81, &pininfo);
1732       pincb (pincb_arg, NULL, NULL);  /* Dismiss the prompt. */
1733     }
1734   else
1735     {
1736       err = pincb (pincb_arg, prompt, &pinvalue);
1737       if (err)
1738         {
1739           log_info ("PIN callback returned error: %s\n", gpg_strerror (err));
1740           return err;
1741         }
1742
1743       err = iso7816_verify (app->slot, 0x81, pinvalue, strlen(pinvalue));
1744       xfree (pinvalue);
1745     }
1746   if (err)
1747     {
1748       log_error ("PIN verification failed: %s\n", gpg_strerror (err));
1749       return err;
1750     }
1751   log_debug ("PIN verification succeeded\n");
1752   return err;
1753 }
1754
1755
1756
1757 /* Handler for the PKSIGN command.
1758
1759    Create the signature and return the allocated result in OUTDATA.
1760    If a PIN is required, the PINCB will be used to ask for the PIN;
1761    that callback should return the PIN in an allocated buffer and
1762    store that as the 3rd argument.
1763
1764    The API is somewhat inconsistent: The caller can either supply
1765    a plain hash and the algorithm in hashalgo or a complete
1766    DigestInfo structure. The former is detect by characteristic length
1767    of the provided data (20,28,32,48 or 64 byte).
1768
1769    The function returns the RSA block in the size of the modulus or
1770    the ECDSA signature in X9.62 format (SEQ/INT(r)/INT(s))
1771 */
1772 static gpg_error_t
1773 do_sign (app_t app, const char *keyidstr, int hashalgo,
1774          gpg_error_t (*pincb)(void*, const char *, char **),
1775          void *pincb_arg,
1776          const void *indata, size_t indatalen,
1777          unsigned char **outdata, size_t *outdatalen )
1778 {
1779   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
1780     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
1781       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
1782   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
1783     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
1784       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
1785   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
1786     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
1787       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
1788       0x1C  };
1789   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
1790     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
1791       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
1792       0x00, 0x04, 0x20  };
1793   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
1794     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
1795       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
1796       0x00, 0x04, 0x30  };
1797   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
1798     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
1799       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
1800       0x00, 0x04, 0x40  };
1801
1802   gpg_error_t err;
1803   unsigned char cdsblk[256]; /* Raw PKCS#1 V1.5 block with padding
1804                                 (RSA) or hash.  */
1805   prkdf_object_t prkdf;      /* The private key object. */
1806   size_t cdsblklen;
1807   unsigned char algoid;
1808   int sw;
1809
1810   if (!keyidstr || !*keyidstr)
1811     return gpg_error (GPG_ERR_INV_VALUE);
1812
1813   if (indatalen > 124)          /* Limit for 1024 bit key */
1814     return gpg_error (GPG_ERR_INV_VALUE);
1815
1816   err = prkdf_object_from_keyidstr (app, keyidstr, &prkdf);
1817   if (err)
1818     return err;
1819   if (!(prkdf->usageflags.sign || prkdf->usageflags.sign_recover
1820         ||prkdf->usageflags.non_repudiation))
1821     {
1822       log_error ("key %s may not be used for signing\n", keyidstr);
1823       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1824     }
1825
1826   if (prkdf->keytype == KEY_TYPE_RSA)
1827     {
1828       algoid = 0x20;
1829
1830       cdsblklen = prkdf->keysize >> 3;
1831       if (!cdsblklen)
1832         cdsblklen = 256;
1833
1834       if (hashalgo == GCRY_MD_SHA1 && indatalen == 20)
1835         apply_PKCS_padding (indata, indatalen,
1836                             sha1_prefix, sizeof(sha1_prefix),
1837                             cdsblk, cdsblklen);
1838       else if (hashalgo == GCRY_MD_MD5 && indatalen == 20)
1839         apply_PKCS_padding (indata, indatalen,
1840                             rmd160_prefix, sizeof(rmd160_prefix),
1841                             cdsblk, cdsblklen);
1842       else if (hashalgo == GCRY_MD_SHA224 && indatalen == 28)
1843         apply_PKCS_padding (indata, indatalen,
1844                             sha224_prefix, sizeof(sha224_prefix),
1845                             cdsblk, cdsblklen);
1846       else if (hashalgo == GCRY_MD_SHA256 && indatalen == 32)
1847         apply_PKCS_padding (indata, indatalen,
1848                             sha256_prefix, sizeof(sha256_prefix),
1849                             cdsblk, cdsblklen);
1850       else if (hashalgo == GCRY_MD_SHA384 && indatalen == 48)
1851         apply_PKCS_padding (indata, indatalen,
1852                             sha384_prefix, sizeof(sha384_prefix),
1853                             cdsblk, cdsblklen);
1854       else if (hashalgo == GCRY_MD_SHA512 && indatalen == 64)
1855         apply_PKCS_padding (indata, indatalen,
1856                             sha512_prefix, sizeof(sha512_prefix),
1857                             cdsblk, cdsblklen);
1858       else  /* Assume it's already a digest info or TLS_MD5SHA1 */
1859         apply_PKCS_padding (indata, indatalen, NULL, 0, cdsblk, cdsblklen);
1860     }
1861   else
1862     {
1863       algoid = 0x70;
1864       if (indatalen != 20 && indatalen != 28 && indatalen != 32
1865           && indatalen != 48 && indatalen != 64)
1866         {
1867           cdsblklen = sizeof(cdsblk);
1868           err = hash_from_digestinfo (indata, indatalen, cdsblk, &cdsblklen);
1869           if (err)
1870             {
1871               log_error ("DigestInfo invalid: %s\n", gpg_strerror (err));
1872               return err;
1873             }
1874         }
1875       else
1876         {
1877           memcpy (cdsblk, indata, indatalen);
1878           cdsblklen = indatalen;
1879         }
1880     }
1881
1882   err = verify_pin (app, pincb, pincb_arg);
1883   if (err)
1884     return err;
1885
1886   sw = apdu_send_le (app->slot, 1, 0x80, 0x68, prkdf->key_reference, algoid,
1887                      cdsblklen, cdsblk, 0, outdata, outdatalen);
1888   return iso7816_map_sw (sw);
1889 }
1890
1891
1892
1893 /* Handler for the PKAUTH command.
1894
1895    This is basically the same as the PKSIGN command but we first check
1896    that the requested key is suitable for authentication; that is, it
1897    must match the criteria used for the attribute $AUTHKEYID.  See
1898    do_sign for calling conventions; there is no HASHALGO, though. */
1899 static gpg_error_t
1900 do_auth (app_t app, const char *keyidstr,
1901          gpg_error_t (*pincb)(void*, const char *, char **),
1902          void *pincb_arg,
1903          const void *indata, size_t indatalen,
1904          unsigned char **outdata, size_t *outdatalen )
1905 {
1906   gpg_error_t err;
1907   prkdf_object_t prkdf;
1908   int algo;
1909
1910   if (!keyidstr || !*keyidstr)
1911     return gpg_error (GPG_ERR_INV_VALUE);
1912
1913   err = prkdf_object_from_keyidstr (app, keyidstr, &prkdf);
1914   if (err)
1915     return err;
1916   if (!prkdf->usageflags.sign)
1917     {
1918       log_error ("key %s may not be used for authentication\n", keyidstr);
1919       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1920     }
1921
1922   algo = indatalen == 36? MD_USER_TLS_MD5SHA1 : GCRY_MD_SHA1;
1923   return do_sign (app, keyidstr, algo, pincb, pincb_arg,
1924                   indata, indatalen, outdata, outdatalen);
1925 }
1926
1927
1928
1929 /* Check PKCS#1 V1.5 padding and extract plain text.  The function
1930  * allocates a buffer for the plain text.  The caller must release the
1931  * buffer.  */
1932 static gpg_error_t
1933 strip_PKCS15_padding(unsigned char *src, int srclen, unsigned char **dst,
1934                      size_t *dstlen)
1935 {
1936   unsigned char *p;
1937
1938   if (srclen < 2)
1939     return gpg_error (GPG_ERR_DECRYPT_FAILED);
1940   if (*src++ != 0x00)
1941     return gpg_error (GPG_ERR_DECRYPT_FAILED);
1942   if (*src++ != 0x02)
1943     return gpg_error (GPG_ERR_DECRYPT_FAILED);
1944   srclen -= 2;
1945   while ((srclen > 0) && *src)
1946     {
1947       src++;
1948       srclen--;
1949     }
1950
1951   if (srclen < 2)
1952     return gpg_error (GPG_ERR_DECRYPT_FAILED);
1953
1954   src++;
1955   srclen--;
1956
1957   p = xtrymalloc (srclen);
1958   if (!p)
1959     return gpg_error_from_syserror ();
1960
1961   memcpy (p, src, srclen);
1962   *dst = p;
1963   *dstlen = srclen;
1964
1965   return 0;
1966 }
1967
1968
1969 /* Decrypt a PKCS#1 V1.5 formatted cryptogram using the referenced
1970    key.  */
1971 static gpg_error_t
1972 do_decipher (app_t app, const char *keyidstr,
1973              gpg_error_t (*pincb)(void*, const char *, char **),
1974              void *pincb_arg,
1975              const void *indata, size_t indatalen,
1976              unsigned char **outdata, size_t *outdatalen,
1977              unsigned int *r_info)
1978 {
1979   gpg_error_t err;
1980   unsigned char p1blk[256]; /* Enciphered P1 block */
1981   prkdf_object_t prkdf;     /* The private key object. */
1982   unsigned char *rspdata;
1983   size_t rspdatalen;
1984   size_t p1blklen;
1985   int sw;
1986
1987   if (!keyidstr || !*keyidstr || !indatalen)
1988     return gpg_error (GPG_ERR_INV_VALUE);
1989
1990   err = prkdf_object_from_keyidstr (app, keyidstr, &prkdf);
1991   if (err)
1992     return err;
1993   if (!(prkdf->usageflags.decrypt || prkdf->usageflags.unwrap))
1994     {
1995       log_error ("key %s may not be used for deciphering\n", keyidstr);
1996       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1997     }
1998
1999   if (prkdf->keytype != KEY_TYPE_RSA)
2000     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2001
2002   p1blklen = prkdf->keysize >> 3;
2003   if (!p1blklen)
2004     p1blklen = 256;
2005
2006   /* The input may be shorter (due to MPIs not storing leading zeroes)
2007      or longer than the block size.  We put INDATA right aligned into
2008      the buffer.  If INDATA is longer than the block size we truncate
2009      it on the left. */
2010   memset (p1blk, 0, sizeof(p1blk));
2011   if (indatalen > p1blklen)
2012     memcpy (p1blk, (unsigned char *)indata + (indatalen - p1blklen), p1blklen);
2013   else
2014     memcpy (p1blk + (p1blklen - indatalen), indata, indatalen);
2015
2016
2017   err = verify_pin(app, pincb, pincb_arg);
2018   if (err)
2019     return err;
2020
2021   sw = apdu_send_le (app->slot, 1, 0x80, 0x62, prkdf->key_reference, 0x21,
2022                      p1blklen, p1blk, 0, &rspdata, &rspdatalen);
2023   err = iso7816_map_sw (sw);
2024   if (err)
2025     {
2026       log_error ("Decrypt failed: %s\n", gpg_strerror (err));
2027       return err;
2028     }
2029
2030   err = strip_PKCS15_padding (rspdata, rspdatalen, outdata, outdatalen);
2031   xfree (rspdata);
2032
2033   if (!err)
2034     *r_info |= APP_DECIPHER_INFO_NOPAD;
2035
2036   return err;
2037 }
2038
2039
2040
2041 /*
2042  * Select the SmartCard-HSM application on the card in SLOT.
2043  */
2044 gpg_error_t
2045 app_select_sc_hsm (app_t app)
2046 {
2047   int slot = app->slot;
2048   int rc;
2049
2050   rc = iso7816_select_application (slot, sc_hsm_aid, sizeof sc_hsm_aid, 0);
2051   if (!rc)
2052     {
2053       app->apptype = "SC-HSM";
2054
2055       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2056       if (!app->app_local)
2057         {
2058           rc = gpg_error_from_syserror ();
2059           goto leave;
2060         }
2061
2062       rc = read_meta (app);
2063       if (rc)
2064         goto leave;
2065
2066       app->fnc.deinit = do_deinit;
2067       app->fnc.learn_status = do_learn_status;
2068       app->fnc.readcert = do_readcert;
2069       app->fnc.getattr = do_getattr;
2070       app->fnc.setattr = NULL;
2071       app->fnc.genkey = NULL;
2072       app->fnc.sign = do_sign;
2073       app->fnc.auth = do_auth;
2074       app->fnc.decipher = do_decipher;
2075       app->fnc.change_pin = NULL;
2076       app->fnc.check_pin = NULL;
2077
2078     leave:
2079       if (rc)
2080         do_deinit (app);
2081    }
2082
2083   return rc;
2084 }