gpg: Re-indent a file.
[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
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 gpg_error_t
51 do_delete_key( const char *username, int secret, int force, int *r_sec_avail )
52 {
53   gpg_error_t err;
54   kbnode_t keyblock = NULL;
55   kbnode_t node;
56   KEYDB_HANDLE hd;
57   PKT_public_key *pk = NULL;
58   u32 keyid[2];
59   int okay=0;
60   int yes;
61   KEYDB_SEARCH_DESC desc;
62   int exactmatch;
63
64   *r_sec_avail = 0;
65
66   hd = keydb_new ();
67
68   /* Search the userid.  */
69   err = classify_user_id (username, &desc, 1);
70   exactmatch = (desc.mode == KEYDB_SEARCH_MODE_FPR
71                 || desc.mode == KEYDB_SEARCH_MODE_FPR16
72                 || desc.mode == KEYDB_SEARCH_MODE_FPR20);
73   if (!err)
74     err = keydb_search (hd, &desc, 1, NULL);
75   if (err)
76     {
77       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
78       write_status_text (STATUS_DELETE_PROBLEM, "1");
79       goto leave;
80     }
81
82   /* Read the keyblock.  */
83   err = keydb_get_keyblock (hd, &keyblock);
84   if (err)
85     {
86       log_error (_("error reading keyblock: %s\n"), gpg_strerror (err) );
87       goto leave;
88     }
89
90   /* Get the keyid from the keyblock.  */
91   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
92   if (!node)
93     {
94       log_error ("Oops; key not found anymore!\n");
95       err = gpg_error (GPG_ERR_GENERAL);
96       goto leave;
97     }
98   pk = node->pkt->pkt.public_key;
99   keyid_from_pk (pk, keyid);
100
101   if (!secret && !force)
102     {
103       if (have_secret_key_with_kid (keyid))
104         {
105           *r_sec_avail = 1;
106           err = gpg_error (GPG_ERR_EOF);
107           goto leave;
108         }
109       else
110         err = 0;
111     }
112
113   if (opt.batch && exactmatch)
114     okay++;
115   else if (opt.batch && secret)
116     {
117       log_error(_("can't do this in batch mode\n"));
118       log_info (_("(unless you specify the key by fingerprint)\n"));
119     }
120   else if (opt.batch && opt.answer_yes)
121     okay++;
122   else if (opt.batch)
123     {
124       log_error(_("can't do this in batch mode without \"--yes\"\n"));
125       log_info (_("(unless you specify the key by fingerprint)\n"));
126     }
127   else
128     {
129       if (secret)
130         print_seckey_info (pk);
131       else
132         print_pubkey_info (NULL, pk );
133       tty_printf( "\n" );
134
135       yes = cpr_get_answer_is_yes
136         (secret? "delete_key.secret.okay": "delete_key.okay",
137          _("Delete this key from the keyring? (y/N) "));
138
139       if (!cpr_enabled() && secret && yes)
140         {
141           /* I think it is not required to check a passphrase; if the
142            * user is so stupid as to let others access his secret
143            * keyring (and has no backup) - it is up him to read some
144            * very basic texts about security.  */
145           yes = cpr_get_answer_is_yes
146             ("delete_key.secret.okay",
147              _("This is a secret key! - really delete? (y/N) "));
148         }
149
150       if (yes)
151         okay++;
152     }
153
154
155   if (okay)
156     {
157       if (secret)
158         {
159           log_error (_("deleting secret key not implemented\n"));
160           err = gpg_error (GPG_ERR_NOT_IMPLEMENTED); /* FIXME */
161           goto leave;
162         }
163       else
164         {
165           err = keydb_delete_keyblock (hd);
166           if (err)
167             {
168               log_error (_("deleting keyblock failed: %s\n"),
169                          gpg_strerror (err));
170               goto leave;
171             }
172         }
173
174       /* Note that the ownertrust being cleared will trigger a
175          revalidation_mark().  This makes sense - only deleting keys
176          that have ownertrust set should trigger this. */
177
178       if (!secret && pk && clear_ownertrusts (pk))
179         {
180           if (opt.verbose)
181             log_info (_("ownertrust information cleared\n"));
182         }
183     }
184
185  leave:
186   keydb_release (hd);
187   release_kbnode (keyblock);
188   return err;
189 }
190
191 /****************
192  * Delete a public or secret key from a keyring.
193  */
194 gpg_error_t
195 delete_keys (strlist_t names, int secret, int allow_both)
196 {
197   gpg_error_t err;
198   int avail;
199   int force = (!allow_both && !secret && opt.expert);
200
201   /* Force allows us to delete a public key even if a secret key
202      exists. */
203
204   for ( ;names ; names=names->next )
205     {
206       err = do_delete_key (names->d, secret, force, &avail);
207       if (err && avail)
208         {
209           if (allow_both)
210             {
211               err = do_delete_key (names->d, 1, 0, &avail);
212               if (!err)
213                 err = do_delete_key (names->d, 0, 0, &avail);
214             }
215           else
216             {
217               log_error (_("there is a secret key for public key \"%s\"!\n"),
218                          names->d);
219               log_info(_("use option \"--delete-secret-keys\" to delete"
220                          " it first.\n"));
221               write_status_text (STATUS_DELETE_PROBLEM, "2");
222               return err;
223             }
224         }
225
226       if (err)
227         {
228           log_error ("%s: delete key failed: %s\n",
229                      names->d, gpg_strerror (err));
230           return err;
231         }
232     }
233
234   return 0;
235 }