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