See ChangeLog: Tue Mar 2 16:44:57 CET 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 md5handle 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
58     if( is_RSA(sig->pubkey_algo) )
59         write_status(STATUS_RSA_OR_IDEA);
60
61     if( get_pubkey( pk, sig->keyid ) )
62         rc = G10ERR_NO_PUBKEY;
63     else
64         rc = do_check( pk, sig, digest );
65
66     free_public_key( pk );
67
68     if( !rc && is_status_enabled() ) {
69         /* This signature id works best with DLP algorithms because
70          * they use a random parameter for every signature.  Instead of
71          * this sig-id we could have also used the hash of the document
72          * and the timestamp, but the drawback of this is, that it is
73          * not possible to sign more than one identical document within
74          * one second.  Some remote bacth processing applications might
75          * like this feature here */
76         MD_HANDLE md;
77         u32 a = sig->timestamp;
78         int i, nsig = pubkey_get_nsig( sig->pubkey_algo );
79         byte *p;
80
81         md = md_open( DIGEST_ALGO_RMD160, 0);
82         md_putc( digest, sig->pubkey_algo );
83         md_putc( digest, sig->digest_algo );
84         md_putc( digest, (a >> 24) & 0xff );
85         md_putc( digest, (a >> 16) & 0xff );
86         md_putc( digest, (a >>  8) & 0xff );
87         md_putc( digest,  a        & 0xff );
88         for(i=0; i < nsig; i++ ) {
89             unsigned n = mpi_get_nbits( sig->data[i]);
90
91             md_putc( md, n>>8);
92             md_putc( md, n );
93             p = mpi_get_buffer( sig->data[i], &n, NULL );
94             md_write( md, p, n );
95             m_free(p);
96         }
97         md_final( md );
98         p = make_radix64_string( md_read( md, 0 ), 20 );
99         write_status_text( STATUS_SIG_ID, p );
100         m_free(p);
101         md_close(md);
102     }
103
104     return rc;
105 }
106
107
108 /****************
109  * This function gets called by pubkey_verify() if the algorithm needs it.
110  */
111 static int
112 cmp_help( void *opaque, MPI result )
113 {
114   #if 0 /* we do not use this anymore */
115     int rc=0, i, j, c, old_enc;
116     byte *dp;
117     const byte *asn;
118     size_t mdlen, asnlen;
119     struct cmp_help_context_s *ctx = opaque;
120     PKT_signature *sig = ctx->sig;
121     MD_HANDLE digest = ctx->md;
122
123     old_enc = 0;
124     for(i=j=0; (c=mpi_getbyte(result, i)) != -1; i++ ) {
125         if( !j ) {
126             if( !i && c != 1 )
127                 break;
128             else if( i && c == 0xff )
129                 ; /* skip the padding */
130             else if( i && !c )
131                 j++;
132             else
133                 break;
134         }
135         else if( ++j == 18 && c != 1 )
136             break;
137         else if( j == 19 && c == 0 ) {
138             old_enc++;
139             break;
140         }
141     }
142     if( old_enc ) {
143         log_error("old encoding scheme is not supported\n");
144         return G10ERR_GENERAL;
145     }
146
147     if( (rc=check_digest_algo(sig->digest_algo)) )
148         return rc; /* unsupported algo */
149     asn = md_asn_oid( sig->digest_algo, &asnlen, &mdlen );
150
151     for(i=mdlen,j=asnlen-1; (c=mpi_getbyte(result, i)) != -1 && j >= 0;
152                                                            i++, j-- )
153         if( asn[j] != c )
154             break;
155     if( j != -1 || mpi_getbyte(result, i) )
156         return G10ERR_BAD_PUBKEY;  /* ASN is wrong */
157     for(i++; (c=mpi_getbyte(result, i)) != -1; i++ )
158         if( c != 0xff  )
159             break;
160     i++;
161     if( c != sig->digest_algo || mpi_getbyte(result, i) ) {
162         /* Padding or leading bytes in signature is wrong */
163         return G10ERR_BAD_PUBKEY;
164     }
165     if( mpi_getbyte(result, mdlen-1) != sig->digest_start[0]
166         || mpi_getbyte(result, mdlen-2) != sig->digest_start[1] ) {
167         /* Wrong key used to check the signature */
168         return G10ERR_BAD_PUBKEY;
169     }
170
171     dp = md_read( digest, sig->digest_algo );
172     for(i=mdlen-1; i >= 0; i--, dp++ ) {
173         if( mpi_getbyte( result, i ) != *dp )
174             return G10ERR_BAD_SIGN;
175     }
176     return 0;
177   #else
178     return -1;
179   #endif
180 }
181
182
183 static int
184 do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest )
185 {
186     MPI result = NULL;
187     int rc=0;
188     struct cmp_help_context_s ctx;
189     u32 cur_time;
190
191     if( pk->version == 4 && pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E ) {
192         log_info(_("this is a PGP generated "
193                   "ElGamal key which is NOT secure for signatures!\n"));
194         return G10ERR_PUBKEY_ALGO;
195     }
196
197     if( pk->timestamp > sig->timestamp ) {
198         ulong d = pk->timestamp - sig->timestamp;
199         log_info( d==1
200                   ? _("public key is %lu second newer than the signature\n")
201                   : _("public key is %lu seconds newer than the signature\n"),
202                        d );
203         return G10ERR_TIME_CONFLICT; /* pubkey newer than signature */
204     }
205
206     cur_time = make_timestamp();
207     if( pk->timestamp > cur_time ) {
208         ulong d = pk->timestamp - cur_time;
209         log_info( d==1 ? _("key has been created %lu second "
210                            "in future (time warp or clock problem)\n")
211                        : _("key has been created %lu seconds "
212                            "in future (time warp or clock problem)\n"), d );
213         return G10ERR_TIME_CONFLICT;
214     }
215
216     if( pk->expiredate && pk->expiredate < cur_time ) {
217         log_info(_("NOTE: signature key expired %s\n"),
218                                         asctimestamp( pk->expiredate ) );
219         write_status(STATUS_SIGEXPIRED);
220     }
221
222
223     if( (rc=check_digest_algo(sig->digest_algo)) )
224         return rc;
225     if( (rc=check_pubkey_algo(sig->pubkey_algo)) )
226         return rc;
227
228     /* make sure the digest algo is enabled (in case of a detached signature)*/
229     md_enable( digest, sig->digest_algo );
230
231     /* complete the digest */
232     if( sig->version >= 4 )
233         md_putc( digest, sig->version );
234     md_putc( digest, sig->sig_class );
235     if( sig->version < 4 ) {
236         u32 a = sig->timestamp;
237         md_putc( digest, (a >> 24) & 0xff );
238         md_putc( digest, (a >> 16) & 0xff );
239         md_putc( digest, (a >>  8) & 0xff );
240         md_putc( digest,  a        & 0xff );
241     }
242     else {
243         byte buf[6];
244         size_t n;
245         md_putc( digest, sig->pubkey_algo );
246         md_putc( digest, sig->digest_algo );
247         if( sig->hashed_data ) {
248             n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
249             md_write( digest, sig->hashed_data, n+2 );
250             n += 6;
251         }
252         else
253             n = 6;
254         /* add some magic */
255         buf[0] = sig->version;
256         buf[1] = 0xff;
257         buf[2] = n >> 24;
258         buf[3] = n >> 16;
259         buf[4] = n >>  8;
260         buf[5] = n;
261         md_write( digest, buf, 6 );
262     }
263     md_final( digest );
264
265     result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
266                                       mpi_get_nbits(pk->pkey[0]));
267
268     ctx.sig = sig;
269     ctx.md = digest;
270     rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
271                         cmp_help, &ctx );
272     mpi_free( result );
273     if( !rc && sig->flags.unknown_critical ) {
274         log_info(_("assuming bad signature due to an unknown critical bit\n"));
275         rc = G10ERR_BAD_SIGN;
276     }
277     sig->flags.checked = 1;
278     sig->flags.valid = !rc;
279
280     return rc;
281 }
282
283
284 static void
285 hash_uid_node( KBNODE unode, MD_HANDLE md, PKT_signature *sig )
286 {
287     PKT_user_id *uid = unode->pkt->pkt.user_id;
288
289     assert( unode->pkt->pkttype == PKT_USER_ID );
290     if( sig->version >=4 ) {
291         byte buf[5];
292         buf[0] = 0xb4; /* indicates a userid packet */
293         buf[1] = uid->len >> 24;  /* always use 4 length bytes */
294         buf[2] = uid->len >> 16;
295         buf[3] = uid->len >>  8;
296         buf[4] = uid->len;
297         md_write( md, buf, 5 );
298     }
299     md_write( md, uid->name, uid->len );
300 }
301
302 /****************
303  * check the signature pointed to by NODE. This is a key signature.
304  * If the function detects a self-signature, it uses the PK from
305  * ROOT and does not read any public key.
306  */
307 int
308 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
309 {
310     MD_HANDLE md;
311     PKT_public_key *pk;
312     PKT_signature *sig;
313     int algo;
314     int rc;
315
316     if( is_selfsig )
317         *is_selfsig = 0;
318     assert( node->pkt->pkttype == PKT_SIGNATURE );
319     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
320
321     pk = root->pkt->pkt.public_key;
322     sig = node->pkt->pkt.signature;
323     algo = sig->digest_algo;
324     if( (rc=check_digest_algo(algo)) )
325         return rc;
326
327     if( sig->sig_class == 0x20 ) {
328         md = md_open( algo, 0 );
329         hash_public_key( md, pk );
330         rc = do_check( pk, sig, md );
331         md_close(md);
332     }
333     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
334         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
335
336         if( snode ) {
337             md = md_open( algo, 0 );
338             hash_public_key( md, pk );
339             hash_public_key( md, snode->pkt->pkt.public_key );
340             rc = do_check( pk, sig, md );
341             md_close(md);
342         }
343         else {
344             log_error("no subkey for subkey revocation packet\n");
345             rc = G10ERR_SIG_CLASS;
346         }
347     }
348     else if( sig->sig_class == 0x18 ) {
349         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
350
351         if( snode ) {
352             if( is_selfsig ) {  /* does this make sense????? */
353                 u32 keyid[2];   /* it should always be a selfsig */
354
355                 keyid_from_pk( pk, keyid );
356                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
357                     *is_selfsig = 1;
358             }
359             md = md_open( algo, 0 );
360             hash_public_key( md, pk );
361             hash_public_key( md, snode->pkt->pkt.public_key );
362             rc = do_check( pk, sig, md );
363             md_close(md);
364         }
365         else {
366             log_error("no subkey for key signature packet\n");
367             rc = G10ERR_SIG_CLASS;
368         }
369     }
370     else {
371         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
372
373         if( unode ) {
374             u32 keyid[2];
375
376             keyid_from_pk( pk, keyid );
377             md = md_open( algo, 0 );
378             hash_public_key( md, pk );
379             hash_uid_node( unode, md, sig );
380             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
381                 if( is_selfsig )
382                     *is_selfsig = 1;
383                 rc = do_check( pk, sig, md );
384             }
385             else
386                 rc = signature_check( sig, md );
387             md_close(md);
388         }
389         else {
390             log_error("no user id for key signature packet\n");
391             rc = G10ERR_SIG_CLASS;
392         }
393     }
394
395     return rc;
396 }
397
398