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