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