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