sm/
[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 || pkalgo == GCRY_PK_ECDSA)
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==5 && !memcmp (name, "ecdsa", 5))
147     algo = GCRY_PK_ECDSA;
148   /* Because this function is called only for verification we can
149      assume that ECC actually means ECDSA.  */
150   else if (n==3 && !memcmp (name, "ecc", 3))
151     algo = GCRY_PK_ECDSA;
152   else if (n==13 && !memcmp (name, "ambiguous-rsa", 13))
153     algo = GCRY_PK_RSA;
154   else
155     algo = 0;
156   gcry_sexp_release (l2);
157   return algo;
158 }
159
160
161 /*
162   Check the signature on CERT using the ISSUER-CERT.  This function
163   does only test the cryptographic signature and nothing else.  It is
164   assumed that the ISSUER_CERT is valid. */
165 int
166 gpgsm_check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert)
167 {
168   const char *algoid;
169   gcry_md_hd_t md;
170   int rc, algo;
171   gcry_mpi_t frame;
172   ksba_sexp_t p;
173   size_t n;
174   gcry_sexp_t s_sig, s_hash, s_pkey;
175
176   algo = gcry_md_map_name ( (algoid=ksba_cert_get_digest_algo (cert)));
177   if (!algo)
178     {
179       log_error ("unknown hash algorithm `%s'\n", algoid? algoid:"?");
180       if (algoid
181           && (  !strcmp (algoid, "1.2.840.113549.1.1.2")
182                 ||!strcmp (algoid, "1.2.840.113549.2.2")))
183         log_info (_("(this is the MD2 algorithm)\n"));
184       return gpg_error (GPG_ERR_GENERAL);
185     }
186   rc = gcry_md_open (&md, algo, 0);
187   if (rc)
188     {
189       log_error ("md_open failed: %s\n", gpg_strerror (rc));
190       return rc;
191     }
192   if (DBG_HASHING)
193     gcry_md_start_debug (md, "hash.cert");
194
195   rc = ksba_cert_hash (cert, 1, HASH_FNC, md);
196   if (rc)
197     {
198       log_error ("ksba_cert_hash failed: %s\n", gpg_strerror (rc));
199       gcry_md_close (md);
200       return rc;
201     }
202   gcry_md_final (md);
203
204   p = ksba_cert_get_sig_val (cert);
205   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
206   if (!n)
207     {
208       log_error ("libksba did not return a proper S-Exp\n");
209       gcry_md_close (md);
210       ksba_free (p);
211       return gpg_error (GPG_ERR_BUG);
212     }
213   if (DBG_CRYPTO)
214     {
215       int j;
216       log_debug ("signature value:");
217       for (j=0; j < n; j++)
218         log_printf (" %02X", p[j]);
219       log_printf ("\n");
220     }
221
222   rc = gcry_sexp_sscan ( &s_sig, NULL, (char*)p, n);
223   ksba_free (p);
224   if (rc)
225     {
226       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
227       gcry_md_close (md);
228       return rc;
229     }
230
231   p = ksba_cert_get_public_key (issuer_cert);
232   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
233   if (!n)
234     {
235       log_error ("libksba did not return a proper S-Exp\n");
236       gcry_md_close (md);
237       ksba_free (p);
238       gcry_sexp_release (s_sig);
239       return gpg_error (GPG_ERR_BUG);
240     }
241   rc = gcry_sexp_sscan ( &s_pkey, NULL, (char*)p, n);
242   ksba_free (p);
243   if (rc)
244     {
245       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
246       gcry_md_close (md);
247       gcry_sexp_release (s_sig);
248       return rc;
249     }
250
251   rc = do_encode_md (md, algo, pk_algo_from_sexp (s_pkey),
252                      gcry_pk_get_nbits (s_pkey), &frame);
253   if (rc)
254     {
255       gcry_md_close (md);
256       gcry_sexp_release (s_sig);
257       gcry_sexp_release (s_pkey);
258       return rc;
259     }
260
261   /* put hash into the S-Exp s_hash */
262   if ( gcry_sexp_build (&s_hash, NULL, "%m", frame) )
263     BUG ();
264   gcry_mpi_release (frame);
265
266   
267   rc = gcry_pk_verify (s_sig, s_hash, s_pkey);
268   if (DBG_X509)
269       log_debug ("gcry_pk_verify: %s\n", gpg_strerror (rc));
270   gcry_md_close (md);
271   gcry_sexp_release (s_sig);
272   gcry_sexp_release (s_hash);
273   gcry_sexp_release (s_pkey);
274   return rc;
275 }
276
277
278
279 int
280 gpgsm_check_cms_signature (ksba_cert_t cert, ksba_const_sexp_t sigval,
281                            gcry_md_hd_t md, int algo)
282 {
283   int rc;
284   ksba_sexp_t p;
285   gcry_mpi_t frame;
286   gcry_sexp_t s_sig, s_hash, s_pkey;
287   size_t n;
288
289   n = gcry_sexp_canon_len (sigval, 0, NULL, NULL);
290   if (!n)
291     {
292       log_error ("libksba did not return a proper S-Exp\n");
293       return gpg_error (GPG_ERR_BUG);
294     }
295   rc = gcry_sexp_sscan (&s_sig, NULL, (char*)sigval, n);
296   if (rc)
297     {
298       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
299       return rc;
300     }
301
302   p = ksba_cert_get_public_key (cert);
303   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
304   if (!n)
305     {
306       log_error ("libksba did not return a proper S-Exp\n");
307       ksba_free (p);
308       gcry_sexp_release (s_sig);
309       return gpg_error (GPG_ERR_BUG);
310     }
311   if (DBG_CRYPTO)
312     log_printhex ("public key: ", p, n);
313
314   rc = gcry_sexp_sscan ( &s_pkey, NULL, (char*)p, n);
315   ksba_free (p);
316   if (rc)
317     {
318       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
319       gcry_sexp_release (s_sig);
320       return rc;
321     }
322
323
324   rc = do_encode_md (md, algo, pk_algo_from_sexp (s_pkey),
325                      gcry_pk_get_nbits (s_pkey), &frame);
326   if (rc)
327     {
328       gcry_sexp_release (s_sig);
329       gcry_sexp_release (s_pkey);
330       return rc;
331     }
332   /* put hash into the S-Exp s_hash */
333   if ( gcry_sexp_build (&s_hash, NULL, "%m", frame) )
334     BUG ();
335   gcry_mpi_release (frame);
336   
337   rc = gcry_pk_verify (s_sig, s_hash, s_pkey);
338   if (DBG_X509)
339       log_debug ("gcry_pk_verify: %s\n", gpg_strerror (rc));
340   gcry_sexp_release (s_sig);
341   gcry_sexp_release (s_hash);
342   gcry_sexp_release (s_pkey);
343   return rc;
344 }
345
346
347
348 int
349 gpgsm_create_cms_signature (ctrl_t ctrl, ksba_cert_t cert,
350                             gcry_md_hd_t md, int mdalgo,
351                             unsigned char **r_sigval)
352 {
353   int rc;
354   char *grip, *desc;
355   size_t siglen;
356
357   grip = gpgsm_get_keygrip_hexstring (cert);
358   if (!grip)
359     return gpg_error (GPG_ERR_BAD_CERT);
360
361   desc = gpgsm_format_keydesc (cert);
362
363   rc = gpgsm_agent_pksign (ctrl, grip, desc, gcry_md_read(md, mdalgo), 
364                            gcry_md_get_algo_dlen (mdalgo), mdalgo,
365                            r_sigval, &siglen);
366   xfree (desc);
367   xfree (grip);
368   return rc;
369 }
370
371
372