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