Fix commit 04e2c83f.
[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   int pkalgo;
123
124   *r_hash = NULL;
125
126   pkalgo = map_pk_openpgp_to_gcry (dsaalgo);
127
128   if (pkalgo == GCRY_PK_ECDSA)
129     qbits = gcry_pk_get_nbits (pkey);
130   else if (pkalgo == GCRY_PK_DSA)
131     qbits = get_dsa_qbits (pkey);
132   else
133     return gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
134
135   if (pkalgo == GCRY_PK_DSA && (qbits%8))
136     {
137       /* FIXME: We check the QBITS but print a message about the hash
138          length.  */
139       log_error (_("DSA requires the hash length to be a"
140                    " multiple of 8 bits\n"));
141       return gpg_error (GPG_ERR_INV_LENGTH);
142     }
143
144   /* Don't allow any Q smaller than 160 bits.  We don't want someone
145      to issue signatures from a key with a 16-bit Q or something like
146      that, which would look correct but allow trivial forgeries.  Yes,
147      I know this rules out using MD5 with DSA. ;) */
148   if (qbits < 160)
149     {
150       log_error (_("%s key uses an unsafe (%u bit) hash\n"),
151                  gcry_pk_algo_name (pkalgo), qbits);
152       return gpg_error (GPG_ERR_INV_LENGTH);
153     }
154
155   /* Check if we're too short.  Too long is safe as we'll
156    * automatically left-truncate.
157    *
158    * This check would require the use of SHA512 with ECDSA 512. I
159    * think this is overkill to fail in this case.  Therefore, relax
160    * the check, but only for ECDSA keys.  We may need to adjust it
161    * later for general case.  (Note that the check is really a bug for
162    * ECDSA 521 as the only hash that matches it is SHA 512, but 512 <
163    * 521 ).
164    */
165   if (mdlen < ((pkalgo==GCRY_PK_ECDSA && qbits > 521) ? 512 : qbits)/8)
166     {
167       log_error (_("a %zu bit hash is not valid for a %u bit %s key\n"),
168                  mdlen*8,
169                  gcry_pk_get_nbits (pkey),
170                  gcry_pk_algo_name (pkalgo));
171       /* FIXME: we need to check the requirements for ECDSA.  */
172       if (mdlen < 20 || pkalgo == GCRY_PK_DSA)
173         return gpg_error (GPG_ERR_INV_LENGTH);
174     }
175
176   /* Truncate.  */
177   if (mdlen > qbits/8)
178     mdlen = qbits/8;
179
180   /* Create the S-expression.  We need to convert to an MPI first
181      because we want an unsigned integer.  Using %b directly is not
182      possible because libgcrypt assumes an mpi and uses
183      GCRYMPI_FMT_STD for parsing and thus possible yielding a negative
184      value.  */
185   {
186     gcry_mpi_t mpi;
187
188     err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_USG, md, mdlen, NULL);
189     if (!err)
190       {
191         err = gcry_sexp_build (&hash, NULL,
192                                "(data (flags raw) (value %m))", mpi);
193         gcry_mpi_release (mpi);
194       }
195   }
196   if (!err)
197     *r_hash = hash;
198   return err;
199 }
200
201
202 /* Special version of do_encode_md to take care of pkcs#1 padding.
203    For TLS-MD5SHA1 we need to do the padding ourself as Libgrypt does
204    not know about this special scheme.  Fixme: We should have a
205    pkcs1-only-padding flag for Libgcrypt. */
206 static int
207 do_encode_raw_pkcs1 (const byte *md, size_t mdlen, unsigned int nbits,
208                      gcry_sexp_t *r_hash)
209 {
210   int rc;
211   gcry_sexp_t hash;
212   unsigned char *frame;
213   size_t i, n, nframe;
214
215   nframe = (nbits+7) / 8;
216   if ( !mdlen || mdlen + 8 + 4 > nframe )
217     {
218       /* Can't encode this hash into a frame of size NFRAME. */
219       return gpg_error (GPG_ERR_TOO_SHORT);
220     }
221
222   frame = xtrymalloc (nframe);
223   if (!frame)
224     return gpg_error_from_syserror ();
225
226   /* Assemble the pkcs#1 block type 1. */
227   n = 0;
228   frame[n++] = 0;
229   frame[n++] = 1; /* Block type. */
230   i = nframe - mdlen - 3 ;
231   assert (i >= 8); /* At least 8 bytes of padding.  */
232   memset (frame+n, 0xff, i );
233   n += i;
234   frame[n++] = 0;
235   memcpy (frame+n, md, mdlen );
236   n += mdlen;
237   assert (n == nframe);
238
239   /* Create the S-expression.  */
240   rc = gcry_sexp_build (&hash, NULL,
241                         "(data (flags raw) (value %b))",
242                         (int)nframe, frame);
243   xfree (frame);
244
245   *r_hash = hash;
246   return rc;
247 }
248
249
250
251 /* SIGN whatever information we have accumulated in CTRL and return
252    the signature S-expression.  LOOKUP is an optional function to
253    provide a way for lower layers to ask for the caching TTL.  If a
254    CACHE_NONCE is given that cache item is first tried to get a
255    passphrase.  */
256 int
257 agent_pksign_do (ctrl_t ctrl, const char *cache_nonce,
258                  const char *desc_text,
259                  gcry_sexp_t *signature_sexp,
260                  cache_mode_t cache_mode, lookup_ttl_t lookup_ttl)
261 {
262   gcry_sexp_t s_skey = NULL, s_sig = NULL;
263   unsigned char *shadow_info = NULL;
264   unsigned int rc = 0;          /* FIXME: gpg-error? */
265
266   if (! ctrl->have_keygrip)
267     return gpg_error (GPG_ERR_NO_SECKEY);
268
269   rc = agent_key_from_file (ctrl, cache_nonce, desc_text, ctrl->keygrip,
270                             &shadow_info, cache_mode, lookup_ttl,
271                             &s_skey, NULL);
272   if (rc)
273     {
274       log_error ("failed to read the secret key\n");
275       goto leave;
276     }
277
278   if (!s_skey)
279     {
280       /* Divert operation to the smartcard */
281       gcry_sexp_t s_pkey, l;
282       const char *name;
283       size_t len;
284       unsigned char *buf = NULL;
285       int is_RSA = 0;
286       int is_ECDSA = 0;
287
288       /* Check keytype by public key */
289       rc = agent_public_key_from_file (ctrl, ctrl->keygrip, &s_pkey);
290       if (rc)
291         {
292           log_error ("failed to read the public key\n");
293           goto leave;
294         }
295       l = gcry_sexp_cadr (s_pkey);
296       name = gcry_sexp_nth_data (l, 0, &len);
297       if (len == 3 && !memcmp (name, "rsa", 3))
298         is_RSA = 1;
299       else if (len == 5 && !memcmp (name, "ecdsa", 5))
300         is_ECDSA = 1;
301       gcry_sexp_release (l);
302       gcry_sexp_release (s_pkey);
303
304       rc = divert_pksign (ctrl,
305                           ctrl->digest.value,
306                           ctrl->digest.valuelen,
307                           ctrl->digest.algo,
308                           shadow_info, &buf, &len);
309       if (rc)
310         {
311           log_error ("smartcard signing failed: %s\n", gpg_strerror (rc));
312           goto leave;
313         }
314
315       if (is_RSA)
316         {
317           if (*buf & 0x80)
318             {
319               len++;
320               buf = xtryrealloc (buf, len);
321               if (!buf)
322                 goto leave;
323
324               memmove (buf + 1, buf, len - 1);
325               *buf = 0;
326             }
327
328           rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%b)))", len, buf);
329         }
330       else if (is_ECDSA)
331         {
332           unsigned char *r_buf_allocated = NULL;
333           unsigned char *s_buf_allocated = NULL;
334           unsigned char *r_buf, *s_buf;
335           int r_buflen, s_buflen;
336
337           r_buflen = s_buflen = len/2;
338
339           if (*buf & 0x80)
340             {
341               r_buflen++;
342               r_buf_allocated = xtrymalloc (r_buflen);
343               if (!r_buf_allocated)
344                 goto leave;
345
346               r_buf = r_buf_allocated;
347               memcpy (r_buf + 1, buf, len/2);
348               *r_buf = 0;
349             }
350           else
351             r_buf = buf;
352
353           if (*(buf + len/2) & 0x80)
354             {
355               s_buflen++;
356               s_buf_allocated = xtrymalloc (s_buflen);
357               if (!s_buf_allocated)
358                 {
359                   xfree (r_buf_allocated);
360                   goto leave;
361                 }
362
363               s_buf = s_buf_allocated;
364               memcpy (s_buf + 1, buf + len/2, len/2);
365               *s_buf = 0;
366             }
367           else
368             s_buf = buf + len/2;
369
370           rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(ecdsa(r%b)(s%b)))",
371                                 r_buflen, r_buf,
372                                 s_buflen, s_buf);
373           xfree (r_buf_allocated);
374           xfree (s_buf_allocated);
375         }
376       else
377         rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
378
379       xfree (buf);
380       if (rc)
381         {
382           log_error ("failed to convert sigbuf returned by divert_pksign "
383                      "into S-Exp: %s", gpg_strerror (rc));
384           goto leave;
385         }
386     }
387   else
388     {
389       /* No smartcard, but a private key */
390       gcry_sexp_t s_hash = NULL;
391       int dsaalgo;
392
393       /* Put the hash into a sexp */
394       if (ctrl->digest.algo == MD_USER_TLS_MD5SHA1)
395         rc = do_encode_raw_pkcs1 (ctrl->digest.value,
396                                   ctrl->digest.valuelen,
397                                   gcry_pk_get_nbits (s_skey),
398                                   &s_hash);
399       else if ( (dsaalgo = agent_is_dsa_key (s_skey)) )
400         rc = do_encode_dsa (ctrl->digest.value,
401                             ctrl->digest.valuelen,
402                             dsaalgo, s_skey,
403                             &s_hash);
404       else
405         rc = do_encode_md (ctrl->digest.value,
406                            ctrl->digest.valuelen,
407                            ctrl->digest.algo,
408                            &s_hash,
409                            ctrl->digest.raw_value);
410       if (rc)
411         goto leave;
412
413       if (DBG_CRYPTO)
414         {
415           log_debug ("skey:\n");
416           gcry_sexp_dump (s_skey);
417           log_debug ("hash:\n");
418           gcry_sexp_dump (s_hash);
419         }
420
421       /* sign */
422       rc = gcry_pk_sign (&s_sig, s_hash, s_skey);
423       gcry_sexp_release (s_hash);
424       if (rc)
425         {
426           log_error ("signing failed: %s\n", gpg_strerror (rc));
427           goto leave;
428         }
429
430       if (DBG_CRYPTO)
431         {
432           log_debug ("result:\n");
433           gcry_sexp_dump (s_sig);
434         }
435     }
436
437  leave:
438
439   *signature_sexp = s_sig;
440
441   gcry_sexp_release (s_skey);
442   xfree (shadow_info);
443
444   return rc;
445 }
446
447 /* SIGN whatever information we have accumulated in CTRL and write it
448    back to OUTFP.  If a CACHE_NONCE is given that cache item is first
449    tried to get a passphrase.  */
450 int
451 agent_pksign (ctrl_t ctrl, const char *cache_nonce, const char *desc_text,
452               membuf_t *outbuf, cache_mode_t cache_mode)
453 {
454   gcry_sexp_t s_sig = NULL;
455   char *buf = NULL;
456   size_t len = 0;
457   int rc = 0;
458
459   rc = agent_pksign_do (ctrl, cache_nonce, desc_text, &s_sig, cache_mode, NULL);
460   if (rc)
461     goto leave;
462
463   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, NULL, 0);
464   assert (len);
465   buf = xmalloc (len);
466   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, buf, len);
467   assert (len);
468
469   put_membuf (outbuf, buf, len);
470
471  leave:
472   gcry_sexp_release (s_sig);
473   xfree (buf);
474
475   return rc;
476 }