g10: Fix card-edit/fetch to use keyserver_fetch.
[gnupg.git] / g10 / card-util.c
1 /* card-util.c - Utility functions for the OpenPGP card.
2  * Copyright (C) 2003, 2004, 2005, 2009 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <assert.h>
26 #ifdef HAVE_LIBREADLINE
27 # define GNUPG_LIBREADLINE_H_INCLUDED
28 # include <readline/readline.h>
29 #endif /*HAVE_LIBREADLINE*/
30
31 #if GNUPG_MAJOR_VERSION != 1
32 # include "gpg.h"
33 #endif /*GNUPG_MAJOR_VERSION != 1*/
34 #include "util.h"
35 #include "i18n.h"
36 #include "ttyio.h"
37 #include "status.h"
38 #include "options.h"
39 #include "main.h"
40 #include "keyserver-internal.h"
41
42 #if GNUPG_MAJOR_VERSION == 1
43 # include "cardglue.h"
44 #else /*GNUPG_MAJOR_VERSION!=1*/
45 # include "call-agent.h"
46 #endif /*GNUPG_MAJOR_VERSION!=1*/
47
48 #define CONTROL_D ('D' - 'A' + 1)
49
50
51 static void
52 write_sc_op_status (gpg_error_t err)
53 {
54   switch (gpg_err_code (err))
55     {
56     case 0:
57       write_status (STATUS_SC_OP_SUCCESS);
58       break;
59 #if GNUPG_MAJOR_VERSION != 1
60     case GPG_ERR_CANCELED:
61       write_status_text (STATUS_SC_OP_FAILURE, "1");
62       break;
63     case GPG_ERR_BAD_PIN:
64       write_status_text (STATUS_SC_OP_FAILURE, "2");
65       break;
66     default:
67       write_status (STATUS_SC_OP_FAILURE);
68       break;
69 #endif /* GNUPG_MAJOR_VERSION != 1 */
70     }
71 }
72
73
74 /* Change the PIN of a an OpenPGP card.  This is an interactive
75    function. */
76 void
77 change_pin (int unblock_v2, int allow_admin)
78 {
79   struct agent_card_info_s info;
80   int rc;
81
82   rc = agent_learn (&info);
83   if (rc)
84     {
85       log_error (_("OpenPGP card not available: %s\n"),
86                   gpg_strerror (rc));
87       return;
88     }
89
90   log_info (_("OpenPGP card no. %s detected\n"),
91               info.serialno? info.serialno : "[none]");
92
93   agent_clear_pin_cache (info.serialno);
94
95   if (opt.batch)
96     {
97       agent_release_card_info (&info);
98       log_error (_("can't do this in batch mode\n"));
99       return;
100     }
101
102
103   if (unblock_v2)
104     {
105       if (!info.is_v2)
106         log_error (_("This command is only available for version 2 cards\n"));
107       else if (!info.chvretry[1])
108         log_error (_("Reset Code not or not anymore available\n"));
109       else
110         {
111           rc = agent_scd_change_pin (2, info.serialno);
112           write_sc_op_status (rc);
113           if (rc)
114             tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
115           else
116             tty_printf ("PIN changed.\n");
117         }
118     }
119   else if (!allow_admin)
120     {
121       rc = agent_scd_change_pin (1, info.serialno);
122       write_sc_op_status (rc);
123       if (rc)
124         tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
125       else
126         tty_printf ("PIN changed.\n");
127     }
128   else
129     for (;;)
130       {
131         char *answer;
132
133         tty_printf ("\n");
134         tty_printf ("1 - change PIN\n"
135                     "2 - unblock PIN\n"
136                     "3 - change Admin PIN\n"
137                     "4 - set the Reset Code\n"
138                     "Q - quit\n");
139         tty_printf ("\n");
140
141         answer = cpr_get("cardutil.change_pin.menu",_("Your selection? "));
142         cpr_kill_prompt();
143         if (strlen (answer) != 1)
144           continue;
145
146         rc = 0;
147         if (*answer == '1')
148           {
149             /* Change PIN.  */
150             rc = agent_scd_change_pin (1, info.serialno);
151             write_sc_op_status (rc);
152             if (rc)
153               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
154             else
155               tty_printf ("PIN changed.\n");
156           }
157         else if (*answer == '2')
158           {
159             /* Unblock PIN.  */
160             rc = agent_scd_change_pin (101, info.serialno);
161             write_sc_op_status (rc);
162             if (rc)
163               tty_printf ("Error unblocking the PIN: %s\n", gpg_strerror (rc));
164             else
165               tty_printf ("PIN unblocked and new PIN set.\n");
166           }
167         else if (*answer == '3')
168           {
169             /* Change Admin PIN.  */
170             rc = agent_scd_change_pin (3, info.serialno);
171             write_sc_op_status (rc);
172             if (rc)
173               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
174             else
175               tty_printf ("PIN changed.\n");
176           }
177         else if (*answer == '4')
178           {
179             /* Set a new Reset Code.  */
180             rc = agent_scd_change_pin (102, info.serialno);
181             write_sc_op_status (rc);
182             if (rc)
183               tty_printf ("Error setting the Reset Code: %s\n",
184                           gpg_strerror (rc));
185             else
186               tty_printf ("Reset Code set.\n");
187           }
188         else if (*answer == 'q' || *answer == 'Q')
189           {
190             break;
191           }
192       }
193
194   agent_release_card_info (&info);
195 }
196
197 static const char *
198 get_manufacturer (unsigned int no)
199 {
200   /* Note:  Make sure that there is no colon or linefeed in the string. */
201   switch (no)
202     {
203     case 0x0001: return "PPC Card Systems";
204     case 0x0002: return "Prism";
205     case 0x0003: return "OpenFortress";
206     case 0x0004: return "Wewid AB";
207     case 0x0005: return "ZeitControl";
208     case 0x0006: return "Yubico";
209
210     case 0x002A: return "Magrathea";
211
212     case 0xF517: return "FSIJ";
213
214       /* 0x00000 and 0xFFFF are defined as test cards per spec,
215          0xFFF00 to 0xFFFE are assigned for use with randomly created
216          serial numbers.  */
217     case 0x0000:
218     case 0xffff: return "test card";
219     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
220     }
221 }
222
223
224 static void
225 print_sha1_fpr (FILE *fp, const unsigned char *fpr)
226 {
227   int i;
228
229   if (fpr)
230     {
231       for (i=0; i < 20 ; i+=2, fpr += 2 )
232         {
233           if (i == 10 )
234             tty_fprintf (fp, " ");
235           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
236         }
237     }
238   else
239     tty_fprintf (fp, " [none]");
240   tty_fprintf (fp, "\n");
241 }
242
243
244 static void
245 print_sha1_fpr_colon (FILE *fp, const unsigned char *fpr)
246 {
247   int i;
248
249   if (fpr)
250     {
251       for (i=0; i < 20 ; i++, fpr++)
252         fprintf (fp, "%02X", *fpr);
253     }
254   putc (':', fp);
255 }
256
257
258 static void
259 print_name (FILE *fp, const char *text, const char *name)
260 {
261   tty_fprintf (fp, "%s", text);
262
263   /* FIXME: tty_printf_utf8_string2 eats everything after and
264      including an @ - e.g. when printing an url. */
265   if (name && *name)
266     {
267       if (fp)
268         print_utf8_string2 (fp, name, strlen (name), '\n');
269       else
270         tty_print_utf8_string2 (name, strlen (name), 0);
271     }
272   else
273     tty_fprintf (fp, _("[not set]"));
274   tty_fprintf (fp, "\n");
275 }
276
277 static void
278 print_isoname (FILE *fp, const char *text, const char *tag, const char *name)
279 {
280   if (opt.with_colons)
281     fprintf (fp, "%s:", tag);
282   else
283     tty_fprintf (fp, "%s", text);
284
285   if (name && *name)
286     {
287       char *p, *given, *buf = xstrdup (name);
288
289       given = strstr (buf, "<<");
290       for (p=buf; *p; p++)
291         if (*p == '<')
292           *p = ' ';
293       if (given && given[2])
294         {
295           *given = 0;
296           given += 2;
297           if (opt.with_colons)
298             print_string (fp, given, strlen (given), ':');
299           else if (fp)
300             print_utf8_string2 (fp, given, strlen (given), '\n');
301           else
302             tty_print_utf8_string2 (given, strlen (given), 0);
303
304           if (opt.with_colons)
305             putc (':', fp);
306           else if (*buf)
307             tty_fprintf (fp, " ");
308         }
309
310       if (opt.with_colons)
311         print_string (fp, buf, strlen (buf), ':');
312       else if (fp)
313         print_utf8_string2 (fp, buf, strlen (buf), '\n');
314       else
315         tty_print_utf8_string2 (buf, strlen (buf), 0);
316       xfree (buf);
317     }
318   else
319     {
320       if (opt.with_colons)
321         putc (':', fp);
322       else
323         tty_fprintf (fp, _("[not set]"));
324     }
325
326   if (opt.with_colons)
327     fputs (":\n", fp);
328   else
329     tty_fprintf (fp, "\n");
330 }
331
332 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
333 static int
334 fpr_is_zero (const char *fpr)
335 {
336   int i;
337
338   for (i=0; i < 20 && !fpr[i]; i++)
339     ;
340   return (i == 20);
341 }
342
343
344 /* Return true if the SHA1 fingerprint FPR consists only of 0xFF. */
345 static int
346 fpr_is_ff (const char *fpr)
347 {
348   int i;
349
350   for (i=0; i < 20 && fpr[i] == '\xff'; i++)
351     ;
352   return (i == 20);
353 }
354
355
356 /* Print all available information about the current card. */
357 void
358 card_status (FILE *fp, char *serialno, size_t serialnobuflen)
359 {
360   struct agent_card_info_s info;
361   PKT_public_key *pk = xcalloc (1, sizeof *pk);
362   int rc;
363   unsigned int uval;
364   const unsigned char *thefpr;
365   int i;
366
367   if (serialno && serialnobuflen)
368     *serialno = 0;
369
370   rc = agent_learn (&info);
371   if (rc)
372     {
373       if (opt.with_colons)
374         fputs ("AID:::\n", fp);
375       log_error (_("OpenPGP card not available: %s\n"),
376                   gpg_strerror (rc));
377       xfree (pk);
378       return;
379     }
380
381   if (opt.with_colons)
382     fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
383   else
384     tty_fprintf (fp, "Application ID ...: %s\n",
385                  info.serialno? info.serialno : "[none]");
386   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12)
387       || strlen (info.serialno) != 32 )
388     {
389       if (info.apptype && !strcmp (info.apptype, "NKS"))
390         {
391           if (opt.with_colons)
392             fputs ("netkey-card:\n", fp);
393           log_info ("this is a NetKey card\n");
394         }
395       else if (info.apptype && !strcmp (info.apptype, "DINSIG"))
396         {
397           if (opt.with_colons)
398             fputs ("dinsig-card:\n", fp);
399           log_info ("this is a DINSIG compliant card\n");
400         }
401       else if (info.apptype && !strcmp (info.apptype, "P15"))
402         {
403           if (opt.with_colons)
404             fputs ("pkcs15-card:\n", fp);
405           log_info ("this is a PKCS#15 compliant card\n");
406         }
407       else if (info.apptype && !strcmp (info.apptype, "GELDKARTE"))
408         {
409           if (opt.with_colons)
410             fputs ("geldkarte-card:\n", fp);
411           log_info ("this is a Geldkarte compliant card\n");
412         }
413       else
414         {
415           if (opt.with_colons)
416             fputs ("unknown:\n", fp);
417         }
418       log_info ("not an OpenPGP card\n");
419       agent_release_card_info (&info);
420       xfree (pk);
421       return;
422     }
423
424   if (!serialno)
425     ;
426   else if (strlen (serialno)+1 > serialnobuflen)
427     log_error ("serial number longer than expected\n");
428   else
429     strcpy (serialno, info.serialno);
430
431   if (opt.with_colons)
432     fputs ("openpgp-card:\n", fp);
433
434
435   if (opt.with_colons)
436     {
437       fprintf (fp, "version:%.4s:\n", info.serialno+12);
438       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
439       fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
440       fprintf (fp, "serial:%.8s:\n", info.serialno+20);
441
442       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
443
444       fputs ("lang:", fp);
445       if (info.disp_lang)
446         print_string (fp, info.disp_lang, strlen (info.disp_lang), ':');
447       fputs (":\n", fp);
448
449       fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
450                                  info.disp_sex == 2? 'f' : 'u'));
451
452       fputs ("url:", fp);
453       if (info.pubkey_url)
454         print_string (fp, info.pubkey_url, strlen (info.pubkey_url), ':');
455       fputs (":\n", fp);
456
457       fputs ("login:", fp);
458       if (info.login_data)
459         print_string (fp, info.login_data, strlen (info.login_data), ':');
460       fputs (":\n", fp);
461
462       fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
463       for (i=0; i < DIM (info.key_attr); i++)
464         if (info.key_attr[0].algo)
465           fprintf (fp, "keyattr:%d:%d:%u:\n", i+1,
466                    info.key_attr[i].algo, info.key_attr[i].nbits);
467       fprintf (fp, "maxpinlen:%d:%d:%d:\n",
468                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
469       fprintf (fp, "pinretry:%d:%d:%d:\n",
470                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
471       fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
472
473       for (i=0; i < 4; i++)
474         {
475           if (info.private_do[i])
476             {
477               fprintf (fp, "private_do:%d:", i+1);
478               print_string (fp, info.private_do[i],
479                             strlen (info.private_do[i]), ':');
480               fputs (":\n", fp);
481             }
482         }
483
484       fputs ("cafpr:", fp);
485       print_sha1_fpr_colon (fp, info.cafpr1valid? info.cafpr1:NULL);
486       print_sha1_fpr_colon (fp, info.cafpr2valid? info.cafpr2:NULL);
487       print_sha1_fpr_colon (fp, info.cafpr3valid? info.cafpr3:NULL);
488       putc ('\n', fp);
489       fputs ("fpr:", fp);
490       print_sha1_fpr_colon (fp, info.fpr1valid? info.fpr1:NULL);
491       print_sha1_fpr_colon (fp, info.fpr2valid? info.fpr2:NULL);
492       print_sha1_fpr_colon (fp, info.fpr3valid? info.fpr3:NULL);
493       putc ('\n', fp);
494       fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
495                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
496                (unsigned long)info.fpr3time);
497     }
498   else
499     {
500       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
501                    info.serialno[12] == '0'?"":info.serialno+12,
502                    info.serialno[13],
503                    info.serialno[14] == '0'?"":info.serialno+14,
504                    info.serialno[15]);
505       tty_fprintf (fp, "Manufacturer .....: %s\n",
506                    get_manufacturer (xtoi_2(info.serialno+16)*256
507                                      + xtoi_2 (info.serialno+18)));
508       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
509
510       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
511       print_name (fp, "Language prefs ...: ", info.disp_lang);
512       tty_fprintf (fp,    "Sex ..............: %s\n",
513                    info.disp_sex == 1? _("male"):
514                    info.disp_sex == 2? _("female") : _("unspecified"));
515       print_name (fp, "URL of public key : ", info.pubkey_url);
516       print_name (fp, "Login data .......: ", info.login_data);
517       if (info.private_do[0])
518         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
519       if (info.private_do[1])
520         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
521       if (info.private_do[2])
522         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
523       if (info.private_do[3])
524         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
525       if (info.cafpr1valid)
526         {
527           tty_fprintf (fp, "CA fingerprint %d .:", 1);
528           print_sha1_fpr (fp, info.cafpr1);
529         }
530       if (info.cafpr2valid)
531         {
532           tty_fprintf (fp, "CA fingerprint %d .:", 2);
533           print_sha1_fpr (fp, info.cafpr2);
534         }
535       if (info.cafpr3valid)
536         {
537           tty_fprintf (fp, "CA fingerprint %d .:", 3);
538           print_sha1_fpr (fp, info.cafpr3);
539         }
540       tty_fprintf (fp,    "Signature PIN ....: %s\n",
541                    info.chv1_cached? _("not forced"): _("forced"));
542       if (info.key_attr[0].algo)
543         {
544           tty_fprintf (fp,    "Key attributes ...:");
545           for (i=0; i < DIM (info.key_attr); i++)
546             tty_fprintf (fp, " %u%c",
547                          info.key_attr[i].nbits,
548                          info.key_attr[i].algo == 1? 'R':
549                          info.key_attr[i].algo == 17? 'D': '?');
550           tty_fprintf (fp, "\n");
551         }
552       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
553                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
554       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
555                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
556       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
557       tty_fprintf (fp, "Signature key ....:");
558       print_sha1_fpr (fp, info.fpr1valid? info.fpr1:NULL);
559       if (info.fpr1valid && info.fpr1time)
560         tty_fprintf (fp, "      created ....: %s\n",
561                      isotimestamp (info.fpr1time));
562       tty_fprintf (fp, "Encryption key....:");
563       print_sha1_fpr (fp, info.fpr2valid? info.fpr2:NULL);
564       if (info.fpr2valid && info.fpr2time)
565         tty_fprintf (fp, "      created ....: %s\n",
566                      isotimestamp (info.fpr2time));
567       tty_fprintf (fp, "Authentication key:");
568       print_sha1_fpr (fp, info.fpr3valid? info.fpr3:NULL);
569       if (info.fpr3valid && info.fpr3time)
570         tty_fprintf (fp, "      created ....: %s\n",
571                      isotimestamp (info.fpr3time));
572       tty_fprintf (fp, "General key info..: ");
573
574       thefpr = (info.fpr1valid? info.fpr1 : info.fpr2valid? info.fpr2 :
575                 info.fpr3valid? info.fpr3 : NULL);
576       /* If the fingerprint is all 0xff, the key has no asssociated
577          OpenPGP certificate.  */
578       if ( thefpr && !fpr_is_ff (thefpr)
579            && !get_pubkey_byfprint (pk, thefpr, 20))
580         {
581           KBNODE keyblock = NULL;
582
583           print_pubkey_info (fp, pk);
584
585           if ( !get_seckeyblock_byfprint (&keyblock, thefpr, 20) )
586             print_card_key_info (fp, keyblock);
587           else if ( !get_keyblock_byfprint (&keyblock, thefpr, 20) )
588             {
589               release_kbnode (keyblock);
590               keyblock = NULL;
591
592               if (!auto_create_card_key_stub (info.serialno,
593                                               info.fpr1valid? info.fpr1:NULL,
594                                               info.fpr2valid? info.fpr2:NULL,
595                                               info.fpr3valid? info.fpr3:NULL))
596                 {
597                   if ( !get_seckeyblock_byfprint (&keyblock, thefpr, 20) )
598                     print_card_key_info (fp, keyblock);
599                 }
600             }
601
602           release_kbnode (keyblock);
603         }
604       else
605         tty_fprintf (fp, "[none]\n");
606     }
607
608   free_public_key (pk);
609   agent_release_card_info (&info);
610 }
611
612
613 static char *
614 get_one_name (const char *prompt1, const char *prompt2)
615 {
616   char *name;
617   int i;
618
619   for (;;)
620     {
621       name = cpr_get (prompt1, prompt2);
622       if (!name)
623         return NULL;
624       trim_spaces (name);
625       cpr_kill_prompt ();
626       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
627         ;
628
629       /* The name must be in Latin-1 and not UTF-8 - lacking the code
630          to ensure this we restrict it to ASCII. */
631       if (name[i])
632         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
633       else if (strchr (name, '<'))
634         tty_printf (_("Error: The \"<\" character may not be used.\n"));
635       else if (strstr (name, "  "))
636         tty_printf (_("Error: Double spaces are not allowed.\n"));
637       else
638         return name;
639       xfree (name);
640     }
641 }
642
643
644
645 static int
646 change_name (void)
647 {
648   char *surname = NULL, *givenname = NULL;
649   char *isoname, *p;
650   int rc;
651
652   surname = get_one_name ("keygen.smartcard.surname",
653                                     _("Cardholder's surname: "));
654   givenname = get_one_name ("keygen.smartcard.givenname",
655                                        _("Cardholder's given name: "));
656   if (!surname || !givenname || (!*surname && !*givenname))
657     {
658       xfree (surname);
659       xfree (givenname);
660       return -1; /*canceled*/
661     }
662
663   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
664   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
665   xfree (surname);
666   xfree (givenname);
667   for (p=isoname; *p; p++)
668     if (*p == ' ')
669       *p = '<';
670
671   if (strlen (isoname) > 39 )
672     {
673       tty_printf (_("Error: Combined name too long "
674                     "(limit is %d characters).\n"), 39);
675       xfree (isoname);
676       return -1;
677     }
678
679   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname), NULL );
680   if (rc)
681     log_error ("error setting Name: %s\n", gpg_strerror (rc));
682
683   xfree (isoname);
684   return rc;
685 }
686
687
688 static int
689 change_url (void)
690 {
691   char *url;
692   int rc;
693
694   url = cpr_get ("cardedit.change_url", _("URL to retrieve public key: "));
695   if (!url)
696     return -1;
697   trim_spaces (url);
698   cpr_kill_prompt ();
699
700   if (strlen (url) > 254 )
701     {
702       tty_printf (_("Error: URL too long "
703                     "(limit is %d characters).\n"), 254);
704       xfree (url);
705       return -1;
706     }
707
708   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url), NULL );
709   if (rc)
710     log_error ("error setting URL: %s\n", gpg_strerror (rc));
711   xfree (url);
712   write_sc_op_status (rc);
713   return rc;
714 }
715
716
717 /* Fetch the key from the URL given on the card or try to get it from
718    the default keyserver.  */
719 static int
720 fetch_url(void)
721 {
722   int rc;
723   struct agent_card_info_s info;
724
725   memset(&info,0,sizeof(info));
726
727   rc=agent_scd_getattr("PUBKEY-URL",&info);
728   if(rc)
729     log_error("error retrieving URL from card: %s\n",gpg_strerror(rc));
730   else
731     {
732       rc=agent_scd_getattr("KEY-FPR",&info);
733       if(rc)
734         log_error("error retrieving key fingerprint from card: %s\n",
735                   gpg_strerror(rc));
736       else if (info.pubkey_url && *info.pubkey_url)
737         {
738           strlist_t sl = NULL;
739
740           add_to_strlist (&sl, info.pubkey_url);
741           rc = keyserver_fetch (sl);
742           free_strlist (sl);
743         }
744       else if (info.fpr1valid)
745         {
746           rc = keyserver_import_fprint (info.fpr1, 20, opt.keyserver);
747         }
748     }
749
750   return rc;
751 }
752
753
754 /* Read data from file FNAME up to MAXLEN characters.  On error return
755    -1 and store NULL at R_BUFFER; on success return the number of
756    bytes read and store the address of a newly allocated buffer at
757    R_BUFFER. */
758 static int
759 get_data_from_file (const char *fname, size_t maxlen, char **r_buffer)
760 {
761   FILE *fp;
762   char *data;
763   int n;
764
765   *r_buffer = NULL;
766
767   fp = fopen (fname, "rb");
768 #if GNUPG_MAJOR_VERSION == 1
769   if (fp && is_secured_file (fileno (fp)))
770     {
771       fclose (fp);
772       fp = NULL;
773       errno = EPERM;
774     }
775 #endif
776   if (!fp)
777     {
778       tty_printf (_("can't open `%s': %s\n"), fname, strerror (errno));
779       return -1;
780     }
781
782   data = xtrymalloc (maxlen? maxlen:1);
783   if (!data)
784     {
785       tty_printf (_("error allocating enough memory: %s\n"), strerror (errno));
786       fclose (fp);
787       return -1;
788     }
789
790   if (maxlen)
791     n = fread (data, 1, maxlen, fp);
792   else
793     n = 0;
794   fclose (fp);
795   if (n < 0)
796     {
797       tty_printf (_("error reading `%s': %s\n"), fname, strerror (errno));
798       xfree (data);
799       return -1;
800     }
801   *r_buffer = data;
802   return n;
803 }
804
805
806 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
807    success.  */
808 static int
809 put_data_to_file (const char *fname, const void *buffer, size_t length)
810 {
811   FILE *fp;
812
813   fp = fopen (fname, "wb");
814 #if GNUPG_MAJOR_VERSION == 1
815   if (fp && is_secured_file (fileno (fp)))
816     {
817       fclose (fp);
818       fp = NULL;
819       errno = EPERM;
820     }
821 #endif
822   if (!fp)
823     {
824       tty_printf (_("can't create `%s': %s\n"), fname, strerror (errno));
825       return -1;
826     }
827
828   if (length && fwrite (buffer, length, 1, fp) != 1)
829     {
830       tty_printf (_("error writing `%s': %s\n"), fname, strerror (errno));
831       fclose (fp);
832       return -1;
833     }
834   fclose (fp);
835   return 0;
836 }
837
838
839 static int
840 change_login (const char *args)
841 {
842   char *data;
843   int n;
844   int rc;
845
846   if (args && *args == '<')  /* Read it from a file */
847     {
848       for (args++; spacep (args); args++)
849         ;
850       n = get_data_from_file (args, 254, &data);
851       if (n < 0)
852         return -1;
853     }
854   else
855     {
856       data = cpr_get ("cardedit.change_login",
857                       _("Login data (account name): "));
858       if (!data)
859         return -1;
860       trim_spaces (data);
861       cpr_kill_prompt ();
862       n = strlen (data);
863     }
864
865   if (n > 254 )
866     {
867       tty_printf (_("Error: Login data too long "
868                     "(limit is %d characters).\n"), 254);
869       xfree (data);
870       return -1;
871     }
872
873   rc = agent_scd_setattr ("LOGIN-DATA", data, n, NULL );
874   if (rc)
875     log_error ("error setting login data: %s\n", gpg_strerror (rc));
876   xfree (data);
877   write_sc_op_status (rc);
878   return rc;
879 }
880
881 static int
882 change_private_do (const char *args, int nr)
883 {
884   char do_name[] = "PRIVATE-DO-X";
885   char *data;
886   int n;
887   int rc;
888
889   assert (nr >= 1 && nr <= 4);
890   do_name[11] = '0' + nr;
891
892   if (args && (args = strchr (args, '<')))  /* Read it from a file */
893     {
894       for (args++; spacep (args); args++)
895         ;
896       n = get_data_from_file (args, 254, &data);
897       if (n < 0)
898         return -1;
899     }
900   else
901     {
902       data = cpr_get ("cardedit.change_private_do",
903                       _("Private DO data: "));
904       if (!data)
905         return -1;
906       trim_spaces (data);
907       cpr_kill_prompt ();
908       n = strlen (data);
909     }
910
911   if (n > 254 )
912     {
913       tty_printf (_("Error: Private DO too long "
914                     "(limit is %d characters).\n"), 254);
915       xfree (data);
916       return -1;
917     }
918
919   rc = agent_scd_setattr (do_name, data, n, NULL );
920   if (rc)
921     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
922   xfree (data);
923   write_sc_op_status (rc);
924   return rc;
925 }
926
927
928 static int
929 change_cert (const char *args)
930 {
931   char *data;
932   int n;
933   int rc;
934
935   if (args && *args == '<')  /* Read it from a file */
936     {
937       for (args++; spacep (args); args++)
938         ;
939       n = get_data_from_file (args, 16384, &data);
940       if (n < 0)
941         return -1;
942     }
943   else
944     {
945       tty_printf ("usage error: redirection to file required\n");
946       return -1;
947     }
948
949   rc = agent_scd_writecert ("OPENPGP.3", data, n);
950   if (rc)
951     log_error ("error writing certificate to card: %s\n", gpg_strerror (rc));
952   xfree (data);
953   write_sc_op_status (rc);
954   return rc;
955 }
956
957
958 static int
959 read_cert (const char *args)
960 {
961   const char *fname;
962   void *buffer;
963   size_t length;
964   int rc;
965
966   if (args && *args == '>')  /* Write it to a file */
967     {
968       for (args++; spacep (args); args++)
969         ;
970       fname = args;
971     }
972   else
973     {
974       tty_printf ("usage error: redirection to file required\n");
975       return -1;
976     }
977
978   rc = agent_scd_readcert ("OPENPGP.3", &buffer, &length);
979   if (rc)
980     log_error ("error reading certificate from card: %s\n", gpg_strerror (rc));
981   else
982     rc = put_data_to_file (fname, buffer, length);
983   xfree (buffer);
984   write_sc_op_status (rc);
985   return rc;
986 }
987
988
989 static int
990 change_lang (void)
991 {
992   char *data, *p;
993   int rc;
994
995   data = cpr_get ("cardedit.change_lang",
996                   _("Language preferences: "));
997   if (!data)
998     return -1;
999   trim_spaces (data);
1000   cpr_kill_prompt ();
1001
1002   if (strlen (data) > 8 || (strlen (data) & 1))
1003     {
1004       tty_printf (_("Error: invalid length of preference string.\n"));
1005       xfree (data);
1006       return -1;
1007     }
1008
1009   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1010     ;
1011   if (*p)
1012     {
1013       tty_printf (_("Error: invalid characters in preference string.\n"));
1014       xfree (data);
1015       return -1;
1016     }
1017
1018   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data), NULL );
1019   if (rc)
1020     log_error ("error setting lang: %s\n", gpg_strerror (rc));
1021   xfree (data);
1022   write_sc_op_status (rc);
1023   return rc;
1024 }
1025
1026
1027 static int
1028 change_sex (void)
1029 {
1030   char *data;
1031   const char *str;
1032   int rc;
1033
1034   data = cpr_get ("cardedit.change_sex",
1035                   _("Sex ((M)ale, (F)emale or space): "));
1036   if (!data)
1037     return -1;
1038   trim_spaces (data);
1039   cpr_kill_prompt ();
1040
1041   if (!*data)
1042     str = "9";
1043   else if ((*data == 'M' || *data == 'm') && !data[1])
1044     str = "1";
1045   else if ((*data == 'F' || *data == 'f') && !data[1])
1046     str = "2";
1047   else
1048     {
1049       tty_printf (_("Error: invalid response.\n"));
1050       xfree (data);
1051       return -1;
1052     }
1053
1054   rc = agent_scd_setattr ("DISP-SEX", str, 1, NULL );
1055   if (rc)
1056     log_error ("error setting sex: %s\n", gpg_strerror (rc));
1057   xfree (data);
1058   write_sc_op_status (rc);
1059   return rc;
1060 }
1061
1062
1063 static int
1064 change_cafpr (int fprno)
1065 {
1066   char *data;
1067   const char *s;
1068   int i, c, rc;
1069   unsigned char fpr[20];
1070
1071   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1072   if (!data)
1073     return -1;
1074   trim_spaces (data);
1075   cpr_kill_prompt ();
1076
1077   for (i=0, s=data; i < 20 && *s; )
1078     {
1079       while (spacep(s))
1080         s++;
1081       if (*s == ':')
1082         s++;
1083       while (spacep(s))
1084         s++;
1085       c = hextobyte (s);
1086       if (c == -1)
1087         break;
1088       fpr[i++] = c;
1089       s += 2;
1090     }
1091   xfree (data);
1092   if (i != 20 || *s)
1093     {
1094       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1095       return -1;
1096     }
1097
1098   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1099                           fprno==2?"CA-FPR-2":
1100                           fprno==3?"CA-FPR-3":"x", fpr, 20, NULL );
1101   if (rc)
1102     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1103   write_sc_op_status (rc);
1104   return rc;
1105 }
1106
1107
1108
1109 static void
1110 toggle_forcesig (void)
1111 {
1112   struct agent_card_info_s info;
1113   int rc;
1114   int newstate;
1115
1116   memset (&info, 0, sizeof info);
1117   rc = agent_scd_getattr ("CHV-STATUS", &info);
1118   if (rc)
1119     {
1120       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1121       return;
1122     }
1123   newstate = !info.chv1_cached;
1124   agent_release_card_info (&info);
1125
1126   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1127   if (rc)
1128     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1129   write_sc_op_status (rc);
1130 }
1131
1132
1133 /* Helper for the key generation/edit functions.  */
1134 static int
1135 get_info_for_key_operation (struct agent_card_info_s *info)
1136 {
1137   int rc;
1138
1139   memset (info, 0, sizeof *info);
1140   rc = agent_scd_getattr ("SERIALNO", info);
1141   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1142       || strlen (info->serialno) != 32 )
1143     {
1144       log_error (_("key operation not possible: %s\n"),
1145                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1146       return rc? rc: -1;
1147     }
1148   rc = agent_scd_getattr ("KEY-FPR", info);
1149   if (!rc)
1150     rc = agent_scd_getattr ("CHV-STATUS", info);
1151   if (!rc)
1152     rc = agent_scd_getattr ("DISP-NAME", info);
1153   if (!rc)
1154     rc = agent_scd_getattr ("EXTCAP", info);
1155   if (!rc)
1156     rc = agent_scd_getattr ("KEY-ATTR", info);
1157   if (rc)
1158     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1159   return rc;
1160 }
1161
1162
1163 /* Helper for the key generation/edit functions.  */
1164 static int
1165 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1166 {
1167   int rc = 0;
1168
1169   agent_clear_pin_cache (info->serialno);
1170
1171   *forced_chv1 = !info->chv1_cached;
1172   if (*forced_chv1)
1173     { /* Switch off the forced mode so that during key generation we
1174          don't get bothered with PIN queries for each
1175          self-signature. */
1176       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1177       if (rc)
1178         {
1179           log_error ("error clearing forced signature PIN flag: %s\n",
1180                      gpg_strerror (rc));
1181           *forced_chv1 = 0;
1182         }
1183     }
1184
1185   if (!rc)
1186     {
1187       /* Check the PIN now, so that we won't get asked later for each
1188          binding signature. */
1189       rc = agent_scd_checkpin (info->serialno);
1190       if (rc)
1191         {
1192           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1193           write_sc_op_status (rc);
1194         }
1195   }
1196   return rc;
1197 }
1198
1199 /* Helper for the key generation/edit functions.  */
1200 static void
1201 restore_forced_chv1 (int *forced_chv1)
1202 {
1203   int rc;
1204
1205   if (*forced_chv1)
1206     { /* Switch back to forced state. */
1207       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1208       if (rc)
1209         {
1210           log_error ("error setting forced signature PIN flag: %s\n",
1211                      gpg_strerror (rc));
1212         }
1213     }
1214 }
1215
1216
1217 /* Helper for the key generation/edit functions.  */
1218 static void
1219 show_card_key_info (struct agent_card_info_s *info)
1220 {
1221   tty_fprintf (NULL, "Signature key ....:");
1222   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
1223   tty_fprintf (NULL, "Encryption key....:");
1224   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
1225   tty_fprintf (NULL, "Authentication key:");
1226   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
1227   tty_printf ("\n");
1228 }
1229
1230
1231 /* Helper for the key generation/edit functions.  */
1232 static int
1233 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1234 {
1235   assert (keyno >= 0 && keyno <= 3);
1236
1237   if ((keyno == 1 && info->fpr1valid)
1238       || (keyno == 2 && info->fpr2valid)
1239       || (keyno == 3 && info->fpr3valid))
1240     {
1241       tty_printf ("\n");
1242       log_info ("WARNING: such a key has already been stored on the card!\n");
1243       tty_printf ("\n");
1244       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1245                                   _("Replace existing key? (y/N) ")))
1246         return -1;
1247     }
1248   return 0;
1249 }
1250
1251
1252 static void
1253 show_keysize_warning (void)
1254 {
1255   static int shown;
1256
1257   if (shown)
1258     return;
1259   shown = 1;
1260   tty_printf
1261     (_("NOTE: There is no guarantee that the card "
1262        "supports the requested size.\n"
1263        "      If the key generation does not succeed, "
1264        "please check the\n"
1265        "      documentation of your card to see what "
1266        "sizes are allowed.\n"));
1267 }
1268
1269
1270 /* Ask for the size of a card key.  NBITS is the current size
1271    configured for the card.  KEYNO is the number of the key used to
1272    select the prompt.  Returns 0 to use the default size (i.e. NBITS)
1273    or the selected size.  */
1274 static unsigned int
1275 ask_card_keysize (int keyno, unsigned int nbits)
1276 {
1277   unsigned int min_nbits = 1024;
1278   unsigned int max_nbits = 4096;
1279   char *prompt, *answer;
1280   unsigned int req_nbits;
1281
1282   for (;;)
1283     {
1284       prompt = xasprintf
1285         (keyno == 0?
1286          _("What keysize do you want for the Signature key? (%u) "):
1287          keyno == 1?
1288          _("What keysize do you want for the Encryption key? (%u) "):
1289          _("What keysize do you want for the Authentication key? (%u) "),
1290          nbits);
1291       answer = cpr_get ("cardedit.genkeys.size", prompt);
1292       cpr_kill_prompt ();
1293       req_nbits = *answer? atoi (answer): nbits;
1294       xfree (prompt);
1295       xfree (answer);
1296
1297       if (req_nbits != nbits && (req_nbits % 32) )
1298         {
1299           req_nbits = ((req_nbits + 31) / 32) * 32;
1300           tty_printf (_("rounded up to %u bits\n"), req_nbits);
1301         }
1302
1303       if (req_nbits == nbits)
1304         return 0;  /* Use default.  */
1305
1306       if (req_nbits < min_nbits || req_nbits > max_nbits)
1307         {
1308           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1309                       "RSA", min_nbits, max_nbits);
1310         }
1311       else
1312         {
1313           tty_printf (_("The card will now be re-configured "
1314                         "to generate a key of %u bits\n"), req_nbits);
1315           show_keysize_warning ();
1316           return req_nbits;
1317         }
1318     }
1319 }
1320
1321
1322 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1323    message if that fails.  */
1324 static gpg_error_t
1325 do_change_keysize (int keyno, unsigned int nbits)
1326 {
1327   gpg_error_t err;
1328   char args[100];
1329
1330   snprintf (args, sizeof args, "--force %d 1 %u", keyno+1, nbits);
1331   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1332   if (err)
1333     log_error (_("error changing size of key %d to %u bits: %s\n"),
1334                keyno+1, nbits, gpg_strerror (err));
1335   return err;
1336 }
1337
1338
1339 static void
1340 generate_card_keys (void)
1341 {
1342   struct agent_card_info_s info;
1343   int forced_chv1;
1344   int want_backup;
1345   int keyno;
1346
1347   if (get_info_for_key_operation (&info))
1348     return;
1349
1350   if (info.extcap.ki)
1351     {
1352       char *answer;
1353
1354       answer = cpr_get ("cardedit.genkeys.backup_enc",
1355                         _("Make off-card backup of encryption key? (Y/n) "));
1356
1357       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1358       cpr_kill_prompt ();
1359       xfree (answer);
1360     }
1361   else
1362     want_backup = 0;
1363
1364   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1365        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1366        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1367     {
1368       tty_printf ("\n");
1369       log_info (_("NOTE: keys are already stored on the card!\n"));
1370       tty_printf ("\n");
1371       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1372                                    _("Replace existing keys? (y/N) ")))
1373         {
1374           agent_release_card_info (&info);
1375           return;
1376         }
1377     }
1378
1379   /* If no displayed name has been set, we assume that this is a fresh
1380      card and print a hint about the default PINs.  */
1381   if (!info.disp_name || !*info.disp_name)
1382     {
1383       tty_printf ("\n");
1384       tty_printf (_("Please note that the factory settings of the PINs are\n"
1385                     "   PIN = `%s'     Admin PIN = `%s'\n"
1386                     "You should change them using the command --change-pin\n"),
1387                   "123456", "12345678");
1388       tty_printf ("\n");
1389     }
1390
1391   if (check_pin_for_key_operation (&info, &forced_chv1))
1392     goto leave;
1393
1394   /* If the cards features changeable key attributes, we ask for the
1395      key size.  */
1396   if (info.is_v2 && info.extcap.aac)
1397     {
1398       unsigned int nbits;
1399
1400       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1401         {
1402           nbits = ask_card_keysize (keyno, info.key_attr[keyno].nbits);
1403           if (nbits && do_change_keysize (keyno, nbits))
1404             {
1405               /* Error: Better read the default key size again.  */
1406               agent_release_card_info (&info);
1407               if (get_info_for_key_operation (&info))
1408                 goto leave;
1409               /* Ask again for this key size. */
1410               keyno--;
1411             }
1412         }
1413       /* Note that INFO has not be synced.  However we will only use
1414          the serialnumber and thus it won't harm.  */
1415     }
1416
1417   generate_keypair (NULL, info.serialno, want_backup? opt.homedir:NULL);
1418
1419  leave:
1420   agent_release_card_info (&info);
1421   restore_forced_chv1 (&forced_chv1);
1422 }
1423
1424
1425 /* This function is used by the key edit menu to generate an arbitrary
1426    subkey. */
1427 int
1428 card_generate_subkey (KBNODE pub_keyblock, KBNODE sec_keyblock)
1429 {
1430   struct agent_card_info_s info;
1431   int okay = 0;
1432   int forced_chv1 = 0;
1433   int keyno;
1434
1435   if (get_info_for_key_operation (&info))
1436     return 0;
1437
1438   show_card_key_info (&info);
1439
1440   tty_printf (_("Please select the type of key to generate:\n"));
1441
1442   tty_printf (_("   (1) Signature key\n"));
1443   tty_printf (_("   (2) Encryption key\n"));
1444   tty_printf (_("   (3) Authentication key\n"));
1445
1446   for (;;)
1447     {
1448       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1449                               _("Your selection? "));
1450       cpr_kill_prompt();
1451       if (*answer == CONTROL_D)
1452         {
1453           xfree (answer);
1454           goto leave;
1455         }
1456       keyno = *answer? atoi(answer): 0;
1457       xfree(answer);
1458       if (keyno >= 1 && keyno <= 3)
1459         break; /* Okay. */
1460       tty_printf(_("Invalid selection.\n"));
1461     }
1462
1463   if (replace_existing_key_p (&info, keyno))
1464     goto leave;
1465
1466   if (check_pin_for_key_operation (&info, &forced_chv1))
1467     goto leave;
1468
1469   /* If the cards features changeable key attributes, we ask for the
1470      key size.  */
1471   if (info.is_v2 && info.extcap.aac)
1472     {
1473       unsigned int nbits;
1474
1475     ask_again:
1476       nbits = ask_card_keysize (keyno-1, info.key_attr[keyno-1].nbits);
1477       if (nbits && do_change_keysize (keyno-1, nbits))
1478         {
1479           /* Error: Better read the default key size again.  */
1480           agent_release_card_info (&info);
1481           if (get_info_for_key_operation (&info))
1482             goto leave;
1483           goto ask_again;
1484         }
1485       /* Note that INFO has not be synced.  However we will only use
1486          the serialnumber and thus it won't harm.  */
1487     }
1488
1489   okay = generate_card_subkeypair (pub_keyblock, sec_keyblock,
1490                                    keyno, info.serialno);
1491
1492  leave:
1493   agent_release_card_info (&info);
1494   restore_forced_chv1 (&forced_chv1);
1495   return okay;
1496 }
1497
1498
1499 /* Store the key at NODE into the smartcard and modify NODE to
1500    carry the serialno stuff instead of the actual secret key
1501    parameters.  USE is the usage for that key; 0 means any
1502    usage. */
1503 int
1504 card_store_subkey (KBNODE node, int use)
1505 {
1506   struct agent_card_info_s info;
1507   int okay = 0;
1508   int rc;
1509   int keyno, i;
1510   PKT_secret_key *copied_sk = NULL;
1511   PKT_secret_key *sk;
1512   size_t n;
1513   const char *s;
1514   int allow_keyno[3];
1515   unsigned int nbits;
1516
1517
1518   assert (node->pkt->pkttype == PKT_SECRET_KEY
1519           || node->pkt->pkttype == PKT_SECRET_SUBKEY);
1520   sk = node->pkt->pkt.secret_key;
1521
1522   if (get_info_for_key_operation (&info))
1523     return 0;
1524
1525   if (!info.extcap.ki)
1526     {
1527       tty_printf ("The card does not support the import of keys\n");
1528       tty_printf ("\n");
1529       goto leave;
1530     }
1531
1532   show_card_key_info (&info);
1533
1534   nbits = nbits_from_sk (sk);
1535
1536   if (!is_RSA (sk->pubkey_algo) || (!info.is_v2 && nbits != 1024) )
1537     {
1538       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1539       tty_printf ("\n");
1540       goto leave;
1541     }
1542
1543   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1544   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1545   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1546
1547   tty_printf (_("Please select where to store the key:\n"));
1548
1549   if (allow_keyno[0])
1550     tty_printf (_("   (1) Signature key\n"));
1551   if (allow_keyno[1])
1552     tty_printf (_("   (2) Encryption key\n"));
1553   if (allow_keyno[2])
1554     tty_printf (_("   (3) Authentication key\n"));
1555
1556   for (;;)
1557     {
1558       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1559                               _("Your selection? "));
1560       cpr_kill_prompt();
1561       if (*answer == CONTROL_D || !*answer)
1562         {
1563           xfree (answer);
1564           goto leave;
1565         }
1566       keyno = *answer? atoi(answer): 0;
1567       xfree(answer);
1568       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1569         {
1570           if (info.is_v2 && !info.extcap.aac
1571               && info.key_attr[keyno-1].nbits != nbits)
1572             {
1573               tty_printf ("Key does not match the card's capability.\n");
1574             }
1575           else
1576             break; /* Okay. */
1577         }
1578       else
1579         tty_printf(_("Invalid selection.\n"));
1580     }
1581
1582   if (replace_existing_key_p (&info, keyno))
1583     goto leave;
1584
1585   /* Unprotect key.  */
1586   switch (is_secret_key_protected (sk) )
1587     {
1588     case 0: /* Not protected. */
1589       break;
1590     case -1:
1591       log_error (_("unknown key protection algorithm\n"));
1592       goto leave;
1593     default:
1594       if (sk->protect.s2k.mode == 1001)
1595         {
1596           log_error (_("secret parts of key are not available\n"));
1597           goto leave;
1598         }
1599       if (sk->protect.s2k.mode == 1002)
1600         {
1601           log_error (_("secret key already stored on a card\n"));
1602           goto leave;
1603         }
1604       /* We better copy the key before we unprotect it.  */
1605       copied_sk = sk = copy_secret_key (NULL, sk);
1606       rc = check_secret_key (sk, 0);
1607       if (rc)
1608         goto leave;
1609     }
1610
1611   rc = save_unprotected_key_to_card (sk, keyno);
1612   if (rc)
1613     {
1614       log_error (_("error writing key to card: %s\n"), gpg_strerror (rc));
1615       goto leave;
1616     }
1617
1618   /* Get back to the maybe protected original secret key.  */
1619   if (copied_sk)
1620     {
1621       free_secret_key (copied_sk);
1622       copied_sk = NULL;
1623     }
1624   sk = node->pkt->pkt.secret_key;
1625
1626   /* Get rid of the secret key parameters and store the serial numer. */
1627   n = pubkey_get_nskey (sk->pubkey_algo);
1628   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
1629     {
1630       gcry_mpi_release (sk->skey[i]);
1631       sk->skey[i] = NULL;
1632     }
1633   i = pubkey_get_npkey (sk->pubkey_algo);
1634   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
1635   sk->is_protected = 1;
1636   sk->protect.s2k.mode = 1002;
1637   s = info.serialno;
1638   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
1639        sk->protect.ivlen++, s += 2)
1640     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
1641
1642   okay = 1;
1643
1644  leave:
1645   if (copied_sk)
1646     free_secret_key (copied_sk);
1647   agent_release_card_info (&info);
1648   return okay;
1649 }
1650
1651
1652 \f
1653 /* Data used by the command parser.  This needs to be outside of the
1654    function scope to allow readline based command completion.  */
1655 enum cmdids
1656   {
1657     cmdNOP = 0,
1658     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1659     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1660     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1661     cmdREADCERT, cmdUNBLOCK,
1662     cmdINVCMD
1663   };
1664
1665 static struct
1666 {
1667   const char *name;
1668   enum cmdids id;
1669   int admin_only;
1670   const char *desc;
1671 } cmds[] =
1672   {
1673     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1674     { "q"       , cmdQUIT  , 0, NULL },
1675     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1676     { "help"    , cmdHELP  , 0, N_("show this help")},
1677     { "?"       , cmdHELP  , 0, NULL },
1678     { "list"    , cmdLIST  , 0, N_("list all available data")},
1679     { "l"       , cmdLIST  , 0, NULL },
1680     { "debug"   , cmdDEBUG , 0, NULL },
1681     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1682     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1683     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1684     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1685     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1686     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1687     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1688     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1689     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1690     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1691     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1692     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1693     /* Note, that we do not announce these command yet. */
1694     { "privatedo", cmdPRIVATEDO, 0, NULL },
1695     { "readcert", cmdREADCERT, 0, NULL },
1696     { "writecert", cmdWRITECERT, 1, NULL },
1697     { NULL, cmdINVCMD, 0, NULL }
1698   };
1699
1700
1701 #ifdef HAVE_LIBREADLINE
1702
1703 /* These two functions are used by readline for command completion. */
1704
1705 static char *
1706 command_generator(const char *text,int state)
1707 {
1708   static int list_index,len;
1709   const char *name;
1710
1711   /* If this is a new word to complete, initialize now.  This includes
1712      saving the length of TEXT for efficiency, and initializing the
1713      index variable to 0. */
1714   if(!state)
1715     {
1716       list_index=0;
1717       len=strlen(text);
1718     }
1719
1720   /* Return the next partial match */
1721   while((name=cmds[list_index].name))
1722     {
1723       /* Only complete commands that have help text */
1724       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1725         return strdup(name);
1726     }
1727
1728   return NULL;
1729 }
1730
1731 static char **
1732 card_edit_completion(const char *text, int start, int end)
1733 {
1734   (void)end;
1735   /* If we are at the start of a line, we try and command-complete.
1736      If not, just do nothing for now. */
1737
1738   if(start==0)
1739     return rl_completion_matches(text,command_generator);
1740
1741   rl_attempted_completion_over=1;
1742
1743   return NULL;
1744 }
1745 #endif /*HAVE_LIBREADLINE*/
1746
1747 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1748    Key creation is not handled here. */
1749 void
1750 card_edit (strlist_t commands)
1751 {
1752   enum cmdids cmd = cmdNOP;
1753   int have_commands = !!commands;
1754   int redisplay = 1;
1755   char *answer = NULL;
1756   int allow_admin=0;
1757   char serialnobuf[50];
1758
1759
1760   if (opt.command_fd != -1)
1761     ;
1762   else if (opt.batch && !have_commands)
1763     {
1764       log_error(_("can't do this in batch mode\n"));
1765       goto leave;
1766     }
1767
1768   for (;;)
1769     {
1770       int arg_number;
1771       const char *arg_string = "";
1772       const char *arg_rest = "";
1773       char *p;
1774       int i;
1775       int cmd_admin_only;
1776
1777       tty_printf("\n");
1778       if (redisplay )
1779         {
1780           if (opt.with_colons)
1781             {
1782               card_status (stdout, serialnobuf, DIM (serialnobuf));
1783               fflush (stdout);
1784             }
1785           else
1786             {
1787               card_status (NULL, serialnobuf, DIM (serialnobuf));
1788               tty_printf("\n");
1789             }
1790           redisplay = 0;
1791         }
1792
1793       do
1794         {
1795           xfree (answer);
1796           if (have_commands)
1797             {
1798               if (commands)
1799                 {
1800                   answer = xstrdup (commands->d);
1801                   commands = commands->next;
1802                 }
1803               else if (opt.batch)
1804                 {
1805                   answer = xstrdup ("quit");
1806                 }
1807               else
1808                 have_commands = 0;
1809             }
1810
1811             if (!have_commands)
1812               {
1813                 tty_enable_completion (card_edit_completion);
1814                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
1815                 cpr_kill_prompt();
1816                 tty_disable_completion ();
1817               }
1818             trim_spaces(answer);
1819         }
1820       while ( *answer == '#' );
1821
1822       arg_number = 0; /* Yes, here is the init which egcc complains about */
1823       cmd_admin_only = 0;
1824       if (!*answer)
1825         cmd = cmdLIST; /* Default to the list command */
1826       else if (*answer == CONTROL_D)
1827         cmd = cmdQUIT;
1828       else
1829         {
1830           if ((p=strchr (answer,' ')))
1831             {
1832               *p++ = 0;
1833               trim_spaces (answer);
1834               trim_spaces (p);
1835               arg_number = atoi(p);
1836               arg_string = p;
1837               arg_rest = p;
1838               while (digitp (arg_rest))
1839                 arg_rest++;
1840               while (spacep (arg_rest))
1841                 arg_rest++;
1842             }
1843
1844           for (i=0; cmds[i].name; i++ )
1845             if (!ascii_strcasecmp (answer, cmds[i].name ))
1846               break;
1847
1848           cmd = cmds[i].id;
1849           cmd_admin_only = cmds[i].admin_only;
1850         }
1851
1852       if (!allow_admin && cmd_admin_only)
1853         {
1854           tty_printf ("\n");
1855           tty_printf (_("Admin-only command\n"));
1856           continue;
1857         }
1858
1859       switch (cmd)
1860         {
1861         case cmdHELP:
1862           for (i=0; cmds[i].name; i++ )
1863             if(cmds[i].desc
1864                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
1865               tty_printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
1866           break;
1867
1868         case cmdADMIN:
1869           if ( !strcmp (arg_string, "on") )
1870             allow_admin = 1;
1871           else if ( !strcmp (arg_string, "off") )
1872             allow_admin = 0;
1873           else if ( !strcmp (arg_string, "verify") )
1874             {
1875               /* Force verification of the Admin Command.  However,
1876                  this is only done if the retry counter is at initial
1877                  state.  */
1878               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
1879               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
1880               allow_admin = !agent_scd_checkpin (tmp);
1881               xfree (tmp);
1882             }
1883           else /* Toggle. */
1884             allow_admin=!allow_admin;
1885           if(allow_admin)
1886             tty_printf(_("Admin commands are allowed\n"));
1887           else
1888             tty_printf(_("Admin commands are not allowed\n"));
1889           break;
1890
1891         case cmdVERIFY:
1892           agent_scd_checkpin (serialnobuf);
1893           redisplay = 1;
1894           break;
1895
1896         case cmdLIST:
1897           redisplay = 1;
1898           break;
1899
1900         case cmdNAME:
1901           change_name ();
1902           break;
1903
1904         case cmdURL:
1905           change_url ();
1906           break;
1907
1908         case cmdFETCH:
1909           fetch_url();
1910           break;
1911
1912         case cmdLOGIN:
1913           change_login (arg_string);
1914           break;
1915
1916         case cmdLANG:
1917           change_lang ();
1918           break;
1919
1920         case cmdSEX:
1921           change_sex ();
1922           break;
1923
1924         case cmdCAFPR:
1925           if ( arg_number < 1 || arg_number > 3 )
1926             tty_printf ("usage: cafpr N\n"
1927                         "       1 <= N <= 3\n");
1928           else
1929             change_cafpr (arg_number);
1930           break;
1931
1932         case cmdPRIVATEDO:
1933           if ( arg_number < 1 || arg_number > 4 )
1934             tty_printf ("usage: privatedo N\n"
1935                         "       1 <= N <= 4\n");
1936           else
1937             change_private_do (arg_string, arg_number);
1938           break;
1939
1940         case cmdWRITECERT:
1941           if ( arg_number != 3 )
1942             tty_printf ("usage: writecert 3 < FILE\n");
1943           else
1944             change_cert (arg_rest);
1945           break;
1946
1947         case cmdREADCERT:
1948           if ( arg_number != 3 )
1949             tty_printf ("usage: readcert 3 > FILE\n");
1950           else
1951             read_cert (arg_rest);
1952           break;
1953
1954         case cmdFORCESIG:
1955           toggle_forcesig ();
1956           break;
1957
1958         case cmdGENERATE:
1959           generate_card_keys ();
1960           break;
1961
1962         case cmdPASSWD:
1963           change_pin (0, allow_admin);
1964           break;
1965
1966         case cmdUNBLOCK:
1967           change_pin (1, allow_admin);
1968           break;
1969
1970         case cmdQUIT:
1971           goto leave;
1972
1973         case cmdNOP:
1974           break;
1975
1976         case cmdINVCMD:
1977         default:
1978           tty_printf ("\n");
1979           tty_printf (_("Invalid command  (try \"help\")\n"));
1980           break;
1981         } /* End command switch. */
1982     } /* End of main menu loop. */
1983
1984  leave:
1985   xfree (answer);
1986 }
1987