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