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