* main.h, keylist.c (print_subpackets_colon): Make a public function.
[gnupg.git] / g10 / cardglue.c
1 /* cardglue.c - mainly dispatcher for card related functions.
2  * Copyright (C) 2003, 2004 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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #ifndef ENABLE_CARD_SUPPORT
23 #error  not configured for card support.
24 #endif
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <stdarg.h>
30 #include <assert.h>
31
32 #include "options.h"
33 #include "packet.h"
34 #include "errors.h"
35 #include "memory.h"
36 #include "util.h"
37 #include "main.h"
38 #include "status.h"
39 #include "ttyio.h"
40 #include "i18n.h"
41
42 #include "cardglue.h"
43 #include "apdu.h"
44 #include "app-common.h"
45
46 struct ctrl_ctx_s {
47   int (*status_cb)(void *opaque, const char *line);
48   void *status_cb_arg;
49 };
50
51
52 static char *default_reader_port;
53 static APP current_app;
54
55
56
57
58 /* Create a serialno/fpr string from the serial number and the secret
59    key.  caller must free the returned string.  There is no error
60    return. [Taken from 1.9's keyid.c]*/
61 char *
62 serialno_and_fpr_from_sk (const unsigned char *sn, size_t snlen,
63                           PKT_secret_key *sk)
64 {
65   unsigned char fpr[MAX_FINGERPRINT_LEN];
66   size_t fprlen;
67   char *buffer, *p;
68   int i;
69   
70   fingerprint_from_sk (sk, fpr, &fprlen);
71   buffer = p = xmalloc (snlen*2 + 1 + fprlen*2 + 1);
72   for (i=0; i < snlen; i++, p+=2)
73     sprintf (p, "%02X", sn[i]);
74   *p++ = '/';
75   for (i=0; i < fprlen; i++, p+=2)
76     sprintf (p, "%02X", fpr[i]);
77   *p = 0;
78   return buffer;
79 }
80
81
82 /* Send a line with status information via assuan and escape all given
83    buffers. The variable elements are pairs of (char *, size_t),
84    terminated with a (NULL, 0). */
85 void
86 send_status_info (CTRL ctrl, const char *keyword, ...)
87 {
88   va_list arg_ptr;
89   const unsigned char *value;
90   size_t valuelen;
91   char buf[950], *p;
92   size_t n;
93   
94   va_start (arg_ptr, keyword);
95
96   p = buf; 
97   n = 0;
98   valuelen = strlen (keyword);
99   for ( ; valuelen && n < DIM (buf)-2; n++, valuelen--, keyword++)
100     *p++ = *keyword;
101
102   while ( (value = va_arg (arg_ptr, const unsigned char *)) )
103     {
104       valuelen = va_arg (arg_ptr, size_t);
105       if (!valuelen)
106         continue; /* empty buffer */
107       if (n)
108         {
109           *p++ = ' ';
110           n++;
111         }
112       for ( ; valuelen && n < DIM (buf)-2; n++, valuelen--, value++)
113         {
114           if (*value < ' ' || *value == '+')
115             {
116               sprintf (p, "%%%02X", *value);
117               p += 3;
118             }
119           else if (*value == ' ')
120             *p++ = '+';
121           else
122             *p++ = *value;
123         }
124     }
125   *p = 0;
126   ctrl->status_cb (ctrl->status_cb_arg, buf);
127
128   va_end (arg_ptr);
129 }
130
131
132 void gcry_md_hash_buffer (int algo, void *digest,
133                           const void *buffer, size_t length)
134 {
135   MD_HANDLE h = md_open (algo, 0);
136   if (!h)
137     BUG();
138   md_write (h, (byte *) buffer, length);
139   md_final (h);
140   memcpy (digest, md_read (h, algo), md_digest_length (algo));
141   md_close (h);
142 }
143
144
145 /* This is a limited version of the one in 1.9 but it should be
146    sufficient here. */
147 void
148 log_printf (const char *fmt, ...)
149 {
150   va_list arg_ptr;
151
152   va_start (arg_ptr, fmt);
153   vfprintf (log_stream (), fmt, arg_ptr);
154   va_end (arg_ptr);
155 }
156
157
158
159 /* Print a hexdump of BUFFER.  With TEXT of NULL print just the raw
160    dump, with TEXT just an empty string, print a trailing linefeed,
161    otherwise print an entire debug line. */
162 void
163 log_printhex (const char *text, const void *buffer, size_t length)
164 {
165   if (text && *text)
166     log_debug ("%s ", text);
167   if (length)
168     {
169       const unsigned char *p = buffer;
170       log_printf ("%02X", *p);
171       for (length--, p++; length--; p++)
172         log_printf (" %02X", *p);
173     }
174   if (text)
175     log_printf ("\n");
176 }
177
178
179
180 void
181 app_set_default_reader_port (const char *portstr)
182 {
183   xfree (default_reader_port);
184   default_reader_port = portstr? xstrdup (portstr): NULL;
185 }
186
187
188 void
189 card_set_reader_port (const char *portstr)
190 {
191   app_set_default_reader_port (portstr);
192 }
193
194
195 /* Retrieve the serial number and the time of the last update of the
196    card.  The serial number is returned as a malloced string (hex
197    encoded) in SERIAL and the time of update is returned in STAMP.  If
198    no update time is available the returned value is 0.  Caller must
199    free SERIAL unless the function returns an error. */
200 int 
201 app_get_serial_and_stamp (APP app, char **serial, time_t *stamp)
202 {
203   unsigned char *buf, *p;
204   int i;
205
206   if (!app || !serial || !stamp)
207     return gpg_error (GPG_ERR_INV_VALUE);
208
209   *serial = NULL;
210   *stamp = 0; /* not available */
211
212   buf = xtrymalloc (app->serialnolen * 2 + 1);
213   if (!buf)
214     return gpg_error_from_errno (errno);
215   for (p=buf, i=0; i < app->serialnolen; p +=2, i++)
216     sprintf (p, "%02X", app->serialno[i]);
217   *p = 0;
218   *serial = buf;
219   return 0;
220 }
221
222
223
224
225
226
227 /* Release the card info structure. */
228 void 
229 agent_release_card_info (struct agent_card_info_s *info)
230 {
231   if (!info)
232     return;
233
234   xfree (info->serialno); info->serialno = NULL;
235   xfree (info->disp_name); info->disp_name = NULL;
236   xfree (info->disp_lang); info->disp_lang = NULL;
237   xfree (info->pubkey_url); info->pubkey_url = NULL;
238   xfree (info->login_data); info->login_data = NULL;
239   info->fpr1valid = info->fpr2valid = info->fpr3valid = 0;
240   info->cafpr1valid = info->cafpr2valid = info->cafpr3valid = 0;
241 }
242
243
244 /* Open the current card and select the openpgp application.  Return
245    an APP context handle to be used for further procesing or NULL on
246    error or if no OpenPGP application exists.*/
247 static APP
248 open_card (void)
249 {
250   int slot;
251   int rc;
252   APP app;
253
254   card_close ();
255
256  retry:
257   slot = apdu_open_reader (default_reader_port);
258   if (slot == -1)
259     {
260       log_error ("card reader not available\n");
261       return NULL;
262     }
263
264   app = xcalloc (1, sizeof *app);
265   app->slot = slot;
266   rc = app_select_openpgp (app);
267   if (rc && !opt.batch)
268     {
269       write_status_text (STATUS_CARDCTRL, "1");
270       
271       if ( cpr_get_answer_okay_cancel ("cardctrl.insert_card.okay",
272            _("Please insert the card and hit return or enter 'c' to cancel: "),
273                                        1) )
274         {
275           apdu_close_reader (slot);
276           xfree (app);
277           goto retry;
278         }
279     }
280   if (rc)
281     {
282       log_info ("selecting openpgp failed: %s\n", gpg_strerror (rc));
283       apdu_close_reader (slot);
284       xfree (app);
285       return NULL;
286     }
287
288   app->initialized = 1;
289   current_app = app;
290   if (is_status_enabled () )
291     {
292       int i;
293       char *p, *buf;
294
295       buf = xmalloc (5 + app->serialnolen * 2 + 1);
296       p = stpcpy (buf, "3 ");
297       for (i=0; i < app->serialnolen; p +=2, i++)
298         sprintf (p, "%02X", app->serialno[i]);
299       write_status_text (STATUS_CARDCTRL, buf);
300       xfree (buf);
301     }
302
303   return app;
304 }
305
306 void
307 card_close (void)
308 {
309   if (current_app)
310     {
311       APP app = current_app;
312       current_app = NULL;
313
314       apdu_close_reader (app->slot);
315       xfree (app);
316     }
317 }
318
319
320 /* Check that the serial number of the current card (as described by
321    APP) matches SERIALNO.  If there is no match and we are not in
322    batch mode, present a prompt to insert the desired card.  The
323    function return 0 is the present card is okay, -1 if the user
324    selected to insert a new card or an error value.  Note that the
325    card context will be closed in all cases except for 0 as return
326    value. */
327 static int
328 check_card_serialno (APP app, const char *serialno)
329 {
330   const char *s;
331   int ask = 0;
332   int n;
333   
334   for (s = serialno, n=0; *s != '/' && hexdigitp (s); s++, n++)
335     ;
336   if (n != 32)
337     {
338       log_error ("invalid serial number in keyring detected\n");
339       return gpg_error (GPG_ERR_INV_ID);
340     }
341   if (app->serialnolen != 16)
342     ask = 1;
343   for (s = serialno, n=0; !ask && n < 16; s += 2, n++)
344     if (app->serialno[n] != xtoi_2 (s))
345       ask = 1;
346   if (ask)
347     {
348       char buf[5+32+1];
349
350       card_close ();
351       tty_printf (_("Please remove the current card and "
352                     "insert the one with the serial number:\n"
353                     "   %.*s\n"), 32, serialno);
354
355       sprintf (buf, "1 %.32s", serialno);
356       write_status_text (STATUS_CARDCTRL, buf);
357
358       if ( cpr_get_answer_okay_cancel ("cardctrl.change_card.okay",
359                           _("Hit return when ready "
360                             "or enter 'c' to cancel: "),
361                                        1) )
362         return -1;
363       return gpg_error (GPG_ERR_INV_ID);
364     }
365   return 0;
366 }
367
368
369
370 /* Return a new malloced string by unescaping the string S.  Escaping
371    is percent escaping and '+'/space mapping.  A binary nul will
372    silently be replaced by a 0xFF.  Function returns NULL to indicate
373    an out of memory status. */
374 static char *
375 unescape_status_string (const unsigned char *s)
376 {
377   char *buffer, *d;
378
379   buffer = d = xmalloc (strlen (s)+1);
380   while (*s)
381     {
382       if (*s == '%' && s[1] && s[2])
383         { 
384           s++;
385           *d = xtoi_2 (s);
386           if (!*d)
387             *d = '\xff';
388           d++;
389           s += 2;
390         }
391       else if (*s == '+')
392         {
393           *d++ = ' ';
394           s++;
395         }
396       else
397         *d++ = *s++;
398     }
399   *d = 0; 
400   return buffer;
401 }
402
403 /* Take a 20 byte hexencoded string and put it into the the provided
404    20 byte buffer FPR in binary format. */
405 static int
406 unhexify_fpr (const char *hexstr, unsigned char *fpr)
407 {
408   const char *s;
409   int n;
410
411   for (s=hexstr, n=0; hexdigitp (s); s++, n++)
412     ;
413   if (*s || (n != 40))
414     return 0; /* no fingerprint (invalid or wrong length). */
415   n /= 2;
416   for (s=hexstr, n=0; *s; s += 2, n++)
417     fpr[n] = xtoi_2 (s);
418   return 1; /* okay */
419 }
420
421 /* Take the serial number from LINE and return it verbatim in a newly
422    allocated string.  We make sure that only hex characters are
423    returned. */
424 static char *
425 store_serialno (const char *line)
426 {
427   const char *s;
428   char *p;
429
430   for (s=line; hexdigitp (s); s++)
431     ;
432   p = xmalloc (s + 1 - line);
433   memcpy (p, line, s-line);
434   p[s-line] = 0;
435   return p;
436 }
437
438
439
440 static int
441 learn_status_cb (void *opaque, const char *line)
442 {
443   struct agent_card_info_s *parm = opaque;
444   const char *keyword = line;
445   int keywordlen;
446   int i;
447
448   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
449     ;
450   while (spacep (line))
451     line++;
452
453   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
454     {
455       xfree (parm->serialno);
456       parm->serialno = store_serialno (line);
457     }
458   else if (keywordlen == 9 && !memcmp (keyword, "DISP-NAME", keywordlen))
459     {
460       xfree (parm->disp_name);
461       parm->disp_name = unescape_status_string (line);
462     }
463   else if (keywordlen == 9 && !memcmp (keyword, "DISP-LANG", keywordlen))
464     {
465       xfree (parm->disp_lang);
466       parm->disp_lang = unescape_status_string (line);
467     }
468   else if (keywordlen == 8 && !memcmp (keyword, "DISP-SEX", keywordlen))
469     {
470       parm->disp_sex = *line == '1'? 1 : *line == '2' ? 2: 0;
471     }
472   else if (keywordlen == 10 && !memcmp (keyword, "PUBKEY-URL", keywordlen))
473     {
474       xfree (parm->pubkey_url);
475       parm->pubkey_url = unescape_status_string (line);
476     }
477   else if (keywordlen == 10 && !memcmp (keyword, "LOGIN-DATA", keywordlen))
478     {
479       xfree (parm->login_data);
480       parm->login_data = unescape_status_string (line);
481     }
482   else if (keywordlen == 11 && !memcmp (keyword, "SIG-COUNTER", keywordlen))
483     {
484       parm->sig_counter = strtoul (line, NULL, 0);
485     }
486   else if (keywordlen == 10 && !memcmp (keyword, "CHV-STATUS", keywordlen))
487     {
488       char *p, *buf;
489
490       buf = p = unescape_status_string (line);
491       if (buf)
492         {
493           while (spacep (p))
494             p++;
495           parm->chv1_cached = atoi (p);
496           while (*p && !spacep (p))
497             p++;
498           while (spacep (p))
499             p++;
500           for (i=0; *p && i < 3; i++)
501             {
502               parm->chvmaxlen[i] = atoi (p);
503               while (*p && !spacep (p))
504                 p++;
505               while (spacep (p))
506                 p++;
507             }
508           for (i=0; *p && i < 3; i++)
509             {
510               parm->chvretry[i] = atoi (p);
511               while (*p && !spacep (p))
512                 p++;
513               while (spacep (p))
514                 p++;
515             }
516           xfree (buf);
517         }
518     }
519   else if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
520     {
521       int no = atoi (line);
522       while (* line && !spacep (line))
523         line++;
524       while (spacep (line))
525         line++;
526       if (no == 1)
527         parm->fpr1valid = unhexify_fpr (line, parm->fpr1);
528       else if (no == 2)
529         parm->fpr2valid = unhexify_fpr (line, parm->fpr2);
530       else if (no == 3)
531         parm->fpr3valid = unhexify_fpr (line, parm->fpr3);
532     }
533   else if (keywordlen == 6 && !memcmp (keyword, "CA-FPR", keywordlen))
534     {
535       int no = atoi (line);
536       while (*line && !spacep (line))
537         line++;
538       while (spacep (line))
539         line++;
540       if (no == 1)
541         parm->cafpr1valid = unhexify_fpr (line, parm->cafpr1);
542       else if (no == 2)
543         parm->cafpr2valid = unhexify_fpr (line, parm->cafpr2);
544       else if (no == 3)
545         parm->cafpr3valid = unhexify_fpr (line, parm->cafpr3);
546     }
547
548   return 0;
549 }
550
551
552 /* Return card info. */
553 int 
554 agent_learn (struct agent_card_info_s *info)
555 {
556   APP app;
557   int rc;
558   struct ctrl_ctx_s ctrl;
559   time_t stamp;
560   char *serial;
561   
562   app = current_app? current_app : open_card ();
563   if (!app)
564     return gpg_error (GPG_ERR_CARD);
565
566   memset (info, 0, sizeof *info);
567   memset (&ctrl, 0, sizeof ctrl);
568   ctrl.status_cb = learn_status_cb;
569   ctrl.status_cb_arg = info;
570
571   rc = app_get_serial_and_stamp (app, &serial, &stamp);
572   if (!rc)
573     {
574       send_status_info (&ctrl, "SERIALNO", serial, strlen(serial), NULL, 0);
575       xfree (serial);
576       rc = app->fnc.learn_status (app, &ctrl);
577     }
578
579   return rc;
580 }
581
582 /* Get an attribite from the card. Make sure info is initialized. */
583 int 
584 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
585 {
586   APP app;
587   struct ctrl_ctx_s ctrl;
588
589   app = current_app? current_app : open_card ();
590   if (!app)
591     return gpg_error (GPG_ERR_CARD);
592
593   ctrl.status_cb = learn_status_cb;
594   ctrl.status_cb_arg = info;
595   return app->fnc.getattr (app, &ctrl, name);
596 }
597
598
599
600 static int 
601 pin_cb (void *opaque, const char *info, char **retstr)
602 {
603   char *value;
604   int canceled;
605   int isadmin = (info && strstr (info, "dmin"));
606
607
608   *retstr = NULL;
609   log_debug ("asking for PIN '%s'\n", info);
610
611   value = ask_passphrase (info, 
612                           isadmin? "passphrase.adminpin.ask"
613                                  : "passphrase.pin.ask", 
614                           isadmin?  _("Enter Admin PIN: ") : _("Enter PIN: "),
615                           &canceled);
616   if (!value && canceled)
617     return -1;
618   else if (!value)
619     return G10ERR_GENERAL;
620
621   *retstr = value;
622   return 0;
623 }
624
625
626
627 /* Send a SETATTR command to the SCdaemon. */
628 int 
629 agent_scd_setattr (const char *name,
630                    const unsigned char *value, size_t valuelen)
631 {
632   APP app;
633
634   app = current_app? current_app : open_card ();
635   if (!app)
636     return gpg_error (GPG_ERR_CARD);
637
638   return app->fnc.setattr (app, name, pin_cb, NULL, value, valuelen);
639 }
640
641
642 static int
643 genkey_status_cb (void *opaque, const char *line)
644 {
645   struct agent_card_genkey_s *parm = opaque;
646   const char *keyword = line;
647   int keywordlen;
648
649   log_debug ("got status line `%s'\n", line);
650   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
651     ;
652   while (spacep (line))
653     line++;
654
655   if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
656     {
657       parm->fprvalid = unhexify_fpr (line, parm->fpr);
658     }
659   if (keywordlen == 8 && !memcmp (keyword, "KEY-DATA", keywordlen))
660     {
661       MPI a;
662       const char *name = line;
663       char *buf;
664
665       while (*line && !spacep (line))
666         line++;
667       while (spacep (line))
668         line++;
669
670       buf = xmalloc ( 2 + strlen (line) + 1);
671       strcpy (stpcpy (buf, "0x"), line);
672       a = mpi_alloc (300);
673       if( mpi_fromstr (a, buf) )
674         log_error ("error parsing received key data\n");
675       else if (*name == 'n' && spacep (name+1))
676         parm->n = a;
677       else if (*name == 'e' && spacep (name+1))
678         parm->e = a;
679       else
680         {
681           log_info ("unknown parameter name in received key data\n");
682           mpi_free (a);
683         }
684       xfree (buf);
685     }
686   else if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
687     {
688       parm->created_at = (u32)strtoul (line, NULL, 10);
689     }
690
691   return 0;
692 }
693
694 /* Send a GENKEY command to the SCdaemon. */
695 int 
696 agent_scd_genkey (struct agent_card_genkey_s *info, int keyno, int force)
697 {
698   APP app;
699   char keynostr[20];
700   struct ctrl_ctx_s ctrl;
701
702   app = current_app? current_app : open_card ();
703   if (!app)
704     return gpg_error (GPG_ERR_CARD);
705
706   memset (info, 0, sizeof *info);
707   sprintf (keynostr, "%d", keyno);
708   ctrl.status_cb = genkey_status_cb;
709   ctrl.status_cb_arg = info;
710
711   return app->fnc.genkey (app, &ctrl, keynostr,
712                            force? 1:0,
713                            pin_cb, NULL);
714 }
715
716 /* Send a PKSIGN command to the SCdaemon. */
717 int 
718 agent_scd_pksign (const char *serialno, int hashalgo,
719                   const unsigned char *indata, size_t indatalen,
720                   unsigned char **r_buf, size_t *r_buflen)
721 {
722   APP app;
723   int rc;
724
725   *r_buf = NULL;
726   *r_buflen = 0;
727  retry:
728   app = current_app? current_app : open_card ();
729   if (!app)
730     return gpg_error (GPG_ERR_CARD);
731
732   /* Check that the card's serialnumber is as required.*/
733   rc = check_card_serialno (app, serialno);
734   if (rc == -1)
735     goto retry;
736   if (rc)
737     return rc;
738
739   return app->fnc.sign (app, serialno, hashalgo,
740                         pin_cb, NULL,
741                         indata, indatalen,
742                         r_buf, r_buflen);
743 }
744
745
746 /* Send a PKDECRYPT command to the SCdaemon. */
747 int 
748 agent_scd_pkdecrypt (const char *serialno,
749                      const unsigned char *indata, size_t indatalen,
750                      unsigned char **r_buf, size_t *r_buflen)
751 {
752   APP app;
753   int rc;
754
755   *r_buf = NULL;
756   *r_buflen = 0;
757  retry:
758   app = current_app? current_app : open_card ();
759   if (!app)
760     return gpg_error (GPG_ERR_CARD);
761
762   /* Check that the card's serialnumber is as required.*/
763   rc = check_card_serialno (app, serialno);
764   if (rc == -1)
765     goto retry;
766   if (rc)
767     return rc;
768
769   return app->fnc.decipher (app, serialno, 
770                             pin_cb, NULL,
771                             indata, indatalen,
772                             r_buf, r_buflen);
773 }
774
775 /* Change the PIN of an OpenPGP card or reset the retry counter. */
776 int 
777 agent_scd_change_pin (int chvno)
778 {
779   APP app;
780   char chvnostr[20];
781   int reset = 0;
782
783   reset = (chvno >= 100);
784   chvno %= 100;
785
786   app = current_app? current_app : open_card ();
787   if (!app)
788     return gpg_error (GPG_ERR_CARD);
789
790   sprintf (chvnostr, "%d", chvno);
791   return app->fnc.change_pin (app, NULL, chvnostr, reset,
792                               pin_cb, NULL);
793 }
794
795 /* Perform a CHECKPIN operation.  SERIALNO should be the seriial
796    number of the card - optioanlly followed by the fingerprint;
797    however the fingerprint is ignored here. */
798 int
799 agent_scd_checkpin (const char *serialnobuf)
800 {
801   APP app;
802
803   app = current_app? current_app : open_card ();
804   if (!app)
805     return gpg_error (GPG_ERR_CARD);
806
807   return app->fnc.check_pin (app, serialnobuf, pin_cb, NULL);
808 }
809