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