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