* keygen.c (do_add_key_flags): Don't set the certify flag for subkeys.
[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     return signature_check2( sig, digest, NULL, NULL, NULL );
54 }
55
56 int
57 signature_check2( PKT_signature *sig, MD_HANDLE digest, u32 *r_expiredate, 
58                   int *r_expired, PKT_public_key *ret_pk )
59 {
60     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
61     int rc=0;
62
63     /* Sanity check that the md has a context for the hash that the
64        sig is expecting.  This can happen if a onepass sig header does
65        not match the actual sig, and also if the clearsign "Hash:"
66        header is missing or does not match the actual sig. */
67
68     if(!md_algo_present(digest,sig->digest_algo)) {
69         log_info(_("WARNING: signature digest conflict in message\n"));
70         rc=G10ERR_GENERAL;
71     }
72     else if( get_pubkey( pk, sig->keyid ) )
73         rc = G10ERR_NO_PUBKEY;
74     else if(!pk->is_valid && !pk->is_primary)
75         rc=G10ERR_BAD_PUBKEY; /* you cannot have a good sig from an
76                                  invalid subkey */
77     else {
78         if(r_expiredate)
79           *r_expiredate = pk->expiredate;
80         rc = do_check( pk, sig, digest, r_expired, ret_pk );
81     }
82
83     free_public_key( pk );
84
85     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
86         /* This signature id works best with DLP algorithms because
87          * they use a random parameter for every signature.  Instead of
88          * this sig-id we could have also used the hash of the document
89          * and the timestamp, but the drawback of this is, that it is
90          * not possible to sign more than one identical document within
91          * one second.  Some remote batch processing applications might
92          * like this feature here */
93         MD_HANDLE md;
94         u32 a = sig->timestamp;
95         int i, nsig = pubkey_get_nsig( sig->pubkey_algo );
96         byte *p, *buffer;
97
98         md = md_open( DIGEST_ALGO_RMD160, 0);
99         md_putc( digest, sig->pubkey_algo );
100         md_putc( digest, sig->digest_algo );
101         md_putc( digest, (a >> 24) & 0xff );
102         md_putc( digest, (a >> 16) & 0xff );
103         md_putc( digest, (a >>  8) & 0xff );
104         md_putc( digest,  a        & 0xff );
105         for(i=0; i < nsig; i++ ) {
106             unsigned n = mpi_get_nbits( sig->data[i]);
107
108             md_putc( md, n>>8);
109             md_putc( md, n );
110             p = mpi_get_buffer( sig->data[i], &n, NULL );
111             md_write( md, p, n );
112             m_free(p);
113         }
114         md_final( md );
115         p = make_radix64_string( md_read( md, 0 ), 20 );
116         buffer = m_alloc( strlen(p) + 60 );
117         sprintf( buffer, "%s %s %lu",
118                  p, strtimestamp( sig->timestamp ), (ulong)sig->timestamp );
119         write_status_text( STATUS_SIG_ID, buffer );
120         m_free(buffer);
121         m_free(p);
122         md_close(md);
123     }
124
125     return rc;
126 }
127
128
129 /****************
130  * This function gets called by pubkey_verify() if the algorithm needs it.
131  */
132 static int
133 cmp_help( void *opaque, MPI result )
134 {
135 #if 0 /* we do not use this anymore */
136     int rc=0, i, j, c, old_enc;
137     byte *dp;
138     const byte *asn;
139     size_t mdlen, asnlen;
140     struct cmp_help_context_s *ctx = opaque;
141     PKT_signature *sig = ctx->sig;
142     MD_HANDLE digest = ctx->md;
143
144     old_enc = 0;
145     for(i=j=0; (c=mpi_getbyte(result, i)) != -1; i++ ) {
146         if( !j ) {
147             if( !i && c != 1 )
148                 break;
149             else if( i && c == 0xff )
150                 ; /* skip the padding */
151             else if( i && !c )
152                 j++;
153             else
154                 break;
155         }
156         else if( ++j == 18 && c != 1 )
157             break;
158         else if( j == 19 && c == 0 ) {
159             old_enc++;
160             break;
161         }
162     }
163     if( old_enc ) {
164         log_error("old encoding scheme is not supported\n");
165         return G10ERR_GENERAL;
166     }
167
168     if( (rc=check_digest_algo(sig->digest_algo)) )
169         return rc; /* unsupported algo */
170     asn = md_asn_oid( sig->digest_algo, &asnlen, &mdlen );
171
172     for(i=mdlen,j=asnlen-1; (c=mpi_getbyte(result, i)) != -1 && j >= 0;
173                                                            i++, j-- )
174         if( asn[j] != c )
175             break;
176     if( j != -1 || mpi_getbyte(result, i) )
177         return G10ERR_BAD_PUBKEY;  /* ASN is wrong */
178     for(i++; (c=mpi_getbyte(result, i)) != -1; i++ )
179         if( c != 0xff  )
180             break;
181     i++;
182     if( c != sig->digest_algo || mpi_getbyte(result, i) ) {
183         /* Padding or leading bytes in signature is wrong */
184         return G10ERR_BAD_PUBKEY;
185     }
186     if( mpi_getbyte(result, mdlen-1) != sig->digest_start[0]
187         || mpi_getbyte(result, mdlen-2) != sig->digest_start[1] ) {
188         /* Wrong key used to check the signature */
189         return G10ERR_BAD_PUBKEY;
190     }
191
192     dp = md_read( digest, sig->digest_algo );
193     for(i=mdlen-1; i >= 0; i--, dp++ ) {
194         if( mpi_getbyte( result, i ) != *dp )
195             return G10ERR_BAD_SIGN;
196     }
197     return 0;
198 #else
199     return -1;
200 #endif
201 }
202
203 static int
204 do_check_messages( PKT_public_key *pk, PKT_signature *sig, int *r_expired )
205 {
206     u32 cur_time;
207
208     if(r_expired)
209       *r_expired = 0;
210     if( pk->version == 4 && pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E ) {
211         log_info(_("key %08lX: this is a PGP generated "
212                    "ElGamal key which is NOT secure for signatures!\n"),
213                   (ulong)keyid_from_pk(pk,NULL));
214         return G10ERR_PUBKEY_ALGO;
215     }
216
217     if( pk->timestamp > sig->timestamp ) {
218         ulong d = pk->timestamp - sig->timestamp;
219         log_info( d==1
220              ? _("public key %08lX is %lu second newer than the signature\n")
221              : _("public key %08lX is %lu seconds newer than the signature\n"),
222                 (ulong)keyid_from_pk(pk,NULL),d );
223         if( !opt.ignore_time_conflict )
224             return G10ERR_TIME_CONFLICT; /* pubkey newer than signature */
225     }
226
227     cur_time = make_timestamp();
228     if( pk->timestamp > cur_time ) {
229         ulong d = pk->timestamp - cur_time;
230         log_info( d==1 ? _("key %08lX has been created %lu second "
231                            "in future (time warp or clock problem)\n")
232                        : _("key %08lX has been created %lu seconds "
233                            "in future (time warp or clock problem)\n"),
234                        (ulong)keyid_from_pk(pk,NULL),d );
235         if( !opt.ignore_time_conflict )
236             return G10ERR_TIME_CONFLICT;
237     }
238
239     if( pk->expiredate && pk->expiredate < cur_time ) {
240         char buf[11];
241         if (opt.verbose) {
242             u32 tmp_kid[2];
243
244             keyid_from_pk( pk, tmp_kid );
245             log_info(_("NOTE: signature key %08lX expired %s\n"),
246                      (ulong)tmp_kid[1], asctimestamp( pk->expiredate ) );
247         }
248         /* SIGEXPIRED is deprecated.  Use KEYEXPIRED. */
249         sprintf(buf,"%lu",(ulong)pk->expiredate);
250         write_status_text(STATUS_KEYEXPIRED,buf);
251         write_status(STATUS_SIGEXPIRED);
252         if(r_expired)
253           *r_expired = 1;
254     }
255
256     return 0;
257 }
258
259
260 static int
261 do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
262           int *r_expired, PKT_public_key *ret_pk )
263 {
264     MPI result = NULL;
265     int rc=0;
266     struct cmp_help_context_s ctx;
267
268     if( (rc=do_check_messages(pk,sig,r_expired)) )
269         return rc;
270     if( (rc=check_digest_algo(sig->digest_algo)) )
271         return rc;
272     if( (rc=check_pubkey_algo(sig->pubkey_algo)) )
273         return rc;
274
275     /* make sure the digest algo is enabled (in case of a detached signature)*/
276     md_enable( digest, sig->digest_algo );
277
278     /* complete the digest */
279     if( sig->version >= 4 )
280         md_putc( digest, sig->version );
281     md_putc( digest, sig->sig_class );
282     if( sig->version < 4 ) {
283         u32 a = sig->timestamp;
284         md_putc( digest, (a >> 24) & 0xff );
285         md_putc( digest, (a >> 16) & 0xff );
286         md_putc( digest, (a >>  8) & 0xff );
287         md_putc( digest,  a        & 0xff );
288     }
289     else {
290         byte buf[6];
291         size_t n;
292         md_putc( digest, sig->pubkey_algo );
293         md_putc( digest, sig->digest_algo );
294         if( sig->hashed ) {
295             n = sig->hashed->len;
296             md_putc (digest, (n >> 8) );
297             md_putc (digest,  n       );
298             md_write (digest, sig->hashed->data, n);
299             n += 6;
300         }
301         else {
302           /* Two octets for the (empty) length of the hashed
303              section. */
304           md_putc (digest, 0);
305           md_putc (digest, 0);
306           n = 6;
307         }
308         /* add some magic */
309         buf[0] = sig->version;
310         buf[1] = 0xff;
311         buf[2] = n >> 24;
312         buf[3] = n >> 16;
313         buf[4] = n >>  8;
314         buf[5] = n;
315         md_write( digest, buf, 6 );
316     }
317     md_final( digest );
318
319     result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
320                               mpi_get_nbits(pk->pkey[0]), 0 );
321     if (!result)
322         return G10ERR_GENERAL;
323     ctx.sig = sig;
324     ctx.md = digest;
325     rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
326                         cmp_help, &ctx );
327     mpi_free( result );
328     if( (opt.emulate_bugs & EMUBUG_MDENCODE)
329         && rc == G10ERR_BAD_SIGN && is_ELGAMAL(pk->pubkey_algo) ) {
330         /* In this case we try again because old GnuPG versions didn't encode
331          * the hash right. There is no problem with DSA however  */
332         result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
333                               mpi_get_nbits(pk->pkey[0]), (sig->version < 5) );
334         if (!result)
335             rc = G10ERR_GENERAL;
336         else {
337             ctx.sig = sig;
338             ctx.md = digest;
339             rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
340                                 cmp_help, &ctx );
341         }
342     }
343
344     if( !rc && sig->flags.unknown_critical ) {
345       log_info(_("assuming bad signature from key %08lX due to an unknown critical bit\n"),(ulong)keyid_from_pk(pk,NULL));
346         rc = G10ERR_BAD_SIGN;
347     }
348
349     if(!rc && ret_pk)
350       copy_public_key(ret_pk,pk);
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   return check_key_signature2(root, node, NULL, NULL, is_selfsig, NULL, NULL );
479 }
480
481 /* If check_pk is set, then use it to check the signature in node
482    rather than getting it from root or the keydb.  If ret_pk is set,
483    fill in the public key that was used to verify the signature.
484    ret_pk is only meaningful when the verification was successful. */
485 int
486 check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
487                       PKT_public_key *ret_pk, int *is_selfsig,
488                       u32 *r_expiredate, int *r_expired )
489 {
490     MD_HANDLE md;
491     PKT_public_key *pk;
492     PKT_signature *sig;
493     int algo;
494     int rc;
495
496     if( is_selfsig )
497         *is_selfsig = 0;
498     if( r_expiredate )
499         *r_expiredate = 0;
500     if( r_expired )
501         *r_expired = 0;
502     assert( node->pkt->pkttype == PKT_SIGNATURE );
503     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
504
505     pk = root->pkt->pkt.public_key;
506     sig = node->pkt->pkt.signature;
507     algo = sig->digest_algo;
508
509     /* check whether we have cached the result of a previous signature check.*/
510     if ( !opt.no_sig_cache ) {
511         if (sig->flags.checked) { /*cached status available*/
512             if( is_selfsig ) {  
513                 u32 keyid[2];   
514
515                 keyid_from_pk( pk, keyid );
516                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
517                     *is_selfsig = 1;
518             }
519             /* TODO: should set r_expiredate here as well */
520             if((rc=do_check_messages(pk,sig,r_expired)))
521               return rc;
522             return sig->flags.valid? 0 : G10ERR_BAD_SIGN;
523         }
524     }
525
526     if( (rc=check_digest_algo(algo)) )
527         return rc;
528
529     if( sig->sig_class == 0x20 ) { /* key revocation */
530         u32 keyid[2];   
531         keyid_from_pk( pk, keyid );
532
533         /* is it a designated revoker? */
534         if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
535           rc=check_revocation_keys(pk,sig);
536         else
537           {
538             md = md_open( algo, 0 );
539             hash_public_key( md, pk );
540             rc = do_check( pk, sig, md, r_expired, ret_pk );
541             cache_sig_result ( sig, rc );
542             md_close(md);
543           }
544     }
545     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
546         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
547
548         if( snode ) {
549             md = md_open( algo, 0 );
550             hash_public_key( md, pk );
551             hash_public_key( md, snode->pkt->pkt.public_key );
552             rc = do_check( pk, sig, md, r_expired, ret_pk );
553             cache_sig_result ( sig, rc );
554             md_close(md);
555         }
556         else {
557             if (!opt.quiet)
558                 log_info (_("key %08lX: no subkey for subkey "
559                             "revocation signature\n"),
560                           (ulong)keyid_from_pk (pk, NULL));
561             rc = G10ERR_SIG_CLASS;
562         }
563     }
564     else if( sig->sig_class == 0x18 ) { /* key binding */
565         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
566
567         if( snode ) {
568             if( is_selfsig ) {  /* does this make sense????? */
569                 u32 keyid[2];   /* it should always be a selfsig */
570
571                 keyid_from_pk( pk, keyid );
572                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
573                     *is_selfsig = 1;
574             }
575             md = md_open( algo, 0 );
576             hash_public_key( md, pk );
577             hash_public_key( md, snode->pkt->pkt.public_key );
578             rc = do_check( pk, sig, md, r_expired, ret_pk );
579             cache_sig_result ( sig, rc );
580             md_close(md);
581         }
582         else {
583             if (opt.verbose)
584                 log_info(_("key %08lX: no subkey for subkey "
585                            "binding signature\n"),
586                          (ulong)keyid_from_pk (pk, NULL));
587             rc = G10ERR_SIG_CLASS;
588         }
589     }
590     else if( sig->sig_class == 0x1f ) { /* direct key signature */
591         md = md_open( algo, 0 );
592         hash_public_key( md, pk );
593         rc = do_check( pk, sig, md, r_expired, ret_pk );
594         cache_sig_result ( sig, rc );
595         md_close(md);
596     }
597     else { /* all other classes */
598         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
599
600         if( unode ) {
601             u32 keyid[2];
602
603             keyid_from_pk( pk, keyid );
604             md = md_open( algo, 0 );
605             hash_public_key( md, pk );
606             hash_uid_node( unode, md, sig );
607             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
608               {
609                 if( is_selfsig )
610                   *is_selfsig = 1;
611                 rc = do_check( pk, sig, md, r_expired, ret_pk );
612               }
613             else if (check_pk)
614               rc=do_check(check_pk,sig,md,r_expired, ret_pk);
615             else
616               rc = signature_check2( sig, md, r_expiredate, r_expired, ret_pk);
617
618             cache_sig_result ( sig, rc );
619             md_close(md);
620         }
621         else {
622             if (!opt.quiet)
623                 log_info ("key %08lX: no user ID for key signature packet "
624                           "of class %02x\n",
625                           (ulong)keyid_from_pk (pk, NULL), sig->sig_class );
626             rc = G10ERR_SIG_CLASS;
627         }
628     }
629
630     return rc;
631 }