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