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