scd: Split data structures into app and card related objects.
[gnupg.git] / scd / app-dinsig.c
1 /* app-dinsig.c - The DINSIG (DIN V 66291-1) card application.
2  * Copyright (C) 2002, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20
21 /* The German signature law and its bylaw (SigG and SigV) is currently
22    used with an interface specification described in DIN V 66291-1.
23    The AID to be used is: 'D27600006601'.
24
25    The file IDs for certificates utilize the generic format:
26         Cxyz
27     C being the hex digit 'C' (12).
28     x being the service indicator:
29          '0' := SigG conform digital signature.
30          '1' := entity authentication.
31          '2' := key encipherment.
32          '3' := data encipherment.
33          '4' := key agreement.
34          other values are reserved for future use.
35     y being the security environment number using '0' for cards
36       not supporting a SE number.
37     z being the certificate type:
38          '0'        := C.CH (base certificate of card holder) or C.ICC.
39          '1' .. '7' := C.CH (business or professional certificate
40                        of card holder.
41          '8' .. 'D' := C.CA (certificate of a CA issue by the Root-CA).
42          'E'        := C.RCA (self certified certificate of the Root-CA).
43          'F'        := reserved.
44
45    The file IDs used by default are:
46    '1F00'  EF.SSD (security service descriptor). [o,o]
47    '2F02'  EF.GDO (global data objects) [m,m]
48    'A000'  EF.PROT (signature log).  Cyclic file with 20 records of 53 byte.
49            Read and update after user authentication. [o,o]
50    'B000'  EF.PK.RCA.DS (public keys of Root-CA).  Size is 512b or size
51            of keys. [m (unless a 'C00E' is present),m]
52    'B001'  EF.PK.CA.DS (public keys of CAs).  Size is 512b or size
53            of keys. [o,o]
54    'C00n'  EF.C.CH.DS (digital signature certificate of card holder)
55            with n := 0 .. 7.  Size is 2k or size of cert.  Read and
56            update allowed after user authentication. [m,m]
57    'C00m'  EF.C.CA.DS (digital signature certificate of CA)
58            with m := 8 .. E.  Size is 1k or size of cert.  Read always
59            allowed, update after user authentication. [o,o]
60    'C100'  EF.C.ICC.AUT (AUT certificate of ICC) [o,m]
61    'C108'  EF.C.CA.AUT (AUT certificate of CA) [o,m]
62    'D000'  EF.DM (display message) [-,m]
63
64    The letters in brackets indicate optional or mandatory files: The
65    first for card terminals under full control and the second for
66    "business" card terminals.
67 */
68
69
70
71
72 #include <config.h>
73 #include <errno.h>
74 #include <stdio.h>
75 #include <stdlib.h>
76 #include <string.h>
77 #include <assert.h>
78 #include <time.h>
79
80 #include "scdaemon.h"
81
82 #include "../common/i18n.h"
83 #include "iso7816.h"
84 #include "app-common.h"
85 #include "../common/tlv.h"
86
87
88 static gpg_error_t
89 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
90 {
91   gpg_error_t err;
92   char ct_buf[100], id_buf[100];
93   char hexkeygrip[41];
94   size_t len, certoff;
95   unsigned char *der;
96   size_t derlen;
97   ksba_cert_t cert;
98   int fid;
99
100   (void)flags;
101
102   /* Return the certificate of the card holder. */
103   fid = 0xC000;
104   len = app_help_read_length_of_cert (app_get_slot (app), fid, &certoff);
105   if (!len)
106     return 0; /* Card has not been personalized. */
107
108   sprintf (ct_buf, "%d", 101);
109   sprintf (id_buf, "DINSIG.%04X", fid);
110   send_status_info (ctrl, "CERTINFO",
111                     ct_buf, strlen (ct_buf),
112                     id_buf, strlen (id_buf),
113                     NULL, (size_t)0);
114
115   /* Now we need to read the certificate, so that we can get the
116      public key out of it.  */
117   err = iso7816_read_binary (app_get_slot (app), certoff, len-certoff,
118                              &der, &derlen);
119   if (err)
120     {
121       log_info ("error reading entire certificate from FID 0x%04X: %s\n",
122                 fid, gpg_strerror (err));
123       return 0;
124     }
125
126   err = ksba_cert_new (&cert);
127   if (err)
128     {
129       xfree (der);
130       return err;
131     }
132   err = ksba_cert_init_from_mem (cert, der, derlen);
133   xfree (der); der = NULL;
134   if (err)
135     {
136       log_error ("failed to parse the certificate at FID 0x%04X: %s\n",
137                  fid, gpg_strerror (err));
138       ksba_cert_release (cert);
139       return err;
140     }
141   err = app_help_get_keygrip_string (cert, hexkeygrip);
142   if (err)
143     {
144       log_error ("failed to calculate the keygrip for FID 0x%04X\n", fid);
145       ksba_cert_release (cert);
146       return gpg_error (GPG_ERR_CARD);
147     }
148   ksba_cert_release (cert);
149
150   sprintf (id_buf, "DINSIG.%04X", fid);
151   send_status_info (ctrl, "KEYPAIRINFO",
152                     hexkeygrip, 40,
153                     id_buf, strlen (id_buf),
154                     NULL, (size_t)0);
155   return 0;
156 }
157
158
159
160
161 /* Read the certificate with id CERTID (as returned by learn_status in
162    the CERTINFO status lines) and return it in the freshly allocated
163    buffer put into CERT and the length of the certificate put into
164    CERTLEN.
165
166    FIXME: This needs some cleanups and caching with do_learn_status.
167 */
168 static gpg_error_t
169 do_readcert (app_t app, const char *certid,
170              unsigned char **cert, size_t *certlen)
171 {
172   int fid;
173   gpg_error_t err;
174   unsigned char *buffer;
175   const unsigned char *p;
176   size_t buflen, n;
177   int class, tag, constructed, ndef;
178   size_t totobjlen, objlen, hdrlen;
179   int rootca = 0;
180
181   *cert = NULL;
182   *certlen = 0;
183   if (strncmp (certid, "DINSIG.", 7) )
184     return gpg_error (GPG_ERR_INV_ID);
185   certid += 7;
186   if (!hexdigitp (certid) || !hexdigitp (certid+1)
187       || !hexdigitp (certid+2) || !hexdigitp (certid+3)
188       || certid[4])
189     return gpg_error (GPG_ERR_INV_ID);
190   fid = xtoi_4 (certid);
191   if (fid != 0xC000 )
192     return gpg_error (GPG_ERR_NOT_FOUND);
193
194   /* Read the entire file.  fixme: This could be optimized by first
195      reading the header to figure out how long the certificate
196      actually is. */
197   err = iso7816_select_file (app_get_slot (app), fid, 0);
198   if (err)
199     {
200       log_error ("error selecting FID 0x%04X: %s\n", fid, gpg_strerror (err));
201       return err;
202     }
203
204   err = iso7816_read_binary (app_get_slot (app), 0, 0, &buffer, &buflen);
205   if (err)
206     {
207       log_error ("error reading certificate from FID 0x%04X: %s\n",
208                  fid, gpg_strerror (err));
209       return err;
210     }
211
212   if (!buflen || *buffer == 0xff)
213     {
214       log_info ("no certificate contained in FID 0x%04X\n", fid);
215       err = gpg_error (GPG_ERR_NOT_FOUND);
216       goto leave;
217     }
218
219   /* Now figure something out about the object. */
220   p = buffer;
221   n = buflen;
222   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
223                           &ndef, &objlen, &hdrlen);
224   if (err)
225     goto leave;
226   if ( class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed )
227     ;
228   else if ( class == CLASS_UNIVERSAL && tag == TAG_SET && constructed )
229     rootca = 1;
230   else
231     return gpg_error (GPG_ERR_INV_OBJ);
232   totobjlen = objlen + hdrlen;
233   assert (totobjlen <= buflen);
234
235   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
236                           &ndef, &objlen, &hdrlen);
237   if (err)
238     goto leave;
239
240   if (rootca)
241     ;
242   else if (class == CLASS_UNIVERSAL && tag == TAG_OBJECT_ID && !constructed)
243     {
244       const unsigned char *save_p;
245
246       /* The certificate seems to be contained in a userCertificate
247          container.  Skip this and assume the following sequence is
248          the certificate. */
249       if (n < objlen)
250         {
251           err = gpg_error (GPG_ERR_INV_OBJ);
252           goto leave;
253         }
254       p += objlen;
255       n -= objlen;
256       save_p = p;
257       err = parse_ber_header (&p, &n, &class, &tag, &constructed,
258                               &ndef, &objlen, &hdrlen);
259       if (err)
260         goto leave;
261       if ( !(class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed) )
262         return gpg_error (GPG_ERR_INV_OBJ);
263       totobjlen = objlen + hdrlen;
264       assert (save_p + totobjlen <= buffer + buflen);
265       memmove (buffer, save_p, totobjlen);
266     }
267
268   *cert = buffer;
269   buffer = NULL;
270   *certlen = totobjlen;
271
272  leave:
273   xfree (buffer);
274   return err;
275 }
276
277
278 /* Verify the PIN if required.  */
279 static gpg_error_t
280 verify_pin (app_t app,
281             gpg_error_t (*pincb)(void*, const char *, char **),
282             void *pincb_arg)
283 {
284   const char *s;
285   int rc;
286   pininfo_t pininfo;
287
288   if ( app->did_chv1 && !app->force_chv1 )
289     return 0;  /* No need to verify it again.  */
290
291   memset (&pininfo, 0, sizeof pininfo);
292   pininfo.fixedlen = -1;
293   pininfo.minlen = 6;
294   pininfo.maxlen = 8;
295
296   if (!opt.disable_pinpad
297       && !iso7816_check_pinpad (app_get_slot (app), ISO7816_VERIFY, &pininfo) )
298     {
299       rc = pincb (pincb_arg,
300                   _("||Please enter your PIN at the reader's pinpad"),
301                   NULL);
302       if (rc)
303         {
304           log_info (_("PIN callback returned error: %s\n"),
305                     gpg_strerror (rc));
306           return rc;
307         }
308       rc = iso7816_verify_kp (app_get_slot (app), 0x81, &pininfo);
309       /* Dismiss the prompt. */
310       pincb (pincb_arg, NULL, NULL);
311     }
312   else  /* No Pinpad.  */
313     {
314       char *pinvalue;
315
316       rc = pincb (pincb_arg, "PIN", &pinvalue);
317       if (rc)
318         {
319           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
320           return rc;
321         }
322
323       /* We require the PIN to be at least 6 and at max 8 bytes.
324          According to the specs, this should all be ASCII.  */
325       for (s=pinvalue; digitp (s); s++)
326         ;
327       if (*s)
328         {
329           log_error ("Non-numeric digits found in PIN\n");
330           xfree (pinvalue);
331           return gpg_error (GPG_ERR_BAD_PIN);
332         }
333
334       if (strlen (pinvalue) < pininfo.minlen)
335         {
336           log_error ("PIN is too short; minimum length is %d\n",
337                      pininfo.minlen);
338           xfree (pinvalue);
339           return gpg_error (GPG_ERR_BAD_PIN);
340         }
341       else if (strlen (pinvalue) > pininfo.maxlen)
342         {
343           log_error ("PIN is too large; maximum length is %d\n",
344                      pininfo.maxlen);
345           xfree (pinvalue);
346           return gpg_error (GPG_ERR_BAD_PIN);
347         }
348
349       rc = iso7816_verify (app_get_slot (app), 0x81,
350                            pinvalue, strlen (pinvalue));
351       if (gpg_err_code (rc) == GPG_ERR_INV_VALUE)
352         {
353           /* We assume that ISO 9564-1 encoding is used and we failed
354              because the first nibble we passed was 3 and not 2.  DIN
355              says something about looking up such an encoding in the
356              SSD but I was not able to find any tag relevant to
357              this. */
358           char paddedpin[8];
359           int i, ndigits;
360
361           for (ndigits=0, s=pinvalue; *s; ndigits++, s++)
362             ;
363           i = 0;
364           paddedpin[i++] = 0x20 | (ndigits & 0x0f);
365           for (s=pinvalue; i < sizeof paddedpin && *s && s[1]; s = s+2 )
366             paddedpin[i++] = (((*s - '0') << 4) | ((s[1] - '0') & 0x0f));
367           if (i < sizeof paddedpin && *s)
368             paddedpin[i++] = (((*s - '0') << 4) | 0x0f);
369           while (i < sizeof paddedpin)
370             paddedpin[i++] = 0xff;
371           rc = iso7816_verify (app_get_slot (app), 0x81,
372                                paddedpin, sizeof paddedpin);
373         }
374       xfree (pinvalue);
375     }
376
377   if (rc)
378     {
379       log_error ("verify PIN failed\n");
380       return rc;
381     }
382   app->did_chv1 = 1;
383   return 0;
384 }
385
386
387
388 /* Create the signature and return the allocated result in OUTDATA.
389    If a PIN is required the PINCB will be used to ask for the PIN;
390    that callback should return the PIN in an allocated buffer and
391    store that in the 3rd argument.  */
392 static gpg_error_t
393 do_sign (app_t app, const char *keyidstr, int hashalgo,
394          gpg_error_t (*pincb)(void*, const char *, char **),
395          void *pincb_arg,
396          const void *indata, size_t indatalen,
397          unsigned char **outdata, size_t *outdatalen )
398 {
399   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
400     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
401       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
402   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
403     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
404       0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
405   static unsigned char sha256_prefix[19] = /* OID is 2.16.840.1.101.3.4.2.1 */
406     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
407       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
408       0x00, 0x04, 0x20 };
409   int rc;
410   int fid;
411   unsigned char data[19+32]; /* Must be large enough for a SHA-256 digest
412                                 + the largest OID _prefix above. */
413   int datalen;
414
415   if (!keyidstr || !*keyidstr)
416     return gpg_error (GPG_ERR_INV_VALUE);
417   if (indatalen != 20 && indatalen != 16 && indatalen != 32
418       && indatalen != (15+20) && indatalen != (19+32))
419     return gpg_error (GPG_ERR_INV_VALUE);
420
421   /* Check that the provided ID is valid.  This is not really needed
422      but we do it to enforce correct usage by the caller. */
423   if (strncmp (keyidstr, "DINSIG.", 7) )
424     return gpg_error (GPG_ERR_INV_ID);
425   keyidstr += 7;
426   if (!hexdigitp (keyidstr) || !hexdigitp (keyidstr+1)
427       || !hexdigitp (keyidstr+2) || !hexdigitp (keyidstr+3)
428       || keyidstr[4])
429     return gpg_error (GPG_ERR_INV_ID);
430   fid = xtoi_4 (keyidstr);
431   if (fid != 0xC000)
432     return gpg_error (GPG_ERR_NOT_FOUND);
433
434   /* Prepare the DER object from INDATA. */
435   datalen = 35;
436   if (indatalen == 15+20)
437     {
438       /* Alright, the caller was so kind to send us an already
439          prepared DER object.  Check that it is what we want and that
440          it matches the hash algorithm. */
441       if (hashalgo == GCRY_MD_SHA1 && !memcmp (indata, sha1_prefix, 15))
442         ;
443       else if (hashalgo == GCRY_MD_RMD160 && !memcmp (indata, rmd160_prefix,15))
444         ;
445       else
446         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
447       memcpy (data, indata, indatalen);
448     }
449   else if (indatalen == 19+32)
450     {
451       /* Alright, the caller was so kind to send us an already
452          prepared DER object.  Check that it is what we want and that
453          it matches the hash algorithm. */
454       datalen = indatalen;
455       if (hashalgo == GCRY_MD_SHA256 && !memcmp (indata, sha256_prefix, 19))
456         ;
457       else if (hashalgo == GCRY_MD_SHA1 && !memcmp (indata, sha256_prefix, 19))
458         {
459           /* Fixme: This is a kludge.  A better solution is not to use
460              SHA1 as default but use an autodetection.  However this
461              needs changes in all app-*.c */
462           datalen  = indatalen;
463         }
464       else
465         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
466       memcpy (data, indata, indatalen);
467     }
468   else
469     {
470       int len = 15;
471       if (hashalgo == GCRY_MD_SHA1)
472         memcpy (data, sha1_prefix, len);
473       else if (hashalgo == GCRY_MD_RMD160)
474         memcpy (data, rmd160_prefix, len);
475       else if (hashalgo == GCRY_MD_SHA256)
476         {
477           len = 19;
478           datalen = len + indatalen;
479           memcpy (data, sha256_prefix, len);
480         }
481       else
482         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
483       memcpy (data+len, indata, indatalen);
484     }
485
486   rc = verify_pin (app, pincb, pincb_arg);
487   if (!rc)
488     rc = iso7816_compute_ds (app_get_slot (app), 0, data, datalen, 0,
489                              outdata, outdatalen);
490   return rc;
491 }
492
493
494 #if 0
495 #warning test function - works but may brick your card
496 /* Handle the PASSWD command.  CHVNOSTR is currently ignored; we
497    always use VHV0.  RESET_MODE is not yet implemented.  */
498 static gpg_error_t
499 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
500                unsigned int flags,
501                gpg_error_t (*pincb)(void*, const char *, char **),
502                void *pincb_arg)
503 {
504   gpg_error_t err;
505   char *pinvalue;
506   const char *oldpin;
507   size_t oldpinlen;
508
509   if ((flags & APP_CHANGE_FLAG_RESET))
510     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
511
512   if ((flags & APP_CHANGE_FLAG_NULLPIN))
513     {
514       /* With the nullpin flag, we do not verify the PIN - it would fail
515          if the Nullpin is still set.  */
516       oldpin = "\0\0\0\0\0";
517       oldpinlen = 6;
518     }
519   else
520     {
521       err = verify_pin (app, pincb, pincb_arg);
522       if (err)
523         return err;
524       oldpin = NULL;
525       oldpinlen = 0;
526     }
527
528   /* TRANSLATORS: Do not translate the "|*|" prefixes but
529      keep it at the start of the string.  We need this elsewhere
530      to get some infos on the string. */
531   err = pincb (pincb_arg, _("|N|Initial New PIN"), &pinvalue);
532   if (err)
533     {
534       log_error (_("error getting new PIN: %s\n"), gpg_strerror (err));
535       return err;
536     }
537
538   err = iso7816_change_reference_data (app_get_slot (app), 0x81,
539                                        oldpin, oldpinlen,
540                                        pinvalue, strlen (pinvalue));
541   xfree (pinvalue);
542   return err;
543 }
544 #endif /*0*/
545
546
547 /* Select the DINSIG application on the card in SLOT.  This function
548    must be used before any other DINSIG application functions. */
549 gpg_error_t
550 app_select_dinsig (app_t app)
551 {
552   static char const aid[] = { 0xD2, 0x76, 0x00, 0x00, 0x66, 0x01 };
553   int slot = app_get_slot (app);
554   int rc;
555
556   rc = iso7816_select_application (slot, aid, sizeof aid, 0);
557   if (!rc)
558     {
559       app->apptype = "DINSIG";
560
561       app->fnc.learn_status = do_learn_status;
562       app->fnc.readcert = do_readcert;
563       app->fnc.getattr = NULL;
564       app->fnc.setattr = NULL;
565       app->fnc.genkey = NULL;
566       app->fnc.sign = do_sign;
567       app->fnc.auth = NULL;
568       app->fnc.decipher = NULL;
569       app->fnc.change_pin = NULL /*do_change_pin*/;
570       app->fnc.check_pin = NULL;
571
572       app->force_chv1 = 1;
573    }
574
575   return rc;
576 }