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