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