gpg: default to AES-256.
[gnupg.git] / g10 / key-check.c
1 /* key-check.c - Detect and fix various problems with keys
2  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2017 Werner Koch
4  * Copyright (C) 2015-2017 g10 Code GmbH
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 <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23
24 #include "gpg.h"
25 #include "options.h"
26 #include "packet.h"
27 #include "keydb.h"
28 #include "main.h"
29 #include "../common/ttyio.h"
30 #include "../common/i18n.h"
31 #include "keyedit.h"
32
33 #include "key-check.h"
34
35 /* Order two signatures.  The actual ordering isn't important.  Our
36  * goal is to ensure that identical signatures occur together.  */
37 static int
38 sig_comparison (const void *av, const void *bv)
39 {
40   const KBNODE an = *(const KBNODE *) av;
41   const KBNODE bn = *(const KBNODE *) bv;
42   const PKT_signature *a;
43   const PKT_signature *b;
44   int ndataa;
45   int ndatab;
46   int i;
47
48   log_assert (an->pkt->pkttype == PKT_SIGNATURE);
49   log_assert (bn->pkt->pkttype == PKT_SIGNATURE);
50
51   a = an->pkt->pkt.signature;
52   b = bn->pkt->pkt.signature;
53
54   if (a->digest_algo < b->digest_algo)
55     return -1;
56   if (a->digest_algo > b->digest_algo)
57     return 1;
58
59   ndataa = pubkey_get_nsig (a->pubkey_algo);
60   ndatab = pubkey_get_nsig (b->pubkey_algo);
61   if (ndataa != ndatab)
62     return (ndataa < ndatab)? -1 : 1;
63
64   for (i = 0; i < ndataa; i ++)
65     {
66       int c = gcry_mpi_cmp (a->data[i], b->data[i]);
67       if (c != 0)
68         return c;
69     }
70
71   /* Okay, they are equal.  */
72   return 0;
73 }
74
75
76 /* Perform a few sanity checks on a keyblock is okay and possibly
77  * repair some damage.  Concretely:
78  *
79  *   - Detect duplicate signatures and remove them.
80  *
81  *   - Detect out of order signatures and relocate them (e.g., a sig
82  *     over user id X located under subkey Y).
83  *
84  * Note: this function does not remove signatures that don't belong or
85  * components that are not signed!  (Although it would be trivial to
86  * do so.)
87  *
88  * If ONLY_SELFSIGS is true, then this function only reorders self
89  * signatures (it still checks all signatures for duplicates,
90  * however).
91  *
92  * Allowed values for MODE are:
93  *  -1 - print to the TTY
94  *   0 - print to stdout
95  *   1 - use log_info.
96  *
97  * Returns true if the keyblock was modified.  */
98 int
99 key_check_all_keysigs (ctrl_t ctrl, int mode, kbnode_t kb,
100                        int only_selected, int only_selfsigs)
101 {
102   gpg_error_t err;
103   estream_t fp = mode < 0? NULL : mode ? log_get_stream () : es_stdout;
104   PKT_public_key *pk;
105   KBNODE n, n_next, *n_prevp, n2;
106   char *pending_desc = NULL;
107   PKT_public_key *issuer;
108   KBNODE last_printed_component;
109   KBNODE current_component = NULL;
110   int dups = 0;
111   int missing_issuer = 0;
112   int reordered = 0;
113   int bad_signature = 0;
114   int missing_selfsig = 0;
115   int modified = 0;
116
117   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
118   pk = kb->pkt->pkt.public_key;
119
120   /* First we look for duplicates.  */
121   {
122     int nsigs;
123     kbnode_t *sigs;
124     int i;
125     int last_i;
126
127     /* Count the sigs.  */
128     for (nsigs = 0, n = kb; n; n = n->next)
129       {
130         if (is_deleted_kbnode (n))
131           continue;
132         else if (n->pkt->pkttype == PKT_SIGNATURE)
133           nsigs ++;
134       }
135
136     if (!nsigs)
137       return 0; /* No signatures at all.  */
138
139     /* Add them all to the SIGS array.  */
140     sigs = xtrycalloc (nsigs, sizeof *sigs);
141     if (!sigs)
142       {
143         log_error (_("error allocating memory: %s\n"),
144                    gpg_strerror (gpg_error_from_syserror ()));
145         return 0;
146       }
147
148     i = 0;
149     for (n = kb; n; n = n->next)
150       {
151         if (is_deleted_kbnode (n))
152           continue;
153
154         if (n->pkt->pkttype != PKT_SIGNATURE)
155           continue;
156
157         sigs[i] = n;
158         i ++;
159       }
160     log_assert (i == nsigs);
161
162     qsort (sigs, nsigs, sizeof (sigs[0]), sig_comparison);
163
164     last_i = 0;
165     for (i = 1; i < nsigs; i ++)
166       {
167         log_assert (sigs[last_i]);
168         log_assert (sigs[last_i]->pkt->pkttype == PKT_SIGNATURE);
169         log_assert (sigs[i]);
170         log_assert (sigs[i]->pkt->pkttype == PKT_SIGNATURE);
171
172         if (sig_comparison (&sigs[last_i], &sigs[i]) == 0)
173           /* They are the same.  Kill the latter.  */
174           {
175             if (DBG_PACKET)
176               {
177                 PKT_signature *sig = sigs[i]->pkt->pkt.signature;
178
179                 log_debug ("Signature appears multiple times, "
180                            "deleting duplicate:\n");
181                 log_debug ("  sig: class 0x%x, issuer: %s,"
182                            " timestamp: %s (%lld), digest: %02x %02x\n",
183                            sig->sig_class, keystr (sig->keyid),
184                            isotimestamp (sig->timestamp),
185                            (long long) sig->timestamp,
186                            sig->digest_start[0], sig->digest_start[1]);
187               }
188
189             /* Remove sigs[i] from the keyblock.  */
190             {
191               KBNODE z, *prevp;
192               int to_kill = last_i;
193               last_i = i;
194
195               for (prevp = &kb, z = kb; z; prevp = &z->next, z = z->next)
196                 if (z == sigs[to_kill])
197                   break;
198
199               *prevp = sigs[to_kill]->next;
200
201               sigs[to_kill]->next = NULL;
202               release_kbnode (sigs[to_kill]);
203               sigs[to_kill] = NULL;
204
205               dups ++;
206               modified = 1;
207             }
208           }
209         else
210           last_i = i;
211       }
212
213     xfree (sigs);
214   }
215
216   /* Make sure the sigs occur after the component (public key, subkey,
217      user id) that they sign.  */
218   issuer = NULL;
219   last_printed_component = NULL;
220   for (n_prevp = &kb, n = kb;
221        n;
222        /* If we moved n, then n_prevp is need valid.  */
223        n_prevp = (n->next == n_next ? &n->next : n_prevp), n = n_next)
224     {
225       PACKET *p;
226       int processed_current_component;
227       PKT_signature *sig;
228       int rc;
229       int dump_sig_params = 0;
230
231       n_next = n->next;
232
233       if (is_deleted_kbnode (n))
234         continue;
235
236       p = n->pkt;
237
238       if (issuer && issuer != pk)
239         {
240           free_public_key (issuer);
241           issuer = NULL;
242         }
243
244       xfree (pending_desc);
245       pending_desc = NULL;
246
247       switch (p->pkttype)
248         {
249         case PKT_PUBLIC_KEY:
250           log_assert (p->pkt.public_key == pk);
251           if (only_selected && ! (n->flag & NODFLG_SELKEY))
252             {
253               current_component = NULL;
254               break;
255             }
256
257           if (DBG_PACKET)
258             log_debug ("public key %s: timestamp: %s (%lld)\n",
259                        pk_keyid_str (pk),
260                        isotimestamp (pk->timestamp),
261                        (long long) pk->timestamp);
262           current_component = n;
263           break;
264         case PKT_PUBLIC_SUBKEY:
265           if (only_selected && ! (n->flag & NODFLG_SELKEY))
266             {
267               current_component = NULL;
268               break;
269             }
270
271           if (DBG_PACKET)
272             log_debug ("subkey %s: timestamp: %s (%lld)\n",
273                        pk_keyid_str (p->pkt.public_key),
274                        isotimestamp (p->pkt.public_key->timestamp),
275                        (long long) p->pkt.public_key->timestamp);
276           current_component = n;
277           break;
278         case PKT_USER_ID:
279           if (only_selected && ! (n->flag & NODFLG_SELUID))
280             {
281               current_component = NULL;
282               break;
283             }
284
285           if (DBG_PACKET)
286             log_debug ("user id: %s\n",
287                        p->pkt.user_id->attrib_data
288                        ? "[ photo id ]"
289                        : p->pkt.user_id->name);
290           current_component = n;
291           break;
292         case PKT_SIGNATURE:
293           if (! current_component)
294             /* The current component is not selected, don't check the
295                sigs under it.  */
296             break;
297
298           sig = n->pkt->pkt.signature;
299
300           pending_desc = xasprintf ("  sig: class: 0x%x, issuer: %s,"
301                                     " timestamp: %s (%lld), digest: %02x %02x",
302                                     sig->sig_class,
303                                     keystr (sig->keyid),
304                                     isotimestamp (sig->timestamp),
305                                     (long long) sig->timestamp,
306                                     sig->digest_start[0], sig->digest_start[1]);
307
308
309           if (keyid_cmp (pk_keyid (pk), sig->keyid) == 0)
310             issuer = pk;
311           else /* Issuer is a different key.  */
312             {
313               if (only_selfsigs)
314                 continue;
315
316               issuer = xmalloc (sizeof (*issuer));
317               err = get_pubkey (ctrl, issuer, sig->keyid);
318               if (err)
319                 {
320                   xfree (issuer);
321                   issuer = NULL;
322                   if (DBG_PACKET)
323                     {
324                       if (pending_desc)
325                         log_debug ("%s", pending_desc);
326                       log_debug ("    Can't check signature allegedly"
327                                  " issued by %s: %s\n",
328                                  keystr (sig->keyid), gpg_strerror (err));
329                     }
330                   missing_issuer ++;
331                   break;
332                 }
333             }
334
335           if ((err = openpgp_pk_test_algo (sig->pubkey_algo)))
336             {
337               if (DBG_PACKET && pending_desc)
338                 log_debug ("%s", pending_desc);
339               log_info (_("can't check signature with unsupported"
340                           " public-key algorithm (%d): %s.\n"),
341                           sig->pubkey_algo, gpg_strerror (err));
342               break;
343             }
344           if ((err = openpgp_md_test_algo (sig->digest_algo)))
345             {
346               if (DBG_PACKET && pending_desc)
347                 log_debug ("%s", pending_desc);
348               log_info (_("can't check signature with unsupported"
349                           " message-digest algorithm %d: %s.\n"),
350                           sig->digest_algo, gpg_strerror (err));
351               break;
352             }
353
354           /* We iterate over the keyblock.  Most likely, the matching
355              component is the current component so always try that
356              first.  */
357           processed_current_component = 0;
358           for (n2 = current_component;
359                n2;
360                n2 = (processed_current_component ? n2->next : kb),
361                  processed_current_component = 1)
362             if (is_deleted_kbnode (n2))
363               continue;
364             else if (processed_current_component && n2 == current_component)
365               /* Don't process it twice.  */
366               continue;
367             else
368               {
369                 err = check_signature_over_key_or_uid (ctrl,
370                                                        issuer, sig, kb, n2->pkt,
371                                                        NULL, NULL);
372                 if (! err)
373                   break;
374               }
375
376           /* n/sig is a signature and n2 is the component (public key,
377              subkey or user id) that it signs, if any.
378              current_component is that component that it appears to
379              apply to (according to the ordering).  */
380
381           if (current_component == n2)
382             {
383               if (DBG_PACKET)
384                 {
385                   log_debug ("%s", pending_desc);
386                   log_debug ("    Good signature over last key or uid!\n");
387                 }
388
389               rc = 0;
390             }
391           else if (n2)
392             {
393               log_assert (n2->pkt->pkttype == PKT_USER_ID
394                           || n2->pkt->pkttype == PKT_PUBLIC_KEY
395                           || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY);
396
397               if (DBG_PACKET)
398                 {
399                   log_debug ("%s", pending_desc);
400                   log_debug ("    Good signature out of order!"
401                              "  (Over %s (%d) '%s')\n",
402                              n2->pkt->pkttype == PKT_USER_ID
403                              ? "user id"
404                              : n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
405                              ? "subkey"
406                              : "primary key",
407                              n2->pkt->pkttype,
408                              n2->pkt->pkttype == PKT_USER_ID
409                              ? n2->pkt->pkt.user_id->name
410                              : pk_keyid_str (n2->pkt->pkt.public_key));
411                 }
412
413               /* Reorder the packets: move the signature n to be just
414                  after n2.  */
415
416               /* Unlink the signature.  */
417               log_assert (n_prevp);
418               *n_prevp = n->next;
419
420               /* Insert the sig immediately after the component.  */
421               n->next = n2->next;
422               n2->next = n;
423
424               reordered ++;
425               modified = 1;
426
427               rc = 0;
428             }
429           else
430             {
431               if (DBG_PACKET)
432                 {
433                   log_debug ("%s", pending_desc);
434                   log_debug ("    Bad signature.\n");
435                 }
436
437               if (DBG_PACKET)
438                 dump_sig_params = 1;
439
440               bad_signature ++;
441
442               rc = GPG_ERR_BAD_SIGNATURE;
443             }
444
445           /* We don't cache the result here, because we haven't
446              completely checked that the signature is legitimate.  For
447              instance, if we have a revocation certificate on Alice's
448              key signed by Bob, the signature may be good, but we
449              haven't checked that Bob is a designated revoker.  */
450           /* cache_sig_result (sig, rc); */
451
452           {
453             int has_selfsig = 0;
454             if (! rc && issuer == pk)
455               {
456                 if (n2->pkt->pkttype == PKT_PUBLIC_KEY
457                     && (/* Direct key signature.  */
458                         sig->sig_class == 0x1f
459                         /* Key revocation signature.  */
460                         || sig->sig_class == 0x20))
461                   has_selfsig = 1;
462                 if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
463                     && (/* Subkey binding sig.  */
464                         sig->sig_class == 0x18
465                         /* Subkey revocation sig.  */
466                         || sig->sig_class == 0x28))
467                   has_selfsig = 1;
468                 if (n2->pkt->pkttype == PKT_USER_ID
469                     && (/* Certification sigs.  */
470                         sig->sig_class == 0x10
471                         || sig->sig_class == 0x11
472                         || sig->sig_class == 0x12
473                         || sig->sig_class == 0x13
474                         /* Certification revocation sig.  */
475                         || sig->sig_class == 0x30))
476                   has_selfsig = 1;
477               }
478
479             if ((n2 && n2 != last_printed_component)
480                 || (! n2 && last_printed_component != current_component))
481               {
482                 int is_reordered = n2 && n2 != current_component;
483                 if (n2)
484                   last_printed_component = n2;
485                 else
486                   last_printed_component = current_component;
487
488                 if (!modified)
489                   ;
490                 else if (last_printed_component->pkt->pkttype == PKT_USER_ID)
491                   {
492                     tty_fprintf (fp, "uid  ");
493                     tty_print_utf8_string2 (fp,
494                                             last_printed_component
495                                             ->pkt->pkt.user_id->name,
496                                             last_printed_component
497                                             ->pkt->pkt.user_id->len, 0);
498                   }
499                 else if (last_printed_component->pkt->pkttype
500                          == PKT_PUBLIC_KEY)
501                   tty_fprintf (fp, "pub  %s",
502                                pk_keyid_str (last_printed_component
503                                              ->pkt->pkt.public_key));
504                 else
505                   tty_fprintf (fp, "sub  %s",
506                                pk_keyid_str (last_printed_component
507                                              ->pkt->pkt.public_key));
508
509                 if (modified)
510                   {
511                     if (is_reordered)
512                       tty_fprintf (fp, _(" (reordered signatures follow)"));
513                     if (mode > 0)
514                       log_printf ("\n");
515                     else
516                       tty_fprintf (fp, "\n");
517                   }
518               }
519
520             if (modified)
521               keyedit_print_one_sig (ctrl, fp, rc, kb, n, NULL, NULL, NULL,
522                                      has_selfsig, 0, only_selfsigs);
523           }
524
525           if (dump_sig_params)
526             {
527               int i;
528
529               for (i = 0; i < pubkey_get_nsig (sig->pubkey_algo); i ++)
530                 {
531                   char buffer[1024];
532                   size_t len;
533                   char *printable;
534                   gcry_mpi_print (GCRYMPI_FMT_USG,
535                                   buffer, sizeof (buffer), &len,
536                                   sig->data[i]);
537                   printable = bin2hex (buffer, len, NULL);
538                   log_debug ("        %d: %s\n", i, printable);
539                   xfree (printable);
540                 }
541             }
542           break;
543         default:
544           if (DBG_PACKET)
545             log_debug ("unhandled packet: %d\n", p->pkttype);
546           break;
547         }
548     }
549
550   xfree (pending_desc);
551   pending_desc = NULL;
552
553   if (issuer != pk)
554     free_public_key (issuer);
555   issuer = NULL;
556
557   /* Identify keys / uids that don't have a self-sig.  */
558   {
559     int has_selfsig = 0;
560     PACKET *p;
561     PKT_signature *sig;
562
563     current_component = NULL;
564     for (n = kb; n; n = n->next)
565       {
566         if (is_deleted_kbnode (n))
567           continue;
568
569         p = n->pkt;
570
571         switch (p->pkttype)
572           {
573           case PKT_PUBLIC_KEY:
574           case PKT_PUBLIC_SUBKEY:
575           case PKT_USER_ID:
576             if (current_component && ! has_selfsig)
577               missing_selfsig ++;
578             current_component = n;
579             has_selfsig = 0;
580             break;
581
582           case PKT_SIGNATURE:
583             if (! current_component || has_selfsig)
584               break;
585
586             sig = n->pkt->pkt.signature;
587
588             if (! (sig->flags.checked && sig->flags.valid))
589               break;
590
591             if (keyid_cmp (pk_keyid (pk), sig->keyid) != 0)
592               /* Different issuer, couldn't be a self-sig.  */
593               break;
594
595             if (current_component->pkt->pkttype == PKT_PUBLIC_KEY
596                 && (/* Direct key signature.  */
597                     sig->sig_class == 0x1f
598                     /* Key revocation signature.  */
599                     || sig->sig_class == 0x20))
600               has_selfsig = 1;
601             if (current_component->pkt->pkttype == PKT_PUBLIC_SUBKEY
602                 && (/* Subkey binding sig.  */
603                     sig->sig_class == 0x18
604                     /* Subkey revocation sig.  */
605                     || sig->sig_class == 0x28))
606               has_selfsig = 1;
607             if (current_component->pkt->pkttype == PKT_USER_ID
608                 && (/* Certification sigs.  */
609                     sig->sig_class == 0x10
610                     || sig->sig_class == 0x11
611                     || sig->sig_class == 0x12
612                     || sig->sig_class == 0x13
613                     /* Certification revocation sig.  */
614                     || sig->sig_class == 0x30))
615               has_selfsig = 1;
616
617             break;
618
619           default:
620             if (current_component && ! has_selfsig)
621               missing_selfsig ++;
622             current_component = NULL;
623           }
624       }
625   }
626
627   if (dups || missing_issuer || bad_signature || reordered)
628     tty_fprintf (fp, _("key %s:\n"), pk_keyid_str (pk));
629
630   if (dups)
631     tty_fprintf (fp,
632                  ngettext ("%d duplicate signature removed\n",
633                            "%d duplicate signatures removed\n", dups), dups);
634   if (missing_issuer)
635     tty_fprintf (fp,
636                  ngettext ("%d signature not checked due to a missing key\n",
637                            "%d signatures not checked due to missing keys\n",
638                            missing_issuer), missing_issuer);
639   if (bad_signature)
640     tty_fprintf (fp,
641                  ngettext ("%d bad signature\n",
642                            "%d bad signatures\n",
643                            bad_signature), bad_signature);
644   if (reordered)
645     tty_fprintf (fp,
646                  ngettext ("%d signature reordered\n",
647                            "%d signatures reordered\n",
648                            reordered), reordered);
649
650   if (only_selfsigs && (bad_signature || reordered))
651     tty_fprintf (fp, _("Warning: errors found and only checked self-signatures,"
652                        " run '%s' to check all signatures.\n"), "check");
653
654   return modified;
655 }