gpg: Tweak compliance checking for verification
[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       ; /* We don't have this digest. */
136     else if (! gnupg_digest_is_allowed (opt.compliance, 0, sig->digest_algo))
137       {
138         /* Compliance failure.  */
139         log_info (_("you may not use digest algorithm '%s'"
140                     " while in %s mode\n"),
141                   gcry_md_algo_name (sig->digest_algo),
142                   gnupg_compliance_option_string (opt.compliance));
143         rc = gpg_error (GPG_ERR_DIGEST_ALGO);
144       }
145     else if ((rc=openpgp_pk_test_algo(sig->pubkey_algo)))
146       ; /* We don't have this pubkey algo. */
147     else if (!gcry_md_is_enabled (digest,sig->digest_algo))
148       {
149         /* Sanity check that the md has a context for the hash that the
150            sig is expecting.  This can happen if a onepass sig header does
151            not match the actual sig, and also if the clearsign "Hash:"
152            header is missing or does not match the actual sig. */
153
154         log_info(_("WARNING: signature digest conflict in message\n"));
155         rc = gpg_error (GPG_ERR_GENERAL);
156       }
157     else if( get_pubkey (ctrl, pk, sig->keyid ) )
158       rc = gpg_error (GPG_ERR_NO_PUBKEY);
159     else if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_VERIFICATION,
160                                     pk->pubkey_algo, pk->pkey,
161                                     nbits_from_pk (pk),
162                                     NULL))
163       {
164         /* Compliance failure.  */
165         log_error (_("key %s is not suitable for signature verification"
166                      " in %s mode\n"),
167                    keystr_from_pk (pk),
168                    gnupg_compliance_option_string (opt.compliance));
169         rc = gpg_error (GPG_ERR_PUBKEY_ALGO);
170       }
171     else if(!pk->flags.valid)
172       {
173         /* You cannot have a good sig from an invalid key.  */
174         rc = gpg_error (GPG_ERR_BAD_PUBKEY);
175       }
176     else
177       {
178         if(r_expiredate)
179           *r_expiredate = pk->expiredate;
180
181         rc = check_signature_end (pk, sig, digest, r_expired, r_revoked, NULL);
182
183         /* Check the backsig.  This is a 0x19 signature from the
184            subkey on the primary key.  The idea here is that it should
185            not be possible for someone to "steal" subkeys and claim
186            them as their own.  The attacker couldn't actually use the
187            subkey, but they could try and claim ownership of any
188            signatures issued by it. */
189         if (!rc && !pk->flags.primary && pk->flags.backsig < 2)
190           {
191             if (!pk->flags.backsig)
192               {
193                 log_info(_("WARNING: signing subkey %s is not"
194                            " cross-certified\n"),keystr_from_pk(pk));
195                 log_info(_("please see %s for more information\n"),
196                          "https://gnupg.org/faq/subkey-cross-certify.html");
197                 /* --require-cross-certification makes this warning an
198                      error.  TODO: change the default to require this
199                      after more keys have backsigs. */
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];
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
325               (ngettext
326                ("public key %s is %lu second newer than the signature\n",
327                 "public key %s is %lu seconds newer than the signature\n",
328                 d), keystr_from_pk (pk), d);
329           }
330         else
331           {
332             d /= 86400;
333             log_info
334               (ngettext
335                ("public key %s is %lu day newer than the signature\n",
336                 "public key %s is %lu days newer than the signature\n",
337                 d), keystr_from_pk (pk), d);
338           }
339         if (!opt.ignore_time_conflict)
340           return GPG_ERR_TIME_CONFLICT; /* pubkey newer than signature.  */
341       }
342
343     cur_time = make_timestamp();
344     if( pk->timestamp > cur_time )
345       {
346         ulong d = pk->timestamp - cur_time;
347         if (d < 86400)
348           {
349             log_info (ngettext("key %s was created %lu second"
350                                " in the future (time warp or clock problem)\n",
351                                "key %s was created %lu seconds"
352                                " in the future (time warp or clock problem)\n",
353                                d), keystr_from_pk (pk), d);
354           }
355         else
356           {
357             d /= 86400;
358             log_info (ngettext("key %s was created %lu day"
359                                " in the future (time warp or clock problem)\n",
360                                "key %s was created %lu days"
361                                " in the future (time warp or clock problem)\n",
362                                d), keystr_from_pk (pk), d);
363           }
364         if (!opt.ignore_time_conflict)
365           return GPG_ERR_TIME_CONFLICT;
366       }
367
368     /* Check whether the key has expired.  We check the has_expired
369        flag which is set after a full evaluation of the key (getkey.c)
370        as well as a simple compare to the current time in case the
371        merge has for whatever reasons not been done.  */
372     if( pk->has_expired || (pk->expiredate && pk->expiredate < cur_time)) {
373         char buf[11];
374         if (opt.verbose)
375           log_info(_("Note: signature key %s expired %s\n"),
376                    keystr_from_pk(pk), asctimestamp( pk->expiredate ) );
377         sprintf(buf,"%lu",(ulong)pk->expiredate);
378         write_status_text(STATUS_KEYEXPIRED,buf);
379         if(r_expired)
380           *r_expired = 1;
381     }
382
383     if (pk->flags.revoked)
384       {
385         if (opt.verbose)
386           log_info (_("Note: signature key %s has been revoked\n"),
387                     keystr_from_pk(pk));
388         if (r_revoked)
389           *r_revoked=1;
390       }
391
392     return 0;
393 }
394
395
396 /* Finish generating a signature and check it.  Concretely: make sure
397  * that the signature is valid (it was not created prior to the key,
398  * the public key was created in the past, and the signature does not
399  * include any unsupported critical features), finish computing the
400  * digest by adding the relevant data from the signature packet, and
401  * check that the signature verifies the digest.
402  *
403  * DIGEST contains a hash context, which has already hashed the signed
404  * data.  This function adds the relevant meta-data from the signature
405  * packet to compute the final hash.  (See Section 5.2 of RFC 4880:
406  * "The concatenation of the data being signed and the signature data
407  * from the version number through the hashed subpacket data
408  * (inclusive) is hashed.")
409  *
410  * SIG is the signature to check.
411  *
412  * PK is the public key used to generate the signature.
413  *
414  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has expired
415  * (0 otherwise).  Note: PK being expired does not cause this function
416  * to fail.
417  *
418  * If R_REVOKED is not NULL, *R_REVOKED is set to 1 if PK has been
419  * revoked (0 otherwise).  Note: PK being revoked does not cause this
420  * function to fail.
421  *
422  * If RET_PK is not NULL, PK is copied into RET_PK on success.
423  *
424  * Returns 0 on success.  An error code other.  */
425 static int
426 check_signature_end (PKT_public_key *pk, PKT_signature *sig,
427                      gcry_md_hd_t digest,
428                      int *r_expired, int *r_revoked, PKT_public_key *ret_pk)
429 {
430     int rc = 0;
431
432     if ((rc = check_signature_metadata_validity (pk, sig,
433                                                  r_expired, r_revoked)))
434         return rc;
435
436     if ((rc = check_signature_end_simple (pk, sig, digest)))
437       return rc;
438
439     if(!rc && ret_pk)
440       copy_public_key(ret_pk,pk);
441
442     return rc;
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       for (weak = opt.weak_digests; weak; weak = weak->next)
458         if (sig->digest_algo == weak->algo)
459           {
460             print_digest_rejected_note(sig->digest_algo);
461             return GPG_ERR_DIGEST_ALGO;
462           }
463
464     /* Make sure the digest algo is enabled (in case of a detached
465        signature).  */
466     gcry_md_enable (digest, sig->digest_algo);
467
468     /* Complete the digest. */
469     if( sig->version >= 4 )
470         gcry_md_putc( digest, sig->version );
471     gcry_md_putc( digest, sig->sig_class );
472     if( sig->version < 4 ) {
473         u32 a = sig->timestamp;
474         gcry_md_putc( digest, (a >> 24) & 0xff );
475         gcry_md_putc( digest, (a >> 16) & 0xff );
476         gcry_md_putc( digest, (a >>     8) & 0xff );
477         gcry_md_putc( digest,  a           & 0xff );
478     }
479     else {
480         byte buf[6];
481         size_t n;
482         gcry_md_putc( digest, sig->pubkey_algo );
483         gcry_md_putc( digest, sig->digest_algo );
484         if( sig->hashed ) {
485             n = sig->hashed->len;
486             gcry_md_putc (digest, (n >> 8) );
487             gcry_md_putc (digest,  n       );
488             gcry_md_write (digest, sig->hashed->data, n);
489             n += 6;
490         }
491         else {
492           /* Two octets for the (empty) length of the hashed
493              section. */
494           gcry_md_putc (digest, 0);
495           gcry_md_putc (digest, 0);
496           n = 6;
497         }
498         /* add some magic per Section 5.2.4 of RFC 4880.  */
499         buf[0] = sig->version;
500         buf[1] = 0xff;
501         buf[2] = n >> 24;
502         buf[3] = n >> 16;
503         buf[4] = n >>  8;
504         buf[5] = n;
505         gcry_md_write( digest, buf, 6 );
506     }
507     gcry_md_final( digest );
508
509     /* Convert the digest to an MPI.  */
510     result = encode_md_value (pk, digest, sig->digest_algo );
511     if (!result)
512         return GPG_ERR_GENERAL;
513
514     /* Verify the signature.  */
515     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
516     gcry_mpi_release (result);
517
518     if( !rc && sig->flags.unknown_critical )
519       {
520         log_info(_("assuming bad signature from key %s"
521                    " due to an unknown critical bit\n"),keystr_from_pk(pk));
522         rc = GPG_ERR_BAD_SIGNATURE;
523       }
524
525     return rc;
526 }
527
528
529 /* Add a uid node to a hash context.  See section 5.2.4, paragraph 4
530    of RFC 4880.  */
531 static void
532 hash_uid_packet (PKT_user_id *uid, gcry_md_hd_t md, PKT_signature *sig )
533 {
534     if( uid->attrib_data ) {
535         if( sig->version >=4 ) {
536             byte buf[5];
537             buf[0] = 0xd1;                   /* packet of type 17 */
538             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
539             buf[2] = uid->attrib_len >> 16;
540             buf[3] = uid->attrib_len >>  8;
541             buf[4] = uid->attrib_len;
542             gcry_md_write( md, buf, 5 );
543         }
544         gcry_md_write( md, uid->attrib_data, uid->attrib_len );
545     }
546     else {
547         if( sig->version >=4 ) {
548             byte buf[5];
549             buf[0] = 0xb4;            /* indicates a userid packet */
550             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
551             buf[2] = uid->len >> 16;
552             buf[3] = uid->len >>  8;
553             buf[4] = uid->len;
554             gcry_md_write( md, buf, 5 );
555         }
556         gcry_md_write( md, uid->name, uid->len );
557     }
558 }
559
560 static void
561 cache_sig_result ( PKT_signature *sig, int result )
562 {
563     if ( !result ) {
564         sig->flags.checked = 1;
565         sig->flags.valid = 1;
566     }
567     else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
568         sig->flags.checked = 1;
569         sig->flags.valid = 0;
570     }
571     else {
572         sig->flags.checked = 0;
573         sig->flags.valid = 0;
574     }
575 }
576
577
578 /* SIG is a key revocation signature.  Check if this signature was
579  * generated by any of the public key PK's designated revokers.
580  *
581  *   PK is the public key that SIG allegedly revokes.
582  *
583  *   SIG is the revocation signature to check.
584  *
585  * This function avoids infinite recursion, which can happen if two
586  * keys are designed revokers for each other and they revoke each
587  * other.  This is done by observing that if a key A is revoked by key
588  * B we still consider the revocation to be valid even if B is
589  * revoked.  Thus, we don't need to determine whether B is revoked to
590  * determine whether A has been revoked by B, we just need to check
591  * the signature.
592  *
593  * Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
594  * revoked.  We are careful to make sure that GPG_ERR_NO_PUBKEY is
595  * only returned when a revocation signature is from a valid
596  * revocation key designated in a revkey subpacket, but the revocation
597  * key itself isn't present.
598  *
599  * XXX: This code will need to be modified if gpg ever becomes
600  * multi-threaded.  Note that this guarantees that a designated
601  * revocation sig will never be considered valid unless it is actually
602  * valid, as well as being issued by a revocation key in a valid
603  * direct signature.  Note also that this is written so that a revoked
604  * revoker can still issue revocations: i.e. If A revokes B, but A is
605  * revoked, B is still revoked.  I'm not completely convinced this is
606  * the proper behavior, but it matches how PGP does it. -dms */
607 int
608 check_revocation_keys (ctrl_t ctrl, PKT_public_key *pk, PKT_signature *sig)
609 {
610   static int busy=0;
611   int i;
612   int rc = GPG_ERR_GENERAL;
613
614   log_assert (IS_KEY_REV(sig));
615   log_assert ((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
616
617   /* Avoid infinite recursion.  Consider the following:
618    *
619    *   - We want to check if A is revoked.
620    *
621    *   - C is a designated revoker for B and has revoked B.
622    *
623    *   - B is a designated revoker for A and has revoked A.
624    *
625    * When checking if A is revoked (in merge_selfsigs_main), we
626    * observe that A has a designed revoker.  As such, we call this
627    * function.  This function sees that there is a valid revocation
628    * signature, which is signed by B.  It then calls check_signature()
629    * to verify that the signature is good.  To check the sig, we need
630    * to lookup B.  Looking up B means calling merge_selfsigs_main,
631    * which checks whether B is revoked, which calls this function to
632    * see if B was revoked by some key.
633    *
634    * In this case, the added level of indirection doesn't hurt.  It
635    * just means a bit more work.  However, if C == A, then we'd end up
636    * in a loop.  But, it doesn't make sense to look up C anyways: even
637    * if B is revoked, we conservatively consider a valid revocation
638    * signed by B to revoke A.  Since this is the only place where this
639    * type of recursion can occur, we simply cause this function to
640    * fail if it is entered recursively.  */
641   if (busy)
642     {
643       /* Return an error (i.e. not revoked), but mark the pk as
644          uncacheable as we don't really know its revocation status
645          until it is checked directly.  */
646       pk->flags.dont_cache = 1;
647       return rc;
648     }
649
650   busy=1;
651
652   /*  es_printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
653       (ulong)sig->keyid[1]); */
654
655   /* is the issuer of the sig one of our revokers? */
656   if( !pk->revkey && pk->numrevkeys )
657      BUG();
658   else
659       for(i=0;i<pk->numrevkeys;i++)
660         {
661           /* The revoker's keyid.  */
662           u32 keyid[2];
663
664           keyid_from_fingerprint (ctrl, pk->revkey[i].fpr,
665                                   MAX_FINGERPRINT_LEN, keyid);
666
667           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
668             /* The signature was generated by a designated revoker.
669                Verify the signature.  */
670             {
671               gcry_md_hd_t md;
672
673               if (gcry_md_open (&md, sig->digest_algo, 0))
674                 BUG ();
675               hash_public_key(md,pk);
676               /* Note: check_signature only checks that the signature
677                  is good.  It does not fail if the key is revoked.  */
678               rc = check_signature (ctrl, sig, md);
679               cache_sig_result(sig,rc);
680               gcry_md_close (md);
681               break;
682             }
683         }
684
685   busy=0;
686
687   return rc;
688 }
689
690 /* Check that the backsig BACKSIG from the subkey SUB_PK to its
691    primary key MAIN_PK is valid.
692
693    Backsigs (0x19) have the same format as binding sigs (0x18), but
694    this function is simpler than check_key_signature in a few ways.
695    For example, there is no support for expiring backsigs since it is
696    questionable what such a thing actually means.  Note also that the
697    sig cache check here, unlike other sig caches in GnuPG, is not
698    persistent. */
699 int
700 check_backsig (PKT_public_key *main_pk,PKT_public_key *sub_pk,
701                PKT_signature *backsig)
702 {
703   gcry_md_hd_t md;
704   int rc;
705
706   /* Always check whether the algorithm is available.  Although
707      gcry_md_open would throw an error, some libgcrypt versions will
708      print a debug message in that case too. */
709   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
710     return rc;
711
712   if(!opt.no_sig_cache && backsig->flags.checked)
713     return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
714
715   rc = gcry_md_open (&md, backsig->digest_algo,0);
716   if (!rc)
717     {
718       hash_public_key(md,main_pk);
719       hash_public_key(md,sub_pk);
720       rc = check_signature_end (sub_pk, backsig, md, NULL, NULL, NULL);
721       cache_sig_result(backsig,rc);
722       gcry_md_close(md);
723     }
724
725   return rc;
726 }
727
728
729 /* Check that a signature over a key is valid.  This is a
730  * specialization of check_key_signature2 with the unnamed parameters
731  * passed as NULL.  See the documentation for that function for more
732  * details.  */
733 int
734 check_key_signature (ctrl_t ctrl, kbnode_t root, kbnode_t node,
735                      int *is_selfsig)
736 {
737   return check_key_signature2 (ctrl, root, node, NULL, NULL,
738                                is_selfsig, NULL, NULL);
739 }
740
741
742 /* Returns whether SIGNER generated the signature SIG over the packet
743    PACKET, which is a key, subkey or uid, and comes from the key block
744    KB.  (KB is PACKET's corresponding keyblock; we don't assume that
745    SIG has been added to the keyblock.)
746
747    If SIGNER is set, then checks whether SIGNER generated the
748    signature.  Otherwise, uses SIG->KEYID to find the alleged signer.
749    This parameter can be used to effectively override the alleged
750    signer that is stored in SIG.
751
752    KB may be NULL if SIGNER is set.
753
754    Unlike check_key_signature, this function ignores any cached
755    results!  That is, it does not consider SIG->FLAGS.CHECKED and
756    SIG->FLAGS.VALID nor does it set them.
757
758    This doesn't check the signature's semantic mean.  Concretely, it
759    doesn't check whether a non-self signed revocation signature was
760    created by a designated revoker.  In fact, it doesn't return an
761    error for a binding generated by a completely different key!
762
763    Returns 0 if the signature is valid.  Returns GPG_ERR_SIG_CLASS if
764    this signature can't be over PACKET.  Returns GPG_ERR_NOT_FOUND if
765    the key that generated the signature (according to SIG) could not
766    be found.  Returns GPG_ERR_BAD_SIGNATURE if the signature is bad.
767    Other errors codes may be returned if something else goes wrong.
768
769    IF IS_SELFSIG is not NULL, sets *IS_SELFSIG to 1 if this is a
770    self-signature (by the key's primary key) or 0 if not.
771
772    If RET_PK is not NULL, returns a copy of the public key that
773    generated the signature (i.e., the signer) on success.  This must
774    be released by the caller using release_public_key_parts ().  */
775 gpg_error_t
776 check_signature_over_key_or_uid (ctrl_t ctrl, PKT_public_key *signer,
777                                  PKT_signature *sig, KBNODE kb, PACKET *packet,
778                                  int *is_selfsig, PKT_public_key *ret_pk)
779 {
780   int rc;
781   PKT_public_key *pripk = kb->pkt->pkt.public_key;
782   gcry_md_hd_t md;
783   int signer_alloced = 0;
784
785   rc = openpgp_pk_test_algo (sig->pubkey_algo);
786   if (rc)
787     return rc;
788   rc = openpgp_md_test_algo (sig->digest_algo);
789   if (rc)
790     return rc;
791
792   /* A signature's class indicates the type of packet that it
793      signs.  */
794   if (/* Primary key binding (made by a subkey).  */
795       sig->sig_class == 0x19
796       /* Direct key signature.  */
797       || sig->sig_class == 0x1f
798       /* Primary key revocation.  */
799       || sig->sig_class == 0x20)
800     {
801       if (packet->pkttype != PKT_PUBLIC_KEY)
802         /* Key revocations can only be over primary keys.  */
803         return gpg_error (GPG_ERR_SIG_CLASS);
804     }
805   else if (/* Subkey binding.  */
806            sig->sig_class == 0x18
807            /* Subkey revocation.  */
808            || sig->sig_class == 0x28)
809     {
810       if (packet->pkttype != PKT_PUBLIC_SUBKEY)
811         return gpg_error (GPG_ERR_SIG_CLASS);
812     }
813   else if (/* Certification.  */
814            sig->sig_class == 0x10
815            || sig->sig_class == 0x11
816            || sig->sig_class == 0x12
817            || sig->sig_class == 0x13
818            /* Certification revocation.  */
819            || sig->sig_class == 0x30)
820     {
821       if (packet->pkttype != PKT_USER_ID)
822         return gpg_error (GPG_ERR_SIG_CLASS);
823     }
824   else
825     return gpg_error (GPG_ERR_SIG_CLASS);
826
827   /* PACKET is the right type for SIG.  */
828
829   if (signer)
830     {
831       if (is_selfsig)
832         {
833           if (signer->keyid[0] == pripk->keyid[0]
834               && signer->keyid[1] == pripk->keyid[1])
835             *is_selfsig = 1;
836           else
837             *is_selfsig = 0;
838         }
839     }
840   else
841     {
842       /* Get the signer.  If possible, avoid a look up.  */
843       if (sig->keyid[0] == pripk->keyid[0]
844           && sig->keyid[1] == pripk->keyid[1])
845         /* Issued by the primary key.  */
846         {
847           signer = pripk;
848           if (is_selfsig)
849             *is_selfsig = 1;
850         }
851       else
852         {
853           kbnode_t ctx = NULL;
854           kbnode_t n;
855
856           /* See if one of the subkeys was the signer (although this
857              is extremely unlikely).  */
858           while ((n = walk_kbnode (kb, &ctx, 0)))
859             {
860               PKT_public_key *subk;
861
862               if (n->pkt->pkttype != PKT_PUBLIC_SUBKEY)
863                 continue;
864
865               subk = n->pkt->pkt.public_key;
866               if (sig->keyid[0] == subk->keyid[0]
867                   && sig->keyid[1] == subk->keyid[1])
868                 /* Issued by a subkey.  */
869                 {
870                   signer = subk;
871                   break;
872                 }
873             }
874
875           if (! signer)
876             /* Signer by some other key.  */
877             {
878               if (is_selfsig)
879                 *is_selfsig = 0;
880               if (ret_pk)
881                 {
882                   signer = ret_pk;
883                   memset (signer, 0, sizeof (*signer));
884                   signer_alloced = 1;
885                 }
886               else
887                 {
888                   signer = xmalloc_clear (sizeof (*signer));
889                   signer_alloced = 2;
890                 }
891
892               rc = get_pubkey (ctrl, signer, sig->keyid);
893               if (rc)
894                 {
895                   xfree (signer);
896                   signer = NULL;
897                   signer_alloced = 0;
898                   goto out;
899                 }
900             }
901         }
902     }
903
904   /* We checked above that we supported this algo, so an error here is
905      a bug.  */
906   if (gcry_md_open (&md, sig->digest_algo, 0))
907     BUG ();
908
909   /* Hash the relevant data.  */
910
911   if (/* Direct key signature.  */
912       sig->sig_class == 0x1f
913       /* Primary key revocation.  */
914       || sig->sig_class == 0x20)
915     {
916       log_assert (packet->pkttype == PKT_PUBLIC_KEY);
917       hash_public_key (md, packet->pkt.public_key);
918       rc = check_signature_end_simple (signer, sig, md);
919     }
920   else if (/* Primary key binding (made by a subkey).  */
921       sig->sig_class == 0x19)
922     {
923       log_assert (packet->pkttype == PKT_PUBLIC_KEY);
924       hash_public_key (md, packet->pkt.public_key);
925       hash_public_key (md, signer);
926       rc = check_signature_end_simple (signer, sig, md);
927     }
928   else if (/* Subkey binding.  */
929            sig->sig_class == 0x18
930            /* Subkey revocation.  */
931            || sig->sig_class == 0x28)
932     {
933       log_assert (packet->pkttype == PKT_PUBLIC_SUBKEY);
934       hash_public_key (md, pripk);
935       hash_public_key (md, packet->pkt.public_key);
936       rc = check_signature_end_simple (signer, sig, md);
937     }
938   else if (/* Certification.  */
939            sig->sig_class == 0x10
940            || sig->sig_class == 0x11
941            || sig->sig_class == 0x12
942            || sig->sig_class == 0x13
943            /* Certification revocation.  */
944            || sig->sig_class == 0x30)
945     {
946       log_assert (packet->pkttype == PKT_USER_ID);
947       hash_public_key (md, pripk);
948       hash_uid_packet (packet->pkt.user_id, md, sig);
949       rc = check_signature_end_simple (signer, sig, md);
950     }
951   else
952     /* We should never get here.  (The first if above should have
953        already caught this error.)  */
954     BUG ();
955
956   gcry_md_close (md);
957
958  out:
959   if (! rc && ret_pk && (signer_alloced == -1 || ret_pk != signer))
960     copy_public_key (ret_pk, signer);
961   if (signer_alloced == 1)
962     /* We looked up SIGNER; it is not a pointer into KB.  */
963     {
964       release_public_key_parts (signer);
965       if (signer_alloced == 2)
966         /* We also allocated the memory.  */
967         xfree (signer);
968     }
969
970   return rc;
971 }
972
973 /* Check that a signature over a key (e.g., a key revocation, key
974  * binding, user id certification, etc.) is valid.  If the function
975  * detects a self-signature, it uses the public key from the specified
976  * key block and does not bother looking up the key specified in the
977  * signature packet.
978  *
979  * ROOT is a keyblock.
980  *
981  * NODE references a signature packet that appears in the keyblock
982  * that should be verified.
983  *
984  * If CHECK_PK is set, the specified key is sometimes preferred for
985  * verifying signatures.  See the implementation for details.
986  *
987  * If RET_PK is not NULL, the public key that successfully verified
988  * the signature is copied into *RET_PK.
989  *
990  * If IS_SELFSIG is not NULL, *IS_SELFSIG is set to 1 if NODE is a
991  * self-signature.
992  *
993  * If R_EXPIREDATE is not NULL, *R_EXPIREDATE is set to the expiry
994  * date.
995  *
996  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has been
997  * expired (0 otherwise).  Note: PK being revoked does not cause this
998  * function to fail.
999  *
1000  *
1001  * If OPT.NO_SIG_CACHE is not set, this function will first check if
1002  * the result of a previous verification is already cached in the
1003  * signature packet's data structure.
1004  *
1005  * TODO: add r_revoked here as well.  It has the same problems as
1006  * r_expiredate and r_expired and the cache.  */
1007 int
1008 check_key_signature2 (ctrl_t ctrl,
1009                       kbnode_t root, kbnode_t node, PKT_public_key *check_pk,
1010                       PKT_public_key *ret_pk, int *is_selfsig,
1011                       u32 *r_expiredate, int *r_expired )
1012 {
1013   PKT_public_key *pk;
1014   PKT_signature *sig;
1015   int algo;
1016   int rc;
1017
1018   if (is_selfsig)
1019     *is_selfsig = 0;
1020   if (r_expiredate)
1021     *r_expiredate = 0;
1022   if (r_expired)
1023     *r_expired = 0;
1024   log_assert (node->pkt->pkttype == PKT_SIGNATURE);
1025   log_assert (root->pkt->pkttype == PKT_PUBLIC_KEY);
1026
1027   pk = root->pkt->pkt.public_key;
1028   sig = node->pkt->pkt.signature;
1029   algo = sig->digest_algo;
1030
1031   /* Check whether we have cached the result of a previous signature
1032      check.  Note that we may no longer have the pubkey or hash
1033      needed to verify a sig, but can still use the cached value.  A
1034      cache refresh detects and clears these cases. */
1035   if ( !opt.no_sig_cache )
1036     {
1037       cache_stats.total++;
1038       if (sig->flags.checked) /* Cached status available.  */
1039         {
1040           cache_stats.cached++;
1041           if (is_selfsig)
1042             {
1043               u32 keyid[2];
1044
1045               keyid_from_pk (pk, keyid);
1046               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
1047                 *is_selfsig = 1;
1048             }
1049           /* BUG: This is wrong for non-self-sigs... needs to be the
1050              actual pk.  */
1051           rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
1052           if (rc)
1053             return rc;
1054           if (sig->flags.valid)
1055             {
1056               cache_stats.goodsig++;
1057               return 0;
1058             }
1059           cache_stats.badsig++;
1060           return gpg_error (GPG_ERR_BAD_SIGNATURE);
1061         }
1062     }
1063
1064   rc = openpgp_pk_test_algo(sig->pubkey_algo);
1065   if (rc)
1066     return rc;
1067   rc = openpgp_md_test_algo(algo);
1068   if (rc)
1069     return rc;
1070
1071   if (sig->sig_class == 0x20) /* key revocation */
1072     {
1073       u32 keyid[2];
1074       keyid_from_pk( pk, keyid );
1075
1076       /* Is it a designated revoker? */
1077       if (keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1])
1078         rc = check_revocation_keys (ctrl, pk, sig);
1079       else
1080         {
1081           rc = check_signature_metadata_validity (pk, sig,
1082                                                   r_expired, NULL);
1083           if (! rc)
1084             rc = check_signature_over_key_or_uid (ctrl, pk, sig,
1085                                                   root, root->pkt,
1086                                                   is_selfsig, ret_pk);
1087         }
1088     }
1089   else if (sig->sig_class == 0x28  /* subkey revocation */
1090            || sig->sig_class == 0x18) /* key binding */
1091     {
1092       kbnode_t snode = find_prev_kbnode (root, node, PKT_PUBLIC_SUBKEY);
1093
1094       if (snode)
1095         {
1096           rc = check_signature_metadata_validity (pk, sig,
1097                                                   r_expired, NULL);
1098           if (! rc)
1099             /* 0x28 must be a self-sig, but 0x18 needn't be.  */
1100             rc = check_signature_over_key_or_uid (ctrl,
1101                                                   sig->sig_class == 0x18
1102                                                   ? NULL : pk,
1103                                                   sig, root, snode->pkt,
1104                                                   is_selfsig, ret_pk);
1105         }
1106       else
1107         {
1108           if (opt.verbose)
1109             {
1110               if (sig->sig_class == 0x28)
1111                 log_info (_("key %s: no subkey for subkey"
1112                             " revocation signature\n"), keystr_from_pk(pk));
1113               else if (sig->sig_class == 0x18)
1114                 log_info(_("key %s: no subkey for subkey"
1115                            " binding signature\n"), keystr_from_pk(pk));
1116             }
1117           rc = GPG_ERR_SIG_CLASS;
1118         }
1119     }
1120     else if (sig->sig_class == 0x1f) /* direct key signature */
1121       {
1122         rc = check_signature_metadata_validity (pk, sig,
1123                                                 r_expired, NULL);
1124         if (! rc)
1125           rc = check_signature_over_key_or_uid (ctrl, pk, sig, root, root->pkt,
1126                                                 is_selfsig, ret_pk);
1127       }
1128     else if (/* Certification.  */
1129              sig->sig_class == 0x10
1130              || sig->sig_class == 0x11
1131              || sig->sig_class == 0x12
1132              || sig->sig_class == 0x13
1133              /* Certification revocation.  */
1134              || sig->sig_class == 0x30)
1135       {
1136         kbnode_t unode = find_prev_kbnode (root, node, PKT_USER_ID);
1137
1138         if (unode)
1139           {
1140             rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
1141             if (! rc)
1142               /* If this is a self-sig, ignore check_pk.  */
1143               rc = check_signature_over_key_or_uid
1144                 (ctrl,
1145                  keyid_cmp (pk_keyid (pk), sig->keyid) == 0 ? pk : check_pk,
1146                  sig, root, unode->pkt, NULL, ret_pk);
1147           }
1148         else
1149           {
1150             if (!opt.quiet)
1151               log_info ("key %s: no user ID for key signature packet"
1152                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
1153             rc = GPG_ERR_SIG_CLASS;
1154           }
1155       }
1156   else
1157     {
1158       log_info ("sig issued by %s with class %d (digest: %02x %02x)"
1159                 " is not valid over a user id or a key id, ignoring.\n",
1160                 keystr (sig->keyid), sig->sig_class,
1161                 sig->digest_start[0], sig->digest_start[1]);
1162       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
1163     }
1164
1165   cache_sig_result  (sig, rc);
1166
1167   return rc;
1168 }