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