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