* options.h, main.h, export.c (parse_export_options, do_export_stream),
[gnupg.git] / g10 / delkey.c
1 /* delkey.c - delete keys
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 "options.h"
30 #include "packet.h"
31 #include "errors.h"
32 #include "iobuf.h"
33 #include "keydb.h"
34 #include "memory.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 *r_sec_avail )
51 {
52     int rc = 0;
53     KBNODE keyblock = NULL;
54     KBNODE node;
55     KEYDB_HANDLE hd = keydb_new (secret);
56     PKT_public_key *pk = NULL;
57     PKT_secret_key *sk = NULL;
58     u32 keyid[2];
59     int okay=0;
60     int yes;
61     KEYDB_SEARCH_DESC desc;
62
63     *r_sec_avail = 0;
64
65     /* search the userid */
66     classify_user_id (username, &desc);
67     rc = desc.mode? keydb_search (hd, &desc, 1):G10ERR_INV_USER_ID;
68     if (rc) {
69         log_error (_("key `%s' not found: %s\n"), username, g10_errstr (rc));
70         write_status_text( STATUS_DELETE_PROBLEM, "1" );
71         goto leave;
72     }
73
74     /* read the keyblock */
75     rc = keydb_get_keyblock (hd, &keyblock );
76     if (rc) {
77         log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
78         goto leave;
79     }
80
81     /* get the keyid from the keyblock */
82     node = find_kbnode( keyblock, secret? PKT_SECRET_KEY:PKT_PUBLIC_KEY );
83     if( !node ) {
84         log_error("Oops; key not found anymore!\n");
85         rc = G10ERR_GENERAL;
86         goto leave;
87     }
88
89     if( secret ) {
90         sk = node->pkt->pkt.secret_key;
91         keyid_from_sk( sk, keyid );
92     }
93     else {
94         pk = node->pkt->pkt.public_key;
95         keyid_from_pk( pk, keyid );
96         rc = seckey_available( keyid );
97         if( !rc ) {
98             *r_sec_avail = 1;
99             rc = -1;
100             goto leave;
101         }
102         else if( rc != G10ERR_NO_SECKEY ) {
103             log_error("%s: get secret key: %s\n", username, g10_errstr(rc) );
104         }
105         else
106             rc = 0;
107     }
108
109     if( rc )
110         rc = 0;
111     else if( opt.batch && secret )
112         log_error(_("can't do that in batchmode\n"));
113     else if( opt.batch && opt.answer_yes )
114         okay++;
115     else if( opt.batch )
116         log_error(_("can't do that in batchmode without \"--yes\"\n"));
117     else {
118         char *p;
119         size_t n;
120
121         if( secret )
122             tty_printf("sec  %4u%c/%08lX %s   ",
123                       nbits_from_sk( sk ),
124                       pubkey_letter( sk->pubkey_algo ),
125                       (ulong)keyid[1], datestr_from_sk(sk) );
126         else
127             tty_printf("pub  %4u%c/%08lX %s   ",
128                       nbits_from_pk( pk ),
129                       pubkey_letter( pk->pubkey_algo ),
130                       (ulong)keyid[1], datestr_from_pk(pk) );
131         p = get_user_id( keyid, &n );
132         tty_print_utf8_string( p, n );
133         m_free(p);
134         tty_printf("\n\n");
135
136         yes = cpr_get_answer_is_yes( secret? "delete_key.secret.okay"
137                                            : "delete_key.okay",
138                               _("Delete this key from the keyring? "));
139         if( !cpr_enabled() && secret && yes ) {
140             /* I think it is not required to check a passphrase; if
141              * the user is so stupid as to let others access his secret keyring
142              * (and has no backup) - it is up him to read some very
143              * basic texts about security.
144              */
145             yes = cpr_get_answer_is_yes("delete_key.secret.okay",
146                          _("This is a secret key! - really delete? "));
147         }
148         if( yes )
149             okay++;
150     }
151
152
153     if( okay ) {
154         rc = keydb_delete_keyblock (hd);
155         if (rc) {
156             log_error (_("deleting keyblock failed: %s\n"), g10_errstr(rc) );
157             goto leave;
158         }
159
160         /* Note that the ownertrust being cleared will trigger a
161            revalidation_mark().  This makes sense - only deleting keys
162            that have ownertrust set should trigger this. */
163
164         if (!secret && pk && clear_ownertrust (pk)) {
165           if (opt.verbose)
166             log_info (_("ownertrust information cleared\n"));
167         }
168     }
169
170   leave:
171     keydb_release (hd);
172     release_kbnode (keyblock);
173     return rc;
174 }
175
176 /****************
177  * Delete a public or secret key from a keyring.
178  */
179 int
180 delete_keys( STRLIST names, int secret, int allow_both )
181 {
182     int rc, avail;
183
184     for(;names;names=names->next) {
185        rc = do_delete_key (names->d, secret, &avail );
186        if ( rc && avail ) { 
187          if ( allow_both ) {
188            rc = do_delete_key (names->d, 1, &avail );
189            if ( !rc )
190              rc = do_delete_key (names->d, 0, &avail );
191          }
192          else {
193            log_error(_(
194               "there is a secret key for public key \"%s\"!\n"),names->d);
195            log_info(_(
196               "use option \"--delete-secret-keys\" to delete it first.\n"));
197            write_status_text( STATUS_DELETE_PROBLEM, "2" );
198            return rc;
199          }
200        }
201
202        if(rc) {
203          log_error("%s: delete key failed: %s\n", names->d, g10_errstr(rc) );
204          return rc;
205        }
206     }
207
208     return 0;
209 }