gpg: Keep a lock during the read-update/insert cycle in import.
[gnupg.git] / g10 / revoke.c
1 /* revoke.c - Create recovation certificates.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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 3 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, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <ctype.h>
27
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "../common/status.h"
32 #include "keydb.h"
33 #include "../common/util.h"
34 #include "main.h"
35 #include "../common/ttyio.h"
36 #include "../common/i18n.h"
37 #include "call-agent.h"
38
39 struct revocation_reason_info {
40     int code;
41     char *desc;
42 };
43
44
45 int
46 revocation_reason_build_cb( PKT_signature *sig, void *opaque )
47 {
48     struct revocation_reason_info *reason = opaque;
49     char *ud = NULL;
50     byte *buffer;
51     size_t buflen = 1;
52
53     if(!reason)
54       return 0;
55
56     if( reason->desc ) {
57         ud = native_to_utf8( reason->desc );
58         buflen += strlen(ud);
59     }
60     buffer = xmalloc( buflen );
61     *buffer = reason->code;
62     if( ud ) {
63         memcpy(buffer+1, ud, strlen(ud) );
64         xfree( ud );
65     }
66
67     build_sig_subpkt( sig, SIGSUBPKT_REVOC_REASON, buffer, buflen );
68     xfree( buffer );
69     return 0;
70 }
71
72 /* Outputs a minimal pk (as defined by 2440) from a keyblock.  A
73    minimal pk consists of the public key packet and a user ID.  We try
74    and pick a user ID that has a uid signature, and include it if
75    possible. */
76 static int
77 export_minimal_pk(IOBUF out,KBNODE keyblock,
78                   PKT_signature *revsig,PKT_signature *revkey)
79 {
80   KBNODE node;
81   PACKET pkt;
82   PKT_user_id *uid=NULL;
83   PKT_signature *selfsig=NULL;
84   u32 keyid[2];
85   int rc;
86
87   node=find_kbnode(keyblock,PKT_PUBLIC_KEY);
88   if(!node)
89     {
90       log_error("key incomplete\n");
91       return GPG_ERR_GENERAL;
92     }
93
94   keyid_from_pk(node->pkt->pkt.public_key,keyid);
95
96   pkt=*node->pkt;
97   rc=build_packet(out,&pkt);
98   if(rc)
99     {
100       log_error(_("build_packet failed: %s\n"), gpg_strerror (rc) );
101       return rc;
102     }
103
104   init_packet(&pkt);
105   pkt.pkttype=PKT_SIGNATURE;
106
107   /* the revocation itself, if any.  2440 likes this to come first. */
108   if(revsig)
109     {
110       pkt.pkt.signature=revsig;
111       rc=build_packet(out,&pkt);
112       if(rc)
113         {
114           log_error("build_packet failed: %s\n", gpg_strerror (rc) );
115           return rc;
116         }
117     }
118
119   /* If a revkey in a 1F sig is present, include it too */
120   if(revkey)
121     {
122       pkt.pkt.signature=revkey;
123       rc=build_packet(out,&pkt);
124       if(rc)
125         {
126           log_error(_("build_packet failed: %s\n"), gpg_strerror (rc) );
127           return rc;
128         }
129     }
130
131   while(!selfsig)
132     {
133       KBNODE signode;
134
135       node=find_next_kbnode(node,PKT_USER_ID);
136       if(!node)
137         {
138           /* We're out of user IDs - none were self-signed. */
139           if(uid)
140             break;
141           else
142             {
143               log_error(_("key %s has no user IDs\n"),keystr(keyid));
144               return GPG_ERR_GENERAL;
145             }
146         }
147
148       if(node->pkt->pkt.user_id->attrib_data)
149         continue;
150
151       uid=node->pkt->pkt.user_id;
152       signode=node;
153
154       while((signode=find_next_kbnode(signode,PKT_SIGNATURE)))
155         {
156           if(keyid[0]==signode->pkt->pkt.signature->keyid[0] &&
157              keyid[1]==signode->pkt->pkt.signature->keyid[1] &&
158              IS_UID_SIG(signode->pkt->pkt.signature))
159             {
160               selfsig=signode->pkt->pkt.signature;
161               break;
162             }
163         }
164     }
165
166   pkt.pkttype=PKT_USER_ID;
167   pkt.pkt.user_id=uid;
168
169   rc=build_packet(out,&pkt);
170   if(rc)
171     {
172       log_error(_("build_packet failed: %s\n"), gpg_strerror (rc) );
173       return rc;
174     }
175
176   if(selfsig)
177     {
178       pkt.pkttype=PKT_SIGNATURE;
179       pkt.pkt.signature=selfsig;
180
181       rc=build_packet(out,&pkt);
182       if(rc)
183         {
184           log_error(_("build_packet failed: %s\n"), gpg_strerror (rc) );
185           return rc;
186         }
187     }
188
189   return 0;
190 }
191
192 /****************
193  * Generate a revocation certificate for UNAME via a designated revoker
194  */
195 int
196 gen_desig_revoke (ctrl_t ctrl, const char *uname, strlist_t locusr)
197 {
198     int rc = 0;
199     armor_filter_context_t *afx;
200     PKT_public_key *pk = NULL;
201     PKT_public_key *pk2 = NULL;
202     PKT_signature *sig = NULL;
203     IOBUF out = NULL;
204     struct revocation_reason_info *reason = NULL;
205     KEYDB_HANDLE kdbhd;
206     KEYDB_SEARCH_DESC desc;
207     KBNODE keyblock=NULL,node;
208     u32 keyid[2];
209     int i,any=0;
210     SK_LIST sk_list=NULL;
211
212     if( opt.batch )
213       {
214         log_error(_("can't do this in batch mode\n"));
215         return GPG_ERR_GENERAL;
216       }
217
218     afx = new_armor_context ();
219
220     kdbhd = keydb_new ();
221     if (!kdbhd)
222       {
223         rc = gpg_error_from_syserror ();
224         goto leave;
225       }
226     rc = classify_user_id (uname, &desc, 1);
227     if (!rc)
228       rc = keydb_search (kdbhd, &desc, 1, NULL);
229     if (rc) {
230         log_error (_("key \"%s\" not found: %s\n"),uname, gpg_strerror (rc));
231         goto leave;
232     }
233
234     rc = keydb_get_keyblock (kdbhd, &keyblock );
235     if( rc ) {
236         log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
237         goto leave;
238     }
239
240     /* To parse the revkeys */
241     merge_keys_and_selfsig (ctrl, keyblock);
242
243     /* get the key from the keyblock */
244     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
245     if( !node )
246       BUG ();
247
248     pk=node->pkt->pkt.public_key;
249
250     keyid_from_pk(pk,keyid);
251
252     if(locusr)
253       {
254         rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_CERT);
255         if(rc)
256           goto leave;
257       }
258
259     /* Are we a designated revoker for this key? */
260
261     if(!pk->revkey && pk->numrevkeys)
262       BUG();
263
264     for(i=0;i<pk->numrevkeys;i++)
265       {
266         SK_LIST list;
267
268         free_public_key (pk2);
269         pk2 = NULL;
270
271         if(sk_list)
272           {
273             for(list=sk_list;list;list=list->next)
274               {
275                 byte fpr[MAX_FINGERPRINT_LEN];
276                 size_t fprlen;
277
278                 fingerprint_from_pk (list->pk, fpr, &fprlen);
279
280                 /* Don't get involved with keys that don't have 160
281                    bit fingerprints */
282                 if(fprlen!=20)
283                   continue;
284
285                 if(memcmp(fpr,pk->revkey[i].fpr,20)==0)
286                   break;
287               }
288
289             if (list)
290               pk2 = copy_public_key (NULL, list->pk);
291             else
292               continue;
293           }
294         else
295           {
296             pk2 = xmalloc_clear (sizeof *pk2);
297             rc = get_pubkey_byfprint (ctrl, pk2, NULL,
298                                       pk->revkey[i].fpr, MAX_FINGERPRINT_LEN);
299           }
300
301         /* We have the revocation key.  */
302         if(!rc)
303           {
304             PKT_signature *revkey = NULL;
305
306             any = 1;
307
308             print_pubkey_info (ctrl, NULL, pk);
309             tty_printf ("\n");
310
311             tty_printf (_("To be revoked by:\n"));
312             print_seckey_info (ctrl, pk2);
313
314             if(pk->revkey[i].class&0x40)
315               tty_printf(_("(This is a sensitive revocation key)\n"));
316             tty_printf("\n");
317
318             rc = agent_probe_secret_key (ctrl, pk2);
319             if (rc)
320               {
321                 tty_printf (_("Secret key is not available.\n"));
322                 continue;
323               }
324
325             if( !cpr_get_answer_is_yes("gen_desig_revoke.okay",
326          _("Create a designated revocation certificate for this key? (y/N) ")))
327               continue;
328
329             /* get the reason for the revocation (this is always v4) */
330             reason = ask_revocation_reason( 1, 0, 1 );
331             if( !reason )
332               continue;
333
334             if( !opt.armor )
335               tty_printf(_("ASCII armored output forced.\n"));
336
337             if( (rc = open_outfile (-1, NULL, 0, 1, &out )) )
338               goto leave;
339
340             afx->what = 1;
341             afx->hdrlines = "Comment: A designated revocation certificate"
342               " should follow\n";
343             push_armor_filter (afx, out);
344
345             /* create it */
346             rc = make_keysig_packet (ctrl, &sig, pk, NULL, NULL, pk2, 0x20, 0,
347                                      0, 0,
348                                      revocation_reason_build_cb, reason,
349                                      NULL);
350             if( rc ) {
351               log_error(_("make_keysig_packet failed: %s\n"), gpg_strerror (rc));
352               goto leave;
353             }
354
355             /* Spit out a minimal pk as well, since otherwise there is
356                no way to know which key to attach this revocation to.
357                Also include the direct key signature that contains
358                this revocation key.  We're allowed to include
359                sensitive revocation keys along with a revocation, as
360                this may be the only time the recipient has seen it.
361                Note that this means that if we have multiple different
362                sensitive revocation keys in a given direct key
363                signature, we're going to include them all here.  This
364                is annoying, but the good outweighs the bad, since
365                without including this a sensitive revoker can't really
366                do their job.  People should not include multiple
367                sensitive revocation keys in one signature: 2440 says
368                "Note that it may be appropriate to isolate this
369                subpacket within a separate signature so that it is not
370                combined with other subpackets that need to be
371                exported." -dms */
372
373             while(!revkey)
374               {
375                 KBNODE signode;
376
377                 signode=find_next_kbnode(node,PKT_SIGNATURE);
378                 if(!signode)
379                   break;
380
381                 node=signode;
382
383                 if(keyid[0]==signode->pkt->pkt.signature->keyid[0] &&
384                    keyid[1]==signode->pkt->pkt.signature->keyid[1] &&
385                    IS_KEY_SIG(signode->pkt->pkt.signature))
386                   {
387                     int j;
388
389                     for(j=0;j<signode->pkt->pkt.signature->numrevkeys;j++)
390                       {
391                         if(pk->revkey[i].class==
392                            signode->pkt->pkt.signature->revkey[j].class &&
393                            pk->revkey[i].algid==
394                            signode->pkt->pkt.signature->revkey[j].algid &&
395                            memcmp(pk->revkey[i].fpr,
396                                   signode->pkt->pkt.signature->revkey[j].fpr,
397                                   MAX_FINGERPRINT_LEN)==0)
398                           {
399                             revkey=signode->pkt->pkt.signature;
400                             break;
401                           }
402                       }
403                   }
404               }
405
406             if(!revkey)
407               BUG();
408
409             rc=export_minimal_pk(out,keyblock,sig,revkey);
410             if(rc)
411               goto leave;
412
413             /* and issue a usage notice */
414             tty_printf(_("Revocation certificate created.\n"));
415             break;
416           }
417       }
418
419     if(!any)
420       log_error(_("no revocation keys found for \"%s\"\n"),uname);
421
422   leave:
423     free_public_key (pk);
424     free_public_key (pk2);
425     if( sig )
426         free_seckey_enc( sig );
427
428     release_sk_list(sk_list);
429
430     if( rc )
431         iobuf_cancel(out);
432     else
433         iobuf_close(out);
434     release_revocation_reason_info( reason );
435     release_armor_context (afx);
436     return rc;
437 }
438
439
440 /* Common core to create the revocation. FILENAME may be NULL to write
441    to stdout or the filename given by --output.  REASON describes the
442    revocation reason.  PSK is the public primary key - we expect that
443    a corresponding secret key is available.  KEYBLOCK is the entire
444    KEYBLOCK which is used in PGP mode to write a minimal key and not
445    just the naked revocation signature; it may be NULL.  If LEADINTEXT
446    is not NULL, it is written right before the (armored) output.*/
447 static int
448 create_revocation (ctrl_t ctrl,
449                    const char *filename,
450                    struct revocation_reason_info *reason,
451                    PKT_public_key *psk,
452                    kbnode_t keyblock,
453                    const char *leadintext, int suffix,
454                    const char *cache_nonce)
455 {
456   int rc;
457   iobuf_t out = NULL;
458   armor_filter_context_t *afx;
459   PKT_signature *sig = NULL;
460   PACKET pkt;
461
462   afx = new_armor_context ();
463
464   if ((rc = open_outfile (-1, filename, suffix, 1, &out)))
465     goto leave;
466
467   if (leadintext )
468     iobuf_writestr (out, leadintext);
469
470   afx->what = 1;
471   afx->hdrlines = "Comment: This is a revocation certificate\n";
472   push_armor_filter (afx, out);
473
474   rc = make_keysig_packet (ctrl, &sig, psk, NULL, NULL, psk, 0x20, 0,
475                            0, 0,
476                            revocation_reason_build_cb, reason, cache_nonce);
477   if (rc)
478     {
479       log_error (_("make_keysig_packet failed: %s\n"), gpg_strerror (rc));
480       goto leave;
481     }
482
483   if (keyblock && (PGP6 || PGP7 || PGP8))
484     {
485       /* Use a minimal pk for PGPx mode, since PGP can't import bare
486          revocation certificates. */
487       rc = export_minimal_pk (out, keyblock, sig, NULL);
488       if (rc)
489         goto leave;
490     }
491   else
492     {
493       init_packet (&pkt);
494       pkt.pkttype = PKT_SIGNATURE;
495       pkt.pkt.signature = sig;
496
497       rc = build_packet (out, &pkt);
498       if (rc)
499         {
500           log_error (_("build_packet failed: %s\n"), gpg_strerror (rc));
501           goto leave;
502         }
503     }
504
505  leave:
506   if (sig)
507     free_seckey_enc (sig);
508   if (rc)
509     iobuf_cancel (out);
510   else
511     iobuf_close (out);
512   release_armor_context (afx);
513   return rc;
514 }
515
516
517 /* This function is used to generate a standard revocation certificate
518    by gpg's interactive key generation function.  The certificate is
519    stored at a dedicated place in a slightly modified form to avoid an
520    accidental import.  PSK is the primary key; a corresponding secret
521    key must be available.  CACHE_NONCE is optional but can be used to
522    help gpg-agent to avoid an extra passphrase prompt. */
523 int
524 gen_standard_revoke (ctrl_t ctrl, PKT_public_key *psk, const char *cache_nonce)
525 {
526   int rc;
527   estream_t memfp;
528   struct revocation_reason_info reason;
529   char *dir, *tmpstr, *fname;
530   void *leadin;
531   size_t len;
532   u32 keyid[2];
533   int kl;
534   char *orig_codeset;
535   char *old_outfile;
536
537   dir = get_openpgp_revocdir (gnupg_homedir ());
538   tmpstr = hexfingerprint (psk, NULL, 0);
539   fname = xstrconcat (dir, DIRSEP_S, tmpstr, NULL);
540   xfree (tmpstr);
541   xfree (dir);
542
543   keyid_from_pk (psk, keyid);
544
545   memfp = es_fopenmem (0, "r+");
546   if (!memfp)
547     log_fatal ("error creating memory stream\n");
548
549   orig_codeset = i18n_switchto_utf8 ();
550
551   es_fprintf (memfp, "%s\n\n",
552               _("This is a revocation certificate for the OpenPGP key:"));
553
554   print_key_line (ctrl, memfp, psk, 0);
555
556   if (opt.keyid_format != KF_NONE)
557     print_fingerprint (ctrl, memfp, psk, 3);
558
559   kl = opt.keyid_format == KF_NONE? 0 : keystrlen ();
560
561   tmpstr = get_user_id (ctrl, keyid, &len);
562   es_fprintf (memfp, "uid%*s%.*s\n\n",
563               kl + 10, "",
564               (int)len, tmpstr);
565   xfree (tmpstr);
566
567   es_fprintf (memfp, "%s\n\n%s\n\n%s\n\n:",
568      _("A revocation certificate is a kind of \"kill switch\" to publicly\n"
569        "declare that a key shall not anymore be used.  It is not possible\n"
570        "to retract such a revocation certificate once it has been published."),
571      _("Use it to revoke this key in case of a compromise or loss of\n"
572        "the secret key.  However, if the secret key is still accessible,\n"
573        "it is better to generate a new revocation certificate and give\n"
574        "a reason for the revocation.  For details see the description of\n"
575        "of the gpg command \"--generate-revocation\" in the "
576        "GnuPG manual."),
577      _("To avoid an accidental use of this file, a colon has been inserted\n"
578        "before the 5 dashes below.  Remove this colon with a text editor\n"
579        "before importing and publishing this revocation certificate."));
580
581   es_putc (0, memfp);
582
583   i18n_switchback (orig_codeset);
584
585   if (es_fclose_snatch (memfp, &leadin, NULL))
586     log_fatal ("error snatching memory stream\n");
587
588   reason.code = 0x00; /* No particular reason.  */
589   reason.desc = NULL;
590   old_outfile = opt.outfile;
591   opt.outfile = NULL;
592   rc = create_revocation (ctrl,
593                           fname, &reason, psk, NULL, leadin, 3, cache_nonce);
594   opt.outfile = old_outfile;
595   if (!rc && !opt.quiet)
596     log_info (_("revocation certificate stored as '%s.rev'\n"), fname);
597
598   xfree (leadin);
599   xfree (fname);
600
601   return rc;
602 }
603
604
605
606 /****************
607  * Generate a revocation certificate for UNAME
608  */
609 int
610 gen_revoke (ctrl_t ctrl, const char *uname)
611 {
612   int rc = 0;
613   PKT_public_key *psk;
614   u32 keyid[2];
615   kbnode_t keyblock = NULL;
616   kbnode_t node;
617   KEYDB_HANDLE kdbhd;
618   struct revocation_reason_info *reason = NULL;
619   KEYDB_SEARCH_DESC desc;
620
621   if( opt.batch )
622     {
623       log_error(_("can't do this in batch mode\n"));
624       return GPG_ERR_GENERAL;
625     }
626
627   /* Search the userid; we don't want the whole getkey stuff here.  */
628   kdbhd = keydb_new ();
629   if (!kdbhd)
630     {
631       rc = gpg_error_from_syserror ();
632       goto leave;
633     }
634   rc = classify_user_id (uname, &desc, 1);
635   if (!rc)
636     rc = keydb_search (kdbhd, &desc, 1, NULL);
637   if (rc)
638     {
639       if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
640         log_error (_("secret key \"%s\" not found\n"), uname);
641       else
642         log_error (_("secret key \"%s\" not found: %s\n"),
643                    uname, gpg_strerror (rc));
644       goto leave;
645     }
646
647   rc = keydb_get_keyblock (kdbhd, &keyblock );
648   if (rc)
649     {
650       log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
651       goto leave;
652     }
653
654   rc = keydb_search (kdbhd, &desc, 1, NULL);
655   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
656     /* Not ambiguous.  */
657     {
658     }
659   else if (rc == 0)
660     /* Ambiguous.  */
661     {
662       char *info;
663
664       /* TRANSLATORS: The %s prints a key specification which
665          for example has been given at the command line.  Several lines
666          lines with secret key infos are printed after this message.  */
667       log_error (_("'%s' matches multiple secret keys:\n"), uname);
668
669       info = format_seckey_info (ctrl, keyblock->pkt->pkt.public_key);
670       log_error ("  %s\n", info);
671       xfree (info);
672       release_kbnode (keyblock);
673
674       rc = keydb_get_keyblock (kdbhd, &keyblock);
675       while (! rc)
676         {
677           info = format_seckey_info (ctrl, keyblock->pkt->pkt.public_key);
678           log_info ("  %s\n", info);
679           xfree (info);
680           release_kbnode (keyblock);
681           keyblock = NULL;
682
683           rc = keydb_search (kdbhd, &desc, 1, NULL);
684           if (! rc)
685             rc = keydb_get_keyblock (kdbhd, &keyblock);
686         }
687
688       rc = GPG_ERR_AMBIGUOUS_NAME;
689
690       goto leave;
691     }
692   else
693     {
694       log_error (_("error searching the keyring: %s\n"), gpg_strerror (rc));
695       goto leave;
696     }
697
698   /* Get the keyid from the keyblock.  */
699   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
700   if (!node)
701     BUG ();
702
703   psk = node->pkt->pkt.public_key;
704   rc = agent_probe_secret_key (NULL, psk);
705   if (rc)
706     {
707       log_error (_("secret key \"%s\" not found: %s\n"),
708                  uname, gpg_strerror (rc));
709       goto leave;
710     }
711
712   keyid_from_pk (psk, keyid );
713   print_seckey_info (ctrl, psk);
714
715   tty_printf("\n");
716   if (!cpr_get_answer_is_yes ("gen_revoke.okay",
717                 _("Create a revocation certificate for this key? (y/N) ")))
718     {
719       rc = 0;
720       goto leave;
721     }
722
723   /* Get the reason for the revocation.  */
724   reason = ask_revocation_reason (1, 0, 1);
725   if (!reason)
726     {
727       /* User decided to cancel.  */
728       rc = 0;
729       goto leave;
730     }
731
732   if (!opt.armor)
733     tty_printf (_("ASCII armored output forced.\n"));
734
735   rc = create_revocation (ctrl, NULL, reason, psk, keyblock, NULL, 0, NULL);
736   if (rc)
737     goto leave;
738
739   /* and issue a usage notice */
740   tty_printf (_(
741 "Revocation certificate created.\n\n"
742 "Please move it to a medium which you can hide away; if Mallory gets\n"
743 "access to this certificate he can use it to make your key unusable.\n"
744 "It is smart to print this certificate and store it away, just in case\n"
745 "your media become unreadable.  But have some caution:  The print system of\n"
746 "your machine might store the data and make it available to others!\n"));
747
748  leave:
749   release_kbnode (keyblock);
750   keydb_release (kdbhd);
751   release_revocation_reason_info( reason );
752   return rc;
753 }
754
755
756
757 struct revocation_reason_info *
758 ask_revocation_reason( int key_rev, int cert_rev, int hint )
759 {
760     int code=-1;
761     char *description = NULL;
762     struct revocation_reason_info *reason;
763     const char *text_0 = _("No reason specified");
764     const char *text_1 = _("Key has been compromised");
765     const char *text_2 = _("Key is superseded");
766     const char *text_3 = _("Key is no longer used");
767     const char *text_4 = _("User ID is no longer valid");
768     const char *code_text = NULL;
769
770     do {
771         code=-1;
772         xfree(description);
773         description = NULL;
774
775         tty_printf(_("Please select the reason for the revocation:\n"));
776         tty_printf(    "  0 = %s\n", text_0 );
777         if( key_rev )
778             tty_printf("  1 = %s\n", text_1 );
779         if( key_rev )
780             tty_printf("  2 = %s\n", text_2 );
781         if( key_rev )
782             tty_printf("  3 = %s\n", text_3 );
783         if( cert_rev )
784             tty_printf("  4 = %s\n", text_4 );
785         tty_printf(    "  Q = %s\n", _("Cancel") );
786         if( hint )
787             tty_printf(_("(Probably you want to select %d here)\n"), hint );
788
789         while(code==-1) {
790             int n;
791             char *answer = cpr_get("ask_revocation_reason.code",
792                                                 _("Your decision? "));
793             trim_spaces( answer );
794             cpr_kill_prompt();
795             if( *answer == 'q' || *answer == 'Q')
796               return NULL; /* cancel */
797             if( hint && !*answer )
798                 n = hint;
799             else if(!digitp( answer ) )
800                 n = -1;
801             else
802                 n = atoi(answer);
803             xfree(answer);
804             if( n == 0 ) {
805                 code = 0x00; /* no particular reason */
806                 code_text = text_0;
807             }
808             else if( key_rev && n == 1 ) {
809                 code = 0x02; /* key has been compromised */
810                 code_text = text_1;
811             }
812             else if( key_rev && n == 2 ) {
813                 code = 0x01; /* key is superseded */
814                 code_text = text_2;
815             }
816             else if( key_rev && n == 3 ) {
817                 code = 0x03; /* key is no longer used */
818                 code_text = text_3;
819             }
820             else if( cert_rev && n == 4 ) {
821                 code = 0x20; /* uid is no longer valid */
822                 code_text = text_4;
823             }
824             else
825                 tty_printf(_("Invalid selection.\n"));
826         }
827
828         tty_printf(_("Enter an optional description; "
829                      "end it with an empty line:\n") );
830         for(;;) {
831             char *answer = cpr_get("ask_revocation_reason.text", "> " );
832             trim_trailing_ws( answer, strlen(answer) );
833             cpr_kill_prompt();
834             if( !*answer ) {
835                 xfree(answer);
836                 break;
837             }
838
839             {
840                 char *p = make_printable_string( answer, strlen(answer), 0 );
841                 xfree(answer);
842                 answer = p;
843             }
844
845             if( !description )
846                 description = xstrdup(answer);
847             else {
848                 char *p = xmalloc( strlen(description) + strlen(answer) + 2 );
849                 strcpy(stpcpy(stpcpy( p, description),"\n"),answer);
850                 xfree(description);
851                 description = p;
852             }
853             xfree(answer);
854         }
855
856         tty_printf(_("Reason for revocation: %s\n"), code_text );
857         if( !description )
858             tty_printf(_("(No description given)\n") );
859         else
860             tty_printf("%s\n", description );
861
862     } while( !cpr_get_answer_is_yes("ask_revocation_reason.okay",
863                                             _("Is this okay? (y/N) "))  );
864
865     reason = xmalloc( sizeof *reason );
866     reason->code = code;
867     reason->desc = description;
868     return reason;
869 }
870
871 struct revocation_reason_info *
872 get_default_uid_revocation_reason(void)
873 {
874   struct revocation_reason_info *reason;
875   reason = xmalloc( sizeof *reason );
876   reason->code = 0x20; /* uid is no longer valid */
877   reason->desc = strdup(""); /* no text */
878   return reason;
879 }
880
881 void
882 release_revocation_reason_info( struct revocation_reason_info *reason )
883 {
884     if( reason ) {
885         xfree( reason->desc );
886         xfree( reason );
887     }
888 }