gpg: Add sub-command "factory-reset" to --card-edit.
[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
1639 /* Direct sending of an hex encoded APDU with error printing.  */
1640 static gpg_error_t
1641 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1642 {
1643   gpg_error_t err;
1644   unsigned int sw;
1645
1646   err = agent_scd_apdu (hexapdu, &sw);
1647   if (err)
1648     tty_printf ("sending card command %s failed: %s\n", desc,
1649                 gpg_strerror (err));
1650   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1651     ;
1652   else if (ignore == 0xffff)
1653     ; /* Ignore all status words.  */
1654   else if (sw != 0x9000)
1655     {
1656       switch (sw)
1657         {
1658         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1659         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1660         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1661         default: err = gpg_error (GPG_ERR_CARD);
1662         }
1663       if (!(ignore && ignore == sw))
1664         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1665                     gpg_strerror (err),  sw);
1666     }
1667   return err;
1668 }
1669
1670
1671 /* Do a factory reset after confirmation.  */
1672 static void
1673 factory_reset (void)
1674 {
1675   struct agent_card_info_s info;
1676   gpg_error_t err;
1677   char *answer = NULL;
1678   int termstate = 0;
1679   int i;
1680
1681   /*  The code below basically does the same what this
1682       gpg-connect-agent script does:
1683
1684         scd reset
1685         scd serialno undefined
1686         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1687         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1688         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1689         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1690         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1691         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1692         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1693         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1694         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1695         scd apdu 00 e6 00 00
1696         scd reset
1697         scd serialno undefined
1698         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1699         scd apdu 00 44 00 00
1700         /echo Card has been reset to factory defaults
1701
1702       but tries to find out something about the card first.
1703    */
1704
1705   err = agent_scd_learn (&info);
1706   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1707       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1708     termstate = 1;
1709   else if (err)
1710     {
1711       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1712       return;
1713     }
1714
1715   if (!termstate)
1716     {
1717       log_info (_("OpenPGP card no. %s detected\n"),
1718                 info.serialno? info.serialno : "[none]");
1719       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1720         {
1721           /* Note: We won't see status-indicator 3 here because it is not
1722              possible to select a card application in termination state.  */
1723           log_error (_("This command is not supported by this card\n"));
1724           goto leave;
1725         }
1726
1727       tty_printf ("\n");
1728       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1729       tty_printf ("\n");
1730       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1731                                   _("Continue? (y/N) ")))
1732         goto leave;
1733
1734
1735       answer = cpr_get ("cardedit.factory-reset.really",
1736                         _("Really do a factory reset? (enter \"yes\") "));
1737       cpr_kill_prompt ();
1738       trim_spaces (answer);
1739       if (strcmp (answer, "yes"))
1740         goto leave;
1741
1742       /* We need to select a card application before we can send APDUs
1743          to the card without scdaemon doing anything on its own.  */
1744       err = send_apdu (NULL, "RESET", 0);
1745       if (err)
1746         goto leave;
1747       err = send_apdu ("undefined", "dummy select ", 0);
1748       if (err)
1749         goto leave;
1750
1751       /* Select the OpenPGP application.  */
1752       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1753       if (err)
1754         goto leave;
1755
1756       /* Do some dummy verifies with wrong PINs to set the retry
1757          counter to zero.  We can't easily use the card version 2.1
1758          feature of presenting the admin PIN to allow the terminate
1759          command because there is no machinery in scdaemon to catch
1760          the verify command and ask for the PIN when the "APDU"
1761          command is used. */
1762       for (i=0; i < 4; i++)
1763         send_apdu ("00200081084040404040404040", "VERIFY", 0xffff);
1764       for (i=0; i < 4; i++)
1765         send_apdu ("00200083084040404040404040", "VERIFY", 0xffff);
1766
1767       /* Send terminate datafile command.  */
1768       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1769       if (err)
1770         goto leave;
1771     }
1772
1773   /* The card is in termination state - reset and select again.  */
1774   err = send_apdu (NULL, "RESET", 0);
1775   if (err)
1776     goto leave;
1777   err = send_apdu ("undefined", "dummy select", 0);
1778   if (err)
1779     goto leave;
1780
1781   /* Select the OpenPGP application. (no error checking here). */
1782   send_apdu ("00A4040006D27600012401", "SELECT AID", 0xffff);
1783
1784   /* Send activate datafile command.  This is used without
1785      confirmation if the card is already in termination state.  */
1786   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1787   if (err)
1788     goto leave;
1789
1790   /* Finally we reset the card reader once more.  */
1791   err = send_apdu (NULL, "RESET", 0);
1792   if (err)
1793     goto leave;
1794
1795  leave:
1796   xfree (answer);
1797   agent_release_card_info (&info);
1798 }
1799
1800
1801 \f
1802 /* Data used by the command parser.  This needs to be outside of the
1803    function scope to allow readline based command completion.  */
1804 enum cmdids
1805   {
1806     cmdNOP = 0,
1807     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1808     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1809     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1810     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET,
1811     cmdINVCMD
1812   };
1813
1814 static struct
1815 {
1816   const char *name;
1817   enum cmdids id;
1818   int admin_only;
1819   const char *desc;
1820 } cmds[] =
1821   {
1822     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1823     { "q"       , cmdQUIT  , 0, NULL },
1824     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1825     { "help"    , cmdHELP  , 0, N_("show this help")},
1826     { "?"       , cmdHELP  , 0, NULL },
1827     { "list"    , cmdLIST  , 0, N_("list all available data")},
1828     { "l"       , cmdLIST  , 0, NULL },
1829     { "debug"   , cmdDEBUG , 0, NULL },
1830     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1831     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1832     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1833     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1834     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1835     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1836     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1837     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1838     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1839     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1840     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1841     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1842     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
1843     /* Note, that we do not announce these command yet. */
1844     { "privatedo", cmdPRIVATEDO, 0, NULL },
1845     { "readcert", cmdREADCERT, 0, NULL },
1846     { "writecert", cmdWRITECERT, 1, NULL },
1847     { NULL, cmdINVCMD, 0, NULL }
1848   };
1849
1850
1851 #ifdef HAVE_LIBREADLINE
1852
1853 /* These two functions are used by readline for command completion. */
1854
1855 static char *
1856 command_generator(const char *text,int state)
1857 {
1858   static int list_index,len;
1859   const char *name;
1860
1861   /* If this is a new word to complete, initialize now.  This includes
1862      saving the length of TEXT for efficiency, and initializing the
1863      index variable to 0. */
1864   if(!state)
1865     {
1866       list_index=0;
1867       len=strlen(text);
1868     }
1869
1870   /* Return the next partial match */
1871   while((name=cmds[list_index].name))
1872     {
1873       /* Only complete commands that have help text */
1874       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1875         return strdup(name);
1876     }
1877
1878   return NULL;
1879 }
1880
1881 static char **
1882 card_edit_completion(const char *text, int start, int end)
1883 {
1884   (void)end;
1885   /* If we are at the start of a line, we try and command-complete.
1886      If not, just do nothing for now. */
1887
1888   if(start==0)
1889     return rl_completion_matches(text,command_generator);
1890
1891   rl_attempted_completion_over=1;
1892
1893   return NULL;
1894 }
1895 #endif /*HAVE_LIBREADLINE*/
1896
1897 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1898    Key creation is not handled here. */
1899 void
1900 card_edit (ctrl_t ctrl, strlist_t commands)
1901 {
1902   enum cmdids cmd = cmdNOP;
1903   int have_commands = !!commands;
1904   int redisplay = 1;
1905   char *answer = NULL;
1906   int allow_admin=0;
1907   char serialnobuf[50];
1908
1909
1910   if (opt.command_fd != -1)
1911     ;
1912   else if (opt.batch && !have_commands)
1913     {
1914       log_error(_("can't do this in batch mode\n"));
1915       goto leave;
1916     }
1917
1918   for (;;)
1919     {
1920       int arg_number;
1921       const char *arg_string = "";
1922       const char *arg_rest = "";
1923       char *p;
1924       int i;
1925       int cmd_admin_only;
1926
1927       tty_printf("\n");
1928       if (redisplay )
1929         {
1930           if (opt.with_colons)
1931             {
1932               card_status (es_stdout, serialnobuf, DIM (serialnobuf));
1933               fflush (stdout);
1934             }
1935           else
1936             {
1937               card_status (NULL, serialnobuf, DIM (serialnobuf));
1938               tty_printf("\n");
1939             }
1940           redisplay = 0;
1941         }
1942
1943       do
1944         {
1945           xfree (answer);
1946           if (have_commands)
1947             {
1948               if (commands)
1949                 {
1950                   answer = xstrdup (commands->d);
1951                   commands = commands->next;
1952                 }
1953               else if (opt.batch)
1954                 {
1955                   answer = xstrdup ("quit");
1956                 }
1957               else
1958                 have_commands = 0;
1959             }
1960
1961             if (!have_commands)
1962               {
1963                 tty_enable_completion (card_edit_completion);
1964                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
1965                 cpr_kill_prompt();
1966                 tty_disable_completion ();
1967               }
1968             trim_spaces(answer);
1969         }
1970       while ( *answer == '#' );
1971
1972       arg_number = 0; /* Yes, here is the init which egcc complains about */
1973       cmd_admin_only = 0;
1974       if (!*answer)
1975         cmd = cmdLIST; /* Default to the list command */
1976       else if (*answer == CONTROL_D)
1977         cmd = cmdQUIT;
1978       else
1979         {
1980           if ((p=strchr (answer,' ')))
1981             {
1982               *p++ = 0;
1983               trim_spaces (answer);
1984               trim_spaces (p);
1985               arg_number = atoi(p);
1986               arg_string = p;
1987               arg_rest = p;
1988               while (digitp (arg_rest))
1989                 arg_rest++;
1990               while (spacep (arg_rest))
1991                 arg_rest++;
1992             }
1993
1994           for (i=0; cmds[i].name; i++ )
1995             if (!ascii_strcasecmp (answer, cmds[i].name ))
1996               break;
1997
1998           cmd = cmds[i].id;
1999           cmd_admin_only = cmds[i].admin_only;
2000         }
2001
2002       if (!allow_admin && cmd_admin_only)
2003         {
2004           tty_printf ("\n");
2005           tty_printf (_("Admin-only command\n"));
2006           continue;
2007         }
2008
2009       switch (cmd)
2010         {
2011         case cmdHELP:
2012           for (i=0; cmds[i].name; i++ )
2013             if(cmds[i].desc
2014                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2015               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2016           break;
2017
2018         case cmdADMIN:
2019           if ( !strcmp (arg_string, "on") )
2020             allow_admin = 1;
2021           else if ( !strcmp (arg_string, "off") )
2022             allow_admin = 0;
2023           else if ( !strcmp (arg_string, "verify") )
2024             {
2025               /* Force verification of the Admin Command.  However,
2026                  this is only done if the retry counter is at initial
2027                  state.  */
2028               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2029               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2030               allow_admin = !agent_scd_checkpin (tmp);
2031               xfree (tmp);
2032             }
2033           else /* Toggle. */
2034             allow_admin=!allow_admin;
2035           if(allow_admin)
2036             tty_printf(_("Admin commands are allowed\n"));
2037           else
2038             tty_printf(_("Admin commands are not allowed\n"));
2039           break;
2040
2041         case cmdVERIFY:
2042           agent_scd_checkpin (serialnobuf);
2043           redisplay = 1;
2044           break;
2045
2046         case cmdLIST:
2047           redisplay = 1;
2048           break;
2049
2050         case cmdNAME:
2051           change_name ();
2052           break;
2053
2054         case cmdURL:
2055           change_url ();
2056           break;
2057
2058         case cmdFETCH:
2059           fetch_url (ctrl);
2060           break;
2061
2062         case cmdLOGIN:
2063           change_login (arg_string);
2064           break;
2065
2066         case cmdLANG:
2067           change_lang ();
2068           break;
2069
2070         case cmdSEX:
2071           change_sex ();
2072           break;
2073
2074         case cmdCAFPR:
2075           if ( arg_number < 1 || arg_number > 3 )
2076             tty_printf ("usage: cafpr N\n"
2077                         "       1 <= N <= 3\n");
2078           else
2079             change_cafpr (arg_number);
2080           break;
2081
2082         case cmdPRIVATEDO:
2083           if ( arg_number < 1 || arg_number > 4 )
2084             tty_printf ("usage: privatedo N\n"
2085                         "       1 <= N <= 4\n");
2086           else
2087             change_private_do (arg_string, arg_number);
2088           break;
2089
2090         case cmdWRITECERT:
2091           if ( arg_number != 3 )
2092             tty_printf ("usage: writecert 3 < FILE\n");
2093           else
2094             change_cert (arg_rest);
2095           break;
2096
2097         case cmdREADCERT:
2098           if ( arg_number != 3 )
2099             tty_printf ("usage: readcert 3 > FILE\n");
2100           else
2101             read_cert (arg_rest);
2102           break;
2103
2104         case cmdFORCESIG:
2105           toggle_forcesig ();
2106           break;
2107
2108         case cmdGENERATE:
2109           generate_card_keys (ctrl);
2110           break;
2111
2112         case cmdPASSWD:
2113           change_pin (0, allow_admin);
2114           break;
2115
2116         case cmdUNBLOCK:
2117           change_pin (1, allow_admin);
2118           break;
2119
2120         case cmdFACTORYRESET:
2121           factory_reset ();
2122           break;
2123
2124         case cmdQUIT:
2125           goto leave;
2126
2127         case cmdNOP:
2128           break;
2129
2130         case cmdINVCMD:
2131         default:
2132           tty_printf ("\n");
2133           tty_printf (_("Invalid command  (try \"help\")\n"));
2134           break;
2135         } /* End command switch. */
2136     } /* End of main menu loop. */
2137
2138  leave:
2139   xfree (answer);
2140 }