agent: Use different translation func for Pinentry strings.
[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)))",
367                                 (int)len, buf);
368         }
369       else if (is_EdDSA)
370         {
371           rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(eddsa(r%b)(s%b)))",
372                                 (int)len/2, buf, (int)len/2, buf + len/2);
373         }
374       else if (is_ECDSA)
375         {
376           unsigned char *r_buf_allocated = NULL;
377           unsigned char *s_buf_allocated = NULL;
378           unsigned char *r_buf, *s_buf;
379           int r_buflen, s_buflen;
380
381           r_buflen = s_buflen = len/2;
382
383           if (*buf & 0x80)
384             {
385               r_buflen++;
386               r_buf_allocated = xtrymalloc (r_buflen);
387               if (!r_buf_allocated)
388                 goto leave;
389
390               r_buf = r_buf_allocated;
391               memcpy (r_buf + 1, buf, len/2);
392               *r_buf = 0;
393             }
394           else
395             r_buf = buf;
396
397           if (*(buf + len/2) & 0x80)
398             {
399               s_buflen++;
400               s_buf_allocated = xtrymalloc (s_buflen);
401               if (!s_buf_allocated)
402                 {
403                   xfree (r_buf_allocated);
404                   goto leave;
405                 }
406
407               s_buf = s_buf_allocated;
408               memcpy (s_buf + 1, buf + len/2, len/2);
409               *s_buf = 0;
410             }
411           else
412             s_buf = buf + len/2;
413
414           rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(ecdsa(r%b)(s%b)))",
415                                 r_buflen, r_buf,
416                                 s_buflen, s_buf);
417           xfree (r_buf_allocated);
418           xfree (s_buf_allocated);
419         }
420       else
421         rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
422
423       xfree (buf);
424       if (rc)
425         {
426           log_error ("failed to convert sigbuf returned by divert_pksign "
427                      "into S-Exp: %s", gpg_strerror (rc));
428           goto leave;
429         }
430     }
431   else
432     {
433       /* No smartcard, but a private key */
434       gcry_sexp_t s_hash = NULL;
435       int dsaalgo;
436
437       /* Put the hash into a sexp */
438       if (agent_is_eddsa_key (s_skey))
439         rc = do_encode_eddsa (data, datalen,
440                               &s_hash);
441       else if (ctrl->digest.algo == MD_USER_TLS_MD5SHA1)
442         rc = do_encode_raw_pkcs1 (data, datalen,
443                                   gcry_pk_get_nbits (s_skey),
444                                   &s_hash);
445       else if ( (dsaalgo = agent_is_dsa_key (s_skey)) )
446         rc = do_encode_dsa (data, datalen,
447                             dsaalgo, s_skey,
448                             &s_hash);
449       else
450         rc = do_encode_md (data, datalen,
451                            ctrl->digest.algo,
452                            &s_hash,
453                            ctrl->digest.raw_value);
454       if (rc)
455         goto leave;
456
457       if (DBG_CRYPTO)
458         {
459           gcry_log_debugsxp ("skey", s_skey);
460           gcry_log_debugsxp ("hash", s_hash);
461         }
462
463       /* sign */
464       rc = gcry_pk_sign (&s_sig, s_hash, s_skey);
465       gcry_sexp_release (s_hash);
466       if (rc)
467         {
468           log_error ("signing failed: %s\n", gpg_strerror (rc));
469           goto leave;
470         }
471
472       if (DBG_CRYPTO)
473         gcry_log_debugsxp ("rslt", s_sig);
474     }
475
476  leave:
477
478   *signature_sexp = s_sig;
479
480   gcry_sexp_release (s_skey);
481   xfree (shadow_info);
482
483   return rc;
484 }
485
486 /* SIGN whatever information we have accumulated in CTRL and write it
487    back to OUTFP.  If a CACHE_NONCE is given that cache item is first
488    tried to get a passphrase.  */
489 int
490 agent_pksign (ctrl_t ctrl, const char *cache_nonce, const char *desc_text,
491               membuf_t *outbuf, cache_mode_t cache_mode)
492 {
493   gcry_sexp_t s_sig = NULL;
494   char *buf = NULL;
495   size_t len = 0;
496   int rc = 0;
497
498   rc = agent_pksign_do (ctrl, cache_nonce, desc_text, &s_sig, cache_mode, NULL,
499                         NULL, 0);
500   if (rc)
501     goto leave;
502
503   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, NULL, 0);
504   assert (len);
505   buf = xmalloc (len);
506   len = gcry_sexp_sprint (s_sig, GCRYSEXP_FMT_CANON, buf, len);
507   assert (len);
508
509   put_membuf (outbuf, buf, len);
510
511  leave:
512   gcry_sexp_release (s_sig);
513   xfree (buf);
514
515   return rc;
516 }