gpg: Remove all assert.h and s/assert/log_assert/.
[gnupg.git] / g10 / keyedit.c
1 /* keyedit.c - Edit properties of a key
2  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2015 Werner Koch
4  * Copyright (C) 2015, 2016 g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <ctype.h>
28 #ifdef HAVE_LIBREADLINE
29 # define GNUPG_LIBREADLINE_H_INCLUDED
30 # include <readline/readline.h>
31 #endif
32
33 #include "gpg.h"
34 #include "options.h"
35 #include "packet.h"
36 #include "status.h"
37 #include "iobuf.h"
38 #include "keydb.h"
39 #include "photoid.h"
40 #include "util.h"
41 #include "main.h"
42 #include "trustdb.h"
43 #include "filter.h"
44 #include "ttyio.h"
45 #include "status.h"
46 #include "i18n.h"
47 #include "keyserver-internal.h"
48 #include "call-agent.h"
49 #include "host2net.h"
50 #include "tofu.h"
51
52 static void show_prefs (PKT_user_id * uid, PKT_signature * selfsig,
53                         int verbose);
54 static void show_names (estream_t fp, KBNODE keyblock, PKT_public_key * pk,
55                         unsigned int flag, int with_prefs);
56 static void show_key_with_all_names (ctrl_t ctrl, estream_t fp,
57                                      KBNODE keyblock, int only_marked,
58                                      int with_revoker, int with_fpr,
59                                      int with_subkeys, int with_prefs,
60                                      int nowarn);
61 static void show_key_and_fingerprint (kbnode_t keyblock, int with_subkeys);
62 static void show_key_and_grip (kbnode_t keyblock);
63 static void subkey_expire_warning (kbnode_t keyblock);
64 static int menu_adduid (KBNODE keyblock, int photo, const char *photo_name,
65                         const char *uidstr);
66 static void menu_deluid (KBNODE pub_keyblock);
67 static int menu_delsig (KBNODE pub_keyblock);
68 static int menu_clean (KBNODE keyblock, int self_only);
69 static void menu_delkey (KBNODE pub_keyblock);
70 static int menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive);
71 static int menu_expire (KBNODE pub_keyblock);
72 static int menu_changeusage (kbnode_t keyblock);
73 static int menu_backsign (KBNODE pub_keyblock);
74 static int menu_set_primary_uid (KBNODE pub_keyblock);
75 static int menu_set_preferences (KBNODE pub_keyblock);
76 static int menu_set_keyserver_url (const char *url, KBNODE pub_keyblock);
77 static int menu_set_notation (const char *string, KBNODE pub_keyblock);
78 static int menu_select_uid (KBNODE keyblock, int idx);
79 static int menu_select_uid_namehash (KBNODE keyblock, const char *namehash);
80 static int menu_select_key (KBNODE keyblock, int idx, char *p);
81 static int count_uids (KBNODE keyblock);
82 static int count_uids_with_flag (KBNODE keyblock, unsigned flag);
83 static int count_keys_with_flag (KBNODE keyblock, unsigned flag);
84 static int count_selected_uids (KBNODE keyblock);
85 static int real_uids_left (KBNODE keyblock);
86 static int count_selected_keys (KBNODE keyblock);
87 static int menu_revsig (KBNODE keyblock);
88 static int menu_revuid (KBNODE keyblock);
89 static int menu_revkey (KBNODE pub_keyblock);
90 static int menu_revsubkey (KBNODE pub_keyblock);
91 #ifndef NO_TRUST_MODELS
92 static int enable_disable_key (KBNODE keyblock, int disable);
93 #endif /*!NO_TRUST_MODELS*/
94 static void menu_showphoto (KBNODE keyblock);
95
96 static int update_trust = 0;
97
98 #define CONTROL_D ('D' - 'A' + 1)
99
100 #define NODFLG_BADSIG (1<<0)    /* Bad signature.  */
101 #define NODFLG_NOKEY  (1<<1)    /* No public key.  */
102 #define NODFLG_SIGERR (1<<2)    /* Other sig error.  */
103
104 #define NODFLG_MARK_A (1<<4)    /* Temporary mark.  */
105 #define NODFLG_DELSIG (1<<5)    /* To be deleted.  */
106
107 #define NODFLG_SELUID (1<<8)    /* Indicate the selected userid. */
108 #define NODFLG_SELKEY (1<<9)    /* Indicate the selected key.  */
109 #define NODFLG_SELSIG (1<<10)   /* Indicate a selected signature.  */
110
111 struct sign_attrib
112 {
113   int non_exportable, non_revocable;
114   struct revocation_reason_info *reason;
115   byte trust_depth, trust_value;
116   char *trust_regexp;
117 };
118
119
120
121 /* TODO: Fix duplicated code between here and the check-sigs/list-sigs
122    code in keylist.c. */
123 static int
124 print_and_check_one_sig_colon (KBNODE keyblock, KBNODE node,
125                                int *inv_sigs, int *no_key, int *oth_err,
126                                int *is_selfsig, int print_without_key)
127 {
128   PKT_signature *sig = node->pkt->pkt.signature;
129   int rc, sigrc;
130
131   /* TODO: Make sure a cached sig record here still has the pk that
132      issued it.  See also keylist.c:list_keyblock_print */
133
134   rc = check_key_signature (keyblock, node, is_selfsig);
135   switch (gpg_err_code (rc))
136     {
137     case 0:
138       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
139       sigrc = '!';
140       break;
141     case GPG_ERR_BAD_SIGNATURE:
142       node->flag = NODFLG_BADSIG;
143       sigrc = '-';
144       if (inv_sigs)
145         ++ * inv_sigs;
146       break;
147     case GPG_ERR_NO_PUBKEY:
148     case GPG_ERR_UNUSABLE_PUBKEY:
149       node->flag = NODFLG_NOKEY;
150       sigrc = '?';
151       if (no_key)
152         ++ * no_key;
153       break;
154     default:
155       node->flag = NODFLG_SIGERR;
156       sigrc = '%';
157       if (oth_err)
158         ++ * oth_err;
159       break;
160     }
161
162   if (sigrc != '?' || print_without_key)
163     {
164       es_printf ("sig:%c::%d:%08lX%08lX:%lu:%lu:",
165                  sigrc, sig->pubkey_algo, (ulong) sig->keyid[0],
166                  (ulong) sig->keyid[1], (ulong) sig->timestamp,
167                  (ulong) sig->expiredate);
168
169       if (sig->trust_depth || sig->trust_value)
170         es_printf ("%d %d", sig->trust_depth, sig->trust_value);
171
172       es_printf (":");
173
174       if (sig->trust_regexp)
175         es_write_sanitized (es_stdout,
176                             sig->trust_regexp, strlen (sig->trust_regexp),
177                             ":", NULL);
178
179       es_printf ("::%02x%c\n", sig->sig_class,
180                  sig->flags.exportable ? 'x' : 'l');
181
182       if (opt.show_subpackets)
183         print_subpackets_colon (sig);
184     }
185
186   return (sigrc == '!');
187 }
188
189
190 /*
191  * Print information about a signature (rc is its status), check it
192  * and return true if the signature is okay.  NODE must be a signature
193  * packet.  With EXTENDED set all possible signature list options will
194  * always be printed.
195  */
196 static int
197 print_one_sig (int rc, KBNODE keyblock, KBNODE node,
198                int *inv_sigs, int *no_key, int *oth_err,
199                int is_selfsig, int print_without_key, int extended)
200 {
201   PKT_signature *sig = node->pkt->pkt.signature;
202   int sigrc;
203   int is_rev = sig->sig_class == 0x30;
204
205   /* TODO: Make sure a cached sig record here still has the pk that
206      issued it.  See also keylist.c:list_keyblock_print */
207
208   switch (gpg_err_code (rc))
209     {
210     case 0:
211       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
212       sigrc = '!';
213       break;
214     case GPG_ERR_BAD_SIGNATURE:
215       node->flag = NODFLG_BADSIG;
216       sigrc = '-';
217       if (inv_sigs)
218         ++ * inv_sigs;
219       break;
220     case GPG_ERR_NO_PUBKEY:
221     case GPG_ERR_UNUSABLE_PUBKEY:
222       node->flag = NODFLG_NOKEY;
223       sigrc = '?';
224       if (no_key)
225         ++ * no_key;
226       break;
227     default:
228       node->flag = NODFLG_SIGERR;
229       sigrc = '%';
230       if (oth_err)
231         ++ * oth_err;
232       break;
233     }
234   if (sigrc != '?' || print_without_key)
235     {
236       tty_printf ("%s%c%c %c%c%c%c%c%c %s %s",
237                   is_rev ? "rev" : "sig", sigrc,
238                   (sig->sig_class - 0x10 > 0 &&
239                    sig->sig_class - 0x10 <
240                    4) ? '0' + sig->sig_class - 0x10 : ' ',
241                   sig->flags.exportable ? ' ' : 'L',
242                   sig->flags.revocable ? ' ' : 'R',
243                   sig->flags.policy_url ? 'P' : ' ',
244                   sig->flags.notation ? 'N' : ' ',
245                   sig->flags.expired ? 'X' : ' ',
246                   (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
247                                                   0) ? '0' +
248                   sig->trust_depth : ' ',
249                   keystr (sig->keyid),
250                   datestr_from_sig (sig));
251       if ((opt.list_options & LIST_SHOW_SIG_EXPIRE) || extended )
252         tty_printf (" %s", expirestr_from_sig (sig));
253       tty_printf ("  ");
254       if (sigrc == '%')
255         tty_printf ("[%s] ", gpg_strerror (rc));
256       else if (sigrc == '?')
257         ;
258       else if (is_selfsig)
259         {
260           tty_printf (is_rev ? _("[revocation]") : _("[self-signature]"));
261           if (extended && sig->flags.chosen_selfsig)
262             tty_printf ("*");
263         }
264       else
265         {
266           size_t n;
267           char *p = get_user_id (sig->keyid, &n);
268           tty_print_utf8_string2 (NULL, p, n,
269                                   opt.screen_columns - keystrlen () - 26 -
270                                   ((opt.
271                                     list_options & LIST_SHOW_SIG_EXPIRE) ? 11
272                                    : 0));
273           xfree (p);
274         }
275       tty_printf ("\n");
276
277       if (sig->flags.policy_url
278           && ((opt.list_options & LIST_SHOW_POLICY_URLS) || extended))
279         show_policy_url (sig, 3, 0);
280
281       if (sig->flags.notation
282           && ((opt.list_options & LIST_SHOW_NOTATIONS) || extended))
283         show_notation (sig, 3, 0,
284                        ((opt.
285                          list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0) +
286                        ((opt.
287                          list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0));
288
289       if (sig->flags.pref_ks
290           && ((opt.list_options & LIST_SHOW_KEYSERVER_URLS) || extended))
291         show_keyserver_url (sig, 3, 0);
292
293       if (extended)
294         {
295           PKT_public_key *pk = keyblock->pkt->pkt.public_key;
296           const unsigned char *s;
297
298           s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL);
299           if (s && *s)
300             tty_printf ("             [primary]\n");
301
302           s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
303           if (s && buf32_to_u32 (s))
304             tty_printf ("             [expires: %s]\n",
305                         isotimestamp (pk->timestamp + buf32_to_u32 (s)));
306         }
307     }
308
309   return (sigrc == '!');
310 }
311
312
313 static int
314 print_and_check_one_sig (KBNODE keyblock, KBNODE node,
315                          int *inv_sigs, int *no_key, int *oth_err,
316                          int *is_selfsig, int print_without_key, int extended)
317 {
318   int rc;
319
320   rc = check_key_signature (keyblock, node, is_selfsig);
321   return print_one_sig (rc,
322                         keyblock, node, inv_sigs, no_key, oth_err,
323                         *is_selfsig, print_without_key, extended);
324 }
325
326
327
328 /* Order two signatures.  The actual ordering isn't important.  Our
329    goal is to ensure that identical signatures occur together.  */
330 static int
331 sig_comparison (const void *av, const void *bv)
332 {
333   const KBNODE an = *(const KBNODE *) av;
334   const KBNODE bn = *(const KBNODE *) bv;
335   const PKT_signature *a;
336   const PKT_signature *b;
337   int ndataa;
338   int ndatab;
339   int i;
340
341   log_assert (an->pkt->pkttype == PKT_SIGNATURE);
342   log_assert (bn->pkt->pkttype == PKT_SIGNATURE);
343
344   a = an->pkt->pkt.signature;
345   b = bn->pkt->pkt.signature;
346
347   if (a->digest_algo < b->digest_algo)
348     return -1;
349   if (a->digest_algo > b->digest_algo)
350     return 1;
351
352   ndataa = pubkey_get_nsig (a->pubkey_algo);
353   ndatab = pubkey_get_nsig (a->pubkey_algo);
354   log_assert (ndataa == ndatab);
355
356   for (i = 0; i < ndataa; i ++)
357     {
358       int c = gcry_mpi_cmp (a->data[i], b->data[i]);
359       if (c != 0)
360         return c;
361     }
362
363   /* Okay, they are equal.  */
364   return 0;
365 }
366
367 /* Perform a few sanity checks on a keyblock is okay and possibly
368    repair some damage.  Concretely:
369
370      - Detect duplicate signatures and remove them.
371
372      - Detect out of order signatures and relocate them (e.g., a sig
373        over user id X located under subkey Y).
374
375    Note: this function does not remove signatures that don't belong or
376    components that are not signed!  (Although it would be trivial to
377    do so.)
378
379    If ONLY_SELFSIGS is true, then this function only reorders self
380    signatures (it still checks all signatures for duplicates,
381    however).
382
383    Returns 1 if the keyblock was modified, 0 otherwise.  */
384 static int
385 check_all_keysigs (KBNODE kb, int only_selected, int only_selfsigs)
386 {
387   gpg_error_t err;
388   PKT_public_key *pk;
389   KBNODE n, n_next, *n_prevp, n2;
390   char *pending_desc = NULL;
391   PKT_public_key *issuer;
392   KBNODE last_printed_component;
393   KBNODE current_component = NULL;
394   int dups = 0;
395   int missing_issuer = 0;
396   int reordered = 0;
397   int bad_signature = 0;
398   int missing_selfsig = 0;
399   int modified = 0;
400
401   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
402   pk = kb->pkt->pkt.public_key;
403
404   /* First we look for duplicates.  */
405   {
406     int nsigs = 0;
407     KBNODE *sigs;
408     int i;
409     int last_i;
410
411     /* Count the sigs.  */
412     for (n = kb; n; n = n->next)
413       if (is_deleted_kbnode (n))
414         continue;
415       else if (n->pkt->pkttype == PKT_SIGNATURE)
416         nsigs ++;
417
418     /* Add them all to the SIGS array.  */
419     sigs = xmalloc_clear (sizeof (*sigs) * nsigs);
420
421     i = 0;
422     for (n = kb; n; n = n->next)
423       {
424         if (is_deleted_kbnode (n))
425           continue;
426
427         if (n->pkt->pkttype != PKT_SIGNATURE)
428           continue;
429
430         sigs[i] = n;
431         i ++;
432       }
433     log_assert (i == nsigs);
434
435     qsort (sigs, nsigs, sizeof (sigs[0]), sig_comparison);
436
437     last_i = 0;
438     for (i = 1; i < nsigs; i ++)
439       {
440         log_assert (sigs[last_i]);
441         log_assert (sigs[last_i]->pkt->pkttype == PKT_SIGNATURE);
442         log_assert (sigs[i]);
443         log_assert (sigs[i]->pkt->pkttype == PKT_SIGNATURE);
444
445         if (sig_comparison (&sigs[last_i], &sigs[i]) == 0)
446           /* They are the same.  Kill the latter.  */
447           {
448             if (DBG_PACKET)
449               {
450                 PKT_signature *sig = sigs[i]->pkt->pkt.signature;
451
452                 log_debug ("Signature appears multiple times, deleting duplicate:\n");
453                 log_debug ("  sig: class 0x%x, issuer: %s, timestamp: %s (%lld), digest: %02x %02x\n",
454                            sig->sig_class, keystr (sig->keyid),
455                            isotimestamp (sig->timestamp),
456                            (long long) sig->timestamp,
457                            sig->digest_start[0], sig->digest_start[1]);
458               }
459
460             /* Remove sigs[i] from the keyblock.  */
461             {
462               KBNODE z, *prevp;
463               int to_kill = last_i;
464               last_i = i;
465
466               for (prevp = &kb, z = kb; z; prevp = &z->next, z = z->next)
467                 if (z == sigs[to_kill])
468                   break;
469
470               *prevp = sigs[to_kill]->next;
471
472               sigs[to_kill]->next = NULL;
473               release_kbnode (sigs[to_kill]);
474               sigs[to_kill] = NULL;
475
476               dups ++;
477               modified = 1;
478             }
479           }
480         else
481           last_i = i;
482       }
483
484     xfree (sigs);
485   }
486
487   /* Make sure the sigs occur after the component (public key, subkey,
488      user id) that they sign.  */
489   issuer = NULL;
490   last_printed_component = NULL;
491   for (n_prevp = &kb, n = kb;
492        n;
493        /* If we moved n, then n_prevp is need valid.  */
494        n_prevp = (n->next == n_next ? &n->next : n_prevp), n = n_next)
495     {
496       PACKET *p;
497       int processed_current_component;
498       PKT_signature *sig;
499       int rc;
500       int dump_sig_params = 0;
501
502       n_next = n->next;
503
504       if (is_deleted_kbnode (n))
505         continue;
506
507       p = n->pkt;
508
509       if (issuer && issuer != pk)
510         {
511           free_public_key (issuer);
512           issuer = NULL;
513         }
514
515       xfree (pending_desc);
516       pending_desc = NULL;
517
518       switch (p->pkttype)
519         {
520         case PKT_PUBLIC_KEY:
521           log_assert (p->pkt.public_key == pk);
522           if (only_selected && ! (n->flag & NODFLG_SELKEY))
523             {
524               current_component = NULL;
525               break;
526             }
527
528           if (DBG_PACKET)
529             log_debug ("public key %s: timestamp: %s (%lld)\n",
530                        pk_keyid_str (pk),
531                        isotimestamp (pk->timestamp),
532                        (long long) pk->timestamp);
533           current_component = n;
534           break;
535         case PKT_PUBLIC_SUBKEY:
536           if (only_selected && ! (n->flag & NODFLG_SELKEY))
537             {
538               current_component = NULL;
539               break;
540             }
541
542           if (DBG_PACKET)
543             log_debug ("subkey %s: timestamp: %s (%lld)\n",
544                        pk_keyid_str (p->pkt.public_key),
545                        isotimestamp (p->pkt.public_key->timestamp),
546                        (long long) p->pkt.public_key->timestamp);
547           current_component = n;
548           break;
549         case PKT_USER_ID:
550           if (only_selected && ! (n->flag & NODFLG_SELUID))
551             {
552               current_component = NULL;
553               break;
554             }
555
556           if (DBG_PACKET)
557             log_debug ("user id: %s\n",
558                        p->pkt.user_id->attrib_data
559                        ? "[ photo id ]"
560                        : p->pkt.user_id->name);
561           current_component = n;
562           break;
563         case PKT_SIGNATURE:
564           if (! current_component)
565             /* The current component is not selected, don't check the
566                sigs under it.  */
567             break;
568
569           sig = n->pkt->pkt.signature;
570
571           pending_desc = xasprintf ("  sig: class: 0x%x, issuer: %s, timestamp: %s (%lld), digest: %02x %02x",
572                                     sig->sig_class,
573                                     keystr (sig->keyid),
574                                     isotimestamp (sig->timestamp),
575                                     (long long) sig->timestamp,
576                                     sig->digest_start[0], sig->digest_start[1]);
577
578
579           if (keyid_cmp (pk_keyid (pk), sig->keyid) == 0)
580             issuer = pk;
581           else
582             /* Issuer is a different key.  */
583             {
584               if (only_selfsigs)
585                 continue;
586
587               issuer = xmalloc (sizeof (*issuer));
588               err = get_pubkey (issuer, sig->keyid);
589               if (err)
590                 {
591                   xfree (issuer);
592                   issuer = NULL;
593                   if (DBG_PACKET)
594                     {
595                       if (pending_desc)
596                         log_debug ("%s", pending_desc);
597                       log_debug ("    Can't check signature allegedly issued by %s: %s\n",
598                                 keystr (sig->keyid), gpg_strerror (err));
599                     }
600                   missing_issuer ++;
601                   break;
602                 }
603             }
604
605           if ((err = openpgp_pk_test_algo (sig->pubkey_algo)))
606             {
607               if (DBG_PACKET && pending_desc)
608                 log_debug ("%s", pending_desc);
609               tty_printf (_("can't check signature with unsupported public-key algorithm (%d): %s.\n"),
610                           sig->pubkey_algo, gpg_strerror (err));
611               break;
612             }
613           if ((err = openpgp_md_test_algo (sig->digest_algo)))
614             {
615               if (DBG_PACKET && pending_desc)
616                 log_debug ("%s", pending_desc);
617               tty_printf (_("can't check signature with unsupported message-digest algorithm %d: %s.\n"),
618                           sig->digest_algo, gpg_strerror (err));
619               break;
620             }
621
622           /* We iterate over the keyblock.  Most likely, the matching
623              component is the current component so always try that
624              first.  */
625           processed_current_component = 0;
626           for (n2 = current_component;
627                n2;
628                n2 = (processed_current_component ? n2->next : kb),
629                  processed_current_component = 1)
630             if (is_deleted_kbnode (n2))
631               continue;
632             else if (processed_current_component && n2 == current_component)
633               /* Don't process it twice.  */
634               continue;
635             else
636               {
637                 err = check_signature_over_key_or_uid (issuer, sig, kb, n2->pkt,
638                                                        NULL, NULL);
639                 if (! err)
640                   break;
641               }
642
643           /* n/sig is a signature and n2 is the component (public key,
644              subkey or user id) that it signs, if any.
645              current_component is that component that it appears to
646              apply to (according to the ordering).  */
647
648           if (current_component == n2)
649             {
650               if (DBG_PACKET)
651                 {
652                   log_debug ("%s", pending_desc);
653                   log_debug ("    Good signature over last key or uid!\n");
654                 }
655
656               rc = 0;
657             }
658           else if (n2)
659             {
660               log_assert (n2->pkt->pkttype == PKT_USER_ID
661                           || n2->pkt->pkttype == PKT_PUBLIC_KEY
662                           || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY);
663
664               if (DBG_PACKET)
665                 {
666                   log_debug ("%s", pending_desc);
667                   log_debug ("    Good signature out of order!  (Over %s (%d) '%s')\n",
668                              n2->pkt->pkttype == PKT_USER_ID
669                              ? "user id"
670                              : n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
671                              ? "subkey"
672                              : "primary key",
673                              n2->pkt->pkttype,
674                              n2->pkt->pkttype == PKT_USER_ID
675                              ? n2->pkt->pkt.user_id->name
676                              : pk_keyid_str (n2->pkt->pkt.public_key));
677                 }
678
679               /* Reorder the packets: move the signature n to be just
680                  after n2.  */
681
682               /* Unlink the signature.  */
683               log_assert (n_prevp);
684               *n_prevp = n->next;
685
686               /* Insert the sig immediately after the component.  */
687               n->next = n2->next;
688               n2->next = n;
689
690               reordered ++;
691               modified = 1;
692
693               rc = 0;
694             }
695           else
696             {
697               if (DBG_PACKET)
698                 {
699                   log_debug ("%s", pending_desc);
700                   log_debug ("    Bad signature.\n");
701                 }
702
703               if (DBG_PACKET)
704                 dump_sig_params = 1;
705
706               bad_signature ++;
707
708               rc = GPG_ERR_BAD_SIGNATURE;
709             }
710
711           /* We don't cache the result here, because we haven't
712              completely checked that the signature is legitimate.  For
713              instance, if we have a revocation certificate on Alice's
714              key signed by Bob, the signature may be good, but we
715              haven't checked that Bob is a designated revoker.  */
716           /* cache_sig_result (sig, rc); */
717
718           {
719             int has_selfsig = 0;
720             if (! rc && issuer == pk)
721               {
722                 if (n2->pkt->pkttype == PKT_PUBLIC_KEY
723                     && (/* Direct key signature.  */
724                         sig->sig_class == 0x1f
725                         /* Key revocation signature.  */
726                         || sig->sig_class == 0x20))
727                   has_selfsig = 1;
728                 if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
729                     && (/* Subkey binding sig.  */
730                         sig->sig_class == 0x18
731                         /* Subkey revocation sig.  */
732                         || sig->sig_class == 0x28))
733                   has_selfsig = 1;
734                 if (n2->pkt->pkttype == PKT_USER_ID
735                     && (/* Certification sigs.  */
736                         sig->sig_class == 0x10
737                         || sig->sig_class == 0x11
738                         || sig->sig_class == 0x12
739                         || sig->sig_class == 0x13
740                         /* Certification revocation sig.  */
741                         || sig->sig_class == 0x30))
742                   has_selfsig = 1;
743               }
744
745             if ((n2 && n2 != last_printed_component)
746                 || (! n2 && last_printed_component != current_component))
747               {
748                 int is_reordered = n2 && n2 != current_component;
749                 if (n2)
750                   last_printed_component = n2;
751                 else
752                   last_printed_component = current_component;
753
754                 if (!modified)
755                   ;
756                 else if (last_printed_component->pkt->pkttype == PKT_USER_ID)
757                   {
758                     tty_printf ("uid  ");
759                     tty_print_utf8_string (last_printed_component
760                                            ->pkt->pkt.user_id->name,
761                                            last_printed_component
762                                            ->pkt->pkt.user_id->len);
763                   }
764                 else if (last_printed_component->pkt->pkttype
765                          == PKT_PUBLIC_KEY)
766                   tty_printf ("pub  %s",
767                               pk_keyid_str (last_printed_component
768                                             ->pkt->pkt.public_key));
769                 else
770                   tty_printf ("sub  %s",
771                               pk_keyid_str (last_printed_component
772                                             ->pkt->pkt.public_key));
773
774                 if (modified)
775                   {
776                     if (is_reordered)
777                       tty_printf (_(" (reordered signatures follow)"));
778                     tty_printf ("\n");
779                   }
780               }
781
782             if (modified)
783               print_one_sig (rc, kb, n, NULL, NULL, NULL, has_selfsig,
784                              0, only_selfsigs);
785           }
786
787           if (dump_sig_params)
788             {
789               int i;
790
791               for (i = 0; i < pubkey_get_nsig (sig->pubkey_algo); i ++)
792                 {
793                   char buffer[1024];
794                   size_t len;
795                   char *printable;
796                   gcry_mpi_print (GCRYMPI_FMT_USG,
797                                   buffer, sizeof (buffer), &len,
798                                   sig->data[i]);
799                   printable = bin2hex (buffer, len, NULL);
800                   log_info ("        %d: %s\n", i, printable);
801                   xfree (printable);
802                 }
803             }
804           break;
805         default:
806           if (DBG_PACKET)
807             log_debug ("unhandled packet: %d\n", p->pkttype);
808           break;
809         }
810     }
811
812   xfree (pending_desc);
813   pending_desc = NULL;
814
815   if (issuer != pk)
816     free_public_key (issuer);
817   issuer = NULL;
818
819   /* Identify keys / uids that don't have a self-sig.  */
820   {
821     int has_selfsig = 0;
822     PACKET *p;
823     PKT_signature *sig;
824
825     current_component = NULL;
826     for (n = kb; n; n = n->next)
827       {
828         if (is_deleted_kbnode (n))
829           continue;
830
831         p = n->pkt;
832
833         switch (p->pkttype)
834           {
835           case PKT_PUBLIC_KEY:
836           case PKT_PUBLIC_SUBKEY:
837           case PKT_USER_ID:
838             if (current_component && ! has_selfsig)
839               missing_selfsig ++;
840             current_component = n;
841             has_selfsig = 0;
842             break;
843
844           case PKT_SIGNATURE:
845             if (! current_component || has_selfsig)
846               break;
847
848             sig = n->pkt->pkt.signature;
849
850             if (! (sig->flags.checked && sig->flags.valid))
851               break;
852
853             if (keyid_cmp (pk_keyid (pk), sig->keyid) != 0)
854               /* Different issuer, couldn't be a self-sig.  */
855               break;
856
857             if (current_component->pkt->pkttype == PKT_PUBLIC_KEY
858                 && (/* Direct key signature.  */
859                     sig->sig_class == 0x1f
860                     /* Key revocation signature.  */
861                     || sig->sig_class == 0x20))
862               has_selfsig = 1;
863             if (current_component->pkt->pkttype == PKT_PUBLIC_SUBKEY
864                 && (/* Subkey binding sig.  */
865                     sig->sig_class == 0x18
866                     /* Subkey revocation sig.  */
867                     || sig->sig_class == 0x28))
868               has_selfsig = 1;
869             if (current_component->pkt->pkttype == PKT_USER_ID
870                 && (/* Certification sigs.  */
871                     sig->sig_class == 0x10
872                     || sig->sig_class == 0x11
873                     || sig->sig_class == 0x12
874                     || sig->sig_class == 0x13
875                     /* Certification revocation sig.  */
876                     || sig->sig_class == 0x30))
877               has_selfsig = 1;
878
879             break;
880
881           default:
882             if (current_component && ! has_selfsig)
883               missing_selfsig ++;
884             current_component = NULL;
885           }
886       }
887   }
888
889   if (dups || missing_issuer || bad_signature || reordered)
890     tty_printf (_("key %s:\n"), pk_keyid_str (pk));
891
892   if (dups)
893     tty_printf (ngettext ("%d duplicate signature removed\n",
894                           "%d duplicate signatures removed\n", dups), dups);
895   if (missing_issuer)
896     tty_printf (ngettext ("%d signature not checked due to a missing key\n",
897                           "%d signatures not checked due to missing keys\n",
898                           missing_issuer), missing_issuer);
899   if (bad_signature)
900     tty_printf (ngettext ("%d bad signature\n",
901                           "%d bad signatures\n",
902                           bad_signature), bad_signature);
903   if (reordered)
904     tty_printf (ngettext ("%d signature reordered\n",
905                           "%d signatures reordered\n",
906                           reordered), reordered);
907
908   if (only_selfsigs && (bad_signature || reordered))
909     tty_printf (_("Warning: errors found and only checked self-signatures, run 'check' to check all signatures.\n"));
910
911   return modified;
912 }
913
914
915 static int
916 sign_mk_attrib (PKT_signature * sig, void *opaque)
917 {
918   struct sign_attrib *attrib = opaque;
919   byte buf[8];
920
921   if (attrib->non_exportable)
922     {
923       buf[0] = 0;               /* not exportable */
924       build_sig_subpkt (sig, SIGSUBPKT_EXPORTABLE, buf, 1);
925     }
926
927   if (attrib->non_revocable)
928     {
929       buf[0] = 0;               /* not revocable */
930       build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
931     }
932
933   if (attrib->reason)
934     revocation_reason_build_cb (sig, attrib->reason);
935
936   if (attrib->trust_depth)
937     {
938       /* Not critical.  If someone doesn't understand trust sigs,
939          this can still be a valid regular signature. */
940       buf[0] = attrib->trust_depth;
941       buf[1] = attrib->trust_value;
942       build_sig_subpkt (sig, SIGSUBPKT_TRUST, buf, 2);
943
944       /* Critical.  If someone doesn't understands regexps, this
945          whole sig should be invalid.  Note the +1 for the length -
946          regexps are null terminated. */
947       if (attrib->trust_regexp)
948         build_sig_subpkt (sig, SIGSUBPKT_FLAG_CRITICAL | SIGSUBPKT_REGEXP,
949                           attrib->trust_regexp,
950                           strlen (attrib->trust_regexp) + 1);
951     }
952
953   return 0;
954 }
955
956
957 static void
958 trustsig_prompt (byte * trust_value, byte * trust_depth, char **regexp)
959 {
960   char *p;
961
962   *trust_value = 0;
963   *trust_depth = 0;
964   *regexp = NULL;
965
966   /* Same string as pkclist.c:do_edit_ownertrust */
967   tty_printf (_
968               ("Please decide how far you trust this user to correctly verify"
969                " other users' keys\n(by looking at passports, checking"
970                " fingerprints from different sources, etc.)\n"));
971   tty_printf ("\n");
972   tty_printf (_("  %d = I trust marginally\n"), 1);
973   tty_printf (_("  %d = I trust fully\n"), 2);
974   tty_printf ("\n");
975
976   while (*trust_value == 0)
977     {
978       p = cpr_get ("trustsig_prompt.trust_value", _("Your selection? "));
979       trim_spaces (p);
980       cpr_kill_prompt ();
981       /* 60 and 120 are as per RFC2440 */
982       if (p[0] == '1' && !p[1])
983         *trust_value = 60;
984       else if (p[0] == '2' && !p[1])
985         *trust_value = 120;
986       xfree (p);
987     }
988
989   tty_printf ("\n");
990
991   tty_printf (_("Please enter the depth of this trust signature.\n"
992                 "A depth greater than 1 allows the key you are signing to make\n"
993                 "trust signatures on your behalf.\n"));
994   tty_printf ("\n");
995
996   while (*trust_depth == 0)
997     {
998       p = cpr_get ("trustsig_prompt.trust_depth", _("Your selection? "));
999       trim_spaces (p);
1000       cpr_kill_prompt ();
1001       *trust_depth = atoi (p);
1002       xfree (p);
1003     }
1004
1005   tty_printf ("\n");
1006
1007   tty_printf (_("Please enter a domain to restrict this signature, "
1008                 "or enter for none.\n"));
1009
1010   tty_printf ("\n");
1011
1012   p = cpr_get ("trustsig_prompt.trust_regexp", _("Your selection? "));
1013   trim_spaces (p);
1014   cpr_kill_prompt ();
1015
1016   if (strlen (p) > 0)
1017     {
1018       char *q = p;
1019       int regexplen = 100, ind;
1020
1021       *regexp = xmalloc (regexplen);
1022
1023       /* Now mangle the domain the user entered into a regexp.  To do
1024          this, \-escape everything that isn't alphanumeric, and attach
1025          "<[^>]+[@.]" to the front, and ">$" to the end. */
1026
1027       strcpy (*regexp, "<[^>]+[@.]");
1028       ind = strlen (*regexp);
1029
1030       while (*q)
1031         {
1032           if (!((*q >= 'A' && *q <= 'Z')
1033                 || (*q >= 'a' && *q <= 'z') || (*q >= '0' && *q <= '9')))
1034             (*regexp)[ind++] = '\\';
1035
1036           (*regexp)[ind++] = *q;
1037
1038           if ((regexplen - ind) < 3)
1039             {
1040               regexplen += 100;
1041               *regexp = xrealloc (*regexp, regexplen);
1042             }
1043
1044           q++;
1045         }
1046
1047       (*regexp)[ind] = '\0';
1048       strcat (*regexp, ">$");
1049     }
1050
1051   xfree (p);
1052   tty_printf ("\n");
1053 }
1054
1055
1056 /*
1057  * Loop over all LOCUSR and and sign the uids after asking.  If no
1058  * user id is marked, all user ids will be signed; if some user_ids
1059  * are marked only those will be signed.  If QUICK is true the
1060  * function won't ask the user and use sensible defaults.
1061  */
1062 static int
1063 sign_uids (ctrl_t ctrl, estream_t fp,
1064            kbnode_t keyblock, strlist_t locusr, int *ret_modified,
1065            int local, int nonrevocable, int trust, int interactive,
1066            int quick)
1067 {
1068   int rc = 0;
1069   SK_LIST sk_list = NULL;
1070   SK_LIST sk_rover = NULL;
1071   PKT_public_key *pk = NULL;
1072   KBNODE node, uidnode;
1073   PKT_public_key *primary_pk = NULL;
1074   int select_all = !count_selected_uids (keyblock) || interactive;
1075
1076   /* Build a list of all signators.
1077    *
1078    * We use the CERT flag to request the primary which must always
1079    * be one which is capable of signing keys.  I can't see a reason
1080    * why to sign keys using a subkey.  Implementation of USAGE_CERT
1081    * is just a hack in getkey.c and does not mean that a subkey
1082    * marked as certification capable will be used. */
1083   rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_CERT);
1084   if (rc)
1085     goto leave;
1086
1087   /* Loop over all signators.  */
1088   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1089     {
1090       u32 sk_keyid[2], pk_keyid[2];
1091       char *p, *trust_regexp = NULL;
1092       int class = 0, selfsig = 0;
1093       u32 duration = 0, timestamp = 0;
1094       byte trust_depth = 0, trust_value = 0;
1095
1096       pk = sk_rover->pk;
1097       keyid_from_pk (pk, sk_keyid);
1098
1099       /* Set mark A for all selected user ids.  */
1100       for (node = keyblock; node; node = node->next)
1101         {
1102           if (select_all || (node->flag & NODFLG_SELUID))
1103             node->flag |= NODFLG_MARK_A;
1104           else
1105             node->flag &= ~NODFLG_MARK_A;
1106         }
1107
1108       /* Reset mark for uids which are already signed.  */
1109       uidnode = NULL;
1110       for (node = keyblock; node; node = node->next)
1111         {
1112           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1113             {
1114               primary_pk = node->pkt->pkt.public_key;
1115               keyid_from_pk (primary_pk, pk_keyid);
1116
1117               /* Is this a self-sig? */
1118               if (pk_keyid[0] == sk_keyid[0] && pk_keyid[1] == sk_keyid[1])
1119                 selfsig = 1;
1120             }
1121           else if (node->pkt->pkttype == PKT_USER_ID)
1122             {
1123               uidnode = (node->flag & NODFLG_MARK_A) ? node : NULL;
1124               if (uidnode)
1125                 {
1126                   int yesreally = 0;
1127                   char *user;
1128
1129                   user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
1130                                          uidnode->pkt->pkt.user_id->len, 0);
1131
1132                   if (opt.only_sign_text_ids
1133                       && uidnode->pkt->pkt.user_id->attribs)
1134                     {
1135                       tty_fprintf (fp, _("Skipping user ID \"%s\","
1136                                          " which is not a text ID.\n"),
1137                                    user);
1138                       uidnode->flag &= ~NODFLG_MARK_A;
1139                       uidnode = NULL;
1140                     }
1141                   else if (uidnode->pkt->pkt.user_id->is_revoked)
1142                     {
1143                       tty_fprintf (fp, _("User ID \"%s\" is revoked."), user);
1144
1145                       if (selfsig)
1146                         tty_fprintf (fp, "\n");
1147                       else if (opt.expert && !quick)
1148                         {
1149                           tty_fprintf (fp, "\n");
1150                           /* No, so remove the mark and continue */
1151                           if (!cpr_get_answer_is_yes ("sign_uid.revoke_okay",
1152                                                       _("Are you sure you "
1153                                                         "still want to sign "
1154                                                         "it? (y/N) ")))
1155                             {
1156                               uidnode->flag &= ~NODFLG_MARK_A;
1157                               uidnode = NULL;
1158                             }
1159                           else if (interactive)
1160                             yesreally = 1;
1161                         }
1162                       else
1163                         {
1164                           uidnode->flag &= ~NODFLG_MARK_A;
1165                           uidnode = NULL;
1166                           tty_fprintf (fp, _("  Unable to sign.\n"));
1167                         }
1168                     }
1169                   else if (uidnode->pkt->pkt.user_id->is_expired)
1170                     {
1171                       tty_fprintf (fp, _("User ID \"%s\" is expired."), user);
1172
1173                       if (selfsig)
1174                         tty_fprintf (fp, "\n");
1175                       else if (opt.expert && !quick)
1176                         {
1177                           tty_fprintf (fp, "\n");
1178                           /* No, so remove the mark and continue */
1179                           if (!cpr_get_answer_is_yes ("sign_uid.expire_okay",
1180                                                       _("Are you sure you "
1181                                                         "still want to sign "
1182                                                         "it? (y/N) ")))
1183                             {
1184                               uidnode->flag &= ~NODFLG_MARK_A;
1185                               uidnode = NULL;
1186                             }
1187                           else if (interactive)
1188                             yesreally = 1;
1189                         }
1190                       else
1191                         {
1192                           uidnode->flag &= ~NODFLG_MARK_A;
1193                           uidnode = NULL;
1194                           tty_fprintf (fp, _("  Unable to sign.\n"));
1195                         }
1196                     }
1197                   else if (!uidnode->pkt->pkt.user_id->created && !selfsig)
1198                     {
1199                       tty_fprintf (fp, _("User ID \"%s\" is not self-signed."),
1200                                    user);
1201
1202                       if (opt.expert && !quick)
1203                         {
1204                           tty_fprintf (fp, "\n");
1205                           /* No, so remove the mark and continue */
1206                           if (!cpr_get_answer_is_yes ("sign_uid.nosig_okay",
1207                                                       _("Are you sure you "
1208                                                         "still want to sign "
1209                                                         "it? (y/N) ")))
1210                             {
1211                               uidnode->flag &= ~NODFLG_MARK_A;
1212                               uidnode = NULL;
1213                             }
1214                           else if (interactive)
1215                             yesreally = 1;
1216                         }
1217                       else
1218                         {
1219                           uidnode->flag &= ~NODFLG_MARK_A;
1220                           uidnode = NULL;
1221                           tty_fprintf (fp, _("  Unable to sign.\n"));
1222                         }
1223                     }
1224
1225                   if (uidnode && interactive && !yesreally && !quick)
1226                     {
1227                       tty_fprintf (fp,
1228                                    _("User ID \"%s\" is signable.  "), user);
1229                       if (!cpr_get_answer_is_yes ("sign_uid.sign_okay",
1230                                                   _("Sign it? (y/N) ")))
1231                         {
1232                           uidnode->flag &= ~NODFLG_MARK_A;
1233                           uidnode = NULL;
1234                         }
1235                     }
1236
1237                   xfree (user);
1238                 }
1239             }
1240           else if (uidnode && node->pkt->pkttype == PKT_SIGNATURE
1241                    && (node->pkt->pkt.signature->sig_class & ~3) == 0x10)
1242             {
1243               if (sk_keyid[0] == node->pkt->pkt.signature->keyid[0]
1244                   && sk_keyid[1] == node->pkt->pkt.signature->keyid[1])
1245                 {
1246                   char buf[50];
1247                   char *user;
1248
1249                   user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
1250                                          uidnode->pkt->pkt.user_id->len, 0);
1251
1252                   /* It's a v3 self-sig.  Make it into a v4 self-sig? */
1253                   if (node->pkt->pkt.signature->version < 4
1254                       && selfsig && !quick)
1255                     {
1256                       tty_fprintf (fp,
1257                                    _("The self-signature on \"%s\"\n"
1258                                      "is a PGP 2.x-style signature.\n"), user);
1259
1260                       /* Note that the regular PGP2 warning below
1261                          still applies if there are no v4 sigs on
1262                          this key at all. */
1263
1264                       if (opt.expert)
1265                         if (cpr_get_answer_is_yes ("sign_uid.v4_promote_okay",
1266                                                    _("Do you want to promote "
1267                                                      "it to an OpenPGP self-"
1268                                                      "signature? (y/N) ")))
1269                           {
1270                             node->flag |= NODFLG_DELSIG;
1271                             xfree (user);
1272                             continue;
1273                           }
1274                     }
1275
1276                   /* Is the current signature expired? */
1277                   if (node->pkt->pkt.signature->flags.expired)
1278                     {
1279                       tty_fprintf (fp, _("Your current signature on \"%s\"\n"
1280                                          "has expired.\n"), user);
1281
1282                       if (quick || cpr_get_answer_is_yes
1283                           ("sign_uid.replace_expired_okay",
1284                            _("Do you want to issue a "
1285                              "new signature to replace "
1286                              "the expired one? (y/N) ")))
1287                         {
1288                           /* Mark these for later deletion.  We
1289                              don't want to delete them here, just in
1290                              case the replacement signature doesn't
1291                              happen for some reason.  We only delete
1292                              these after the replacement is already
1293                              in place. */
1294
1295                           node->flag |= NODFLG_DELSIG;
1296                           xfree (user);
1297                           continue;
1298                         }
1299                     }
1300
1301                   if (!node->pkt->pkt.signature->flags.exportable && !local)
1302                     {
1303                       /* It's a local sig, and we want to make a
1304                          exportable sig. */
1305                       tty_fprintf (fp, _("Your current signature on \"%s\"\n"
1306                                          "is a local signature.\n"), user);
1307
1308                       if (quick || cpr_get_answer_is_yes
1309                           ("sign_uid.local_promote_okay",
1310                            _("Do you want to promote "
1311                              "it to a full exportable " "signature? (y/N) ")))
1312                         {
1313                           /* Mark these for later deletion.  We
1314                              don't want to delete them here, just in
1315                              case the replacement signature doesn't
1316                              happen for some reason.  We only delete
1317                              these after the replacement is already
1318                              in place. */
1319
1320                           node->flag |= NODFLG_DELSIG;
1321                           xfree (user);
1322                           continue;
1323                         }
1324                     }
1325
1326                   /* Fixme: see whether there is a revocation in which
1327                    * case we should allow to sign it again. */
1328                   if (!node->pkt->pkt.signature->flags.exportable && local)
1329                     tty_fprintf ( fp,
1330                        _("\"%s\" was already locally signed by key %s\n"),
1331                        user, keystr_from_pk (pk));
1332                   else
1333                     tty_fprintf (fp,
1334                                 _("\"%s\" was already signed by key %s\n"),
1335                                 user, keystr_from_pk (pk));
1336
1337                   if (opt.expert && !quick
1338                       && cpr_get_answer_is_yes ("sign_uid.dupe_okay",
1339                                                 _("Do you want to sign it "
1340                                                   "again anyway? (y/N) ")))
1341                     {
1342                       /* Don't delete the old sig here since this is
1343                          an --expert thing. */
1344                       xfree (user);
1345                       continue;
1346                     }
1347
1348                   snprintf (buf, sizeof buf, "%08lX%08lX",
1349                             (ulong) pk->keyid[0], (ulong) pk->keyid[1]);
1350                   write_status_text (STATUS_ALREADY_SIGNED, buf);
1351                   uidnode->flag &= ~NODFLG_MARK_A;      /* remove mark */
1352
1353                   xfree (user);
1354                 }
1355             }
1356         }
1357
1358       /* Check whether any uids are left for signing.  */
1359       if (!count_uids_with_flag (keyblock, NODFLG_MARK_A))
1360         {
1361           tty_fprintf (fp, _("Nothing to sign with key %s\n"),
1362                       keystr_from_pk (pk));
1363           continue;
1364         }
1365
1366       /* Ask whether we really should sign these user id(s). */
1367       tty_fprintf (fp, "\n");
1368       show_key_with_all_names (ctrl, fp, keyblock, 1, 0, 1, 0, 0, 0);
1369       tty_fprintf (fp, "\n");
1370
1371       if (primary_pk->expiredate && !selfsig)
1372         {
1373           /* Static analyzer note: A claim that PRIMARY_PK might be
1374              NULL is not correct because it set from the public key
1375              packet which is always the first packet in a keyblock and
1376              parsed in the above loop over the keyblock.  In case the
1377              keyblock has no packets at all and thus the loop was not
1378              entered the above count_uids_with_flag would have
1379              detected this case.  */
1380
1381           u32 now = make_timestamp ();
1382
1383           if (primary_pk->expiredate <= now)
1384             {
1385               tty_fprintf (fp, _("This key has expired!"));
1386
1387               if (opt.expert && !quick)
1388                 {
1389                   tty_fprintf (fp, "  ");
1390                   if (!cpr_get_answer_is_yes ("sign_uid.expired_okay",
1391                                               _("Are you sure you still "
1392                                                 "want to sign it? (y/N) ")))
1393                     continue;
1394                 }
1395               else
1396                 {
1397                   tty_fprintf (fp, _("  Unable to sign.\n"));
1398                   continue;
1399                 }
1400             }
1401           else
1402             {
1403               tty_fprintf (fp, _("This key is due to expire on %s.\n"),
1404                            expirestr_from_pk (primary_pk));
1405
1406               if (opt.ask_cert_expire && !quick)
1407                 {
1408                   char *answer = cpr_get ("sign_uid.expire",
1409                                           _("Do you want your signature to "
1410                                             "expire at the same time? (Y/n) "));
1411                   if (answer_is_yes_no_default (answer, 1))
1412                     {
1413                       /* This fixes the signature timestamp we're
1414                          going to make as now.  This is so the
1415                          expiration date is exactly correct, and not
1416                          a few seconds off (due to the time it takes
1417                          to answer the questions, enter the
1418                          passphrase, etc). */
1419                       timestamp = now;
1420                       duration = primary_pk->expiredate - now;
1421                     }
1422
1423                   cpr_kill_prompt ();
1424                   xfree (answer);
1425                 }
1426             }
1427         }
1428
1429       /* Only ask for duration if we haven't already set it to match
1430          the expiration of the pk */
1431       if (!duration && !selfsig)
1432         {
1433           if (opt.ask_cert_expire && !quick)
1434             duration = ask_expire_interval (1, opt.def_cert_expire);
1435           else
1436             duration = parse_expire_string (opt.def_cert_expire);
1437         }
1438
1439       if (selfsig)
1440         ;
1441       else
1442         {
1443           if (opt.batch || !opt.ask_cert_level || quick)
1444             class = 0x10 + opt.def_cert_level;
1445           else
1446             {
1447               char *answer;
1448
1449               tty_fprintf (fp,
1450                            _("How carefully have you verified the key you are "
1451                             "about to sign actually belongs\nto the person "
1452                             "named above?  If you don't know what to "
1453                             "answer, enter \"0\".\n"));
1454               tty_fprintf (fp, "\n");
1455               tty_fprintf (fp, _("   (0) I will not answer.%s\n"),
1456                           opt.def_cert_level == 0 ? " (default)" : "");
1457               tty_fprintf (fp, _("   (1) I have not checked at all.%s\n"),
1458                           opt.def_cert_level == 1 ? " (default)" : "");
1459               tty_fprintf (fp, _("   (2) I have done casual checking.%s\n"),
1460                           opt.def_cert_level == 2 ? " (default)" : "");
1461               tty_fprintf (fp,
1462                            _("   (3) I have done very careful checking.%s\n"),
1463                           opt.def_cert_level == 3 ? " (default)" : "");
1464               tty_fprintf (fp, "\n");
1465
1466               while (class == 0)
1467                 {
1468                   answer = cpr_get ("sign_uid.class",
1469                                     _("Your selection? "
1470                                       "(enter '?' for more information): "));
1471                   if (answer[0] == '\0')
1472                     class = 0x10 + opt.def_cert_level;  /* Default */
1473                   else if (ascii_strcasecmp (answer, "0") == 0)
1474                     class = 0x10;       /* Generic */
1475                   else if (ascii_strcasecmp (answer, "1") == 0)
1476                     class = 0x11;       /* Persona */
1477                   else if (ascii_strcasecmp (answer, "2") == 0)
1478                     class = 0x12;       /* Casual */
1479                   else if (ascii_strcasecmp (answer, "3") == 0)
1480                     class = 0x13;       /* Positive */
1481                   else
1482                     tty_fprintf (fp, _("Invalid selection.\n"));
1483
1484                   xfree (answer);
1485                 }
1486             }
1487
1488           if (trust && !quick)
1489             trustsig_prompt (&trust_value, &trust_depth, &trust_regexp);
1490         }
1491
1492       if (!quick)
1493         {
1494           p = get_user_id_native (sk_keyid);
1495           tty_fprintf (fp,
1496                    _("Are you sure that you want to sign this key with your\n"
1497                      "key \"%s\" (%s)\n"), p, keystr_from_pk (pk));
1498           xfree (p);
1499         }
1500
1501       if (selfsig)
1502         {
1503           tty_fprintf (fp, "\n");
1504           tty_fprintf (fp, _("This will be a self-signature.\n"));
1505
1506           if (local)
1507             {
1508               tty_fprintf (fp, "\n");
1509               tty_fprintf (fp, _("WARNING: the signature will not be marked "
1510                                  "as non-exportable.\n"));
1511             }
1512
1513           if (nonrevocable)
1514             {
1515               tty_fprintf (fp, "\n");
1516               tty_fprintf (fp, _("WARNING: the signature will not be marked "
1517                                  "as non-revocable.\n"));
1518             }
1519         }
1520       else
1521         {
1522           if (local)
1523             {
1524               tty_fprintf (fp, "\n");
1525               tty_fprintf (fp,
1526                  _("The signature will be marked as non-exportable.\n"));
1527             }
1528
1529           if (nonrevocable)
1530             {
1531               tty_fprintf (fp, "\n");
1532               tty_fprintf (fp,
1533                  _("The signature will be marked as non-revocable.\n"));
1534             }
1535
1536           switch (class)
1537             {
1538             case 0x11:
1539               tty_fprintf (fp, "\n");
1540               tty_fprintf (fp, _("I have not checked this key at all.\n"));
1541               break;
1542
1543             case 0x12:
1544               tty_fprintf (fp, "\n");
1545               tty_fprintf (fp, _("I have checked this key casually.\n"));
1546               break;
1547
1548             case 0x13:
1549               tty_fprintf (fp, "\n");
1550               tty_fprintf (fp, _("I have checked this key very carefully.\n"));
1551               break;
1552             }
1553         }
1554
1555       tty_fprintf (fp, "\n");
1556
1557       if (opt.batch && opt.answer_yes)
1558         ;
1559       else if (quick)
1560         ;
1561       else if (!cpr_get_answer_is_yes ("sign_uid.okay",
1562                                        _("Really sign? (y/N) ")))
1563         continue;
1564
1565       /* Now we can sign the user ids.  */
1566     reloop:  /* (Must use this, because we are modifing the list.)  */
1567       primary_pk = NULL;
1568       for (node = keyblock; node; node = node->next)
1569         {
1570           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1571             primary_pk = node->pkt->pkt.public_key;
1572           else if (node->pkt->pkttype == PKT_USER_ID
1573                    && (node->flag & NODFLG_MARK_A))
1574             {
1575               PACKET *pkt;
1576               PKT_signature *sig;
1577               struct sign_attrib attrib;
1578
1579               log_assert (primary_pk);
1580               memset (&attrib, 0, sizeof attrib);
1581               attrib.non_exportable = local;
1582               attrib.non_revocable = nonrevocable;
1583               attrib.trust_depth = trust_depth;
1584               attrib.trust_value = trust_value;
1585               attrib.trust_regexp = trust_regexp;
1586               node->flag &= ~NODFLG_MARK_A;
1587
1588               /* We force creation of a v4 signature for local
1589                * signatures, otherwise we would not generate the
1590                * subpacket with v3 keys and the signature becomes
1591                * exportable.  */
1592
1593               if (selfsig)
1594                 rc = make_keysig_packet (&sig, primary_pk,
1595                                          node->pkt->pkt.user_id,
1596                                          NULL,
1597                                          pk,
1598                                          0x13, 0, 0, 0,
1599                                          keygen_add_std_prefs, primary_pk,
1600                                          NULL);
1601               else
1602                 rc = make_keysig_packet (&sig, primary_pk,
1603                                          node->pkt->pkt.user_id,
1604                                          NULL,
1605                                          pk,
1606                                          class, 0,
1607                                          timestamp, duration,
1608                                          sign_mk_attrib, &attrib,
1609                                          NULL);
1610               if (rc)
1611                 {
1612                   write_status_error ("keysig", rc);
1613                   log_error (_("signing failed: %s\n"), gpg_strerror (rc));
1614                   goto leave;
1615                 }
1616
1617               *ret_modified = 1;        /* We changed the keyblock. */
1618               update_trust = 1;
1619
1620               pkt = xmalloc_clear (sizeof *pkt);
1621               pkt->pkttype = PKT_SIGNATURE;
1622               pkt->pkt.signature = sig;
1623               insert_kbnode (node, new_kbnode (pkt), PKT_SIGNATURE);
1624               goto reloop;
1625             }
1626         }
1627
1628       /* Delete any sigs that got promoted */
1629       for (node = keyblock; node; node = node->next)
1630         if (node->flag & NODFLG_DELSIG)
1631           delete_kbnode (node);
1632     } /* End loop over signators.  */
1633
1634  leave:
1635   release_sk_list (sk_list);
1636   return rc;
1637 }
1638
1639
1640 /*
1641  * Change the passphrase of the primary and all secondary keys.  Note
1642  * that it is common to use only one passphrase for the primary and
1643  * all subkeys.  However, this is now (since GnuPG 2.1) all up to the
1644  * gpg-agent.  Returns 0 on success or an error code.
1645  */
1646 static gpg_error_t
1647 change_passphrase (ctrl_t ctrl, kbnode_t keyblock)
1648 {
1649   gpg_error_t err;
1650   kbnode_t node;
1651   PKT_public_key *pk;
1652   int any;
1653   u32 keyid[2], subid[2];
1654   char *hexgrip = NULL;
1655   char *cache_nonce = NULL;
1656   char *passwd_nonce = NULL;
1657
1658   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1659   if (!node)
1660     {
1661       log_error ("Oops; public key missing!\n");
1662       err = gpg_error (GPG_ERR_INTERNAL);
1663       goto leave;
1664     }
1665   pk = node->pkt->pkt.public_key;
1666   keyid_from_pk (pk, keyid);
1667
1668   /* Check whether it is likely that we will be able to change the
1669      passphrase for any subkey.  */
1670   for (any = 0, node = keyblock; node; node = node->next)
1671     {
1672       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1673           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1674         {
1675           char *serialno;
1676
1677           pk = node->pkt->pkt.public_key;
1678           keyid_from_pk (pk, subid);
1679
1680           xfree (hexgrip);
1681           err = hexkeygrip_from_pk (pk, &hexgrip);
1682           if (err)
1683             goto leave;
1684           err = agent_get_keyinfo (ctrl, hexgrip, &serialno);
1685           if (!err && serialno)
1686             ; /* Key on card.  */
1687           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1688             ; /* Maybe stub key. */
1689           else if (!err)
1690             any = 1; /* Key is known.  */
1691           else
1692             log_error ("key %s: error getting keyinfo from agent: %s\n",
1693                        keystr_with_sub (keyid, subid), gpg_strerror (err));
1694           xfree (serialno);
1695         }
1696     }
1697   err = 0;
1698   if (!any)
1699     {
1700       tty_printf (_("Key has only stub or on-card key items - "
1701                     "no passphrase to change.\n"));
1702       goto leave;
1703     }
1704
1705   /* Change the passphrase for all keys.  */
1706   for (node = keyblock; node; node = node->next)
1707     {
1708       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1709           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1710         {
1711           char *desc;
1712
1713           pk = node->pkt->pkt.public_key;
1714           keyid_from_pk (pk, subid);
1715
1716           xfree (hexgrip);
1717           err = hexkeygrip_from_pk (pk, &hexgrip);
1718           if (err)
1719             goto leave;
1720
1721           desc = gpg_format_keydesc (pk, FORMAT_KEYDESC_NORMAL, 1);
1722           err = agent_passwd (ctrl, hexgrip, desc, &cache_nonce, &passwd_nonce);
1723           xfree (desc);
1724
1725           if (err)
1726             log_log ((gpg_err_code (err) == GPG_ERR_CANCELED
1727                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1728                      ? GPGRT_LOG_INFO : GPGRT_LOG_ERROR,
1729                      _("key %s: error changing passphrase: %s\n"),
1730                        keystr_with_sub (keyid, subid),
1731                        gpg_strerror (err));
1732           if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1733             break;
1734         }
1735     }
1736
1737  leave:
1738   xfree (hexgrip);
1739   xfree (cache_nonce);
1740   xfree (passwd_nonce);
1741   return err;
1742 }
1743
1744
1745 \f
1746 /* Fix various problems in the keyblock.  Returns true if the keyblock
1747    was changed.  Note that a pointer to the keyblock must be given and
1748    the function may change it (i.e. replacing the first node).  */
1749 static int
1750 fix_keyblock (kbnode_t *keyblockp)
1751 {
1752   int changed = 0;
1753
1754   if (collapse_uids (keyblockp))
1755     changed++;
1756   if (check_all_keysigs (*keyblockp, 0, 1))
1757     changed++;
1758   reorder_keyblock (*keyblockp);
1759   /* If we modified the keyblock, make sure the flags are right. */
1760   if (changed)
1761     merge_keys_and_selfsig (*keyblockp);
1762
1763   return changed;
1764 }
1765
1766
1767 static int
1768 parse_sign_type (const char *str, int *localsig, int *nonrevokesig,
1769                  int *trustsig)
1770 {
1771   const char *p = str;
1772
1773   while (*p)
1774     {
1775       if (ascii_strncasecmp (p, "l", 1) == 0)
1776         {
1777           *localsig = 1;
1778           p++;
1779         }
1780       else if (ascii_strncasecmp (p, "nr", 2) == 0)
1781         {
1782           *nonrevokesig = 1;
1783           p += 2;
1784         }
1785       else if (ascii_strncasecmp (p, "t", 1) == 0)
1786         {
1787           *trustsig = 1;
1788           p++;
1789         }
1790       else
1791         return 0;
1792     }
1793
1794   return 1;
1795 }
1796
1797
1798 \f
1799 /*
1800  * Menu driven key editor.  If seckey_check is true, then a secret key
1801  * that matches username will be looked for.  If it is false, not all
1802  * commands will be available.
1803  *
1804  * Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
1805  */
1806
1807 /* Need an SK for this command */
1808 #define KEYEDIT_NEED_SK 1
1809 /* Cannot be viewing the SK for this command */
1810 #define KEYEDIT_NOT_SK  2
1811 /* Must be viewing the SK for this command */
1812 #define KEYEDIT_ONLY_SK 4
1813 /* Match the tail of the string */
1814 #define KEYEDIT_TAIL_MATCH 8
1815
1816 enum cmdids
1817 {
1818   cmdNONE = 0,
1819   cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
1820   cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
1821   cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
1822   cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
1823   cmdEXPIRE, cmdCHANGEUSAGE, cmdBACKSIGN,
1824 #ifndef NO_TRUST_MODELS
1825   cmdENABLEKEY, cmdDISABLEKEY,
1826 #endif /*!NO_TRUST_MODELS*/
1827   cmdSHOWPREF,
1828   cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
1829   cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdBKUPTOCARD,
1830   cmdCLEAN, cmdMINIMIZE, cmdGRIP, cmdNOP
1831 };
1832
1833 static struct
1834 {
1835   const char *name;
1836   enum cmdids id;
1837   int flags;
1838   const char *desc;
1839 } cmds[] =
1840 {
1841   { "quit", cmdQUIT, 0, N_("quit this menu")},
1842   { "q", cmdQUIT, 0, NULL},
1843   { "save", cmdSAVE, 0, N_("save and quit")},
1844   { "help", cmdHELP, 0, N_("show this help")},
1845   { "?", cmdHELP, 0, NULL},
1846   { "fpr", cmdFPR, 0, N_("show key fingerprint")},
1847   { "grip", cmdGRIP, 0, N_("show the keygrip")},
1848   { "list", cmdLIST, 0, N_("list key and user IDs")},
1849   { "l", cmdLIST, 0, NULL},
1850   { "uid", cmdSELUID, 0, N_("select user ID N")},
1851   { "key", cmdSELKEY, 0, N_("select subkey N")},
1852   { "check", cmdCHECK, 0, N_("check signatures")},
1853   { "c", cmdCHECK, 0, NULL},
1854   { "change-usage", cmdCHANGEUSAGE, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1855   { "cross-certify", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1856   { "backsign", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1857   { "sign", cmdSIGN, KEYEDIT_NOT_SK | KEYEDIT_TAIL_MATCH,
1858     N_("sign selected user IDs [* see below for related commands]")},
1859   { "s", cmdSIGN, KEYEDIT_NOT_SK, NULL},
1860     /* "lsign" and friends will never match since "sign" comes first
1861        and it is a tail match.  They are just here so they show up in
1862        the help menu. */
1863   { "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
1864   { "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
1865   { "nrsign", cmdNOP, 0,
1866     N_("sign selected user IDs with a non-revocable signature")},
1867   { "debug", cmdDEBUG, 0, NULL},
1868   { "adduid", cmdADDUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a user ID")},
1869   { "addphoto", cmdADDPHOTO, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1870     N_("add a photo ID")},
1871   { "deluid", cmdDELUID, KEYEDIT_NOT_SK, N_("delete selected user IDs")},
1872     /* delphoto is really deluid in disguise */
1873   { "delphoto", cmdDELUID, KEYEDIT_NOT_SK, NULL},
1874   { "addkey", cmdADDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a subkey")},
1875 #ifdef ENABLE_CARD_SUPPORT
1876   { "addcardkey", cmdADDCARDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1877     N_("add a key to a smartcard")},
1878   { "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1879     N_("move a key to a smartcard")},
1880   { "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1881     N_("move a backup key to a smartcard")},
1882 #endif /*ENABLE_CARD_SUPPORT */
1883   { "delkey", cmdDELKEY, KEYEDIT_NOT_SK, N_("delete selected subkeys")},
1884   { "addrevoker", cmdADDREVOKER, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1885     N_("add a revocation key")},
1886   { "delsig", cmdDELSIG, KEYEDIT_NOT_SK,
1887     N_("delete signatures from the selected user IDs")},
1888   { "expire", cmdEXPIRE, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1889     N_("change the expiration date for the key or selected subkeys")},
1890   { "primary", cmdPRIMARY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1891     N_("flag the selected user ID as primary")},
1892   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},  /* Dummy command.  */
1893   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
1894   { "pref", cmdPREF, KEYEDIT_NOT_SK, N_("list preferences (expert)")},
1895   { "showpref", cmdSHOWPREF, KEYEDIT_NOT_SK, N_("list preferences (verbose)")},
1896   { "setpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1897     N_("set preference list for the selected user IDs")},
1898   { "updpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1899   { "keyserver", cmdPREFKS, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1900     N_("set the preferred keyserver URL for the selected user IDs")},
1901   { "notation", cmdNOTATION, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1902     N_("set a notation for the selected user IDs")},
1903   { "passwd", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1904     N_("change the passphrase")},
1905   { "password", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1906 #ifndef NO_TRUST_MODELS
1907   { "trust", cmdTRUST, KEYEDIT_NOT_SK, N_("change the ownertrust")},
1908 #endif /*!NO_TRUST_MODELS*/
1909   { "revsig", cmdREVSIG, KEYEDIT_NOT_SK,
1910     N_("revoke signatures on the selected user IDs")},
1911   { "revuid", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1912     N_("revoke selected user IDs")},
1913   { "revphoto", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1914   { "revkey", cmdREVKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1915     N_("revoke key or selected subkeys")},
1916 #ifndef NO_TRUST_MODELS
1917   { "enable", cmdENABLEKEY, KEYEDIT_NOT_SK, N_("enable key")},
1918   { "disable", cmdDISABLEKEY, KEYEDIT_NOT_SK, N_("disable key")},
1919 #endif /*!NO_TRUST_MODELS*/
1920   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
1921   { "clean", cmdCLEAN, KEYEDIT_NOT_SK,
1922     N_("compact unusable user IDs and remove unusable signatures from key")},
1923   { "minimize", cmdMINIMIZE, KEYEDIT_NOT_SK,
1924     N_("compact unusable user IDs and remove all signatures from key")},
1925
1926   { NULL, cmdNONE, 0, NULL}
1927 };
1928
1929
1930 \f
1931 #ifdef HAVE_LIBREADLINE
1932
1933 /*
1934    These two functions are used by readline for command completion.
1935  */
1936
1937 static char *
1938 command_generator (const char *text, int state)
1939 {
1940   static int list_index, len;
1941   const char *name;
1942
1943   /* If this is a new word to complete, initialize now.  This includes
1944      saving the length of TEXT for efficiency, and initializing the
1945      index variable to 0. */
1946   if (!state)
1947     {
1948       list_index = 0;
1949       len = strlen (text);
1950     }
1951
1952   /* Return the next partial match */
1953   while ((name = cmds[list_index].name))
1954     {
1955       /* Only complete commands that have help text */
1956       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
1957         return strdup (name);
1958     }
1959
1960   return NULL;
1961 }
1962
1963 static char **
1964 keyedit_completion (const char *text, int start, int end)
1965 {
1966   /* If we are at the start of a line, we try and command-complete.
1967      If not, just do nothing for now. */
1968
1969   (void) end;
1970
1971   if (start == 0)
1972     return rl_completion_matches (text, command_generator);
1973
1974   rl_attempted_completion_over = 1;
1975
1976   return NULL;
1977 }
1978 #endif /* HAVE_LIBREADLINE */
1979
1980
1981 \f
1982 /* Main function of the menu driven key editor.  */
1983 void
1984 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
1985               strlist_t commands, int quiet, int seckey_check)
1986 {
1987   enum cmdids cmd = 0;
1988   gpg_error_t err = 0;
1989   KBNODE keyblock = NULL;
1990   KEYDB_HANDLE kdbhd = NULL;
1991   int have_seckey = 0;
1992   char *answer = NULL;
1993   int redisplay = 1;
1994   int modified = 0;
1995   int sec_shadowing = 0;
1996   int run_subkey_warnings = 0;
1997   int have_commands = !!commands;
1998
1999   if (opt.command_fd != -1)
2000     ;
2001   else if (opt.batch && !have_commands)
2002     {
2003       log_error (_("can't do this in batch mode\n"));
2004       goto leave;
2005     }
2006
2007 #ifdef HAVE_W32_SYSTEM
2008   /* Due to Windows peculiarities we need to make sure that the
2009      trustdb stale check is done before we open another file
2010      (i.e. by searching for a key).  In theory we could make sure
2011      that the files are closed after use but the open/close caches
2012      inhibits that and flushing the cache right before the stale
2013      check is not easy to implement.  Thus we take the easy way out
2014      and run the stale check as early as possible.  Note, that for
2015      non- W32 platforms it is run indirectly trough a call to
2016      get_validity ().  */
2017   check_trustdb_stale ();
2018 #endif
2019
2020   /* Get the public key */
2021   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
2022   if (err)
2023     {
2024       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
2025       goto leave;
2026     }
2027
2028   if (fix_keyblock (&keyblock))
2029     modified++;
2030
2031   /* See whether we have a matching secret key.  */
2032   if (seckey_check)
2033     {
2034       have_seckey = !agent_probe_any_secret_key (ctrl, keyblock);
2035       if (have_seckey && !quiet)
2036         tty_printf (_("Secret key is available.\n"));
2037     }
2038
2039   /* Main command loop.  */
2040   for (;;)
2041     {
2042       int i, arg_number, photo;
2043       const char *arg_string = "";
2044       char *p;
2045       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
2046
2047       tty_printf ("\n");
2048
2049       if (redisplay && !quiet)
2050         {
2051           /* Show using flags: with_revoker, with_subkeys.  */
2052           show_key_with_all_names (ctrl, NULL, keyblock, 0, 1, 0, 1, 0, 0);
2053           tty_printf ("\n");
2054           redisplay = 0;
2055         }
2056
2057       if (run_subkey_warnings)
2058         {
2059           run_subkey_warnings = 0;
2060           if (!count_selected_keys (keyblock))
2061             subkey_expire_warning (keyblock);
2062         }
2063
2064       do
2065         {
2066           xfree (answer);
2067           if (have_commands)
2068             {
2069               if (commands)
2070                 {
2071                   answer = xstrdup (commands->d);
2072                   commands = commands->next;
2073                 }
2074               else if (opt.batch)
2075                 {
2076                   answer = xstrdup ("quit");
2077                 }
2078               else
2079                 have_commands = 0;
2080             }
2081           if (!have_commands)
2082             {
2083 #ifdef HAVE_LIBREADLINE
2084               tty_enable_completion (keyedit_completion);
2085 #endif
2086               answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
2087               cpr_kill_prompt ();
2088               tty_disable_completion ();
2089             }
2090           trim_spaces (answer);
2091         }
2092       while (*answer == '#');
2093
2094       arg_number = 0; /* Here is the init which egcc complains about.  */
2095       photo = 0;      /* Same here. */
2096       if (!*answer)
2097         cmd = cmdLIST;
2098       else if (*answer == CONTROL_D)
2099         cmd = cmdQUIT;
2100       else if (digitp (answer))
2101         {
2102           cmd = cmdSELUID;
2103           arg_number = atoi (answer);
2104         }
2105       else
2106         {
2107           if ((p = strchr (answer, ' ')))
2108             {
2109               *p++ = 0;
2110               trim_spaces (answer);
2111               trim_spaces (p);
2112               arg_number = atoi (p);
2113               arg_string = p;
2114             }
2115
2116           for (i = 0; cmds[i].name; i++)
2117             {
2118               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
2119                 {
2120                   size_t l = strlen (cmds[i].name);
2121                   size_t a = strlen (answer);
2122                   if (a >= l)
2123                     {
2124                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
2125                         {
2126                           answer[a - l] = '\0';
2127                           break;
2128                         }
2129                     }
2130                 }
2131               else if (!ascii_strcasecmp (answer, cmds[i].name))
2132                 break;
2133             }
2134           if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
2135             {
2136               tty_printf (_("Need the secret key to do this.\n"));
2137               cmd = cmdNOP;
2138             }
2139           else
2140             cmd = cmds[i].id;
2141         }
2142
2143       /* Dispatch the command.  */
2144       switch (cmd)
2145         {
2146         case cmdHELP:
2147           for (i = 0; cmds[i].name; i++)
2148             {
2149               if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
2150                 ; /* Skip those item if we do not have the secret key.  */
2151               else if (cmds[i].desc)
2152                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
2153             }
2154
2155           tty_printf ("\n");
2156           tty_printf
2157             (_("* The 'sign' command may be prefixed with an 'l' for local "
2158                "signatures (lsign),\n"
2159                "  a 't' for trust signatures (tsign), an 'nr' for "
2160                "non-revocable signatures\n"
2161                "  (nrsign), or any combination thereof (ltsign, "
2162                "tnrsign, etc.).\n"));
2163           break;
2164
2165         case cmdLIST:
2166           redisplay = 1;
2167           break;
2168
2169         case cmdFPR:
2170           show_key_and_fingerprint
2171             (keyblock, (*arg_string == '*'
2172                         && (!arg_string[1] || spacep (arg_string + 1))));
2173           break;
2174
2175         case cmdGRIP:
2176           show_key_and_grip (keyblock);
2177           break;
2178
2179         case cmdSELUID:
2180           if (strlen (arg_string) == NAMEHASH_LEN * 2)
2181             redisplay = menu_select_uid_namehash (keyblock, arg_string);
2182           else
2183             {
2184               if (*arg_string == '*'
2185                   && (!arg_string[1] || spacep (arg_string + 1)))
2186                 arg_number = -1;        /* Select all. */
2187               redisplay = menu_select_uid (keyblock, arg_number);
2188             }
2189           break;
2190
2191         case cmdSELKEY:
2192           {
2193             if (*arg_string == '*'
2194                 && (!arg_string[1] || spacep (arg_string + 1)))
2195               arg_number = -1;  /* Select all. */
2196             if (menu_select_key (keyblock, arg_number, p))
2197               redisplay = 1;
2198           }
2199           break;
2200
2201         case cmdCHECK:
2202           check_all_keysigs (keyblock, count_selected_uids (keyblock),
2203                              !strcmp (arg_string, "selfsig"));
2204           break;
2205
2206         case cmdSIGN:
2207           {
2208             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
2209
2210             if (pk->flags.revoked)
2211               {
2212                 tty_printf (_("Key is revoked."));
2213
2214                 if (opt.expert)
2215                   {
2216                     tty_printf ("  ");
2217                     if (!cpr_get_answer_is_yes
2218                         ("keyedit.sign_revoked.okay",
2219                          _("Are you sure you still want to sign it? (y/N) ")))
2220                       break;
2221                   }
2222                 else
2223                   {
2224                     tty_printf (_("  Unable to sign.\n"));
2225                     break;
2226                   }
2227               }
2228
2229             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock))
2230               {
2231                 int result;
2232                 if (opt.only_sign_text_ids)
2233                   result = cpr_get_answer_is_yes
2234                     ("keyedit.sign_all.okay",
2235                      _("Really sign all user IDs? (y/N) "));
2236                 else
2237                   result = cpr_get_answer_is_yes
2238                     ("keyedit.sign_all.okay",
2239                      _("Really sign all text user IDs? (y/N) "));
2240
2241                 if (! result)
2242                   {
2243                     if (opt.interactive)
2244                       interactive = 1;
2245                     else
2246                       {
2247                         tty_printf (_("Hint: Select the user IDs to sign\n"));
2248                         have_commands = 0;
2249                         break;
2250                       }
2251
2252                   }
2253               }
2254             /* What sort of signing are we doing? */
2255             if (!parse_sign_type
2256                 (answer, &localsig, &nonrevokesig, &trustsig))
2257               {
2258                 tty_printf (_("Unknown signature type '%s'\n"), answer);
2259                 break;
2260               }
2261
2262             sign_uids (ctrl, NULL, keyblock, locusr, &modified,
2263                        localsig, nonrevokesig, trustsig, interactive, 0);
2264           }
2265           break;
2266
2267         case cmdDEBUG:
2268           dump_kbnode (keyblock);
2269           break;
2270
2271         case cmdTOGGLE:
2272           /* The toggle command is a leftover from old gpg versions
2273              where we worked with a secret and a public keyring.  It
2274              is not necessary anymore but we keep this command for the
2275              sake of scripts using it.  */
2276           redisplay = 1;
2277           break;
2278
2279         case cmdADDPHOTO:
2280           if (RFC2440)
2281             {
2282               tty_printf (_("This command is not allowed while in %s mode.\n"),
2283                           compliance_option_string ());
2284               break;
2285             }
2286           photo = 1;
2287           /* fall through */
2288         case cmdADDUID:
2289           if (menu_adduid (keyblock, photo, arg_string, NULL))
2290             {
2291               update_trust = 1;
2292               redisplay = 1;
2293               modified = 1;
2294               merge_keys_and_selfsig (keyblock);
2295             }
2296           break;
2297
2298         case cmdDELUID:
2299           {
2300             int n1;
2301
2302             if (!(n1 = count_selected_uids (keyblock)))
2303               {
2304                 tty_printf (_("You must select at least one user ID.\n"));
2305                 if (!opt.expert)
2306                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
2307               }
2308             else if (real_uids_left (keyblock) < 1)
2309               tty_printf (_("You can't delete the last user ID!\n"));
2310             else if (cpr_get_answer_is_yes
2311                      ("keyedit.remove.uid.okay",
2312                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
2313                       :        _("Really remove this user ID? (y/N) ")))
2314               {
2315                 menu_deluid (keyblock);
2316                 redisplay = 1;
2317                 modified = 1;
2318               }
2319           }
2320           break;
2321
2322         case cmdDELSIG:
2323           {
2324             int n1;
2325
2326             if (!(n1 = count_selected_uids (keyblock)))
2327               {
2328                 tty_printf (_("You must select at least one user ID.\n"));
2329                 if (!opt.expert)
2330                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
2331               }
2332             else if (menu_delsig (keyblock))
2333               {
2334                 /* No redisplay here, because it may scroll away some
2335                  * of the status output of this command.  */
2336                 modified = 1;
2337               }
2338           }
2339           break;
2340
2341         case cmdADDKEY:
2342           if (!generate_subkeypair (ctrl, keyblock))
2343             {
2344               redisplay = 1;
2345               modified = 1;
2346               merge_keys_and_selfsig (keyblock);
2347             }
2348           break;
2349
2350 #ifdef ENABLE_CARD_SUPPORT
2351         case cmdADDCARDKEY:
2352           if (!card_generate_subkey (keyblock))
2353             {
2354               redisplay = 1;
2355               modified = 1;
2356               merge_keys_and_selfsig (keyblock);
2357             }
2358           break;
2359
2360         case cmdKEYTOCARD:
2361           {
2362             KBNODE node = NULL;
2363             switch (count_selected_keys (keyblock))
2364               {
2365               case 0:
2366                 if (cpr_get_answer_is_yes
2367                     ("keyedit.keytocard.use_primary",
2368                      /* TRANSLATORS: Please take care: This is about
2369                         moving the key and not about removing it.  */
2370                      _("Really move the primary key? (y/N) ")))
2371                   node = keyblock;
2372                 break;
2373               case 1:
2374                 for (node = keyblock; node; node = node->next)
2375                   {
2376                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2377                         && node->flag & NODFLG_SELKEY)
2378                       break;
2379                   }
2380                 break;
2381               default:
2382                 tty_printf (_("You must select exactly one key.\n"));
2383                 break;
2384               }
2385             if (node)
2386               {
2387                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
2388                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
2389                   {
2390                     redisplay = 1;
2391                     sec_shadowing = 1;
2392                   }
2393               }
2394           }
2395           break;
2396
2397         case cmdBKUPTOCARD:
2398           {
2399             /* Ask for a filename, check whether this is really a
2400                backup key as generated by the card generation, parse
2401                that key and store it on card. */
2402             KBNODE node;
2403             char *fname;
2404             PACKET *pkt;
2405             IOBUF a;
2406
2407             if (!*arg_string)
2408               {
2409                 tty_printf (_("Command expects a filename argument\n"));
2410                 break;
2411               }
2412
2413             if (*arg_string == DIRSEP_C)
2414               fname = xstrdup (arg_string);
2415             else if (*arg_string == '~')
2416               fname = make_filename (arg_string, NULL);
2417             else
2418               fname = make_filename (opt.homedir, arg_string, NULL);
2419
2420             /* Open that file.  */
2421             a = iobuf_open (fname);
2422             if (a && is_secured_file (iobuf_get_fd (a)))
2423               {
2424                 iobuf_close (a);
2425                 a = NULL;
2426                 gpg_err_set_errno (EPERM);
2427               }
2428             if (!a)
2429               {
2430                 tty_printf (_("Can't open '%s': %s\n"),
2431                             fname, strerror (errno));
2432                 xfree (fname);
2433                 break;
2434               }
2435
2436             /* Parse and check that file.  */
2437             pkt = xmalloc (sizeof *pkt);
2438             init_packet (pkt);
2439             err = parse_packet (a, pkt);
2440             iobuf_close (a);
2441             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
2442             if (!err && pkt->pkttype != PKT_SECRET_KEY
2443                 && pkt->pkttype != PKT_SECRET_SUBKEY)
2444               err = GPG_ERR_NO_SECKEY;
2445             if (err)
2446               {
2447                 tty_printf (_("Error reading backup key from '%s': %s\n"),
2448                             fname, gpg_strerror (err));
2449                 xfree (fname);
2450                 free_packet (pkt);
2451                 xfree (pkt);
2452                 break;
2453               }
2454
2455             xfree (fname);
2456             node = new_kbnode (pkt);
2457
2458             /* Transfer it to gpg-agent which handles secret keys.  */
2459             err = transfer_secret_keys (ctrl, NULL, node, 1, 1);
2460
2461             /* Treat the pkt as a public key.  */
2462             pkt->pkttype = PKT_PUBLIC_KEY;
2463
2464             /* Ask gpg-agent to store the secret key to card.  */
2465             if (card_store_subkey (node, 0))
2466               {
2467                 redisplay = 1;
2468                 sec_shadowing = 1;
2469               }
2470             release_kbnode (node);
2471           }
2472           break;
2473
2474 #endif /* ENABLE_CARD_SUPPORT */
2475
2476         case cmdDELKEY:
2477           {
2478             int n1;
2479
2480             if (!(n1 = count_selected_keys (keyblock)))
2481               {
2482                 tty_printf (_("You must select at least one key.\n"));
2483                 if (!opt.expert)
2484                   tty_printf (_("(Use the '%s' command.)\n"), "key");
2485               }
2486             else if (!cpr_get_answer_is_yes
2487                      ("keyedit.remove.subkey.okay",
2488                       n1 > 1 ? _("Do you really want to delete the "
2489                                  "selected keys? (y/N) ")
2490                       :  _("Do you really want to delete this key? (y/N) ")))
2491               ;
2492             else
2493               {
2494                 menu_delkey (keyblock);
2495                 redisplay = 1;
2496                 modified = 1;
2497               }
2498           }
2499           break;
2500
2501         case cmdADDREVOKER:
2502           {
2503             int sensitive = 0;
2504
2505             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
2506               sensitive = 1;
2507             if (menu_addrevoker (ctrl, keyblock, sensitive))
2508               {
2509                 redisplay = 1;
2510                 modified = 1;
2511                 merge_keys_and_selfsig (keyblock);
2512               }
2513           }
2514           break;
2515
2516         case cmdREVUID:
2517           {
2518             int n1;
2519
2520             if (!(n1 = count_selected_uids (keyblock)))
2521               {
2522                 tty_printf (_("You must select at least one user ID.\n"));
2523                 if (!opt.expert)
2524                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
2525               }
2526             else if (cpr_get_answer_is_yes
2527                      ("keyedit.revoke.uid.okay",
2528                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
2529                       :        _("Really revoke this user ID? (y/N) ")))
2530               {
2531                 if (menu_revuid (keyblock))
2532                   {
2533                     modified = 1;
2534                     redisplay = 1;
2535                   }
2536               }
2537           }
2538           break;
2539
2540         case cmdREVKEY:
2541           {
2542             int n1;
2543
2544             if (!(n1 = count_selected_keys (keyblock)))
2545               {
2546                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2547                                            _("Do you really want to revoke"
2548                                              " the entire key? (y/N) ")))
2549                   {
2550                     if (menu_revkey (keyblock))
2551                       modified = 1;
2552
2553                     redisplay = 1;
2554                   }
2555               }
2556             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2557                                             n1 > 1 ?
2558                                             _("Do you really want to revoke"
2559                                               " the selected subkeys? (y/N) ")
2560                                             : _("Do you really want to revoke"
2561                                                 " this subkey? (y/N) ")))
2562               {
2563                 if (menu_revsubkey (keyblock))
2564                   modified = 1;
2565
2566                 redisplay = 1;
2567               }
2568
2569             if (modified)
2570               merge_keys_and_selfsig (keyblock);
2571           }
2572           break;
2573
2574         case cmdEXPIRE:
2575           if (menu_expire (keyblock))
2576             {
2577               merge_keys_and_selfsig (keyblock);
2578               run_subkey_warnings = 1;
2579               modified = 1;
2580               redisplay = 1;
2581             }
2582           break;
2583
2584         case cmdCHANGEUSAGE:
2585           if (menu_changeusage (keyblock))
2586             {
2587               merge_keys_and_selfsig (keyblock);
2588               modified = 1;
2589               redisplay = 1;
2590             }
2591           break;
2592
2593         case cmdBACKSIGN:
2594           if (menu_backsign (keyblock))
2595             {
2596               modified = 1;
2597               redisplay = 1;
2598             }
2599           break;
2600
2601         case cmdPRIMARY:
2602           if (menu_set_primary_uid (keyblock))
2603             {
2604               merge_keys_and_selfsig (keyblock);
2605               modified = 1;
2606               redisplay = 1;
2607             }
2608           break;
2609
2610         case cmdPASSWD:
2611           change_passphrase (ctrl, keyblock);
2612           break;
2613
2614 #ifndef NO_TRUST_MODELS
2615         case cmdTRUST:
2616           if (opt.trust_model == TM_EXTERNAL)
2617             {
2618               tty_printf (_("Owner trust may not be set while "
2619                             "using a user provided trust database\n"));
2620               break;
2621             }
2622
2623           show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
2624           tty_printf ("\n");
2625           if (edit_ownertrust (find_kbnode (keyblock,
2626                                             PKT_PUBLIC_KEY)->pkt->pkt.
2627                                public_key, 1))
2628             {
2629               redisplay = 1;
2630               /* No real need to set update_trust here as
2631                  edit_ownertrust() calls revalidation_mark()
2632                  anyway. */
2633               update_trust = 1;
2634             }
2635           break;
2636 #endif /*!NO_TRUST_MODELS*/
2637
2638         case cmdPREF:
2639           {
2640             int count = count_selected_uids (keyblock);
2641             log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2642             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2643                         count ? NODFLG_SELUID : 0, 1);
2644           }
2645           break;
2646
2647         case cmdSHOWPREF:
2648           {
2649             int count = count_selected_uids (keyblock);
2650             log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2651             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2652                         count ? NODFLG_SELUID : 0, 2);
2653           }
2654           break;
2655
2656         case cmdSETPREF:
2657           {
2658             PKT_user_id *tempuid;
2659
2660             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2661
2662             tempuid = keygen_get_std_prefs ();
2663             tty_printf (_("Set preference list to:\n"));
2664             show_prefs (tempuid, NULL, 1);
2665             free_user_id (tempuid);
2666
2667             if (cpr_get_answer_is_yes
2668                 ("keyedit.setpref.okay",
2669                  count_selected_uids (keyblock) ?
2670                  _("Really update the preferences"
2671                    " for the selected user IDs? (y/N) ")
2672                  : _("Really update the preferences? (y/N) ")))
2673               {
2674                 if (menu_set_preferences (keyblock))
2675                   {
2676                     merge_keys_and_selfsig (keyblock);
2677                     modified = 1;
2678                     redisplay = 1;
2679                   }
2680               }
2681           }
2682           break;
2683
2684         case cmdPREFKS:
2685           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2686                                       keyblock))
2687             {
2688               merge_keys_and_selfsig (keyblock);
2689               modified = 1;
2690               redisplay = 1;
2691             }
2692           break;
2693
2694         case cmdNOTATION:
2695           if (menu_set_notation (*arg_string ? arg_string : NULL,
2696                                  keyblock))
2697             {
2698               merge_keys_and_selfsig (keyblock);
2699               modified = 1;
2700               redisplay = 1;
2701             }
2702           break;
2703
2704         case cmdNOP:
2705           break;
2706
2707         case cmdREVSIG:
2708           if (menu_revsig (keyblock))
2709             {
2710               redisplay = 1;
2711               modified = 1;
2712             }
2713           break;
2714
2715 #ifndef NO_TRUST_MODELS
2716         case cmdENABLEKEY:
2717         case cmdDISABLEKEY:
2718           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2719             {
2720               redisplay = 1;
2721               modified = 1;
2722             }
2723           break;
2724 #endif /*!NO_TRUST_MODELS*/
2725
2726         case cmdSHOWPHOTO:
2727           menu_showphoto (keyblock);
2728           break;
2729
2730         case cmdCLEAN:
2731           if (menu_clean (keyblock, 0))
2732             redisplay = modified = 1;
2733           break;
2734
2735         case cmdMINIMIZE:
2736           if (menu_clean (keyblock, 1))
2737             redisplay = modified = 1;
2738           break;
2739
2740         case cmdQUIT:
2741           if (have_commands)
2742             goto leave;
2743           if (!modified && !sec_shadowing)
2744             goto leave;
2745           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2746                                       _("Save changes? (y/N) ")))
2747             {
2748               if (cpr_enabled ()
2749                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2750                                             _("Quit without saving? (y/N) ")))
2751                 goto leave;
2752               break;
2753             }
2754           /* fall thru */
2755         case cmdSAVE:
2756           if (modified)
2757             {
2758               err = keydb_update_keyblock (kdbhd, keyblock);
2759               if (err)
2760                 {
2761                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2762                   break;
2763                 }
2764             }
2765
2766           if (sec_shadowing)
2767             {
2768               err = agent_scd_learn (NULL, 1);
2769               if (err)
2770                 {
2771                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2772                   break;
2773                 }
2774             }
2775
2776           if (!modified && !sec_shadowing)
2777             tty_printf (_("Key not changed so no update needed.\n"));
2778
2779           if (update_trust)
2780             {
2781               revalidation_mark ();
2782               update_trust = 0;
2783             }
2784           goto leave;
2785
2786         case cmdINVCMD:
2787         default:
2788           tty_printf ("\n");
2789           tty_printf (_("Invalid command  (try \"help\")\n"));
2790           break;
2791         }
2792     } /* End of the main command loop.  */
2793
2794  leave:
2795   release_kbnode (keyblock);
2796   keydb_release (kdbhd);
2797   xfree (answer);
2798 }
2799
2800
2801 /* Change the passphrase of the secret key identified by USERNAME.  */
2802 void
2803 keyedit_passwd (ctrl_t ctrl, const char *username)
2804 {
2805   gpg_error_t err;
2806   PKT_public_key *pk;
2807   kbnode_t keyblock = NULL;
2808
2809   pk = xtrycalloc (1, sizeof *pk);
2810   if (!pk)
2811     {
2812       err = gpg_error_from_syserror ();
2813       goto leave;
2814     }
2815   err = getkey_byname (ctrl, NULL, pk, username, 1, &keyblock);
2816   if (err)
2817     goto leave;
2818
2819   err = change_passphrase (ctrl, keyblock);
2820
2821 leave:
2822   release_kbnode (keyblock);
2823   free_public_key (pk);
2824   if (err)
2825     {
2826       log_info ("error changing the passphrase for '%s': %s\n",
2827                 username, gpg_strerror (err));
2828       write_status_error ("keyedit.passwd", err);
2829     }
2830   else
2831     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2832 }
2833
2834
2835 /* Unattended adding of a new keyid.  USERNAME specifies the
2836    key. NEWUID is the new user id to add to the key.  */
2837 void
2838 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2839 {
2840   gpg_error_t err;
2841   KEYDB_HANDLE kdbhd = NULL;
2842   KEYDB_SEARCH_DESC desc;
2843   kbnode_t keyblock = NULL;
2844   kbnode_t node;
2845   char *uidstring = NULL;
2846
2847   uidstring = xstrdup (newuid);
2848   trim_spaces (uidstring);
2849   if (!*uidstring)
2850     {
2851       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2852       goto leave;
2853     }
2854
2855 #ifdef HAVE_W32_SYSTEM
2856   /* See keyedit_menu for why we need this.  */
2857   check_trustdb_stale ();
2858 #endif
2859
2860   /* Search the key; we don't want the whole getkey stuff here.  */
2861   kdbhd = keydb_new ();
2862   if (!kdbhd)
2863     {
2864       /* Note that keydb_new has already used log_error.  */
2865       goto leave;
2866     }
2867
2868   err = classify_user_id (username, &desc, 1);
2869   if (!err)
2870     err = keydb_search (kdbhd, &desc, 1, NULL);
2871   if (!err)
2872     {
2873       err = keydb_get_keyblock (kdbhd, &keyblock);
2874       if (err)
2875         {
2876           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2877           goto leave;
2878         }
2879       /* Now with the keyblock retrieved, search again to detect an
2880          ambiguous specification.  We need to save the found state so
2881          that we can do an update later.  */
2882       keydb_push_found_state (kdbhd);
2883       err = keydb_search (kdbhd, &desc, 1, NULL);
2884       if (!err)
2885         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2886       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2887         err = 0;
2888       keydb_pop_found_state (kdbhd);
2889
2890       if (!err)
2891         {
2892           /* We require the secret primary key to add a UID.  */
2893           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2894           if (!node)
2895             BUG ();
2896           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2897         }
2898     }
2899   if (err)
2900     {
2901       log_error (_("secret key \"%s\" not found: %s\n"),
2902                  username, gpg_strerror (err));
2903       goto leave;
2904     }
2905
2906   fix_keyblock (&keyblock);
2907
2908   if (menu_adduid (keyblock, 0, NULL, uidstring))
2909     {
2910       err = keydb_update_keyblock (kdbhd, keyblock);
2911       if (err)
2912         {
2913           log_error (_("update failed: %s\n"), gpg_strerror (err));
2914           goto leave;
2915         }
2916
2917       if (update_trust)
2918         revalidation_mark ();
2919     }
2920
2921  leave:
2922   xfree (uidstring);
2923   release_kbnode (keyblock);
2924   keydb_release (kdbhd);
2925 }
2926
2927
2928 /* Unattended key signing function.  If the key specifified by FPR is
2929    available and FPR is the primary fingerprint all user ids of the
2930    key are signed using the default signing key.  If UIDS is an empty
2931    list all usable UIDs are signed, if it is not empty, only those
2932    user ids matching one of the entries of the list are signed.  With
2933    LOCAL being true the signatures are marked as non-exportable.  */
2934 void
2935 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2936                     strlist_t locusr, int local)
2937 {
2938   gpg_error_t err;
2939   kbnode_t keyblock = NULL;
2940   KEYDB_HANDLE kdbhd = NULL;
2941   int modified = 0;
2942   KEYDB_SEARCH_DESC desc;
2943   PKT_public_key *pk;
2944   kbnode_t node;
2945   strlist_t sl;
2946   int any;
2947
2948 #ifdef HAVE_W32_SYSTEM
2949   /* See keyedit_menu for why we need this.  */
2950   check_trustdb_stale ();
2951 #endif
2952
2953   /* We require a fingerprint because only this uniquely identifies a
2954      key and may thus be used to select a key for unattended key
2955      signing.  */
2956   if (classify_user_id (fpr, &desc, 1)
2957       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2958            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2959            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2960     {
2961       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2962       goto leave;
2963     }
2964   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2965   if (err)
2966     {
2967       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2968       goto leave;
2969     }
2970
2971   /* Check that the primary fingerprint has been given. */
2972   {
2973     byte fprbin[MAX_FINGERPRINT_LEN];
2974     size_t fprlen;
2975
2976     fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2977     if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2978         && !memcmp (fprbin, desc.u.fpr, 16))
2979       ;
2980     else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2981              && !memcmp (fprbin, desc.u.fpr, 16)
2982              && !desc.u.fpr[16]
2983              && !desc.u.fpr[17]
2984              && !desc.u.fpr[18]
2985              && !desc.u.fpr[19])
2986       ;
2987     else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2988                               || desc.mode == KEYDB_SEARCH_MODE_FPR)
2989              && !memcmp (fprbin, desc.u.fpr, 20))
2990       ;
2991     else
2992       {
2993         log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2994         goto leave;
2995       }
2996   }
2997
2998   if (fix_keyblock (&keyblock))
2999     modified++;
3000
3001   /* Give some info in verbose.  */
3002   if (opt.verbose)
3003     {
3004       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
3005                                1/*with_revoker*/, 1/*with_fingerprint*/,
3006                                0, 0, 1);
3007       es_fflush (es_stdout);
3008     }
3009
3010   pk = keyblock->pkt->pkt.public_key;
3011   if (pk->flags.revoked)
3012     {
3013       if (!opt.verbose)
3014         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
3015       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
3016       goto leave;
3017     }
3018
3019   /* Set the flags according to the UIDS list.  Fixme: We may want to
3020      use classify_user_id along with dedicated compare functions so
3021      that we match the same way as in the key lookup. */
3022   any = 0;
3023   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
3024   for (sl=uids; sl; sl = sl->next)
3025     {
3026       const char *name = sl->d;
3027       int count = 0;
3028
3029       sl->flags &= ~(1|2);  /* Clear flags used for error reporting.  */
3030
3031       for (node = keyblock; node; node = node->next)
3032         {
3033           if (node->pkt->pkttype == PKT_USER_ID)
3034             {
3035               PKT_user_id *uid = node->pkt->pkt.user_id;
3036
3037               if (uid->attrib_data)
3038                 ;
3039               else if (*name == '='
3040                        && strlen (name+1) == uid->len
3041                        && !memcmp (uid->name, name + 1, uid->len))
3042                 { /* Exact match - we don't do a check for ambiguity
3043                    * in this case.  */
3044                   node->flag |= NODFLG_SELUID;
3045                   if (any != -1)
3046                     {
3047                       sl->flags |= 1;  /* Report as found.  */
3048                       any = 1;
3049                     }
3050                 }
3051               else if (ascii_memistr (uid->name, uid->len,
3052                                       *name == '*'? name+1:name))
3053                 {
3054                   node->flag |= NODFLG_SELUID;
3055                   if (any != -1)
3056                     {
3057                       sl->flags |= 1;  /* Report as found.  */
3058                       any = 1;
3059                     }
3060                   count++;
3061                 }
3062             }
3063         }
3064
3065       if (count > 1)
3066         {
3067           any = -1;        /* Force failure at end.  */
3068           sl->flags |= 2;  /* Report as ambiguous.  */
3069         }
3070     }
3071
3072   /* Check whether all given user ids were found.  */
3073   for (sl=uids; sl; sl = sl->next)
3074     if (!(sl->flags & 1))
3075       any = -1;  /* That user id was not found.  */
3076
3077   /* Print an error if there was a problem with the user ids.  */
3078   if (uids && any < 1)
3079     {
3080       if (!opt.verbose)
3081         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
3082       es_fflush (es_stdout);
3083       for (sl=uids; sl; sl = sl->next)
3084         {
3085           if ((sl->flags & 2))
3086             log_info (_("Invalid user ID '%s': %s\n"),
3087                       sl->d, gpg_strerror (GPG_ERR_AMBIGUOUS_NAME));
3088           else if (!(sl->flags & 1))
3089             log_info (_("Invalid user ID '%s': %s\n"),
3090                       sl->d, gpg_strerror (GPG_ERR_NOT_FOUND));
3091         }
3092       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
3093       goto leave;
3094     }
3095
3096   /* Sign. */
3097   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
3098   es_fflush (es_stdout);
3099
3100   if (modified)
3101     {
3102       err = keydb_update_keyblock (kdbhd, keyblock);
3103       if (err)
3104         {
3105           log_error (_("update failed: %s\n"), gpg_strerror (err));
3106           goto leave;
3107         }
3108     }
3109   else
3110     log_info (_("Key not changed so no update needed.\n"));
3111
3112   if (update_trust)
3113     revalidation_mark ();
3114
3115
3116  leave:
3117   release_kbnode (keyblock);
3118   keydb_release (kdbhd);
3119 }
3120
3121
3122 \f
3123 static void
3124 tty_print_notations (int indent, PKT_signature * sig)
3125 {
3126   int first = 1;
3127   struct notation *notation, *nd;
3128
3129   if (indent < 0)
3130     {
3131       first = 0;
3132       indent = -indent;
3133     }
3134
3135   notation = sig_to_notation (sig);
3136
3137   for (nd = notation; nd; nd = nd->next)
3138     {
3139       if (!first)
3140         tty_printf ("%*s", indent, "");
3141       else
3142         first = 0;
3143
3144       tty_print_utf8_string (nd->name, strlen (nd->name));
3145       tty_printf ("=");
3146       tty_print_utf8_string (nd->value, strlen (nd->value));
3147       tty_printf ("\n");
3148     }
3149
3150   free_notation (notation);
3151 }
3152
3153
3154 /*
3155  * Show preferences of a public keyblock.
3156  */
3157 static void
3158 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
3159 {
3160   const prefitem_t fake = { 0, 0 };
3161   const prefitem_t *prefs;
3162   int i;
3163
3164   if (!uid)
3165     return;
3166
3167   if (uid->prefs)
3168     prefs = uid->prefs;
3169   else if (verbose)
3170     prefs = &fake;
3171   else
3172     return;
3173
3174   if (verbose)
3175     {
3176       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
3177
3178       tty_printf ("     ");
3179       tty_printf (_("Cipher: "));
3180       for (i = any = 0; prefs[i].type; i++)
3181         {
3182           if (prefs[i].type == PREFTYPE_SYM)
3183             {
3184               if (any)
3185                 tty_printf (", ");
3186               any = 1;
3187               /* We don't want to display strings for experimental algos */
3188               if (!openpgp_cipher_test_algo (prefs[i].value)
3189                   && prefs[i].value < 100)
3190                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
3191               else
3192                 tty_printf ("[%d]", prefs[i].value);
3193               if (prefs[i].value == CIPHER_ALGO_3DES)
3194                 des_seen = 1;
3195             }
3196         }
3197       if (!des_seen)
3198         {
3199           if (any)
3200             tty_printf (", ");
3201           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
3202         }
3203       tty_printf ("\n     ");
3204       tty_printf (_("Digest: "));
3205       for (i = any = 0; prefs[i].type; i++)
3206         {
3207           if (prefs[i].type == PREFTYPE_HASH)
3208             {
3209               if (any)
3210                 tty_printf (", ");
3211               any = 1;
3212               /* We don't want to display strings for experimental algos */
3213               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
3214                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
3215               else
3216                 tty_printf ("[%d]", prefs[i].value);
3217               if (prefs[i].value == DIGEST_ALGO_SHA1)
3218                 sha1_seen = 1;
3219             }
3220         }
3221       if (!sha1_seen)
3222         {
3223           if (any)
3224             tty_printf (", ");
3225           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
3226         }
3227       tty_printf ("\n     ");
3228       tty_printf (_("Compression: "));
3229       for (i = any = 0; prefs[i].type; i++)
3230         {
3231           if (prefs[i].type == PREFTYPE_ZIP)
3232             {
3233               const char *s = compress_algo_to_string (prefs[i].value);
3234
3235               if (any)
3236                 tty_printf (", ");
3237               any = 1;
3238               /* We don't want to display strings for experimental algos */
3239               if (s && prefs[i].value < 100)
3240                 tty_printf ("%s", s);
3241               else
3242                 tty_printf ("[%d]", prefs[i].value);
3243               if (prefs[i].value == COMPRESS_ALGO_NONE)
3244                 uncomp_seen = 1;
3245             }
3246         }
3247       if (!uncomp_seen)
3248         {
3249           if (any)
3250             tty_printf (", ");
3251           else
3252             {
3253               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
3254               tty_printf (", ");
3255             }
3256           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
3257         }
3258       if (uid->flags.mdc || !uid->flags.ks_modify)
3259         {
3260           tty_printf ("\n     ");
3261           tty_printf (_("Features: "));
3262           any = 0;
3263           if (uid->flags.mdc)
3264             {
3265               tty_printf ("MDC");
3266               any = 1;
3267             }
3268           if (!uid->flags.ks_modify)
3269             {
3270               if (any)
3271                 tty_printf (", ");
3272               tty_printf (_("Keyserver no-modify"));
3273             }
3274         }
3275       tty_printf ("\n");
3276
3277       if (selfsig)
3278         {
3279           const byte *pref_ks;
3280           size_t pref_ks_len;
3281
3282           pref_ks = parse_sig_subpkt (selfsig->hashed,
3283                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
3284           if (pref_ks && pref_ks_len)
3285             {
3286               tty_printf ("     ");
3287               tty_printf (_("Preferred keyserver: "));
3288               tty_print_utf8_string (pref_ks, pref_ks_len);
3289               tty_printf ("\n");
3290             }
3291
3292           if (selfsig->flags.notation)
3293             {
3294               tty_printf ("     ");
3295               tty_printf (_("Notations: "));
3296               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
3297             }
3298         }
3299     }
3300   else
3301     {
3302       tty_printf ("    ");
3303       for (i = 0; prefs[i].type; i++)
3304         {
3305           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
3306                       prefs[i].type == PREFTYPE_HASH ? 'H' :
3307                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
3308                       prefs[i].value);
3309         }
3310       if (uid->flags.mdc)
3311         tty_printf (" [mdc]");
3312       if (!uid->flags.ks_modify)
3313         tty_printf (" [no-ks-modify]");
3314       tty_printf ("\n");
3315     }
3316 }
3317
3318
3319 /* This is the version of show_key_with_all_names used when
3320    opt.with_colons is used.  It prints all available data in a easy to
3321    parse format and does not translate utf8 */
3322 static void
3323 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
3324 {
3325   KBNODE node;
3326   int i, j, ulti_hack = 0;
3327   byte pk_version = 0;
3328   PKT_public_key *primary = NULL;
3329   int have_seckey;
3330
3331   if (!fp)
3332     fp = es_stdout;
3333
3334   /* the keys */
3335   for (node = keyblock; node; node = node->next)
3336     {
3337       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3338           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
3339         {
3340           PKT_public_key *pk = node->pkt->pkt.public_key;
3341           u32 keyid[2];
3342
3343           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3344             {
3345               pk_version = pk->version;
3346               primary = pk;
3347             }