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