* card-util.c (fetch_url): Fetch the key from the default
[gnupg.git] / g10 / card-util.c
1 /* card-util.c - Utility functions for the OpenPGP card.
2  *      Copyright (C) 2003, 2004, 2005 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 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #if GNUPG_MAJOR_VERSION != 1
29 #include "gpg.h"
30 #endif
31 #include "util.h"
32 #include "i18n.h"
33 #include "ttyio.h"
34 #include "status.h"
35 #include "options.h"
36 #include "main.h"
37 #include "keyserver-internal.h"
38 #if GNUPG_MAJOR_VERSION == 1
39 #include "cardglue.h"
40 #else
41 #include "call-agent.h"
42 #endif
43
44 #define CONTROL_D ('D' - 'A' + 1)
45
46
47 /* Change the PIN of a an OpenPGP card.  This is an interactive
48    function. */
49 void
50 change_pin (int chvno, int allow_admin)
51 {
52   struct agent_card_info_s info;
53   int rc;
54
55   rc = agent_learn (&info);
56   if (rc)
57     {
58       log_error (_("OpenPGP card not available: %s\n"),
59                   gpg_strerror (rc));
60       return;
61     }
62   
63   log_info (_("OpenPGP card no. %s detected\n"),
64               info.serialno? info.serialno : "[none]");
65
66   agent_release_card_info (&info);
67
68   if (opt.batch)
69     {
70       log_error (_("can't do this in batch mode\n"));
71       return;
72     }
73
74   if(!allow_admin)
75     {
76       rc = agent_scd_change_pin (1);
77       if (rc)
78         tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
79       else
80         tty_printf ("PIN changed.\n");
81     }
82   else
83     for (;;)
84       {
85         char *answer;
86
87         tty_printf ("\n");
88         tty_printf ("1 - change PIN\n"
89                     "2 - unblock PIN\n"
90                     "3 - change Admin PIN\n"
91                     "Q - quit\n");
92         tty_printf ("\n");
93
94         answer = cpr_get("cardutil.change_pin.menu",_("Your selection? "));
95         cpr_kill_prompt();
96         if (strlen (answer) != 1)
97           continue;
98
99         rc = 0;
100         if (*answer == '1')
101           {
102             rc = agent_scd_change_pin (1);
103             if (rc)
104               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
105             else
106               tty_printf ("PIN changed.\n");
107           }
108         else if (*answer == '2')
109           {
110             rc = agent_scd_change_pin (101);
111             if (rc)
112               tty_printf ("Error unblocking the PIN: %s\n", gpg_strerror (rc));
113             else
114               tty_printf ("PIN unblocked and new PIN set.\n");
115           }
116         else if (*answer == '3')
117           {
118             rc = agent_scd_change_pin (3);
119             if (rc)
120               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
121             else
122               tty_printf ("PIN changed.\n");
123           }
124         else if (*answer == 'q' || *answer == 'Q')
125           {
126             break;
127           }
128       }
129 }
130
131 static const char *
132 get_manufacturer (unsigned int no)
133 {
134   /* Note:  Make sure that there is no colon or linefeed in the string. */
135   switch (no)
136     {
137     case 0:
138     case 0xffff: return "test card";
139     case 0x0001: return "PPC Card Systems";
140     default: return "unknown";
141     }
142 }
143
144
145 static void
146 print_sha1_fpr (FILE *fp, const unsigned char *fpr)
147 {
148   int i;
149
150   if (fpr)
151     {
152       for (i=0; i < 20 ; i+=2, fpr += 2 )
153         {
154           if (i == 10 )
155             tty_fprintf (fp, " ");
156           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
157         }
158     }
159   else
160     tty_fprintf (fp, " [none]");
161   tty_fprintf (fp, "\n");
162 }
163
164
165 static void
166 print_sha1_fpr_colon (FILE *fp, const unsigned char *fpr)
167 {
168   int i;
169
170   if (fpr)
171     {
172       for (i=0; i < 20 ; i++, fpr++)
173         fprintf (fp, "%02X", *fpr);
174     }
175   putc (':', fp);
176 }
177
178
179 static void
180 print_name (FILE *fp, const char *text, const char *name)
181 {
182   tty_fprintf (fp, "%s", text);
183
184   /* FIXME: tty_printf_utf8_string2 eats everything after and
185      including an @ - e.g. when printing an url. */
186   if (name && *name)
187     {
188       if (fp)
189         print_utf8_string2 (fp, name, strlen (name), '\n');
190       else
191         tty_print_utf8_string2 (name, strlen (name), 0);
192     }
193   else
194     tty_fprintf (fp, _("[not set]"));
195   tty_fprintf (fp, "\n");
196 }
197
198 static void
199 print_isoname (FILE *fp, const char *text, const char *tag, const char *name)
200 {
201   if (opt.with_colons)
202     fprintf (fp, "%s:", tag);
203   else
204     tty_fprintf (fp, "%s", text);
205
206   if (name && *name)
207     {
208       char *p, *given, *buf = xstrdup (name);
209
210       given = strstr (buf, "<<");
211       for (p=buf; *p; p++)
212         if (*p == '<')
213           *p = ' ';
214       if (given && given[2])
215         {
216           *given = 0;
217           given += 2;
218           if (opt.with_colons)
219             print_string (fp, given, strlen (given), ':');
220           else if (fp)
221             print_utf8_string2 (fp, given, strlen (given), '\n');
222           else
223             tty_print_utf8_string2 (given, strlen (given), 0);
224
225           if (opt.with_colons)
226             putc (':', fp);
227           else if (*buf)
228             tty_fprintf (fp, " ");
229         }
230
231       if (opt.with_colons)
232         print_string (fp, buf, strlen (buf), ':');
233       else if (fp)
234         print_utf8_string2 (fp, buf, strlen (buf), '\n');
235       else
236         tty_print_utf8_string2 (buf, strlen (buf), 0);
237       xfree (buf);
238     }
239   else
240     {
241       if (opt.with_colons)
242         putc (':', fp);
243       else
244         tty_fprintf (fp, _("[not set]"));
245     }
246
247   if (opt.with_colons)
248     fputs (":\n", fp);
249   else
250     tty_fprintf (fp, "\n");
251 }
252
253 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
254 static int
255 fpr_is_zero (const char *fpr)
256 {
257   int i;
258
259   for (i=0; i < 20 && !fpr[i]; i++)
260     ;
261   return (i == 20);
262 }
263
264
265 /* Print all available information about the current card. */
266 void
267 card_status (FILE *fp, char *serialno, size_t serialnobuflen)
268 {
269   struct agent_card_info_s info;
270   PKT_public_key *pk = xcalloc (1, sizeof *pk);
271   int rc;
272   unsigned int uval;
273   const unsigned char *thefpr;
274
275   if (serialno && serialnobuflen)
276     *serialno = 0;
277
278   rc = agent_learn (&info);
279   if (rc)
280     {
281       if (opt.with_colons)
282         fputs ("AID:::\n", fp);
283       log_error (_("OpenPGP card not available: %s\n"),
284                   gpg_strerror (rc));
285       xfree (pk);
286       return;
287     }
288
289   if (opt.with_colons)
290     fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
291   else
292     tty_fprintf (fp, "Application ID ...: %s\n",
293                  info.serialno? info.serialno : "[none]");
294   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12) 
295       || strlen (info.serialno) != 32 )
296     {
297       if (opt.with_colons)
298         fputs ("unknown:\n", fp);
299       log_info ("not an OpenPGP card\n");
300       agent_release_card_info (&info);
301       xfree (pk);
302       return;
303     }
304
305   if (!serialno)
306     ;
307   else if (strlen (serialno)+1 > serialnobuflen)
308     log_error ("serial number longer than expected\n");
309   else 
310     strcpy (serialno, info.serialno);
311
312   if (opt.with_colons)
313     fputs ("openpgp-card:\n", fp);
314
315
316   if (opt.with_colons)
317     {
318       fprintf (fp, "version:%.4s:\n", info.serialno+12);
319       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
320       fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
321       fprintf (fp, "serial:%.8s:\n", info.serialno+20);
322       
323       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
324
325       fputs ("lang:", fp);
326       if (info.disp_lang)
327         print_string (fp, info.disp_lang, strlen (info.disp_lang), ':');
328       fputs (":\n", fp);
329
330       fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
331                                  info.disp_sex == 2? 'f' : 'u'));
332
333       fputs ("url:", fp);
334       if (info.pubkey_url)
335         print_string (fp, info.pubkey_url, strlen (info.pubkey_url), ':');
336       fputs (":\n", fp);
337
338       fputs ("login:", fp);
339       if (info.login_data)
340         print_string (fp, info.login_data, strlen (info.login_data), ':');
341       fputs (":\n", fp);
342
343       fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
344       fprintf (fp, "maxpinlen:%d:%d:%d:\n",
345                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
346       fprintf (fp, "pinretry:%d:%d:%d:\n",
347                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
348       fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
349
350       fputs ("cafpr:", fp);
351       print_sha1_fpr_colon (fp, info.cafpr1valid? info.cafpr1:NULL);
352       print_sha1_fpr_colon (fp, info.cafpr2valid? info.cafpr2:NULL);
353       print_sha1_fpr_colon (fp, info.cafpr3valid? info.cafpr3:NULL);
354       putc ('\n', fp);
355       fputs ("fpr:", fp);
356       print_sha1_fpr_colon (fp, info.fpr1valid? info.fpr1:NULL);
357       print_sha1_fpr_colon (fp, info.fpr2valid? info.fpr2:NULL);
358       print_sha1_fpr_colon (fp, info.fpr3valid? info.fpr3:NULL);
359       putc ('\n', fp);
360       fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
361                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
362                (unsigned long)info.fpr3time);
363     }
364   else 
365     {
366       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
367                    info.serialno[12] == '0'?"":info.serialno+12,
368                    info.serialno[13],
369                    info.serialno[14] == '0'?"":info.serialno+14,
370                    info.serialno[15]);
371       tty_fprintf (fp, "Manufacturer .....: %s\n", 
372                    get_manufacturer (xtoi_2(info.serialno+16)*256
373                                      + xtoi_2 (info.serialno+18)));
374       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
375       
376       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
377       print_name (fp, "Language prefs ...: ", info.disp_lang);
378       tty_fprintf (fp,    "Sex ..............: %s\n",
379                    info.disp_sex == 1? _("male"):
380                    info.disp_sex == 2? _("female") : _("unspecified"));
381       print_name (fp, "URL of public key : ", info.pubkey_url);
382       print_name (fp, "Login data .......: ", info.login_data);
383       if (info.private_do[0])
384         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
385       if (info.private_do[1])
386         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
387       if (info.private_do[2])
388         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
389       if (info.private_do[3])
390         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
391       if (info.cafpr1valid)
392         {
393           tty_fprintf (fp, "CA fingerprint %d .:", 1);
394           print_sha1_fpr (fp, info.cafpr1);
395         }
396       if (info.cafpr2valid)
397         {
398           tty_fprintf (fp, "CA fingerprint %d .:", 2);
399           print_sha1_fpr (fp, info.cafpr2);
400         }
401       if (info.cafpr3valid)
402         {
403           tty_fprintf (fp, "CA fingerprint %d .:", 3);
404           print_sha1_fpr (fp, info.cafpr3);
405         }
406       tty_fprintf (fp,    "Signature PIN ....: %s\n",
407                    info.chv1_cached? _("not forced"): _("forced"));
408       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
409                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
410       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
411                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
412       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
413       tty_fprintf (fp, "Signature key ....:");
414       print_sha1_fpr (fp, info.fpr1valid? info.fpr1:NULL);
415       if (info.fpr1valid && info.fpr1time)
416         tty_fprintf (fp, "      created ....: %s\n",
417                      asctimestamp (info.fpr1time));
418       tty_fprintf (fp, "Encryption key....:");
419       print_sha1_fpr (fp, info.fpr2valid? info.fpr2:NULL);
420       if (info.fpr2valid && info.fpr2time)
421         tty_fprintf (fp, "      created ....: %s\n",
422                      asctimestamp (info.fpr2time));
423       tty_fprintf (fp, "Authentication key:");
424       print_sha1_fpr (fp, info.fpr3valid? info.fpr3:NULL);
425       if (info.fpr3valid && info.fpr3time)
426         tty_fprintf (fp, "      created ....: %s\n",
427                      asctimestamp (info.fpr3time));
428       tty_fprintf (fp, "General key info..: "); 
429
430       thefpr = (info.fpr1valid? info.fpr1 : info.fpr2valid? info.fpr2 : 
431                 info.fpr3valid? info.fpr3 : NULL);
432       if ( thefpr && !get_pubkey_byfprint (pk, thefpr, 20))
433         {
434           KBNODE keyblock = NULL;
435
436           print_pubkey_info (fp, pk);
437
438           if ( !get_seckeyblock_byfprint (&keyblock, thefpr, 20) )
439             print_card_key_info (fp, keyblock);
440           else if ( !get_keyblock_byfprint (&keyblock, thefpr, 20) )
441             {
442               release_kbnode (keyblock);
443               keyblock = NULL;
444               
445               if (!auto_create_card_key_stub (info.serialno,
446                                               info.fpr1valid? info.fpr1:NULL,
447                                               info.fpr2valid? info.fpr2:NULL,
448                                               info.fpr3valid? info.fpr3:NULL))
449                 {
450                   if ( !get_seckeyblock_byfprint (&keyblock, thefpr, 20) )
451                     print_card_key_info (fp, keyblock);
452                 }
453             }
454
455           release_kbnode (keyblock);
456         }
457       else
458         tty_fprintf (fp, "[none]\n");
459     }
460       
461   free_public_key (pk);
462   agent_release_card_info (&info);
463 }
464
465
466 static char *
467 get_one_name (const char *prompt1, const char *prompt2)
468 {
469   char *name;
470   int i;
471
472   for (;;)
473     {
474       name = cpr_get (prompt1, prompt2);
475       if (!name)
476         return NULL;
477       trim_spaces (name);
478       cpr_kill_prompt ();
479       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
480         ;
481
482       /* The name must be in Latin-1 and not UTF-8 - lacking the code
483          to ensure this we restrict it to ASCII. */
484       if (name[i])
485         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
486       else if (strchr (name, '<'))
487         tty_printf (_("Error: The \"<\" character may not be used.\n"));
488       else if (strstr (name, "  "))
489         tty_printf (_("Error: Double spaces are not allowed.\n"));    
490       else
491         return name;
492       xfree (name);
493     }
494 }
495
496
497
498 static int
499 change_name (void)
500 {
501   char *surname = NULL, *givenname = NULL;
502   char *isoname, *p;
503   int rc;
504
505   surname = get_one_name ("keygen.smartcard.surname",
506                                     _("Cardholder's surname: "));
507   givenname = get_one_name ("keygen.smartcard.givenname",
508                                        _("Cardholder's given name: "));
509   if (!surname || !givenname || (!*surname && !*givenname))
510     {
511       xfree (surname);
512       xfree (givenname);
513       return -1; /*canceled*/
514     }
515
516   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
517   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
518   xfree (surname);
519   xfree (givenname);
520   for (p=isoname; *p; p++)
521     if (*p == ' ')
522       *p = '<';
523
524   if (strlen (isoname) > 39 )
525     {
526       tty_printf (_("Error: Combined name too long "
527                     "(limit is %d characters).\n"), 39);    
528       xfree (isoname);
529       return -1;
530     }
531
532   log_debug ("setting Name to `%s'\n", isoname);
533   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname) );
534   if (rc)
535     log_error ("error setting Name: %s\n", gpg_strerror (rc));
536
537   xfree (isoname);
538   return rc;
539 }
540
541
542 static int
543 change_url (void)
544 {
545   char *url;
546   int rc;
547
548   url = cpr_get ("cardedit.change_url", _("URL to retrieve public key: "));
549   if (!url)
550     return -1;
551   trim_spaces (url);
552   cpr_kill_prompt ();
553
554   if (strlen (url) > 254 )
555     {
556       tty_printf (_("Error: URL too long "
557                     "(limit is %d characters).\n"), 254);    
558       xfree (url);
559       return -1;
560     }
561
562   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url) );
563   if (rc)
564     log_error ("error setting URL: %s\n", gpg_strerror (rc));
565   xfree (url);
566   return rc;
567 }
568
569
570 /* Fetch the key from the URL given on teh card or try to get it from
571    the default keyserver.  */
572 static int
573 fetch_url(void)
574 {
575 #if GNUPG_MAJOR_VERSION == 1
576   int rc;
577   struct agent_card_info_s info;
578
579   memset(&info,0,sizeof(info));
580
581   rc=agent_scd_getattr("PUBKEY-URL",&info);
582   if(rc)
583     log_error("error retrieving URL from card: %s\n",gpg_strerror(rc));
584   else
585     {
586       struct keyserver_spec *spec=NULL;
587
588       rc=agent_scd_getattr("KEY-FPR",&info);
589       if(rc)
590         log_error("error retrieving key fingerprint from card: %s\n",
591                   gpg_strerror(rc));
592       else if (info.pubkey_url && *info.pubkey_url)
593         {
594           spec=parse_keyserver_uri(info.pubkey_url,0,NULL,0);
595           if(spec && info.fpr1valid)
596             {
597               /* This is not perfectly right.  Currently, all card
598                  fingerprints are 20 digits, but what about
599                  fingerprints for a future v5 key?  We should get the
600                  length from somewhere lower in the code.  In any
601                  event, the fpr/keyid is not meaningful for straight
602                  HTTP fetches, but using it allows the card to point
603                  to HKP and LDAP servers as well. */
604               rc=keyserver_import_fprint(info.fpr1,20,spec);
605               free_keyserver_spec(spec);
606             }
607         }
608       else if (info.fpr1valid)
609         {
610           rc = keyserver_import_fprint (info.fpr1, 20, opt.keyserver);
611         }
612     }
613
614   return rc;
615 #else
616   return 0;
617 #endif
618 }
619
620
621 static int
622 change_login (const char *args)
623 {
624   char *data;
625   int n;
626   int rc;
627
628   if (args && *args == '<')  /* Read it from a file */
629     {
630       FILE *fp;
631
632       for (args++; spacep (args); args++)
633         ;
634       fp = fopen (args, "rb");
635 #if GNUPG_MAJOR_VERSION == 1
636       if (fp && is_secured_file (fileno (fp)))
637         {
638           fclose (fp);
639           fp = NULL;
640           errno = EPERM;
641         }
642 #endif
643       if (!fp)
644         {
645           tty_printf (_("can't open `%s': %s\n"), args, strerror (errno));
646           return -1;
647         }
648           
649       data = xmalloc (254);
650       n = fread (data, 1, 254, fp);
651       fclose (fp);
652       if (n < 0)
653         {
654           tty_printf (_("error reading `%s': %s\n"), args, strerror (errno));
655           xfree (data);
656           return -1;
657         }
658     }
659   else
660     {
661       data = cpr_get ("cardedit.change_login",
662                       _("Login data (account name): "));
663       if (!data)
664         return -1;
665       trim_spaces (data);
666       cpr_kill_prompt ();
667       n = strlen (data);
668     }
669
670   if (n > 254 )
671     {
672       tty_printf (_("Error: Login data too long "
673                     "(limit is %d characters).\n"), 254);    
674       xfree (data);
675       return -1;
676     }
677
678   rc = agent_scd_setattr ("LOGIN-DATA", data, n );
679   if (rc)
680     log_error ("error setting login data: %s\n", gpg_strerror (rc));
681   xfree (data);
682   return rc;
683 }
684
685 static int
686 change_private_do (const char *args, int nr)
687 {
688   char do_name[] = "PRIVATE-DO-X";
689   char *data;
690   int n;
691   int rc; 
692
693   assert (nr >= 1 && nr <= 4);
694   do_name[11] = '0' + nr;
695
696   if (args && (args = strchr (args, '<')))  /* Read it from a file */
697     {
698       FILE *fp;
699
700       /* Fixme: Factor this duplicated code out. */
701       for (args++; spacep (args); args++)
702         ;
703       fp = fopen (args, "rb");
704 #if GNUPG_MAJOR_VERSION == 1
705       if (fp && is_secured_file (fileno (fp)))
706         {
707           fclose (fp);
708           fp = NULL;
709           errno = EPERM;
710         }
711 #endif
712       if (!fp)
713         {
714           tty_printf (_("can't open `%s': %s\n"), args, strerror (errno));
715           return -1;
716         }
717           
718       data = xmalloc (254);
719       n = fread (data, 1, 254, fp);
720       fclose (fp);
721       if (n < 0)
722         {
723           tty_printf (_("error reading `%s': %s\n"), args, strerror (errno));
724           xfree (data);
725           return -1;
726         }
727     }
728   else
729     {
730       data = cpr_get ("cardedit.change_private_do",
731                       _("Private DO data: "));
732       if (!data)
733         return -1;
734       trim_spaces (data);
735       cpr_kill_prompt ();
736       n = strlen (data);
737     }
738
739   if (n > 254 )
740     {
741       tty_printf (_("Error: Private DO too long "
742                     "(limit is %d characters).\n"), 254);    
743       xfree (data);
744       return -1;
745     }
746
747   rc = agent_scd_setattr (do_name, data, n );
748   if (rc)
749     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
750   xfree (data);
751   return rc;
752 }
753
754 static int
755 change_lang (void)
756 {
757   char *data, *p;
758   int rc;
759
760   data = cpr_get ("cardedit.change_lang",
761                   _("Language preferences: "));
762   if (!data)
763     return -1;
764   trim_spaces (data);
765   cpr_kill_prompt ();
766
767   if (strlen (data) > 8 || (strlen (data) & 1))
768     {
769       tty_printf (_("Error: invalid length of preference string.\n"));
770       xfree (data);
771       return -1;
772     }
773
774   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
775     ;
776   if (*p)
777     {
778       tty_printf (_("Error: invalid characters in preference string.\n"));
779       xfree (data);
780       return -1;
781     }
782
783   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data) );
784   if (rc)
785     log_error ("error setting lang: %s\n", gpg_strerror (rc));
786   xfree (data);
787   return rc;
788 }
789
790
791 static int
792 change_sex (void)
793 {
794   char *data;
795   const char *str;
796   int rc;
797
798   data = cpr_get ("cardedit.change_sex",
799                   _("Sex ((M)ale, (F)emale or space): "));
800   if (!data)
801     return -1;
802   trim_spaces (data);
803   cpr_kill_prompt ();
804
805   if (!*data)
806     str = "9";
807   else if ((*data == 'M' || *data == 'm') && !data[1])
808     str = "1";
809   else if ((*data == 'F' || *data == 'f') && !data[1])
810     str = "2";
811   else 
812     {
813       tty_printf (_("Error: invalid response.\n"));
814       xfree (data);
815       return -1;
816     }
817      
818   rc = agent_scd_setattr ("DISP-SEX", str, 1 );
819   if (rc)
820     log_error ("error setting sex: %s\n", gpg_strerror (rc));
821   xfree (data);
822   return rc;
823 }
824
825
826 static int
827 change_cafpr (int fprno)
828 {
829   char *data;
830   const char *s;
831   int i, c, rc;
832   unsigned char fpr[20];
833
834   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
835   if (!data)
836     return -1;
837   trim_spaces (data);
838   cpr_kill_prompt ();
839
840   for (i=0, s=data; i < 20 && *s; )
841     {
842       while (spacep(s))
843         s++;
844       if (*s == ':')
845         s++;
846       while (spacep(s))
847         s++;
848       c = hextobyte (s);
849       if (c == -1)
850         break;
851       fpr[i++] = c;
852       s += 2;
853     }
854   xfree (data);
855   if (i != 20 || *s)
856     {
857       tty_printf (_("Error: invalid formatted fingerprint.\n"));
858       return -1;
859     }
860
861   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
862                           fprno==2?"CA-FPR-2":
863                           fprno==3?"CA-FPR-3":"x", fpr, 20 );
864   if (rc)
865     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
866   return rc;
867 }
868
869
870
871 static void
872 toggle_forcesig (void)
873 {
874   struct agent_card_info_s info;
875   int rc;
876   int newstate;
877
878   memset (&info, 0, sizeof info);
879   rc = agent_scd_getattr ("CHV-STATUS", &info);
880   if (rc)
881     {
882       log_error ("error getting current status: %s\n", gpg_strerror (rc));
883       return;
884     }
885   newstate = !info.chv1_cached;
886   agent_release_card_info (&info);
887
888   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1);
889   if (rc)
890     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
891 }
892
893
894 /* Helper for the key generation/edit functions.  */
895 static int
896 get_info_for_key_operation (struct agent_card_info_s *info)
897 {
898   int rc;
899
900   memset (info, 0, sizeof *info);
901   rc = agent_scd_getattr ("SERIALNO", info);
902   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12) 
903       || strlen (info->serialno) != 32 )
904     {
905       log_error (_("key operation not possible: %s\n"),
906                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
907       return rc? rc: -1;
908     }
909   rc = agent_scd_getattr ("KEY-FPR", info);
910   if (!rc)
911     rc = agent_scd_getattr ("CHV-STATUS", info);
912   if (!rc)
913     rc = agent_scd_getattr ("DISP-NAME", info);
914   if (rc)
915     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
916   return rc;
917 }
918
919
920 /* Helper for the key generation/edit functions.  */
921 static int
922 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
923 {     
924   int rc = 0;
925
926   *forced_chv1 = !info->chv1_cached;
927   if (*forced_chv1)
928     { /* Switch of the forced mode so that during key generation we
929          don't get bothered with PIN queries for each
930          self-signature. */
931       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1);
932       if (rc)
933         {
934           log_error ("error clearing forced signature PIN flag: %s\n",
935                      gpg_strerror (rc));
936           *forced_chv1 = 0;
937         }
938     }
939
940   if (!rc)
941     {
942       /* Check the PIN now, so that we won't get asked later for each
943          binding signature. */
944       rc = agent_scd_checkpin (info->serialno);
945       if (rc)
946         log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
947     }
948   return rc;
949 }
950
951 /* Helper for the key generation/edit functions.  */
952 static void 
953 restore_forced_chv1 (int *forced_chv1)
954 {
955   int rc;
956
957   if (*forced_chv1)
958     { /* Switch back to forced state. */
959       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1);
960       if (rc)
961         {
962           log_error ("error setting forced signature PIN flag: %s\n",
963                      gpg_strerror (rc));
964         }
965     }
966 }
967
968 #if GNUPG_MAJOR_VERSION == 1
969 /* Helper for the key generation/edit functions.  */
970 static void
971 show_card_key_info (struct agent_card_info_s *info)
972 {
973   tty_fprintf (NULL, "Signature key ....:");
974   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
975   tty_fprintf (NULL, "Encryption key....:");
976   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
977   tty_fprintf (NULL, "Authentication key:");
978   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
979   tty_printf ("\n");
980 }
981 #endif
982
983 #if GNUPG_MAJOR_VERSION == 1
984 /* Helper for the key generation/edit functions.  */
985 static int
986 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
987 {
988   assert (keyno >= 0 && keyno <= 3);
989
990   if ((keyno == 1 && info->fpr1valid)
991       || (keyno == 2 && info->fpr2valid)
992       || (keyno == 3 && info->fpr3valid))
993     {
994       tty_printf ("\n");
995       log_info ("WARNING: such a key has already been stored on the card!\n");
996       tty_printf ("\n");
997       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
998                                   _("Replace existing key? (y/N) ")))
999         return -1;
1000     }
1001   return 0;
1002 }
1003 #endif
1004
1005
1006 static void
1007 generate_card_keys (const char *serialno)
1008 {
1009   struct agent_card_info_s info;
1010   int forced_chv1;
1011   int want_backup;
1012
1013   if (get_info_for_key_operation (&info))
1014     return;
1015
1016 #if GNUPG_MAJOR_VERSION == 1
1017   {
1018     char *answer=cpr_get("cardedit.genkeys.backup_enc",
1019                          _("Make off-card backup of encryption key? (Y/n) "));
1020
1021     want_backup=answer_is_yes_no_default(answer,1);
1022     cpr_kill_prompt();
1023     m_free(answer);
1024   }
1025 #else
1026   want_backup = cpr_get_answer_is_yes 
1027                   ( "cardedit.genkeys.backup_enc",
1028                     _("Make off-card backup of encryption key? (Y/n) "));
1029   /*FIXME: we need answer_is_yes_no_default()*/
1030 #endif
1031
1032   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1033        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1034        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1035     {
1036       tty_printf ("\n");
1037       log_info ("NOTE: keys are already stored on the card!\n");
1038       tty_printf ("\n");
1039       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_keys",
1040                                   _("Replace existing keys? (y/N) ")))
1041         {
1042           agent_release_card_info (&info);
1043           return;
1044         }
1045     }
1046   else if (!info.disp_name || !*info.disp_name)
1047     {
1048       tty_printf ("\n");
1049       tty_printf (_("Please note that the factory settings of the PINs are\n"
1050                     "   PIN = `%s'     Admin PIN = `%s'\n"
1051                     "You should change them using the command --change-pin\n"),
1052                   "123456", "12345678");
1053       tty_printf ("\n");
1054     }
1055
1056   if (check_pin_for_key_operation (&info, &forced_chv1))
1057     goto leave;
1058   
1059 #if GNUPG_MAJOR_VERSION == 1
1060   generate_keypair (NULL, info.serialno,
1061                     want_backup? opt.homedir:NULL);
1062 #else
1063   generate_keypair (NULL, info.serialno);
1064 #endif
1065
1066  leave:
1067   agent_release_card_info (&info);
1068   restore_forced_chv1 (&forced_chv1);
1069 }
1070
1071
1072 /* This function is used by the key edit menu to generate an arbitrary
1073    subkey. */
1074 int
1075 card_generate_subkey (KBNODE pub_keyblock, KBNODE sec_keyblock)
1076 {
1077 #if GNUPG_MAJOR_VERSION == 1
1078   struct agent_card_info_s info;
1079   int okay = 0;
1080   int forced_chv1 = 0;
1081   int keyno;
1082
1083   if (get_info_for_key_operation (&info))
1084     return 0;
1085
1086   show_card_key_info (&info);
1087
1088   tty_printf (_("Please select the type of key to generate:\n"));
1089
1090   tty_printf (_("   (1) Signature key\n"));
1091   tty_printf (_("   (2) Encryption key\n"));
1092   tty_printf (_("   (3) Authentication key\n"));
1093
1094   for (;;) 
1095     {
1096       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1097                               _("Your selection? "));
1098       cpr_kill_prompt();
1099       if (*answer == CONTROL_D)
1100         {
1101           xfree (answer);
1102           goto leave;
1103         }
1104       keyno = *answer? atoi(answer): 0;
1105       xfree(answer);
1106       if (keyno >= 1 && keyno <= 3)
1107         break; /* Okay. */
1108       tty_printf(_("Invalid selection.\n"));
1109     }
1110
1111   if (replace_existing_key_p (&info, keyno))
1112     goto leave;
1113
1114   if (check_pin_for_key_operation (&info, &forced_chv1))
1115     goto leave;
1116
1117   okay = generate_card_subkeypair (pub_keyblock, sec_keyblock,
1118                                    keyno, info.serialno);
1119
1120  leave:
1121   agent_release_card_info (&info);
1122   restore_forced_chv1 (&forced_chv1);
1123   return okay;
1124 #else
1125   return 0;
1126 #endif
1127 }
1128
1129
1130 /* Store the key at NODE into the smartcard and modify NODE to
1131    carry the serialno stuff instead of the actual secret key
1132    parameters.  USE is the usage for that key; 0 means any
1133    usage. */
1134 int 
1135 card_store_subkey (KBNODE node, int use)
1136 {
1137 #if GNUPG_MAJOR_VERSION == 1
1138   struct agent_card_info_s info;
1139   int okay = 0;
1140   int rc;
1141   int keyno, i;
1142   PKT_secret_key *copied_sk = NULL;
1143   PKT_secret_key *sk;
1144   size_t n;
1145   const char *s;
1146   int allow_keyno[3];
1147
1148   assert (node->pkt->pkttype == PKT_SECRET_KEY
1149           || node->pkt->pkttype == PKT_SECRET_SUBKEY);
1150   sk = node->pkt->pkt.secret_key;
1151
1152   if (get_info_for_key_operation (&info))
1153     return 0;
1154
1155   show_card_key_info (&info);
1156
1157   if (!is_RSA (sk->pubkey_algo) || nbits_from_sk (sk) != 1024 )
1158     {
1159       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1160       tty_printf ("\n");
1161       goto leave;
1162     }
1163
1164   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG)));
1165   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1166   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1167
1168   tty_printf (_("Please select where to store the key:\n"));
1169
1170   if (allow_keyno[0])
1171     tty_printf (_("   (1) Signature key\n"));
1172   if (allow_keyno[1])
1173     tty_printf (_("   (2) Encryption key\n"));
1174   if (allow_keyno[2])
1175     tty_printf (_("   (3) Authentication key\n"));
1176
1177   for (;;) 
1178     {
1179       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1180                               _("Your selection? "));
1181       cpr_kill_prompt();
1182       if (*answer == CONTROL_D || !*answer)
1183         {
1184           xfree (answer);
1185           goto leave;
1186         }
1187       keyno = *answer? atoi(answer): 0;
1188       xfree(answer);
1189       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1190         break; /* Okay. */
1191       tty_printf(_("Invalid selection.\n"));
1192     }
1193
1194   if (replace_existing_key_p (&info, keyno))
1195     goto leave;
1196
1197   /* Unprotect key.  */
1198   switch (is_secret_key_protected (sk) )
1199     {
1200     case 0: /* Not protected. */
1201       break;
1202     case -1:
1203       log_error (_("unknown key protection algorithm\n"));
1204       goto leave;
1205     default:
1206       if (sk->protect.s2k.mode == 1001)
1207         {
1208           log_error (_("secret parts of key are not available\n"));
1209           goto leave;
1210         }
1211       if (sk->protect.s2k.mode == 1002)
1212         {
1213           log_error (_("secret key already stored on a card\n"));
1214           goto leave;
1215         }
1216       /* We better copy the key before we unprotect it.  */
1217       copied_sk = sk = copy_secret_key (NULL, sk);
1218       rc = check_secret_key (sk, 0);
1219       if (rc)
1220         goto leave;
1221     }
1222
1223   rc = save_unprotected_key_to_card (sk, keyno);
1224   if (rc)
1225     goto leave;
1226
1227   /* Get back to the maybe protected original secret key.  */
1228   if (copied_sk)
1229     {
1230       free_secret_key (copied_sk);
1231       copied_sk = NULL; 
1232     }
1233   sk = node->pkt->pkt.secret_key;
1234
1235   /* Get rid of the secret key parameters and store the serial numer. */
1236   n = pubkey_get_nskey (sk->pubkey_algo);
1237   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
1238     {
1239       mpi_free (sk->skey[i]);
1240       sk->skey[i] = NULL;
1241     }
1242   i = pubkey_get_npkey (sk->pubkey_algo);
1243   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
1244   sk->is_protected = 1;
1245   sk->protect.s2k.mode = 1002;
1246   s = info.serialno;
1247   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
1248        sk->protect.ivlen++, s += 2)
1249     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
1250
1251   okay = 1;
1252
1253  leave:
1254   if (copied_sk)
1255     free_secret_key (copied_sk);
1256   agent_release_card_info (&info);
1257   return okay;
1258 #else
1259   return 0;
1260 #endif
1261 }
1262
1263
1264 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1265    Key creation is not handled here. */
1266 void
1267 card_edit (STRLIST commands)
1268 {
1269   enum cmdids {
1270     cmdNOP = 0,
1271     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG,
1272     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1273     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO,
1274     cmdINVCMD
1275   };
1276
1277   static struct {
1278     const char *name;
1279     enum cmdids id;
1280     int admin_only;
1281     const char *desc;
1282   } cmds[] = {
1283     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1284     { "q"       , cmdQUIT  , 0, NULL },
1285     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1286     { "help"    , cmdHELP  , 0, N_("show this help")},
1287     { "?"       , cmdHELP  , 0, NULL },
1288     { "list"    , cmdLIST  , 0, N_("list all available data")},
1289     { "l"       , cmdLIST  , 0, NULL },
1290     { "debug"   , cmdDEBUG , 0, NULL },
1291     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1292     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1293     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1294     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1295     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1296     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1297     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1298     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1299     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1300     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1301     /* Note, that we do not announce this command yet. */
1302     { "privatedo", cmdPRIVATEDO, 0, NULL },
1303     { NULL, cmdINVCMD, 0, NULL } 
1304   };
1305  
1306   enum cmdids cmd = cmdNOP;
1307   int have_commands = !!commands;
1308   int redisplay = 1;
1309   char *answer = NULL;
1310   int did_checkpin = 0, allow_admin=0;
1311   char serialnobuf[50];
1312
1313
1314   if (opt.command_fd != -1)
1315     ;
1316   else if (opt.batch && !have_commands)
1317     {
1318       log_error(_("can't do this in batch mode\n"));
1319       goto leave;
1320     }
1321
1322   for (;;)
1323     {
1324       int arg_number;
1325       const char *arg_string = "";
1326       char *p;
1327       int i;
1328       int cmd_admin_only;
1329       
1330       tty_printf("\n");
1331       if (redisplay )
1332         {
1333           if (opt.with_colons)
1334             {
1335               card_status (stdout, serialnobuf, DIM (serialnobuf));
1336               fflush (stdout);
1337             }
1338           else
1339             {
1340               card_status (NULL, serialnobuf, DIM (serialnobuf));
1341               tty_printf("\n");
1342             }
1343           redisplay = 0;
1344         }
1345
1346       do
1347         {
1348           xfree (answer);
1349           if (have_commands)
1350             {
1351               if (commands)
1352                 {
1353                   answer = xstrdup (commands->d);
1354                   commands = commands->next;
1355                 }
1356               else if (opt.batch)
1357                 {
1358                   answer = xstrdup ("quit");
1359                 }
1360               else
1361                 have_commands = 0;
1362             }
1363
1364             if (!have_commands)
1365               {
1366                 answer = cpr_get_no_help("cardedit.prompt", _("Command> "));
1367                 cpr_kill_prompt();
1368             }
1369             trim_spaces(answer);
1370         }
1371       while ( *answer == '#' );
1372
1373       arg_number = 0; /* Yes, here is the init which egcc complains about */
1374       cmd_admin_only = 0;
1375       if (!*answer)
1376         cmd = cmdLIST; /* Default to the list command */
1377       else if (*answer == CONTROL_D)
1378         cmd = cmdQUIT;
1379       else 
1380         {
1381           if ((p=strchr (answer,' ')))
1382             {
1383               *p++ = 0;
1384               trim_spaces (answer);
1385               trim_spaces (p);
1386               arg_number = atoi(p);
1387               arg_string = p;
1388             }
1389           
1390           for (i=0; cmds[i].name; i++ )
1391             if (!ascii_strcasecmp (answer, cmds[i].name ))
1392               break;
1393
1394           cmd = cmds[i].id;
1395           cmd_admin_only = cmds[i].admin_only;
1396         }
1397
1398       if (!allow_admin && cmd_admin_only)
1399         {
1400           tty_printf ("\n");
1401           tty_printf (_("Admin-only command\n"));
1402           continue;
1403         }
1404
1405       switch (cmd)
1406         {
1407         case cmdHELP:
1408           for (i=0; cmds[i].name; i++ )
1409             if(cmds[i].desc
1410                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
1411               tty_printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
1412           break;
1413
1414         case cmdADMIN:
1415           allow_admin=!allow_admin;
1416           if(allow_admin)
1417             tty_printf(_("Admin commands are allowed\n"));
1418           else
1419             tty_printf(_("Admin commands are not allowed\n"));
1420           break;
1421
1422         case cmdLIST:
1423           redisplay = 1;
1424           break;
1425
1426         case cmdNAME:
1427           change_name ();
1428           break;
1429
1430         case cmdURL:
1431           change_url ();
1432           break;
1433
1434         case cmdFETCH:
1435           fetch_url();
1436           break;
1437
1438         case cmdLOGIN:
1439           change_login (arg_string);
1440           break;
1441
1442         case cmdLANG:
1443           change_lang ();
1444           break;
1445
1446         case cmdSEX:
1447           change_sex ();
1448           break;
1449
1450         case cmdCAFPR:
1451           if ( arg_number < 1 || arg_number > 3 )
1452             tty_printf ("usage: cafpr N\n"
1453                         "       1 <= N <= 3\n");
1454           else
1455             change_cafpr (arg_number);
1456           break;
1457
1458         case cmdPRIVATEDO:
1459           if ( arg_number < 1 || arg_number > 4 )
1460             tty_printf ("usage: privatedo N\n"
1461                         "       1 <= N <= 4\n");
1462           else
1463             change_private_do (arg_string, arg_number);
1464           break;
1465
1466         case cmdFORCESIG:
1467           toggle_forcesig ();
1468           break;
1469
1470         case cmdGENERATE:
1471           generate_card_keys (serialnobuf);
1472           break;
1473
1474         case cmdPASSWD:
1475           change_pin (0, allow_admin);
1476           did_checkpin = 0; /* Need to reset it of course. */
1477           break;
1478
1479         case cmdQUIT:
1480           goto leave;
1481
1482         case cmdNOP:
1483           break;
1484
1485         case cmdINVCMD:
1486         default:
1487           tty_printf ("\n");
1488           tty_printf (_("Invalid command  (try \"help\")\n"));
1489           break;
1490         } /* End command switch. */
1491     } /* End of main menu loop. */
1492
1493  leave:
1494   xfree (answer);
1495 }
1496