Adjusted for use with current libgcrypt (1.1.42).
[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
28 #include "gpg.h"
29 #include "util.h"
30 #include "packet.h"
31 #include "memory.h"
32 #include "mpi.h"
33 #include "keydb.h"
34 #include "cipher.h"
35 #include "main.h"
36 #include "status.h"
37 #include "i18n.h"
38 #include "options.h"
39 #include "pkglue.h"
40
41 struct cmp_help_context_s {
42     PKT_signature *sig;
43     MD_HANDLE md;
44 };
45
46 static int do_check( PKT_public_key *pk, PKT_signature *sig,
47                                          MD_HANDLE digest, int *r_expired );
48
49 /****************
50  * Check the signature which is contained in SIG.
51  * The MD_HANDLE should be currently open, so that this function
52  * is able to append some data, before finalizing the digest.
53  */
54 int
55 signature_check( PKT_signature *sig, MD_HANDLE digest )
56 {
57     u32 dummy;
58     int dum2;
59     return signature_check2( sig, digest, &dummy, &dum2 );
60 }
61
62 int
63 signature_check2( PKT_signature *sig, MD_HANDLE digest,
64                   u32 *r_expiredate, int *r_expired )
65 {
66     PKT_public_key *pk = xcalloc (1, sizeof *pk );
67     int rc=0;
68
69     *r_expiredate = 0;
70
71     /* Sanity check that the md has a context for the hash that the
72        sig is expecting.  This can happen if a onepass sig header does
73        not match the actual sig, and also if the clearsign "Hash:"
74        header is missing or does not match the actual sig. */
75
76     if(!gcry_md_is_enabled (digest,sig->digest_algo)) {
77         log_info(_("WARNING: signature digest conflict in message\n"));
78         rc=GPG_ERR_GENERAL;
79     }
80     else if( get_pubkey( pk, sig->keyid ) )
81         rc = GPG_ERR_NO_PUBKEY;
82     else if(!pk->is_valid && !pk->is_primary)
83         rc=GPG_ERR_BAD_PUBKEY; /* you cannot have a good sig from an
84                                  invalid subkey */
85     else {
86         *r_expiredate = pk->expiredate;
87         rc = do_check( pk, sig, digest, r_expired );
88     }
89
90     free_public_key( pk );
91
92     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
93         /* This signature id works best with DLP algorithms because
94          * they use a random parameter for every signature.  Instead of
95          * this sig-id we could have also used the hash of the document
96          * and the timestamp, but the drawback of this is, that it is
97          * not possible to sign more than one identical document within
98          * one second.  Some remote batch processing applications might
99          * like this feature here */
100         gcry_md_hd_t md;
101         u32 a = sig->timestamp;
102         int i, nsig = pubkey_get_nsig( sig->pubkey_algo );
103         byte *p, *buffer;
104
105         gcry_md_open (&md, GCRY_MD_RMD160, 0);
106         gcry_md_putc( digest, sig->pubkey_algo );
107         gcry_md_putc( digest, sig->digest_algo );
108         gcry_md_putc( digest, (a >> 24) & 0xff );
109         gcry_md_putc( digest, (a >> 16) & 0xff );
110         gcry_md_putc( digest, (a >>  8) & 0xff );
111         gcry_md_putc( digest,  a        & 0xff );
112         for(i=0; i < nsig; i++ ) {
113             size_t n;
114             unsigned char *tmp;
115
116             if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &tmp, &n, sig->data[i]))
117                 BUG();
118             
119             gcry_md_write (md, tmp, n);
120             xfree (tmp);
121         }
122         gcry_md_final( md );
123         p = make_radix64_string( gcry_md_read( md, 0 ), 20 );
124         buffer = xmalloc ( strlen(p) + 60 );
125         sprintf( buffer, "%s %s %lu",
126                  p, strtimestamp( sig->timestamp ), (ulong)sig->timestamp );
127         write_status_text( STATUS_SIG_ID, buffer );
128         xfree (buffer);
129         xfree (p);
130         gcry_md_close(md);
131     }
132
133     return rc;
134 }
135
136
137 static int
138 do_check_messages( PKT_public_key *pk, PKT_signature *sig, int *r_expired )
139 {
140     u32 cur_time;
141
142     *r_expired = 0;
143     if( pk->version == 4 && pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E ) {
144         log_info(_("key %08lX: this is a PGP generated "
145                    "ElGamal key which is NOT secure for signatures!\n"),
146                   (ulong)keyid_from_pk(pk,NULL));
147         return GPG_ERR_PUBKEY_ALGO;
148     }
149
150     if( pk->timestamp > sig->timestamp ) {
151         ulong d = pk->timestamp - sig->timestamp;
152         log_info( d==1
153              ? _("public key %08lX is %lu second newer than the signature\n")
154              : _("public key %08lX is %lu seconds newer than the signature\n"),
155                 (ulong)keyid_from_pk(pk,NULL),d );
156         if( !opt.ignore_time_conflict )
157             return GPG_ERR_TIME_CONFLICT; /* pubkey newer than signature */
158     }
159
160     cur_time = make_timestamp();
161     if( pk->timestamp > cur_time ) {
162         ulong d = pk->timestamp - cur_time;
163         log_info( d==1 ? _("key %08lX has been created %lu second "
164                            "in future (time warp or clock problem)\n")
165                        : _("key %08lX has been created %lu seconds "
166                            "in future (time warp or clock problem)\n"),
167                        (ulong)keyid_from_pk(pk,NULL),d );
168         if( !opt.ignore_time_conflict )
169             return GPG_ERR_TIME_CONFLICT;
170     }
171
172     if( pk->expiredate && pk->expiredate < cur_time ) {
173         char buf[11];
174         if (opt.verbose) {
175             u32 tmp_kid[2];
176
177             keyid_from_pk( pk, tmp_kid );
178             log_info(_("NOTE: signature key %08lX expired %s\n"),
179                      (ulong)tmp_kid[1], asctimestamp( pk->expiredate ) );
180         }
181         /* SIGEXPIRED is deprecated.  Use KEYEXPIRED. */
182         sprintf(buf,"%lu",(ulong)pk->expiredate);
183         write_status_text(STATUS_KEYEXPIRED,buf);
184         write_status(STATUS_SIGEXPIRED);
185         *r_expired = 1;
186     }
187
188     return 0;
189 }
190
191
192 static int
193 do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
194                                                     int *r_expired )
195 {
196     gcry_mpi_t result = NULL;
197     int rc=0;
198     struct cmp_help_context_s ctx;
199
200     if( (rc=do_check_messages(pk,sig,r_expired)) )
201         return rc;
202     if( (rc=gcry_md_test_algo(sig->digest_algo)) )
203         return rc;
204     if( (rc=gcry_pk_test_algo(sig->pubkey_algo)) )
205         return rc;
206
207     /* make sure the digest algo is enabled (in case of a detached
208        signature)*/
209     gcry_md_enable( digest, sig->digest_algo );
210
211     /* complete the digest */
212     if( sig->version >= 4 )
213         gcry_md_putc( digest, sig->version );
214     gcry_md_putc( digest, sig->sig_class );
215     if( sig->version < 4 ) {
216         u32 a = sig->timestamp;
217         gcry_md_putc( digest, (a >> 24) & 0xff );
218         gcry_md_putc( digest, (a >> 16) & 0xff );
219         gcry_md_putc( digest, (a >>     8) & 0xff );
220         gcry_md_putc( digest,  a           & 0xff );
221     }
222     else {
223         byte buf[6];
224         size_t n;
225         gcry_md_putc( digest, sig->pubkey_algo );
226         gcry_md_putc( digest, sig->digest_algo );
227         if( sig->hashed ) {
228             n = sig->hashed->len;
229             gcry_md_putc (digest, (n >> 8) );
230             gcry_md_putc (digest,  n       );
231             gcry_md_write (digest, sig->hashed->data, n);
232             n += 6;
233         }
234         else {
235           /* Two octets for the (empty) length of the hashed
236              section. */
237           gcry_md_putc (digest, 0);
238           gcry_md_putc (digest, 0);
239           n = 6;
240         }
241         /* add some magic */
242         buf[0] = sig->version;
243         buf[1] = 0xff;
244         buf[2] = n >> 24;
245         buf[3] = n >> 16;
246         buf[4] = n >>  8;
247         buf[5] = n;
248         gcry_md_write( digest, buf, 6 );
249     }
250     gcry_md_final (digest);
251
252     result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
253                               mpi_get_nbits(pk->pkey[0]), 0 );
254     if (!result)
255         return GPG_ERR_GENERAL;
256     ctx.sig = sig;
257     ctx.md = digest;
258     rc = pk_verify ( pk->pubkey_algo, result, sig->data, pk->pkey);
259     gcry_mpi_release ( result );
260     if( (opt.emulate_bugs & EMUBUG_MDENCODE)
261         && gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE
262         && is_ELGAMAL(pk->pubkey_algo) ) {
263         /* In this case we try again because old GnuPG versions didn't encode
264          * the hash right. There is no problem with DSA however  */
265         result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
266                               mpi_get_nbits(pk->pkey[0]), (sig->version < 5) );
267         if (!result)
268             rc = GPG_ERR_GENERAL;
269         else {
270             ctx.sig = sig;
271             ctx.md = digest;
272             rc = pk_verify (pk->pubkey_algo, result, sig->data, pk->pkey);
273         }
274     }
275
276     if( !rc && sig->flags.unknown_critical ) {
277       log_info(_("assuming bad signature from key %08lX "
278                  "due to an unknown critical bit\n"),
279                (ulong)keyid_from_pk(pk,NULL));
280         rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
281     }
282
283     return rc;
284 }
285
286
287 static void
288 hash_uid_node( KBNODE unode, MD_HANDLE md, PKT_signature *sig )
289 {
290     PKT_user_id *uid = unode->pkt->pkt.user_id;
291
292     assert( unode->pkt->pkttype == PKT_USER_ID );
293     if( uid->attrib_data ) {
294         if( sig->version >=4 ) {
295             byte buf[5];
296             buf[0] = 0xd1;                   /* packet of type 17 */
297             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
298             buf[2] = uid->attrib_len >> 16;
299             buf[3] = uid->attrib_len >>  8;
300             buf[4] = uid->attrib_len;
301             gcry_md_write( md, buf, 5 );
302         }
303         gcry_md_write( md, uid->attrib_data, uid->attrib_len );
304     }
305     else {
306         if( sig->version >=4 ) {
307             byte buf[5];
308             buf[0] = 0xb4;            /* indicates a userid packet */
309             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
310             buf[2] = uid->len >> 16;
311             buf[3] = uid->len >>  8;
312             buf[4] = uid->len;
313             gcry_md_write( md, buf, 5 );
314         }
315         gcry_md_write( md, uid->name, uid->len );
316     }
317 }
318
319 static void
320 cache_sig_result ( PKT_signature *sig, int result )
321 {
322     if ( !result ) {
323         sig->flags.checked = 1;
324         sig->flags.valid = 1;
325     }
326     else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
327         sig->flags.checked = 1;
328         sig->flags.valid = 0;
329     }
330     else {
331         sig->flags.checked = 0;
332         sig->flags.valid = 0;
333     }
334 }
335
336
337 /* Check the revocation keys to see if any of them have revoked our
338    pk.  sig is the revocation sig.  pk is the key it is on.  This code
339    will need to be modified if gpg ever becomes multi-threaded.  Note
340    that this guarantees that a designated revocation sig will never be
341    considered valid unless it is actually valid, as well as being
342    issued by a revocation key in a valid direct signature.  Note that
343    this is written so that a revoked revoker can still issue
344    revocations: i.e. If A revokes B, but A is revoked, B is still
345    revoked.  I'm not completely convinced this is the proper behavior,
346    but it matches how PGP does it. -dms */
347
348 /* Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
349    revoked */
350 int
351 check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
352 {
353   static int busy=0;
354   int i,rc=GPG_ERR_GENERAL;
355
356   assert(IS_KEY_REV(sig));
357   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
358
359   if(busy)
360     {
361       /* return -1 (i.e. not revoked), but mark the pk as uncacheable
362          as we don't really know its revocation status until it is
363          checked directly. */
364
365       pk->dont_cache=1;
366       return rc;
367     }
368
369   busy=1;
370
371   /*  printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
372       (ulong)sig->keyid[1]); */
373
374   /* is the issuer of the sig one of our revokers? */
375   if( !pk->revkey && pk->numrevkeys )
376      BUG();
377   else
378       for(i=0;i<pk->numrevkeys;i++)
379         {
380           u32 keyid[2];
381     
382           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
383     
384           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
385             {
386               gcry_md_hd_t md;
387     
388               gcry_md_open (&md, sig->digest_algo,0);
389               hash_public_key(md,pk);
390               rc=signature_check(sig,md);
391               cache_sig_result(sig,rc);
392               break;
393             }
394         }
395
396   busy=0;
397
398   return rc;
399
400
401 /****************
402  * check the signature pointed to by NODE. This is a key signature.
403  * If the function detects a self-signature, it uses the PK from
404  * ROOT and does not read any public key.
405  */
406 int
407 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
408 {
409     u32 dummy;
410     int dum2;
411     return check_key_signature2(root, node, NULL, is_selfsig, &dummy, &dum2 );
412 }
413
414 /* If check_pk is set, then use it to check the signature in node
415    rather than getting it from root or the keydb. */
416 int
417 check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
418                       int *is_selfsig, u32 *r_expiredate, int *r_expired )
419 {
420     MD_HANDLE md;
421     PKT_public_key *pk;
422     PKT_signature *sig;
423     int algo;
424     int rc;
425
426     if( is_selfsig )
427         *is_selfsig = 0;
428     *r_expiredate = 0;
429     *r_expired = 0;
430     assert( node->pkt->pkttype == PKT_SIGNATURE );
431     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
432
433     pk = root->pkt->pkt.public_key;
434     sig = node->pkt->pkt.signature;
435     algo = sig->digest_algo;
436
437     /* check whether we have cached the result of a previous signature check.*/
438     if ( !opt.no_sig_cache ) {
439         if (sig->flags.checked) { /*cached status available*/
440             if( is_selfsig ) {  
441                 u32 keyid[2];   
442
443                 keyid_from_pk( pk, keyid );
444                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
445                     *is_selfsig = 1;
446             }
447             if((rc=do_check_messages(pk,sig,r_expired)))
448               return rc;
449             return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
450         }
451     }
452
453     if( (rc=gcry_md_test_algo(algo)) )
454       return rc;
455
456     if( sig->sig_class == 0x20 ) { /* key revocation */
457         u32 keyid[2];   
458         keyid_from_pk( pk, keyid );
459
460         /* is it a designated revoker? */
461         if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
462           rc=check_revocation_keys(pk,sig);
463         else
464           {
465             gcry_md_open (&md, algo, 0 );
466             hash_public_key( md, pk );
467             rc = do_check( pk, sig, md, r_expired );
468             cache_sig_result ( sig, rc );
469             gcry_md_close(md);
470           }
471     }
472     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
473         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
474
475         if( snode ) {
476             gcry_md_open (&md, algo, 0 );
477             hash_public_key( md, pk );
478             hash_public_key( md, snode->pkt->pkt.public_key );
479             rc = do_check( pk, sig, md, r_expired );
480             cache_sig_result ( sig, rc );
481             gcry_md_close(md);
482         }
483         else {
484             if (!opt.quiet)
485                 log_info (_("key %08lX: no subkey for subkey "
486                             "revocation signature\n"),
487                           (ulong)keyid_from_pk (pk, NULL));
488             rc = GPG_ERR_SIG_CLASS;
489         }
490     }
491     else if( sig->sig_class == 0x18 ) { /* key binding */
492         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
493
494         if( snode ) {
495             if( is_selfsig ) {  /* does this make sense????? */
496                 u32 keyid[2];   /* it should always be a selfsig */
497
498                 keyid_from_pk( pk, keyid );
499                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
500                     *is_selfsig = 1;
501             }
502             gcry_md_open (&md, algo, 0 );
503             hash_public_key( md, pk );
504             hash_public_key( md, snode->pkt->pkt.public_key );
505             rc = do_check( pk, sig, md, r_expired );
506             cache_sig_result ( sig, rc );
507             gcry_md_close(md);
508         }
509         else {
510             if (opt.verbose)
511                 log_info(_("key %08lX: no subkey for subkey "
512                            "binding signature\n"),
513                          (ulong)keyid_from_pk (pk, NULL));
514             rc = GPG_ERR_SIG_CLASS;
515         }
516     }
517     else if( sig->sig_class == 0x1f ) { /* direct key signature */
518         gcry_md_open (&md, algo, 0 );
519         hash_public_key( md, pk );
520         rc = do_check( pk, sig, md, r_expired );
521         cache_sig_result ( sig, rc );
522         gcry_md_close(md);
523     }
524     else { /* all other classes */
525         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
526
527         if( unode ) {
528             u32 keyid[2];
529
530             keyid_from_pk( pk, keyid );
531             gcry_md_open (&md, algo, 0 );
532             hash_public_key( md, pk );
533             hash_uid_node( unode, md, sig );
534             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
535               {
536                 if( is_selfsig )
537                   *is_selfsig = 1;
538                 rc = do_check( pk, sig, md, r_expired );
539               }
540             else if (check_pk)
541               rc=do_check(check_pk,sig,md,r_expired);
542             else
543               rc = signature_check2( sig, md, r_expiredate, r_expired );
544
545             cache_sig_result ( sig, rc );
546             gcry_md_close(md);
547         }
548         else {
549             if (!opt.quiet)
550                 log_info ("key %08lX: no user ID for key signature packet "
551                           "of class %02x\n",
552                           (ulong)keyid_from_pk (pk, NULL), sig->sig_class );
553             rc = GPG_ERR_SIG_CLASS;
554         }
555     }
556
557     return rc;
558 }