See ChangeLog: Mon Apr 26 17:48:15 CEST 1999 Werner Koch
[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 #include "util.h"
27 #include "packet.h"
28 #include "memory.h"
29 #include "mpi.h"
30 #include "keydb.h"
31 #include "cipher.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     MD_HANDLE md;
39 };
40
41
42 static int do_check( PKT_public_key *pk, PKT_signature *sig,
43                                                 MD_HANDLE digest );
44
45
46 /****************
47  * Check the signature which is contained in SIG.
48  * The MD_HANDLE should be currently open, so that this function
49  * is able to append some data, before finalizing the digest.
50  */
51 int
52 signature_check( PKT_signature *sig, MD_HANDLE digest )
53 {
54     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
55     int rc=0;
56
57     if( is_RSA(sig->pubkey_algo) )
58         write_status(STATUS_RSA_OR_IDEA);
59
60     if( get_pubkey( pk, sig->keyid ) )
61         rc = G10ERR_NO_PUBKEY;
62     else
63         rc = do_check( pk, sig, digest );
64
65     free_public_key( pk );
66
67     if( !rc && is_status_enabled() ) {
68         /* This signature id works best with DLP algorithms because
69          * they use a random parameter for every signature.  Instead of
70          * this sig-id we could have also used the hash of the document
71          * and the timestamp, but the drawback of this is, that it is
72          * not possible to sign more than one identical document within
73          * one second.  Some remote bacth processing applications might
74          * like this feature here */
75         MD_HANDLE md;
76         u32 a = sig->timestamp;
77         int i, nsig = pubkey_get_nsig( sig->pubkey_algo );
78         byte *p, *buffer;
79
80         md = md_open( DIGEST_ALGO_RMD160, 0);
81         md_putc( digest, sig->pubkey_algo );
82         md_putc( digest, sig->digest_algo );
83         md_putc( digest, (a >> 24) & 0xff );
84         md_putc( digest, (a >> 16) & 0xff );
85         md_putc( digest, (a >>  8) & 0xff );
86         md_putc( digest,  a        & 0xff );
87         for(i=0; i < nsig; i++ ) {
88             unsigned n = mpi_get_nbits( sig->data[i]);
89
90             md_putc( md, n>>8);
91             md_putc( md, n );
92             p = mpi_get_buffer( sig->data[i], &n, NULL );
93             md_write( md, p, n );
94             m_free(p);
95         }
96         md_final( md );
97         p = make_radix64_string( md_read( md, 0 ), 20 );
98         buffer = m_alloc( strlen(p) + 40 );
99         sprintf( buffer, "%s %s", p, strtimestamp( sig->timestamp ) );
100         write_status_text( STATUS_SIG_ID, buffer );
101         m_free(buffer);
102         m_free(p);
103         md_close(md);
104     }
105
106     return rc;
107 }
108
109
110
111 /****************
112  * Check the MDC which is contained in SIG.
113  * The MD_HANDLE should be currently open, so that this function
114  * is able to append some data, before finalizing the digest.
115  */
116 int
117 mdc_kludge_check( PKT_signature *sig, MD_HANDLE digest )
118 {
119     int rc=0;
120
121     if( (rc=check_digest_algo(sig->digest_algo)) )
122         return rc;
123
124     /* make sure the digest algo is enabled (in case of a detached mdc??) */
125     md_enable( digest, sig->digest_algo );
126
127     /* complete the digest */
128     if( sig->version >= 4 )
129         md_putc( digest, sig->version );
130     md_putc( digest, sig->sig_class );
131     if( sig->version < 4 ) {
132         u32 a = sig->timestamp;
133         md_putc( digest, (a >> 24) & 0xff );
134         md_putc( digest, (a >> 16) & 0xff );
135         md_putc( digest, (a >>  8) & 0xff );
136         md_putc( digest,  a        & 0xff );
137     }
138     else {
139         byte buf[6];
140         size_t n;
141         md_putc( digest, sig->pubkey_algo );
142         md_putc( digest, sig->digest_algo );
143         if( sig->hashed_data ) {
144             n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
145             md_write( digest, sig->hashed_data, n+2 );
146             n += 6;
147         }
148         else
149             n = 6;
150         /* add some magic */
151         buf[0] = sig->version;
152         buf[1] = 0xff;
153         buf[2] = n >> 24;
154         buf[3] = n >> 16;
155         buf[4] = n >>  8;
156         buf[5] = n;
157         md_write( digest, buf, 6 );
158     }
159     md_final( digest );
160
161     rc = G10ERR_BAD_SIGN;
162     {   const byte *s1 = md_read( digest, sig->digest_algo );
163         int s1len = md_digest_length( sig->digest_algo );
164
165         log_hexdump( "MDC calculated", s1, s1len );
166
167         if( !sig->data[0] )
168             log_debug("sig_data[0] is NULL\n");
169         else {
170             unsigned s2len;
171             byte *s2;
172             s2 = mpi_get_buffer( sig->data[0], &s2len, NULL );
173             log_hexdump( "MDC stored    ", s2, s2len );
174
175             if( s2len != s1len )
176                 log_debug("MDC check: len differ: %d/%d\n", s1len, s2len);
177             else if( memcmp( s1, s2, s1len ) )
178                 log_debug("MDC check: hashs differ\n");
179             else
180                 rc = 0;
181             m_free(s2);
182         }
183     }
184
185     if( !rc && sig->flags.unknown_critical ) {
186         log_info(_("assuming bad MDC due to an unknown critical bit\n"));
187         rc = G10ERR_BAD_SIGN;
188     }
189     sig->flags.checked = 1;
190     sig->flags.valid = !rc;
191
192     /* FIXME: check that we are actually in an encrypted packet */
193
194     return rc;
195 }
196
197
198 /****************
199  * This function gets called by pubkey_verify() if the algorithm needs it.
200  */
201 static int
202 cmp_help( void *opaque, MPI result )
203 {
204   #if 0 /* we do not use this anymore */
205     int rc=0, i, j, c, old_enc;
206     byte *dp;
207     const byte *asn;
208     size_t mdlen, asnlen;
209     struct cmp_help_context_s *ctx = opaque;
210     PKT_signature *sig = ctx->sig;
211     MD_HANDLE digest = ctx->md;
212
213     old_enc = 0;
214     for(i=j=0; (c=mpi_getbyte(result, i)) != -1; i++ ) {
215         if( !j ) {
216             if( !i && c != 1 )
217                 break;
218             else if( i && c == 0xff )
219                 ; /* skip the padding */
220             else if( i && !c )
221                 j++;
222             else
223                 break;
224         }
225         else if( ++j == 18 && c != 1 )
226             break;
227         else if( j == 19 && c == 0 ) {
228             old_enc++;
229             break;
230         }
231     }
232     if( old_enc ) {
233         log_error("old encoding scheme is not supported\n");
234         return G10ERR_GENERAL;
235     }
236
237     if( (rc=check_digest_algo(sig->digest_algo)) )
238         return rc; /* unsupported algo */
239     asn = md_asn_oid( sig->digest_algo, &asnlen, &mdlen );
240
241     for(i=mdlen,j=asnlen-1; (c=mpi_getbyte(result, i)) != -1 && j >= 0;
242                                                            i++, j-- )
243         if( asn[j] != c )
244             break;
245     if( j != -1 || mpi_getbyte(result, i) )
246         return G10ERR_BAD_PUBKEY;  /* ASN is wrong */
247     for(i++; (c=mpi_getbyte(result, i)) != -1; i++ )
248         if( c != 0xff  )
249             break;
250     i++;
251     if( c != sig->digest_algo || mpi_getbyte(result, i) ) {
252         /* Padding or leading bytes in signature is wrong */
253         return G10ERR_BAD_PUBKEY;
254     }
255     if( mpi_getbyte(result, mdlen-1) != sig->digest_start[0]
256         || mpi_getbyte(result, mdlen-2) != sig->digest_start[1] ) {
257         /* Wrong key used to check the signature */
258         return G10ERR_BAD_PUBKEY;
259     }
260
261     dp = md_read( digest, sig->digest_algo );
262     for(i=mdlen-1; i >= 0; i--, dp++ ) {
263         if( mpi_getbyte( result, i ) != *dp )
264             return G10ERR_BAD_SIGN;
265     }
266     return 0;
267   #else
268     return -1;
269   #endif
270 }
271
272
273 static int
274 do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest )
275 {
276     MPI result = NULL;
277     int rc=0;
278     struct cmp_help_context_s ctx;
279     u32 cur_time;
280
281     if( pk->version == 4 && pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E ) {
282         log_info(_("this is a PGP generated "
283                   "ElGamal key which is NOT secure for signatures!\n"));
284         return G10ERR_PUBKEY_ALGO;
285     }
286
287     if( pk->timestamp > sig->timestamp ) {
288         ulong d = pk->timestamp - sig->timestamp;
289         log_info( d==1
290                   ? _("public key is %lu second newer than the signature\n")
291                   : _("public key is %lu seconds newer than the signature\n"),
292                        d );
293         return G10ERR_TIME_CONFLICT; /* pubkey newer than signature */
294     }
295
296     cur_time = make_timestamp();
297     if( pk->timestamp > cur_time ) {
298         ulong d = pk->timestamp - cur_time;
299         log_info( d==1 ? _("key has been created %lu second "
300                            "in future (time warp or clock problem)\n")
301                        : _("key has been created %lu seconds "
302                            "in future (time warp or clock problem)\n"), d );
303         return G10ERR_TIME_CONFLICT;
304     }
305
306     if( pk->expiredate && pk->expiredate < cur_time ) {
307         log_info(_("NOTE: signature key expired %s\n"),
308                                         asctimestamp( pk->expiredate ) );
309         write_status(STATUS_SIGEXPIRED);
310     }
311
312
313     if( (rc=check_digest_algo(sig->digest_algo)) )
314         return rc;
315     if( (rc=check_pubkey_algo(sig->pubkey_algo)) )
316         return rc;
317
318     /* make sure the digest algo is enabled (in case of a detached signature)*/
319     md_enable( digest, sig->digest_algo );
320
321     /* complete the digest */
322     if( sig->version >= 4 )
323         md_putc( digest, sig->version );
324     md_putc( digest, sig->sig_class );
325     if( sig->version < 4 ) {
326         u32 a = sig->timestamp;
327         md_putc( digest, (a >> 24) & 0xff );
328         md_putc( digest, (a >> 16) & 0xff );
329         md_putc( digest, (a >>  8) & 0xff );
330         md_putc( digest,  a        & 0xff );
331     }
332     else {
333         byte buf[6];
334         size_t n;
335         md_putc( digest, sig->pubkey_algo );
336         md_putc( digest, sig->digest_algo );
337         if( sig->hashed_data ) {
338             n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
339             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         md_write( digest, buf, 6 );
352     }
353     md_final( digest );
354
355     result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
356                                       mpi_get_nbits(pk->pkey[0]));
357
358     ctx.sig = sig;
359     ctx.md = digest;
360     rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
361                         cmp_help, &ctx );
362     mpi_free( result );
363     if( !rc && sig->flags.unknown_critical ) {
364         log_info(_("assuming bad signature due to an unknown critical bit\n"));
365         rc = G10ERR_BAD_SIGN;
366     }
367     sig->flags.checked = 1;
368     sig->flags.valid = !rc;
369
370     return rc;
371 }
372
373
374 static void
375 hash_uid_node( KBNODE unode, MD_HANDLE md, PKT_signature *sig )
376 {
377     PKT_user_id *uid = unode->pkt->pkt.user_id;
378
379     assert( unode->pkt->pkttype == PKT_USER_ID );
380     if( sig->version >=4 ) {
381         byte buf[5];
382         buf[0] = 0xb4; /* indicates a userid packet */
383         buf[1] = uid->len >> 24;  /* always use 4 length bytes */
384         buf[2] = uid->len >> 16;
385         buf[3] = uid->len >>  8;
386         buf[4] = uid->len;
387         md_write( md, buf, 5 );
388     }
389     md_write( md, uid->name, uid->len );
390 }
391
392 /****************
393  * check the signature pointed to by NODE. This is a key signature.
394  * If the function detects a self-signature, it uses the PK from
395  * ROOT and does not read any public key.
396  */
397 int
398 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
399 {
400     MD_HANDLE md;
401     PKT_public_key *pk;
402     PKT_signature *sig;
403     int algo;
404     int rc;
405
406     if( is_selfsig )
407         *is_selfsig = 0;
408     assert( node->pkt->pkttype == PKT_SIGNATURE );
409     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
410
411     pk = root->pkt->pkt.public_key;
412     sig = node->pkt->pkt.signature;
413     algo = sig->digest_algo;
414     if( (rc=check_digest_algo(algo)) )
415         return rc;
416
417     if( sig->sig_class == 0x20 ) {
418         md = md_open( algo, 0 );
419         hash_public_key( md, pk );
420         rc = do_check( pk, sig, md );
421         md_close(md);
422     }
423     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
424         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
425
426         if( snode ) {
427             md = md_open( algo, 0 );
428             hash_public_key( md, pk );
429             hash_public_key( md, snode->pkt->pkt.public_key );
430             rc = do_check( pk, sig, md );
431             md_close(md);
432         }
433         else {
434             log_error("no subkey for subkey revocation packet\n");
435             rc = G10ERR_SIG_CLASS;
436         }
437     }
438     else if( sig->sig_class == 0x18 ) {
439         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
440
441         if( snode ) {
442             if( is_selfsig ) {  /* does this make sense????? */
443                 u32 keyid[2];   /* it should always be a selfsig */
444
445                 keyid_from_pk( pk, keyid );
446                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
447                     *is_selfsig = 1;
448             }
449             md = md_open( algo, 0 );
450             hash_public_key( md, pk );
451             hash_public_key( md, snode->pkt->pkt.public_key );
452             rc = do_check( pk, sig, md );
453             md_close(md);
454         }
455         else {
456             log_error("no subkey for key signature packet\n");
457             rc = G10ERR_SIG_CLASS;
458         }
459     }
460     else {
461         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
462
463         if( unode ) {
464             u32 keyid[2];
465
466             keyid_from_pk( pk, keyid );
467             md = md_open( algo, 0 );
468             hash_public_key( md, pk );
469             hash_uid_node( unode, md, sig );
470             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
471                 if( is_selfsig )
472                     *is_selfsig = 1;
473                 rc = do_check( pk, sig, md );
474             }
475             else
476                 rc = signature_check( sig, md );
477             md_close(md);
478         }
479         else {
480             log_error("no user id for key signature packet\n");
481             rc = G10ERR_SIG_CLASS;
482         }
483     }
484
485     return rc;
486 }
487
488