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