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