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