card: Suppress error message by agent_scd_cardlist.
[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     SK_LIST 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       release_sk_list (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               char *serialno;
384
385               name = NULL;
386               keyblock = NULL;
387               switch (c->state)
388                 {
389                 case 0: /* First try to use the --default-key.  */
390                   name = parse_def_secret_key (ctrl);
391                   c->state = 1;
392                   break;
393
394                 case 1: /* Init list of keys to try.  */
395                   c->sl = opt.secret_keys_to_try;
396                   c->state++;
397                   break;
398
399                 case 2: /* Get next item from list.  */
400                   if (c->sl)
401                     {
402                       name = c->sl->d;
403                       c->sl = c->sl->next;
404                     }
405                   else
406                     c->state++;
407                   break;
408
409                 case 3: /* Init list of card keys to try.  */
410                   err = agent_scd_cardlist (&c->card_list);
411                   if (!err)
412                     agent_scd_serialno (&c->serialno, NULL);
413                   c->sl = c->card_list;
414                   c->state++;
415                   break;
416
417                 case 4: /* Get next item from card list.  */
418                   if (c->sl)
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                       serialno = c->serialno;
448                       if (serialno)
449                         {
450                           /* Select the original card again.  */
451                           agent_scd_serialno (&c->serialno, serialno);
452                           xfree (serialno);
453                         }
454                       c->state++;
455                     }
456                   break;
457
458                 case 5: /* Init search context to enum all secret keys.  */
459                   err = getkey_bynames (ctrl, &c->ctx, NULL, NULL, 1,
460                                         &keyblock);
461                   if (err)
462                     {
463                       release_kbnode (keyblock);
464                       keyblock = NULL;
465                       getkey_end (ctrl, c->ctx);
466                       c->ctx = NULL;
467                     }
468                   c->state++;
469                   break;
470
471                 case 6: /* Get next item from the context.  */
472                   if (c->ctx)
473                     {
474                       err = getkey_next (ctrl, c->ctx, NULL, &keyblock);
475                       if (err)
476                         {
477                           release_kbnode (keyblock);
478                           keyblock = NULL;
479                           getkey_end (ctrl, c->ctx);
480                           c->ctx = NULL;
481                         }
482                     }
483                   else
484                     c->state++;
485                   break;
486
487                 default: /* No more names to check - stop.  */
488                   c->eof = 1;
489                   free_public_key (sk);
490                   return gpg_error (GPG_ERR_EOF);
491                 }
492             }
493           while ((!name || !*name) && !keyblock);
494
495           if (keyblock)
496             c->node = c->keyblock = keyblock;
497           else
498             {
499               err = getkey_byname (ctrl, NULL, NULL, name, 1, &c->keyblock);
500               if (err)
501                 {
502                   /* getkey_byname might return a keyblock even in the
503                      error case - I have not checked.  Thus better release
504                      it.  */
505                   release_kbnode (c->keyblock);
506                   c->keyblock = NULL;
507                 }
508               else
509                 c->node = c->keyblock;
510             }
511         }
512
513       /* Get the next key from the current keyblock.  */
514       for (; c->node; c->node = c->node->next)
515         {
516           if (c->node->pkt->pkttype == PKT_PUBLIC_KEY
517               || c->node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
518             {
519               SK_LIST r;
520
521               /* Skip this candidate if it's already enumerated.  */
522               for (r = c->results; r; r = r->next)
523                 if (!cmp_public_keys (r->pk, c->node->pkt->pkt.public_key))
524                   break;
525               if (r)
526                 continue;
527
528               copy_public_key (sk, c->node->pkt->pkt.public_key);
529               c->node = c->node->next;
530
531               r = xtrycalloc (1, sizeof (*r));
532               if (!r)
533                 {
534                   err = gpg_error_from_syserror ();
535                   free_public_key (sk);
536                   return err;
537                 }
538
539               r->pk = sk;
540               r->next = c->results;
541               c->results = r;
542
543               return 0; /* Found.  */
544             }
545         }
546
547       /* Dispose the keyblock and continue.  */
548       release_kbnode (c->keyblock);
549       c->keyblock = NULL;
550     }
551 }