Fix use of strncpy, which is actually good to use memcpy.
[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         return gpg_error_from_syserror ();
349       *context = c;
350     }
351
352   if (!sk)
353     {
354       /* Free the context.  */
355       xfree (c->serialno);
356       free_strlist (c->card_list);
357       pubkeys_free (c->results);
358       release_kbnode (c->keyblock);
359       getkey_end (ctrl, c->ctx);
360       xfree (c);
361       *context = NULL;
362       return 0;
363     }
364
365   if (c->eof)
366     return gpg_error (GPG_ERR_EOF);
367
368   for (;;)
369     {
370       /* Loop until we have a keyblock.  */
371       while (!c->keyblock)
372         {
373           /* Loop over the list of secret keys.  */
374           do
375             {
376               name = NULL;
377               keyblock = NULL;
378               switch (c->state)
379                 {
380                 case 0: /* First try to use the --default-key.  */
381                   name = parse_def_secret_key (ctrl);
382                   c->state = 1;
383                   break;
384
385                 case 1: /* Init list of keys to try.  */
386                   c->sl = opt.secret_keys_to_try;
387                   c->state++;
388                   break;
389
390                 case 2: /* Get next item from list.  */
391                   if (c->sl)
392                     {
393                       name = c->sl->d;
394                       c->sl = c->sl->next;
395                     }
396                   else
397                     c->state++;
398                   break;
399
400                 case 3: /* Init list of card keys to try.  */
401                   err = agent_scd_cardlist (&c->card_list);
402                   if (!err)
403                     agent_scd_serialno (&c->serialno, NULL);
404                   c->sl = c->card_list;
405                   c->state++;
406                   break;
407
408                 case 4: /* Get next item from card list.  */
409                   if (c->sl)
410                     {
411                       char *serialno;
412
413                       err = agent_scd_serialno (&serialno, c->sl->d);
414                       if (err)
415                         {
416                           if (opt.verbose)
417                             log_info (_("error getting serial number of card: %s\n"),
418                                       gpg_strerror (err));
419                           continue;
420                         }
421
422                       xfree (serialno);
423                       c->info.fpr2len = 0;
424                       err = agent_scd_getattr ("KEY-FPR", &c->info);
425                       if (err)
426                         log_error ("error retrieving key fingerprint from card: %s\n",
427                                    gpg_strerror (err));
428
429                       if (c->info.fpr2len)
430                         {
431                           c->fpr2[0] = '0';
432                           c->fpr2[1] = 'x';
433                           bin2hex (c->info.fpr2, sizeof c->info.fpr2,c->fpr2+2);
434                           name = c->fpr2;
435                         }
436                       c->sl = c->sl->next;
437                     }
438                   else
439                     {
440                       if (c->serialno)
441                         /* Select the original card again.  */
442                         agent_scd_serialno (&c->serialno, c->serialno);
443                       c->state++;
444                     }
445                   break;
446
447                 case 5: /* Init search context to enum all secret keys.  */
448                   err = getkey_bynames (ctrl, &c->ctx, NULL, NULL, 1,
449                                         &keyblock);
450                   if (err)
451                     {
452                       release_kbnode (keyblock);
453                       keyblock = NULL;
454                       getkey_end (ctrl, c->ctx);
455                       c->ctx = NULL;
456                     }
457                   c->state++;
458                   break;
459
460                 case 6: /* Get next item from the context.  */
461                   if (c->ctx)
462                     {
463                       err = getkey_next (ctrl, c->ctx, NULL, &keyblock);
464                       if (err)
465                         {
466                           release_kbnode (keyblock);
467                           keyblock = NULL;
468                           getkey_end (ctrl, c->ctx);
469                           c->ctx = NULL;
470                         }
471                     }
472                   else
473                     c->state++;
474                   break;
475
476                 default: /* No more names to check - stop.  */
477                   c->eof = 1;
478                   return gpg_error (GPG_ERR_EOF);
479                 }
480             }
481           while ((!name || !*name) && !keyblock);
482
483           if (keyblock)
484             c->node = c->keyblock = keyblock;
485           else
486             {
487               err = getkey_byname (ctrl, NULL, NULL, name, 1, &c->keyblock);
488               if (err)
489                 {
490                   /* getkey_byname might return a keyblock even in the
491                      error case - I have not checked.  Thus better release
492                      it.  */
493                   release_kbnode (c->keyblock);
494                   c->keyblock = NULL;
495                 }
496               else
497                 c->node = c->keyblock;
498             }
499         }
500
501       /* Get the next key from the current keyblock.  */
502       for (; c->node; c->node = c->node->next)
503         {
504           if (c->node->pkt->pkttype == PKT_PUBLIC_KEY
505               || c->node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
506             {
507               pubkey_t r;
508
509               /* Skip this candidate if it's already enumerated.  */
510               for (r = c->results; r; r = r->next)
511                 if (!cmp_public_keys (r->pk, c->node->pkt->pkt.public_key))
512                   break;
513               if (r)
514                 continue;
515
516               copy_public_key (sk, c->node->pkt->pkt.public_key);
517               c->node = c->node->next;
518
519               r = xtrycalloc (1, sizeof (*r));
520               if (!r)
521                 {
522                   err = gpg_error_from_syserror ();
523                   free_public_key (sk);
524                   return err;
525                 }
526
527               r->pk = sk;
528               r->keyblock = NULL;
529               r->next = c->results;
530               c->results = r;
531
532               return 0; /* Found.  */
533             }
534         }
535
536       /* Dispose the keyblock and continue.  */
537       release_kbnode (c->keyblock);
538       c->keyblock = NULL;
539     }
540 }