Use Assuan socket wrapper calls.
[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 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 <http://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 "i18n.h"
83 #include "iso7816.h"
84 #include "app-common.h"
85 #include "tlv.h"
86
87
88 static gpg_error_t
89 do_learn_status (app_t app, ctrl_t ctrl)
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   /* Return the certificate of the card holder. */
101   fid = 0xC000;
102   len = app_help_read_length_of_cert (app->slot, fid, &certoff); 
103   if (!len)
104     return 0; /* Card has not been personalized. */
105
106   sprintf (ct_buf, "%d", 101);
107   sprintf (id_buf, "DINSIG.%04X", fid);
108   send_status_info (ctrl, "CERTINFO",
109                     ct_buf, strlen (ct_buf), 
110                     id_buf, strlen (id_buf), 
111                     NULL, (size_t)0);
112
113   /* Now we need to read the certificate, so that we can get the
114      public key out of it.  */
115   err = iso7816_read_binary (app->slot, certoff, len-certoff, &der, &derlen);
116   if (err)
117     {
118       log_info ("error reading entire certificate from FID 0x%04X: %s\n",
119                 fid, gpg_strerror (err));
120       return 0;
121     }
122
123   err = ksba_cert_new (&cert);
124   if (err)
125     {
126       xfree (der);
127       return err;
128     }
129   err = ksba_cert_init_from_mem (cert, der, derlen); 
130   xfree (der); der = NULL;
131   if (err)
132     {
133       log_error ("failed to parse the certificate at FID 0x%04X: %s\n",
134                  fid, gpg_strerror (err));
135       ksba_cert_release (cert);
136       return err;
137     }
138   err = app_help_get_keygrip_string (cert, hexkeygrip);
139   if (err)
140     {
141       log_error ("failed to calculate the keygrip for FID 0x%04X\n", fid);
142       ksba_cert_release (cert);
143       return gpg_error (GPG_ERR_CARD);
144     }      
145   ksba_cert_release (cert);
146
147   sprintf (id_buf, "DINSIG.%04X", fid);
148   send_status_info (ctrl, "KEYPAIRINFO",
149                     hexkeygrip, 40, 
150                     id_buf, strlen (id_buf), 
151                     NULL, (size_t)0);
152   return 0;
153 }
154
155
156
157
158 /* Read the certificate with id CERTID (as returned by learn_status in
159    the CERTINFO status lines) and return it in the freshly allocated
160    buffer put into CERT and the length of the certificate put into
161    CERTLEN. 
162
163    FIXME: This needs some cleanups and caching with do_learn_status.
164 */
165 static gpg_error_t
166 do_readcert (app_t app, const char *certid,
167              unsigned char **cert, size_t *certlen)
168 {
169   int fid;
170   gpg_error_t err;
171   unsigned char *buffer;
172   const unsigned char *p;
173   size_t buflen, n;
174   int class, tag, constructed, ndef;
175   size_t totobjlen, objlen, hdrlen;
176   int rootca = 0;
177
178   *cert = NULL;
179   *certlen = 0;
180   if (strncmp (certid, "DINSIG.", 7) ) 
181     return gpg_error (GPG_ERR_INV_ID);
182   certid += 7;
183   if (!hexdigitp (certid) || !hexdigitp (certid+1)
184       || !hexdigitp (certid+2) || !hexdigitp (certid+3) 
185       || certid[4])
186     return gpg_error (GPG_ERR_INV_ID);
187   fid = xtoi_4 (certid);
188   if (fid != 0xC000 )
189     return gpg_error (GPG_ERR_NOT_FOUND);
190
191   /* Read the entire file.  fixme: This could be optimized by first
192      reading the header to figure out how long the certificate
193      actually is. */
194   err = iso7816_select_file (app->slot, fid, 0, NULL, NULL);
195   if (err)
196     {
197       log_error ("error selecting FID 0x%04X: %s\n", fid, gpg_strerror (err));
198       return err;
199     }
200
201   err = iso7816_read_binary (app->slot, 0, 0, &buffer, &buflen);
202   if (err)
203     {
204       log_error ("error reading certificate from FID 0x%04X: %s\n",
205                  fid, gpg_strerror (err));
206       return err;
207     }
208   
209   if (!buflen || *buffer == 0xff)
210     {
211       log_info ("no certificate contained in FID 0x%04X\n", fid);
212       err = gpg_error (GPG_ERR_NOT_FOUND);
213       goto leave;
214     }
215
216   /* Now figure something out about the object. */
217   p = buffer;
218   n = buflen;
219   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
220                           &ndef, &objlen, &hdrlen);
221   if (err)
222     goto leave;
223   if ( class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed )
224     ;
225   else if ( class == CLASS_UNIVERSAL && tag == TAG_SET && constructed )
226     rootca = 1;
227   else
228     return gpg_error (GPG_ERR_INV_OBJ);
229   totobjlen = objlen + hdrlen;
230   assert (totobjlen <= buflen);
231
232   err = parse_ber_header (&p, &n, &class, &tag, &constructed,
233                           &ndef, &objlen, &hdrlen);
234   if (err)
235     goto leave;
236   
237   if (rootca)
238     ;
239   else if (class == CLASS_UNIVERSAL && tag == TAG_OBJECT_ID && !constructed)
240     {
241       const unsigned char *save_p;
242   
243       /* The certificate seems to be contained in a userCertificate
244          container.  Skip this and assume the following sequence is
245          the certificate. */
246       if (n < objlen)
247         {
248           err = gpg_error (GPG_ERR_INV_OBJ);
249           goto leave;
250         }
251       p += objlen;
252       n -= objlen;
253       save_p = p;
254       err = parse_ber_header (&p, &n, &class, &tag, &constructed,
255                               &ndef, &objlen, &hdrlen);
256       if (err) 
257         goto leave;
258       if ( !(class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && constructed) )
259         return gpg_error (GPG_ERR_INV_OBJ);
260       totobjlen = objlen + hdrlen;
261       assert (save_p + totobjlen <= buffer + buflen);
262       memmove (buffer, save_p, totobjlen);
263     }
264   
265   *cert = buffer;
266   buffer = NULL;
267   *certlen = totobjlen;
268
269  leave:
270   xfree (buffer);
271   return err;
272 }
273
274
275 /* Verify the PIN if required.  */
276 static gpg_error_t
277 verify_pin (app_t app,
278             gpg_error_t (*pincb)(void*, const char *, char **),
279             void *pincb_arg)
280 {
281   const char *s;
282   int rc;
283   iso7816_pininfo_t pininfo;
284
285   if ( app->did_chv1 && !app->force_chv1 ) 
286     return 0;  /* No need to verify it again.  */
287
288   memset (&pininfo, 0, sizeof pininfo);
289   pininfo.mode = 1;
290   pininfo.minlen = 6;
291   pininfo.maxlen = 8;
292
293   if (!opt.disable_keypad
294       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
295     {
296       rc = pincb (pincb_arg,
297                   _("||Please enter your PIN at the reader's keypad"),
298                   NULL);
299       if (rc)
300         {
301           log_info (_("PIN callback returned error: %s\n"),
302                     gpg_strerror (rc));
303           return rc;
304         }
305       rc = iso7816_verify_kp (app->slot, 0x81, "", 0, &pininfo); 
306       /* Dismiss the prompt. */
307       pincb (pincb_arg, NULL, NULL);
308     }
309   else  /* No Keypad.  */
310     {
311       char *pinvalue;
312
313       rc = pincb (pincb_arg, "PIN", &pinvalue);
314       if (rc)
315         {
316           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
317           return rc;
318         }
319
320       /* We require the PIN to be at least 6 and at max 8 bytes.
321          According to the specs, this should all be ASCII.  */
322       for (s=pinvalue; digitp (s); s++)
323         ;
324       if (*s)
325         {
326           log_error ("Non-numeric digits found in PIN\n");
327           xfree (pinvalue);
328           return gpg_error (GPG_ERR_BAD_PIN);
329         }
330
331       if (strlen (pinvalue) < pininfo.minlen)
332         {
333           log_error ("PIN is too short; minimum length is %d\n",
334                      pininfo.minlen);
335           xfree (pinvalue);
336           return gpg_error (GPG_ERR_BAD_PIN);
337         }
338       else if (strlen (pinvalue) > pininfo.maxlen)
339         {
340           log_error ("PIN is too large; maximum length is %d\n",
341                      pininfo.maxlen);
342           xfree (pinvalue);
343           return gpg_error (GPG_ERR_BAD_PIN);
344         }
345
346       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
347       if (gpg_err_code (rc) == GPG_ERR_INV_VALUE)
348         {
349           /* We assume that ISO 9564-1 encoding is used and we failed
350              because the first nibble we passed was 3 and not 2.  DIN
351              says something about looking up such an encoding in the
352              SSD but I was not able to find any tag relevant to
353              this. */
354           char paddedpin[8];
355           int i, ndigits;
356           
357           for (ndigits=0, s=pinvalue; *s; ndigits++, s++)
358             ;
359           i = 0;
360           paddedpin[i++] = 0x20 | (ndigits & 0x0f);
361           for (s=pinvalue; i < sizeof paddedpin && *s && s[1]; s = s+2 )
362             paddedpin[i++] = (((*s - '0') << 4) | ((s[1] - '0') & 0x0f));
363           if (i < sizeof paddedpin && *s)
364             paddedpin[i++] = (((*s - '0') << 4) | 0x0f);
365           while (i < sizeof paddedpin)
366             paddedpin[i++] = 0xff;
367           rc = iso7816_verify (app->slot, 0x81, paddedpin, sizeof paddedpin);
368         }
369       xfree (pinvalue);
370     }
371
372   if (rc)
373     {
374       log_error ("verify PIN failed\n");
375       return rc;
376     }
377   app->did_chv1 = 1;
378   return 0;
379 }
380
381
382
383 /* Create the signature and return the allocated result in OUTDATA.
384    If a PIN is required the PINCB will be used to ask for the PIN;
385    that callback should return the PIN in an allocated buffer and
386    store that in the 3rd argument.  */
387 static gpg_error_t 
388 do_sign (app_t app, const char *keyidstr, int hashalgo,
389          gpg_error_t (*pincb)(void*, const char *, char **),
390          void *pincb_arg,
391          const void *indata, size_t indatalen,
392          unsigned char **outdata, size_t *outdatalen )
393 {
394   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
395     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
396       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
397   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
398     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
399       0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
400   int rc;
401   int fid;
402   unsigned char data[35];   /* Must be large enough for a SHA-1 digest
403                                + the largest OID _prefix above. */
404
405   if (!keyidstr || !*keyidstr)
406     return gpg_error (GPG_ERR_INV_VALUE);
407   if (indatalen != 20 && indatalen != 16 && indatalen != 35)
408     return gpg_error (GPG_ERR_INV_VALUE);
409
410   /* Check that the provided ID is vaid.  This is not really needed
411      but we do it to to enforce correct usage by the caller. */
412   if (strncmp (keyidstr, "DINSIG.", 7) ) 
413     return gpg_error (GPG_ERR_INV_ID);
414   keyidstr += 7;
415   if (!hexdigitp (keyidstr) || !hexdigitp (keyidstr+1)
416       || !hexdigitp (keyidstr+2) || !hexdigitp (keyidstr+3) 
417       || keyidstr[4])
418     return gpg_error (GPG_ERR_INV_ID);
419   fid = xtoi_4 (keyidstr);
420   if (fid != 0xC000)
421     return gpg_error (GPG_ERR_NOT_FOUND);
422
423   /* Prepare the DER object from INDATA. */
424   if (indatalen == 35)
425     {
426       /* Alright, the caller was so kind to send us an already
427          prepared DER object.  Check that it is what we want and that
428          it matches the hash algorithm. */
429       if (hashalgo == GCRY_MD_SHA1 && !memcmp (indata, sha1_prefix, 15))
430         ;
431       else if (hashalgo == GCRY_MD_RMD160 && !memcmp (indata, rmd160_prefix,15))
432         ;
433       else 
434         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
435       memcpy (data, indata, indatalen);
436     }
437   else
438     {
439       if (hashalgo == GCRY_MD_SHA1)
440         memcpy (data, sha1_prefix, 15);
441       else if (hashalgo == GCRY_MD_RMD160)
442         memcpy (data, rmd160_prefix, 15);
443       else 
444         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
445       memcpy (data+15, indata, indatalen);
446     }
447
448   rc = verify_pin (app, pincb, pincb_arg);
449   if (!rc)
450     rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
451   return rc;
452 }
453
454
455
456 /* Select the DINSIG application on the card in SLOT.  This function
457    must be used before any other DINSIG application functions. */
458 gpg_error_t
459 app_select_dinsig (app_t app)
460 {
461   static char const aid[] = { 0xD2, 0x76, 0x00, 0x00, 0x66, 0x01 };
462   int slot = app->slot;
463   int rc;
464   
465   rc = iso7816_select_application (slot, aid, sizeof aid, 0);
466   if (!rc)
467     {
468       app->apptype = "DINSIG";
469
470       app->fnc.learn_status = do_learn_status;
471       app->fnc.readcert = do_readcert;
472       app->fnc.getattr = NULL;
473       app->fnc.setattr = NULL;
474       app->fnc.genkey = NULL;
475       app->fnc.sign = do_sign;
476       app->fnc.auth = NULL;
477       app->fnc.decipher = NULL;
478       app->fnc.change_pin = NULL;
479       app->fnc.check_pin = NULL;
480
481       app->force_chv1 = 1;
482    }
483
484   return rc;
485 }