gpg: Let --debug clock time sign and verify.
[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     if (DBG_CLOCK && sig->sig_class <= 0x01)
514       log_clock ("enter pk_verify");
515     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
516     if (DBG_CLOCK && sig->sig_class <= 0x01)
517       log_clock ("leave pk_verify");
518     gcry_mpi_release (result);
519
520     if( !rc && sig->flags.unknown_critical )
521       {
522         log_info(_("assuming bad signature from key %s"
523                    " due to an unknown critical bit\n"),keystr_from_pk(pk));
524         rc = GPG_ERR_BAD_SIGNATURE;
525       }
526
527     return rc;
528 }
529
530
531 /* Add a uid node to a hash context.  See section 5.2.4, paragraph 4
532    of RFC 4880.  */
533 static void
534 hash_uid_packet (PKT_user_id *uid, gcry_md_hd_t md, PKT_signature *sig )
535 {
536     if( uid->attrib_data ) {
537         if( sig->version >=4 ) {
538             byte buf[5];
539             buf[0] = 0xd1;                   /* packet of type 17 */
540             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
541             buf[2] = uid->attrib_len >> 16;
542             buf[3] = uid->attrib_len >>  8;
543             buf[4] = uid->attrib_len;
544             gcry_md_write( md, buf, 5 );
545         }
546         gcry_md_write( md, uid->attrib_data, uid->attrib_len );
547     }
548     else {
549         if( sig->version >=4 ) {
550             byte buf[5];
551             buf[0] = 0xb4;            /* indicates a userid packet */
552             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
553             buf[2] = uid->len >> 16;
554             buf[3] = uid->len >>  8;
555             buf[4] = uid->len;
556             gcry_md_write( md, buf, 5 );
557         }
558         gcry_md_write( md, uid->name, uid->len );
559     }
560 }
561
562 static void
563 cache_sig_result ( PKT_signature *sig, int result )
564 {
565     if ( !result ) {
566         sig->flags.checked = 1;
567         sig->flags.valid = 1;
568     }
569     else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
570         sig->flags.checked = 1;
571         sig->flags.valid = 0;
572     }
573     else {
574         sig->flags.checked = 0;
575         sig->flags.valid = 0;
576     }
577 }
578
579
580 /* SIG is a key revocation signature.  Check if this signature was
581  * generated by any of the public key PK's designated revokers.
582  *
583  *   PK is the public key that SIG allegedly revokes.
584  *
585  *   SIG is the revocation signature to check.
586  *
587  * This function avoids infinite recursion, which can happen if two
588  * keys are designed revokers for each other and they revoke each
589  * other.  This is done by observing that if a key A is revoked by key
590  * B we still consider the revocation to be valid even if B is
591  * revoked.  Thus, we don't need to determine whether B is revoked to
592  * determine whether A has been revoked by B, we just need to check
593  * the signature.
594  *
595  * Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
596  * revoked.  We are careful to make sure that GPG_ERR_NO_PUBKEY is
597  * only returned when a revocation signature is from a valid
598  * revocation key designated in a revkey subpacket, but the revocation
599  * key itself isn't present.
600  *
601  * XXX: This code will need to be modified if gpg ever becomes
602  * multi-threaded.  Note that this guarantees that a designated
603  * revocation sig will never be considered valid unless it is actually
604  * valid, as well as being issued by a revocation key in a valid
605  * direct signature.  Note also that this is written so that a revoked
606  * revoker can still issue revocations: i.e. If A revokes B, but A is
607  * revoked, B is still revoked.  I'm not completely convinced this is
608  * the proper behavior, but it matches how PGP does it. -dms */
609 int
610 check_revocation_keys (ctrl_t ctrl, PKT_public_key *pk, PKT_signature *sig)
611 {
612   static int busy=0;
613   int i;
614   int rc = GPG_ERR_GENERAL;
615
616   log_assert (IS_KEY_REV(sig));
617   log_assert ((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
618
619   /* Avoid infinite recursion.  Consider the following:
620    *
621    *   - We want to check if A is revoked.
622    *
623    *   - C is a designated revoker for B and has revoked B.
624    *
625    *   - B is a designated revoker for A and has revoked A.
626    *
627    * When checking if A is revoked (in merge_selfsigs_main), we
628    * observe that A has a designed revoker.  As such, we call this
629    * function.  This function sees that there is a valid revocation
630    * signature, which is signed by B.  It then calls check_signature()
631    * to verify that the signature is good.  To check the sig, we need
632    * to lookup B.  Looking up B means calling merge_selfsigs_main,
633    * which checks whether B is revoked, which calls this function to
634    * see if B was revoked by some key.
635    *
636    * In this case, the added level of indirection doesn't hurt.  It
637    * just means a bit more work.  However, if C == A, then we'd end up
638    * in a loop.  But, it doesn't make sense to look up C anyways: even
639    * if B is revoked, we conservatively consider a valid revocation
640    * signed by B to revoke A.  Since this is the only place where this
641    * type of recursion can occur, we simply cause this function to
642    * fail if it is entered recursively.  */
643   if (busy)
644     {
645       /* Return an error (i.e. not revoked), but mark the pk as
646          uncacheable as we don't really know its revocation status
647          until it is checked directly.  */
648       pk->flags.dont_cache = 1;
649       return rc;
650     }
651
652   busy=1;
653
654   /*  es_printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
655       (ulong)sig->keyid[1]); */
656
657   /* is the issuer of the sig one of our revokers? */
658   if( !pk->revkey && pk->numrevkeys )
659      BUG();
660   else
661       for(i=0;i<pk->numrevkeys;i++)
662         {
663           /* The revoker's keyid.  */
664           u32 keyid[2];
665
666           keyid_from_fingerprint (ctrl, pk->revkey[i].fpr,
667                                   MAX_FINGERPRINT_LEN, keyid);
668
669           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
670             /* The signature was generated by a designated revoker.
671                Verify the signature.  */
672             {
673               gcry_md_hd_t md;
674
675               if (gcry_md_open (&md, sig->digest_algo, 0))
676                 BUG ();
677               hash_public_key(md,pk);
678               /* Note: check_signature only checks that the signature
679                  is good.  It does not fail if the key is revoked.  */
680               rc = check_signature (ctrl, sig, md);
681               cache_sig_result(sig,rc);
682               gcry_md_close (md);
683               break;
684             }
685         }
686
687   busy=0;
688
689   return rc;
690 }
691
692 /* Check that the backsig BACKSIG from the subkey SUB_PK to its
693    primary key MAIN_PK is valid.
694
695    Backsigs (0x19) have the same format as binding sigs (0x18), but
696    this function is simpler than check_key_signature in a few ways.
697    For example, there is no support for expiring backsigs since it is
698    questionable what such a thing actually means.  Note also that the
699    sig cache check here, unlike other sig caches in GnuPG, is not
700    persistent. */
701 int
702 check_backsig (PKT_public_key *main_pk,PKT_public_key *sub_pk,
703                PKT_signature *backsig)
704 {
705   gcry_md_hd_t md;
706   int rc;
707
708   /* Always check whether the algorithm is available.  Although
709      gcry_md_open would throw an error, some libgcrypt versions will
710      print a debug message in that case too. */
711   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
712     return rc;
713
714   if(!opt.no_sig_cache && backsig->flags.checked)
715     return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
716
717   rc = gcry_md_open (&md, backsig->digest_algo,0);
718   if (!rc)
719     {
720       hash_public_key(md,main_pk);
721       hash_public_key(md,sub_pk);
722       rc = check_signature_end (sub_pk, backsig, md, NULL, NULL, NULL);
723       cache_sig_result(backsig,rc);
724       gcry_md_close(md);
725     }
726
727   return rc;
728 }
729
730
731 /* Check that a signature over a key is valid.  This is a
732  * specialization of check_key_signature2 with the unnamed parameters
733  * passed as NULL.  See the documentation for that function for more
734  * details.  */
735 int
736 check_key_signature (ctrl_t ctrl, kbnode_t root, kbnode_t node,
737                      int *is_selfsig)
738 {
739   return check_key_signature2 (ctrl, root, node, NULL, NULL,
740                                is_selfsig, NULL, NULL);
741 }
742
743
744 /* Returns whether SIGNER generated the signature SIG over the packet
745  * PACKET, which is a key, subkey or uid, and comes from the key block
746  * KB.  (KB is PACKET's corresponding keyblock; we don't assume that
747  * SIG has been added to the keyblock.)
748  *
749  * If SIGNER is set, then checks whether SIGNER generated the
750  * signature.  Otherwise, uses SIG->KEYID to find the alleged signer.
751  * This parameter can be used to effectively override the alleged
752  * signer that is stored in SIG.
753  *
754  * KB may be NULL if SIGNER is set.
755  *
756  * Unlike check_key_signature, this function ignores any cached
757  * results!  That is, it does not consider SIG->FLAGS.CHECKED and
758  * SIG->FLAGS.VALID nor does it set them.
759  *
760  * This doesn't check the signature's semantic mean.  Concretely, it
761  * doesn't check whether a non-self signed revocation signature was
762  * created by a designated revoker.  In fact, it doesn't return an
763  * error for a binding generated by a completely different key!
764  *
765  * Returns 0 if the signature is valid.  Returns GPG_ERR_SIG_CLASS if
766  * this signature can't be over PACKET.  Returns GPG_ERR_NOT_FOUND if
767  * the key that generated the signature (according to SIG) could not
768  * be found.  Returns GPG_ERR_BAD_SIGNATURE if the signature is bad.
769  * Other errors codes may be returned if something else goes wrong.
770  *
771  * IF IS_SELFSIG is not NULL, sets *IS_SELFSIG to 1 if this is a
772  * self-signature (by the key's primary key) or 0 if not.
773  *
774  * If RET_PK is not NULL, returns a copy of the public key that
775  * generated the signature (i.e., the signer) on success.  This must
776  * be released by the caller using release_public_key_parts ().  */
777 gpg_error_t
778 check_signature_over_key_or_uid (ctrl_t ctrl, PKT_public_key *signer,
779                                  PKT_signature *sig, KBNODE kb, PACKET *packet,
780                                  int *is_selfsig, PKT_public_key *ret_pk)
781 {
782   int rc;
783   PKT_public_key *pripk = kb->pkt->pkt.public_key;
784   gcry_md_hd_t md;
785   int signer_alloced = 0;
786
787   rc = openpgp_pk_test_algo (sig->pubkey_algo);
788   if (rc)
789     return rc;
790   rc = openpgp_md_test_algo (sig->digest_algo);
791   if (rc)
792     return rc;
793
794   /* A signature's class indicates the type of packet that it
795      signs.  */
796   if (/* Primary key binding (made by a subkey).  */
797       sig->sig_class == 0x19
798       /* Direct key signature.  */
799       || sig->sig_class == 0x1f
800       /* Primary key revocation.  */
801       || sig->sig_class == 0x20)
802     {
803       /* Key revocations can only be over primary keys.  */
804       if (packet->pkttype != PKT_PUBLIC_KEY)
805         return gpg_error (GPG_ERR_SIG_CLASS);
806     }
807   else if (/* Subkey binding.  */
808            sig->sig_class == 0x18
809            /* Subkey revocation.  */
810            || sig->sig_class == 0x28)
811     {
812       if (packet->pkttype != PKT_PUBLIC_SUBKEY)
813         return gpg_error (GPG_ERR_SIG_CLASS);
814     }
815   else if (/* Certification.  */
816            sig->sig_class == 0x10
817            || sig->sig_class == 0x11
818            || sig->sig_class == 0x12
819            || sig->sig_class == 0x13
820            /* Certification revocation.  */
821            || sig->sig_class == 0x30)
822     {
823       if (packet->pkttype != PKT_USER_ID)
824         return gpg_error (GPG_ERR_SIG_CLASS);
825     }
826   else
827     return gpg_error (GPG_ERR_SIG_CLASS);
828
829   /* PACKET is the right type for SIG.  */
830
831   if (signer)
832     {
833       if (is_selfsig)
834         {
835           if (signer->keyid[0] == pripk->keyid[0]
836               && signer->keyid[1] == pripk->keyid[1])
837             *is_selfsig = 1;
838           else
839             *is_selfsig = 0;
840         }
841     }
842   else
843     {
844       /* Get the signer.  If possible, avoid a look up.  */
845       if (sig->keyid[0] == pripk->keyid[0]
846           && sig->keyid[1] == pripk->keyid[1])
847         {
848           /* Issued by the primary key.  */
849           signer = pripk;
850           if (is_selfsig)
851             *is_selfsig = 1;
852         }
853       else
854         {
855           /* See if one of the subkeys was the signer (although this
856              is extremely unlikely).  */
857           kbnode_t ctx = NULL;
858           kbnode_t n;
859
860           while ((n = walk_kbnode (kb, &ctx, 0)))
861             {
862               PKT_public_key *subk;
863
864               if (n->pkt->pkttype != PKT_PUBLIC_SUBKEY)
865                 continue;
866
867               subk = n->pkt->pkt.public_key;
868               if (sig->keyid[0] == subk->keyid[0]
869                   && sig->keyid[1] == subk->keyid[1])
870                 {
871                   /* Issued by a subkey.  */
872                   signer = subk;
873                   break;
874                 }
875             }
876
877           if (! signer)
878             {
879               /* Signer by some other key.  */
880               if (is_selfsig)
881                 *is_selfsig = 0;
882               if (ret_pk)
883                 {
884                   signer = ret_pk;
885                   /* FIXME: Using memset here is probematic because it
886                    * assumes that there are no allocated fields in
887                    * SIGNER.  */
888                   memset (signer, 0, sizeof (*signer));
889                   signer_alloced = 1;
890                 }
891               else
892                 {
893                   signer = xmalloc_clear (sizeof (*signer));
894                   signer_alloced = 2;
895                 }
896
897               rc = get_pubkey (ctrl, signer, sig->keyid);
898               if (rc)
899                 {
900                   xfree (signer);
901                   signer = NULL;
902                   signer_alloced = 0;
903                   goto leave;
904                 }
905             }
906         }
907     }
908
909   /* We checked above that we supported this algo, so an error here is
910    * a bug.  */
911   if (gcry_md_open (&md, sig->digest_algo, 0))
912     BUG ();
913
914   /* Hash the relevant data.  */
915
916   if (/* Direct key signature.  */
917       sig->sig_class == 0x1f
918       /* Primary key revocation.  */
919       || sig->sig_class == 0x20)
920     {
921       log_assert (packet->pkttype == PKT_PUBLIC_KEY);
922       hash_public_key (md, packet->pkt.public_key);
923       rc = check_signature_end_simple (signer, sig, md);
924     }
925   else if (/* Primary key binding (made by a subkey).  */
926            sig->sig_class == 0x19)
927     {
928       log_assert (packet->pkttype == PKT_PUBLIC_KEY);
929       hash_public_key (md, packet->pkt.public_key);
930       hash_public_key (md, signer);
931       rc = check_signature_end_simple (signer, sig, md);
932     }
933   else if (/* Subkey binding.  */
934            sig->sig_class == 0x18
935            /* Subkey revocation.  */
936            || sig->sig_class == 0x28)
937     {
938       log_assert (packet->pkttype == PKT_PUBLIC_SUBKEY);
939       hash_public_key (md, pripk);
940       hash_public_key (md, packet->pkt.public_key);
941       rc = check_signature_end_simple (signer, sig, md);
942     }
943   else if (/* Certification.  */
944            sig->sig_class == 0x10
945            || sig->sig_class == 0x11
946            || sig->sig_class == 0x12
947            || sig->sig_class == 0x13
948            /* Certification revocation.  */
949            || sig->sig_class == 0x30)
950     {
951       log_assert (packet->pkttype == PKT_USER_ID);
952       hash_public_key (md, pripk);
953       hash_uid_packet (packet->pkt.user_id, md, sig);
954       rc = check_signature_end_simple (signer, sig, md);
955     }
956   else
957     {
958       /* We should never get here.  (The first if above should have
959        * already caught this error.)  */
960       BUG ();
961     }
962
963   gcry_md_close (md);
964
965  leave:
966   if (! rc && ret_pk && ret_pk != signer)
967     copy_public_key (ret_pk, signer);
968
969   if (signer_alloced)
970     {
971       /* We looked up SIGNER; it is not a pointer into KB.  */
972       release_public_key_parts (signer);
973       /* Free if we also allocated the memory.  */
974       if (signer_alloced == 2)
975         xfree (signer);
976     }
977
978   return rc;
979 }
980
981
982 /* Check that a signature over a key (e.g., a key revocation, key
983  * binding, user id certification, etc.) is valid.  If the function
984  * detects a self-signature, it uses the public key from the specified
985  * key block and does not bother looking up the key specified in the
986  * signature packet.
987  *
988  * ROOT is a keyblock.
989  *
990  * NODE references a signature packet that appears in the keyblock
991  * that should be verified.
992  *
993  * If CHECK_PK is set, the specified key is sometimes preferred for
994  * verifying signatures.  See the implementation for details.
995  *
996  * If RET_PK is not NULL, the public key that successfully verified
997  * the signature is copied into *RET_PK.
998  *
999  * If IS_SELFSIG is not NULL, *IS_SELFSIG is set to 1 if NODE is a
1000  * self-signature.
1001  *
1002  * If R_EXPIREDATE is not NULL, *R_EXPIREDATE is set to the expiry
1003  * date.
1004  *
1005  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has been
1006  * expired (0 otherwise).  Note: PK being revoked does not cause this
1007  * function to fail.
1008  *
1009  *
1010  * If OPT.NO_SIG_CACHE is not set, this function will first check if
1011  * the result of a previous verification is already cached in the
1012  * signature packet's data structure.
1013  *
1014  * TODO: add r_revoked here as well.  It has the same problems as
1015  * r_expiredate and r_expired and the cache.  */
1016 int
1017 check_key_signature2 (ctrl_t ctrl,
1018                       kbnode_t root, kbnode_t node, PKT_public_key *check_pk,
1019                       PKT_public_key *ret_pk, int *is_selfsig,
1020                       u32 *r_expiredate, int *r_expired )
1021 {
1022   PKT_public_key *pk;
1023   PKT_signature *sig;
1024   int algo;
1025   int rc;
1026
1027   if (is_selfsig)
1028     *is_selfsig = 0;
1029   if (r_expiredate)
1030     *r_expiredate = 0;
1031   if (r_expired)
1032     *r_expired = 0;
1033   log_assert (node->pkt->pkttype == PKT_SIGNATURE);
1034   log_assert (root->pkt->pkttype == PKT_PUBLIC_KEY);
1035
1036   pk = root->pkt->pkt.public_key;
1037   sig = node->pkt->pkt.signature;
1038   algo = sig->digest_algo;
1039
1040   /* Check whether we have cached the result of a previous signature
1041    * check.  Note that we may no longer have the pubkey or hash
1042    * needed to verify a sig, but can still use the cached value.  A
1043    * cache refresh detects and clears these cases. */
1044   if ( !opt.no_sig_cache )
1045     {
1046       cache_stats.total++;
1047       if (sig->flags.checked) /* Cached status available.  */
1048         {
1049           cache_stats.cached++;
1050           if (is_selfsig)
1051             {
1052               u32 keyid[2];
1053
1054               keyid_from_pk (pk, keyid);
1055               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
1056                 *is_selfsig = 1;
1057             }
1058           /* BUG: This is wrong for non-self-sigs... needs to be the
1059            * actual pk.  */
1060           rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
1061           if (rc)
1062             return rc;
1063           if (sig->flags.valid)
1064             {
1065               cache_stats.goodsig++;
1066               return 0;
1067             }
1068           cache_stats.badsig++;
1069           return gpg_error (GPG_ERR_BAD_SIGNATURE);
1070         }
1071     }
1072
1073   rc = openpgp_pk_test_algo(sig->pubkey_algo);
1074   if (rc)
1075     return rc;
1076   rc = openpgp_md_test_algo(algo);
1077   if (rc)
1078     return rc;
1079
1080   if (sig->sig_class == 0x20) /* key revocation */
1081     {
1082       u32 keyid[2];
1083       keyid_from_pk( pk, keyid );
1084
1085       /* Is it a designated revoker? */
1086       if (keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1])
1087         rc = check_revocation_keys (ctrl, pk, sig);
1088       else
1089         {
1090           rc = check_signature_metadata_validity (pk, sig,
1091                                                   r_expired, NULL);
1092           if (! rc)
1093             rc = check_signature_over_key_or_uid (ctrl, pk, sig,
1094                                                   root, root->pkt,
1095                                                   is_selfsig, ret_pk);
1096         }
1097     }
1098   else if (sig->sig_class == 0x28  /* subkey revocation */
1099            || sig->sig_class == 0x18) /* key binding */
1100     {
1101       kbnode_t snode = find_prev_kbnode (root, node, PKT_PUBLIC_SUBKEY);
1102
1103       if (snode)
1104         {
1105           rc = check_signature_metadata_validity (pk, sig,
1106                                                   r_expired, NULL);
1107           if (! rc)
1108             {
1109               /* 0x28 must be a self-sig, but 0x18 needn't be.  */
1110               rc = check_signature_over_key_or_uid (ctrl,
1111                                                     sig->sig_class == 0x18
1112                                                     ? NULL : pk,
1113                                                     sig, root, snode->pkt,
1114                                                     is_selfsig, ret_pk);
1115             }
1116         }
1117       else
1118         {
1119           if (opt.verbose)
1120             {
1121               if (sig->sig_class == 0x28)
1122                 log_info (_("key %s: no subkey for subkey"
1123                             " revocation signature\n"), keystr_from_pk(pk));
1124               else if (sig->sig_class == 0x18)
1125                 log_info(_("key %s: no subkey for subkey"
1126                            " binding signature\n"), keystr_from_pk(pk));
1127             }
1128           rc = GPG_ERR_SIG_CLASS;
1129         }
1130     }
1131     else if (sig->sig_class == 0x1f) /* direct key signature */
1132       {
1133         rc = check_signature_metadata_validity (pk, sig,
1134                                                 r_expired, NULL);
1135         if (! rc)
1136           rc = check_signature_over_key_or_uid (ctrl, pk, sig, root, root->pkt,
1137                                                 is_selfsig, ret_pk);
1138       }
1139     else if (/* Certification.  */
1140              sig->sig_class == 0x10
1141              || sig->sig_class == 0x11
1142              || sig->sig_class == 0x12
1143              || sig->sig_class == 0x13
1144              /* Certification revocation.  */
1145              || sig->sig_class == 0x30)
1146       {
1147         kbnode_t unode = find_prev_kbnode (root, node, PKT_USER_ID);
1148
1149         if (unode)
1150           {
1151             rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
1152             if (! rc)
1153               {
1154                 /* If this is a self-sig, ignore check_pk.  */
1155                 rc = check_signature_over_key_or_uid
1156                   (ctrl,
1157                    keyid_cmp (pk_keyid (pk), sig->keyid) == 0 ? pk : check_pk,
1158                    sig, root, unode->pkt, NULL, ret_pk);
1159               }
1160           }
1161         else
1162           {
1163             if (!opt.quiet)
1164               log_info ("key %s: no user ID for key signature packet"
1165                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
1166             rc = GPG_ERR_SIG_CLASS;
1167           }
1168       }
1169   else
1170     {
1171       log_info ("sig issued by %s with class %d (digest: %02x %02x)"
1172                 " is not valid over a user id or a key id, ignoring.\n",
1173                 keystr (sig->keyid), sig->sig_class,
1174                 sig->digest_start[0], sig->digest_start[1]);
1175       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
1176     }
1177
1178   cache_sig_result  (sig, rc);
1179
1180   return rc;
1181 }