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