g10: Fix segfault on unsupported curve.
[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 <http://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 <assert.h>
28 #include <ctype.h>
29
30 #include "gpg.h"
31 #include "options.h"
32 #include "packet.h"
33 #include "status.h"
34 #include "iobuf.h"
35 #include "keydb.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 #include "call-agent.h"
44
45
46 /****************
47  * Delete a public or secret key from a keyring.
48  * r_sec_avail will be set if a secret key is available and the public
49  * key can't be deleted for that reason.
50  */
51 static gpg_error_t
52 do_delete_key( const char *username, int secret, int force, int *r_sec_avail )
53 {
54   gpg_error_t err;
55   kbnode_t keyblock = NULL;
56   kbnode_t node, kbctx;
57   KEYDB_HANDLE hd;
58   PKT_public_key *pk = 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   hd = keydb_new ();
68   if (!hd)
69     return gpg_error_from_syserror ();
70
71   /* Search the userid.  */
72   err = classify_user_id (username, &desc, 1);
73   exactmatch = (desc.mode == KEYDB_SEARCH_MODE_FPR
74                 || desc.mode == KEYDB_SEARCH_MODE_FPR16
75                 || desc.mode == KEYDB_SEARCH_MODE_FPR20);
76   if (!err)
77     err = keydb_search (hd, &desc, 1, NULL);
78   if (err)
79     {
80       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
81       write_status_text (STATUS_DELETE_PROBLEM, "1");
82       goto leave;
83     }
84
85   /* Read the keyblock.  */
86   err = keydb_get_keyblock (hd, &keyblock);
87   if (err)
88     {
89       log_error (_("error reading keyblock: %s\n"), gpg_strerror (err) );
90       goto leave;
91     }
92
93   /* Get the keyid from the keyblock.  */
94   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
95   if (!node)
96     {
97       log_error ("Oops; key not found anymore!\n");
98       err = gpg_error (GPG_ERR_GENERAL);
99       goto leave;
100     }
101   pk = node->pkt->pkt.public_key;
102   keyid_from_pk (pk, keyid);
103
104   if (!secret && !force)
105     {
106       if (have_secret_key_with_kid (keyid))
107         {
108           *r_sec_avail = 1;
109           err = gpg_error (GPG_ERR_EOF);
110           goto leave;
111         }
112       else
113         err = 0;
114     }
115
116   if (secret && !have_secret_key_with_kid (keyid))
117     {
118       err = gpg_error (GPG_ERR_NOT_FOUND);
119       log_error (_("key \"%s\" not found\n"), username);
120       write_status_text (STATUS_DELETE_PROBLEM, "1");
121       goto leave;
122     }
123
124
125   if (opt.batch && exactmatch)
126     okay++;
127   else if (opt.batch && secret)
128     {
129       log_error(_("can't do this in batch mode\n"));
130       log_info (_("(unless you specify the key by fingerprint)\n"));
131     }
132   else if (opt.batch && opt.answer_yes)
133     okay++;
134   else if (opt.batch)
135     {
136       log_error(_("can't do this in batch mode without \"--yes\"\n"));
137       log_info (_("(unless you specify the key by fingerprint)\n"));
138     }
139   else
140     {
141       if (secret)
142         print_seckey_info (pk);
143       else
144         print_pubkey_info (NULL, pk );
145       tty_printf( "\n" );
146
147       yes = cpr_get_answer_is_yes
148         (secret? "delete_key.secret.okay": "delete_key.okay",
149          _("Delete this key from the keyring? (y/N) "));
150
151       if (!cpr_enabled() && secret && yes)
152         {
153           /* I think it is not required to check a passphrase; if the
154            * user is so stupid as to let others access his secret
155            * keyring (and has no backup) - it is up him to read some
156            * very basic texts about security.  */
157           yes = cpr_get_answer_is_yes
158             ("delete_key.secret.okay",
159              _("This is a secret key! - really delete? (y/N) "));
160         }
161
162       if (yes)
163         okay++;
164     }
165
166
167   if (okay)
168     {
169       if (secret)
170         {
171           char *prompt;
172           gpg_error_t firsterr = 0;
173           char *hexgrip;
174
175           setup_main_keyids (keyblock);
176           for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
177             {
178               if (!(node->pkt->pkttype == PKT_PUBLIC_KEY
179                     || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
180                 continue;
181
182               if (agent_probe_secret_key (NULL, node->pkt->pkt.public_key))
183                 continue;  /* No secret key for that public (sub)key.  */
184
185               prompt = gpg_format_keydesc (node->pkt->pkt.public_key,
186                                            FORMAT_KEYDESC_DELKEY, 1);
187               err = hexkeygrip_from_pk (node->pkt->pkt.public_key, &hexgrip);
188               if (!err)
189                 err = agent_delete_key (NULL, hexgrip, prompt);
190               xfree (prompt);
191               xfree (hexgrip);
192               if (err)
193                 {
194                   if (gpg_err_code (err) == GPG_ERR_KEY_ON_CARD)
195                     write_status_text (STATUS_DELETE_PROBLEM, "1");
196                   log_error (_("deleting secret %s failed: %s\n"),
197                              (node->pkt->pkttype == PKT_PUBLIC_KEY
198                               ? _("key"):_("subkey")),
199                              gpg_strerror (err));
200                   if (!firsterr)
201                     firsterr = err;
202                   if (gpg_err_code (err) == GPG_ERR_CANCELED
203                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
204                     {
205                       write_status_error ("delete_key.secret", err);
206                       break;
207                     }
208                 }
209
210             }
211
212           err = firsterr;
213           if (firsterr)
214             goto leave;
215         }
216       else
217         {
218           err = keydb_delete_keyblock (hd);
219           if (err)
220             {
221               log_error (_("deleting keyblock failed: %s\n"),
222                          gpg_strerror (err));
223               goto leave;
224             }
225         }
226
227       /* Note that the ownertrust being cleared will trigger a
228          revalidation_mark().  This makes sense - only deleting keys
229          that have ownertrust set should trigger this. */
230
231       if (!secret && pk && clear_ownertrusts (pk))
232         {
233           if (opt.verbose)
234             log_info (_("ownertrust information cleared\n"));
235         }
236     }
237
238  leave:
239   keydb_release (hd);
240   release_kbnode (keyblock);
241   return err;
242 }
243
244 /****************
245  * Delete a public or secret key from a keyring.
246  */
247 gpg_error_t
248 delete_keys (strlist_t names, int secret, int allow_both)
249 {
250   gpg_error_t err;
251   int avail;
252   int force = (!allow_both && !secret && opt.expert);
253
254   /* Force allows us to delete a public key even if a secret key
255      exists. */
256
257   for ( ;names ; names=names->next )
258     {
259       err = do_delete_key (names->d, secret, force, &avail);
260       if (err && avail)
261         {
262           if (allow_both)
263             {
264               err = do_delete_key (names->d, 1, 0, &avail);
265               if (!err)
266                 err = do_delete_key (names->d, 0, 0, &avail);
267             }
268           else
269             {
270               log_error (_("there is a secret key for public key \"%s\"!\n"),
271                          names->d);
272               log_info(_("use option \"--delete-secret-keys\" to delete"
273                          " it first.\n"));
274               write_status_text (STATUS_DELETE_PROBLEM, "2");
275               return err;
276             }
277         }
278
279       if (err)
280         {
281           log_error ("%s: delete key failed: %s\n",
282                      names->d, gpg_strerror (err));
283           return err;
284         }
285     }
286
287   return 0;
288 }