gpg: Add build and runtime support for larger RSA keys
[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       struct keyserver_spec *spec=NULL;
733
734       rc=agent_scd_getattr("KEY-FPR",&info);
735       if(rc)
736         log_error("error retrieving key fingerprint from card: %s\n",
737                   gpg_strerror(rc));
738       else if (info.pubkey_url && *info.pubkey_url)
739         {
740           spec=parse_keyserver_uri(info.pubkey_url,1,NULL,0);
741           if(spec && info.fpr1valid)
742             {
743               /* This is not perfectly right.  Currently, all card
744                  fingerprints are 20 digits, but what about
745                  fingerprints for a future v5 key?  We should get the
746                  length from somewhere lower in the code.  In any
747                  event, the fpr/keyid is not meaningful for straight
748                  HTTP fetches, but using it allows the card to point
749                  to HKP and LDAP servers as well. */
750               rc=keyserver_import_fprint(info.fpr1,20,spec);
751               free_keyserver_spec(spec);
752             }
753         }
754       else if (info.fpr1valid)
755         {
756           rc = keyserver_import_fprint (info.fpr1, 20, opt.keyserver);
757         }
758     }
759
760   return rc;
761 }
762
763
764 /* Read data from file FNAME up to MAXLEN characters.  On error return
765    -1 and store NULL at R_BUFFER; on success return the number of
766    bytes read and store the address of a newly allocated buffer at
767    R_BUFFER. */
768 static int
769 get_data_from_file (const char *fname, size_t maxlen, char **r_buffer)
770 {
771   FILE *fp;
772   char *data;
773   int n;
774
775   *r_buffer = NULL;
776
777   fp = fopen (fname, "rb");
778 #if GNUPG_MAJOR_VERSION == 1
779   if (fp && is_secured_file (fileno (fp)))
780     {
781       fclose (fp);
782       fp = NULL;
783       errno = EPERM;
784     }
785 #endif
786   if (!fp)
787     {
788       tty_printf (_("can't open `%s': %s\n"), fname, strerror (errno));
789       return -1;
790     }
791
792   data = xtrymalloc (maxlen? maxlen:1);
793   if (!data)
794     {
795       tty_printf (_("error allocating enough memory: %s\n"), strerror (errno));
796       fclose (fp);
797       return -1;
798     }
799
800   if (maxlen)
801     n = fread (data, 1, maxlen, fp);
802   else
803     n = 0;
804   fclose (fp);
805   if (n < 0)
806     {
807       tty_printf (_("error reading `%s': %s\n"), fname, strerror (errno));
808       xfree (data);
809       return -1;
810     }
811   *r_buffer = data;
812   return n;
813 }
814
815
816 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
817    success.  */
818 static int
819 put_data_to_file (const char *fname, const void *buffer, size_t length)
820 {
821   FILE *fp;
822
823   fp = fopen (fname, "wb");
824 #if GNUPG_MAJOR_VERSION == 1
825   if (fp && is_secured_file (fileno (fp)))
826     {
827       fclose (fp);
828       fp = NULL;
829       errno = EPERM;
830     }
831 #endif
832   if (!fp)
833     {
834       tty_printf (_("can't create `%s': %s\n"), fname, strerror (errno));
835       return -1;
836     }
837
838   if (length && fwrite (buffer, length, 1, fp) != 1)
839     {
840       tty_printf (_("error writing `%s': %s\n"), fname, strerror (errno));
841       fclose (fp);
842       return -1;
843     }
844   fclose (fp);
845   return 0;
846 }
847
848
849 static int
850 change_login (const char *args)
851 {
852   char *data;
853   int n;
854   int rc;
855
856   if (args && *args == '<')  /* Read it from a file */
857     {
858       for (args++; spacep (args); args++)
859         ;
860       n = get_data_from_file (args, 254, &data);
861       if (n < 0)
862         return -1;
863     }
864   else
865     {
866       data = cpr_get ("cardedit.change_login",
867                       _("Login data (account name): "));
868       if (!data)
869         return -1;
870       trim_spaces (data);
871       cpr_kill_prompt ();
872       n = strlen (data);
873     }
874
875   if (n > 254 )
876     {
877       tty_printf (_("Error: Login data too long "
878                     "(limit is %d characters).\n"), 254);
879       xfree (data);
880       return -1;
881     }
882
883   rc = agent_scd_setattr ("LOGIN-DATA", data, n, NULL );
884   if (rc)
885     log_error ("error setting login data: %s\n", gpg_strerror (rc));
886   xfree (data);
887   write_sc_op_status (rc);
888   return rc;
889 }
890
891 static int
892 change_private_do (const char *args, int nr)
893 {
894   char do_name[] = "PRIVATE-DO-X";
895   char *data;
896   int n;
897   int rc;
898
899   assert (nr >= 1 && nr <= 4);
900   do_name[11] = '0' + nr;
901
902   if (args && (args = strchr (args, '<')))  /* Read it from a file */
903     {
904       for (args++; spacep (args); args++)
905         ;
906       n = get_data_from_file (args, 254, &data);
907       if (n < 0)
908         return -1;
909     }
910   else
911     {
912       data = cpr_get ("cardedit.change_private_do",
913                       _("Private DO data: "));
914       if (!data)
915         return -1;
916       trim_spaces (data);
917       cpr_kill_prompt ();
918       n = strlen (data);
919     }
920
921   if (n > 254 )
922     {
923       tty_printf (_("Error: Private DO too long "
924                     "(limit is %d characters).\n"), 254);
925       xfree (data);
926       return -1;
927     }
928
929   rc = agent_scd_setattr (do_name, data, n, NULL );
930   if (rc)
931     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
932   xfree (data);
933   write_sc_op_status (rc);
934   return rc;
935 }
936
937
938 static int
939 change_cert (const char *args)
940 {
941   char *data;
942   int n;
943   int rc;
944
945   if (args && *args == '<')  /* Read it from a file */
946     {
947       for (args++; spacep (args); args++)
948         ;
949       n = get_data_from_file (args, 16384, &data);
950       if (n < 0)
951         return -1;
952     }
953   else
954     {
955       tty_printf ("usage error: redirection to file required\n");
956       return -1;
957     }
958
959   rc = agent_scd_writecert ("OPENPGP.3", data, n);
960   if (rc)
961     log_error ("error writing certificate to card: %s\n", gpg_strerror (rc));
962   xfree (data);
963   write_sc_op_status (rc);
964   return rc;
965 }
966
967
968 static int
969 read_cert (const char *args)
970 {
971   const char *fname;
972   void *buffer;
973   size_t length;
974   int rc;
975
976   if (args && *args == '>')  /* Write it to a file */
977     {
978       for (args++; spacep (args); args++)
979         ;
980       fname = args;
981     }
982   else
983     {
984       tty_printf ("usage error: redirection to file required\n");
985       return -1;
986     }
987
988   rc = agent_scd_readcert ("OPENPGP.3", &buffer, &length);
989   if (rc)
990     log_error ("error reading certificate from card: %s\n", gpg_strerror (rc));
991   else
992     rc = put_data_to_file (fname, buffer, length);
993   xfree (buffer);
994   write_sc_op_status (rc);
995   return rc;
996 }
997
998
999 static int
1000 change_lang (void)
1001 {
1002   char *data, *p;
1003   int rc;
1004
1005   data = cpr_get ("cardedit.change_lang",
1006                   _("Language preferences: "));
1007   if (!data)
1008     return -1;
1009   trim_spaces (data);
1010   cpr_kill_prompt ();
1011
1012   if (strlen (data) > 8 || (strlen (data) & 1))
1013     {
1014       tty_printf (_("Error: invalid length of preference string.\n"));
1015       xfree (data);
1016       return -1;
1017     }
1018
1019   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1020     ;
1021   if (*p)
1022     {
1023       tty_printf (_("Error: invalid characters in preference string.\n"));
1024       xfree (data);
1025       return -1;
1026     }
1027
1028   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data), NULL );
1029   if (rc)
1030     log_error ("error setting lang: %s\n", gpg_strerror (rc));
1031   xfree (data);
1032   write_sc_op_status (rc);
1033   return rc;
1034 }
1035
1036
1037 static int
1038 change_sex (void)
1039 {
1040   char *data;
1041   const char *str;
1042   int rc;
1043
1044   data = cpr_get ("cardedit.change_sex",
1045                   _("Sex ((M)ale, (F)emale or space): "));
1046   if (!data)
1047     return -1;
1048   trim_spaces (data);
1049   cpr_kill_prompt ();
1050
1051   if (!*data)
1052     str = "9";
1053   else if ((*data == 'M' || *data == 'm') && !data[1])
1054     str = "1";
1055   else if ((*data == 'F' || *data == 'f') && !data[1])
1056     str = "2";
1057   else
1058     {
1059       tty_printf (_("Error: invalid response.\n"));
1060       xfree (data);
1061       return -1;
1062     }
1063
1064   rc = agent_scd_setattr ("DISP-SEX", str, 1, NULL );
1065   if (rc)
1066     log_error ("error setting sex: %s\n", gpg_strerror (rc));
1067   xfree (data);
1068   write_sc_op_status (rc);
1069   return rc;
1070 }
1071
1072
1073 static int
1074 change_cafpr (int fprno)
1075 {
1076   char *data;
1077   const char *s;
1078   int i, c, rc;
1079   unsigned char fpr[20];
1080
1081   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1082   if (!data)
1083     return -1;
1084   trim_spaces (data);
1085   cpr_kill_prompt ();
1086
1087   for (i=0, s=data; i < 20 && *s; )
1088     {
1089       while (spacep(s))
1090         s++;
1091       if (*s == ':')
1092         s++;
1093       while (spacep(s))
1094         s++;
1095       c = hextobyte (s);
1096       if (c == -1)
1097         break;
1098       fpr[i++] = c;
1099       s += 2;
1100     }
1101   xfree (data);
1102   if (i != 20 || *s)
1103     {
1104       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1105       return -1;
1106     }
1107
1108   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1109                           fprno==2?"CA-FPR-2":
1110                           fprno==3?"CA-FPR-3":"x", fpr, 20, NULL );
1111   if (rc)
1112     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1113   write_sc_op_status (rc);
1114   return rc;
1115 }
1116
1117
1118
1119 static void
1120 toggle_forcesig (void)
1121 {
1122   struct agent_card_info_s info;
1123   int rc;
1124   int newstate;
1125
1126   memset (&info, 0, sizeof info);
1127   rc = agent_scd_getattr ("CHV-STATUS", &info);
1128   if (rc)
1129     {
1130       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1131       return;
1132     }
1133   newstate = !info.chv1_cached;
1134   agent_release_card_info (&info);
1135
1136   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1137   if (rc)
1138     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1139   write_sc_op_status (rc);
1140 }
1141
1142
1143 /* Helper for the key generation/edit functions.  */
1144 static int
1145 get_info_for_key_operation (struct agent_card_info_s *info)
1146 {
1147   int rc;
1148
1149   memset (info, 0, sizeof *info);
1150   rc = agent_scd_getattr ("SERIALNO", info);
1151   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1152       || strlen (info->serialno) != 32 )
1153     {
1154       log_error (_("key operation not possible: %s\n"),
1155                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1156       return rc? rc: -1;
1157     }
1158   rc = agent_scd_getattr ("KEY-FPR", info);
1159   if (!rc)
1160     rc = agent_scd_getattr ("CHV-STATUS", info);
1161   if (!rc)
1162     rc = agent_scd_getattr ("DISP-NAME", info);
1163   if (!rc)
1164     rc = agent_scd_getattr ("EXTCAP", info);
1165   if (!rc)
1166     rc = agent_scd_getattr ("KEY-ATTR", info);
1167   if (rc)
1168     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1169   return rc;
1170 }
1171
1172
1173 /* Helper for the key generation/edit functions.  */
1174 static int
1175 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1176 {
1177   int rc = 0;
1178
1179   agent_clear_pin_cache (info->serialno);
1180
1181   *forced_chv1 = !info->chv1_cached;
1182   if (*forced_chv1)
1183     { /* Switch off the forced mode so that during key generation we
1184          don't get bothered with PIN queries for each
1185          self-signature. */
1186       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1187       if (rc)
1188         {
1189           log_error ("error clearing forced signature PIN flag: %s\n",
1190                      gpg_strerror (rc));
1191           *forced_chv1 = 0;
1192         }
1193     }
1194
1195   if (!rc)
1196     {
1197       /* Check the PIN now, so that we won't get asked later for each
1198          binding signature. */
1199       rc = agent_scd_checkpin (info->serialno);
1200       if (rc)
1201         {
1202           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1203           write_sc_op_status (rc);
1204         }
1205   }
1206   return rc;
1207 }
1208
1209 /* Helper for the key generation/edit functions.  */
1210 static void
1211 restore_forced_chv1 (int *forced_chv1)
1212 {
1213   int rc;
1214
1215   if (*forced_chv1)
1216     { /* Switch back to forced state. */
1217       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1218       if (rc)
1219         {
1220           log_error ("error setting forced signature PIN flag: %s\n",
1221                      gpg_strerror (rc));
1222         }
1223     }
1224 }
1225
1226
1227 /* Helper for the key generation/edit functions.  */
1228 static void
1229 show_card_key_info (struct agent_card_info_s *info)
1230 {
1231   tty_fprintf (NULL, "Signature key ....:");
1232   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
1233   tty_fprintf (NULL, "Encryption key....:");
1234   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
1235   tty_fprintf (NULL, "Authentication key:");
1236   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
1237   tty_printf ("\n");
1238 }
1239
1240
1241 /* Helper for the key generation/edit functions.  */
1242 static int
1243 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1244 {
1245   assert (keyno >= 0 && keyno <= 3);
1246
1247   if ((keyno == 1 && info->fpr1valid)
1248       || (keyno == 2 && info->fpr2valid)
1249       || (keyno == 3 && info->fpr3valid))
1250     {
1251       tty_printf ("\n");
1252       log_info ("WARNING: such a key has already been stored on the card!\n");
1253       tty_printf ("\n");
1254       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1255                                   _("Replace existing key? (y/N) ")))
1256         return -1;
1257     }
1258   return 0;
1259 }
1260
1261
1262 static void
1263 show_keysize_warning (void)
1264 {
1265   static int shown;
1266
1267   if (shown)
1268     return;
1269   shown = 1;
1270   tty_printf
1271     (_("NOTE: There is no guarantee that the card "
1272        "supports the requested size.\n"
1273        "      If the key generation does not succeed, "
1274        "please check the\n"
1275        "      documentation of your card to see what "
1276        "sizes are allowed.\n"));
1277 }
1278
1279
1280 /* Ask for the size of a card key.  NBITS is the current size
1281    configured for the card.  KEYNO is the number of the key used to
1282    select the prompt.  Returns 0 to use the default size (i.e. NBITS)
1283    or the selected size.  */
1284 static unsigned int
1285 ask_card_keysize (int keyno, unsigned int nbits)
1286 {
1287   unsigned int min_nbits = 1024;
1288   unsigned int max_nbits = 4096;
1289   char *prompt, *answer;
1290   unsigned int req_nbits;
1291
1292   for (;;)
1293     {
1294       prompt = xasprintf
1295         (keyno == 0?
1296          _("What keysize do you want for the Signature key? (%u) "):
1297          keyno == 1?
1298          _("What keysize do you want for the Encryption key? (%u) "):
1299          _("What keysize do you want for the Authentication key? (%u) "),
1300          nbits);
1301       answer = cpr_get ("cardedit.genkeys.size", prompt);
1302       cpr_kill_prompt ();
1303       req_nbits = *answer? atoi (answer): nbits;
1304       xfree (prompt);
1305       xfree (answer);
1306
1307       if (req_nbits != nbits && (req_nbits % 32) )
1308         {
1309           req_nbits = ((req_nbits + 31) / 32) * 32;
1310           tty_printf (_("rounded up to %u bits\n"), req_nbits);
1311         }
1312
1313       if (req_nbits == nbits)
1314         return 0;  /* Use default.  */
1315
1316       if (req_nbits < min_nbits || req_nbits > max_nbits)
1317         {
1318           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1319                       "RSA", min_nbits, max_nbits);
1320         }
1321       else
1322         {
1323           tty_printf (_("The card will now be re-configured "
1324                         "to generate a key of %u bits\n"), req_nbits);
1325           show_keysize_warning ();
1326           return req_nbits;
1327         }
1328     }
1329 }
1330
1331
1332 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1333    message if that fails.  */
1334 static gpg_error_t
1335 do_change_keysize (int keyno, unsigned int nbits)
1336 {
1337   gpg_error_t err;
1338   char args[100];
1339
1340   snprintf (args, sizeof args, "--force %d 1 %u", keyno+1, nbits);
1341   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1342   if (err)
1343     log_error (_("error changing size of key %d to %u bits: %s\n"),
1344                keyno+1, nbits, gpg_strerror (err));
1345   return err;
1346 }
1347
1348
1349 static void
1350 generate_card_keys (void)
1351 {
1352   struct agent_card_info_s info;
1353   int forced_chv1;
1354   int want_backup;
1355   int keyno;
1356
1357   if (get_info_for_key_operation (&info))
1358     return;
1359
1360   if (info.extcap.ki)
1361     {
1362       char *answer;
1363
1364       answer = cpr_get ("cardedit.genkeys.backup_enc",
1365                         _("Make off-card backup of encryption key? (Y/n) "));
1366
1367       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1368       cpr_kill_prompt ();
1369       xfree (answer);
1370     }
1371   else
1372     want_backup = 0;
1373
1374   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1375        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1376        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1377     {
1378       tty_printf ("\n");
1379       log_info (_("NOTE: keys are already stored on the card!\n"));
1380       tty_printf ("\n");
1381       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1382                                    _("Replace existing keys? (y/N) ")))
1383         {
1384           agent_release_card_info (&info);
1385           return;
1386         }
1387     }
1388
1389   /* If no displayed name has been set, we assume that this is a fresh
1390      card and print a hint about the default PINs.  */
1391   if (!info.disp_name || !*info.disp_name)
1392     {
1393       tty_printf ("\n");
1394       tty_printf (_("Please note that the factory settings of the PINs are\n"
1395                     "   PIN = `%s'     Admin PIN = `%s'\n"
1396                     "You should change them using the command --change-pin\n"),
1397                   "123456", "12345678");
1398       tty_printf ("\n");
1399     }
1400
1401   if (check_pin_for_key_operation (&info, &forced_chv1))
1402     goto leave;
1403
1404   /* If the cards features changeable key attributes, we ask for the
1405      key size.  */
1406   if (info.is_v2 && info.extcap.aac)
1407     {
1408       unsigned int nbits;
1409
1410       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1411         {
1412           nbits = ask_card_keysize (keyno, info.key_attr[keyno].nbits);
1413           if (nbits && do_change_keysize (keyno, nbits))
1414             {
1415               /* Error: Better read the default key size again.  */
1416               agent_release_card_info (&info);
1417               if (get_info_for_key_operation (&info))
1418                 goto leave;
1419               /* Ask again for this key size. */
1420               keyno--;
1421             }
1422         }
1423       /* Note that INFO has not be synced.  However we will only use
1424          the serialnumber and thus it won't harm.  */
1425     }
1426
1427   generate_keypair (NULL, info.serialno, want_backup? opt.homedir:NULL);
1428
1429  leave:
1430   agent_release_card_info (&info);
1431   restore_forced_chv1 (&forced_chv1);
1432 }
1433
1434
1435 /* This function is used by the key edit menu to generate an arbitrary
1436    subkey. */
1437 int
1438 card_generate_subkey (KBNODE pub_keyblock, KBNODE sec_keyblock)
1439 {
1440   struct agent_card_info_s info;
1441   int okay = 0;
1442   int forced_chv1 = 0;
1443   int keyno;
1444
1445   if (get_info_for_key_operation (&info))
1446     return 0;
1447
1448   show_card_key_info (&info);
1449
1450   tty_printf (_("Please select the type of key to generate:\n"));
1451
1452   tty_printf (_("   (1) Signature key\n"));
1453   tty_printf (_("   (2) Encryption key\n"));
1454   tty_printf (_("   (3) Authentication key\n"));
1455
1456   for (;;)
1457     {
1458       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1459                               _("Your selection? "));
1460       cpr_kill_prompt();
1461       if (*answer == CONTROL_D)
1462         {
1463           xfree (answer);
1464           goto leave;
1465         }
1466       keyno = *answer? atoi(answer): 0;
1467       xfree(answer);
1468       if (keyno >= 1 && keyno <= 3)
1469         break; /* Okay. */
1470       tty_printf(_("Invalid selection.\n"));
1471     }
1472
1473   if (replace_existing_key_p (&info, keyno))
1474     goto leave;
1475
1476   if (check_pin_for_key_operation (&info, &forced_chv1))
1477     goto leave;
1478
1479   /* If the cards features changeable key attributes, we ask for the
1480      key size.  */
1481   if (info.is_v2 && info.extcap.aac)
1482     {
1483       unsigned int nbits;
1484
1485     ask_again:
1486       nbits = ask_card_keysize (keyno-1, info.key_attr[keyno-1].nbits);
1487       if (nbits && do_change_keysize (keyno-1, nbits))
1488         {
1489           /* Error: Better read the default key size again.  */
1490           agent_release_card_info (&info);
1491           if (get_info_for_key_operation (&info))
1492             goto leave;
1493           goto ask_again;
1494         }
1495       /* Note that INFO has not be synced.  However we will only use
1496          the serialnumber and thus it won't harm.  */
1497     }
1498
1499   okay = generate_card_subkeypair (pub_keyblock, sec_keyblock,
1500                                    keyno, info.serialno);
1501
1502  leave:
1503   agent_release_card_info (&info);
1504   restore_forced_chv1 (&forced_chv1);
1505   return okay;
1506 }
1507
1508
1509 /* Store the key at NODE into the smartcard and modify NODE to
1510    carry the serialno stuff instead of the actual secret key
1511    parameters.  USE is the usage for that key; 0 means any
1512    usage. */
1513 int
1514 card_store_subkey (KBNODE node, int use)
1515 {
1516   struct agent_card_info_s info;
1517   int okay = 0;
1518   int rc;
1519   int keyno, i;
1520   PKT_secret_key *copied_sk = NULL;
1521   PKT_secret_key *sk;
1522   size_t n;
1523   const char *s;
1524   int allow_keyno[3];
1525   unsigned int nbits;
1526
1527
1528   assert (node->pkt->pkttype == PKT_SECRET_KEY
1529           || node->pkt->pkttype == PKT_SECRET_SUBKEY);
1530   sk = node->pkt->pkt.secret_key;
1531
1532   if (get_info_for_key_operation (&info))
1533     return 0;
1534
1535   if (!info.extcap.ki)
1536     {
1537       tty_printf ("The card does not support the import of keys\n");
1538       tty_printf ("\n");
1539       goto leave;
1540     }
1541
1542   show_card_key_info (&info);
1543
1544   nbits = nbits_from_sk (sk);
1545
1546   if (!is_RSA (sk->pubkey_algo) || (!info.is_v2 && nbits != 1024) )
1547     {
1548       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1549       tty_printf ("\n");
1550       goto leave;
1551     }
1552
1553   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1554   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1555   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1556
1557   tty_printf (_("Please select where to store the key:\n"));
1558
1559   if (allow_keyno[0])
1560     tty_printf (_("   (1) Signature key\n"));
1561   if (allow_keyno[1])
1562     tty_printf (_("   (2) Encryption key\n"));
1563   if (allow_keyno[2])
1564     tty_printf (_("   (3) Authentication key\n"));
1565
1566   for (;;)
1567     {
1568       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1569                               _("Your selection? "));
1570       cpr_kill_prompt();
1571       if (*answer == CONTROL_D || !*answer)
1572         {
1573           xfree (answer);
1574           goto leave;
1575         }
1576       keyno = *answer? atoi(answer): 0;
1577       xfree(answer);
1578       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1579         {
1580           if (info.is_v2 && !info.extcap.aac
1581               && info.key_attr[keyno-1].nbits != nbits)
1582             {
1583               tty_printf ("Key does not match the card's capability.\n");
1584             }
1585           else
1586             break; /* Okay. */
1587         }
1588       else
1589         tty_printf(_("Invalid selection.\n"));
1590     }
1591
1592   if (replace_existing_key_p (&info, keyno))
1593     goto leave;
1594
1595   /* Unprotect key.  */
1596   switch (is_secret_key_protected (sk) )
1597     {
1598     case 0: /* Not protected. */
1599       break;
1600     case -1:
1601       log_error (_("unknown key protection algorithm\n"));
1602       goto leave;
1603     default:
1604       if (sk->protect.s2k.mode == 1001)
1605         {
1606           log_error (_("secret parts of key are not available\n"));
1607           goto leave;
1608         }
1609       if (sk->protect.s2k.mode == 1002)
1610         {
1611           log_error (_("secret key already stored on a card\n"));
1612           goto leave;
1613         }
1614       /* We better copy the key before we unprotect it.  */
1615       copied_sk = sk = copy_secret_key (NULL, sk);
1616       rc = check_secret_key (sk, 0);
1617       if (rc)
1618         goto leave;
1619     }
1620
1621   rc = save_unprotected_key_to_card (sk, keyno);
1622   if (rc)
1623     {
1624       log_error (_("error writing key to card: %s\n"), gpg_strerror (rc));
1625       goto leave;
1626     }
1627
1628   /* Get back to the maybe protected original secret key.  */
1629   if (copied_sk)
1630     {
1631       free_secret_key (copied_sk);
1632       copied_sk = NULL;
1633     }
1634   sk = node->pkt->pkt.secret_key;
1635
1636   /* Get rid of the secret key parameters and store the serial numer. */
1637   n = pubkey_get_nskey (sk->pubkey_algo);
1638   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
1639     {
1640       gcry_mpi_release (sk->skey[i]);
1641       sk->skey[i] = NULL;
1642     }
1643   i = pubkey_get_npkey (sk->pubkey_algo);
1644   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
1645   sk->is_protected = 1;
1646   sk->protect.s2k.mode = 1002;
1647   s = info.serialno;
1648   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
1649        sk->protect.ivlen++, s += 2)
1650     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
1651
1652   okay = 1;
1653
1654  leave:
1655   if (copied_sk)
1656     free_secret_key (copied_sk);
1657   agent_release_card_info (&info);
1658   return okay;
1659 }
1660
1661
1662 \f
1663 /* Data used by the command parser.  This needs to be outside of the
1664    function scope to allow readline based command completion.  */
1665 enum cmdids
1666   {
1667     cmdNOP = 0,
1668     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1669     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1670     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1671     cmdREADCERT, cmdUNBLOCK,
1672     cmdINVCMD
1673   };
1674
1675 static struct
1676 {
1677   const char *name;
1678   enum cmdids id;
1679   int admin_only;
1680   const char *desc;
1681 } cmds[] =
1682   {
1683     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1684     { "q"       , cmdQUIT  , 0, NULL },
1685     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1686     { "help"    , cmdHELP  , 0, N_("show this help")},
1687     { "?"       , cmdHELP  , 0, NULL },
1688     { "list"    , cmdLIST  , 0, N_("list all available data")},
1689     { "l"       , cmdLIST  , 0, NULL },
1690     { "debug"   , cmdDEBUG , 0, NULL },
1691     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1692     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1693     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1694     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1695     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1696     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1697     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1698     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1699     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1700     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1701     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1702     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1703     /* Note, that we do not announce these command yet. */
1704     { "privatedo", cmdPRIVATEDO, 0, NULL },
1705     { "readcert", cmdREADCERT, 0, NULL },
1706     { "writecert", cmdWRITECERT, 1, NULL },
1707     { NULL, cmdINVCMD, 0, NULL }
1708   };
1709
1710
1711 #ifdef HAVE_LIBREADLINE
1712
1713 /* These two functions are used by readline for command completion. */
1714
1715 static char *
1716 command_generator(const char *text,int state)
1717 {
1718   static int list_index,len;
1719   const char *name;
1720
1721   /* If this is a new word to complete, initialize now.  This includes
1722      saving the length of TEXT for efficiency, and initializing the
1723      index variable to 0. */
1724   if(!state)
1725     {
1726       list_index=0;
1727       len=strlen(text);
1728     }
1729
1730   /* Return the next partial match */
1731   while((name=cmds[list_index].name))
1732     {
1733       /* Only complete commands that have help text */
1734       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1735         return strdup(name);
1736     }
1737
1738   return NULL;
1739 }
1740
1741 static char **
1742 card_edit_completion(const char *text, int start, int end)
1743 {
1744   (void)end;
1745   /* If we are at the start of a line, we try and command-complete.
1746      If not, just do nothing for now. */
1747
1748   if(start==0)
1749     return rl_completion_matches(text,command_generator);
1750
1751   rl_attempted_completion_over=1;
1752
1753   return NULL;
1754 }
1755 #endif /*HAVE_LIBREADLINE*/
1756
1757 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1758    Key creation is not handled here. */
1759 void
1760 card_edit (strlist_t commands)
1761 {
1762   enum cmdids cmd = cmdNOP;
1763   int have_commands = !!commands;
1764   int redisplay = 1;
1765   char *answer = NULL;
1766   int allow_admin=0;
1767   char serialnobuf[50];
1768
1769
1770   if (opt.command_fd != -1)
1771     ;
1772   else if (opt.batch && !have_commands)
1773     {
1774       log_error(_("can't do this in batch mode\n"));
1775       goto leave;
1776     }
1777
1778   for (;;)
1779     {
1780       int arg_number;
1781       const char *arg_string = "";
1782       const char *arg_rest = "";
1783       char *p;
1784       int i;
1785       int cmd_admin_only;
1786
1787       tty_printf("\n");
1788       if (redisplay )
1789         {
1790           if (opt.with_colons)
1791             {
1792               card_status (stdout, serialnobuf, DIM (serialnobuf));
1793               fflush (stdout);
1794             }
1795           else
1796             {
1797               card_status (NULL, serialnobuf, DIM (serialnobuf));
1798               tty_printf("\n");
1799             }
1800           redisplay = 0;
1801         }
1802
1803       do
1804         {
1805           xfree (answer);
1806           if (have_commands)
1807             {
1808               if (commands)
1809                 {
1810                   answer = xstrdup (commands->d);
1811                   commands = commands->next;
1812                 }
1813               else if (opt.batch)
1814                 {
1815                   answer = xstrdup ("quit");
1816                 }
1817               else
1818                 have_commands = 0;
1819             }
1820
1821             if (!have_commands)
1822               {
1823                 tty_enable_completion (card_edit_completion);
1824                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
1825                 cpr_kill_prompt();
1826                 tty_disable_completion ();
1827               }
1828             trim_spaces(answer);
1829         }
1830       while ( *answer == '#' );
1831
1832       arg_number = 0; /* Yes, here is the init which egcc complains about */
1833       cmd_admin_only = 0;
1834       if (!*answer)
1835         cmd = cmdLIST; /* Default to the list command */
1836       else if (*answer == CONTROL_D)
1837         cmd = cmdQUIT;
1838       else
1839         {
1840           if ((p=strchr (answer,' ')))
1841             {
1842               *p++ = 0;
1843               trim_spaces (answer);
1844               trim_spaces (p);
1845               arg_number = atoi(p);
1846               arg_string = p;
1847               arg_rest = p;
1848               while (digitp (arg_rest))
1849                 arg_rest++;
1850               while (spacep (arg_rest))
1851                 arg_rest++;
1852             }
1853
1854           for (i=0; cmds[i].name; i++ )
1855             if (!ascii_strcasecmp (answer, cmds[i].name ))
1856               break;
1857
1858           cmd = cmds[i].id;
1859           cmd_admin_only = cmds[i].admin_only;
1860         }
1861
1862       if (!allow_admin && cmd_admin_only)
1863         {
1864           tty_printf ("\n");
1865           tty_printf (_("Admin-only command\n"));
1866           continue;
1867         }
1868
1869       switch (cmd)
1870         {
1871         case cmdHELP:
1872           for (i=0; cmds[i].name; i++ )
1873             if(cmds[i].desc
1874                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
1875               tty_printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
1876           break;
1877
1878         case cmdADMIN:
1879           if ( !strcmp (arg_string, "on") )
1880             allow_admin = 1;
1881           else if ( !strcmp (arg_string, "off") )
1882             allow_admin = 0;
1883           else if ( !strcmp (arg_string, "verify") )
1884             {
1885               /* Force verification of the Admin Command.  However,
1886                  this is only done if the retry counter is at initial
1887                  state.  */
1888               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
1889               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
1890               allow_admin = !agent_scd_checkpin (tmp);
1891               xfree (tmp);
1892             }
1893           else /* Toggle. */
1894             allow_admin=!allow_admin;
1895           if(allow_admin)
1896             tty_printf(_("Admin commands are allowed\n"));
1897           else
1898             tty_printf(_("Admin commands are not allowed\n"));
1899           break;
1900
1901         case cmdVERIFY:
1902           agent_scd_checkpin (serialnobuf);
1903           redisplay = 1;
1904           break;
1905
1906         case cmdLIST:
1907           redisplay = 1;
1908           break;
1909
1910         case cmdNAME:
1911           change_name ();
1912           break;
1913
1914         case cmdURL:
1915           change_url ();
1916           break;
1917
1918         case cmdFETCH:
1919           fetch_url();
1920           break;
1921
1922         case cmdLOGIN:
1923           change_login (arg_string);
1924           break;
1925
1926         case cmdLANG:
1927           change_lang ();
1928           break;
1929
1930         case cmdSEX:
1931           change_sex ();
1932           break;
1933
1934         case cmdCAFPR:
1935           if ( arg_number < 1 || arg_number > 3 )
1936             tty_printf ("usage: cafpr N\n"
1937                         "       1 <= N <= 3\n");
1938           else
1939             change_cafpr (arg_number);
1940           break;
1941
1942         case cmdPRIVATEDO:
1943           if ( arg_number < 1 || arg_number > 4 )
1944             tty_printf ("usage: privatedo N\n"
1945                         "       1 <= N <= 4\n");
1946           else
1947             change_private_do (arg_string, arg_number);
1948           break;
1949
1950         case cmdWRITECERT:
1951           if ( arg_number != 3 )
1952             tty_printf ("usage: writecert 3 < FILE\n");
1953           else
1954             change_cert (arg_rest);
1955           break;
1956
1957         case cmdREADCERT:
1958           if ( arg_number != 3 )
1959             tty_printf ("usage: readcert 3 > FILE\n");
1960           else
1961             read_cert (arg_rest);
1962           break;
1963
1964         case cmdFORCESIG:
1965           toggle_forcesig ();
1966           break;
1967
1968         case cmdGENERATE:
1969           generate_card_keys ();
1970           break;
1971
1972         case cmdPASSWD:
1973           change_pin (0, allow_admin);
1974           break;
1975
1976         case cmdUNBLOCK:
1977           change_pin (1, allow_admin);
1978           break;
1979
1980         case cmdQUIT:
1981           goto leave;
1982
1983         case cmdNOP:
1984           break;
1985
1986         case cmdINVCMD:
1987         default:
1988           tty_printf ("\n");
1989           tty_printf (_("Invalid command  (try \"help\")\n"));
1990           break;
1991         } /* End command switch. */
1992     } /* End of main menu loop. */
1993
1994  leave:
1995   xfree (answer);
1996 }
1997