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