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