card: Suppress error message by agent_scd_cardlist.
[gnupg.git] / g10 / sig-check.c
1 /* sig-check.c -  Check a signature
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004, 2006 Free Software Foundation, Inc.
4  * Copyright (C) 2015, 2016 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 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "gpg.h"
28 #include "../common/util.h"
29 #include "packet.h"
30 #include "keydb.h"
31 #include "main.h"
32 #include "../common/status.h"
33 #include "../common/i18n.h"
34 #include "options.h"
35 #include "pkglue.h"
36 #include "../common/compliance.h"
37
38 static int check_signature_end (PKT_public_key *pk, PKT_signature *sig,
39                                 gcry_md_hd_t digest,
40                                 int *r_expired, int *r_revoked,
41                                 PKT_public_key *ret_pk);
42
43 static int check_signature_end_simple (PKT_public_key *pk, PKT_signature *sig,
44                                        gcry_md_hd_t digest);
45
46
47 /* Statistics for signature verification.  */
48 struct
49 {
50   unsigned int total;  /* Total number of verifications.  */
51   unsigned int cached; /* Number of seen cache entries.  */
52   unsigned int goodsig;/* Number of good verifications from the cache.  */
53   unsigned int badsig; /* Number of bad verifications from the cache.  */
54 } cache_stats;
55
56
57 /* Dump verification stats.  */
58 void
59 sig_check_dump_stats (void)
60 {
61   log_info ("sig_cache: total=%u cached=%u good=%u bad=%u\n",
62             cache_stats.total, cache_stats.cached,
63             cache_stats.goodsig, cache_stats.badsig);
64 }
65
66
67 /* Check a signature.  This is shorthand for check_signature2 with
68    the unnamed arguments passed as NULL.  */
69 int
70 check_signature (ctrl_t ctrl, PKT_signature *sig, gcry_md_hd_t digest)
71 {
72   return check_signature2 (ctrl, sig, digest, NULL, NULL, NULL, NULL);
73 }
74
75
76 /* Check a signature.
77  *
78  * Looks up the public key that created the signature (SIG->KEYID)
79  * from the key db.  Makes sure that the signature is valid (it was
80  * not created prior to the key, the public key was created in the
81  * past, and the signature does not include any unsupported critical
82  * features), finishes computing the hash of the signature data, and
83  * checks that the signature verifies the digest.  If the key that
84  * generated the signature is a subkey, this function also verifies
85  * that there is a valid backsig from the subkey to the primary key.
86  * Finally, if status fd is enabled and the signature class is 0x00 or
87  * 0x01, then a STATUS_SIG_ID is emitted on the status fd.
88  *
89  * SIG is the signature to check.
90  *
91  * DIGEST contains a valid hash context that already includes the
92  * signed data.  This function adds the relevant meta-data from the
93  * signature packet to compute the final hash.  (See Section 5.2 of
94  * RFC 4880: "The concatenation of the data being signed and the
95  * signature data from the version number through the hashed subpacket
96  * data (inclusive) is hashed.")
97  *
98  * If R_EXPIREDATE is not NULL, R_EXPIREDATE is set to the key's
99  * expiry.
100  *
101  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has expired
102  * (0 otherwise).  Note: PK being expired does not cause this function
103  * to fail.
104  *
105  * If R_REVOKED is not NULL, *R_REVOKED is set to 1 if PK has been
106  * revoked (0 otherwise).  Note: PK being revoked does not cause this
107  * function to fail.
108  *
109  * If R_PK is not NULL, the public key is stored at that address if it
110  * was found; other wise NULL is stored.
111  *
112  * Returns 0 on success.  An error code otherwise.  */
113 gpg_error_t
114 check_signature2 (ctrl_t ctrl,
115                   PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
116                   int *r_expired, int *r_revoked, PKT_public_key **r_pk)
117 {
118   int rc=0;
119   PKT_public_key *pk;
120
121   if (r_expiredate)
122     *r_expiredate = 0;
123   if (r_expired)
124     *r_expired = 0;
125   if (r_revoked)
126     *r_revoked = 0;
127   if (r_pk)
128     *r_pk = NULL;
129
130   pk = xtrycalloc (1, sizeof *pk);
131   if (!pk)
132     return gpg_error_from_syserror ();
133
134   if  ((rc=openpgp_md_test_algo(sig->digest_algo)))
135     {
136       /* We don't have this digest. */
137     }
138   else if (!gnupg_digest_is_allowed (opt.compliance, 0, sig->digest_algo))
139     {
140       /* Compliance failure.  */
141       log_info (_("digest algorithm '%s' may not be used in %s mode\n"),
142                 gcry_md_algo_name (sig->digest_algo),
143                 gnupg_compliance_option_string (opt.compliance));
144       rc = gpg_error (GPG_ERR_DIGEST_ALGO);
145     }
146   else if ((rc=openpgp_pk_test_algo(sig->pubkey_algo)))
147     {
148       /* We don't have this pubkey algo. */
149     }
150   else if (!gcry_md_is_enabled (digest,sig->digest_algo))
151     {
152       /* Sanity check that the md has a context for the hash that the
153        * sig is expecting.  This can happen if a onepass sig header
154        * does not match the actual sig, and also if the clearsign
155        * "Hash:" header is missing or does not match the actual sig. */
156       log_info(_("WARNING: signature digest conflict in message\n"));
157       rc = gpg_error (GPG_ERR_GENERAL);
158     }
159   else if (get_pubkey_for_sig (ctrl, pk, sig))
160     rc = gpg_error (GPG_ERR_NO_PUBKEY);
161   else if (!gnupg_pk_is_allowed (opt.compliance, PK_USE_VERIFICATION,
162                                  pk->pubkey_algo, pk->pkey,
163                                  nbits_from_pk (pk),
164                                  NULL))
165     {
166       /* Compliance failure.  */
167       log_error (_("key %s may not be used for signing in %s mode\n"),
168                  keystr_from_pk (pk),
169                  gnupg_compliance_option_string (opt.compliance));
170       rc = gpg_error (GPG_ERR_PUBKEY_ALGO);
171     }
172   else if (!pk->flags.valid)
173     {
174       /* You cannot have a good sig from an invalid key.  */
175       rc = gpg_error (GPG_ERR_BAD_PUBKEY);
176     }
177   else
178     {
179       if (r_expiredate)
180         *r_expiredate = pk->expiredate;
181
182       rc = check_signature_end (pk, sig, digest, r_expired, r_revoked, NULL);
183
184       /* Check the backsig.  This is a back signature (0x19) from
185        * the subkey on the primary key.  The idea here is that it
186        * should not be possible for someone to "steal" subkeys and
187        * claim them as their own.  The attacker couldn't actually
188        * use the subkey, but they could try and claim ownership of
189        * any signatures issued by it.  */
190       if (!rc && !pk->flags.primary && pk->flags.backsig < 2)
191         {
192           if (!pk->flags.backsig)
193             {
194               log_info (_("WARNING: signing subkey %s is not"
195                           " cross-certified\n"),keystr_from_pk(pk));
196               log_info (_("please see %s for more information\n"),
197                         "https://gnupg.org/faq/subkey-cross-certify.html");
198               /* The default option --require-cross-certification
199                * makes this warning an error.  */
200               if (opt.flags.require_cross_cert)
201                 rc = gpg_error (GPG_ERR_GENERAL);
202             }
203           else if(pk->flags.backsig == 1)
204             {
205               log_info (_("WARNING: signing subkey %s has an invalid"
206                           " cross-certification\n"), keystr_from_pk(pk));
207               rc = gpg_error (GPG_ERR_GENERAL);
208             }
209         }
210
211     }
212
213     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
214         /* This signature id works best with DLP algorithms because
215          * they use a random parameter for every signature.  Instead of
216          * this sig-id we could have also used the hash of the document
217          * and the timestamp, but the drawback of this is, that it is
218          * not possible to sign more than one identical document within
219          * one second.  Some remote batch processing applications might
220          * like this feature here.
221          *
222          * Note that before 2.0.10, we used RIPE-MD160 for the hash
223          * and accidentally didn't include the timestamp and algorithm
224          * information in the hash.  Given that this feature is not
225          * commonly used and that a replay attacks detection should
226          * not solely be based on this feature (because it does not
227          * work with RSA), we take the freedom and switch to SHA-1
228          * with 2.0.10 to take advantage of hardware supported SHA-1
229          * implementations.  We also include the missing information
230          * in the hash.  Note also the SIG_ID as computed by gpg 1.x
231          * and gpg 2.x didn't matched either because 2.x used to print
232          * MPIs not in PGP format.  */
233         u32 a = sig->timestamp;
234         int nsig = pubkey_get_nsig( sig->pubkey_algo );
235         unsigned char *p, *buffer;
236         size_t n, nbytes;
237         int i;
238         char hashbuf[20];  /* We use SHA-1 here.  */
239
240       nbytes = 6;
241       for (i=0; i < nsig; i++ )
242         {
243           if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &n, sig->data[i]))
244             BUG();
245           nbytes += n;
246         }
247
248       /* Make buffer large enough to be later used as output buffer.  */
249       if (nbytes < 100)
250         nbytes = 100;
251       nbytes += 10;  /* Safety margin.  */
252
253       /* Fill and hash buffer.  */
254       buffer = p = xmalloc (nbytes);
255       *p++ = sig->pubkey_algo;
256       *p++ = sig->digest_algo;
257       *p++ = (a >> 24) & 0xff;
258       *p++ = (a >> 16) & 0xff;
259       *p++ = (a >>  8) & 0xff;
260       *p++ =  a & 0xff;
261       nbytes -= 6;
262       for (i=0; i < nsig; i++ )
263         {
264           if (gcry_mpi_print (GCRYMPI_FMT_PGP, p, nbytes, &n, sig->data[i]))
265             BUG();
266           p += n;
267           nbytes -= n;
268         }
269       gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, buffer, p-buffer);
270
271       p = make_radix64_string (hashbuf, 20);
272       sprintf (buffer, "%s %s %lu",
273                p, strtimestamp (sig->timestamp), (ulong)sig->timestamp);
274       xfree (p);
275       write_status_text (STATUS_SIG_ID, buffer);
276       xfree (buffer);
277     }
278
279   if (r_pk)
280     *r_pk = pk;
281   else
282     {
283       release_public_key_parts (pk);
284       xfree (pk);
285     }
286
287   return rc;
288 }
289
290
291 /* The signature SIG was generated with the public key PK.  Check
292  * whether the signature is valid in the following sense:
293  *
294  *   - Make sure the public key was created before the signature was
295  *     generated.
296  *
297  *   - Make sure the public key was created in the past
298  *
299  *   - Check whether PK has expired (set *R_EXPIRED to 1 if so and 0
300  *     otherwise)
301  *
302  *   - Check whether PK has been revoked (set *R_REVOKED to 1 if so
303  *     and 0 otherwise).
304  *
305  * If either of the first two tests fail, returns an error code.
306  * Otherwise returns 0.  (Thus, this function doesn't fail if the
307  * public key is expired or revoked.)  */
308 static int
309 check_signature_metadata_validity (PKT_public_key *pk, PKT_signature *sig,
310                                    int *r_expired, int *r_revoked)
311 {
312   u32 cur_time;
313
314   if (r_expired)
315     *r_expired = 0;
316   if (r_revoked)
317     *r_revoked = 0;
318
319   if (pk->timestamp > sig->timestamp )
320     {
321       ulong d = pk->timestamp - sig->timestamp;
322       if ( d < 86400 )
323         {
324           log_info (ngettext
325                     ("public key %s is %lu second newer than the signature\n",
326                      "public key %s is %lu seconds newer than the signature\n",
327                      d), keystr_from_pk (pk), d);
328         }
329       else
330         {
331           d /= 86400;
332           log_info (ngettext
333                     ("public key %s is %lu day newer than the signature\n",
334                      "public key %s is %lu days newer than the signature\n",
335                      d), keystr_from_pk (pk), d);
336         }
337       if (!opt.ignore_time_conflict)
338         return GPG_ERR_TIME_CONFLICT; /* pubkey newer than signature.  */
339     }
340
341   cur_time = make_timestamp ();
342   if (pk->timestamp > cur_time)
343     {
344       ulong d = pk->timestamp - cur_time;
345       if (d < 86400)
346         {
347           log_info (ngettext("key %s was created %lu second"
348                              " in the future (time warp or clock problem)\n",
349                              "key %s was created %lu seconds"
350                              " in the future (time warp or clock problem)\n",
351                              d), keystr_from_pk (pk), d);
352         }
353       else
354         {
355           d /= 86400;
356           log_info (ngettext("key %s was created %lu day"
357                              " in the future (time warp or clock problem)\n",
358                              "key %s was created %lu days"
359                              " in the future (time warp or clock problem)\n",
360                              d), keystr_from_pk (pk), d);
361         }
362       if (!opt.ignore_time_conflict)
363         return GPG_ERR_TIME_CONFLICT;
364     }
365
366   /* Check whether the key has expired.  We check the has_expired
367    * flag which is set after a full evaluation of the key (getkey.c)
368    * as well as a simple compare to the current time in case the
369    * merge has for whatever reasons not been done.  */
370   if (pk->has_expired || (pk->expiredate && pk->expiredate < cur_time))
371     {
372       char buf[11];
373       if (opt.verbose)
374         log_info (_("Note: signature key %s expired %s\n"),
375                   keystr_from_pk(pk), asctimestamp( pk->expiredate ) );
376       snprintf (buf, sizeof buf, "%lu",(ulong)pk->expiredate);
377       write_status_text (STATUS_KEYEXPIRED, buf);
378       if (r_expired)
379         *r_expired = 1;
380     }
381
382   if (pk->flags.revoked)
383     {
384       if (opt.verbose)
385         log_info (_("Note: signature key %s has been revoked\n"),
386                   keystr_from_pk(pk));
387       if (r_revoked)
388         *r_revoked=1;
389     }
390
391   return 0;
392 }
393
394
395 /* Finish generating a signature and check it.  Concretely: make sure
396  * that the signature is valid (it was not created prior to the key,
397  * the public key was created in the past, and the signature does not
398  * include any unsupported critical features), finish computing the
399  * digest by adding the relevant data from the signature packet, and
400  * check that the signature verifies the digest.
401  *
402  * DIGEST contains a hash context, which has already hashed the signed
403  * data.  This function adds the relevant meta-data from the signature
404  * packet to compute the final hash.  (See Section 5.2 of RFC 4880:
405  * "The concatenation of the data being signed and the signature data
406  * from the version number through the hashed subpacket data
407  * (inclusive) is hashed.")
408  *
409  * SIG is the signature to check.
410  *
411  * PK is the public key used to generate the signature.
412  *
413  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has expired
414  * (0 otherwise).  Note: PK being expired does not cause this function
415  * to fail.
416  *
417  * If R_REVOKED is not NULL, *R_REVOKED is set to 1 if PK has been
418  * revoked (0 otherwise).  Note: PK being revoked does not cause this
419  * function to fail.
420  *
421  * If RET_PK is not NULL, PK is copied into RET_PK on success.
422  *
423  * Returns 0 on success.  An error code other.  */
424 static int
425 check_signature_end (PKT_public_key *pk, PKT_signature *sig,
426                      gcry_md_hd_t digest,
427                      int *r_expired, int *r_revoked, PKT_public_key *ret_pk)
428 {
429   int rc = 0;
430
431   if ((rc = check_signature_metadata_validity (pk, sig,
432                                                r_expired, r_revoked)))
433     return rc;
434
435   if ((rc = check_signature_end_simple (pk, sig, digest)))
436     return rc;
437
438   if (!rc && ret_pk)
439     copy_public_key(ret_pk,pk);
440
441   return rc;
442 }
443
444
445 /* This function is similar to check_signature_end, but it only checks
446  * whether the signature was generated by PK.  It does not check
447  * expiration, revocation, etc.  */
448 static int
449 check_signature_end_simple (PKT_public_key *pk, PKT_signature *sig,
450                             gcry_md_hd_t digest)
451 {
452   gcry_mpi_t result = NULL;
453   int rc = 0;
454   const struct weakhash *weak;
455
456   if (!opt.flags.allow_weak_digest_algos)
457     {
458       for (weak = opt.weak_digests; weak; weak = weak->next)
459         if (sig->digest_algo == weak->algo)
460           {
461             print_digest_rejected_note(sig->digest_algo);
462             return GPG_ERR_DIGEST_ALGO;
463           }
464     }
465
466   /* For key signatures check that the key has a cert usage.  We may
467    * do this only for subkeys because the primary may always issue key
468    * signature.  The latter may not be reflected in the pubkey_usage
469    * field because we need to check the key signatures to extract the
470    * key usage.  */
471   if (!pk->flags.primary
472       && IS_CERT (sig) && !(pk->pubkey_usage & PUBKEY_USAGE_CERT))
473     {
474       rc = gpg_error (GPG_ERR_WRONG_KEY_USAGE);
475       if (!opt.quiet)
476         log_info (_("bad key signature from key %s: %s (0x%02x, 0x%x)\n"),
477                   keystr_from_pk (pk), gpg_strerror (rc),
478                   sig->sig_class, pk->pubkey_usage);
479       return rc;
480     }
481
482   /* For data signatures check that the key has sign usage.  */
483   if (!IS_BACK_SIG (sig) && IS_SIG (sig)
484       && !(pk->pubkey_usage & PUBKEY_USAGE_SIG))
485     {
486       rc = gpg_error (GPG_ERR_WRONG_KEY_USAGE);
487       if (!opt.quiet)
488         log_info (_("bad data signature from key %s: %s (0x%02x, 0x%x)\n"),
489                   keystr_from_pk (pk), gpg_strerror (rc),
490                   sig->sig_class, pk->pubkey_usage);
491       return rc;
492     }
493
494   /* Make sure the digest algo is enabled (in case of a detached
495    * signature).  */
496   gcry_md_enable (digest, sig->digest_algo);
497
498   /* Complete the digest. */
499   if (sig->version >= 4)
500     gcry_md_putc (digest, sig->version);
501
502   gcry_md_putc( digest, sig->sig_class );
503   if (sig->version < 4)
504     {
505       u32 a = sig->timestamp;
506       gcry_md_putc (digest, ((a >> 24) & 0xff));
507       gcry_md_putc (digest, ((a >> 16) & 0xff));
508       gcry_md_putc (digest, ((a >>  8) & 0xff));
509       gcry_md_putc (digest, ( a        & 0xff));
510     }
511   else
512     {
513       byte buf[10];
514       int i;
515       size_t n;
516       gcry_md_putc (digest, sig->pubkey_algo);
517       gcry_md_putc (digest, sig->digest_algo);
518       if (sig->hashed)
519         {
520           n = sig->hashed->len;
521           gcry_md_putc (digest, (n >> 8) );
522           gcry_md_putc (digest,  n       );
523           gcry_md_write (digest, sig->hashed->data, n);
524           n += 6;
525         }
526       else
527         {
528           /* Two octets for the (empty) length of the hashed
529            * section. */
530           gcry_md_putc (digest, 0);
531           gcry_md_putc (digest, 0);
532           n = 6;
533         }
534         /* add some magic per Section 5.2.4 of RFC 4880.  */
535         i = 0;
536         buf[i++] = sig->version;
537         buf[i++] = 0xff;
538         if (sig->version >= 5)
539           {
540             buf[i++] = 0;
541             buf[i++] = 0;
542             buf[i++] = 0;
543             buf[i++] = 0;
544           }
545         buf[i++] = n >> 24;
546         buf[i++] = n >> 16;
547         buf[i++] = n >>  8;
548         buf[i++] = n;
549         gcry_md_write (digest, buf, i);
550     }
551     gcry_md_final( digest );
552
553     /* Convert the digest to an MPI.  */
554     result = encode_md_value (pk, digest, sig->digest_algo );
555     if (!result)
556         return GPG_ERR_GENERAL;
557
558     /* Verify the signature.  */
559     if (DBG_CLOCK && sig->sig_class <= 0x01)
560       log_clock ("enter pk_verify");
561     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
562     if (DBG_CLOCK && sig->sig_class <= 0x01)
563       log_clock ("leave pk_verify");
564     gcry_mpi_release (result);
565
566   if (!rc && sig->flags.unknown_critical)
567     {
568       log_info(_("assuming bad signature from key %s"
569                  " due to an unknown critical bit\n"),keystr_from_pk(pk));
570       rc = GPG_ERR_BAD_SIGNATURE;
571     }
572
573   return rc;
574 }
575
576
577 /* Add a uid node to a hash context.  See section 5.2.4, paragraph 4
578  * of RFC 4880.  */
579 static void
580 hash_uid_packet (PKT_user_id *uid, gcry_md_hd_t md, PKT_signature *sig )
581 {
582   if (uid->attrib_data)
583     {
584       if (sig->version >= 4)
585         {
586           byte buf[5];
587           buf[0] = 0xd1;                   /* packet of type 17 */
588           buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
589           buf[2] = uid->attrib_len >> 16;
590           buf[3] = uid->attrib_len >>  8;
591           buf[4] = uid->attrib_len;
592           gcry_md_write( md, buf, 5 );
593         }
594       gcry_md_write( md, uid->attrib_data, uid->attrib_len );
595     }
596   else
597     {
598       if (sig->version >= 4)
599         {
600           byte buf[5];
601           buf[0] = 0xb4;              /* indicates a userid packet */
602           buf[1] = uid->len >> 24;    /* always use 4 length bytes */
603           buf[2] = uid->len >> 16;
604           buf[3] = uid->len >>  8;
605           buf[4] = uid->len;
606           gcry_md_write( md, buf, 5 );
607         }
608       gcry_md_write( md, uid->name, uid->len );
609     }
610 }
611
612 static void
613 cache_sig_result ( PKT_signature *sig, int result )
614 {
615   if (!result)
616     {
617       sig->flags.checked = 1;
618       sig->flags.valid = 1;
619     }
620   else if  (gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE)
621     {
622       sig->flags.checked = 1;
623       sig->flags.valid = 0;
624     }
625   else
626     {
627       sig->flags.checked = 0;
628       sig->flags.valid = 0;
629     }
630 }
631
632
633 /* SIG is a key revocation signature.  Check if this signature was
634  * generated by any of the public key PK's designated revokers.
635  *
636  *   PK is the public key that SIG allegedly revokes.
637  *
638  *   SIG is the revocation signature to check.
639  *
640  * This function avoids infinite recursion, which can happen if two
641  * keys are designed revokers for each other and they revoke each
642  * other.  This is done by observing that if a key A is revoked by key
643  * B we still consider the revocation to be valid even if B is
644  * revoked.  Thus, we don't need to determine whether B is revoked to
645  * determine whether A has been revoked by B, we just need to check
646  * the signature.
647  *
648  * Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
649  * revoked.  We are careful to make sure that GPG_ERR_NO_PUBKEY is
650  * only returned when a revocation signature is from a valid
651  * revocation key designated in a revkey subpacket, but the revocation
652  * key itself isn't present.
653  *
654  * XXX: This code will need to be modified if gpg ever becomes
655  * multi-threaded.  Note that this guarantees that a designated
656  * revocation sig will never be considered valid unless it is actually
657  * valid, as well as being issued by a revocation key in a valid
658  * direct signature.  Note also that this is written so that a revoked
659  * revoker can still issue revocations: i.e. If A revokes B, but A is
660  * revoked, B is still revoked.  I'm not completely convinced this is
661  * the proper behavior, but it matches how PGP does it. -dms */
662 int
663 check_revocation_keys (ctrl_t ctrl, PKT_public_key *pk, PKT_signature *sig)
664 {
665   static int busy=0;
666   int i;
667   int rc = GPG_ERR_GENERAL;
668
669   log_assert (IS_KEY_REV(sig));
670   log_assert ((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
671
672   /* Avoid infinite recursion.  Consider the following:
673    *
674    *   - We want to check if A is revoked.
675    *
676    *   - C is a designated revoker for B and has revoked B.
677    *
678    *   - B is a designated revoker for A and has revoked A.
679    *
680    * When checking if A is revoked (in merge_selfsigs_main), we
681    * observe that A has a designed revoker.  As such, we call this
682    * function.  This function sees that there is a valid revocation
683    * signature, which is signed by B.  It then calls check_signature()
684    * to verify that the signature is good.  To check the sig, we need
685    * to lookup B.  Looking up B means calling merge_selfsigs_main,
686    * which checks whether B is revoked, which calls this function to
687    * see if B was revoked by some key.
688    *
689    * In this case, the added level of indirection doesn't hurt.  It
690    * just means a bit more work.  However, if C == A, then we'd end up
691    * in a loop.  But, it doesn't make sense to look up C anyways: even
692    * if B is revoked, we conservatively consider a valid revocation
693    * signed by B to revoke A.  Since this is the only place where this
694    * type of recursion can occur, we simply cause this function to
695    * fail if it is entered recursively.  */
696   if (busy)
697     {
698       /* Return an error (i.e. not revoked), but mark the pk as
699          uncacheable as we don't really know its revocation status
700          until it is checked directly.  */
701       pk->flags.dont_cache = 1;
702       return rc;
703     }
704
705   busy=1;
706
707   /*  es_printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
708       (ulong)sig->keyid[1]); */
709
710   /* is the issuer of the sig one of our revokers? */
711   if( !pk->revkey && pk->numrevkeys )
712      BUG();
713   else
714       for(i=0;i<pk->numrevkeys;i++)
715         {
716           /* The revoker's keyid.  */
717           u32 keyid[2];
718
719           keyid_from_fingerprint (ctrl, pk->revkey[i].fpr, pk->revkey[i].fprlen,
720                                   keyid);
721
722           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
723             /* The signature was generated by a designated revoker.
724                Verify the signature.  */
725             {
726               gcry_md_hd_t md;
727
728               if (gcry_md_open (&md, sig->digest_algo, 0))
729                 BUG ();
730               hash_public_key(md,pk);
731               /* Note: check_signature only checks that the signature
732                  is good.  It does not fail if the key is revoked.  */
733               rc = check_signature (ctrl, sig, md);
734               cache_sig_result(sig,rc);
735               gcry_md_close (md);
736               break;
737             }
738         }
739
740   busy=0;
741
742   return rc;
743 }
744
745 /* Check that the backsig BACKSIG from the subkey SUB_PK to its
746  * primary key MAIN_PK is valid.
747  *
748  * Backsigs (0x19) have the same format as binding sigs (0x18), but
749  * this function is simpler than check_key_signature in a few ways.
750  * For example, there is no support for expiring backsigs since it is
751  * questionable what such a thing actually means.  Note also that the
752  * sig cache check here, unlike other sig caches in GnuPG, is not
753  * persistent.  */
754 int
755 check_backsig (PKT_public_key *main_pk,PKT_public_key *sub_pk,
756                PKT_signature *backsig)
757 {
758   gcry_md_hd_t md;
759   int rc;
760
761   /* Always check whether the algorithm is available.  Although
762      gcry_md_open would throw an error, some libgcrypt versions will
763      print a debug message in that case too. */
764   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
765     return rc;
766
767   if(!opt.no_sig_cache && backsig->flags.checked)
768     return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
769
770   rc = gcry_md_open (&md, backsig->digest_algo,0);
771   if (!rc)
772     {
773       hash_public_key(md,main_pk);
774       hash_public_key(md,sub_pk);
775       rc = check_signature_end (sub_pk, backsig, md, NULL, NULL, NULL);
776       cache_sig_result(backsig,rc);
777       gcry_md_close(md);
778     }
779
780   return rc;
781 }
782
783
784 /* Check that a signature over a key is valid.  This is a
785  * specialization of check_key_signature2 with the unnamed parameters
786  * passed as NULL.  See the documentation for that function for more
787  * details.  */
788 int
789 check_key_signature (ctrl_t ctrl, kbnode_t root, kbnode_t node,
790                      int *is_selfsig)
791 {
792   return check_key_signature2 (ctrl, root, node, NULL, NULL,
793                                is_selfsig, NULL, NULL);
794 }
795
796
797 /* Returns whether SIGNER generated the signature SIG over the packet
798  * PACKET, which is a key, subkey or uid, and comes from the key block
799  * KB.  (KB is PACKET's corresponding keyblock; we don't assume that
800  * SIG has been added to the keyblock.)
801  *
802  * If SIGNER is set, then checks whether SIGNER generated the
803  * signature.  Otherwise, uses SIG->KEYID to find the alleged signer.
804  * This parameter can be used to effectively override the alleged
805  * signer that is stored in SIG.
806  *
807  * KB may be NULL if SIGNER is set.
808  *
809  * Unlike check_key_signature, this function ignores any cached
810  * results!  That is, it does not consider SIG->FLAGS.CHECKED and
811  * SIG->FLAGS.VALID nor does it set them.
812  *
813  * This doesn't check the signature's semantic mean.  Concretely, it
814  * doesn't check whether a non-self signed revocation signature was
815  * created by a designated revoker.  In fact, it doesn't return an
816  * error for a binding generated by a completely different key!
817  *
818  * Returns 0 if the signature is valid.  Returns GPG_ERR_SIG_CLASS if
819  * this signature can't be over PACKET.  Returns GPG_ERR_NOT_FOUND if
820  * the key that generated the signature (according to SIG) could not
821  * be found.  Returns GPG_ERR_BAD_SIGNATURE if the signature is bad.
822  * Other errors codes may be returned if something else goes wrong.
823  *
824  * IF IS_SELFSIG is not NULL, sets *IS_SELFSIG to 1 if this is a
825  * self-signature (by the key's primary key) or 0 if not.
826  *
827  * If RET_PK is not NULL, returns a copy of the public key that
828  * generated the signature (i.e., the signer) on success.  This must
829  * be released by the caller using release_public_key_parts ().  */
830 gpg_error_t
831 check_signature_over_key_or_uid (ctrl_t ctrl, PKT_public_key *signer,
832                                  PKT_signature *sig, KBNODE kb, PACKET *packet,
833                                  int *is_selfsig, PKT_public_key *ret_pk)
834 {
835   int rc;
836   PKT_public_key *pripk = kb->pkt->pkt.public_key;
837   gcry_md_hd_t md;
838   int signer_alloced = 0;
839
840   rc = openpgp_pk_test_algo (sig->pubkey_algo);
841   if (rc)
842     return rc;
843   rc = openpgp_md_test_algo (sig->digest_algo);
844   if (rc)
845     return rc;
846
847   /* A signature's class indicates the type of packet that it
848      signs.  */
849   if (IS_BACK_SIG (sig) || IS_KEY_SIG (sig) || IS_KEY_REV (sig))
850     {
851       /* Key revocations can only be over primary keys.  */
852       if (packet->pkttype != PKT_PUBLIC_KEY)
853         return gpg_error (GPG_ERR_SIG_CLASS);
854     }
855   else if (IS_SUBKEY_SIG (sig) || IS_SUBKEY_REV (sig))
856     {
857       if (packet->pkttype != PKT_PUBLIC_SUBKEY)
858         return gpg_error (GPG_ERR_SIG_CLASS);
859     }
860   else if (IS_UID_SIG (sig) || IS_UID_REV (sig))
861     {
862       if (packet->pkttype != PKT_USER_ID)
863         return gpg_error (GPG_ERR_SIG_CLASS);
864     }
865   else
866     return gpg_error (GPG_ERR_SIG_CLASS);
867
868   /* PACKET is the right type for SIG.  */
869
870   if (signer)
871     {
872       if (is_selfsig)
873         {
874           if (signer->keyid[0] == pripk->keyid[0]
875               && signer->keyid[1] == pripk->keyid[1])
876             *is_selfsig = 1;
877           else
878             *is_selfsig = 0;
879         }
880     }
881   else
882     {
883       /* Get the signer.  If possible, avoid a look up.  */
884       if (sig->keyid[0] == pripk->keyid[0]
885           && sig->keyid[1] == pripk->keyid[1])
886         {
887           /* Issued by the primary key.  */
888           signer = pripk;
889           if (is_selfsig)
890             *is_selfsig = 1;
891         }
892       else
893         {
894           /* See if one of the subkeys was the signer (although this
895            * is extremely unlikely).  */
896           kbnode_t ctx = NULL;
897           kbnode_t n;
898
899           while ((n = walk_kbnode (kb, &ctx, 0)))
900             {
901               PKT_public_key *subk;
902
903               if (n->pkt->pkttype != PKT_PUBLIC_SUBKEY)
904                 continue;
905
906               subk = n->pkt->pkt.public_key;
907               if (sig->keyid[0] == subk->keyid[0]
908                   && sig->keyid[1] == subk->keyid[1])
909                 {
910                   /* Issued by a subkey.  */
911                   signer = subk;
912                   break;
913                 }
914             }
915
916           if (! signer)
917             {
918               /* Signer by some other key.  */
919               if (is_selfsig)
920                 *is_selfsig = 0;
921               if (ret_pk)
922                 {
923                   signer = ret_pk;
924                   /* FIXME: Using memset here is probematic because it
925                    * assumes that there are no allocated fields in
926                    * SIGNER.  */
927                   memset (signer, 0, sizeof (*signer));
928                   signer_alloced = 1;
929                 }
930               else
931                 {
932                   signer = xmalloc_clear (sizeof (*signer));
933                   signer_alloced = 2;
934                 }
935
936               if (IS_CERT (sig))
937                 signer->req_usage = PUBKEY_USAGE_CERT;
938
939               rc = get_pubkey_for_sig (ctrl, signer, sig);
940               if (rc)
941                 {
942                   xfree (signer);
943                   signer = NULL;
944                   signer_alloced = 0;
945                   goto leave;
946                 }
947             }
948         }
949     }
950
951   /* We checked above that we supported this algo, so an error here is
952    * a bug.  */
953   if (gcry_md_open (&md, sig->digest_algo, 0))
954     BUG ();
955
956   /* Hash the relevant data.  */
957
958   if (IS_KEY_SIG (sig) || IS_KEY_REV (sig))
959     {
960       log_assert (packet->pkttype == PKT_PUBLIC_KEY);
961       hash_public_key (md, packet->pkt.public_key);
962       rc = check_signature_end_simple (signer, sig, md);
963     }
964   else if (IS_BACK_SIG (sig))
965     {
966       log_assert (packet->pkttype == PKT_PUBLIC_KEY);
967       hash_public_key (md, packet->pkt.public_key);
968       hash_public_key (md, signer);
969       rc = check_signature_end_simple (signer, sig, md);
970     }
971   else if (IS_SUBKEY_SIG (sig) || IS_SUBKEY_REV (sig))
972     {
973       log_assert (packet->pkttype == PKT_PUBLIC_SUBKEY);
974       hash_public_key (md, pripk);
975       hash_public_key (md, packet->pkt.public_key);
976       rc = check_signature_end_simple (signer, sig, md);
977     }
978   else if (IS_UID_SIG (sig) || IS_UID_REV (sig))
979     {
980       log_assert (packet->pkttype == PKT_USER_ID);
981       hash_public_key (md, pripk);
982       hash_uid_packet (packet->pkt.user_id, md, sig);
983       rc = check_signature_end_simple (signer, sig, md);
984     }
985   else
986     {
987       /* We should never get here.  (The first if above should have
988        * already caught this error.)  */
989       BUG ();
990     }
991
992   gcry_md_close (md);
993
994  leave:
995   if (! rc && ret_pk && ret_pk != signer)
996     copy_public_key (ret_pk, signer);
997
998   if (signer_alloced)
999     {
1000       /* We looked up SIGNER; it is not a pointer into KB.  */
1001       release_public_key_parts (signer);
1002       /* Free if we also allocated the memory.  */
1003       if (signer_alloced == 2)
1004         xfree (signer);
1005     }
1006
1007   return rc;
1008 }
1009
1010
1011 /* Check that a signature over a key (e.g., a key revocation, key
1012  * binding, user id certification, etc.) is valid.  If the function
1013  * detects a self-signature, it uses the public key from the specified
1014  * key block and does not bother looking up the key specified in the
1015  * signature packet.
1016  *
1017  * ROOT is a keyblock.
1018  *
1019  * NODE references a signature packet that appears in the keyblock
1020  * that should be verified.
1021  *
1022  * If CHECK_PK is set, the specified key is sometimes preferred for
1023  * verifying signatures.  See the implementation for details.
1024  *
1025  * If RET_PK is not NULL, the public key that successfully verified
1026  * the signature is copied into *RET_PK.
1027  *
1028  * If IS_SELFSIG is not NULL, *IS_SELFSIG is set to 1 if NODE is a
1029  * self-signature.
1030  *
1031  * If R_EXPIREDATE is not NULL, *R_EXPIREDATE is set to the expiry
1032  * date.
1033  *
1034  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has been
1035  * expired (0 otherwise).  Note: PK being revoked does not cause this
1036  * function to fail.
1037  *
1038  *
1039  * If OPT.NO_SIG_CACHE is not set, this function will first check if
1040  * the result of a previous verification is already cached in the
1041  * signature packet's data structure.
1042  *
1043  * TODO: add r_revoked here as well.  It has the same problems as
1044  * r_expiredate and r_expired and the cache.  */
1045 int
1046 check_key_signature2 (ctrl_t ctrl,
1047                       kbnode_t root, kbnode_t node, PKT_public_key *check_pk,
1048                       PKT_public_key *ret_pk, int *is_selfsig,
1049                       u32 *r_expiredate, int *r_expired )
1050 {
1051   PKT_public_key *pk;
1052   PKT_signature *sig;
1053   int algo;
1054   int rc;
1055
1056   if (is_selfsig)
1057     *is_selfsig = 0;
1058   if (r_expiredate)
1059     *r_expiredate = 0;
1060   if (r_expired)
1061     *r_expired = 0;
1062   log_assert (node->pkt->pkttype == PKT_SIGNATURE);
1063   log_assert (root->pkt->pkttype == PKT_PUBLIC_KEY);
1064
1065   pk = root->pkt->pkt.public_key;
1066   sig = node->pkt->pkt.signature;
1067   algo = sig->digest_algo;
1068
1069   /* Check whether we have cached the result of a previous signature
1070    * check.  Note that we may no longer have the pubkey or hash
1071    * needed to verify a sig, but can still use the cached value.  A
1072    * cache refresh detects and clears these cases. */
1073   if ( !opt.no_sig_cache )
1074     {
1075       cache_stats.total++;
1076       if (sig->flags.checked) /* Cached status available.  */
1077         {
1078           cache_stats.cached++;
1079           if (is_selfsig)
1080             {
1081               u32 keyid[2];
1082
1083               keyid_from_pk (pk, keyid);
1084               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
1085                 *is_selfsig = 1;
1086             }
1087           /* BUG: This is wrong for non-self-sigs... needs to be the
1088            * actual pk.  */
1089           rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
1090           if (rc)
1091             return rc;
1092           if (sig->flags.valid)
1093             {
1094               cache_stats.goodsig++;
1095               return 0;
1096             }
1097           cache_stats.badsig++;
1098           return gpg_error (GPG_ERR_BAD_SIGNATURE);
1099         }
1100     }
1101
1102   rc = openpgp_pk_test_algo(sig->pubkey_algo);
1103   if (rc)
1104     return rc;
1105   rc = openpgp_md_test_algo(algo);
1106   if (rc)
1107     return rc;
1108
1109   if (IS_KEY_REV (sig))
1110     {
1111       u32 keyid[2];
1112       keyid_from_pk( pk, keyid );
1113
1114       /* Is it a designated revoker? */
1115       if (keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1])
1116         rc = check_revocation_keys (ctrl, pk, sig);
1117       else
1118         {
1119           rc = check_signature_metadata_validity (pk, sig,
1120                                                   r_expired, NULL);
1121           if (! rc)
1122             rc = check_signature_over_key_or_uid (ctrl, pk, sig,
1123                                                   root, root->pkt,
1124                                                   is_selfsig, ret_pk);
1125         }
1126     }
1127   else if (IS_SUBKEY_REV (sig) || IS_SUBKEY_SIG (sig))
1128     {
1129       kbnode_t snode = find_prev_kbnode (root, node, PKT_PUBLIC_SUBKEY);
1130
1131       if (snode)
1132         {
1133           rc = check_signature_metadata_validity (pk, sig,
1134                                                   r_expired, NULL);
1135           if (! rc)
1136             {
1137               /* A subkey revocation (0x28) must be a self-sig, but a
1138                * subkey signature (0x18) needn't be.  */
1139               rc = check_signature_over_key_or_uid (ctrl,
1140                                                     IS_SUBKEY_SIG (sig)
1141                                                     ? NULL : pk,
1142                                                     sig, root, snode->pkt,
1143                                                     is_selfsig, ret_pk);
1144             }
1145         }
1146       else
1147         {
1148           if (opt.verbose)
1149             {
1150               if (IS_SUBKEY_REV (sig))
1151                 log_info (_("key %s: no subkey for subkey"
1152                             " revocation signature\n"), keystr_from_pk(pk));
1153               else if (sig->sig_class == 0x18)
1154                 log_info(_("key %s: no subkey for subkey"
1155                            " binding signature\n"), keystr_from_pk(pk));
1156             }
1157           rc = GPG_ERR_SIG_CLASS;
1158         }
1159     }
1160   else if (IS_KEY_SIG (sig)) /* direct key signature */
1161       {
1162         rc = check_signature_metadata_validity (pk, sig,
1163                                                 r_expired, NULL);
1164         if (! rc)
1165           rc = check_signature_over_key_or_uid (ctrl, pk, sig, root, root->pkt,
1166                                                 is_selfsig, ret_pk);
1167       }
1168     else if (IS_UID_SIG (sig) || IS_UID_REV (sig))
1169       {
1170         kbnode_t unode = find_prev_kbnode (root, node, PKT_USER_ID);
1171
1172         if (unode)
1173           {
1174             rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
1175             if (! rc)
1176               {
1177                 /* If this is a self-sig, ignore check_pk.  */
1178                 rc = check_signature_over_key_or_uid
1179                   (ctrl,
1180                    keyid_cmp (pk_keyid (pk), sig->keyid) == 0 ? pk : check_pk,
1181                    sig, root, unode->pkt, NULL, ret_pk);
1182               }
1183           }
1184         else
1185           {
1186             if (!opt.quiet)
1187               log_info ("key %s: no user ID for key signature packet"
1188                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
1189             rc = GPG_ERR_SIG_CLASS;
1190           }
1191       }
1192   else
1193     {
1194       log_info ("sig issued by %s with class %d (digest: %02x %02x)"
1195                 " is not valid over a user id or a key id, ignoring.\n",
1196                 keystr (sig->keyid), sig->sig_class,
1197                 sig->digest_start[0], sig->digest_start[1]);
1198       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
1199     }
1200
1201   cache_sig_result  (sig, rc);
1202
1203   return rc;
1204 }