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