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