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