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