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