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