a3075337cdb0fd73e4ba8651a4cf47c7375c2141
[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  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26
27 #include "gpg.h"
28 #include "util.h"
29 #include "packet.h"
30 #include "keydb.h"
31 #include "main.h"
32 #include "status.h"
33 #include "i18n.h"
34 #include "options.h"
35 #include "pkglue.h"
36
37 /* Context used by the compare function. */
38 struct cmp_help_context_s
39 {
40   PKT_signature *sig;
41   gcry_md_hd_t md;
42 };
43
44
45
46 static int do_check( PKT_public_key *pk, PKT_signature *sig,
47                      gcry_md_hd_t digest,
48                      int *r_expired, int *r_revoked, PKT_public_key *ret_pk);
49
50 /****************
51  * Check the signature which is contained in SIG.
52  * The MD_HANDLE should be currently open, so that this function
53  * is able to append some data, before finalizing the digest.
54  */
55 int
56 signature_check (PKT_signature *sig, gcry_md_hd_t digest)
57 {
58     return signature_check2( sig, digest, NULL, NULL, NULL, NULL );
59 }
60
61 int
62 signature_check2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
63                   int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
64 {
65     PKT_public_key *pk = xmalloc_clear( sizeof *pk );
66     int rc=0;
67
68     if ( (rc=openpgp_md_test_algo(sig->digest_algo)) )
69       ; /* We don't have this digest. */
70     else if ((rc=openpgp_pk_test_algo(sig->pubkey_algo)))
71       ; /* We don't have this pubkey algo. */
72     else if (!gcry_md_is_enabled (digest,sig->digest_algo))
73       {
74         /* Sanity check that the md has a context for the hash that the
75            sig is expecting.  This can happen if a onepass sig header does
76            not match the actual sig, and also if the clearsign "Hash:"
77            header is missing or does not match the actual sig. */
78
79         log_info(_("WARNING: signature digest conflict in message\n"));
80         rc=G10ERR_GENERAL;
81       }
82     else if( get_pubkey( pk, sig->keyid ) )
83         rc = G10ERR_NO_PUBKEY;
84     else if(!pk->flags.valid && !pk->flags.primary)
85         rc=G10ERR_BAD_PUBKEY; /* you cannot have a good sig from an
86                                  invalid subkey */
87     else
88       {
89         if(r_expiredate)
90           *r_expiredate = pk->expiredate;
91
92         rc = do_check( pk, sig, digest, r_expired, r_revoked, ret_pk );
93
94         /* Check the backsig.  This is a 0x19 signature from the
95            subkey on the primary key.  The idea here is that it should
96            not be possible for someone to "steal" subkeys and claim
97            them as their own.  The attacker couldn't actually use the
98            subkey, but they could try and claim ownership of any
99            signaures issued by it. */
100         if(rc==0 && !pk->flags.primary && pk->flags.backsig < 2)
101           {
102             if (!pk->flags.backsig)
103               {
104                 log_info(_("WARNING: signing subkey %s is not"
105                            " cross-certified\n"),keystr_from_pk(pk));
106                 log_info(_("please see %s for more information\n"),
107                          "http://www.gnupg.org/faq/subkey-cross-certify.html");
108                 /* --require-cross-certification makes this warning an
109                      error.  TODO: change the default to require this
110                      after more keys have backsigs. */
111                 if(opt.flags.require_cross_cert)
112                   rc=G10ERR_GENERAL;
113               }
114             else if(pk->flags.backsig == 1)
115               {
116                 log_info(_("WARNING: signing subkey %s has an invalid"
117                            " cross-certification\n"),keystr_from_pk(pk));
118                 rc=G10ERR_GENERAL;
119               }
120           }
121       }
122
123     free_public_key( pk );
124
125     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
126         /* This signature id works best with DLP algorithms because
127          * they use a random parameter for every signature.  Instead of
128          * this sig-id we could have also used the hash of the document
129          * and the timestamp, but the drawback of this is, that it is
130          * not possible to sign more than one identical document within
131          * one second.  Some remote batch processing applications might
132          * like this feature here.
133          *
134          * Note that before 2.0.10, we used RIPE-MD160 for the hash
135          * and accidently didn't include the timestamp and algorithm
136          * information in the hash.  Given that this feature is not
137          * commonly used and that a replay attacks detection should
138          * not solely be based on this feature (because it does not
139          * work with RSA), we take the freedom and switch to SHA-1
140          * with 2.0.10 to take advantage of hardware supported SHA-1
141          * implementations.  We also include the missing information
142          * in the hash.  Note also the SIG_ID as computed by gpg 1.x
143          * and gpg 2.x didn't matched either because 2.x used to print
144          * MPIs not in PGP format.  */
145         u32 a = sig->timestamp;
146         int nsig = pubkey_get_nsig( sig->pubkey_algo );
147         unsigned char *p, *buffer;
148         size_t n, nbytes;
149         int i;
150         char hashbuf[20];
151
152         nbytes = 6;
153         for (i=0; i < nsig; i++ )
154           {
155             if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &n, sig->data[i]))
156               BUG();
157             nbytes += n;
158           }
159
160         /* Make buffer large enough to be later used as output buffer.  */
161         if (nbytes < 100)
162           nbytes = 100;
163         nbytes += 10;  /* Safety margin.  */
164
165         /* Fill and hash buffer.  */
166         buffer = p = xmalloc (nbytes);
167         *p++ = sig->pubkey_algo;
168         *p++ = sig->digest_algo;
169         *p++ = (a >> 24) & 0xff;
170         *p++ = (a >> 16) & 0xff;
171         *p++ = (a >>  8) & 0xff;
172         *p++ =  a & 0xff;
173         nbytes -= 6;
174         for (i=0; i < nsig; i++ )
175           {
176             if (gcry_mpi_print (GCRYMPI_FMT_PGP, p, nbytes, &n, sig->data[i]))
177               BUG();
178             p += n;
179             nbytes -= n;
180           }
181         gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, buffer, p-buffer);
182
183         p = make_radix64_string (hashbuf, 20);
184         sprintf (buffer, "%s %s %lu",
185                  p, strtimestamp (sig->timestamp), (ulong)sig->timestamp);
186         xfree (p);
187         write_status_text (STATUS_SIG_ID, buffer);
188         xfree (buffer);
189     }
190
191     return rc;
192 }
193
194
195 static int
196 do_check_messages( PKT_public_key *pk, PKT_signature *sig,
197                    int *r_expired, int *r_revoked )
198 {
199     u32 cur_time;
200
201     if(r_expired)
202       *r_expired = 0;
203     if(r_revoked)
204       *r_revoked = 0;
205
206     if( pk->timestamp > sig->timestamp )
207       {
208         ulong d = pk->timestamp - sig->timestamp;
209         log_info(d==1
210                  ?_("public key %s is %lu second newer than the signature\n")
211                  :_("public key %s is %lu seconds newer than the signature\n"),
212                  keystr_from_pk(pk),d );
213         if( !opt.ignore_time_conflict )
214           return G10ERR_TIME_CONFLICT; /* pubkey newer than signature */
215       }
216
217     cur_time = make_timestamp();
218     if( pk->timestamp > cur_time )
219       {
220         ulong d = pk->timestamp - cur_time;
221         log_info( d==1
222                   ? _("key %s was created %lu second"
223                       " in the future (time warp or clock problem)\n")
224                   : _("key %s was created %lu seconds"
225                       " in the future (time warp or clock problem)\n"),
226                   keystr_from_pk(pk),d );
227         if( !opt.ignore_time_conflict )
228           return G10ERR_TIME_CONFLICT;
229       }
230
231     /* Check whether the key has expired.  We check the has_expired
232        flag which is set after a full evaluation of the key (getkey.c)
233        as well as a simple compare to the current time in case the
234        merge has for whatever reasons not been done.  */
235     if( pk->has_expired || (pk->expiredate && pk->expiredate < cur_time)) {
236         char buf[11];
237         if (opt.verbose)
238           log_info(_("NOTE: signature key %s expired %s\n"),
239                    keystr_from_pk(pk), asctimestamp( pk->expiredate ) );
240         sprintf(buf,"%lu",(ulong)pk->expiredate);
241         write_status_text(STATUS_KEYEXPIRED,buf);
242         if(r_expired)
243           *r_expired = 1;
244     }
245
246     if (pk->flags.revoked)
247       {
248         if (opt.verbose)
249           log_info (_("NOTE: signature key %s has been revoked\n"),
250                     keystr_from_pk(pk));
251         if (r_revoked)
252           *r_revoked=1;
253       }
254
255     return 0;
256 }
257
258
259 static int
260 do_check( PKT_public_key *pk, PKT_signature *sig, gcry_md_hd_t digest,
261           int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
262 {
263     gcry_mpi_t result = NULL;
264     int rc = 0;
265
266     if( (rc=do_check_messages(pk,sig,r_expired,r_revoked)) )
267         return rc;
268
269     /* Make sure the digest algo is enabled (in case of a detached
270        signature).  */
271     gcry_md_enable (digest, sig->digest_algo);
272
273     /* Complete the digest. */
274     if( sig->version >= 4 )
275         gcry_md_putc( digest, sig->version );
276     gcry_md_putc( digest, sig->sig_class );
277     if( sig->version < 4 ) {
278         u32 a = sig->timestamp;
279         gcry_md_putc( digest, (a >> 24) & 0xff );
280         gcry_md_putc( digest, (a >> 16) & 0xff );
281         gcry_md_putc( digest, (a >>     8) & 0xff );
282         gcry_md_putc( digest,  a           & 0xff );
283     }
284     else {
285         byte buf[6];
286         size_t n;
287         gcry_md_putc( digest, sig->pubkey_algo );
288         gcry_md_putc( digest, sig->digest_algo );
289         if( sig->hashed ) {
290             n = sig->hashed->len;
291             gcry_md_putc (digest, (n >> 8) );
292             gcry_md_putc (digest,  n       );
293             gcry_md_write (digest, sig->hashed->data, n);
294             n += 6;
295         }
296         else {
297           /* Two octets for the (empty) length of the hashed
298              section. */
299           gcry_md_putc (digest, 0);
300           gcry_md_putc (digest, 0);
301           n = 6;
302         }
303         /* add some magic */
304         buf[0] = sig->version;
305         buf[1] = 0xff;
306         buf[2] = n >> 24;
307         buf[3] = n >> 16;
308         buf[4] = n >>  8;
309         buf[5] = n;
310         gcry_md_write( digest, buf, 6 );
311     }
312     gcry_md_final( digest );
313
314     result = encode_md_value (pk, digest, sig->digest_algo );
315     if (!result)
316         return G10ERR_GENERAL;
317     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
318     gcry_mpi_release (result);
319
320     if( !rc && sig->flags.unknown_critical )
321       {
322         log_info(_("assuming bad signature from key %s"
323                    " due to an unknown critical bit\n"),keystr_from_pk(pk));
324         rc = G10ERR_BAD_SIGN;
325       }
326
327     if(!rc && ret_pk)
328       copy_public_key(ret_pk,pk);
329
330     return rc;
331 }
332
333
334
335 static void
336 hash_uid_node( KBNODE unode, gcry_md_hd_t md, PKT_signature *sig )
337 {
338     PKT_user_id *uid = unode->pkt->pkt.user_id;
339
340     assert( unode->pkt->pkttype == PKT_USER_ID );
341     if( uid->attrib_data ) {
342         if( sig->version >=4 ) {
343             byte buf[5];
344             buf[0] = 0xd1;                   /* packet of type 17 */
345             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
346             buf[2] = uid->attrib_len >> 16;
347             buf[3] = uid->attrib_len >>  8;
348             buf[4] = uid->attrib_len;
349             gcry_md_write( md, buf, 5 );
350         }
351         gcry_md_write( md, uid->attrib_data, uid->attrib_len );
352     }
353     else {
354         if( sig->version >=4 ) {
355             byte buf[5];
356             buf[0] = 0xb4;            /* indicates a userid packet */
357             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
358             buf[2] = uid->len >> 16;
359             buf[3] = uid->len >>  8;
360             buf[4] = uid->len;
361             gcry_md_write( md, buf, 5 );
362         }
363         gcry_md_write( md, uid->name, uid->len );
364     }
365 }
366
367 static void
368 cache_sig_result ( PKT_signature *sig, int result )
369 {
370     if ( !result ) {
371         sig->flags.checked = 1;
372         sig->flags.valid = 1;
373     }
374     else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
375         sig->flags.checked = 1;
376         sig->flags.valid = 0;
377     }
378     else {
379         sig->flags.checked = 0;
380         sig->flags.valid = 0;
381     }
382 }
383
384 /* Check the revocation keys to see if any of them have revoked our
385    pk.  sig is the revocation sig.  pk is the key it is on.  This code
386    will need to be modified if gpg ever becomes multi-threaded.  Note
387    that this guarantees that a designated revocation sig will never be
388    considered valid unless it is actually valid, as well as being
389    issued by a revocation key in a valid direct signature.  Note also
390    that this is written so that a revoked revoker can still issue
391    revocations: i.e. If A revokes B, but A is revoked, B is still
392    revoked.  I'm not completely convinced this is the proper behavior,
393    but it matches how PGP does it. -dms */
394
395 /* Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
396    revoked.  It is important that G10ERR_NO_PUBKEY is only returned
397    when a revocation signature is from a valid revocation key
398    designated in a revkey subpacket, but the revocation key itself
399    isn't present. */
400 int
401 check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
402 {
403   static int busy=0;
404   int i,rc=G10ERR_GENERAL;
405
406   assert(IS_KEY_REV(sig));
407   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
408
409   if (busy)
410     {
411       /* Return an error (i.e. not revoked), but mark the pk as
412          uncacheable as we don't really know its revocation status
413          until it is checked directly.  */
414       pk->flags.dont_cache = 1;
415       return rc;
416     }
417
418   busy=1;
419
420   /*  printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
421       (ulong)sig->keyid[1]); */
422
423   /* is the issuer of the sig one of our revokers? */
424   if( !pk->revkey && pk->numrevkeys )
425      BUG();
426   else
427       for(i=0;i<pk->numrevkeys;i++)
428         {
429           u32 keyid[2];
430
431           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
432
433           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
434             {
435               gcry_md_hd_t md;
436
437               if (gcry_md_open (&md, sig->digest_algo, 0))
438                 BUG ();
439               hash_public_key(md,pk);
440               rc=signature_check(sig,md);
441               cache_sig_result(sig,rc);
442               gcry_md_close (md);
443               break;
444             }
445         }
446
447   busy=0;
448
449   return rc;
450 }
451
452 /* Backsigs (0x19) have the same format as binding sigs (0x18), but
453    this function is simpler than check_key_signature in a few ways.
454    For example, there is no support for expiring backsigs since it is
455    questionable what such a thing actually means.  Note also that the
456    sig cache check here, unlike other sig caches in GnuPG, is not
457    persistent. */
458 int
459 check_backsig(PKT_public_key *main_pk,PKT_public_key *sub_pk,
460               PKT_signature *backsig)
461 {
462   gcry_md_hd_t md;
463   int rc;
464
465   /* Always check whether the algorithm is available.  Although
466      gcry_md_open woyuld throw an error, some libgcrypt versions will
467      print a debug message in that case too. */
468   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
469     return rc;
470
471   if(!opt.no_sig_cache && backsig->flags.checked)
472     return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
473
474   rc = gcry_md_open (&md, backsig->digest_algo,0);
475   if (!rc)
476     {
477       hash_public_key(md,main_pk);
478       hash_public_key(md,sub_pk);
479       rc=do_check(sub_pk,backsig,md,NULL,NULL,NULL);
480       cache_sig_result(backsig,rc);
481       gcry_md_close(md);
482     }
483
484   return rc;
485 }
486
487
488 /****************
489  * check the signature pointed to by NODE. This is a key signature.
490  * If the function detects a self-signature, it uses the PK from
491  * ROOT and does not read any public key.
492  */
493 int
494 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
495 {
496   return check_key_signature2(root, node, NULL, NULL, is_selfsig, NULL, NULL );
497 }
498
499 /* If check_pk is set, then use it to check the signature in node
500    rather than getting it from root or the keydb.  If ret_pk is set,
501    fill in the public key that was used to verify the signature.
502    ret_pk is only meaningful when the verification was successful. */
503 /* TODO: add r_revoked here as well.  It has the same problems as
504    r_expiredate and r_expired and the cache. */
505 int
506 check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
507                       PKT_public_key *ret_pk, int *is_selfsig,
508                       u32 *r_expiredate, int *r_expired )
509 {
510     gcry_md_hd_t md;
511     PKT_public_key *pk;
512     PKT_signature *sig;
513     int algo;
514     int rc;
515
516     if( is_selfsig )
517         *is_selfsig = 0;
518     if( r_expiredate )
519         *r_expiredate = 0;
520     if( r_expired )
521         *r_expired = 0;
522     assert( node->pkt->pkttype == PKT_SIGNATURE );
523     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
524
525     pk = root->pkt->pkt.public_key;
526     sig = node->pkt->pkt.signature;
527     algo = sig->digest_algo;
528
529     /* Check whether we have cached the result of a previous signature
530        check.  Note that we may no longer have the pubkey or hash
531        needed to verify a sig, but can still use the cached value.  A
532        cache refresh detects and clears these cases. */
533     if ( !opt.no_sig_cache ) {
534         if (sig->flags.checked) { /*cached status available*/
535             if( is_selfsig ) {
536                 u32 keyid[2];
537
538                 keyid_from_pk( pk, keyid );
539                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
540                     *is_selfsig = 1;
541             }
542             /* BUG: This is wrong for non-self-sigs.. needs to be the
543                actual pk */
544             if((rc=do_check_messages(pk,sig,r_expired,NULL)))
545               return rc;
546             return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
547         }
548     }
549
550     if( (rc=openpgp_pk_test_algo(sig->pubkey_algo)) )
551         return rc;
552     if( (rc=openpgp_md_test_algo(algo)) )
553         return rc;
554
555     if( sig->sig_class == 0x20 ) { /* key revocation */
556         u32 keyid[2];
557         keyid_from_pk( pk, keyid );
558
559         /* is it a designated revoker? */
560         if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
561           rc=check_revocation_keys(pk,sig);
562         else
563           {
564             if (gcry_md_open (&md, algo, 0 ))
565               BUG ();
566             hash_public_key( md, pk );
567             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
568             cache_sig_result ( sig, rc );
569             gcry_md_close(md);
570           }
571     }
572     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
573         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
574
575         if( snode ) {
576             if (gcry_md_open (&md, algo, 0))
577               BUG ();
578             hash_public_key( md, pk );
579             hash_public_key( md, snode->pkt->pkt.public_key );
580             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
581             cache_sig_result ( sig, rc );
582             gcry_md_close(md);
583         }
584         else
585           {
586             if (opt.verbose)
587               log_info (_("key %s: no subkey for subkey"
588                           " revocation signature\n"),keystr_from_pk(pk));
589             rc = G10ERR_SIG_CLASS;
590           }
591     }
592     else if( sig->sig_class == 0x18 ) { /* key binding */
593         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
594
595         if( snode ) {
596             if( is_selfsig ) {  /* does this make sense????? */
597                 u32 keyid[2];   /* it should always be a selfsig */
598
599                 keyid_from_pk( pk, keyid );
600                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
601                     *is_selfsig = 1;
602             }
603             if (gcry_md_open (&md, algo, 0))
604               BUG ();
605             hash_public_key( md, pk );
606             hash_public_key( md, snode->pkt->pkt.public_key );
607             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
608             cache_sig_result ( sig, rc );
609             gcry_md_close(md);
610         }
611         else
612           {
613             if (opt.verbose)
614               log_info(_("key %s: no subkey for subkey"
615                          " binding signature\n"),keystr_from_pk(pk));
616             rc = G10ERR_SIG_CLASS;
617           }
618     }
619     else if( sig->sig_class == 0x1f ) { /* direct key signature */
620         if (gcry_md_open (&md, algo, 0 ))
621           BUG ();
622         hash_public_key( md, pk );
623         rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
624         cache_sig_result ( sig, rc );
625         gcry_md_close(md);
626     }
627     else { /* all other classes */
628         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
629
630         if( unode ) {
631             u32 keyid[2];
632
633             keyid_from_pk( pk, keyid );
634             if (gcry_md_open (&md, algo, 0 ))
635               BUG ();
636             hash_public_key( md, pk );
637             hash_uid_node( unode, md, sig );
638             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
639               {
640                 if( is_selfsig )
641                   *is_selfsig = 1;
642                 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
643               }
644             else if (check_pk)
645               rc=do_check(check_pk,sig,md,r_expired,NULL,ret_pk);
646             else
647               rc=signature_check2(sig,md,r_expiredate,r_expired,NULL,ret_pk);
648
649             cache_sig_result ( sig, rc );
650             gcry_md_close(md);
651         }
652         else
653           {
654             if (!opt.quiet)
655               log_info ("key %s: no user ID for key signature packet"
656                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
657             rc = G10ERR_SIG_CLASS;
658           }
659     }
660
661     return rc;
662 }