gpg: Do not bail on an invalid packet in the local keyring.
[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 <https://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 <sys/stat.h>
28
29 #include "agent.h"
30 #include "../common/i18n.h"
31
32
33 static int
34 do_encode_md (const byte * md, size_t mdlen, int algo, gcry_sexp_t * r_hash,
35               int raw_value)
36 {
37   gcry_sexp_t hash;
38   int rc;
39
40   if (!raw_value)
41     {
42       const char *s;
43       char tmp[16+1];
44       int i;
45
46       s = gcry_md_algo_name (algo);
47       if (s && strlen (s) < 16)
48         {
49           for (i=0; i < strlen (s); i++)
50             tmp[i] = tolower (s[i]);
51           tmp[i] = '\0';
52         }
53
54       rc = gcry_sexp_build (&hash, NULL,
55                             "(data (flags pkcs1) (hash %s %b))",
56                             tmp, (int)mdlen, md);
57     }
58   else
59     {
60       gcry_mpi_t mpi;
61
62       rc = gcry_mpi_scan (&mpi, GCRYMPI_FMT_USG, md, mdlen, NULL);
63       if (!rc)
64         {
65           rc = gcry_sexp_build (&hash, NULL,
66                                 "(data (flags raw) (value %m))",
67                                 mpi);
68           gcry_mpi_release (mpi);
69         }
70       else
71         hash = NULL;
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   /* ECDSA 521 is special has it is larger than the largest hash
191      we have (SHA-512).  Thus we change the size for further
192      processing to 512.  */
193   if (pkalgo == GCRY_PK_ECDSA && qbits > 512)
194     qbits = 512;
195
196   /* Check if we're too short.  Too long is safe as we'll
197      automatically left-truncate.  */
198   if (mdlen < qbits/8)
199     {
200       log_error (_("a %zu bit hash is not valid for a %u bit %s key\n"),
201                  mdlen*8,
202                  gcry_pk_get_nbits (pkey),
203                  gcry_pk_algo_name (pkalgo));
204       return gpg_error (GPG_ERR_INV_LENGTH);
205     }
206
207   /* Truncate.  */
208   if (mdlen > qbits/8)
209     mdlen = qbits/8;
210
211   /* Create the S-expression.  */
212   err = gcry_sexp_build (&hash, NULL,
213                          "(data (flags rfc6979) (hash %s %b))",
214                          rfc6979_hash_algo_string (mdlen),
215                          (int)mdlen, md);
216   if (!err)
217     *r_hash = hash;
218   return err;
219 }
220
221
222 /* Special version of do_encode_md to take care of pkcs#1 padding.
223    For TLS-MD5SHA1 we need to do the padding ourself as Libgrypt does
224    not know about this special scheme.  Fixme: We should have a
225    pkcs1-only-padding flag for Libgcrypt. */
226 static int
227 do_encode_raw_pkcs1 (const byte *md, size_t mdlen, unsigned int nbits,
228                      gcry_sexp_t *r_hash)
229 {
230   int rc;
231   gcry_sexp_t hash;
232   unsigned char *frame;
233   size_t i, n, nframe;
234
235   nframe = (nbits+7) / 8;
236   if ( !mdlen || mdlen + 8 + 4 > nframe )
237     {
238       /* Can't encode this hash into a frame of size NFRAME. */
239       return gpg_error (GPG_ERR_TOO_SHORT);
240     }
241
242   frame = xtrymalloc (nframe);
243   if (!frame)
244     return gpg_error_from_syserror ();
245
246   /* Assemble the pkcs#1 block type 1. */
247   n = 0;
248   frame[n++] = 0;
249   frame[n++] = 1; /* Block type. */
250   i = nframe - mdlen - 3 ;
251   log_assert (i >= 8); /* At least 8 bytes of padding.  */
252   memset (frame+n, 0xff, i );
253   n += i;
254   frame[n++] = 0;
255   memcpy (frame+n, md, mdlen );
256   n += mdlen;
257   log_assert (n == nframe);
258
259   /* Create the S-expression.  */
260   rc = gcry_sexp_build (&hash, NULL,
261                         "(data (flags raw) (value %b))",
262                         (int)nframe, frame);
263   xfree (frame);
264
265   *r_hash = hash;
266   return rc;
267 }
268
269
270
271 /* SIGN whatever information we have accumulated in CTRL and return
272  * the signature S-expression.  LOOKUP is an optional function to
273  * provide a way for lower layers to ask for the caching TTL.  If a
274  * CACHE_NONCE is given that cache item is first tried to get a
275  * passphrase.  If OVERRIDEDATA is not NULL, OVERRIDEDATALEN bytes
276  * from this buffer are used instead of the data in CTRL.  The
277  * override feature is required to allow the use of Ed25519 with ssh
278  * because Ed25519 does the hashing itself.  */
279 gpg_error_t
280 agent_pksign_do (ctrl_t ctrl, const char *cache_nonce,
281                  const char *desc_text,
282                  gcry_sexp_t *signature_sexp,
283                  cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
284                  const void *overridedata, size_t overridedatalen)
285 {
286   gpg_error_t err = 0;
287   gcry_sexp_t s_skey = NULL;
288   gcry_sexp_t s_sig  = NULL;
289   gcry_sexp_t s_hash = NULL;
290   gcry_sexp_t s_pkey = NULL;
291   unsigned char *shadow_info = NULL;
292   const unsigned char *data;
293   int datalen;
294   int check_signature = 0;
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   err = agent_key_from_file (ctrl, cache_nonce, desc_text, ctrl->keygrip,
311                              &shadow_info, cache_mode, lookup_ttl,
312                              &s_skey, NULL);
313   if (err)
314     {
315       if (gpg_err_code (err) != 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       err = agent_public_key_from_file (ctrl, ctrl->keygrip, &s_pkey);
331       if (err)
332         {
333           log_error ("failed to read the public key\n");
334           goto leave;
335         }
336
337       if (agent_is_eddsa_key (s_skey))
338         is_EdDSA = 1;
339       else
340         {
341           key_type = agent_is_dsa_key (s_skey);
342           if (key_type == 0)
343             is_RSA = 1;
344           else if (key_type == GCRY_PK_ECDSA)
345             is_ECDSA = 1;
346         }
347
348       {
349         char *desc2 = NULL;
350
351         if (desc_text)
352           agent_modify_description (desc_text, NULL, s_skey, &desc2);
353
354         err = divert_pksign (ctrl, desc2? desc2 : desc_text,
355                              ctrl->keygrip,
356                              data, datalen,
357                              ctrl->digest.algo,
358                              shadow_info, &buf, &len);
359         xfree (desc2);
360       }
361       if (err)
362         {
363           log_error ("smartcard signing failed: %s\n", gpg_strerror (err));
364           goto leave;
365         }
366
367       if (is_RSA)
368         {
369           unsigned char *p = buf;
370
371           check_signature = 1;
372
373           /*
374            * Smartcard returns fixed-size data, which is good for
375            * PKCS1.  If variable-size unsigned MPI is needed, remove
376            * zeros.
377            */
378           if (ctrl->digest.algo == MD_USER_TLS_MD5SHA1
379               || ctrl->digest.raw_value)
380             {
381               int i;
382
383               for (i = 0; i < len - 1; i++)
384                 if (p[i])
385                   break;
386               p += i;
387               len -= i;
388             }
389
390           err = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%b)))",
391                                  (int)len, p);
392         }
393       else if (is_EdDSA)
394         {
395           err = gcry_sexp_build (&s_sig, NULL, "(sig-val(eddsa(r%b)(s%b)))",
396                                  (int)len/2, buf, (int)len/2, buf + len/2);
397         }
398       else if (is_ECDSA)
399         {
400           unsigned char *r_buf, *s_buf;
401           int r_buflen, s_buflen;
402           int i;
403
404           r_buflen = s_buflen = len/2;
405
406           /*
407            * Smartcard returns fixed-size data.  For ECDSA signature,
408            * variable-size unsigned MPI is assumed, thus, remove
409            * zeros.
410            */
411           r_buf = buf;
412           for (i = 0; i < r_buflen - 1; i++)
413             if (r_buf[i])
414               break;
415           r_buf += i;
416           r_buflen -= i;
417
418           s_buf = buf + len/2;
419           for (i = 0; i < s_buflen - 1; i++)
420             if (s_buf[i])
421               break;
422           s_buf += i;
423           s_buflen -= i;
424
425           err = gcry_sexp_build (&s_sig, NULL, "(sig-val(ecdsa(r%b)(s%b)))",
426                                  r_buflen, r_buf,
427                                  s_buflen, s_buf);
428         }
429       else
430         err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
431
432       xfree (buf);
433       if (err)
434         {
435           log_error ("failed to convert sigbuf returned by divert_pksign "
436                      "into S-Exp: %s", gpg_strerror (err));
437           goto leave;
438         }
439     }
440   else
441     {
442       /* No smartcard, but a private key */
443       int dsaalgo = 0;
444
445       /* Put the hash into a sexp */
446       if (agent_is_eddsa_key (s_skey))
447         err = do_encode_eddsa (data, datalen,
448                                &s_hash);
449       else if (ctrl->digest.algo == MD_USER_TLS_MD5SHA1)
450         err = do_encode_raw_pkcs1 (data, datalen,
451                                    gcry_pk_get_nbits (s_skey),
452                                    &s_hash);
453       else if ( (dsaalgo = agent_is_dsa_key (s_skey)) )
454         err = do_encode_dsa (data, datalen,
455                              dsaalgo, s_skey,
456                              &s_hash);
457       else
458         err = do_encode_md (data, datalen,
459                             ctrl->digest.algo,
460                             &s_hash,
461                             ctrl->digest.raw_value);
462       if (err)
463         goto leave;
464
465       if (dsaalgo == 0 && GCRYPT_VERSION_NUMBER < 0x010700)
466         {
467           /* It's RSA and Libgcrypt < 1.7 */
468           check_signature = 1;
469         }
470
471       if (DBG_CRYPTO)
472         {
473           gcry_log_debugsxp ("skey", s_skey);
474           gcry_log_debugsxp ("hash", s_hash);
475         }
476
477       /* sign */
478       err = gcry_pk_sign (&s_sig, s_hash, s_skey);
479       if (err)
480         {
481           log_error ("signing failed: %s\n", gpg_strerror (err));
482           goto leave;
483         }
484
485       if (DBG_CRYPTO)
486         gcry_log_debugsxp ("rslt", s_sig);
487     }
488
489   /* Check that the signature verification worked and nothing is
490    * fooling us e.g. by a bug in the signature create code or by
491    * deliberately introduced faults.  Because Libgcrypt 1.7 does this
492    * for RSA internally there is no need to do it here again.  */
493   if (check_signature)
494     {
495       gcry_sexp_t sexp_key = s_pkey? s_pkey: s_skey;
496
497       if (s_hash == NULL)
498         {
499           if (ctrl->digest.algo == MD_USER_TLS_MD5SHA1)
500             err = do_encode_raw_pkcs1 (data, datalen,
501                                        gcry_pk_get_nbits (sexp_key), &s_hash);
502           else
503             err = do_encode_md (data, datalen, ctrl->digest.algo, &s_hash,
504                                 ctrl->digest.raw_value);
505         }
506
507       if (!err)
508         err = gcry_pk_verify (s_sig, s_hash, sexp_key);
509
510       if (err)
511         {
512           log_error (_("checking created signature failed: %s\n"),
513                      gpg_strerror (err));
514           gcry_sexp_release (s_sig);
515           s_sig = NULL;
516         }
517     }
518
519  leave:
520
521   *signature_sexp = s_sig;
522
523   gcry_sexp_release (s_pkey);
524   gcry_sexp_release (s_skey);
525   gcry_sexp_release (s_hash);
526   xfree (shadow_info);
527
528   return err;
529 }
530
531
532 /* SIGN whatever information we have accumulated in CTRL and write it
533  * back to OUTFP.  If a CACHE_NONCE is given that cache item is first
534  * tried to get a passphrase.  */
535 gpg_error_t
536 agent_pksign (ctrl_t ctrl, const char *cache_nonce, const char *desc_text,
537               membuf_t *outbuf, cache_mode_t cache_mode)
538 {
539   gpg_error_t err;
540   gcry_sexp_t s_sig = NULL;
541   char *buf = NULL;
542   size_t len = 0;
543
544   err = agent_pksign_do (ctrl, cache_nonce, desc_text, &s_sig, cache_mode,
545                          NULL, NULL, 0);
546   if (err)
547     goto leave;
548
549   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, NULL, 0);
550   log_assert (len);
551   buf = xtrymalloc (len);
552   if (!buf)
553     {
554       err = gpg_error_from_syserror ();
555       goto leave;
556     }
557   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, buf, len);
558   log_assert (len);
559   put_membuf (outbuf, buf, len);
560
561  leave:
562   gcry_sexp_release (s_sig);
563   xfree (buf);
564
565   return err;
566 }