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