Extend algo selection menu.
[gnupg.git] / g10 / delkey.c
1 /* delkey.c - delete keys
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004,
3  *               2005, 2006 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 <http://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 <assert.h>
27 #include <ctype.h>
28
29 #include "gpg.h"
30 #include "options.h"
31 #include "packet.h"
32 #include "status.h"
33 #include "iobuf.h"
34 #include "keydb.h"
35 #include "util.h"
36 #include "main.h"
37 #include "trustdb.h"
38 #include "filter.h"
39 #include "ttyio.h"
40 #include "status.h"
41 #include "i18n.h"
42
43
44 /****************
45  * Delete a public or secret key from a keyring.
46  * r_sec_avail will be set if a secret key is available and the public
47  * key can't be deleted for that reason.
48  */
49 static int
50 do_delete_key( const char *username, int secret, int force, int *r_sec_avail )
51 {
52     int rc = 0;
53     KBNODE keyblock = NULL;
54     KBNODE node;
55     KEYDB_HANDLE hd = keydb_new ();
56     PKT_public_key *pk = NULL;
57     u32 keyid[2];
58     int okay=0;
59     int yes;
60     KEYDB_SEARCH_DESC desc;
61     int exactmatch;
62
63     *r_sec_avail = 0;
64
65     /* Search the userid */
66     rc = classify_user_id (username, &desc);
67     exactmatch = (desc.mode == KEYDB_SEARCH_MODE_FPR
68                   || desc.mode == KEYDB_SEARCH_MODE_FPR16
69                   || desc.mode == KEYDB_SEARCH_MODE_FPR20);
70     if (!rc)
71       rc = keydb_search (hd, &desc, 1);
72     if (rc) {
73         log_error (_("key \"%s\" not found: %s\n"), username, g10_errstr (rc));
74         write_status_text( STATUS_DELETE_PROBLEM, "1" );
75         goto leave;
76     }
77
78     /* read the keyblock */
79     rc = keydb_get_keyblock (hd, &keyblock );
80     if (rc) {
81         log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
82         goto leave;
83     }
84
85     /* get the keyid from the keyblock */
86     node = find_kbnode( keyblock, secret? PKT_SECRET_KEY:PKT_PUBLIC_KEY );
87     if( !node ) {
88         log_error("Oops; key not found anymore!\n");
89         rc = G10ERR_GENERAL;
90         goto leave;
91     }
92
93     pk = node->pkt->pkt.public_key;
94     keyid_from_pk( pk, keyid );
95     
96     if (!force)
97       {
98         if (have_secret_key_with_kid (keyid))
99           {
100             *r_sec_avail = 1;
101             rc = -1;
102             goto leave;
103           }
104         else
105           rc = 0;
106       }
107
108     if( rc )
109         rc = 0;
110     else if (opt.batch && exactmatch)
111         okay++;
112     else if( opt.batch && secret )
113       {
114         log_error(_("can't do this in batch mode\n"));
115         log_info (_("(unless you specify the key by fingerprint)\n"));
116       }
117     else if( opt.batch && opt.answer_yes )
118         okay++;
119     else if( opt.batch )
120       {
121         log_error(_("can't do this in batch mode without \"--yes\"\n"));
122         log_info (_("(unless you specify the key by fingerprint)\n"));
123       }
124     else {
125         if( secret )
126             print_seckey_info (pk);
127         else
128             print_pubkey_info (NULL, pk );
129         tty_printf( "\n" );
130
131         yes = cpr_get_answer_is_yes( secret? "delete_key.secret.okay"
132                                            : "delete_key.okay",
133                               _("Delete this key from the keyring? (y/N) "));
134         if( !cpr_enabled() && secret && yes ) {
135             /* I think it is not required to check a passphrase; if
136              * the user is so stupid as to let others access his secret keyring
137              * (and has no backup) - it is up him to read some very
138              * basic texts about security.
139              */
140             yes = cpr_get_answer_is_yes("delete_key.secret.okay",
141                          _("This is a secret key! - really delete? (y/N) "));
142         }
143         if( yes )
144             okay++;
145     }
146
147
148     if( okay ) {
149         rc = keydb_delete_keyblock (hd);
150         if (rc) {
151             log_error (_("deleting keyblock failed: %s\n"), g10_errstr(rc) );
152             goto leave;
153         }
154
155         /* Note that the ownertrust being cleared will trigger a
156            revalidation_mark().  This makes sense - only deleting keys
157            that have ownertrust set should trigger this. */
158
159         if (!secret && pk && clear_ownertrusts (pk)) {
160           if (opt.verbose)
161             log_info (_("ownertrust information cleared\n"));
162         }
163     }
164
165   leave:
166     keydb_release (hd);
167     release_kbnode (keyblock);
168     return rc;
169 }
170
171 /****************
172  * Delete a public or secret key from a keyring.
173  */
174 int
175 delete_keys( strlist_t names, int secret, int allow_both )
176 {
177     int rc, avail, force=(!allow_both && !secret && opt.expert);
178
179     /* Force allows us to delete a public key even if a secret key
180        exists. */
181
182     for(;names;names=names->next) {
183        rc = do_delete_key (names->d, secret, force, &avail );
184        if ( rc && avail ) { 
185          if ( allow_both ) {
186            rc = do_delete_key (names->d, 1, 0, &avail );
187            if ( !rc )
188              rc = do_delete_key (names->d, 0, 0, &avail );
189          }
190          else {
191            log_error(_(
192               "there is a secret key for public key \"%s\"!\n"),names->d);
193            log_info(_(
194               "use option \"--delete-secret-keys\" to delete it first.\n"));
195            write_status_text( STATUS_DELETE_PROBLEM, "2" );
196            return rc;
197          }
198        }
199
200        if(rc) {
201          log_error("%s: delete key failed: %s\n", names->d, g10_errstr(rc) );
202          return rc;
203        }
204     }
205
206     return 0;
207 }