s/AES/AES128/ in diagnostics and --list-config
[gnupg.git] / agent / pksign.c
1 /* pksign.c - public key signing (well, actually using a secret key)
2  * Copyright (C) 2001, 2002, 2003, 2004, 2010 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <assert.h>
27 #include <unistd.h>
28 #include <sys/stat.h>
29
30 #include "agent.h"
31 #include "i18n.h"
32
33
34 static int
35 do_encode_md (const byte * md, size_t mdlen, int algo, gcry_sexp_t * r_hash,
36               int raw_value)
37 {
38   gcry_sexp_t hash;
39   int rc;
40
41   if (!raw_value)
42     {
43       const char *s;
44       char tmp[16+1];
45       int i;
46       
47       s = gcry_md_algo_name (algo);
48       if (s && strlen (s) < 16)
49         {
50           for (i=0; i < strlen (s); i++)
51             tmp[i] = tolower (s[i]);
52           tmp[i] = '\0';   
53         }
54
55       rc = gcry_sexp_build (&hash, NULL,
56                             "(data (flags pkcs1) (hash %s %b))",
57                             tmp, (int)mdlen, md);
58     }
59   else
60     {
61       gcry_mpi_t mpi;
62       
63       rc = gcry_mpi_scan (&mpi, GCRYMPI_FMT_USG, md, mdlen, NULL);
64       if (! rc)
65         {
66           rc = gcry_sexp_build (&hash, NULL,
67                                 "(data (flags raw) (value %m))",
68                                 mpi);
69           gcry_mpi_release (mpi);
70         }
71           
72     }
73   
74   *r_hash = hash;
75   return rc;   
76 }
77
78
79 /* Return the number of bits of the Q parameter from the DSA key
80    KEY.  */
81 static unsigned int
82 get_dsa_qbits (gcry_sexp_t key)
83 {
84   gcry_sexp_t l1, l2;
85   gcry_mpi_t q;
86   unsigned int nbits;
87
88   l1 = gcry_sexp_find_token (key, "private-key", 0);
89   if (!l1)
90     l1 = gcry_sexp_find_token (key, "protected-private-key", 0);
91   if (!l1)
92     l1 = gcry_sexp_find_token (key, "shadowed-private-key", 0);
93   if (!l1)
94     l1 = gcry_sexp_find_token (key, "public-key", 0);
95   if (!l1)
96     return 0; /* Does not contain a key object.  */
97   l2 = gcry_sexp_cadr (l1);
98   gcry_sexp_release  (l1);
99   l1 = gcry_sexp_find_token (l2, "q", 1);
100   gcry_sexp_release (l2);
101   if (!l1)
102     return 0; /* Invalid object.  */
103   q = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
104   gcry_sexp_release (l1);
105   if (!q)
106     return 0; /* Missing value.  */
107   nbits = gcry_mpi_get_nbits (q);
108   gcry_mpi_release (q);
109
110   return nbits;
111 }
112
113
114 /* Encode a message digest for use with an DSA algorithm. */
115 static gpg_error_t
116 do_encode_dsa (const byte * md, size_t mdlen, int dsaalgo, gcry_sexp_t pkey,
117                gcry_sexp_t *r_hash)
118 {
119   gpg_error_t err;
120   gcry_sexp_t hash;
121   unsigned int qbits;
122
123   *r_hash = NULL;
124
125   if (dsaalgo == GCRY_PK_ECDSA)
126     qbits = gcry_pk_get_nbits (pkey);
127   else if (dsaalgo == GCRY_PK_DSA)
128     qbits = get_dsa_qbits (pkey);
129   else
130     return gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
131   
132   if ((qbits%8))
133     {
134       log_error (_("DSA requires the hash length to be a"
135                    " multiple of 8 bits\n"));
136       return gpg_error (GPG_ERR_INV_LENGTH);
137     }
138
139   /* Don't allow any Q smaller than 160 bits.  We don't want someone
140      to issue signatures from a key with a 16-bit Q or something like
141      that, which would look correct but allow trivial forgeries.  Yes,
142      I know this rules out using MD5 with DSA. ;) */
143   if (qbits < 160)
144     {
145       log_error (_("%s key uses an unsafe (%u bit) hash\n"),
146                  gcry_pk_algo_name (dsaalgo), qbits);
147       return gpg_error (GPG_ERR_INV_LENGTH);
148     }
149
150   /* Check if we're too short.  Too long is safe as we'll
151      automatically left-truncate.  */
152   if (mdlen < qbits/8)
153     {
154       log_error (_("a %zu bit hash is not valid for a %u bit %s key\n"),
155                  mdlen*8,
156                  gcry_pk_get_nbits (pkey), 
157                  gcry_pk_algo_name (dsaalgo));
158       /* FIXME: we need to check the requirements for ECDSA.  */
159       if (mdlen < 20 || dsaalgo == GCRY_PK_DSA)
160         return gpg_error (GPG_ERR_INV_LENGTH);
161     }
162
163   /* Truncate.  */
164   if (mdlen > qbits/8)
165     mdlen = qbits/8;
166             
167   /* Create the S-expression.  We need to convert to an MPI first
168      because we want an unsigned integer.  Using %b directly is not
169      possible because libgcrypt assumes an mpi and uses
170      GCRYMPI_FMT_STD for parsing and thus possible yielding a negative
171      value.  */
172   {
173     gcry_mpi_t mpi;
174       
175     err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_USG, md, mdlen, NULL);
176     if (!err)
177       {
178         err = gcry_sexp_build (&hash, NULL,
179                                "(data (flags raw) (value %m))", mpi);
180         gcry_mpi_release (mpi);
181       }
182   }
183   if (!err)
184     *r_hash = hash;
185   return err;   
186 }
187
188
189 /* Special version of do_encode_md to take care of pkcs#1 padding.
190    For TLS-MD5SHA1 we need to do the padding ourself as Libgrypt does
191    not know about this special scheme.  Fixme: We should have a
192    pkcs1-only-padding flag for Libgcrypt. */
193 static int
194 do_encode_raw_pkcs1 (const byte *md, size_t mdlen, unsigned int nbits,
195                      gcry_sexp_t *r_hash)
196 {
197   int rc;
198   gcry_sexp_t hash;
199   unsigned char *frame;
200   size_t i, n, nframe;
201             
202   nframe = (nbits+7) / 8;
203   if ( !mdlen || mdlen + 8 + 4 > nframe )
204     {
205       /* Can't encode this hash into a frame of size NFRAME. */
206       return gpg_error (GPG_ERR_TOO_SHORT);
207     }
208
209   frame = xtrymalloc (nframe);
210   if (!frame)
211     return gpg_error_from_syserror ();
212   
213   /* Assemble the pkcs#1 block type 1. */
214   n = 0;
215   frame[n++] = 0;
216   frame[n++] = 1; /* Block type. */
217   i = nframe - mdlen - 3 ;
218   assert (i >= 8); /* At least 8 bytes of padding.  */
219   memset (frame+n, 0xff, i );
220   n += i;
221   frame[n++] = 0;
222   memcpy (frame+n, md, mdlen );
223   n += mdlen;
224   assert (n == nframe);
225   
226   /* Create the S-expression.  */
227   rc = gcry_sexp_build (&hash, NULL,
228                         "(data (flags raw) (value %b))",
229                         (int)nframe, frame);
230   xfree (frame);
231
232   *r_hash = hash;
233   return rc;   
234 }
235
236
237
238 /* SIGN whatever information we have accumulated in CTRL and return
239    the signature S-expression.  LOOKUP is an optional function to
240    provide a way for lower layers to ask for the caching TTL.  If a
241    CACHE_NONCE is given that cache item is first tried to get a
242    passphrase.  */
243 int
244 agent_pksign_do (ctrl_t ctrl, const char *cache_nonce,
245                  const char *desc_text,
246                  gcry_sexp_t *signature_sexp,
247                  cache_mode_t cache_mode, lookup_ttl_t lookup_ttl)
248 {
249   gcry_sexp_t s_skey = NULL, s_sig = NULL;
250   unsigned char *shadow_info = NULL;
251   unsigned int rc = 0;          /* FIXME: gpg-error? */
252
253   if (! ctrl->have_keygrip)
254     return gpg_error (GPG_ERR_NO_SECKEY);
255
256   rc = agent_key_from_file (ctrl, cache_nonce, desc_text, ctrl->keygrip,
257                             &shadow_info, cache_mode, lookup_ttl,
258                             &s_skey, NULL);
259   if (rc)
260     {
261       log_error ("failed to read the secret key\n");
262       goto leave;
263     }
264
265   if (!s_skey)
266     {
267       /* Divert operation to the smartcard */
268
269       unsigned char *buf = NULL;
270       size_t len = 0;
271
272       rc = divert_pksign (ctrl, 
273                           ctrl->digest.value, 
274                           ctrl->digest.valuelen,
275                           ctrl->digest.algo,
276                           shadow_info, &buf);
277       if (rc)
278         {
279           log_error ("smartcard signing failed: %s\n", gpg_strerror (rc));
280           goto leave;
281         }
282       len = gcry_sexp_canon_len (buf, 0, NULL, NULL);
283       assert (len);
284
285       rc = gcry_sexp_sscan (&s_sig, NULL, (char*)buf, len);
286       xfree (buf);
287       if (rc)
288         {
289           log_error ("failed to convert sigbuf returned by divert_pksign "
290                      "into S-Exp: %s", gpg_strerror (rc));
291           goto leave;
292         }
293     }
294   else
295     {
296       /* No smartcard, but a private key */
297       gcry_sexp_t s_hash = NULL;
298       int dsaalgo;
299
300       /* Put the hash into a sexp */
301       if (ctrl->digest.algo == MD_USER_TLS_MD5SHA1)
302         rc = do_encode_raw_pkcs1 (ctrl->digest.value,
303                                   ctrl->digest.valuelen,
304                                   gcry_pk_get_nbits (s_skey),
305                                   &s_hash);
306       else if ( (dsaalgo = agent_is_dsa_key (s_skey)) )
307         rc = do_encode_dsa (ctrl->digest.value,
308                             ctrl->digest.valuelen,
309                             dsaalgo, s_skey,
310                             &s_hash);
311       else
312         rc = do_encode_md (ctrl->digest.value,
313                            ctrl->digest.valuelen,
314                            ctrl->digest.algo,
315                            &s_hash,
316                            ctrl->digest.raw_value);
317       if (rc)
318         goto leave;
319
320       if (DBG_CRYPTO)
321         {
322           log_debug ("skey:\n");
323           gcry_sexp_dump (s_skey);
324           log_debug ("hash:\n");
325           gcry_sexp_dump (s_hash);
326         }
327
328       /* sign */
329       rc = gcry_pk_sign (&s_sig, s_hash, s_skey);
330       gcry_sexp_release (s_hash);
331       if (rc)
332         {
333           log_error ("signing failed: %s\n", gpg_strerror (rc));
334           goto leave;
335         }
336
337       if (DBG_CRYPTO)
338         {
339           log_debug ("result:\n");
340           gcry_sexp_dump (s_sig);
341         }
342     }
343
344  leave:
345
346   *signature_sexp = s_sig;
347
348   gcry_sexp_release (s_skey);
349   xfree (shadow_info);
350
351   return rc;
352 }
353
354 /* SIGN whatever information we have accumulated in CTRL and write it
355    back to OUTFP.  If a CACHE_NONCE is given that cache item is first
356    tried to get a passphrase.  */
357 int
358 agent_pksign (ctrl_t ctrl, const char *cache_nonce, const char *desc_text,
359               membuf_t *outbuf, cache_mode_t cache_mode) 
360 {
361   gcry_sexp_t s_sig = NULL;
362   char *buf = NULL;
363   size_t len = 0;
364   int rc = 0;
365
366   rc = agent_pksign_do (ctrl, cache_nonce, desc_text, &s_sig, cache_mode, NULL);
367   if (rc)
368     goto leave;
369
370   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, NULL, 0);
371   assert (len);
372   buf = xmalloc (len);
373   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, buf, len);
374   assert (len);
375
376   put_membuf (outbuf, buf, len);
377
378  leave:
379   gcry_sexp_release (s_sig);
380   xfree (buf);
381
382   return rc;
383 }