agent: Cleanups to prepare implementation of Ed25519.
[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
328       key_type = agent_is_dsa_key (s_skey);
329       if (key_type == 0)
330         is_RSA = 1;
331       else if (key_type == GCRY_PK_ECDSA)
332         is_ECDSA = 1;
333
334       rc = divert_pksign (ctrl,
335                           data, datalen,
336                           ctrl->digest.algo,
337                           shadow_info, &buf, &len);
338       if (rc)
339         {
340           log_error ("smartcard signing failed: %s\n", gpg_strerror (rc));
341           goto leave;
342         }
343
344       if (is_RSA)
345         {
346           if (*buf & 0x80)
347             {
348               len++;
349               buf = xtryrealloc (buf, len);
350               if (!buf)
351                 goto leave;
352
353               memmove (buf + 1, buf, len - 1);
354               *buf = 0;
355             }
356
357           rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%b)))", len, buf);
358         }
359       else if (is_ECDSA)
360         {
361           unsigned char *r_buf_allocated = NULL;
362           unsigned char *s_buf_allocated = NULL;
363           unsigned char *r_buf, *s_buf;
364           int r_buflen, s_buflen;
365
366           r_buflen = s_buflen = len/2;
367
368           if (*buf & 0x80)
369             {
370               r_buflen++;
371               r_buf_allocated = xtrymalloc (r_buflen);
372               if (!r_buf_allocated)
373                 goto leave;
374
375               r_buf = r_buf_allocated;
376               memcpy (r_buf + 1, buf, len/2);
377               *r_buf = 0;
378             }
379           else
380             r_buf = buf;
381
382           if (*(buf + len/2) & 0x80)
383             {
384               s_buflen++;
385               s_buf_allocated = xtrymalloc (s_buflen);
386               if (!s_buf_allocated)
387                 {
388                   xfree (r_buf_allocated);
389                   goto leave;
390                 }
391
392               s_buf = s_buf_allocated;
393               memcpy (s_buf + 1, buf + len/2, len/2);
394               *s_buf = 0;
395             }
396           else
397             s_buf = buf + len/2;
398
399           rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(ecdsa(r%b)(s%b)))",
400                                 r_buflen, r_buf,
401                                 s_buflen, s_buf);
402           xfree (r_buf_allocated);
403           xfree (s_buf_allocated);
404         }
405       else
406         rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
407
408       xfree (buf);
409       if (rc)
410         {
411           log_error ("failed to convert sigbuf returned by divert_pksign "
412                      "into S-Exp: %s", gpg_strerror (rc));
413           goto leave;
414         }
415     }
416   else
417     {
418       /* No smartcard, but a private key */
419       gcry_sexp_t s_hash = NULL;
420       int dsaalgo;
421
422       /* Put the hash into a sexp */
423       if (agent_is_eddsa_key (s_skey))
424         rc = do_encode_eddsa (data, datalen,
425                               &s_hash);
426       else if (ctrl->digest.algo == MD_USER_TLS_MD5SHA1)
427         rc = do_encode_raw_pkcs1 (data, datalen,
428                                   gcry_pk_get_nbits (s_skey),
429                                   &s_hash);
430       else if ( (dsaalgo = agent_is_dsa_key (s_skey)) )
431         rc = do_encode_dsa (data, datalen,
432                             dsaalgo, s_skey,
433                             &s_hash);
434       else
435         rc = do_encode_md (data, datalen,
436                            ctrl->digest.algo,
437                            &s_hash,
438                            ctrl->digest.raw_value);
439       if (rc)
440         goto leave;
441
442       if (DBG_CRYPTO)
443         {
444           gcry_log_debugsxp ("skey", s_skey);
445           gcry_log_debugsxp ("hash", s_hash);
446         }
447
448       /* sign */
449       rc = gcry_pk_sign (&s_sig, s_hash, s_skey);
450       gcry_sexp_release (s_hash);
451       if (rc)
452         {
453           log_error ("signing failed: %s\n", gpg_strerror (rc));
454           goto leave;
455         }
456
457       if (DBG_CRYPTO)
458         gcry_log_debugsxp ("rslt", s_sig);
459     }
460
461  leave:
462
463   *signature_sexp = s_sig;
464
465   gcry_sexp_release (s_skey);
466   xfree (shadow_info);
467
468   return rc;
469 }
470
471 /* SIGN whatever information we have accumulated in CTRL and write it
472    back to OUTFP.  If a CACHE_NONCE is given that cache item is first
473    tried to get a passphrase.  */
474 int
475 agent_pksign (ctrl_t ctrl, const char *cache_nonce, const char *desc_text,
476               membuf_t *outbuf, cache_mode_t cache_mode)
477 {
478   gcry_sexp_t s_sig = NULL;
479   char *buf = NULL;
480   size_t len = 0;
481   int rc = 0;
482
483   rc = agent_pksign_do (ctrl, cache_nonce, desc_text, &s_sig, cache_mode, NULL,
484                         NULL, 0);
485   if (rc)
486     goto leave;
487
488   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, NULL, 0);
489   assert (len);
490   buf = xmalloc (len);
491   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, buf, len);
492   assert (len);
493
494   put_membuf (outbuf, buf, len);
495
496  leave:
497   gcry_sexp_release (s_sig);
498   xfree (buf);
499
500   return rc;
501 }