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