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