doc: Fix description of the field 11.
[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 MAX_FINGERPRINT_LEN < KEYGRIP_LEN
344 # error buffer too short for this configuration
345 #endif
346
347   if (!c)
348     {
349       /* Make a new context.  */
350       c = xtrycalloc (1, sizeof *c);
351       if (!c)
352         {
353           err = gpg_error_from_syserror ();
354           free_public_key (sk);
355           return err;
356         }
357       *context = c;
358     }
359
360   if (!sk)
361     {
362       /* Free the context.  */
363       xfree (c->serialno);
364       free_strlist (c->card_list);
365       release_sk_list (c->results);
366       release_kbnode (c->keyblock);
367       getkey_end (ctrl, c->ctx);
368       xfree (c);
369       *context = NULL;
370       return 0;
371     }
372
373   if (c->eof)
374     {
375       free_public_key (sk);
376       return gpg_error (GPG_ERR_EOF);
377     }
378
379   for (;;)
380     {
381       /* Loop until we have a keyblock.  */
382       while (!c->keyblock)
383         {
384           /* Loop over the list of secret keys.  */
385           do
386             {
387               char *serialno;
388
389               name = NULL;
390               keyblock = NULL;
391               switch (c->state)
392                 {
393                 case 0: /* First try to use the --default-key.  */
394                   name = parse_def_secret_key (ctrl);
395                   c->state = 1;
396                   break;
397
398                 case 1: /* Init list of keys to try.  */
399                   c->sl = opt.secret_keys_to_try;
400                   c->state++;
401                   break;
402
403                 case 2: /* Get next item from list.  */
404                   if (c->sl)
405                     {
406                       name = c->sl->d;
407                       c->sl = c->sl->next;
408                     }
409                   else
410                     c->state++;
411                   break;
412
413                 case 3: /* Init list of card keys to try.  */
414                   err = agent_scd_cardlist (&c->card_list);
415                   if (!err)
416                     agent_scd_serialno (&c->serialno, NULL);
417                   c->sl = c->card_list;
418                   c->state++;
419                   break;
420
421                 case 4: /* Get next item from card list.  */
422                   if (c->sl)
423                     {
424                       err = agent_scd_serialno (&serialno, c->sl->d);
425                       if (err)
426                         {
427                           if (opt.verbose)
428                             log_info (_("error getting serial number of card: %s\n"),
429                                       gpg_strerror (err));
430                           c->sl = c->sl->next;
431                           continue;
432                         }
433
434                       xfree (serialno);
435                       c->info.fpr2len = 0;
436                       err = agent_scd_getattr ("KEY-FPR", &c->info);
437                       if (!err)
438                         {
439                           if (c->info.fpr2len)
440                             {
441                               c->fpr2[0] = '0';
442                               c->fpr2[1] = 'x';
443                               bin2hex (c->info.fpr2, sizeof c->info.fpr2,
444                                        c->fpr2 + 2);
445                               name = c->fpr2;
446                             }
447                         }
448                       else if (gpg_err_code (err) == GPG_ERR_INV_NAME)
449                         {
450                           /* KEY-FPR not supported by the card - get
451                            * the key using the keygrip.  */
452                           char *keyref;
453                           strlist_t kplist;
454                           const char *s;
455                           int i;
456
457                           err = agent_scd_getattr_one ("$ENCRKEYID", &keyref);
458                           if (!err)
459                             {
460                               err = agent_scd_keypairinfo (ctrl, keyref,
461                                                            &kplist);
462                               if (!err)
463                                 {
464                                   c->fpr2[0] = '&';
465                                   for (i=1, s=kplist->d;
466                                        (*s && *s != ' '
467                                         && i < sizeof c->fpr2 - 3);
468                                        s++, i++)
469                                     c->fpr2[i] = *s;
470                                   c->fpr2[i] = 0;
471                                   name = c->fpr2;
472                                   free_strlist (kplist);
473                                 }
474                               xfree (keyref);
475                             }
476                         }
477
478                       if (err)
479                         log_error ("error retrieving key from card: %s\n",
480                                    gpg_strerror (err));
481
482                       c->sl = c->sl->next;
483                     }
484                   else
485                     {
486                       serialno = c->serialno;
487                       if (serialno)
488                         {
489                           /* Select the original card again.  */
490                           agent_scd_serialno (&c->serialno, serialno);
491                           xfree (serialno);
492                         }
493                       c->state++;
494                     }
495                   break;
496
497                 case 5: /* Init search context to enum all secret keys.  */
498                   err = getkey_bynames (ctrl, &c->ctx, NULL, NULL, 1,
499                                         &keyblock);
500                   if (err)
501                     {
502                       release_kbnode (keyblock);
503                       keyblock = NULL;
504                       getkey_end (ctrl, c->ctx);
505                       c->ctx = NULL;
506                     }
507                   c->state++;
508                   break;
509
510                 case 6: /* Get next item from the context.  */
511                   if (c->ctx)
512                     {
513                       err = getkey_next (ctrl, c->ctx, NULL, &keyblock);
514                       if (err)
515                         {
516                           release_kbnode (keyblock);
517                           keyblock = NULL;
518                           getkey_end (ctrl, c->ctx);
519                           c->ctx = NULL;
520                         }
521                     }
522                   else
523                     c->state++;
524                   break;
525
526                 default: /* No more names to check - stop.  */
527                   c->eof = 1;
528                   free_public_key (sk);
529                   return gpg_error (GPG_ERR_EOF);
530                 }
531             }
532           while ((!name || !*name) && !keyblock);
533
534           if (keyblock)
535             c->node = c->keyblock = keyblock;
536           else
537             {
538               err = getkey_byname (ctrl, NULL, NULL, name, 1, &c->keyblock);
539               if (err)
540                 {
541                   /* getkey_byname might return a keyblock even in the
542                      error case - I have not checked.  Thus better release
543                      it.  */
544                   release_kbnode (c->keyblock);
545                   c->keyblock = NULL;
546                 }
547               else
548                 c->node = c->keyblock;
549             }
550         }
551
552       /* Get the next key from the current keyblock.  */
553       for (; c->node; c->node = c->node->next)
554         {
555           if (c->node->pkt->pkttype == PKT_PUBLIC_KEY
556               || c->node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
557             {
558               SK_LIST r;
559
560               /* Skip this candidate if it's already enumerated.  */
561               for (r = c->results; r; r = r->next)
562                 if (!cmp_public_keys (r->pk, c->node->pkt->pkt.public_key))
563                   break;
564               if (r)
565                 continue;
566
567               copy_public_key (sk, c->node->pkt->pkt.public_key);
568               c->node = c->node->next;
569
570               r = xtrycalloc (1, sizeof (*r));
571               if (!r)
572                 {
573                   err = gpg_error_from_syserror ();
574                   free_public_key (sk);
575                   return err;
576                 }
577
578               r->pk = sk;
579               r->next = c->results;
580               c->results = r;
581
582               return 0; /* Found.  */
583             }
584         }
585
586       /* Dispose the keyblock and continue.  */
587       release_kbnode (c->keyblock);
588       c->keyblock = NULL;
589     }
590 }