d233549684b170badac32dcc12c796882472fb95
[gnupg.git] / g10 / skclist.c
1 /* skclist.c - Build a list of secret keys
2  * Copyright (C) 1998, 1999, 2000, 2001, 2006,
3  *               2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "gpg.h"
28 #include "options.h"
29 #include "packet.h"
30 #include "../common/status.h"
31 #include "keydb.h"
32 #include "../common/util.h"
33 #include "../common/i18n.h"
34 #include "call-agent.h"
35
36
37 /* Return true if Libgcrypt's RNG is in faked mode.  */
38 int
39 random_is_faked (void)
40 {
41   return !!gcry_control (GCRYCTL_FAKED_RANDOM_P, 0);
42 }
43
44
45 void
46 release_sk_list (SK_LIST sk_list)
47 {
48   SK_LIST sk_rover;
49
50   for (; sk_list; sk_list = sk_rover)
51     {
52       sk_rover = sk_list->next;
53       free_public_key (sk_list->pk);
54       xfree (sk_list);
55     }
56 }
57
58
59 /* Check that we are only using keys which don't have
60  * the string "(insecure!)" or "not secure" or "do not use"
61  * in one of the user ids.  */
62 static int
63 is_insecure (ctrl_t ctrl, PKT_public_key *pk)
64 {
65   u32 keyid[2];
66   KBNODE node = NULL, u;
67   int insecure = 0;
68
69   keyid_from_pk (pk, keyid);
70   node = get_pubkeyblock (ctrl, keyid);
71   for (u = node; u; u = u->next)
72     {
73       if (u->pkt->pkttype == PKT_USER_ID)
74         {
75           PKT_user_id *id = u->pkt->pkt.user_id;
76           if (id->attrib_data)
77             continue;           /* skip attribute packets */
78           if (strstr (id->name, "(insecure!)")
79               || strstr (id->name, "not secure")
80               || strstr (id->name, "do not use")
81               || strstr (id->name, "(INSECURE!)"))
82             {
83               insecure = 1;
84               break;
85             }
86         }
87     }
88   release_kbnode (node);
89
90   return insecure;
91 }
92
93 static int
94 key_present_in_sk_list (SK_LIST sk_list, PKT_public_key *pk)
95 {
96   for (; sk_list; sk_list = sk_list->next)
97     {
98       if (!cmp_public_keys (sk_list->pk, pk))
99         return 0;
100     }
101   return -1;
102 }
103
104 static int
105 is_duplicated_entry (strlist_t list, strlist_t item)
106 {
107   for (; list && list != item; list = list->next)
108     {
109       if (!strcmp (list->d, item->d))
110         return 1;
111     }
112   return 0;
113 }
114
115
116 gpg_error_t
117 build_sk_list (ctrl_t ctrl,
118                strlist_t locusr, SK_LIST *ret_sk_list, unsigned int use)
119 {
120   gpg_error_t err;
121   SK_LIST sk_list = NULL;
122
123   /* XXX: Change this function to use get_pubkeys instead of
124      getkey_byname to detect ambiguous key specifications and warn
125      about duplicate keyblocks.  For ambiguous key specifications on
126      the command line or provided interactively, prompt the user to
127      select the best key.  If a key specification is ambiguous and we
128      are in batch mode, die.  */
129
130   if (!locusr) /* No user ids given - use the card key or the default key.  */
131     {
132       struct agent_card_info_s info;
133       PKT_public_key *pk;
134       char *serialno;
135
136       memset (&info, 0, sizeof(info));
137       pk = xmalloc_clear (sizeof *pk);
138       pk->req_usage = use;
139
140       /* Check if a card is available.  If any, use the key as a hint.  */
141       err = agent_scd_serialno (&serialno, NULL);
142       if (!err)
143         {
144           xfree (serialno);
145           err = agent_scd_getattr ("KEY-FPR", &info);
146           if (err)
147             log_error ("error retrieving key fingerprint from card: %s\n",
148                        gpg_strerror (err));
149         }
150
151       err = get_seckey_default_or_card (ctrl, pk,
152                                         info.fpr1len? info.fpr1 : NULL,
153                                         info.fpr1len);
154       if (err)
155         {
156           free_public_key (pk);
157           pk = NULL;
158           log_error ("no default secret key: %s\n", gpg_strerror (err));
159           write_status_text (STATUS_INV_SGNR, get_inv_recpsgnr_code (err));
160         }
161       else if ((err = openpgp_pk_test_algo2 (pk->pubkey_algo, use)))
162         {
163           free_public_key (pk);
164           pk = NULL;
165           log_error ("invalid default secret key: %s\n", gpg_strerror (err));
166           write_status_text (STATUS_INV_SGNR, get_inv_recpsgnr_code (err));
167         }
168       else
169         {
170           SK_LIST r;
171
172           if (random_is_faked () && !is_insecure (ctrl, pk))
173             {
174               log_info (_("key is not flagged as insecure - "
175                           "can't use it with the faked RNG!\n"));
176               free_public_key (pk);
177               pk = NULL;
178               write_status_text (STATUS_INV_SGNR,
179                                  get_inv_recpsgnr_code (GPG_ERR_NOT_TRUSTED));
180             }
181           else
182             {
183               r = xmalloc (sizeof *r);
184               r->pk = pk;
185               pk = NULL;
186               r->next = sk_list;
187               r->mark = 0;
188               sk_list = r;
189             }
190         }
191     }
192   else /* Check the given user ids.  */
193     {
194       strlist_t locusr_orig = locusr;
195
196       for (; locusr; locusr = locusr->next)
197         {
198           PKT_public_key *pk;
199
200           err = 0;
201           /* Do an early check against duplicated entries.  However
202            * this won't catch all duplicates because the user IDs may
203            * be specified in different ways.  */
204           if (is_duplicated_entry (locusr_orig, locusr))
205             {
206               log_info (_("skipped \"%s\": duplicated\n"), locusr->d);
207               continue;
208             }
209           pk = xmalloc_clear (sizeof *pk);
210           pk->req_usage = use;
211           if ((err = getkey_byname (ctrl, NULL, pk, locusr->d, 1, NULL)))
212             {
213               free_public_key (pk);
214               pk = NULL;
215               log_error (_("skipped \"%s\": %s\n"),
216                          locusr->d, gpg_strerror (err));
217               write_status_text_and_buffer
218                 (STATUS_INV_SGNR, get_inv_recpsgnr_code (err),
219                  locusr->d, strlen (locusr->d), -1);
220             }
221           else if (!key_present_in_sk_list (sk_list, pk))
222             {
223               free_public_key (pk);
224               pk = NULL;
225               log_info (_("skipped: secret key already present\n"));
226             }
227           else if ((err = openpgp_pk_test_algo2 (pk->pubkey_algo, use)))
228             {
229               free_public_key (pk);
230               pk = NULL;
231               log_error ("skipped \"%s\": %s\n", locusr->d, gpg_strerror (err));
232               write_status_text_and_buffer
233                 (STATUS_INV_SGNR, get_inv_recpsgnr_code (err),
234                  locusr->d, strlen (locusr->d), -1);
235             }
236           else
237             {
238               SK_LIST r;
239
240               if (pk->version == 4 && (use & PUBKEY_USAGE_SIG)
241                   && pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E)
242                 {
243                   log_info (_("skipped \"%s\": %s\n"), locusr->d,
244                             _("this is a PGP generated Elgamal key which"
245                               " is not secure for signatures!"));
246                   free_public_key (pk);
247                   pk = NULL;
248                   write_status_text_and_buffer
249                     (STATUS_INV_SGNR,
250                      get_inv_recpsgnr_code (GPG_ERR_WRONG_KEY_USAGE),
251                      locusr->d, strlen (locusr->d), -1);
252                 }
253               else if (random_is_faked () && !is_insecure (ctrl, pk))
254                 {
255                   log_info (_("key is not flagged as insecure - "
256                               "can't use it with the faked RNG!\n"));
257                   free_public_key (pk);
258                   pk = NULL;
259                   write_status_text_and_buffer
260                     (STATUS_INV_SGNR,
261                      get_inv_recpsgnr_code (GPG_ERR_NOT_TRUSTED),
262                      locusr->d, strlen (locusr->d), -1);
263                 }
264               else
265                 {
266                   r = xmalloc (sizeof *r);
267                   r->pk = pk;
268                   pk = NULL;
269                   r->next = sk_list;
270                   r->mark = 0;
271                   sk_list = r;
272                 }
273             }
274         }
275     }
276
277   if (!err && !sk_list)
278     {
279       log_error ("no valid signators\n");
280       write_status_text (STATUS_NO_SGNR, "0");
281       err = gpg_error (GPG_ERR_NO_USER_ID);
282     }
283
284   if (err)
285     release_sk_list (sk_list);
286   else
287     *ret_sk_list = sk_list;
288   return err;
289 }
290
291
292 /* Enumerate some secret keys (specifically, those specified with
293  * --default-key and --try-secret-key).  Use the following procedure:
294  *
295  *  1) Initialize a void pointer to NULL
296  *  2) Pass a reference to this pointer to this function (content)
297  *     and provide space for the secret key (sk)
298  *  3) Call this function as long as it does not return an error (or
299  *     until you are done).  The error code GPG_ERR_EOF indicates the
300  *     end of the listing.
301  *  4) Call this function a last time with SK set to NULL,
302  *     so that can free it's context.
303  *
304  * In pseudo-code:
305  *
306  *   void *ctx = NULL;
307  *   PKT_public_key *sk = xmalloc_clear (sizeof (*sk));
308  *
309  *   while ((err = enum_secret_keys (&ctx, sk)))
310  *     { // Process SK.
311  *       if (done)
312  *         break;
313  *       sk = xmalloc_clear (sizeof (*sk));
314  *     }
315  *
316  *   // Release any resources used by CTX.
317  *   enum_secret_keys (&ctx, NULL);
318  *
319  *   if (gpg_err_code (err) != GPG_ERR_EOF)
320  *     ; // An error occurred.
321  */
322 gpg_error_t
323 enum_secret_keys (ctrl_t ctrl, void **context, PKT_public_key *sk)
324 {
325   gpg_error_t err = 0;
326   const char *name;
327   kbnode_t keyblock;
328   struct
329   {
330     int eof;
331     int state;
332     strlist_t sl;
333     strlist_t card_list;
334     char *serialno;
335     char fpr2[2 * MAX_FINGERPRINT_LEN + 3 ];
336     struct agent_card_info_s info;
337     kbnode_t keyblock;
338     kbnode_t node;
339     getkey_ctx_t ctx;
340     pubkey_t results;
341   } *c = *context;
342
343   if (!c)
344     {
345       /* Make a new context.  */
346       c = xtrycalloc (1, sizeof *c);
347       if (!c)
348         {
349           err = gpg_error_from_syserror ();
350           free_public_key (sk);
351           return err;
352         }
353       *context = c;
354     }
355
356   if (!sk)
357     {
358       /* Free the context.  */
359       xfree (c->serialno);
360       free_strlist (c->card_list);
361       pubkeys_free (c->results);
362       release_kbnode (c->keyblock);
363       getkey_end (ctrl, c->ctx);
364       xfree (c);
365       *context = NULL;
366       return 0;
367     }
368
369   if (c->eof)
370     {
371       free_public_key (sk);
372       return gpg_error (GPG_ERR_EOF);
373     }
374
375   for (;;)
376     {
377       /* Loop until we have a keyblock.  */
378       while (!c->keyblock)
379         {
380           /* Loop over the list of secret keys.  */
381           do
382             {
383               name = NULL;
384               keyblock = NULL;
385               switch (c->state)
386                 {
387                 case 0: /* First try to use the --default-key.  */
388                   name = parse_def_secret_key (ctrl);
389                   c->state = 1;
390                   break;
391
392                 case 1: /* Init list of keys to try.  */
393                   c->sl = opt.secret_keys_to_try;
394                   c->state++;
395                   break;
396
397                 case 2: /* Get next item from list.  */
398                   if (c->sl)
399                     {
400                       name = c->sl->d;
401                       c->sl = c->sl->next;
402                     }
403                   else
404                     c->state++;
405                   break;
406
407                 case 3: /* Init list of card keys to try.  */
408                   err = agent_scd_cardlist (&c->card_list);
409                   if (!err)
410                     agent_scd_serialno (&c->serialno, NULL);
411                   c->sl = c->card_list;
412                   c->state++;
413                   break;
414
415                 case 4: /* Get next item from card list.  */
416                   if (c->sl)
417                     {
418                       char *serialno;
419
420                       err = agent_scd_serialno (&serialno, c->sl->d);
421                       if (err)
422                         {
423                           if (opt.verbose)
424                             log_info (_("error getting serial number of card: %s\n"),
425                                       gpg_strerror (err));
426                           continue;
427                         }
428
429                       xfree (serialno);
430                       c->info.fpr2len = 0;
431                       err = agent_scd_getattr ("KEY-FPR", &c->info);
432                       if (err)
433                         log_error ("error retrieving key fingerprint from card: %s\n",
434                                    gpg_strerror (err));
435
436                       if (c->info.fpr2len)
437                         {
438                           c->fpr2[0] = '0';
439                           c->fpr2[1] = 'x';
440                           bin2hex (c->info.fpr2, sizeof c->info.fpr2,c->fpr2+2);
441                           name = c->fpr2;
442                         }
443                       c->sl = c->sl->next;
444                     }
445                   else
446                     {
447                       if (c->serialno)
448                         /* Select the original card again.  */
449                         agent_scd_serialno (&c->serialno, c->serialno);
450                       c->state++;
451                     }
452                   break;
453
454                 case 5: /* Init search context to enum all secret keys.  */
455                   err = getkey_bynames (ctrl, &c->ctx, NULL, NULL, 1,
456                                         &keyblock);
457                   if (err)
458                     {
459                       release_kbnode (keyblock);
460                       keyblock = NULL;
461                       getkey_end (ctrl, c->ctx);
462                       c->ctx = NULL;
463                     }
464                   c->state++;
465                   break;
466
467                 case 6: /* Get next item from the context.  */
468                   if (c->ctx)
469                     {
470                       err = getkey_next (ctrl, c->ctx, NULL, &keyblock);
471                       if (err)
472                         {
473                           release_kbnode (keyblock);
474                           keyblock = NULL;
475                           getkey_end (ctrl, c->ctx);
476                           c->ctx = NULL;
477                         }
478                     }
479                   else
480                     c->state++;
481                   break;
482
483                 default: /* No more names to check - stop.  */
484                   c->eof = 1;
485                   free_public_key (sk);
486                   return gpg_error (GPG_ERR_EOF);
487                 }
488             }
489           while ((!name || !*name) && !keyblock);
490
491           if (keyblock)
492             c->node = c->keyblock = keyblock;
493           else
494             {
495               err = getkey_byname (ctrl, NULL, NULL, name, 1, &c->keyblock);
496               if (err)
497                 {
498                   /* getkey_byname might return a keyblock even in the
499                      error case - I have not checked.  Thus better release
500                      it.  */
501                   release_kbnode (c->keyblock);
502                   c->keyblock = NULL;
503                 }
504               else
505                 c->node = c->keyblock;
506             }
507         }
508
509       /* Get the next key from the current keyblock.  */
510       for (; c->node; c->node = c->node->next)
511         {
512           if (c->node->pkt->pkttype == PKT_PUBLIC_KEY
513               || c->node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
514             {
515               pubkey_t r;
516
517               /* Skip this candidate if it's already enumerated.  */
518               for (r = c->results; r; r = r->next)
519                 if (!cmp_public_keys (r->pk, c->node->pkt->pkt.public_key))
520                   break;
521               if (r)
522                 continue;
523
524               copy_public_key (sk, c->node->pkt->pkt.public_key);
525               c->node = c->node->next;
526
527               r = xtrycalloc (1, sizeof (*r));
528               if (!r)
529                 {
530                   err = gpg_error_from_syserror ();
531                   free_public_key (sk);
532                   return err;
533                 }
534
535               r->pk = sk;
536               r->keyblock = NULL;
537               r->next = c->results;
538               c->results = r;
539
540               return 0; /* Found.  */
541             }
542         }
543
544       /* Dispose the keyblock and continue.  */
545       release_kbnode (c->keyblock);
546       c->keyblock = NULL;
547     }
548 }