See ChangeLog: Mon Sep 18 16:35:45 CEST 2000 Werner Koch
[gnupg.git] / g10 / sig-check.c
1 /* sig-check.c -  Check a signature
2  *      Copyright (C) 1998, 1999, 2000 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
27 #include <gcrypt.h>
28 #include "util.h"
29 #include "packet.h"
30 #include "keydb.h"
31 #include "main.h"
32 #include "status.h"
33 #include "i18n.h"
34 #include "options.h"
35
36 struct cmp_help_context_s {
37     PKT_signature *sig;
38     GCRY_MD_HD md;
39 };
40
41
42 static int do_signature_check( PKT_signature *sig, GCRY_MD_HD digest,
43                                          u32 *r_expiredate, int *r_expired );
44 static int do_check( PKT_public_key *pk, PKT_signature *sig,
45                                          GCRY_MD_HD digest, int *r_expired );
46
47
48
49 /****************
50  * Emulate our old PK interface here - sometime in the future we might
51  * change the internal design to directly fit to libgcrypt.
52  */
53 static int
54 pk_verify( int algo, MPI hash, MPI *data, MPI *pkey,
55            int (*cmp)(void *, MPI), void *opaque )
56 {
57     GCRY_SEXP s_sig, s_hash, s_pkey;
58     int rc;
59
60     /* forget about cmp and opaque - we never used it */
61
62     /* make a sexp from pkey */
63     if( algo == GCRY_PK_DSA ) {
64         rc = gcry_sexp_build ( &s_pkey, NULL,
65                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
66                                   pkey[0], pkey[1], pkey[2], pkey[3] );
67     }
68     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
69         rc = gcry_sexp_build ( &s_pkey, NULL,
70                               "(public-key(elg(p%m)(g%m)(y%m)))",
71                                   pkey[0], pkey[1], pkey[2] );
72     }
73     else if( algo == GCRY_PK_RSA ) {
74         rc = gcry_sexp_build ( &s_pkey, NULL,
75                               "(public-key(rsa(n%m)(e%m)))",
76                                   pkey[0], pkey[1] );
77     }
78     else
79         return GPGERR_PUBKEY_ALGO;
80
81     if ( rc )
82         BUG ();
83
84     /* put hash into a S-Exp s_hash */
85     if ( gcry_sexp_build( &s_hash, NULL, "%m", hash ) )
86         BUG ();
87
88     /* put data into a S-Exp s_sig */
89     if( algo == GCRY_PK_DSA ) {
90         rc = gcry_sexp_build ( &s_sig, NULL,
91                               "(sig-val(dsa(r%m)(s%m)))", data[0], data[1] );
92     }
93     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
94         rc = gcry_sexp_build ( &s_sig, NULL,
95                               "(sig-val(elg(r%m)(s%m)))", data[0], data[1] );
96     }
97     else if( algo == GCRY_PK_RSA ) {
98         rc = gcry_sexp_build ( &s_sig, NULL,
99                               "(sig-val(rsa(s%m)))", data[0] );
100     }
101     else
102         BUG();
103
104     if ( rc )
105         BUG ();
106
107
108     rc = gcry_pk_verify( s_sig, s_hash, s_pkey );
109     gcry_sexp_release( s_sig );
110     gcry_sexp_release( s_hash );
111     gcry_sexp_release( s_pkey );
112     return rc;
113 }
114
115
116
117 /****************
118  * Check the signature which is contained in SIG.
119  * The GCRY_MD_HD should be currently open, so that this function
120  * is able to append some data, before finalizing the digest.
121  */
122 int
123 signature_check( PKT_signature *sig, GCRY_MD_HD digest )
124 {
125     u32 dummy;
126     int dum2;
127     return do_signature_check( sig, digest, &dummy, &dum2 );
128 }
129
130 static int
131 do_signature_check( PKT_signature *sig, GCRY_MD_HD digest,
132                                         u32 *r_expiredate, int *r_expired )
133 {
134     PKT_public_key *pk = gcry_xcalloc( 1, sizeof *pk );
135     int rc=0;
136
137     *r_expiredate = 0;
138     if( get_pubkey( pk, sig->keyid ) )
139         rc = GPGERR_NO_PUBKEY;
140     else {
141         *r_expiredate = pk->expiredate;
142         rc = do_check( pk, sig, digest, r_expired );
143     }
144
145     free_public_key( pk );
146
147     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
148         /* This signature id works best with DLP algorithms because
149          * they use a random parameter for every signature.  Instead of
150          * this sig-id we could have also used the hash of the document
151          * and the timestamp, but the drawback of this is, that it is
152          * not possible to sign more than one identical document within
153          * one second.  Some remote bacth processing applications might
154          * like this feature here */
155         GCRY_MD_HD md;
156         u32 a = sig->timestamp;
157         int i, nsig = pubkey_get_nsig( sig->pubkey_algo );
158         byte *p, *buffer;
159
160         if( !(md = gcry_md_open( GCRY_MD_RMD160, 0)) )
161             BUG();
162         gcry_md_putc( digest, sig->pubkey_algo );
163         gcry_md_putc( digest, sig->digest_algo );
164         gcry_md_putc( digest, (a >> 24) & 0xff );
165         gcry_md_putc( digest, (a >> 16) & 0xff );
166         gcry_md_putc( digest, (a >>  8) & 0xff );
167         gcry_md_putc( digest,  a        & 0xff );
168         for(i=0; i < nsig; i++ ) {
169             size_t n = gcry_mpi_get_nbits( sig->data[i]);
170
171             gcry_md_putc( md, n>>8);
172             gcry_md_putc( md, n );
173             if( gcry_mpi_aprint( GCRYMPI_FMT_USG, &p, &n, sig->data[i] ) )
174                 BUG();
175             gcry_md_write( md, p, n );
176             gcry_free(p);
177         }
178         gcry_md_final( md );
179         p = make_radix64_string( gcry_md_read( md, 0 ), 20 );
180         buffer = gcry_xmalloc( strlen(p) + 60 );
181         sprintf( buffer, "%s %s %lu",
182                  p, strtimestamp( sig->timestamp ), (ulong)sig->timestamp );
183         write_status_text( STATUS_SIG_ID, buffer );
184         gcry_free(buffer);
185         gcry_free(p);
186         gcry_md_close(md);
187     }
188
189     return rc;
190 }
191
192
193 /****************
194  * This function gets called by pubkey_verify() if the algorithm needs it.
195  */
196 static int
197 cmp_help( void *opaque, MPI result )
198 {
199   #if 0 /* we do not use this anymore */
200     int rc=0, i, j, c, old_enc;
201     byte *dp;
202     const byte *asn;
203     size_t mdlen, asnlen;
204     struct cmp_help_context_s *ctx = opaque;
205     PKT_signature *sig = ctx->sig;
206     GCRY_MD_HD digest = ctx->md;
207
208     old_enc = 0;
209     for(i=j=0; (c=mpi_getbyte(result, i)) != -1; i++ ) {
210         if( !j ) {
211             if( !i && c != 1 )
212                 break;
213             else if( i && c == 0xff )
214                 ; /* skip the padding */
215             else if( i && !c )
216                 j++;
217             else
218                 break;
219         }
220         else if( ++j == 18 && c != 1 )
221             break;
222         else if( j == 19 && c == 0 ) {
223             old_enc++;
224             break;
225         }
226     }
227     if( old_enc ) {
228         log_error("old encoding scheme is not supported\n");
229         return GPGERR_GENERAL;
230     }
231
232     if( (rc=check_digest_algo(sig->digest_algo)) )
233         return rc; /* unsupported algo */
234     asn = md_asn_oid( sig->digest_algo, &asnlen, &mdlen );
235
236     for(i=mdlen,j=asnlen-1; (c=mpi_getbyte(result, i)) != -1 && j >= 0;
237                                                            i++, j-- )
238         if( asn[j] != c )
239             break;
240     if( j != -1 || mpi_getbyte(result, i) )
241         return GPGERR_BAD_PUBKEY;  /* ASN is wrong */
242     for(i++; (c=mpi_getbyte(result, i)) != -1; i++ )
243         if( c != 0xff  )
244             break;
245     i++;
246     if( c != sig->digest_algo || mpi_getbyte(result, i) ) {
247         /* Padding or leading bytes in signature is wrong */
248         return GPGERR_BAD_PUBKEY;
249     }
250     if( mpi_getbyte(result, mdlen-1) != sig->digest_start[0]
251         || mpi_getbyte(result, mdlen-2) != sig->digest_start[1] ) {
252         /* Wrong key used to check the signature */
253         return GPGERR_BAD_PUBKEY;
254     }
255
256     dp = md_read( digest, sig->digest_algo );
257     for(i=mdlen-1; i >= 0; i--, dp++ ) {
258         if( mpi_getbyte( result, i ) != *dp )
259             return GPGERR_BAD_SIGN;
260     }
261     return 0;
262   #else
263     return -1;
264   #endif
265 }
266
267
268 static int
269 do_check( PKT_public_key *pk, PKT_signature *sig, GCRY_MD_HD digest,
270                                                     int *r_expired )
271 {
272     MPI result = NULL;
273     int rc=0;
274     struct cmp_help_context_s ctx;
275     u32 cur_time;
276
277     *r_expired = 0;
278     if( pk->version == 4 && pk->pubkey_algo == GCRY_PK_ELG_E ) {
279         log_info(_("this is a PGP generated "
280                    "ElGamal key which is NOT secure for signatures!\n"));
281         return GPGERR_PUBKEY_ALGO;
282     }
283
284     if( pk->timestamp > sig->timestamp ) {
285         ulong d = pk->timestamp - sig->timestamp;
286         log_info( d==1
287                   ? _("public key is %lu second newer than the signature\n")
288                   : _("public key is %lu seconds newer than the signature\n"),
289                        d );
290         if( !opt.ignore_time_conflict )
291             return GPGERR_TIME_CONFLICT; /* pubkey newer than signature */
292     }
293
294     cur_time = make_timestamp();
295     if( pk->timestamp > cur_time ) {
296         ulong d = pk->timestamp - cur_time;
297         log_info( d==1 ? _("key has been created %lu second "
298                            "in future (time warp or clock problem)\n")
299                        : _("key has been created %lu seconds "
300                            "in future (time warp or clock problem)\n"), d );
301         if( !opt.ignore_time_conflict )
302             return GPGERR_TIME_CONFLICT;
303     }
304
305     if( pk->expiredate && pk->expiredate < cur_time ) {
306         log_info(_("NOTE: signature key expired %s\n"),
307                                         asctimestamp( pk->expiredate ) );
308         write_status(STATUS_SIGEXPIRED);
309         *r_expired = 1;
310     }
311
312
313     if( (rc=openpgp_md_test_algo(sig->digest_algo)) )
314         return rc;
315     if( (rc=openpgp_pk_test_algo(sig->pubkey_algo, 0)) )
316         return rc;
317
318     /* make sure the digest algo is enabled (in case of a detached signature)*/
319     gcry_md_enable( digest, sig->digest_algo );
320
321     /* complete the digest */
322     if( sig->version >= 4 )
323         gcry_md_putc( digest, sig->version );
324     gcry_md_putc( digest, sig->sig_class );
325     if( sig->version < 4 ) {
326         u32 a = sig->timestamp;
327         gcry_md_putc( digest, (a >> 24) & 0xff );
328         gcry_md_putc( digest, (a >> 16) & 0xff );
329         gcry_md_putc( digest, (a >>  8) & 0xff );
330         gcry_md_putc( digest,  a        & 0xff );
331     }
332     else {
333         byte buf[6];
334         size_t n;
335         gcry_md_putc( digest, sig->pubkey_algo );
336         gcry_md_putc( digest, sig->digest_algo );
337         if( sig->hashed_data ) {
338             n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
339             gcry_md_write( digest, sig->hashed_data, n+2 );
340             n += 6;
341         }
342         else
343             n = 6;
344         /* add some magic */
345         buf[0] = sig->version;
346         buf[1] = 0xff;
347         buf[2] = n >> 24;
348         buf[3] = n >> 16;
349         buf[4] = n >>  8;
350         buf[5] = n;
351         gcry_md_write( digest, buf, 6 );
352     }
353     gcry_md_final( digest );
354
355     result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
356                               gcry_mpi_get_nbits(pk->pkey[0]), 0);
357     ctx.sig = sig;
358     ctx.md = digest;
359     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
360                         cmp_help, &ctx );
361     mpi_release( result );
362     if( (opt.emulate_bugs & EMUBUG_MDENCODE)
363         && rc == GPGERR_BAD_SIGN && is_ELGAMAL(pk->pubkey_algo) ) {
364         /* In this case we try again because old GnuPG versions didn't encode
365          * the hash right. There is no problem with DSA however  */
366         result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
367                                   gcry_mpi_get_nbits(pk->pkey[0]), (sig->version < 5) );
368         ctx.sig = sig;
369         ctx.md = digest;
370         rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
371                         cmp_help, &ctx );
372     }
373
374     if( !rc && sig->flags.unknown_critical ) {
375         log_info(_("assuming bad signature due to an unknown critical bit\n"));
376         rc = GPGERR_BAD_SIGN;
377     }
378     sig->flags.checked = 1;
379     sig->flags.valid = !rc;
380
381     return rc;
382 }
383
384
385 static void
386 hash_uid_node( KBNODE unode, GCRY_MD_HD md, PKT_signature *sig )
387 {
388     PKT_user_id *uid = unode->pkt->pkt.user_id;
389
390     assert( unode->pkt->pkttype == PKT_USER_ID );
391     if( uid->photo ) {
392         if( sig->version >=4 ) {
393             byte buf[5];
394             buf[0] = 0xd1;                 /* packet of type 17 */
395             buf[1] = uid->photolen >> 24;  /* always use 4 length bytes */
396             buf[2] = uid->photolen >> 16;
397             buf[3] = uid->photolen >>  8;
398             buf[4] = uid->photolen;
399             gcry_md_write( md, buf, 5 );
400         }
401         gcry_md_write( md, uid->photo, uid->photolen );
402     }
403     else {
404         if( sig->version >=4 ) {
405             byte buf[5];
406             buf[0] = 0xb4;            /* indicates a userid packet */
407             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
408             buf[2] = uid->len >> 16;
409             buf[3] = uid->len >>  8;
410             buf[4] = uid->len;
411             gcry_md_write( md, buf, 5 );
412         }
413         gcry_md_write( md, uid->name, uid->len );
414     }
415 }
416
417 /****************
418  * check the signature pointed to by NODE. This is a key signature.
419  * If the function detects a self-signature, it uses the PK from
420  * ROOT and does not read any public key.
421  */
422 int
423 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
424 {
425     u32 dummy;
426     int dum2;
427     return check_key_signature2(root, node, is_selfsig, &dummy, &dum2 );
428 }
429
430 int
431 check_key_signature2( KBNODE root, KBNODE node, int *is_selfsig,
432                                        u32 *r_expiredate, int *r_expired )
433 {
434     GCRY_MD_HD md;
435     PKT_public_key *pk;
436     PKT_signature *sig;
437     int algo;
438     int rc;
439
440     if( is_selfsig )
441         *is_selfsig = 0;
442     *r_expiredate = 0;
443     *r_expired = 0;
444     assert( node->pkt->pkttype == PKT_SIGNATURE );
445     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
446
447     pk = root->pkt->pkt.public_key;
448     sig = node->pkt->pkt.signature;
449     algo = sig->digest_algo;
450
451   #if 0
452     if( sig->flags.checked ) {
453         log_debug("check_key_signature: already checked: %s\n",
454                       sig->flags.valid? "good":"bad" );
455         if ( sig->flags.valid )
456             return 0; /* shortcut already checked signatures */
457         /* FIXME: We should also do this with bad signatures but here we
458          * have to distinguish between several reasons; e.g. for a missing
459          * public key. the key may now be available.
460          * For now we simply don't shortcut bad signatures
461          */
462     }
463   #endif
464
465     if( (rc=openpgp_md_test_algo(algo)) )
466         return rc;
467
468     if( sig->sig_class == 0x20 ) {
469         if( !(md = gcry_md_open( algo, 0 )) )
470             BUG();
471         hash_public_key( md, pk );
472         rc = do_check( pk, sig, md, r_expired );
473         gcry_md_close(md);
474     }
475     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
476         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
477
478         if( snode ) {
479             if( !(md = gcry_md_open( algo, 0 )) )
480                 BUG();
481             hash_public_key( md, pk );
482             hash_public_key( md, snode->pkt->pkt.public_key );
483             rc = do_check( pk, sig, md, r_expired );
484             gcry_md_close(md);
485         }
486         else {
487             log_error("no subkey for subkey revocation packet\n");
488             rc = GPGERR_SIG_CLASS;
489         }
490     }
491     else if( sig->sig_class == 0x18 ) {
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             if( !(md = gcry_md_open( algo, 0 )) )
503                 BUG();
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 );
507             gcry_md_close(md);
508         }
509         else {
510             log_error("no subkey for key signature packet\n");
511             rc = GPGERR_SIG_CLASS;
512         }
513     }
514     else {
515         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
516
517         if( unode ) {
518             u32 keyid[2];
519
520             keyid_from_pk( pk, keyid );
521             if( !(md = gcry_md_open( algo, 0 )) )
522                 BUG();
523             hash_public_key( md, pk );
524             hash_uid_node( unode, md, sig );
525             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
526                 if( is_selfsig )
527                     *is_selfsig = 1;
528                 rc = do_check( pk, sig, md, r_expired );
529             }
530             else {
531                 rc = do_signature_check( sig, md, r_expiredate, r_expired );
532             }
533             gcry_md_close(md);
534         }
535         else {
536             log_error("no user ID for key signature packet\n");
537             rc = GPGERR_SIG_CLASS;
538         }
539     }
540
541     return rc;
542 }
543
544