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