gpg: The option --passphrase= can be empty.
[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, 2019 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 (ctrl_t ctrl, const char *username, int secret, int force,
51                int *r_sec_avail)
52 {
53   gpg_error_t err;
54   kbnode_t keyblock = NULL;
55   kbnode_t node, kbctx;
56   kbnode_t targetnode;
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;  /* True if key was found by fingerprint.  */
64   int thiskeyonly; /* 0 = false, 1 = is primary key, 2 = is a subkey.  */
65
66   *r_sec_avail = 0;
67
68   hd = keydb_new ();
69   if (!hd)
70     return gpg_error_from_syserror ();
71
72   /* Search the userid.  */
73   err = classify_user_id (username, &desc, 1);
74   exactmatch = (desc.mode == KEYDB_SEARCH_MODE_FPR);
75   thiskeyonly = desc.exact;
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
102   /* If an operation only on a subkey is requested, find that subkey
103    * now.  */
104   if (thiskeyonly)
105     {
106       kbnode_t tmpnode;
107
108       for (kbctx=NULL; (tmpnode = walk_kbnode (keyblock, &kbctx, 0)); )
109         {
110           if (!(tmpnode->pkt->pkttype == PKT_PUBLIC_KEY
111                 || tmpnode->pkt->pkttype == PKT_PUBLIC_SUBKEY))
112             continue;
113           if (exact_subkey_match_p (&desc, tmpnode))
114             break;
115         }
116       if (!tmpnode)
117         {
118           log_error ("Oops; requested subkey not found anymore!\n");
119           err = gpg_error (GPG_ERR_GENERAL);
120           goto leave;
121         }
122       /* Set NODE to this specific subkey or primary key.  */
123       thiskeyonly = node == tmpnode? 1 : 2;
124       targetnode = tmpnode;
125     }
126   else
127     targetnode = node;
128
129   pk = targetnode->pkt->pkt.public_key;
130   keyid_from_pk (pk, keyid);
131
132   if (!secret && !force)
133     {
134       if (have_secret_key_with_kid (keyid))
135         {
136           *r_sec_avail = 1;
137           err = gpg_error (GPG_ERR_EOF);
138           goto leave;
139         }
140       else
141         err = 0;
142     }
143
144   if (secret && !have_secret_key_with_kid (keyid))
145     {
146       err = gpg_error (GPG_ERR_NOT_FOUND);
147       log_error (_("key \"%s\" not found\n"), username);
148       write_status_text (STATUS_DELETE_PROBLEM, "1");
149       goto leave;
150     }
151
152
153   if (opt.batch && exactmatch)
154     okay++;
155   else if (opt.batch && secret)
156     {
157       log_error(_("can't do this in batch mode\n"));
158       log_info (_("(unless you specify the key by fingerprint)\n"));
159     }
160   else if (opt.batch && opt.answer_yes)
161     okay++;
162   else if (opt.batch)
163     {
164       log_error(_("can't do this in batch mode without \"--yes\"\n"));
165       log_info (_("(unless you specify the key by fingerprint)\n"));
166     }
167   else
168     {
169       print_key_info (ctrl, NULL, 0, pk, secret);
170       tty_printf ("\n");
171       if (thiskeyonly == 1 && !secret)
172         {
173           /* We need to delete the entire public key despite the use
174            * of the thiskeyonly request.  */
175           tty_printf (_("Note: The public primary key and all its subkeys"
176                         " will be deleted.\n"));
177         }
178       else if (thiskeyonly == 2 && !secret)
179         {
180           tty_printf (_("Note: Only the shown public subkey"
181                         " will be deleted.\n"));
182         }
183       if (thiskeyonly == 1 && secret)
184         {
185           tty_printf (_("Note: Only the secret part of the shown primary"
186                         " key will be deleted.\n"));
187         }
188       else if (thiskeyonly == 2 && secret)
189         {
190           tty_printf (_("Note: Only the secret part of the shown subkey"
191                         " will be deleted.\n"));
192         }
193
194       if (thiskeyonly)
195         tty_printf ("\n");
196
197       yes = cpr_get_answer_is_yes
198         (secret? "delete_key.secret.okay": "delete_key.okay",
199          _("Delete this key from the keyring? (y/N) "));
200
201       if (!cpr_enabled() && secret && yes)
202         {
203           /* I think it is not required to check a passphrase; if the
204            * user is so stupid as to let others access his secret
205            * keyring (and has no backup) - it is up him to read some
206            * very basic texts about security.  */
207           yes = cpr_get_answer_is_yes
208             ("delete_key.secret.okay",
209              _("This is a secret key! - really delete? (y/N) "));
210         }
211
212       if (yes)
213         okay++;
214     }
215
216
217   if (okay)
218     {
219       if (secret)
220         {
221           char *prompt;
222           gpg_error_t firsterr = 0;
223           char *hexgrip;
224
225           setup_main_keyids (keyblock);
226           for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
227             {
228               if (!(node->pkt->pkttype == PKT_PUBLIC_KEY
229                     || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
230                 continue;
231
232               if (thiskeyonly && targetnode != node)
233                 continue;
234
235               if (agent_probe_secret_key (NULL, node->pkt->pkt.public_key))
236                 continue;  /* No secret key for that public (sub)key.  */
237
238               prompt = gpg_format_keydesc (ctrl,
239                                            node->pkt->pkt.public_key,
240                                            FORMAT_KEYDESC_DELKEY, 1);
241               err = hexkeygrip_from_pk (node->pkt->pkt.public_key, &hexgrip);
242               /* NB: We require --yes to advise the agent not to
243                * request a confirmation.  The rationale for this extra
244                * pre-caution is that since 2.1 the secret key may also
245                * be used for other protocols and thus deleting it from
246                * the gpg would also delete the key for other tools. */
247               if (!err && !opt.dry_run)
248                 err = agent_delete_key (NULL, hexgrip, prompt,
249                                         opt.answer_yes);
250               xfree (prompt);
251               xfree (hexgrip);
252               if (err)
253                 {
254                   if (gpg_err_code (err) == GPG_ERR_KEY_ON_CARD)
255                     write_status_text (STATUS_DELETE_PROBLEM, "1");
256                   log_error (_("deleting secret %s failed: %s\n"),
257                              (node->pkt->pkttype == PKT_PUBLIC_KEY
258                               ? _("key"):_("subkey")),
259                              gpg_strerror (err));
260                   if (!firsterr)
261                     firsterr = err;
262                   if (gpg_err_code (err) == GPG_ERR_CANCELED
263                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
264                     {
265                       write_status_error ("delete_key.secret", err);
266                       break;
267                     }
268                 }
269
270             }
271
272           err = firsterr;
273           if (firsterr)
274             goto leave;
275         }
276       else if (thiskeyonly == 2)
277         {
278           int selected = 0;
279
280           /* Delete the specified public subkey.  */
281           for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
282             {
283               if (thiskeyonly && targetnode != node)
284                 continue;
285
286               if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
287                 {
288                   selected = targetnode == node;
289                   if (selected)
290                     delete_kbnode (node);
291                 }
292               else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
293                 delete_kbnode (node);
294               else
295                 selected = 0;
296             }
297           commit_kbnode (&keyblock);
298           err = keydb_update_keyblock (ctrl, hd, keyblock);
299           if (err)
300             {
301               log_error (_("update failed: %s\n"), gpg_strerror (err));
302               goto leave;
303             }
304         }
305       else
306         {
307           err = keydb_delete_keyblock (hd);
308           if (err)
309             {
310               log_error (_("deleting keyblock failed: %s\n"),
311                          gpg_strerror (err));
312               goto leave;
313             }
314         }
315
316       /* Note that the ownertrust being cleared will trigger a
317          revalidation_mark().  This makes sense - only deleting keys
318          that have ownertrust set should trigger this. */
319
320       if (!secret && pk && !opt.dry_run && thiskeyonly != 2
321           && clear_ownertrusts (ctrl, pk))
322         {
323           if (opt.verbose)
324             log_info (_("ownertrust information cleared\n"));
325         }
326     }
327
328  leave:
329   keydb_release (hd);
330   release_kbnode (keyblock);
331   return err;
332 }
333
334
335 /*
336  * Delete a public or secret key from a keyring.
337  */
338 gpg_error_t
339 delete_keys (ctrl_t ctrl, strlist_t names, int secret, int allow_both)
340 {
341   gpg_error_t err;
342   int avail;
343   int force = (!allow_both && !secret && opt.expert);
344
345   /* Force allows us to delete a public key even if a secret key
346      exists. */
347
348   for ( ;names ; names=names->next )
349     {
350       err = do_delete_key (ctrl, names->d, secret, force, &avail);
351       if (err && avail)
352         {
353           if (allow_both)
354             {
355               err = do_delete_key (ctrl, names->d, 1, 0, &avail);
356               if (!err)
357                 err = do_delete_key (ctrl, names->d, 0, 0, &avail);
358             }
359           else
360             {
361               log_error (_("there is a secret key for public key \"%s\"!\n"),
362                          names->d);
363               log_info(_("use option \"--delete-secret-keys\" to delete"
364                          " it first.\n"));
365               write_status_text (STATUS_DELETE_PROBLEM, "2");
366               return err;
367             }
368         }
369
370       if (err)
371         {
372           log_error ("%s: delete key failed: %s\n",
373                      names->d, gpg_strerror (err));
374           return err;
375         }
376     }
377
378   return 0;
379 }