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