bug fixes
[gnupg.git] / sm / certcheck.c
1 /* certcheck.c - check one certificate
2  *      Copyright (C) 2001, 2003, 2004 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <unistd.h> 
28 #include <time.h>
29 #include <assert.h>
30
31 #include "gpgsm.h"
32 #include <gcrypt.h>
33 #include <ksba.h>
34
35 #include "keydb.h"
36 #include "i18n.h"
37
38
39 static int
40 do_encode_md (gcry_md_hd_t md, int algo, int pkalgo, unsigned int nbits,
41               gcry_mpi_t *r_val)
42 {
43   int n;
44   size_t nframe;
45   unsigned char *frame;
46
47   if (pkalgo == GCRY_PK_DSA)
48     {
49       nframe = gcry_md_get_algo_dlen (algo);
50       if (nframe != 20)
51         {
52           log_error (_("DSA requires the use of a 160 bit hash algorithm\n"));
53           return gpg_error (GPG_ERR_INTERNAL);
54         }
55       frame = xtrymalloc (nframe);
56       if (!frame)
57         return out_of_core ();
58       memcpy (frame, gcry_md_read (md, algo), nframe);
59       n = nframe;
60     }
61   else
62     {
63       int i;
64       unsigned char asn[100];
65       size_t asnlen;
66       size_t len;
67
68       nframe = (nbits+7) / 8;
69
70       asnlen = DIM(asn);
71       if (!algo || gcry_md_test_algo (algo))
72         return gpg_error (GPG_ERR_DIGEST_ALGO);
73       if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
74         {
75           log_error ("no object identifier for algo %d\n", algo);
76           return gpg_error (GPG_ERR_INTERNAL);
77         }
78       
79       len = gcry_md_get_algo_dlen (algo);
80       
81       if ( len + asnlen + 4  > nframe )
82         {
83           log_error ("can't encode a %d bit MD into a %d bits frame\n",
84                      (int)(len*8), (int)nbits);
85           return gpg_error (GPG_ERR_INTERNAL);
86         }
87       
88       /* We encode the MD in this way:
89        *
90        *           0  A PAD(n bytes)   0  ASN(asnlen bytes)  MD(len bytes)
91        *
92        * PAD consists of FF bytes.
93        */
94       frame = xtrymalloc (nframe);
95       if (!frame)
96         return out_of_core ();
97       n = 0;
98       frame[n++] = 0;
99       frame[n++] = 1; /* block type */
100       i = nframe - len - asnlen -3 ;
101       assert ( i > 1 );
102       memset ( frame+n, 0xff, i ); n += i;
103       frame[n++] = 0;
104       memcpy ( frame+n, asn, asnlen ); n += asnlen;
105       memcpy ( frame+n, gcry_md_read(md, algo), len ); n += len;
106       assert ( n == nframe );
107     }
108   if (DBG_CRYPTO)
109     {
110       int j;
111       log_debug ("encoded hash:");
112       for (j=0; j < nframe; j++)
113         log_printf (" %02X", frame[j]);
114       log_printf ("\n");
115     }
116       
117   gcry_mpi_scan (r_val, GCRYMPI_FMT_USG, frame, n, &nframe);
118   xfree (frame);
119   return 0;
120 }
121
122 /* Return the public key algorithm id from the S-expression PKEY.
123    FIXME: libgcrypt should provide such a function.  Note that this
124    implementation uses the names as used by libksba.  */
125 static int
126 pk_algo_from_sexp (gcry_sexp_t pkey)
127 {
128   gcry_sexp_t l1, l2;
129   const char *name;
130   size_t n;
131   int algo;
132
133   l1 = gcry_sexp_find_token (pkey, "public-key", 0);
134   if (!l1)
135     return 0; /* Not found.  */
136   l2 = gcry_sexp_cadr (l1);
137   gcry_sexp_release (l1);
138
139   name = gcry_sexp_nth_data (l2, 0, &n);
140   if (!name)
141     algo = 0; /* Not found. */
142   else if (n==3 && !memcmp (name, "rsa", 3))
143     algo = GCRY_PK_RSA;
144   else if (n==3 && !memcmp (name, "dsa", 3))
145     algo = GCRY_PK_DSA;
146   else if (n==13 && !memcmp (name, "ambiguous-rsa", 13))
147     algo = GCRY_PK_RSA;
148   else
149     algo = 0;
150   gcry_sexp_release (l2);
151   return algo;
152 }
153
154
155 /*
156   Check the signature on CERT using the ISSUER-CERT.  This function
157   does only test the cryptographic signature and nothing else.  It is
158   assumed that the ISSUER_CERT is valid. */
159 int
160 gpgsm_check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert)
161 {
162   const char *algoid;
163   gcry_md_hd_t md;
164   int rc, algo;
165   gcry_mpi_t frame;
166   ksba_sexp_t p;
167   size_t n;
168   gcry_sexp_t s_sig, s_hash, s_pkey;
169
170   algo = gcry_md_map_name ( (algoid=ksba_cert_get_digest_algo (cert)));
171   if (!algo)
172     {
173       log_error ("unknown hash algorithm `%s'\n", algoid? algoid:"?");
174       if (algoid
175           && (  !strcmp (algoid, "1.2.840.113549.1.1.2")
176                 ||!strcmp (algoid, "1.2.840.113549.2.2")))
177         log_info (_("(this is the MD2 algorithm)\n"));
178       return gpg_error (GPG_ERR_GENERAL);
179     }
180   rc = gcry_md_open (&md, algo, 0);
181   if (rc)
182     {
183       log_error ("md_open failed: %s\n", gpg_strerror (rc));
184       return rc;
185     }
186   if (DBG_HASHING)
187     gcry_md_start_debug (md, "hash.cert");
188
189   rc = ksba_cert_hash (cert, 1, HASH_FNC, md);
190   if (rc)
191     {
192       log_error ("ksba_cert_hash failed: %s\n", gpg_strerror (rc));
193       gcry_md_close (md);
194       return rc;
195     }
196   gcry_md_final (md);
197
198   p = ksba_cert_get_sig_val (cert);
199   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
200   if (!n)
201     {
202       log_error ("libksba did not return a proper S-Exp\n");
203       gcry_md_close (md);
204       ksba_free (p);
205       return gpg_error (GPG_ERR_BUG);
206     }
207   if (DBG_CRYPTO)
208     {
209       int j;
210       log_debug ("signature value:");
211       for (j=0; j < n; j++)
212         log_printf (" %02X", p[j]);
213       log_printf ("\n");
214     }
215
216   rc = gcry_sexp_sscan ( &s_sig, NULL, (char*)p, n);
217   ksba_free (p);
218   if (rc)
219     {
220       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
221       gcry_md_close (md);
222       return rc;
223     }
224
225   p = ksba_cert_get_public_key (issuer_cert);
226   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
227   if (!n)
228     {
229       log_error ("libksba did not return a proper S-Exp\n");
230       gcry_md_close (md);
231       ksba_free (p);
232       gcry_sexp_release (s_sig);
233       return gpg_error (GPG_ERR_BUG);
234     }
235   rc = gcry_sexp_sscan ( &s_pkey, NULL, (char*)p, n);
236   ksba_free (p);
237   if (rc)
238     {
239       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
240       gcry_md_close (md);
241       gcry_sexp_release (s_sig);
242       return rc;
243     }
244
245   rc = do_encode_md (md, algo, pk_algo_from_sexp (s_pkey),
246                      gcry_pk_get_nbits (s_pkey), &frame);
247   if (rc)
248     {
249       gcry_md_close (md);
250       gcry_sexp_release (s_sig);
251       gcry_sexp_release (s_pkey);
252       return rc;
253     }
254
255   /* put hash into the S-Exp s_hash */
256   if ( gcry_sexp_build (&s_hash, NULL, "%m", frame) )
257     BUG ();
258   gcry_mpi_release (frame);
259
260   
261   rc = gcry_pk_verify (s_sig, s_hash, s_pkey);
262   if (DBG_X509)
263       log_debug ("gcry_pk_verify: %s\n", gpg_strerror (rc));
264   gcry_md_close (md);
265   gcry_sexp_release (s_sig);
266   gcry_sexp_release (s_hash);
267   gcry_sexp_release (s_pkey);
268   return rc;
269 }
270
271
272
273 int
274 gpgsm_check_cms_signature (ksba_cert_t cert, ksba_const_sexp_t sigval,
275                            gcry_md_hd_t md, int algo)
276 {
277   int rc;
278   ksba_sexp_t p;
279   gcry_mpi_t frame;
280   gcry_sexp_t s_sig, s_hash, s_pkey;
281   size_t n;
282
283   n = gcry_sexp_canon_len (sigval, 0, NULL, NULL);
284   if (!n)
285     {
286       log_error ("libksba did not return a proper S-Exp\n");
287       return gpg_error (GPG_ERR_BUG);
288     }
289   rc = gcry_sexp_sscan (&s_sig, NULL, (char*)sigval, n);
290   if (rc)
291     {
292       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
293       return rc;
294     }
295
296   p = ksba_cert_get_public_key (cert);
297   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
298   if (!n)
299     {
300       log_error ("libksba did not return a proper S-Exp\n");
301       ksba_free (p);
302       gcry_sexp_release (s_sig);
303       return gpg_error (GPG_ERR_BUG);
304     }
305   if (DBG_CRYPTO)
306     log_printhex ("public key: ", p, n);
307
308   rc = gcry_sexp_sscan ( &s_pkey, NULL, (char*)p, n);
309   ksba_free (p);
310   if (rc)
311     {
312       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
313       gcry_sexp_release (s_sig);
314       return rc;
315     }
316
317
318   rc = do_encode_md (md, algo, pk_algo_from_sexp (s_pkey),
319                      gcry_pk_get_nbits (s_pkey), &frame);
320   if (rc)
321     {
322       gcry_sexp_release (s_sig);
323       gcry_sexp_release (s_pkey);
324       return rc;
325     }
326   /* put hash into the S-Exp s_hash */
327   if ( gcry_sexp_build (&s_hash, NULL, "%m", frame) )
328     BUG ();
329   gcry_mpi_release (frame);
330   
331   rc = gcry_pk_verify (s_sig, s_hash, s_pkey);
332   if (DBG_X509)
333       log_debug ("gcry_pk_verify: %s\n", gpg_strerror (rc));
334   gcry_sexp_release (s_sig);
335   gcry_sexp_release (s_hash);
336   gcry_sexp_release (s_pkey);
337   return rc;
338 }
339
340
341
342 int
343 gpgsm_create_cms_signature (ctrl_t ctrl, ksba_cert_t cert,
344                             gcry_md_hd_t md, int mdalgo,
345                             unsigned char **r_sigval)
346 {
347   int rc;
348   char *grip, *desc;
349   size_t siglen;
350
351   grip = gpgsm_get_keygrip_hexstring (cert);
352   if (!grip)
353     return gpg_error (GPG_ERR_BAD_CERT);
354
355   desc = gpgsm_format_keydesc (cert);
356
357   rc = gpgsm_agent_pksign (ctrl, grip, desc, gcry_md_read(md, mdalgo), 
358                            gcry_md_get_algo_dlen (mdalgo), mdalgo,
359                            r_sigval, &siglen);
360   xfree (desc);
361   xfree (grip);
362   return rc;
363 }
364
365
366