* sig-check.c (cmp_help, do_check), sign.c (do_sign): Remove old unused
[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
324 /* Check the revocation keys to see if any of them have revoked our
325    pk.  sig is the revocation sig.  pk is the key it is on.  This code
326    will need to be modified if gpg ever becomes multi-threaded.  Note
327    that this guarantees that a designated revocation sig will never be
328    considered valid unless it is actually valid, as well as being
329    issued by a revocation key in a valid direct signature.  Note that
330    this is written so that a revoked revoker can still issue
331    revocations: i.e. If A revokes B, but A is revoked, B is still
332    revoked.  I'm not completely convinced this is the proper behavior,
333    but it matches how PGP does it. -dms */
334
335 /* Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
336    revoked */
337 int
338 check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
339 {
340   static int busy=0;
341   int i,rc=G10ERR_GENERAL;
342
343   assert(IS_KEY_REV(sig));
344   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
345
346   if(busy)
347     {
348       /* return -1 (i.e. not revoked), but mark the pk as uncacheable
349          as we don't really know its revocation status until it is
350          checked directly. */
351
352       pk->dont_cache=1;
353       return rc;
354     }
355
356   busy=1;
357
358   /*  printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
359       (ulong)sig->keyid[1]); */
360
361   /* is the issuer of the sig one of our revokers? */
362   if( !pk->revkey && pk->numrevkeys )
363      BUG();
364   else
365       for(i=0;i<pk->numrevkeys;i++)
366         {
367           u32 keyid[2];
368     
369           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
370     
371           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
372             {
373               MD_HANDLE md;
374     
375               md=md_open(sig->digest_algo,0);
376               hash_public_key(md,pk);
377               rc=signature_check(sig,md);
378               cache_sig_result(sig,rc);
379               break;
380             }
381         }
382
383   busy=0;
384
385   return rc;
386
387
388 /****************
389  * check the signature pointed to by NODE. This is a key signature.
390  * If the function detects a self-signature, it uses the PK from
391  * ROOT and does not read any public key.
392  */
393 int
394 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
395 {
396   return check_key_signature2(root, node, NULL, NULL, is_selfsig, NULL, NULL );
397 }
398
399 /* If check_pk is set, then use it to check the signature in node
400    rather than getting it from root or the keydb.  If ret_pk is set,
401    fill in the public key that was used to verify the signature.
402    ret_pk is only meaningful when the verification was successful. */
403 /* TODO: add r_revoked here as well.  It has the same problems as
404    r_expiredate and r_expired and the cache. */
405 int
406 check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
407                       PKT_public_key *ret_pk, int *is_selfsig,
408                       u32 *r_expiredate, int *r_expired )
409 {
410     MD_HANDLE md;
411     PKT_public_key *pk;
412     PKT_signature *sig;
413     int algo;
414     int rc;
415
416     if( is_selfsig )
417         *is_selfsig = 0;
418     if( r_expiredate )
419         *r_expiredate = 0;
420     if( r_expired )
421         *r_expired = 0;
422     assert( node->pkt->pkttype == PKT_SIGNATURE );
423     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
424
425     pk = root->pkt->pkt.public_key;
426     sig = node->pkt->pkt.signature;
427     algo = sig->digest_algo;
428
429     /* check whether we have cached the result of a previous signature check.*/
430     if ( !opt.no_sig_cache ) {
431         if (sig->flags.checked) { /*cached status available*/
432             if( is_selfsig ) {  
433                 u32 keyid[2];   
434
435                 keyid_from_pk( pk, keyid );
436                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
437                     *is_selfsig = 1;
438             }
439             /* BUG: This is wrong for non-self-sigs.. needs to be the
440                actual pk */
441             if((rc=do_check_messages(pk,sig,r_expired,NULL)))
442               return rc;
443             return sig->flags.valid? 0 : G10ERR_BAD_SIGN;
444         }
445     }
446
447     if( (rc=check_pubkey_algo(sig->pubkey_algo)) )
448         return rc;
449     if( (rc=check_digest_algo(algo)) )
450         return rc;
451
452     if( sig->sig_class == 0x20 ) { /* key revocation */
453         u32 keyid[2];   
454         keyid_from_pk( pk, keyid );
455
456         /* is it a designated revoker? */
457         if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
458           rc=check_revocation_keys(pk,sig);
459         else
460           {
461             md = md_open( algo, 0 );
462             hash_public_key( md, pk );
463             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
464             cache_sig_result ( sig, rc );
465             md_close(md);
466           }
467     }
468     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
469         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
470
471         if( snode ) {
472             md = md_open( algo, 0 );
473             hash_public_key( md, pk );
474             hash_public_key( md, snode->pkt->pkt.public_key );
475             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
476             cache_sig_result ( sig, rc );
477             md_close(md);
478         }
479         else {
480             if (opt.verbose)
481                 log_info (_("key %08lX: no subkey for subkey "
482                             "revocation signature\n"),
483                           (ulong)keyid_from_pk (pk, NULL));
484             rc = G10ERR_SIG_CLASS;
485         }
486     }
487     else if( sig->sig_class == 0x18 ) { /* key binding */
488         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
489
490         if( snode ) {
491             if( is_selfsig ) {  /* does this make sense????? */
492                 u32 keyid[2];   /* it should always be a selfsig */
493
494                 keyid_from_pk( pk, keyid );
495                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
496                     *is_selfsig = 1;
497             }
498             md = md_open( algo, 0 );
499             hash_public_key( md, pk );
500             hash_public_key( md, snode->pkt->pkt.public_key );
501             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
502             cache_sig_result ( sig, rc );
503             md_close(md);
504         }
505         else {
506             if (opt.verbose)
507                 log_info(_("key %08lX: no subkey for subkey "
508                            "binding signature\n"),
509                          (ulong)keyid_from_pk (pk, NULL));
510             rc = G10ERR_SIG_CLASS;
511         }
512     }
513     else if( sig->sig_class == 0x1f ) { /* direct key signature */
514         md = md_open( algo, 0 );
515         hash_public_key( md, pk );
516         rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
517         cache_sig_result ( sig, rc );
518         md_close(md);
519     }
520     else { /* all other classes */
521         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
522
523         if( unode ) {
524             u32 keyid[2];
525
526             keyid_from_pk( pk, keyid );
527             md = md_open( algo, 0 );
528             hash_public_key( md, pk );
529             hash_uid_node( unode, md, sig );
530             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
531               {
532                 if( is_selfsig )
533                   *is_selfsig = 1;
534                 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
535               }
536             else if (check_pk)
537               rc=do_check(check_pk,sig,md,r_expired,NULL,ret_pk);
538             else
539               rc=signature_check2(sig,md,r_expiredate,r_expired,NULL,ret_pk);
540
541             cache_sig_result ( sig, rc );
542             md_close(md);
543         }
544         else {
545             if (!opt.quiet)
546                 log_info ("key %08lX: no user ID for key signature packet "
547                           "of class %02x\n",
548                           (ulong)keyid_from_pk (pk, NULL), sig->sig_class );
549             rc = G10ERR_SIG_CLASS;
550         }
551     }
552
553     return rc;
554 }