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