Switch to deterministic DSA.
[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  * Copyright (C) 2013  Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <assert.h>
28 #include <unistd.h>
29 #include <sys/stat.h>
30
31 #include "agent.h"
32 #include "i18n.h"
33
34
35 static int
36 do_encode_md (const byte * md, size_t mdlen, int algo, gcry_sexp_t * r_hash,
37               int raw_value)
38 {
39   gcry_sexp_t hash;
40   int rc;
41
42   if (!raw_value)
43     {
44       const char *s;
45       char tmp[16+1];
46       int i;
47
48       s = gcry_md_algo_name (algo);
49       if (s && strlen (s) < 16)
50         {
51           for (i=0; i < strlen (s); i++)
52             tmp[i] = tolower (s[i]);
53           tmp[i] = '\0';
54         }
55
56       rc = gcry_sexp_build (&hash, NULL,
57                             "(data (flags pkcs1) (hash %s %b))",
58                             tmp, (int)mdlen, md);
59     }
60   else
61     {
62       gcry_mpi_t mpi;
63
64       rc = gcry_mpi_scan (&mpi, GCRYMPI_FMT_USG, md, mdlen, NULL);
65       if (! rc)
66         {
67           rc = gcry_sexp_build (&hash, NULL,
68                                 "(data (flags raw) (value %m))",
69                                 mpi);
70           gcry_mpi_release (mpi);
71         }
72
73     }
74
75   *r_hash = hash;
76   return rc;
77 }
78
79
80 /* Return the number of bits of the Q parameter from the DSA key
81    KEY.  */
82 static unsigned int
83 get_dsa_qbits (gcry_sexp_t key)
84 {
85   gcry_sexp_t l1, l2;
86   gcry_mpi_t q;
87   unsigned int nbits;
88
89   l1 = gcry_sexp_find_token (key, "private-key", 0);
90   if (!l1)
91     l1 = gcry_sexp_find_token (key, "protected-private-key", 0);
92   if (!l1)
93     l1 = gcry_sexp_find_token (key, "shadowed-private-key", 0);
94   if (!l1)
95     l1 = gcry_sexp_find_token (key, "public-key", 0);
96   if (!l1)
97     return 0; /* Does not contain a key object.  */
98   l2 = gcry_sexp_cadr (l1);
99   gcry_sexp_release  (l1);
100   l1 = gcry_sexp_find_token (l2, "q", 1);
101   gcry_sexp_release (l2);
102   if (!l1)
103     return 0; /* Invalid object.  */
104   q = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
105   gcry_sexp_release (l1);
106   if (!q)
107     return 0; /* Missing value.  */
108   nbits = gcry_mpi_get_nbits (q);
109   gcry_mpi_release (q);
110
111   return nbits;
112 }
113
114
115 /* Return an appropriate hash algorithm to be used with RFC-6979 for a
116    message digest of length MDLEN.  Although a fallback of SHA-256 is
117    used the current implementation in Libgcrypt will reject a hash
118    algorithm which does not match the length of the message.  */
119 static const char *
120 rfc6979_hash_algo_string (size_t mdlen)
121 {
122   switch (mdlen)
123     {
124     case 20: return "sha1";
125     case 28: return "sha224";
126     case 32: return "sha256";
127     case 48: return "sha384";
128     case 64: return "sha512";
129     default: return "sha256";
130     }
131 }
132
133
134 /* Encode a message digest for use with an DSA algorithm. */
135 static gpg_error_t
136 do_encode_dsa (const byte *md, size_t mdlen, int dsaalgo, gcry_sexp_t pkey,
137                gcry_sexp_t *r_hash)
138 {
139   gpg_error_t err;
140   gcry_sexp_t hash;
141   unsigned int qbits;
142   int pkalgo;
143
144   *r_hash = NULL;
145
146   pkalgo = map_pk_openpgp_to_gcry (dsaalgo);
147
148   if (pkalgo == GCRY_PK_ECDSA)
149     qbits = gcry_pk_get_nbits (pkey);
150   else if (pkalgo == GCRY_PK_DSA)
151     qbits = get_dsa_qbits (pkey);
152   else
153     return gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
154
155   if (pkalgo == GCRY_PK_DSA && (qbits%8))
156     {
157       /* FIXME: We check the QBITS but print a message about the hash
158          length.  */
159       log_error (_("DSA requires the hash length to be a"
160                    " multiple of 8 bits\n"));
161       return gpg_error (GPG_ERR_INV_LENGTH);
162     }
163
164   /* Don't allow any Q smaller than 160 bits.  We don't want someone
165      to issue signatures from a key with a 16-bit Q or something like
166      that, which would look correct but allow trivial forgeries.  Yes,
167      I know this rules out using MD5 with DSA. ;) */
168   if (qbits < 160)
169     {
170       log_error (_("%s key uses an unsafe (%u bit) hash\n"),
171                  gcry_pk_algo_name (pkalgo), qbits);
172       return gpg_error (GPG_ERR_INV_LENGTH);
173     }
174
175   /* Check if we're too short.  Too long is safe as we'll
176    * automatically left-truncate.
177    *
178    * This check would require the use of SHA512 with ECDSA 512. I
179    * think this is overkill to fail in this case.  Therefore, relax
180    * the check, but only for ECDSA keys.  We may need to adjust it
181    * later for general case.  (Note that the check is really a bug for
182    * ECDSA 521 as the only hash that matches it is SHA 512, but 512 <
183    * 521 ).
184    */
185   if (mdlen < ((pkalgo==GCRY_PK_ECDSA && qbits > 521) ? 512 : qbits)/8)
186     {
187       log_error (_("a %zu bit hash is not valid for a %u bit %s key\n"),
188                  mdlen*8,
189                  gcry_pk_get_nbits (pkey),
190                  gcry_pk_algo_name (pkalgo));
191       /* FIXME: we need to check the requirements for ECDSA.  */
192       if (mdlen < 20 || pkalgo == GCRY_PK_DSA)
193         return gpg_error (GPG_ERR_INV_LENGTH);
194     }
195
196   /* Truncate.  */
197   if (mdlen > qbits/8)
198     mdlen = qbits/8;
199
200   /* Create the S-expression.  If we are using Libgcrypt 1.6 we make
201      use of Deterministic DSA.  Libgcrypt < 1.6 does not implement
202      RFC-6979 and also requires us to convert to an MPI because it
203      expects an unsigned integer.  Using %b directly is not possible
204      because Libgcrypt assumes an MPI and uses GCRYMPI_FMT_STD for
205      parsing and thus possible yielding a negative value.  */
206 #if GCRYPT_VERSION_NUMBER >= 0x010600 /* Libgcrypt >= 1.6 */
207   {
208     err = gcry_sexp_build (&hash, NULL,
209                            "(data (flags rfc6979) (hash %s %b))",
210                            rfc6979_hash_algo_string (mdlen),
211                            (int)mdlen, md);
212   }
213 #else /* Libgcrypt < 1.6 */
214   {
215     gcry_mpi_t mpi;
216
217     err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_USG, md, mdlen, NULL);
218     if (!err)
219       {
220         err = gcry_sexp_build (&hash, NULL,
221                                "(data (flags raw) (value %m))", mpi);
222         gcry_mpi_release (mpi);
223       }
224   }
225 #endif /* Libgcrypt < 1.6 */
226   if (!err)
227     *r_hash = hash;
228   return err;
229 }
230
231
232 /* Special version of do_encode_md to take care of pkcs#1 padding.
233    For TLS-MD5SHA1 we need to do the padding ourself as Libgrypt does
234    not know about this special scheme.  Fixme: We should have a
235    pkcs1-only-padding flag for Libgcrypt. */
236 static int
237 do_encode_raw_pkcs1 (const byte *md, size_t mdlen, unsigned int nbits,
238                      gcry_sexp_t *r_hash)
239 {
240   int rc;
241   gcry_sexp_t hash;
242   unsigned char *frame;
243   size_t i, n, nframe;
244
245   nframe = (nbits+7) / 8;
246   if ( !mdlen || mdlen + 8 + 4 > nframe )
247     {
248       /* Can't encode this hash into a frame of size NFRAME. */
249       return gpg_error (GPG_ERR_TOO_SHORT);
250     }
251
252   frame = xtrymalloc (nframe);
253   if (!frame)
254     return gpg_error_from_syserror ();
255
256   /* Assemble the pkcs#1 block type 1. */
257   n = 0;
258   frame[n++] = 0;
259   frame[n++] = 1; /* Block type. */
260   i = nframe - mdlen - 3 ;
261   assert (i >= 8); /* At least 8 bytes of padding.  */
262   memset (frame+n, 0xff, i );
263   n += i;
264   frame[n++] = 0;
265   memcpy (frame+n, md, mdlen );
266   n += mdlen;
267   assert (n == nframe);
268
269   /* Create the S-expression.  */
270   rc = gcry_sexp_build (&hash, NULL,
271                         "(data (flags raw) (value %b))",
272                         (int)nframe, frame);
273   xfree (frame);
274
275   *r_hash = hash;
276   return rc;
277 }
278
279
280
281 /* SIGN whatever information we have accumulated in CTRL and return
282    the signature S-expression.  LOOKUP is an optional function to
283    provide a way for lower layers to ask for the caching TTL.  If a
284    CACHE_NONCE is given that cache item is first tried to get a
285    passphrase.  */
286 int
287 agent_pksign_do (ctrl_t ctrl, const char *cache_nonce,
288                  const char *desc_text,
289                  gcry_sexp_t *signature_sexp,
290                  cache_mode_t cache_mode, lookup_ttl_t lookup_ttl)
291 {
292   gcry_sexp_t s_skey = NULL, s_sig = NULL;
293   unsigned char *shadow_info = NULL;
294   unsigned int rc = 0;          /* FIXME: gpg-error? */
295
296   if (! ctrl->have_keygrip)
297     return gpg_error (GPG_ERR_NO_SECKEY);
298
299   rc = agent_key_from_file (ctrl, cache_nonce, desc_text, ctrl->keygrip,
300                             &shadow_info, cache_mode, lookup_ttl,
301                             &s_skey, NULL);
302   if (rc)
303     {
304       log_error ("failed to read the secret key\n");
305       goto leave;
306     }
307
308   if (!s_skey)
309     {
310       /* Divert operation to the smartcard */
311       gcry_sexp_t s_pkey, l;
312       const char *name;
313       size_t len;
314       unsigned char *buf = NULL;
315       int is_RSA = 0;
316       int is_ECDSA = 0;
317
318       /* Check keytype by public key */
319       rc = agent_public_key_from_file (ctrl, ctrl->keygrip, &s_pkey);
320       if (rc)
321         {
322           log_error ("failed to read the public key\n");
323           goto leave;
324         }
325       l = gcry_sexp_cadr (s_pkey);
326       name = gcry_sexp_nth_data (l, 0, &len);
327       if (len == 3 && !memcmp (name, "rsa", 3))
328         is_RSA = 1;
329       else if (len == 5 && !memcmp (name, "ecdsa", 5))
330         is_ECDSA = 1;
331       gcry_sexp_release (l);
332       gcry_sexp_release (s_pkey);
333
334       rc = divert_pksign (ctrl,
335                           ctrl->digest.value,
336                           ctrl->digest.valuelen,
337                           ctrl->digest.algo,
338                           shadow_info, &buf, &len);
339       if (rc)
340         {
341           log_error ("smartcard signing failed: %s\n", gpg_strerror (rc));
342           goto leave;
343         }
344
345       if (is_RSA)
346         {
347           if (*buf & 0x80)
348             {
349               len++;
350               buf = xtryrealloc (buf, len);
351               if (!buf)
352                 goto leave;
353
354               memmove (buf + 1, buf, len - 1);
355               *buf = 0;
356             }
357
358           rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%b)))", len, buf);
359         }
360       else if (is_ECDSA)
361         {
362           unsigned char *r_buf_allocated = NULL;
363           unsigned char *s_buf_allocated = NULL;
364           unsigned char *r_buf, *s_buf;
365           int r_buflen, s_buflen;
366
367           r_buflen = s_buflen = len/2;
368
369           if (*buf & 0x80)
370             {
371               r_buflen++;
372               r_buf_allocated = xtrymalloc (r_buflen);
373               if (!r_buf_allocated)
374                 goto leave;
375
376               r_buf = r_buf_allocated;
377               memcpy (r_buf + 1, buf, len/2);
378               *r_buf = 0;
379             }
380           else
381             r_buf = buf;
382
383           if (*(buf + len/2) & 0x80)
384             {
385               s_buflen++;
386               s_buf_allocated = xtrymalloc (s_buflen);
387               if (!s_buf_allocated)
388                 {
389                   xfree (r_buf_allocated);
390                   goto leave;
391                 }
392
393               s_buf = s_buf_allocated;
394               memcpy (s_buf + 1, buf + len/2, len/2);
395               *s_buf = 0;
396             }
397           else
398             s_buf = buf + len/2;
399
400           rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(ecdsa(r%b)(s%b)))",
401                                 r_buflen, r_buf,
402                                 s_buflen, s_buf);
403           xfree (r_buf_allocated);
404           xfree (s_buf_allocated);
405         }
406       else
407         rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
408
409       xfree (buf);
410       if (rc)
411         {
412           log_error ("failed to convert sigbuf returned by divert_pksign "
413                      "into S-Exp: %s", gpg_strerror (rc));
414           goto leave;
415         }
416     }
417   else
418     {
419       /* No smartcard, but a private key */
420       gcry_sexp_t s_hash = NULL;
421       int dsaalgo;
422
423       /* Put the hash into a sexp */
424       if (ctrl->digest.algo == MD_USER_TLS_MD5SHA1)
425         rc = do_encode_raw_pkcs1 (ctrl->digest.value,
426                                   ctrl->digest.valuelen,
427                                   gcry_pk_get_nbits (s_skey),
428                                   &s_hash);
429       else if ( (dsaalgo = agent_is_dsa_key (s_skey)) )
430         rc = do_encode_dsa (ctrl->digest.value,
431                             ctrl->digest.valuelen,
432                             dsaalgo, s_skey,
433                             &s_hash);
434       else
435         rc = do_encode_md (ctrl->digest.value,
436                            ctrl->digest.valuelen,
437                            ctrl->digest.algo,
438                            &s_hash,
439                            ctrl->digest.raw_value);
440       if (rc)
441         goto leave;
442
443       if (DBG_CRYPTO)
444         {
445           log_debug ("skey:\n");
446           gcry_sexp_dump (s_skey);
447           log_debug ("hash:\n");
448           gcry_sexp_dump (s_hash);
449         }
450
451       /* sign */
452       rc = gcry_pk_sign (&s_sig, s_hash, s_skey);
453       gcry_sexp_release (s_hash);
454       if (rc)
455         {
456           log_error ("signing failed: %s\n", gpg_strerror (rc));
457           goto leave;
458         }
459
460       if (DBG_CRYPTO)
461         {
462           log_debug ("result:\n");
463           gcry_sexp_dump (s_sig);
464         }
465     }
466
467  leave:
468
469   *signature_sexp = s_sig;
470
471   gcry_sexp_release (s_skey);
472   xfree (shadow_info);
473
474   return rc;
475 }
476
477 /* SIGN whatever information we have accumulated in CTRL and write it
478    back to OUTFP.  If a CACHE_NONCE is given that cache item is first
479    tried to get a passphrase.  */
480 int
481 agent_pksign (ctrl_t ctrl, const char *cache_nonce, const char *desc_text,
482               membuf_t *outbuf, cache_mode_t cache_mode)
483 {
484   gcry_sexp_t s_sig = NULL;
485   char *buf = NULL;
486   size_t len = 0;
487   int rc = 0;
488
489   rc = agent_pksign_do (ctrl, cache_nonce, desc_text, &s_sig, cache_mode, NULL);
490   if (rc)
491     goto leave;
492
493   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, NULL, 0);
494   assert (len);
495   buf = xmalloc (len);
496   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, buf, len);
497   assert (len);
498
499   put_membuf (outbuf, buf, len);
500
501  leave:
502   gcry_sexp_release (s_sig);
503   xfree (buf);
504
505   return rc;
506 }