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