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