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