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