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