dirmngr: Fix error handling.
[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  * Copyright (C) 2014 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <ctype.h>
28
29 #include "gpg.h"
30 #include "options.h"
31 #include "packet.h"
32 #include "../common/status.h"
33 #include "../common/iobuf.h"
34 #include "keydb.h"
35 #include "../common/util.h"
36 #include "main.h"
37 #include "trustdb.h"
38 #include "filter.h"
39 #include "../common/ttyio.h"
40 #include "../common/i18n.h"
41 #include "call-agent.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 gpg_error_t
50 do_delete_key( const char *username, int secret, int force, int *r_sec_avail )
51 {
52   gpg_error_t err;
53   kbnode_t keyblock = NULL;
54   kbnode_t node, kbctx;
55   KEYDB_HANDLE hd;
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   hd = keydb_new ();
66   if (!hd)
67     return gpg_error_from_syserror ();
68
69   /* Search the userid.  */
70   err = classify_user_id (username, &desc, 1);
71   exactmatch = (desc.mode == KEYDB_SEARCH_MODE_FPR
72                 || desc.mode == KEYDB_SEARCH_MODE_FPR16
73                 || desc.mode == KEYDB_SEARCH_MODE_FPR20);
74   if (!err)
75     err = keydb_search (hd, &desc, 1, NULL);
76   if (err)
77     {
78       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
79       write_status_text (STATUS_DELETE_PROBLEM, "1");
80       goto leave;
81     }
82
83   /* Read the keyblock.  */
84   err = keydb_get_keyblock (hd, &keyblock);
85   if (err)
86     {
87       log_error (_("error reading keyblock: %s\n"), gpg_strerror (err) );
88       goto leave;
89     }
90
91   /* Get the keyid from the keyblock.  */
92   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
93   if (!node)
94     {
95       log_error ("Oops; key not found anymore!\n");
96       err = gpg_error (GPG_ERR_GENERAL);
97       goto leave;
98     }
99   pk = node->pkt->pkt.public_key;
100   keyid_from_pk (pk, keyid);
101
102   if (!secret && !force)
103     {
104       if (have_secret_key_with_kid (keyid))
105         {
106           *r_sec_avail = 1;
107           err = gpg_error (GPG_ERR_EOF);
108           goto leave;
109         }
110       else
111         err = 0;
112     }
113
114   if (secret && !have_secret_key_with_kid (keyid))
115     {
116       err = gpg_error (GPG_ERR_NOT_FOUND);
117       log_error (_("key \"%s\" not found\n"), username);
118       write_status_text (STATUS_DELETE_PROBLEM, "1");
119       goto leave;
120     }
121
122
123   if (opt.batch && exactmatch)
124     okay++;
125   else if (opt.batch && secret)
126     {
127       log_error(_("can't do this in batch mode\n"));
128       log_info (_("(unless you specify the key by fingerprint)\n"));
129     }
130   else if (opt.batch && opt.answer_yes)
131     okay++;
132   else if (opt.batch)
133     {
134       log_error(_("can't do this in batch mode without \"--yes\"\n"));
135       log_info (_("(unless you specify the key by fingerprint)\n"));
136     }
137   else
138     {
139       if (secret)
140         print_seckey_info (pk);
141       else
142         print_pubkey_info (NULL, pk );
143       tty_printf( "\n" );
144
145       yes = cpr_get_answer_is_yes
146         (secret? "delete_key.secret.okay": "delete_key.okay",
147          _("Delete this key from the keyring? (y/N) "));
148
149       if (!cpr_enabled() && secret && yes)
150         {
151           /* I think it is not required to check a passphrase; if the
152            * user is so stupid as to let others access his secret
153            * keyring (and has no backup) - it is up him to read some
154            * very basic texts about security.  */
155           yes = cpr_get_answer_is_yes
156             ("delete_key.secret.okay",
157              _("This is a secret key! - really delete? (y/N) "));
158         }
159
160       if (yes)
161         okay++;
162     }
163
164
165   if (okay)
166     {
167       if (secret)
168         {
169           char *prompt;
170           gpg_error_t firsterr = 0;
171           char *hexgrip;
172
173           setup_main_keyids (keyblock);
174           for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
175             {
176               if (!(node->pkt->pkttype == PKT_PUBLIC_KEY
177                     || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
178                 continue;
179
180               if (agent_probe_secret_key (NULL, node->pkt->pkt.public_key))
181                 continue;  /* No secret key for that public (sub)key.  */
182
183               prompt = gpg_format_keydesc (node->pkt->pkt.public_key,
184                                            FORMAT_KEYDESC_DELKEY, 1);
185               err = hexkeygrip_from_pk (node->pkt->pkt.public_key, &hexgrip);
186               /* NB: We require --yes to advise the agent not to
187                * request a confirmation.  The rationale for this extra
188                * pre-caution is that since 2.1 the secret key may also
189                * be used for other protocols and thus deleting it from
190                * the gpg would also delete the key for other tools. */
191               if (!err)
192                 err = agent_delete_key (NULL, hexgrip, prompt,
193                                         opt.answer_yes);
194               xfree (prompt);
195               xfree (hexgrip);
196               if (err)
197                 {
198                   if (gpg_err_code (err) == GPG_ERR_KEY_ON_CARD)
199                     write_status_text (STATUS_DELETE_PROBLEM, "1");
200                   log_error (_("deleting secret %s failed: %s\n"),
201                              (node->pkt->pkttype == PKT_PUBLIC_KEY
202                               ? _("key"):_("subkey")),
203                              gpg_strerror (err));
204                   if (!firsterr)
205                     firsterr = err;
206                   if (gpg_err_code (err) == GPG_ERR_CANCELED
207                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
208                     {
209                       write_status_error ("delete_key.secret", err);
210                       break;
211                     }
212                 }
213
214             }
215
216           err = firsterr;
217           if (firsterr)
218             goto leave;
219         }
220       else
221         {
222           err = keydb_delete_keyblock (hd);
223           if (err)
224             {
225               log_error (_("deleting keyblock failed: %s\n"),
226                          gpg_strerror (err));
227               goto leave;
228             }
229         }
230
231       /* Note that the ownertrust being cleared will trigger a
232          revalidation_mark().  This makes sense - only deleting keys
233          that have ownertrust set should trigger this. */
234
235       if (!secret && pk && clear_ownertrusts (pk))
236         {
237           if (opt.verbose)
238             log_info (_("ownertrust information cleared\n"));
239         }
240     }
241
242  leave:
243   keydb_release (hd);
244   release_kbnode (keyblock);
245   return err;
246 }
247
248 /****************
249  * Delete a public or secret key from a keyring.
250  */
251 gpg_error_t
252 delete_keys (strlist_t names, int secret, int allow_both)
253 {
254   gpg_error_t err;
255   int avail;
256   int force = (!allow_both && !secret && opt.expert);
257
258   /* Force allows us to delete a public key even if a secret key
259      exists. */
260
261   for ( ;names ; names=names->next )
262     {
263       err = do_delete_key (names->d, secret, force, &avail);
264       if (err && avail)
265         {
266           if (allow_both)
267             {
268               err = do_delete_key (names->d, 1, 0, &avail);
269               if (!err)
270                 err = do_delete_key (names->d, 0, 0, &avail);
271             }
272           else
273             {
274               log_error (_("there is a secret key for public key \"%s\"!\n"),
275                          names->d);
276               log_info(_("use option \"--delete-secret-keys\" to delete"
277                          " it first.\n"));
278               write_status_text (STATUS_DELETE_PROBLEM, "2");
279               return err;
280             }
281         }
282
283       if (err)
284         {
285           log_error ("%s: delete key failed: %s\n",
286                      names->d, gpg_strerror (err));
287           return err;
288         }
289     }
290
291   return 0;
292 }