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