* keyserver.c (parse_keyserver_uri, add_canonical_option): Always append
[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             /* TODO: In a future version, once enough signing subkeys
100                have backsigs, change this to always give the warning,
101                and have --require-backsigs enable or disable the
102                G10ERR_GENERAL. */
103             if(pk->backsig==0 && opt.require_backsigs)
104               {
105                 log_info(_("WARNING: signing subkey %s is not"
106                            " cross-certified\n"),keystr_from_pk(pk));
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->pubkey_algo, digest, sig->digest_algo,
276                               mpi_get_nbits(pk->pkey[0]) );
277     if (!result)
278         return G10ERR_GENERAL;
279     ctx.sig = sig;
280     ctx.md = digest;
281     rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
282     mpi_free( result );
283
284     if( !rc && sig->flags.unknown_critical )
285       {
286         log_info(_("assuming bad signature from key %s"
287                    " due to an unknown critical bit\n"),keystr_from_pk(pk));
288         rc = G10ERR_BAD_SIGN;
289       }
290
291     if(!rc && ret_pk)
292       copy_public_key(ret_pk,pk);
293
294     return rc;
295 }
296
297
298 static void
299 hash_uid_node( KBNODE unode, MD_HANDLE md, PKT_signature *sig )
300 {
301     PKT_user_id *uid = unode->pkt->pkt.user_id;
302
303     assert( unode->pkt->pkttype == PKT_USER_ID );
304     if( uid->attrib_data ) {
305         if( sig->version >=4 ) {
306             byte buf[5];
307             buf[0] = 0xd1;                   /* packet of type 17 */
308             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
309             buf[2] = uid->attrib_len >> 16;
310             buf[3] = uid->attrib_len >>  8;
311             buf[4] = uid->attrib_len;
312             md_write( md, buf, 5 );
313         }
314         md_write( md, uid->attrib_data, uid->attrib_len );
315     }
316     else {
317         if( sig->version >=4 ) {
318             byte buf[5];
319             buf[0] = 0xb4;            /* indicates a userid packet */
320             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
321             buf[2] = uid->len >> 16;
322             buf[3] = uid->len >>  8;
323             buf[4] = uid->len;
324             md_write( md, buf, 5 );
325         }
326         md_write( md, uid->name, uid->len );
327     }
328 }
329
330 static void
331 cache_sig_result ( PKT_signature *sig, int result )
332 {
333     if ( !result ) {
334         sig->flags.checked = 1;
335         sig->flags.valid = 1;
336     }
337     else if ( result == G10ERR_BAD_SIGN ) {
338         sig->flags.checked = 1;
339         sig->flags.valid = 0;
340     }
341     else {
342         sig->flags.checked = 0;
343         sig->flags.valid = 0;
344     }
345 }
346
347 /* Check the revocation keys to see if any of them have revoked our
348    pk.  sig is the revocation sig.  pk is the key it is on.  This code
349    will need to be modified if gpg ever becomes multi-threaded.  Note
350    that this guarantees that a designated revocation sig will never be
351    considered valid unless it is actually valid, as well as being
352    issued by a revocation key in a valid direct signature.  Note also
353    that this is written so that a revoked revoker can still issue
354    revocations: i.e. If A revokes B, but A is revoked, B is still
355    revoked.  I'm not completely convinced this is the proper behavior,
356    but it matches how PGP does it. -dms */
357
358 /* Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
359    revoked.  It is important that G10ERR_NO_PUBKEY is only returned
360    when a revocation signature is from a valid revocation key
361    designated in a revkey subpacket, but the revocation key itself
362    isn't present. */
363 int
364 check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
365 {
366   static int busy=0;
367   int i,rc=G10ERR_GENERAL;
368
369   assert(IS_KEY_REV(sig));
370   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
371
372   if(busy)
373     {
374       /* return an error (i.e. not revoked), but mark the pk as
375          uncacheable as we don't really know its revocation status
376          until it is checked directly. */
377
378       pk->dont_cache=1;
379       return rc;
380     }
381
382   busy=1;
383
384   /*  printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
385       (ulong)sig->keyid[1]); */
386
387   /* is the issuer of the sig one of our revokers? */
388   if( !pk->revkey && pk->numrevkeys )
389      BUG();
390   else
391       for(i=0;i<pk->numrevkeys;i++)
392         {
393           u32 keyid[2];
394     
395           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
396     
397           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
398             {
399               MD_HANDLE md;
400     
401               md=md_open(sig->digest_algo,0);
402               hash_public_key(md,pk);
403               rc=signature_check(sig,md);
404               cache_sig_result(sig,rc);
405               break;
406             }
407         }
408
409   busy=0;
410
411   return rc;
412
413
414 /* Backsigs (0x19) have the same format as binding sigs (0x18), but
415    this function is simpler than check_key_signature in a few ways.
416    For example, there is no support for expiring backsigs since it is
417    questionable what such a thing actually means.  Note also that the
418    sig cache check here, unlike other sig caches in GnuPG, is not
419    persistent. */
420 int
421 check_backsig(PKT_public_key *main_pk,PKT_public_key *sub_pk,
422               PKT_signature *backsig)
423 {
424   MD_HANDLE md;
425   int rc;
426
427   if(!opt.no_sig_cache && backsig->flags.checked)
428     {
429       if((rc=check_digest_algo(backsig->digest_algo)))
430         return rc;
431
432       return backsig->flags.valid? 0 : G10ERR_BAD_SIGN;
433     }
434
435   md=md_open(backsig->digest_algo,0);
436   hash_public_key(md,main_pk);
437   hash_public_key(md,sub_pk);
438   rc=do_check(sub_pk,backsig,md,NULL,NULL,NULL);
439   cache_sig_result(backsig,rc);
440   md_close(md);
441
442   return rc;
443 }
444
445
446 /****************
447  * check the signature pointed to by NODE. This is a key signature.
448  * If the function detects a self-signature, it uses the PK from
449  * ROOT and does not read any public key.
450  */
451 int
452 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
453 {
454   return check_key_signature2(root, node, NULL, NULL, is_selfsig, NULL, NULL );
455 }
456
457 /* If check_pk is set, then use it to check the signature in node
458    rather than getting it from root or the keydb.  If ret_pk is set,
459    fill in the public key that was used to verify the signature.
460    ret_pk is only meaningful when the verification was successful. */
461 /* TODO: add r_revoked here as well.  It has the same problems as
462    r_expiredate and r_expired and the cache. */
463 int
464 check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
465                       PKT_public_key *ret_pk, int *is_selfsig,
466                       u32 *r_expiredate, int *r_expired )
467 {
468     MD_HANDLE md;
469     PKT_public_key *pk;
470     PKT_signature *sig;
471     int algo;
472     int rc;
473
474     if( is_selfsig )
475         *is_selfsig = 0;
476     if( r_expiredate )
477         *r_expiredate = 0;
478     if( r_expired )
479         *r_expired = 0;
480     assert( node->pkt->pkttype == PKT_SIGNATURE );
481     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
482
483     pk = root->pkt->pkt.public_key;
484     sig = node->pkt->pkt.signature;
485     algo = sig->digest_algo;
486
487     /* Check whether we have cached the result of a previous signature
488        check.  Note that we may no longer have the pubkey or hash
489        needed to verify a sig, but can still use the cached value.  A
490        cache refresh detects and clears these cases. */
491     if ( !opt.no_sig_cache ) {
492         if (sig->flags.checked) { /*cached status available*/
493             if( is_selfsig ) {  
494                 u32 keyid[2];   
495
496                 keyid_from_pk( pk, keyid );
497                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
498                     *is_selfsig = 1;
499             }
500             /* BUG: This is wrong for non-self-sigs.. needs to be the
501                actual pk */
502             if((rc=do_check_messages(pk,sig,r_expired,NULL)))
503               return rc;
504             return sig->flags.valid? 0 : G10ERR_BAD_SIGN;
505         }
506     }
507
508     if( (rc=check_pubkey_algo(sig->pubkey_algo)) )
509         return rc;
510     if( (rc=check_digest_algo(algo)) )
511         return rc;
512
513     if( sig->sig_class == 0x20 ) { /* key revocation */
514         u32 keyid[2];   
515         keyid_from_pk( pk, keyid );
516
517         /* is it a designated revoker? */
518         if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
519           rc=check_revocation_keys(pk,sig);
520         else
521           {
522             md = md_open( algo, 0 );
523             hash_public_key( md, pk );
524             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
525             cache_sig_result ( sig, rc );
526             md_close(md);
527           }
528     }
529     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
530         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
531
532         if( snode ) {
533             md = md_open( algo, 0 );
534             hash_public_key( md, pk );
535             hash_public_key( md, snode->pkt->pkt.public_key );
536             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
537             cache_sig_result ( sig, rc );
538             md_close(md);
539         }
540         else
541           {
542             if (opt.verbose)
543               log_info (_("key %s: no subkey for subkey"
544                           " revocation signature\n"),keystr_from_pk(pk));
545             rc = G10ERR_SIG_CLASS;
546           }
547     }
548     else if( sig->sig_class == 0x18 ) { /* key binding */
549         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
550
551         if( snode ) {
552             if( is_selfsig ) {  /* does this make sense????? */
553                 u32 keyid[2];   /* it should always be a selfsig */
554
555                 keyid_from_pk( pk, keyid );
556                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
557                     *is_selfsig = 1;
558             }
559             md = md_open( algo, 0 );
560             hash_public_key( md, pk );
561             hash_public_key( md, snode->pkt->pkt.public_key );
562             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
563             cache_sig_result ( sig, rc );
564             md_close(md);
565         }
566         else
567           {
568             if (opt.verbose)
569               log_info(_("key %s: no subkey for subkey"
570                          " binding signature\n"),keystr_from_pk(pk));
571             rc = G10ERR_SIG_CLASS;
572           }
573     }
574     else if( sig->sig_class == 0x1f ) { /* direct key signature */
575         md = md_open( algo, 0 );
576         hash_public_key( md, pk );
577         rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
578         cache_sig_result ( sig, rc );
579         md_close(md);
580     }
581     else { /* all other classes */
582         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
583
584         if( unode ) {
585             u32 keyid[2];
586
587             keyid_from_pk( pk, keyid );
588             md = md_open( algo, 0 );
589             hash_public_key( md, pk );
590             hash_uid_node( unode, md, sig );
591             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
592               {
593                 if( is_selfsig )
594                   *is_selfsig = 1;
595                 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
596               }
597             else if (check_pk)
598               rc=do_check(check_pk,sig,md,r_expired,NULL,ret_pk);
599             else
600               rc=signature_check2(sig,md,r_expiredate,r_expired,NULL,ret_pk);
601
602             cache_sig_result ( sig, rc );
603             md_close(md);
604         }
605         else
606           {
607             if (!opt.quiet)
608               log_info ("key %s: no user ID for key signature packet"
609                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
610             rc = G10ERR_SIG_CLASS;
611           }
612     }
613
614     return rc;
615 }