gpg: Use "days" in "...newer than..." diagnostics.
[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         if ( d < 86400 )
272           {
273             log_info
274               (ngettext
275                ("public key %s is %lu second newer than the signature\n",
276                 "public key %s is %lu seconds newer than the signature\n",
277                 d), keystr_from_pk (pk), d);
278           }
279         else
280           {
281             d /= 86400;
282             log_info
283               (ngettext
284                ("public key %s is %lu day newer than the signature\n",
285                 "public key %s is %lu days newer than the signature\n",
286                 d), keystr_from_pk (pk), d);
287           }
288         if (!opt.ignore_time_conflict)
289           return GPG_ERR_TIME_CONFLICT; /* pubkey newer than signature.  */
290       }
291
292     cur_time = make_timestamp();
293     if( pk->timestamp > cur_time )
294       {
295         ulong d = pk->timestamp - cur_time;
296         if (d < 86400)
297           {
298             log_info (ngettext("key %s was created %lu second"
299                                " in the future (time warp or clock problem)\n",
300                                "key %s was created %lu seconds"
301                                " in the future (time warp or clock problem)\n",
302                                d), keystr_from_pk (pk), d);
303           }
304         else
305           {
306             d /= 86400;
307             log_info (ngettext("key %s was created %lu day"
308                                " in the future (time warp or clock problem)\n",
309                                "key %s was created %lu days"
310                                " in the future (time warp or clock problem)\n",
311                                d), keystr_from_pk (pk), d);
312           }
313         if (!opt.ignore_time_conflict)
314           return GPG_ERR_TIME_CONFLICT;
315       }
316
317     /* Check whether the key has expired.  We check the has_expired
318        flag which is set after a full evaluation of the key (getkey.c)
319        as well as a simple compare to the current time in case the
320        merge has for whatever reasons not been done.  */
321     if( pk->has_expired || (pk->expiredate && pk->expiredate < cur_time)) {
322         char buf[11];
323         if (opt.verbose)
324           log_info(_("Note: signature key %s expired %s\n"),
325                    keystr_from_pk(pk), asctimestamp( pk->expiredate ) );
326         sprintf(buf,"%lu",(ulong)pk->expiredate);
327         write_status_text(STATUS_KEYEXPIRED,buf);
328         if(r_expired)
329           *r_expired = 1;
330     }
331
332     if (pk->flags.revoked)
333       {
334         if (opt.verbose)
335           log_info (_("Note: signature key %s has been revoked\n"),
336                     keystr_from_pk(pk));
337         if (r_revoked)
338           *r_revoked=1;
339       }
340
341     return 0;
342 }
343
344
345 /* Finish generating a signature and check it.  Concretely: make sure
346  * that the signature is valid (it was not created prior to the key,
347  * the public key was created in the past, and the signature does not
348  * include any unsupported critical features), finish computing the
349  * digest by adding the relevant data from the signature packet, and
350  * check that the signature verifies the digest.
351  *
352  * DIGEST contains a hash context, which has already hashed the signed
353  * data.  This function adds the relevant meta-data from the signature
354  * packet to compute the final hash.  (See Section 5.2 of RFC 4880:
355  * "The concatenation of the data being signed and the signature data
356  * from the version number through the hashed subpacket data
357  * (inclusive) is hashed.")
358  *
359  * SIG is the signature to check.
360  *
361  * PK is the public key used to generate the signature.
362  *
363  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has expired
364  * (0 otherwise).  Note: PK being expired does not cause this function
365  * to fail.
366  *
367  * If R_REVOKED is not NULL, *R_REVOKED is set to 1 if PK has been
368  * revoked (0 otherwise).  Note: PK being revoked does not cause this
369  * function to fail.
370  *
371  * If RET_PK is not NULL, PK is copied into RET_PK on success.
372  *
373  * Returns 0 on success.  An error code other.  */
374 static int
375 check_signature_end (PKT_public_key *pk, PKT_signature *sig,
376                      gcry_md_hd_t digest,
377                      int *r_expired, int *r_revoked, PKT_public_key *ret_pk)
378 {
379     gcry_mpi_t result = NULL;
380     int rc = 0;
381     const struct weakhash *weak;
382
383     if ((rc = check_signature_metadata_validity (pk, sig,
384                                                  r_expired, r_revoked)))
385         return rc;
386
387     if (!opt.flags.allow_weak_digest_algos)
388       for (weak = opt.weak_digests; weak; weak = weak->next)
389         if (sig->digest_algo == weak->algo)
390           {
391             print_digest_rejected_note(sig->digest_algo);
392             return GPG_ERR_DIGEST_ALGO;
393           }
394
395     /* Make sure the digest algo is enabled (in case of a detached
396        signature).  */
397     gcry_md_enable (digest, sig->digest_algo);
398
399     /* Complete the digest. */
400     if( sig->version >= 4 )
401         gcry_md_putc( digest, sig->version );
402     gcry_md_putc( digest, sig->sig_class );
403     if( sig->version < 4 ) {
404         u32 a = sig->timestamp;
405         gcry_md_putc( digest, (a >> 24) & 0xff );
406         gcry_md_putc( digest, (a >> 16) & 0xff );
407         gcry_md_putc( digest, (a >>     8) & 0xff );
408         gcry_md_putc( digest,  a           & 0xff );
409     }
410     else {
411         byte buf[6];
412         size_t n;
413         gcry_md_putc( digest, sig->pubkey_algo );
414         gcry_md_putc( digest, sig->digest_algo );
415         if( sig->hashed ) {
416             n = sig->hashed->len;
417             gcry_md_putc (digest, (n >> 8) );
418             gcry_md_putc (digest,  n       );
419             gcry_md_write (digest, sig->hashed->data, n);
420             n += 6;
421         }
422         else {
423           /* Two octets for the (empty) length of the hashed
424              section. */
425           gcry_md_putc (digest, 0);
426           gcry_md_putc (digest, 0);
427           n = 6;
428         }
429         /* add some magic per Section 5.2.4 of RFC 4880.  */
430         buf[0] = sig->version;
431         buf[1] = 0xff;
432         buf[2] = n >> 24;
433         buf[3] = n >> 16;
434         buf[4] = n >>  8;
435         buf[5] = n;
436         gcry_md_write( digest, buf, 6 );
437     }
438     gcry_md_final( digest );
439
440     /* Convert the digest to an MPI.  */
441     result = encode_md_value (pk, digest, sig->digest_algo );
442     if (!result)
443         return GPG_ERR_GENERAL;
444
445     /* Verify the signature.  */
446     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
447     gcry_mpi_release (result);
448
449     if( !rc && sig->flags.unknown_critical )
450       {
451         log_info(_("assuming bad signature from key %s"
452                    " due to an unknown critical bit\n"),keystr_from_pk(pk));
453         rc = GPG_ERR_BAD_SIGNATURE;
454       }
455
456     if(!rc && ret_pk)
457       copy_public_key(ret_pk,pk);
458
459     return rc;
460 }
461
462
463 /* Add a uid node to a hash context.  See section 5.2.4, paragraph 4
464    of RFC 4880.  */
465 static void
466 hash_uid_node( KBNODE unode, gcry_md_hd_t md, PKT_signature *sig )
467 {
468     PKT_user_id *uid = unode->pkt->pkt.user_id;
469
470     assert( unode->pkt->pkttype == PKT_USER_ID );
471     if( uid->attrib_data ) {
472         if( sig->version >=4 ) {
473             byte buf[5];
474             buf[0] = 0xd1;                   /* packet of type 17 */
475             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
476             buf[2] = uid->attrib_len >> 16;
477             buf[3] = uid->attrib_len >>  8;
478             buf[4] = uid->attrib_len;
479             gcry_md_write( md, buf, 5 );
480         }
481         gcry_md_write( md, uid->attrib_data, uid->attrib_len );
482     }
483     else {
484         if( sig->version >=4 ) {
485             byte buf[5];
486             buf[0] = 0xb4;            /* indicates a userid packet */
487             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
488             buf[2] = uid->len >> 16;
489             buf[3] = uid->len >>  8;
490             buf[4] = uid->len;
491             gcry_md_write( md, buf, 5 );
492         }
493         gcry_md_write( md, uid->name, uid->len );
494     }
495 }
496
497 static void
498 cache_sig_result ( PKT_signature *sig, int result )
499 {
500     if ( !result ) {
501         sig->flags.checked = 1;
502         sig->flags.valid = 1;
503     }
504     else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
505         sig->flags.checked = 1;
506         sig->flags.valid = 0;
507     }
508     else {
509         sig->flags.checked = 0;
510         sig->flags.valid = 0;
511     }
512 }
513
514
515 /* SIG is a key revocation signature.  Check if this signature was
516  * generated by any of the public key PK's designated revokers.
517  *
518  *   PK is the public key that SIG allegedly revokes.
519  *
520  *   SIG is the revocation signature to check.
521  *
522  * This function avoids infinite recursion, which can happen if two
523  * keys are designed revokers for each other and they revoke each
524  * other.  This is done by observing that if a key A is revoked by key
525  * B we still consider the revocation to be valid even if B is
526  * revoked.  Thus, we don't need to determine whether B is revoked to
527  * determine whether A has been revoked by B, we just need to check
528  * the signature.
529  *
530  * Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
531  * revoked.  We are careful to make sure that GPG_ERR_NO_PUBKEY is
532  * only returned when a revocation signature is from a valid
533  * revocation key designated in a revkey subpacket, but the revocation
534  * key itself isn't present.
535  *
536  * XXX: This code will need to be modified if gpg ever becomes
537  * multi-threaded.  Note that this guarantees that a designated
538  * revocation sig will never be considered valid unless it is actually
539  * valid, as well as being issued by a revocation key in a valid
540  * direct signature.  Note also that this is written so that a revoked
541  * revoker can still issue revocations: i.e. If A revokes B, but A is
542  * revoked, B is still revoked.  I'm not completely convinced this is
543  * the proper behavior, but it matches how PGP does it. -dms */
544 int
545 check_revocation_keys (PKT_public_key *pk, PKT_signature *sig)
546 {
547   static int busy=0;
548   int i;
549   int rc = GPG_ERR_GENERAL;
550
551   assert(IS_KEY_REV(sig));
552   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
553
554   /* Avoid infinite recursion.  Consider the following:
555    *
556    *   - We want to check if A is revoked.
557    *
558    *   - C is a designated revoker for B and has revoked B.
559    *
560    *   - B is a designated revoker for A and has revoked A.
561    *
562    * When checking if A is revoked (in merge_selfsigs_main), we
563    * observe that A has a designed revoker.  As such, we call this
564    * function.  This function sees that there is a valid revocation
565    * signature, which is signed by B.  It then calls check_signature()
566    * to verify that the signature is good.  To check the sig, we need
567    * to lookup B.  Looking up B means calling merge_selfsigs_main,
568    * which checks whether B is revoked, which calls this function to
569    * see if B was revoked by some key.
570    *
571    * In this case, the added level of indirection doesn't hurt.  It
572    * just means a bit more work.  However, if C == A, then we'd end up
573    * in a loop.  But, it doesn't make sense to look up C anyways: even
574    * if B is revoked, we conservatively consider a valid revocation
575    * signed by B to revoke A.  Since this is the only place where this
576    * type of recursion can occur, we simply cause this function to
577    * fail if it is entered recursively.  */
578   if (busy)
579     {
580       /* Return an error (i.e. not revoked), but mark the pk as
581          uncacheable as we don't really know its revocation status
582          until it is checked directly.  */
583       pk->flags.dont_cache = 1;
584       return rc;
585     }
586
587   busy=1;
588
589   /*  es_printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
590       (ulong)sig->keyid[1]); */
591
592   /* is the issuer of the sig one of our revokers? */
593   if( !pk->revkey && pk->numrevkeys )
594      BUG();
595   else
596       for(i=0;i<pk->numrevkeys;i++)
597         {
598           /* The revoker's keyid.  */
599           u32 keyid[2];
600
601           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
602
603           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
604             /* The signature was generated by a designated revoker.
605                Verify the signature.  */
606             {
607               gcry_md_hd_t md;
608
609               if (gcry_md_open (&md, sig->digest_algo, 0))
610                 BUG ();
611               hash_public_key(md,pk);
612               /* Note: check_signature only checks that the signature
613                  is good.  It does not fail if the key is revoked.  */
614               rc=check_signature(sig,md);
615               cache_sig_result(sig,rc);
616               gcry_md_close (md);
617               break;
618             }
619         }
620
621   busy=0;
622
623   return rc;
624 }
625
626 /* Check that the backsig BACKSIG from the subkey SUB_PK to its
627    primary key MAIN_PK is valid.
628
629    Backsigs (0x19) have the same format as binding sigs (0x18), but
630    this function is simpler than check_key_signature in a few ways.
631    For example, there is no support for expiring backsigs since it is
632    questionable what such a thing actually means.  Note also that the
633    sig cache check here, unlike other sig caches in GnuPG, is not
634    persistent. */
635 int
636 check_backsig (PKT_public_key *main_pk,PKT_public_key *sub_pk,
637                PKT_signature *backsig)
638 {
639   gcry_md_hd_t md;
640   int rc;
641
642   /* Always check whether the algorithm is available.  Although
643      gcry_md_open would throw an error, some libgcrypt versions will
644      print a debug message in that case too. */
645   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
646     return rc;
647
648   if(!opt.no_sig_cache && backsig->flags.checked)
649     return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
650
651   rc = gcry_md_open (&md, backsig->digest_algo,0);
652   if (!rc)
653     {
654       hash_public_key(md,main_pk);
655       hash_public_key(md,sub_pk);
656       rc = check_signature_end (sub_pk, backsig, md, NULL, NULL, NULL);
657       cache_sig_result(backsig,rc);
658       gcry_md_close(md);
659     }
660
661   return rc;
662 }
663
664
665 /* Check that a signature over a key is valid.  This is a
666  * specialization of check_key_signature2 with the unnamed parameters
667  * passed as NULL.  See the documentation for that function for more
668  * details.  */
669 int
670 check_key_signature (KBNODE root, KBNODE node, int *is_selfsig)
671 {
672   return check_key_signature2 (root, node, NULL, NULL, is_selfsig, NULL, NULL);
673 }
674
675
676 /* Check that a signature over a key (e.g., a key revocation, key
677  * binding, user id certification, etc.) is valid.  If the function
678  * detects a self-signature, it uses the public key from the specified
679  * key block and does not bother looking up the key specified in the
680  * signature packet.
681  *
682  * ROOT is a keyblock.
683  *
684  * NODE references a signature packet that appears in the keyblock
685  * that should be verified.
686  *
687  * If CHECK_PK is set, the specified key is sometimes preferred for
688  * verifying signatures.  See the implementation for details.
689  *
690  * If RET_PK is not NULL, the public key that successfully verified
691  * the signature is copied into *RET_PK.
692  *
693  * If IS_SELFSIG is not NULL, *IS_SELFSIG is set to 1 if NODE is a
694  * self-signature.
695  *
696  * If R_EXPIREDATE is not NULL, *R_EXPIREDATE is set to the expiry
697  * date.
698  *
699  * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has been
700  * expired (0 otherwise).  Note: PK being revoked does not cause this
701  * function to fail.
702  *
703  *
704  * If OPT.NO_SIG_CACHE is not set, this function will first check if
705  * the result of a previous verification is already cached in the
706  * signature packet's data structure.
707  *
708  * TODO: add r_revoked here as well.  It has the same problems as
709  * r_expiredate and r_expired and the cache.  */
710 int
711 check_key_signature2 (kbnode_t root, kbnode_t node, PKT_public_key *check_pk,
712                       PKT_public_key *ret_pk, int *is_selfsig,
713                       u32 *r_expiredate, int *r_expired )
714 {
715   gcry_md_hd_t md;
716   PKT_public_key *pk;
717   PKT_signature *sig;
718   int algo;
719   int rc;
720
721   if (is_selfsig)
722     *is_selfsig = 0;
723   if (r_expiredate)
724     *r_expiredate = 0;
725   if (r_expired)
726     *r_expired = 0;
727   assert (node->pkt->pkttype == PKT_SIGNATURE);
728   assert (root->pkt->pkttype == PKT_PUBLIC_KEY);
729
730   pk = root->pkt->pkt.public_key;
731   sig = node->pkt->pkt.signature;
732   algo = sig->digest_algo;
733
734   /* Check whether we have cached the result of a previous signature
735      check.  Note that we may no longer have the pubkey or hash
736      needed to verify a sig, but can still use the cached value.  A
737      cache refresh detects and clears these cases. */
738   if ( !opt.no_sig_cache )
739     {
740       if (sig->flags.checked) /* Cached status available.  */
741         {
742           if (is_selfsig)
743             {
744               u32 keyid[2];
745
746               keyid_from_pk (pk, keyid);
747               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
748                 *is_selfsig = 1;
749             }
750           /* BUG: This is wrong for non-self-sigs... needs to be the
751              actual pk.  */
752           rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
753           if (rc)
754             return rc;
755           return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
756         }
757     }
758
759   rc = openpgp_pk_test_algo(sig->pubkey_algo);
760   if (rc)
761     return rc;
762   rc = openpgp_md_test_algo(algo);
763   if (rc)
764     return rc;
765
766   if (sig->sig_class == 0x20) /* key revocation */
767     {
768       u32 keyid[2];
769       keyid_from_pk( pk, keyid );
770
771       /* Is it a designated revoker? */
772       if (keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1])
773         rc = check_revocation_keys (pk, sig);
774       else
775         {
776           if (gcry_md_open (&md, algo, 0))
777             BUG ();
778           hash_public_key (md, pk);
779           rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
780           cache_sig_result (sig, rc);
781           gcry_md_close (md);
782         }
783     }
784   else if (sig->sig_class == 0x28) /* subkey revocation */
785     {
786       kbnode_t snode = find_prev_kbnode (root, node, PKT_PUBLIC_SUBKEY);
787
788       if (snode)
789         {
790           if (gcry_md_open (&md, algo, 0))
791             BUG ();
792           hash_public_key (md, pk);
793           hash_public_key (md, snode->pkt->pkt.public_key);
794           rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
795           cache_sig_result (sig, rc);
796           gcry_md_close (md);
797         }
798       else
799         {
800           if (opt.verbose)
801             log_info (_("key %s: no subkey for subkey"
802                         " revocation signature\n"), keystr_from_pk(pk));
803           rc = GPG_ERR_SIG_CLASS;
804         }
805     }
806     else if (sig->sig_class == 0x18) /* key binding */
807       {
808         kbnode_t snode = find_prev_kbnode (root, node, PKT_PUBLIC_SUBKEY);
809
810         if (snode)
811           {
812             if (is_selfsig)
813               {
814                 /* Does this make sense?  It should always be a
815                    selfsig.  Yes: We can't be sure about this and we
816                    need to be able to indicate that it is a selfsig.
817                    FIXME: The question is whether we should reject
818                    such a signature if it is not a selfsig.  */
819                 u32 keyid[2];
820
821                 keyid_from_pk (pk, keyid);
822                 if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
823                   *is_selfsig = 1;
824               }
825             if (gcry_md_open (&md, algo, 0))
826               BUG ();
827             hash_public_key (md, pk);
828             hash_public_key (md, snode->pkt->pkt.public_key);
829             rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
830             cache_sig_result ( sig, rc );
831             gcry_md_close (md);
832           }
833         else
834           {
835             if (opt.verbose)
836               log_info(_("key %s: no subkey for subkey"
837                          " binding signature\n"), keystr_from_pk(pk));
838             rc = GPG_ERR_SIG_CLASS;
839           }
840       }
841     else if (sig->sig_class == 0x1f) /* direct key signature */
842       {
843         if (gcry_md_open (&md, algo, 0 ))
844           BUG ();
845         hash_public_key( md, pk );
846         rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
847         cache_sig_result (sig, rc);
848         gcry_md_close (md);
849       }
850     else /* all other classes */
851       {
852         kbnode_t unode = find_prev_kbnode (root, node, PKT_USER_ID);
853
854         if (unode)
855           {
856             u32 keyid[2];
857
858             keyid_from_pk (pk, keyid);
859             if (gcry_md_open (&md, algo, 0))
860               BUG ();
861             hash_public_key (md, pk);
862             hash_uid_node (unode, md, sig);
863             if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
864               { /* The primary key is the signing key.  */
865
866                 if (is_selfsig)
867                   *is_selfsig = 1;
868                 rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
869               }
870             else if (check_pk)
871               { /* The caller specified a key.  Try that.  */
872
873                 rc = check_signature_end (check_pk, sig, md,
874                                           r_expired, NULL, ret_pk);
875               }
876             else
877               { /* Look up the key.  */
878                 rc = check_signature2 (sig, md, r_expiredate, r_expired,
879                                        NULL, ret_pk);
880               }
881
882             cache_sig_result  (sig, rc);
883             gcry_md_close (md);
884           }
885         else
886           {
887             if (!opt.quiet)
888               log_info ("key %s: no user ID for key signature packet"
889                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
890             rc = GPG_ERR_SIG_CLASS;
891           }
892       }
893
894   return rc;
895 }