gpg: Split the function check_signature_end.
[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 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 <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "util.h"
30 #include "packet.h"
31 #include "keydb.h"
32 #include "main.h"
33 #include "status.h"
34 #include "i18n.h"
35 #include "options.h"
36 #include "pkglue.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 /* Check a signature.  This is shorthand for check_signature2 with
47    the unnamed arguments passed as NULL.  */
48 int
49 check_signature (PKT_signature *sig, gcry_md_hd_t digest)
50 {
51     return check_signature2 (sig, digest, NULL, NULL, NULL, NULL);
52 }
53
54
55 /* Check a signature.
56  *
57  * Looks up the public key that created the signature (SIG->KEYID)
58  * from the key db.  Makes sure that the signature is valid (it was
59  * not created prior to the key, the public key was created in the
60  * past, and the signature does not include any unsupported critical
61  * features), finishes computing the hash of the signature data, and
62  * checks that the signature verifies the digest.  If the key that
63  * generated the signature is a subkey, this function also verifies
64  * that there is a valid backsig from the subkey to the primary key.
65  * Finally, if status fd is enabled and the signature class is 0x00 or
66  * 0x01, then a STATUS_SIG_ID is emitted on the status fd.
67  *
68  * SIG is the signature to check.
69  *
70  * DIGEST contains a valid hash context that already includes the
71  * signed data.  This function adds the relevant meta-data from the
72  * signature packet to compute the final hash.  (See Section 5.2 of
73  * RFC 4880: "The concatenation of the data being signed and the
74  * signature data from the version number through the hashed subpacket
75  * data (inclusive) is hashed.")
76  *
77  * If R_EXPIREDATE is not NULL, R_EXPIREDATE is set to the key's
78  * expiry.
79  *
80  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has expired
81  * (0 otherwise).  Note: PK being expired does not cause this function
82  * to fail.
83  *
84  * If R_REVOKED is not NULL, *R_REVOKED is set to 1 if PK has been
85  * revoked (0 otherwise).  Note: PK being revoked does not cause this
86  * function to fail.
87  *
88  * If PK is not NULL, the public key is saved in *PK on success.
89  *
90  * Returns 0 on success.  An error code otherwise.  */
91 int
92 check_signature2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
93                   int *r_expired, int *r_revoked, PKT_public_key *pk )
94 {
95     int rc=0;
96     int pk_internal;
97
98     if (pk)
99       pk_internal = 0;
100     else
101       {
102         pk_internal = 1;
103         pk = xmalloc_clear( sizeof *pk );
104       }
105
106     if ( (rc=openpgp_md_test_algo(sig->digest_algo)) )
107       ; /* We don't have this digest. */
108     else if ((rc=openpgp_pk_test_algo(sig->pubkey_algo)))
109       ; /* We don't have this pubkey algo. */
110     else if (!gcry_md_is_enabled (digest,sig->digest_algo))
111       {
112         /* Sanity check that the md has a context for the hash that the
113            sig is expecting.  This can happen if a onepass sig header does
114            not match the actual sig, and also if the clearsign "Hash:"
115            header is missing or does not match the actual sig. */
116
117         log_info(_("WARNING: signature digest conflict in message\n"));
118         rc = GPG_ERR_GENERAL;
119       }
120     else if( get_pubkey( pk, sig->keyid ) )
121         rc = GPG_ERR_NO_PUBKEY;
122     else if(!pk->flags.valid && !pk->flags.primary)
123       {
124         /* You cannot have a good sig from an invalid subkey.  */
125         rc = GPG_ERR_BAD_PUBKEY;
126       }
127     else
128       {
129         if(r_expiredate)
130           *r_expiredate = pk->expiredate;
131
132         rc = check_signature_end (pk, sig, digest, r_expired, r_revoked, NULL);
133
134         /* Check the backsig.  This is a 0x19 signature from the
135            subkey on the primary key.  The idea here is that it should
136            not be possible for someone to "steal" subkeys and claim
137            them as their own.  The attacker couldn't actually use the
138            subkey, but they could try and claim ownership of any
139            signatures issued by it. */
140         if(rc==0 && !pk->flags.primary && pk->flags.backsig < 2)
141           {
142             if (!pk->flags.backsig)
143               {
144                 log_info(_("WARNING: signing subkey %s is not"
145                            " cross-certified\n"),keystr_from_pk(pk));
146                 log_info(_("please see %s for more information\n"),
147                          "https://gnupg.org/faq/subkey-cross-certify.html");
148                 /* --require-cross-certification makes this warning an
149                      error.  TODO: change the default to require this
150                      after more keys have backsigs. */
151                 if(opt.flags.require_cross_cert)
152                   rc = GPG_ERR_GENERAL;
153               }
154             else if(pk->flags.backsig == 1)
155               {
156                 log_info(_("WARNING: signing subkey %s has an invalid"
157                            " cross-certification\n"),keystr_from_pk(pk));
158                 rc = GPG_ERR_GENERAL;
159               }
160           }
161       }
162
163     if (pk_internal || rc)
164       {
165         release_public_key_parts (pk);
166         if (pk_internal)
167           xfree (pk);
168         else
169           /* Be very sure that the caller doesn't try to use *PK.  */
170           memset (pk, 0, sizeof (*pk));
171       }
172
173     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
174         /* This signature id works best with DLP algorithms because
175          * they use a random parameter for every signature.  Instead of
176          * this sig-id we could have also used the hash of the document
177          * and the timestamp, but the drawback of this is, that it is
178          * not possible to sign more than one identical document within
179          * one second.  Some remote batch processing applications might
180          * like this feature here.
181          *
182          * Note that before 2.0.10, we used RIPE-MD160 for the hash
183          * and accidentally didn't include the timestamp and algorithm
184          * information in the hash.  Given that this feature is not
185          * commonly used and that a replay attacks detection should
186          * not solely be based on this feature (because it does not
187          * work with RSA), we take the freedom and switch to SHA-1
188          * with 2.0.10 to take advantage of hardware supported SHA-1
189          * implementations.  We also include the missing information
190          * in the hash.  Note also the SIG_ID as computed by gpg 1.x
191          * and gpg 2.x didn't matched either because 2.x used to print
192          * MPIs not in PGP format.  */
193         u32 a = sig->timestamp;
194         int nsig = pubkey_get_nsig( sig->pubkey_algo );
195         unsigned char *p, *buffer;
196         size_t n, nbytes;
197         int i;
198         char hashbuf[20];
199
200         nbytes = 6;
201         for (i=0; i < nsig; i++ )
202           {
203             if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &n, sig->data[i]))
204               BUG();
205             nbytes += n;
206           }
207
208         /* Make buffer large enough to be later used as output buffer.  */
209         if (nbytes < 100)
210           nbytes = 100;
211         nbytes += 10;  /* Safety margin.  */
212
213         /* Fill and hash buffer.  */
214         buffer = p = xmalloc (nbytes);
215         *p++ = sig->pubkey_algo;
216         *p++ = sig->digest_algo;
217         *p++ = (a >> 24) & 0xff;
218         *p++ = (a >> 16) & 0xff;
219         *p++ = (a >>  8) & 0xff;
220         *p++ =  a & 0xff;
221         nbytes -= 6;
222         for (i=0; i < nsig; i++ )
223           {
224             if (gcry_mpi_print (GCRYMPI_FMT_PGP, p, nbytes, &n, sig->data[i]))
225               BUG();
226             p += n;
227             nbytes -= n;
228           }
229         gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, buffer, p-buffer);
230
231         p = make_radix64_string (hashbuf, 20);
232         sprintf (buffer, "%s %s %lu",
233                  p, strtimestamp (sig->timestamp), (ulong)sig->timestamp);
234         xfree (p);
235         write_status_text (STATUS_SIG_ID, buffer);
236         xfree (buffer);
237     }
238
239     return rc;
240 }
241
242
243 /* The signature SIG was generated with the public key PK.  Check
244  * whether the signature is valid in the following sense:
245  *
246  *   - Make sure the public key was created before the signature was
247  *     generated.
248  *
249  *   - Make sure the public key was created in the past
250  *
251  *   - Check whether PK has expired (set *R_EXPIRED to 1 if so and 0
252  *     otherwise)
253  *
254  *   - Check whether PK has been revoked (set *R_REVOKED to 1 if so
255  *     and 0 otherwise).
256  *
257  * If either of the first two tests fail, returns an error code.
258  * Otherwise returns 0.  (Thus, this function doesn't fail if the
259  * public key is expired or revoked.)  */
260 static int
261 check_signature_metadata_validity (PKT_public_key *pk, PKT_signature *sig,
262                                    int *r_expired, int *r_revoked)
263 {
264     u32 cur_time;
265
266     if(r_expired)
267       *r_expired = 0;
268     if(r_revoked)
269       *r_revoked = 0;
270
271     if( pk->timestamp > sig->timestamp )
272       {
273         ulong d = pk->timestamp - sig->timestamp;
274         if ( d < 86400 )
275           {
276             log_info
277               (ngettext
278                ("public key %s is %lu second newer than the signature\n",
279                 "public key %s is %lu seconds newer than the signature\n",
280                 d), keystr_from_pk (pk), d);
281           }
282         else
283           {
284             d /= 86400;
285             log_info
286               (ngettext
287                ("public key %s is %lu day newer than the signature\n",
288                 "public key %s is %lu days newer than the signature\n",
289                 d), keystr_from_pk (pk), d);
290           }
291         if (!opt.ignore_time_conflict)
292           return GPG_ERR_TIME_CONFLICT; /* pubkey newer than signature.  */
293       }
294
295     cur_time = make_timestamp();
296     if( pk->timestamp > cur_time )
297       {
298         ulong d = pk->timestamp - cur_time;
299         if (d < 86400)
300           {
301             log_info (ngettext("key %s was created %lu second"
302                                " in the future (time warp or clock problem)\n",
303                                "key %s was created %lu seconds"
304                                " in the future (time warp or clock problem)\n",
305                                d), keystr_from_pk (pk), d);
306           }
307         else
308           {
309             d /= 86400;
310             log_info (ngettext("key %s was created %lu day"
311                                " in the future (time warp or clock problem)\n",
312                                "key %s was created %lu days"
313                                " in the future (time warp or clock problem)\n",
314                                d), keystr_from_pk (pk), d);
315           }
316         if (!opt.ignore_time_conflict)
317           return GPG_ERR_TIME_CONFLICT;
318       }
319
320     /* Check whether the key has expired.  We check the has_expired
321        flag which is set after a full evaluation of the key (getkey.c)
322        as well as a simple compare to the current time in case the
323        merge has for whatever reasons not been done.  */
324     if( pk->has_expired || (pk->expiredate && pk->expiredate < cur_time)) {
325         char buf[11];
326         if (opt.verbose)
327           log_info(_("Note: signature key %s expired %s\n"),
328                    keystr_from_pk(pk), asctimestamp( pk->expiredate ) );
329         sprintf(buf,"%lu",(ulong)pk->expiredate);
330         write_status_text(STATUS_KEYEXPIRED,buf);
331         if(r_expired)
332           *r_expired = 1;
333     }
334
335     if (pk->flags.revoked)
336       {
337         if (opt.verbose)
338           log_info (_("Note: signature key %s has been revoked\n"),
339                     keystr_from_pk(pk));
340         if (r_revoked)
341           *r_revoked=1;
342       }
343
344     return 0;
345 }
346
347
348 /* Finish generating a signature and check it.  Concretely: make sure
349  * that the signature is valid (it was not created prior to the key,
350  * the public key was created in the past, and the signature does not
351  * include any unsupported critical features), finish computing the
352  * digest by adding the relevant data from the signature packet, and
353  * check that the signature verifies the digest.
354  *
355  * DIGEST contains a hash context, which has already hashed the signed
356  * data.  This function adds the relevant meta-data from the signature
357  * packet to compute the final hash.  (See Section 5.2 of RFC 4880:
358  * "The concatenation of the data being signed and the signature data
359  * from the version number through the hashed subpacket data
360  * (inclusive) is hashed.")
361  *
362  * SIG is the signature to check.
363  *
364  * PK is the public key used to generate the signature.
365  *
366  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has expired
367  * (0 otherwise).  Note: PK being expired does not cause this function
368  * to fail.
369  *
370  * If R_REVOKED is not NULL, *R_REVOKED is set to 1 if PK has been
371  * revoked (0 otherwise).  Note: PK being revoked does not cause this
372  * function to fail.
373  *
374  * If RET_PK is not NULL, PK is copied into RET_PK on success.
375  *
376  * Returns 0 on success.  An error code other.  */
377 static int
378 check_signature_end (PKT_public_key *pk, PKT_signature *sig,
379                      gcry_md_hd_t digest,
380                      int *r_expired, int *r_revoked, PKT_public_key *ret_pk)
381 {
382     int rc = 0;
383
384     if ((rc = check_signature_metadata_validity (pk, sig,
385                                                  r_expired, r_revoked)))
386         return rc;
387
388     if ((rc = check_signature_end_simple (pk, sig, digest)))
389       return rc;
390
391     if(!rc && ret_pk)
392       copy_public_key(ret_pk,pk);
393
394     return rc;
395 }
396
397 /* This function is similar to check_signature_end, but it only checks
398    whether the signature was generated by PK.  It does not check
399    expiration, revocation, etc.  */
400 static int
401 check_signature_end_simple (PKT_public_key *pk, PKT_signature *sig,
402                             gcry_md_hd_t digest)
403 {
404     gcry_mpi_t result = NULL;
405     int rc = 0;
406     const struct weakhash *weak;
407
408     if (!opt.flags.allow_weak_digest_algos)
409       for (weak = opt.weak_digests; weak; weak = weak->next)
410         if (sig->digest_algo == weak->algo)
411           {
412             print_digest_rejected_note(sig->digest_algo);
413             return GPG_ERR_DIGEST_ALGO;
414           }
415
416     /* Make sure the digest algo is enabled (in case of a detached
417        signature).  */
418     gcry_md_enable (digest, sig->digest_algo);
419
420     /* Complete the digest. */
421     if( sig->version >= 4 )
422         gcry_md_putc( digest, sig->version );
423     gcry_md_putc( digest, sig->sig_class );
424     if( sig->version < 4 ) {
425         u32 a = sig->timestamp;
426         gcry_md_putc( digest, (a >> 24) & 0xff );
427         gcry_md_putc( digest, (a >> 16) & 0xff );
428         gcry_md_putc( digest, (a >>     8) & 0xff );
429         gcry_md_putc( digest,  a           & 0xff );
430     }
431     else {
432         byte buf[6];
433         size_t n;
434         gcry_md_putc( digest, sig->pubkey_algo );
435         gcry_md_putc( digest, sig->digest_algo );
436         if( sig->hashed ) {
437             n = sig->hashed->len;
438             gcry_md_putc (digest, (n >> 8) );
439             gcry_md_putc (digest,  n       );
440             gcry_md_write (digest, sig->hashed->data, n);
441             n += 6;
442         }
443         else {
444           /* Two octets for the (empty) length of the hashed
445              section. */
446           gcry_md_putc (digest, 0);
447           gcry_md_putc (digest, 0);
448           n = 6;
449         }
450         /* add some magic per Section 5.2.4 of RFC 4880.  */
451         buf[0] = sig->version;
452         buf[1] = 0xff;
453         buf[2] = n >> 24;
454         buf[3] = n >> 16;
455         buf[4] = n >>  8;
456         buf[5] = n;
457         gcry_md_write( digest, buf, 6 );
458     }
459     gcry_md_final( digest );
460
461     /* Convert the digest to an MPI.  */
462     result = encode_md_value (pk, digest, sig->digest_algo );
463     if (!result)
464         return GPG_ERR_GENERAL;
465
466     /* Verify the signature.  */
467     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
468     gcry_mpi_release (result);
469
470     if( !rc && sig->flags.unknown_critical )
471       {
472         log_info(_("assuming bad signature from key %s"
473                    " due to an unknown critical bit\n"),keystr_from_pk(pk));
474         rc = GPG_ERR_BAD_SIGNATURE;
475       }
476
477     return rc;
478 }
479
480
481 /* Add a uid node to a hash context.  See section 5.2.4, paragraph 4
482    of RFC 4880.  */
483 static void
484 hash_uid_node( KBNODE unode, gcry_md_hd_t md, PKT_signature *sig )
485 {
486     PKT_user_id *uid = unode->pkt->pkt.user_id;
487
488     assert( unode->pkt->pkttype == PKT_USER_ID );
489     if( uid->attrib_data ) {
490         if( sig->version >=4 ) {
491             byte buf[5];
492             buf[0] = 0xd1;                   /* packet of type 17 */
493             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
494             buf[2] = uid->attrib_len >> 16;
495             buf[3] = uid->attrib_len >>  8;
496             buf[4] = uid->attrib_len;
497             gcry_md_write( md, buf, 5 );
498         }
499         gcry_md_write( md, uid->attrib_data, uid->attrib_len );
500     }
501     else {
502         if( sig->version >=4 ) {
503             byte buf[5];
504             buf[0] = 0xb4;            /* indicates a userid packet */
505             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
506             buf[2] = uid->len >> 16;
507             buf[3] = uid->len >>  8;
508             buf[4] = uid->len;
509             gcry_md_write( md, buf, 5 );
510         }
511         gcry_md_write( md, uid->name, uid->len );
512     }
513 }
514
515 static void
516 cache_sig_result ( PKT_signature *sig, int result )
517 {
518     if ( !result ) {
519         sig->flags.checked = 1;
520         sig->flags.valid = 1;
521     }
522     else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
523         sig->flags.checked = 1;
524         sig->flags.valid = 0;
525     }
526     else {
527         sig->flags.checked = 0;
528         sig->flags.valid = 0;
529     }
530 }
531
532
533 /* SIG is a key revocation signature.  Check if this signature was
534  * generated by any of the public key PK's designated revokers.
535  *
536  *   PK is the public key that SIG allegedly revokes.
537  *
538  *   SIG is the revocation signature to check.
539  *
540  * This function avoids infinite recursion, which can happen if two
541  * keys are designed revokers for each other and they revoke each
542  * other.  This is done by observing that if a key A is revoked by key
543  * B we still consider the revocation to be valid even if B is
544  * revoked.  Thus, we don't need to determine whether B is revoked to
545  * determine whether A has been revoked by B, we just need to check
546  * the signature.
547  *
548  * Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
549  * revoked.  We are careful to make sure that GPG_ERR_NO_PUBKEY is
550  * only returned when a revocation signature is from a valid
551  * revocation key designated in a revkey subpacket, but the revocation
552  * key itself isn't present.
553  *
554  * XXX: This code will need to be modified if gpg ever becomes
555  * multi-threaded.  Note that this guarantees that a designated
556  * revocation sig will never be considered valid unless it is actually
557  * valid, as well as being issued by a revocation key in a valid
558  * direct signature.  Note also that this is written so that a revoked
559  * revoker can still issue revocations: i.e. If A revokes B, but A is
560  * revoked, B is still revoked.  I'm not completely convinced this is
561  * the proper behavior, but it matches how PGP does it. -dms */
562 int
563 check_revocation_keys (PKT_public_key *pk, PKT_signature *sig)
564 {
565   static int busy=0;
566   int i;
567   int rc = GPG_ERR_GENERAL;
568
569   assert(IS_KEY_REV(sig));
570   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
571
572   /* Avoid infinite recursion.  Consider the following:
573    *
574    *   - We want to check if A is revoked.
575    *
576    *   - C is a designated revoker for B and has revoked B.
577    *
578    *   - B is a designated revoker for A and has revoked A.
579    *
580    * When checking if A is revoked (in merge_selfsigs_main), we
581    * observe that A has a designed revoker.  As such, we call this
582    * function.  This function sees that there is a valid revocation
583    * signature, which is signed by B.  It then calls check_signature()
584    * to verify that the signature is good.  To check the sig, we need
585    * to lookup B.  Looking up B means calling merge_selfsigs_main,
586    * which checks whether B is revoked, which calls this function to
587    * see if B was revoked by some key.
588    *
589    * In this case, the added level of indirection doesn't hurt.  It
590    * just means a bit more work.  However, if C == A, then we'd end up
591    * in a loop.  But, it doesn't make sense to look up C anyways: even
592    * if B is revoked, we conservatively consider a valid revocation
593    * signed by B to revoke A.  Since this is the only place where this
594    * type of recursion can occur, we simply cause this function to
595    * fail if it is entered recursively.  */
596   if (busy)
597     {
598       /* Return an error (i.e. not revoked), but mark the pk as
599          uncacheable as we don't really know its revocation status
600          until it is checked directly.  */
601       pk->flags.dont_cache = 1;
602       return rc;
603     }
604
605   busy=1;
606
607   /*  es_printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
608       (ulong)sig->keyid[1]); */
609
610   /* is the issuer of the sig one of our revokers? */
611   if( !pk->revkey && pk->numrevkeys )
612      BUG();
613   else
614       for(i=0;i<pk->numrevkeys;i++)
615         {
616           /* The revoker's keyid.  */
617           u32 keyid[2];
618
619           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
620
621           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
622             /* The signature was generated by a designated revoker.
623                Verify the signature.  */
624             {
625               gcry_md_hd_t md;
626
627               if (gcry_md_open (&md, sig->digest_algo, 0))
628                 BUG ();
629               hash_public_key(md,pk);
630               /* Note: check_signature only checks that the signature
631                  is good.  It does not fail if the key is revoked.  */
632               rc=check_signature(sig,md);
633               cache_sig_result(sig,rc);
634               gcry_md_close (md);
635               break;
636             }
637         }
638
639   busy=0;
640
641   return rc;
642 }
643
644 /* Check that the backsig BACKSIG from the subkey SUB_PK to its
645    primary key MAIN_PK is valid.
646
647    Backsigs (0x19) have the same format as binding sigs (0x18), but
648    this function is simpler than check_key_signature in a few ways.
649    For example, there is no support for expiring backsigs since it is
650    questionable what such a thing actually means.  Note also that the
651    sig cache check here, unlike other sig caches in GnuPG, is not
652    persistent. */
653 int
654 check_backsig (PKT_public_key *main_pk,PKT_public_key *sub_pk,
655                PKT_signature *backsig)
656 {
657   gcry_md_hd_t md;
658   int rc;
659
660   /* Always check whether the algorithm is available.  Although
661      gcry_md_open would throw an error, some libgcrypt versions will
662      print a debug message in that case too. */
663   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
664     return rc;
665
666   if(!opt.no_sig_cache && backsig->flags.checked)
667     return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
668
669   rc = gcry_md_open (&md, backsig->digest_algo,0);
670   if (!rc)
671     {
672       hash_public_key(md,main_pk);
673       hash_public_key(md,sub_pk);
674       rc = check_signature_end (sub_pk, backsig, md, NULL, NULL, NULL);
675       cache_sig_result(backsig,rc);
676       gcry_md_close(md);
677     }
678
679   return rc;
680 }
681
682
683 /* Check that a signature over a key is valid.  This is a
684  * specialization of check_key_signature2 with the unnamed parameters
685  * passed as NULL.  See the documentation for that function for more
686  * details.  */
687 int
688 check_key_signature (KBNODE root, KBNODE node, int *is_selfsig)
689 {
690   return check_key_signature2 (root, node, NULL, NULL, is_selfsig, NULL, NULL);
691 }
692
693
694 /* Check that a signature over a key (e.g., a key revocation, key
695  * binding, user id certification, etc.) is valid.  If the function
696  * detects a self-signature, it uses the public key from the specified
697  * key block and does not bother looking up the key specified in the
698  * signature packet.
699  *
700  * ROOT is a keyblock.
701  *
702  * NODE references a signature packet that appears in the keyblock
703  * that should be verified.
704  *
705  * If CHECK_PK is set, the specified key is sometimes preferred for
706  * verifying signatures.  See the implementation for details.
707  *
708  * If RET_PK is not NULL, the public key that successfully verified
709  * the signature is copied into *RET_PK.
710  *
711  * If IS_SELFSIG is not NULL, *IS_SELFSIG is set to 1 if NODE is a
712  * self-signature.
713  *
714  * If R_EXPIREDATE is not NULL, *R_EXPIREDATE is set to the expiry
715  * date.
716  *
717  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has been
718  * expired (0 otherwise).  Note: PK being revoked does not cause this
719  * function to fail.
720  *
721  *
722  * If OPT.NO_SIG_CACHE is not set, this function will first check if
723  * the result of a previous verification is already cached in the
724  * signature packet's data structure.
725  *
726  * TODO: add r_revoked here as well.  It has the same problems as
727  * r_expiredate and r_expired and the cache.  */
728 int
729 check_key_signature2 (kbnode_t root, kbnode_t node, PKT_public_key *check_pk,
730                       PKT_public_key *ret_pk, int *is_selfsig,
731                       u32 *r_expiredate, int *r_expired )
732 {
733   gcry_md_hd_t md;
734   PKT_public_key *pk;
735   PKT_signature *sig;
736   int algo;
737   int rc;
738
739   if (is_selfsig)
740     *is_selfsig = 0;
741   if (r_expiredate)
742     *r_expiredate = 0;
743   if (r_expired)
744     *r_expired = 0;
745   assert (node->pkt->pkttype == PKT_SIGNATURE);
746   assert (root->pkt->pkttype == PKT_PUBLIC_KEY);
747
748   pk = root->pkt->pkt.public_key;
749   sig = node->pkt->pkt.signature;
750   algo = sig->digest_algo;
751
752   /* Check whether we have cached the result of a previous signature
753      check.  Note that we may no longer have the pubkey or hash
754      needed to verify a sig, but can still use the cached value.  A
755      cache refresh detects and clears these cases. */
756   if ( !opt.no_sig_cache )
757     {
758       if (sig->flags.checked) /* Cached status available.  */
759         {
760           if (is_selfsig)
761             {
762               u32 keyid[2];
763
764               keyid_from_pk (pk, keyid);
765               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
766                 *is_selfsig = 1;
767             }
768           /* BUG: This is wrong for non-self-sigs... needs to be the
769              actual pk.  */
770           rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
771           if (rc)
772             return rc;
773           return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
774         }
775     }
776
777   rc = openpgp_pk_test_algo(sig->pubkey_algo);
778   if (rc)
779     return rc;
780   rc = openpgp_md_test_algo(algo);
781   if (rc)
782     return rc;
783
784   if (sig->sig_class == 0x20) /* key revocation */
785     {
786       u32 keyid[2];
787       keyid_from_pk( pk, keyid );
788
789       /* Is it a designated revoker? */
790       if (keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1])
791         rc = check_revocation_keys (pk, sig);
792       else
793         {
794           if (gcry_md_open (&md, algo, 0))
795             BUG ();
796           hash_public_key (md, pk);
797           rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
798           cache_sig_result (sig, rc);
799           gcry_md_close (md);
800         }
801     }
802   else if (sig->sig_class == 0x28) /* subkey revocation */
803     {
804       kbnode_t snode = find_prev_kbnode (root, node, PKT_PUBLIC_SUBKEY);
805
806       if (snode)
807         {
808           if (gcry_md_open (&md, algo, 0))
809             BUG ();
810           hash_public_key (md, pk);
811           hash_public_key (md, snode->pkt->pkt.public_key);
812           rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
813           cache_sig_result (sig, rc);
814           gcry_md_close (md);
815         }
816       else
817         {
818           if (opt.verbose)
819             log_info (_("key %s: no subkey for subkey"
820                         " revocation signature\n"), keystr_from_pk(pk));
821           rc = GPG_ERR_SIG_CLASS;
822         }
823     }
824     else if (sig->sig_class == 0x18) /* key binding */
825       {
826         kbnode_t snode = find_prev_kbnode (root, node, PKT_PUBLIC_SUBKEY);
827
828         if (snode)
829           {
830             if (is_selfsig)
831               {
832                 /* Does this make sense?  It should always be a
833                    selfsig.  Yes: We can't be sure about this and we
834                    need to be able to indicate that it is a selfsig.
835                    FIXME: The question is whether we should reject
836                    such a signature if it is not a selfsig.  */
837                 u32 keyid[2];
838
839                 keyid_from_pk (pk, keyid);
840                 if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
841                   *is_selfsig = 1;
842               }
843             if (gcry_md_open (&md, algo, 0))
844               BUG ();
845             hash_public_key (md, pk);
846             hash_public_key (md, snode->pkt->pkt.public_key);
847             rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
848             cache_sig_result ( sig, rc );
849             gcry_md_close (md);
850           }
851         else
852           {
853             if (opt.verbose)
854               log_info(_("key %s: no subkey for subkey"
855                          " binding signature\n"), keystr_from_pk(pk));
856             rc = GPG_ERR_SIG_CLASS;
857           }
858       }
859     else if (sig->sig_class == 0x1f) /* direct key signature */
860       {
861         if (gcry_md_open (&md, algo, 0 ))
862           BUG ();
863         hash_public_key( md, pk );
864         rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
865         cache_sig_result (sig, rc);
866         gcry_md_close (md);
867       }
868     else /* all other classes */
869       {
870         kbnode_t unode = find_prev_kbnode (root, node, PKT_USER_ID);
871
872         if (unode)
873           {
874             u32 keyid[2];
875
876             keyid_from_pk (pk, keyid);
877             if (gcry_md_open (&md, algo, 0))
878               BUG ();
879             hash_public_key (md, pk);
880             hash_uid_node (unode, md, sig);
881             if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
882               { /* The primary key is the signing key.  */
883
884                 if (is_selfsig)
885                   *is_selfsig = 1;
886                 rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
887               }
888             else if (check_pk)
889               { /* The caller specified a key.  Try that.  */
890
891                 rc = check_signature_end (check_pk, sig, md,
892                                           r_expired, NULL, ret_pk);
893               }
894             else
895               { /* Look up the key.  */
896                 rc = check_signature2 (sig, md, r_expiredate, r_expired,
897                                        NULL, ret_pk);
898               }
899
900             cache_sig_result  (sig, rc);
901             gcry_md_close (md);
902           }
903         else
904           {
905             if (!opt.quiet)
906               log_info ("key %s: no user ID for key signature packet"
907                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
908             rc = GPG_ERR_SIG_CLASS;
909           }
910       }
911
912   return rc;
913 }