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