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