03477b537169df3d1804ab9bf9430b60519478c0
[gnupg.git] / g10 / sig-check.c
1 /* sig-check.c -  Check a signature
2  *      Copyright (C) 1998 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 "memory.h"
31 #include "mpi.h"
32 #include "keydb.h"
33 #include "main.h"
34 #include "status.h"
35 #include "i18n.h"
36
37 struct cmp_help_context_s {
38     PKT_signature *sig;
39     GCRY_MD_HD md;
40 };
41
42
43 static int do_signature_check( PKT_signature *sig, GCRY_MD_HD digest,
44                                                       u32 *r_expire );
45 static int do_check( PKT_public_key *pk, PKT_signature *sig,
46                                                 GCRY_MD_HD digest );
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 G10ERR_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( "public-key", 10 ),
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     return do_signature_check( sig, digest, &dummy );
137 }
138
139 static int
140 do_signature_check( PKT_signature *sig, GCRY_MD_HD digest, u32 *r_expire )
141 {
142     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
143     int rc=0;
144
145     if( is_RSA(sig->pubkey_algo) )
146         write_status(STATUS_RSA_OR_IDEA);
147
148     *r_expire = 0;
149     if( get_pubkey( pk, sig->keyid ) )
150         rc = G10ERR_NO_PUBKEY;
151     else {
152         *r_expire = pk->expiredate;
153         rc = do_check( pk, sig, digest );
154     }
155
156     free_public_key( pk );
157
158     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
159         /* This signature id works best with DLP algorithms because
160          * they use a random parameter for every signature.  Instead of
161          * this sig-id we could have also used the hash of the document
162          * and the timestamp, but the drawback of this is, that it is
163          * not possible to sign more than one identical document within
164          * one second.  Some remote bacth processing applications might
165          * like this feature here */
166         GCRY_MD_HD md;
167         u32 a = sig->timestamp;
168         int i, nsig = pubkey_get_nsig( sig->pubkey_algo );
169         byte *p, *buffer;
170
171         if( !(md = gcry_md_open( DIGEST_ALGO_RMD160, 0)) )
172             BUG();
173         gcry_md_putc( digest, sig->pubkey_algo );
174         gcry_md_putc( digest, sig->digest_algo );
175         gcry_md_putc( digest, (a >> 24) & 0xff );
176         gcry_md_putc( digest, (a >> 16) & 0xff );
177         gcry_md_putc( digest, (a >>  8) & 0xff );
178         gcry_md_putc( digest,  a        & 0xff );
179         for(i=0; i < nsig; i++ ) {
180             unsigned n = mpi_get_nbits( sig->data[i]);
181
182             gcry_md_putc( md, n>>8);
183             gcry_md_putc( md, n );
184             p = mpi_get_buffer( sig->data[i], &n, NULL );
185             gcry_md_write( md, p, n );
186             m_free(p);
187         }
188         gcry_md_final( md );
189         p = make_radix64_string( gcry_md_read( md, 0 ), 20 );
190         buffer = m_alloc( strlen(p) + 60 );
191         sprintf( buffer, "%s %s %lu",
192                  p, strtimestamp( sig->timestamp ), (ulong)sig->timestamp );
193         write_status_text( STATUS_SIG_ID, buffer );
194         m_free(buffer);
195         m_free(p);
196         gcry_md_close(md);
197     }
198
199     return rc;
200 }
201
202
203 #if 0 /* not anymore used */
204 /****************
205  * Check the MDC which is contained in SIG.
206  * The GCRY_MD_HD should be currently open, so that this function
207  * is able to append some data, before finalizing the digest.
208  */
209 int
210 mdc_kludge_check( PKT_signature *sig, GCRY_MD_HD digest )
211 {
212     int rc=0;
213
214     if( (rc=check_digest_algo(sig->digest_algo)) )
215         return rc;
216
217     /* make sure the digest algo is enabled (in case of a detached mdc??) */
218     md_enable( digest, sig->digest_algo );
219
220     /* complete the digest */
221     if( sig->version >= 4 )
222         gcry_md_putc( digest, sig->version );
223     gcry_md_putc( digest, sig->sig_class );
224     if( sig->version < 4 ) {
225         u32 a = sig->timestamp;
226         gcry_md_putc( digest, (a >> 24) & 0xff );
227         gcry_md_putc( digest, (a >> 16) & 0xff );
228         gcry_md_putc( digest, (a >>  8) & 0xff );
229         gcry_md_putc( digest,  a        & 0xff );
230     }
231     else {
232         byte buf[6];
233         size_t n;
234         gcry_md_putc( digest, sig->pubkey_algo );
235         gcry_md_putc( digest, sig->digest_algo );
236         if( sig->hashed_data ) {
237             n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
238             gcry_md_write( digest, sig->hashed_data, n+2 );
239             n += 6;
240         }
241         else
242             n = 6;
243         /* add some magic */
244         buf[0] = sig->version;
245         buf[1] = 0xff;
246         buf[2] = n >> 24;
247         buf[3] = n >> 16;
248         buf[4] = n >>  8;
249         buf[5] = n;
250         gcry_md_write( digest, buf, 6 );
251     }
252     md_final( digest );
253
254     rc = G10ERR_BAD_SIGN;
255     {   const byte *s1 = md_read( digest, sig->digest_algo );
256         int s1len = md_digest_length( sig->digest_algo );
257
258         log_hexdump( "MDC calculated", s1, s1len );
259
260         if( !sig->data[0] )
261             log_debug("sig_data[0] is NULL\n");
262         else {
263             unsigned s2len;
264             byte *s2;
265             s2 = mpi_get_buffer( sig->data[0], &s2len, NULL );
266             log_hexdump( "MDC stored    ", s2, s2len );
267
268             if( s2len != s1len )
269                 log_debug("MDC check: len differ: %d/%d\n", s1len, s2len);
270             else if( memcmp( s1, s2, s1len ) )
271                 log_debug("MDC check: hashs differ\n");
272             else
273                 rc = 0;
274             m_free(s2);
275         }
276     }
277
278     if( !rc && sig->flags.unknown_critical ) {
279         log_info(_("assuming bad MDC due to an unknown critical bit\n"));
280         rc = G10ERR_BAD_SIGN;
281     }
282     sig->flags.checked = 1;
283     sig->flags.valid = !rc;
284
285     /* FIXME: check that we are actually in an encrypted packet */
286
287     return rc;
288 }
289 #endif
290
291 /****************
292  * This function gets called by pubkey_verify() if the algorithm needs it.
293  */
294 static int
295 cmp_help( void *opaque, MPI result )
296 {
297   #if 0 /* we do not use this anymore */
298     int rc=0, i, j, c, old_enc;
299     byte *dp;
300     const byte *asn;
301     size_t mdlen, asnlen;
302     struct cmp_help_context_s *ctx = opaque;
303     PKT_signature *sig = ctx->sig;
304     GCRY_MD_HD digest = ctx->md;
305
306     old_enc = 0;
307     for(i=j=0; (c=mpi_getbyte(result, i)) != -1; i++ ) {
308         if( !j ) {
309             if( !i && c != 1 )
310                 break;
311             else if( i && c == 0xff )
312                 ; /* skip the padding */
313             else if( i && !c )
314                 j++;
315             else
316                 break;
317         }
318         else if( ++j == 18 && c != 1 )
319             break;
320         else if( j == 19 && c == 0 ) {
321             old_enc++;
322             break;
323         }
324     }
325     if( old_enc ) {
326         log_error("old encoding scheme is not supported\n");
327         return G10ERR_GENERAL;
328     }
329
330     if( (rc=check_digest_algo(sig->digest_algo)) )
331         return rc; /* unsupported algo */
332     asn = md_asn_oid( sig->digest_algo, &asnlen, &mdlen );
333
334     for(i=mdlen,j=asnlen-1; (c=mpi_getbyte(result, i)) != -1 && j >= 0;
335                                                            i++, j-- )
336         if( asn[j] != c )
337             break;
338     if( j != -1 || mpi_getbyte(result, i) )
339         return G10ERR_BAD_PUBKEY;  /* ASN is wrong */
340     for(i++; (c=mpi_getbyte(result, i)) != -1; i++ )
341         if( c != 0xff  )
342             break;
343     i++;
344     if( c != sig->digest_algo || mpi_getbyte(result, i) ) {
345         /* Padding or leading bytes in signature is wrong */
346         return G10ERR_BAD_PUBKEY;
347     }
348     if( mpi_getbyte(result, mdlen-1) != sig->digest_start[0]
349         || mpi_getbyte(result, mdlen-2) != sig->digest_start[1] ) {
350         /* Wrong key used to check the signature */
351         return G10ERR_BAD_PUBKEY;
352     }
353
354     dp = md_read( digest, sig->digest_algo );
355     for(i=mdlen-1; i >= 0; i--, dp++ ) {
356         if( mpi_getbyte( result, i ) != *dp )
357             return G10ERR_BAD_SIGN;
358     }
359     return 0;
360   #else
361     return -1;
362   #endif
363 }
364
365
366 static int
367 do_check( PKT_public_key *pk, PKT_signature *sig, GCRY_MD_HD digest )
368 {
369     MPI result = NULL;
370     int rc=0;
371     struct cmp_help_context_s ctx;
372     u32 cur_time;
373
374     if( pk->version == 4 && pk->pubkey_algo == GCRY_PK_ELG_E ) {
375         log_info(_("this is a PGP generated "
376                   "ElGamal key which is NOT secure for signatures!\n"));
377         return G10ERR_PUBKEY_ALGO;
378     }
379
380     if( pk->timestamp > sig->timestamp ) {
381         ulong d = pk->timestamp - sig->timestamp;
382         log_info( d==1
383                   ? _("public key is %lu second newer than the signature\n")
384                   : _("public key is %lu seconds newer than the signature\n"),
385                        d );
386         return G10ERR_TIME_CONFLICT; /* pubkey newer than signature */
387     }
388
389     cur_time = make_timestamp();
390     if( pk->timestamp > cur_time ) {
391         ulong d = pk->timestamp - cur_time;
392         log_info( d==1 ? _("key has been created %lu second "
393                            "in future (time warp or clock problem)\n")
394                        : _("key has been created %lu seconds "
395                            "in future (time warp or clock problem)\n"), d );
396         return G10ERR_TIME_CONFLICT;
397     }
398
399     if( pk->expiredate && pk->expiredate < cur_time ) {
400         log_info(_("NOTE: signature key expired %s\n"),
401                                         asctimestamp( pk->expiredate ) );
402         write_status(STATUS_SIGEXPIRED);
403     }
404
405
406     if( (rc=openpgp_md_test_algo(sig->digest_algo)) )
407         return rc;
408     if( (rc=openpgp_pk_test_algo(sig->pubkey_algo, 0)) )
409         return rc;
410
411     /* make sure the digest algo is enabled (in case of a detached signature)*/
412     gcry_md_enable( digest, sig->digest_algo );
413
414     /* complete the digest */
415     if( sig->version >= 4 )
416         gcry_md_putc( digest, sig->version );
417     gcry_md_putc( digest, sig->sig_class );
418     if( sig->version < 4 ) {
419         u32 a = sig->timestamp;
420         gcry_md_putc( digest, (a >> 24) & 0xff );
421         gcry_md_putc( digest, (a >> 16) & 0xff );
422         gcry_md_putc( digest, (a >>  8) & 0xff );
423         gcry_md_putc( digest,  a        & 0xff );
424     }
425     else {
426         byte buf[6];
427         size_t n;
428         gcry_md_putc( digest, sig->pubkey_algo );
429         gcry_md_putc( digest, sig->digest_algo );
430         if( sig->hashed_data ) {
431             n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
432             gcry_md_write( digest, sig->hashed_data, n+2 );
433             n += 6;
434         }
435         else
436             n = 6;
437         /* add some magic */
438         buf[0] = sig->version;
439         buf[1] = 0xff;
440         buf[2] = n >> 24;
441         buf[3] = n >> 16;
442         buf[4] = n >>  8;
443         buf[5] = n;
444         gcry_md_write( digest, buf, 6 );
445     }
446     gcry_md_final( digest );
447
448     result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
449                                       mpi_get_nbits(pk->pkey[0]));
450
451     ctx.sig = sig;
452     ctx.md = digest;
453     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
454                         cmp_help, &ctx );
455     mpi_free( result );
456     if( !rc && sig->flags.unknown_critical ) {
457         log_info(_("assuming bad signature due to an unknown critical bit\n"));
458         rc = G10ERR_BAD_SIGN;
459     }
460     sig->flags.checked = 1;
461     sig->flags.valid = !rc;
462
463     return rc;
464 }
465
466
467 static void
468 hash_uid_node( KBNODE unode, GCRY_MD_HD md, PKT_signature *sig )
469 {
470     PKT_user_id *uid = unode->pkt->pkt.user_id;
471
472     assert( unode->pkt->pkttype == PKT_USER_ID );
473     if( sig->version >=4 ) {
474         byte buf[5];
475         buf[0] = 0xb4; /* indicates a userid packet */
476         buf[1] = uid->len >> 24;  /* always use 4 length bytes */
477         buf[2] = uid->len >> 16;
478         buf[3] = uid->len >>  8;
479         buf[4] = uid->len;
480         gcry_md_write( md, buf, 5 );
481     }
482     gcry_md_write( md, uid->name, uid->len );
483 }
484
485 /****************
486  * check the signature pointed to by NODE. This is a key signature.
487  * If the function detects a self-signature, it uses the PK from
488  * ROOT and does not read any public key.
489  */
490 int
491 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
492 {
493     u32 dummy;
494     return check_key_signature2(root, node, is_selfsig, &dummy );
495 }
496
497 int
498 check_key_signature2( KBNODE root, KBNODE node, int *is_selfsig, u32 *r_expire)
499 {
500     GCRY_MD_HD md;
501     PKT_public_key *pk;
502     PKT_signature *sig;
503     int algo;
504     int rc;
505
506     if( is_selfsig )
507         *is_selfsig = 0;
508     *r_expire = 0;
509     assert( node->pkt->pkttype == PKT_SIGNATURE );
510     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
511
512     pk = root->pkt->pkt.public_key;
513     sig = node->pkt->pkt.signature;
514     algo = sig->digest_algo;
515
516   #if 0 /* I am not sure whether this is a good thing to do */
517     if( sig->flags.checked )
518         log_debug("check_key_signature: already checked: %s\n",
519                       sig->flags.valid? "good":"bad" );
520   #endif
521
522     if( (rc=openpgp_md_test_algo(algo)) )
523         return rc;
524
525     if( sig->sig_class == 0x20 ) {
526         if( !(md = gcry_md_open( algo, 0 )) )
527             BUG();
528         hash_public_key( md, pk );
529         rc = do_check( pk, sig, md );
530         gcry_md_close(md);
531     }
532     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
533         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
534
535         if( snode ) {
536             if( !(md = gcry_md_open( algo, 0 )) )
537                 BUG();
538             hash_public_key( md, pk );
539             hash_public_key( md, snode->pkt->pkt.public_key );
540             rc = do_check( pk, sig, md );
541             gcry_md_close(md);
542         }
543         else {
544             log_error("no subkey for subkey revocation packet\n");
545             rc = G10ERR_SIG_CLASS;
546         }
547     }
548     else if( sig->sig_class == 0x18 ) {
549         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
550
551         if( snode ) {
552             if( is_selfsig ) {  /* does this make sense????? */
553                 u32 keyid[2];   /* it should always be a selfsig */
554
555                 keyid_from_pk( pk, keyid );
556                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
557                     *is_selfsig = 1;
558             }
559             if( !(md = gcry_md_open( algo, 0 )) )
560                 BUG();
561             hash_public_key( md, pk );
562             hash_public_key( md, snode->pkt->pkt.public_key );
563             rc = do_check( pk, sig, md );
564             gcry_md_close(md);
565         }
566         else {
567             log_error("no subkey for key signature packet\n");
568             rc = G10ERR_SIG_CLASS;
569         }
570     }
571     else {
572         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
573
574         if( unode ) {
575             u32 keyid[2];
576
577             keyid_from_pk( pk, keyid );
578             if( !(md = gcry_md_open( algo, 0 )) )
579                 BUG();
580             hash_public_key( md, pk );
581             hash_uid_node( unode, md, sig );
582             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
583                 if( is_selfsig )
584                     *is_selfsig = 1;
585                 rc = do_check( pk, sig, md );
586             }
587             else
588                 rc = do_signature_check( sig, md, r_expire );
589             gcry_md_close(md);
590         }
591         else {
592             log_error("no user ID for key signature packet\n");
593             rc = G10ERR_SIG_CLASS;
594         }
595     }
596
597     return rc;
598 }
599
600