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