agent: Fix saving with FORCE=1.
[gnupg.git] / agent / findkey.c
1 /* findkey.c - Locate the secret key
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007,
3  *               2010, 2011 Free Software Foundation, Inc.
4  * Copyright (C) 2014 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <ctype.h>
28 #include <fcntl.h>
29 #include <assert.h>
30 #include <unistd.h>
31 #include <sys/stat.h>
32 #include <assert.h>
33 #include <npth.h> /* (we use pth_sleep) */
34
35 #include "agent.h"
36 #include "i18n.h"
37 #include "../common/ssh-utils.h"
38 #include "../common/name-value.h"
39
40 #ifndef O_BINARY
41 #define O_BINARY 0
42 #endif
43
44 /* Helper to pass data to the check callback of the unprotect function. */
45 struct try_unprotect_arg_s
46 {
47   ctrl_t ctrl;
48   const unsigned char *protected_key;
49   unsigned char *unprotected_key;
50   int change_required; /* Set by the callback to indicate that the
51                           user should change the passphrase.  */
52 };
53
54
55 static gpg_error_t
56 write_extended_private_key (char *fname, estream_t fp,
57                             const void *buf, size_t len)
58 {
59   gpg_error_t err;
60   nvc_t pk = NULL;
61   gcry_sexp_t key = NULL;
62   int remove = 0;
63   int line;
64
65   err = nvc_parse_private_key (&pk, &line, fp);
66   if (err)
67     {
68       log_error ("error parsing '%s' line %d: %s\n",
69                  fname, line, gpg_strerror (err));
70       goto leave;
71     }
72
73   err = gcry_sexp_sscan (&key, NULL, buf, len);
74   if (err)
75     goto leave;
76
77   err = nvc_set_private_key (pk, key);
78   if (err)
79     goto leave;
80
81   err = es_fseek (fp, 0, SEEK_SET);
82   if (err)
83     goto leave;
84
85   err = nvc_write (pk, fp);
86   if (err)
87     {
88       log_error ("error writing '%s': %s\n", fname, gpg_strerror (err));
89       remove = 1;
90       goto leave;
91     }
92
93   if (ftruncate (es_fileno (fp), es_ftello (fp)))
94     {
95       err = gpg_error_from_syserror ();
96       log_error ("error truncating '%s': %s\n", fname, gpg_strerror (err));
97       remove = 1;
98       goto leave;
99     }
100
101   if (es_fclose (fp))
102     {
103       err = gpg_error_from_syserror ();
104       log_error ("error closing '%s': %s\n", fname, gpg_strerror (err));
105       remove = 1;
106       goto leave;
107     }
108   else
109     fp = NULL;
110
111   bump_key_eventcounter ();
112
113  leave:
114   if (fp)
115     es_fclose (fp);
116   if (remove)
117     gnupg_remove (fname);
118   xfree (fname);
119   gcry_sexp_release (key);
120   nvc_release (pk);
121   return err;
122 }
123
124 /* Write an S-expression formatted key to our key storage.  With FORCE
125    passed as true an existing key with the given GRIP will get
126    overwritten.  */
127 int
128 agent_write_private_key (const unsigned char *grip,
129                          const void *buffer, size_t length, int force)
130 {
131   char *fname;
132   estream_t fp;
133   char hexgrip[40+4+1];
134
135   bin2hex (grip, 20, hexgrip);
136   strcpy (hexgrip+40, ".key");
137
138   fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
139                          hexgrip, NULL);
140
141   /* FIXME: Write to a temp file first so that write failures during
142      key updates won't lead to a key loss.  */
143
144   if (!force && !access (fname, F_OK))
145     {
146       log_error ("secret key file '%s' already exists\n", fname);
147       xfree (fname);
148       return gpg_error (GPG_ERR_EEXIST);
149     }
150
151   fp = es_fopen (fname, force? "rb+,mode=-rw" : "wbx,mode=-rw");
152   if (!fp)
153     {
154       gpg_error_t tmperr = gpg_error_from_syserror ();
155
156       if (force && gpg_err_code (tmperr) == GPG_ERR_ENOENT)
157         {
158           fp = es_fopen (fname, "wbx,mode=-rw");
159           if (!fp)
160             {
161               tmperr = gpg_error_from_syserror ();
162               goto error;
163             }
164         }
165       else
166         {
167         error:
168           log_error ("can't create '%s': %s\n", fname, gpg_strerror (tmperr));
169           xfree (fname);
170           return tmperr;
171         }
172     }
173   else if (force)
174     {
175       gpg_error_t rc;
176       char first;
177
178       /* See if an existing key is in extended format.  */
179       if (es_fread (&first, 1, 1, fp) != 1)
180         {
181           rc = gpg_error_from_syserror ();
182           log_error ("error reading first byte from '%s': %s\n",
183                      fname, strerror (errno));
184           xfree (fname);
185           es_fclose (fp);
186           return rc;
187         }
188
189       rc = es_fseek (fp, 0, SEEK_SET);
190       if (rc)
191         {
192           log_error ("error seeking in '%s': %s\n", fname, strerror (errno));
193           xfree (fname);
194           es_fclose (fp);
195           return rc;
196         }
197
198       if (first != '(')
199         {
200           /* Key is in extended format.  */
201           return write_extended_private_key (fname, fp, buffer, length);
202         }
203     }
204
205   if (es_fwrite (buffer, length, 1, fp) != 1)
206     {
207       gpg_error_t tmperr = gpg_error_from_syserror ();
208       log_error ("error writing '%s': %s\n", fname, gpg_strerror (tmperr));
209       es_fclose (fp);
210       gnupg_remove (fname);
211       xfree (fname);
212       return tmperr;
213     }
214
215   /* When force is given, the file might have to be truncated.  */
216   if (force && ftruncate (es_fileno (fp), es_ftello (fp)))
217     {
218       gpg_error_t tmperr = gpg_error_from_syserror ();
219       log_error ("error truncating '%s': %s\n", fname, gpg_strerror (tmperr));
220       es_fclose (fp);
221       gnupg_remove (fname);
222       xfree (fname);
223       return tmperr;
224     }
225
226   if (es_fclose (fp))
227     {
228       gpg_error_t tmperr = gpg_error_from_syserror ();
229       log_error ("error closing '%s': %s\n", fname, gpg_strerror (tmperr));
230       gnupg_remove (fname);
231       xfree (fname);
232       return tmperr;
233     }
234   bump_key_eventcounter ();
235   xfree (fname);
236   return 0;
237 }
238
239
240 /* Callback function to try the unprotection from the passphrase query
241    code. */
242 static gpg_error_t
243 try_unprotect_cb (struct pin_entry_info_s *pi)
244 {
245   struct try_unprotect_arg_s *arg = pi->check_cb_arg;
246   ctrl_t ctrl = arg->ctrl;
247   size_t dummy;
248   gpg_error_t err;
249   gnupg_isotime_t now, protected_at, tmptime;
250   char *desc = NULL;
251
252   assert (!arg->unprotected_key);
253
254   arg->change_required = 0;
255   err = agent_unprotect (ctrl, arg->protected_key, pi->pin, protected_at,
256                          &arg->unprotected_key, &dummy);
257   if (err)
258     return err;
259   if (!opt.max_passphrase_days || ctrl->in_passwd)
260     return 0;  /* No regular passphrase change required.  */
261
262   if (!*protected_at)
263     {
264       /* No protection date known - must force passphrase change.  */
265       desc = xtrystrdup (L_("Note: This passphrase has never been changed.%0A"
266                             "Please change it now."));
267       if (!desc)
268         return gpg_error_from_syserror ();
269     }
270   else
271     {
272       gnupg_get_isotime (now);
273       gnupg_copy_time (tmptime, protected_at);
274       err = add_days_to_isotime (tmptime, opt.max_passphrase_days);
275       if (err)
276         return err;
277       if (strcmp (now, tmptime) > 0 )
278         {
279           /* Passphrase "expired".  */
280           desc = xtryasprintf
281             (L_("This passphrase has not been changed%%0A"
282                 "since %.4s-%.2s-%.2s.  Please change it now."),
283              protected_at, protected_at+4, protected_at+6);
284           if (!desc)
285             return gpg_error_from_syserror ();
286         }
287     }
288
289   if (desc)
290     {
291       /* Change required.  */
292       if (opt.enforce_passphrase_constraints)
293         {
294           err = agent_get_confirmation (ctrl, desc,
295                                         L_("Change passphrase"), NULL, 0);
296           if (!err)
297             arg->change_required = 1;
298         }
299       else
300         {
301           err = agent_get_confirmation (ctrl, desc,
302                                         L_("Change passphrase"),
303                                         L_("I'll change it later"), 0);
304           if (!err)
305             arg->change_required = 1;
306           else if (gpg_err_code (err) == GPG_ERR_CANCELED
307                    || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
308             err = 0;
309         }
310       xfree (desc);
311     }
312
313   return 0;
314 }
315
316
317 /* Modify a Key description, replacing certain special format
318    characters.  List of currently supported replacements:
319
320    %% - Replaced by a single %
321    %c - Replaced by the content of COMMENT.
322    %C - Same as %c but put into parentheses.
323    %F - Replaced by an ssh style fingerprint computed from KEY.
324
325    The functions returns 0 on success or an error code.  On success a
326    newly allocated string is stored at the address of RESULT.
327  */
328 static gpg_error_t
329 modify_description (const char *in, const char *comment, const gcry_sexp_t key,
330                     char **result)
331 {
332   size_t comment_length;
333   size_t in_len;
334   size_t out_len;
335   char *out;
336   size_t i;
337   int special, pass;
338   char *ssh_fpr = NULL;
339
340   comment_length = strlen (comment);
341   in_len  = strlen (in);
342
343   /* First pass calculates the length, second pass does the actual
344      copying.  */
345   out = NULL;
346   out_len = 0;
347   for (pass=0; pass < 2; pass++)
348     {
349       special = 0;
350       for (i = 0; i < in_len; i++)
351         {
352           if (special)
353             {
354               special = 0;
355               switch (in[i])
356                 {
357                 case '%':
358                   if (out)
359                     *out++ = '%';
360                   else
361                     out_len++;
362                   break;
363
364                 case 'c': /* Comment.  */
365                   if (out)
366                     {
367                       memcpy (out, comment, comment_length);
368                       out += comment_length;
369                     }
370                   else
371                     out_len += comment_length;
372                   break;
373
374                 case 'C': /* Comment.  */
375                   if (!comment_length)
376                     ;
377                   else if (out)
378                     {
379                       *out++ = '(';
380                       memcpy (out, comment, comment_length);
381                       out += comment_length;
382                       *out++ = ')';
383                     }
384                   else
385                     out_len += comment_length + 2;
386                   break;
387
388                 case 'F': /* SSH style fingerprint.  */
389                   if (!ssh_fpr && key)
390                     ssh_get_fingerprint_string (key, &ssh_fpr);
391                   if (ssh_fpr)
392                     {
393                       if (out)
394                         out = stpcpy (out, ssh_fpr);
395                       else
396                         out_len += strlen (ssh_fpr);
397                     }
398                   break;
399
400                 default: /* Invalid special sequences are kept as they are. */
401                   if (out)
402                     {
403                       *out++ = '%';
404                       *out++ = in[i];
405                     }
406                   else
407                     out_len+=2;
408                   break;
409                 }
410             }
411           else if (in[i] == '%')
412             special = 1;
413           else
414             {
415               if (out)
416                 *out++ = in[i];
417               else
418                 out_len++;
419             }
420         }
421
422       if (!pass)
423         {
424           *result = out = xtrymalloc (out_len + 1);
425           if (!out)
426             {
427               xfree (ssh_fpr);
428               return gpg_error_from_syserror ();
429             }
430         }
431     }
432
433   *out = 0;
434   assert (*result + out_len == out);
435   xfree (ssh_fpr);
436   return 0;
437 }
438
439
440
441 /* Unprotect the canconical encoded S-expression key in KEYBUF.  GRIP
442    should be the hex encoded keygrip of that key to be used with the
443    caching mechanism. DESC_TEXT may be set to override the default
444    description used for the pinentry.  If LOOKUP_TTL is given this
445    function is used to lookup the default ttl.  If R_PASSPHRASE is not
446    NULL, the function succeeded and the key was protected the used
447    passphrase (entered or from the cache) is stored there; if not NULL
448    will be stored.  The caller needs to free the returned
449    passphrase. */
450 static int
451 unprotect (ctrl_t ctrl, const char *cache_nonce, const char *desc_text,
452            unsigned char **keybuf, const unsigned char *grip,
453            cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
454            char **r_passphrase)
455 {
456   struct pin_entry_info_s *pi;
457   struct try_unprotect_arg_s arg;
458   int rc;
459   unsigned char *result;
460   size_t resultlen;
461   char hexgrip[40+1];
462
463   if (r_passphrase)
464     *r_passphrase = NULL;
465
466   bin2hex (grip, 20, hexgrip);
467
468   /* Initially try to get it using a cache nonce.  */
469   if (cache_nonce)
470     {
471       char *pw;
472
473       pw = agent_get_cache (cache_nonce, CACHE_MODE_NONCE);
474       if (pw)
475         {
476           rc = agent_unprotect (ctrl, *keybuf, pw, NULL, &result, &resultlen);
477           if (!rc)
478             {
479               if (r_passphrase)
480                 *r_passphrase = pw;
481               else
482                 xfree (pw);
483               xfree (*keybuf);
484               *keybuf = result;
485               return 0;
486             }
487           xfree (pw);
488         }
489     }
490
491   /* First try to get it from the cache - if there is none or we can't
492      unprotect it, we fall back to ask the user */
493   if (cache_mode != CACHE_MODE_IGNORE)
494     {
495       char *pw;
496
497     retry:
498       pw = agent_get_cache (hexgrip, cache_mode);
499       if (pw)
500         {
501           rc = agent_unprotect (ctrl, *keybuf, pw, NULL, &result, &resultlen);
502           if (!rc)
503             {
504               if (cache_mode == CACHE_MODE_NORMAL)
505                 agent_store_cache_hit (hexgrip);
506               if (r_passphrase)
507                 *r_passphrase = pw;
508               else
509                 xfree (pw);
510               xfree (*keybuf);
511               *keybuf = result;
512               return 0;
513             }
514           xfree (pw);
515           rc  = 0;
516         }
517       else if (cache_mode == CACHE_MODE_NORMAL)
518         {
519           /* The standard use of GPG keys is to have a signing and an
520              encryption subkey.  Commonly both use the same
521              passphrase.  We try to help the user to enter the
522              passphrase only once by silently trying the last
523              correctly entered passphrase.  Checking one additional
524              passphrase should be acceptable; despite the S2K
525              introduced delays. The assumed workflow is:
526
527                1. Read encrypted message in a MUA and thus enter a
528                   passphrase for the encryption subkey.
529
530                2. Reply to that mail with an encrypted and signed
531                   mail, thus entering the passphrase for the signing
532                   subkey.
533
534              We can often avoid the passphrase entry in the second
535              step.  We do this only in normal mode, so not to
536              interfere with unrelated cache entries.  */
537           pw = agent_get_cache (NULL, cache_mode);
538           if (pw)
539             {
540               rc = agent_unprotect (ctrl, *keybuf, pw, NULL,
541                                     &result, &resultlen);
542               if (!rc)
543                 {
544                   if (r_passphrase)
545                     *r_passphrase = pw;
546                   else
547                     xfree (pw);
548                   xfree (*keybuf);
549                   *keybuf = result;
550                   return 0;
551                 }
552               xfree (pw);
553               rc  = 0;
554             }
555         }
556
557       /* If the pinentry is currently in use, we wait up to 60 seconds
558          for it to close and check the cache again.  This solves a common
559          situation where several requests for unprotecting a key have
560          been made but the user is still entering the passphrase for
561          the first request.  Because all requests to agent_askpin are
562          serialized they would then pop up one after the other to
563          request the passphrase - despite that the user has already
564          entered it and is then available in the cache.  This
565          implementation is not race free but in the worst case the
566          user has to enter the passphrase only once more. */
567       if (pinentry_active_p (ctrl, 0))
568         {
569           /* Active - wait */
570           if (!pinentry_active_p (ctrl, 60))
571             {
572               /* We need to give the other thread a chance to actually put
573                  it into the cache. */
574               npth_sleep (1);
575               goto retry;
576             }
577           /* Timeout - better call pinentry now the plain way. */
578         }
579     }
580
581   pi = gcry_calloc_secure (1, sizeof (*pi) + MAX_PASSPHRASE_LEN + 1);
582   if (!pi)
583     return gpg_error_from_syserror ();
584   pi->max_length = MAX_PASSPHRASE_LEN + 1;
585   pi->min_digits = 0;  /* we want a real passphrase */
586   pi->max_digits = 16;
587   pi->max_tries = 3;
588   pi->check_cb = try_unprotect_cb;
589   arg.ctrl = ctrl;
590   arg.protected_key = *keybuf;
591   arg.unprotected_key = NULL;
592   arg.change_required = 0;
593   pi->check_cb_arg = &arg;
594
595   rc = agent_askpin (ctrl, desc_text, NULL, NULL, pi, hexgrip, cache_mode);
596   if (!rc)
597     {
598       assert (arg.unprotected_key);
599       if (arg.change_required)
600         {
601           /* The callback told as that the user should change their
602              passphrase.  Present the dialog to do.  */
603           size_t canlen, erroff;
604           gcry_sexp_t s_skey;
605
606           assert (arg.unprotected_key);
607           canlen = gcry_sexp_canon_len (arg.unprotected_key, 0, NULL, NULL);
608           rc = gcry_sexp_sscan (&s_skey, &erroff,
609                                 (char*)arg.unprotected_key, canlen);
610           if (rc)
611             {
612               log_error ("failed to build S-Exp (off=%u): %s\n",
613                          (unsigned int)erroff, gpg_strerror (rc));
614               wipememory (arg.unprotected_key, canlen);
615               xfree (arg.unprotected_key);
616               xfree (pi);
617               return rc;
618             }
619           rc = agent_protect_and_store (ctrl, s_skey, NULL);
620           gcry_sexp_release (s_skey);
621           if (rc)
622             {
623               log_error ("changing the passphrase failed: %s\n",
624                          gpg_strerror (rc));
625               wipememory (arg.unprotected_key, canlen);
626               xfree (arg.unprotected_key);
627               xfree (pi);
628               return rc;
629             }
630         }
631       else
632         {
633           /* Passphrase is fine.  */
634           agent_put_cache (hexgrip, cache_mode, pi->pin,
635                            lookup_ttl? lookup_ttl (hexgrip) : 0);
636           agent_store_cache_hit (hexgrip);
637           if (r_passphrase && *pi->pin)
638             *r_passphrase = xtrystrdup (pi->pin);
639         }
640       xfree (*keybuf);
641       *keybuf = arg.unprotected_key;
642     }
643   xfree (pi);
644   return rc;
645 }
646
647
648 /* Read the key identified by GRIP from the private key directory and
649    return it as an gcrypt S-expression object in RESULT.  On failure
650    returns an error code and stores NULL at RESULT. */
651 static gpg_error_t
652 read_key_file (const unsigned char *grip, gcry_sexp_t *result)
653 {
654   int rc;
655   char *fname;
656   estream_t fp;
657   struct stat st;
658   unsigned char *buf;
659   size_t buflen, erroff;
660   gcry_sexp_t s_skey;
661   char hexgrip[40+4+1];
662   char first;
663
664   *result = NULL;
665
666   bin2hex (grip, 20, hexgrip);
667   strcpy (hexgrip+40, ".key");
668
669   fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
670                          hexgrip, NULL);
671   fp = es_fopen (fname, "rb");
672   if (!fp)
673     {
674       rc = gpg_error_from_syserror ();
675       if (gpg_err_code (rc) != GPG_ERR_ENOENT)
676         log_error ("can't open '%s': %s\n", fname, strerror (errno));
677       xfree (fname);
678       return rc;
679     }
680
681   if (es_fread (&first, 1, 1, fp) != 1)
682     {
683       rc = gpg_error_from_syserror ();
684       log_error ("error reading first byte from '%s': %s\n",
685                  fname, strerror (errno));
686       xfree (fname);
687       es_fclose (fp);
688       return rc;
689     }
690
691   rc = es_fseek (fp, 0, SEEK_SET);
692   if (rc)
693     {
694       log_error ("error seeking in '%s': %s\n", fname, strerror (errno));
695       xfree (fname);
696       es_fclose (fp);
697       return rc;
698     }
699
700   if (first != '(')
701     {
702       /* Key is in extended format.  */
703       nvc_t pk;
704       int line;
705
706       rc = nvc_parse_private_key (&pk, &line, fp);
707       es_fclose (fp);
708
709       if (rc)
710         log_error ("error parsing '%s' line %d: %s\n",
711                    fname, line, gpg_strerror (rc));
712       else
713         {
714           rc = nvc_get_private_key (pk, result);
715           nvc_release (pk);
716           if (rc)
717             log_error ("error getting private key from '%s': %s\n",
718                        fname, gpg_strerror (rc));
719         }
720
721       xfree (fname);
722       return rc;
723     }
724
725   if (fstat (es_fileno (fp), &st))
726     {
727       rc = gpg_error_from_syserror ();
728       log_error ("can't stat '%s': %s\n", fname, strerror (errno));
729       xfree (fname);
730       es_fclose (fp);
731       return rc;
732     }
733
734   buflen = st.st_size;
735   buf = xtrymalloc (buflen+1);
736   if (!buf)
737     {
738       rc = gpg_error_from_syserror ();
739       log_error ("error allocating %zu bytes for '%s': %s\n",
740                  buflen, fname, strerror (errno));
741       xfree (fname);
742       es_fclose (fp);
743       xfree (buf);
744       return rc;
745
746     }
747
748   if (es_fread (buf, buflen, 1, fp) != 1)
749     {
750       rc = gpg_error_from_syserror ();
751       log_error ("error reading %zu bytes from '%s': %s\n",
752                  buflen, fname, strerror (errno));
753       xfree (fname);
754       es_fclose (fp);
755       xfree (buf);
756       return rc;
757     }
758
759   /* Convert the file into a gcrypt S-expression object.  */
760   rc = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
761   xfree (fname);
762   es_fclose (fp);
763   xfree (buf);
764   if (rc)
765     {
766       log_error ("failed to build S-Exp (off=%u): %s\n",
767                  (unsigned int)erroff, gpg_strerror (rc));
768       return rc;
769     }
770   *result = s_skey;
771   return 0;
772 }
773
774
775 /* Remove the key identified by GRIP from the private key directory.  */
776 static gpg_error_t
777 remove_key_file (const unsigned char *grip)
778 {
779   gpg_error_t err = 0;
780   char *fname;
781   char hexgrip[40+4+1];
782
783   bin2hex (grip, 20, hexgrip);
784   strcpy (hexgrip+40, ".key");
785   fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
786                          hexgrip, NULL);
787   if (gnupg_remove (fname))
788     err = gpg_error_from_syserror ();
789   xfree (fname);
790   return err;
791 }
792
793
794 /* Return the secret key as an S-Exp in RESULT after locating it using
795    the GRIP.  If the operation shall be diverted to a token, an
796    allocated S-expression with the shadow_info part from the file is
797    stored at SHADOW_INFO; if not NULL will be stored at SHADOW_INFO.
798    CACHE_MODE defines now the cache shall be used.  DESC_TEXT may be
799    set to present a custom description for the pinentry.  LOOKUP_TTL
800    is an optional function to convey a TTL to the cache manager; we do
801    not simply pass the TTL value because the value is only needed if
802    an unprotect action was needed and looking up the TTL may have some
803    overhead (e.g. scanning the sshcontrol file).  If a CACHE_NONCE is
804    given that cache item is first tried to get a passphrase.  If
805    R_PASSPHRASE is not NULL, the function succeeded and the key was
806    protected the used passphrase (entered or from the cache) is stored
807    there; if not NULL will be stored.  The caller needs to free the
808    returned passphrase.   */
809 gpg_error_t
810 agent_key_from_file (ctrl_t ctrl, const char *cache_nonce,
811                      const char *desc_text,
812                      const unsigned char *grip, unsigned char **shadow_info,
813                      cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
814                      gcry_sexp_t *result, char **r_passphrase)
815 {
816   int rc;
817   unsigned char *buf;
818   size_t len, buflen, erroff;
819   gcry_sexp_t s_skey;
820
821   *result = NULL;
822   if (shadow_info)
823     *shadow_info = NULL;
824   if (r_passphrase)
825     *r_passphrase = NULL;
826
827   rc = read_key_file (grip, &s_skey);
828   if (rc)
829     {
830       if (gpg_err_code (rc) == GPG_ERR_ENOENT)
831         rc = gpg_error (GPG_ERR_NO_SECKEY);
832       return rc;
833     }
834
835   /* For use with the protection functions we also need the key as an
836      canonical encoded S-expression in a buffer.  Create this buffer
837      now.  */
838   rc = make_canon_sexp (s_skey, &buf, &len);
839   if (rc)
840     return rc;
841
842   switch (agent_private_key_type (buf))
843     {
844     case PRIVATE_KEY_CLEAR:
845       break; /* no unprotection needed */
846     case PRIVATE_KEY_OPENPGP_NONE:
847       {
848         unsigned char *buf_new;
849         size_t buf_newlen;
850
851         rc = agent_unprotect (ctrl, buf, "", NULL, &buf_new, &buf_newlen);
852         if (rc)
853           log_error ("failed to convert unprotected openpgp key: %s\n",
854                      gpg_strerror (rc));
855         else
856           {
857             xfree (buf);
858             buf = buf_new;
859           }
860       }
861       break;
862     case PRIVATE_KEY_PROTECTED:
863       {
864         char *desc_text_final;
865         char *comment = NULL;
866
867         /* Note, that we will take the comment as a C string for
868            display purposes; i.e. all stuff beyond a Nul character is
869            ignored.  */
870         {
871           gcry_sexp_t comment_sexp;
872
873           comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
874           if (comment_sexp)
875             comment = gcry_sexp_nth_string (comment_sexp, 1);
876           gcry_sexp_release (comment_sexp);
877         }
878
879         desc_text_final = NULL;
880         if (desc_text)
881           rc = modify_description (desc_text, comment? comment:"", s_skey,
882                                    &desc_text_final);
883         gcry_free (comment);
884
885         if (!rc)
886           {
887             rc = unprotect (ctrl, cache_nonce, desc_text_final, &buf, grip,
888                             cache_mode, lookup_ttl, r_passphrase);
889             if (rc)
890               log_error ("failed to unprotect the secret key: %s\n",
891                          gpg_strerror (rc));
892           }
893
894         xfree (desc_text_final);
895       }
896       break;
897     case PRIVATE_KEY_SHADOWED:
898       if (shadow_info)
899         {
900           const unsigned char *s;
901           size_t n;
902
903           rc = agent_get_shadow_info (buf, &s);
904           if (!rc)
905             {
906               n = gcry_sexp_canon_len (s, 0, NULL,NULL);
907               assert (n);
908               *shadow_info = xtrymalloc (n);
909               if (!*shadow_info)
910                 rc = out_of_core ();
911               else
912                 {
913                   memcpy (*shadow_info, s, n);
914                   rc = 0;
915                 }
916             }
917           if (rc)
918             log_error ("get_shadow_info failed: %s\n", gpg_strerror (rc));
919         }
920       else
921         rc = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
922       break;
923     default:
924       log_error ("invalid private key format\n");
925       rc = gpg_error (GPG_ERR_BAD_SECKEY);
926       break;
927     }
928   gcry_sexp_release (s_skey);
929   s_skey = NULL;
930   if (rc)
931     {
932       xfree (buf);
933       if (r_passphrase)
934         {
935           xfree (*r_passphrase);
936           *r_passphrase = NULL;
937         }
938       return rc;
939     }
940
941   buflen = gcry_sexp_canon_len (buf, 0, NULL, NULL);
942   rc = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
943   wipememory (buf, buflen);
944   xfree (buf);
945   if (rc)
946     {
947       log_error ("failed to build S-Exp (off=%u): %s\n",
948                  (unsigned int)erroff, gpg_strerror (rc));
949       if (r_passphrase)
950         {
951           xfree (*r_passphrase);
952           *r_passphrase = NULL;
953         }
954       return rc;
955     }
956
957   *result = s_skey;
958   return 0;
959 }
960
961
962 /* Return the string name from the S-expression S_KEY as well as a
963    string describing the names of the parameters.  ALGONAMESIZE and
964    ELEMSSIZE give the allocated size of the provided buffers.  The
965    buffers may be NULL if not required.  If R_LIST is not NULL the top
966    level list will be stored there; the caller needs to release it in
967    this case.  */
968 static gpg_error_t
969 key_parms_from_sexp (gcry_sexp_t s_key, gcry_sexp_t *r_list,
970                      char *r_algoname, size_t algonamesize,
971                      char *r_elems, size_t elemssize)
972 {
973   gcry_sexp_t list, l2;
974   const char *name, *algoname, *elems;
975   size_t n;
976
977   if (r_list)
978     *r_list = NULL;
979
980   list = gcry_sexp_find_token (s_key, "shadowed-private-key", 0 );
981   if (!list)
982     list = gcry_sexp_find_token (s_key, "protected-private-key", 0 );
983   if (!list)
984     list = gcry_sexp_find_token (s_key, "private-key", 0 );
985   if (!list)
986     {
987       log_error ("invalid private key format\n");
988       return gpg_error (GPG_ERR_BAD_SECKEY);
989     }
990
991   l2 = gcry_sexp_cadr (list);
992   gcry_sexp_release (list);
993   list = l2;
994   name = gcry_sexp_nth_data (list, 0, &n);
995   if (n==3 && !memcmp (name, "rsa", 3))
996     {
997       algoname = "rsa";
998       elems = "ne";
999     }
1000   else if (n==3 && !memcmp (name, "dsa", 3))
1001     {
1002       algoname = "dsa";
1003       elems = "pqgy";
1004     }
1005   else if (n==3 && !memcmp (name, "ecc", 3))
1006     {
1007       algoname = "ecc";
1008       elems = "pabgnq";
1009     }
1010   else if (n==5 && !memcmp (name, "ecdsa", 5))
1011     {
1012       algoname = "ecdsa";
1013       elems = "pabgnq";
1014     }
1015   else if (n==4 && !memcmp (name, "ecdh", 4))
1016     {
1017       algoname = "ecdh";
1018       elems = "pabgnq";
1019     }
1020   else if (n==3 && !memcmp (name, "elg", 3))
1021     {
1022       algoname = "elg";
1023       elems = "pgy";
1024     }
1025   else
1026     {
1027       log_error ("unknown private key algorithm\n");
1028       gcry_sexp_release (list);
1029       return gpg_error (GPG_ERR_BAD_SECKEY);
1030     }
1031
1032   if (r_algoname)
1033     {
1034       if (strlen (algoname) >= algonamesize)
1035         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
1036       strcpy (r_algoname, algoname);
1037     }
1038   if (r_elems)
1039     {
1040       if (strlen (elems) >= elemssize)
1041         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
1042       strcpy (r_elems, elems);
1043     }
1044
1045   if (r_list)
1046     *r_list = list;
1047   else
1048     gcry_sexp_release (list);
1049
1050   return 0;
1051 }
1052
1053
1054 /* Return true if KEYPARMS holds an EdDSA key.  */
1055 static int
1056 is_eddsa (gcry_sexp_t keyparms)
1057 {
1058   int result = 0;
1059   gcry_sexp_t list;
1060   const char *s;
1061   size_t n;
1062   int i;
1063
1064   list = gcry_sexp_find_token (keyparms, "flags", 0);
1065   for (i = list ? gcry_sexp_length (list)-1 : 0; i > 0; i--)
1066     {
1067       s = gcry_sexp_nth_data (list, i, &n);
1068       if (!s)
1069         continue; /* Not a data element. */
1070
1071       if (n == 5 && !memcmp (s, "eddsa", 5))
1072         {
1073           result = 1;
1074           break;
1075         }
1076     }
1077   gcry_sexp_release (list);
1078   return result;
1079 }
1080
1081
1082 /* Return the public key algorithm number if S_KEY is a DSA style key.
1083    If it is not a DSA style key, return 0.  */
1084 int
1085 agent_is_dsa_key (gcry_sexp_t s_key)
1086 {
1087   int result;
1088   gcry_sexp_t list;
1089   char algoname[6];
1090
1091   if (!s_key)
1092     return 0;
1093
1094   if (key_parms_from_sexp (s_key, &list, algoname, sizeof algoname, NULL, 0))
1095     return 0; /* Error - assume it is not an DSA key.  */
1096
1097   if (!strcmp (algoname, "dsa"))
1098     result = GCRY_PK_DSA;
1099   else if (!strcmp (algoname, "ecc"))
1100     {
1101       if (is_eddsa (list))
1102         result = 0;
1103       else
1104         result = GCRY_PK_ECDSA;
1105     }
1106   else if (!strcmp (algoname, "ecdsa"))
1107     result = GCRY_PK_ECDSA;
1108   else
1109     result = 0;
1110
1111   gcry_sexp_release (list);
1112   return result;
1113 }
1114
1115
1116 /* Return true if S_KEY is an EdDSA key as used with curve Ed25519.  */
1117 int
1118 agent_is_eddsa_key (gcry_sexp_t s_key)
1119 {
1120   int result;
1121   gcry_sexp_t list;
1122   char algoname[6];
1123
1124   if (!s_key)
1125     return 0;
1126
1127   if (key_parms_from_sexp (s_key, &list, algoname, sizeof algoname, NULL, 0))
1128     return 0; /* Error - assume it is not an EdDSA key.  */
1129
1130   if (!strcmp (algoname, "ecc") && is_eddsa (list))
1131     result = 1;
1132   else if (!strcmp (algoname, "eddsa")) /* backward compatibility.  */
1133     result = 1;
1134   else
1135     result = 0;
1136
1137   gcry_sexp_release (list);
1138   return result;
1139 }
1140
1141
1142 /* Return the key for the keygrip GRIP.  The result is stored at
1143    RESULT.  This function extracts the key from the private key
1144    database and returns it as an S-expression object as it is.  On
1145    failure an error code is returned and NULL stored at RESULT. */
1146 gpg_error_t
1147 agent_raw_key_from_file (ctrl_t ctrl, const unsigned char *grip,
1148                          gcry_sexp_t *result)
1149 {
1150   gpg_error_t err;
1151   gcry_sexp_t s_skey;
1152
1153   (void)ctrl;
1154
1155   *result = NULL;
1156
1157   err = read_key_file (grip, &s_skey);
1158   if (!err)
1159     *result = s_skey;
1160   return err;
1161 }
1162
1163
1164 /* Return the public key for the keygrip GRIP.  The result is stored
1165    at RESULT.  This function extracts the public key from the private
1166    key database.  On failure an error code is returned and NULL stored
1167    at RESULT. */
1168 gpg_error_t
1169 agent_public_key_from_file (ctrl_t ctrl,
1170                             const unsigned char *grip,
1171                             gcry_sexp_t *result)
1172 {
1173   gpg_error_t err;
1174   int i, idx;
1175   gcry_sexp_t s_skey;
1176   const char *algoname, *elems;
1177   int npkey;
1178   gcry_mpi_t array[10];
1179   gcry_sexp_t curve = NULL;
1180   gcry_sexp_t flags = NULL;
1181   gcry_sexp_t uri_sexp, comment_sexp;
1182   const char *uri, *comment;
1183   size_t uri_length, comment_length;
1184   char *format, *p;
1185   void *args[2+7+2+2+1]; /* Size is 2 + max. # of elements + 2 for uri + 2
1186                             for comment + end-of-list.  */
1187   int argidx;
1188   gcry_sexp_t list = NULL;
1189   const char *s;
1190
1191   (void)ctrl;
1192
1193   *result = NULL;
1194
1195   err = read_key_file (grip, &s_skey);
1196   if (err)
1197     return err;
1198
1199   for (i=0; i < DIM (array); i++)
1200     array[i] = NULL;
1201
1202   err = extract_private_key (s_skey, 0, &algoname, &npkey, NULL, &elems,
1203                              array, DIM (array), &curve, &flags);
1204   if (err)
1205     {
1206       gcry_sexp_release (s_skey);
1207       return err;
1208     }
1209
1210   uri = NULL;
1211   uri_length = 0;
1212   uri_sexp = gcry_sexp_find_token (s_skey, "uri", 0);
1213   if (uri_sexp)
1214     uri = gcry_sexp_nth_data (uri_sexp, 1, &uri_length);
1215
1216   comment = NULL;
1217   comment_length = 0;
1218   comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
1219   if (comment_sexp)
1220     comment = gcry_sexp_nth_data (comment_sexp, 1, &comment_length);
1221
1222   gcry_sexp_release (s_skey);
1223   s_skey = NULL;
1224
1225
1226   /* FIXME: The following thing is pretty ugly code; we should
1227      investigate how to make it cleaner.  Probably code to handle
1228      canonical S-expressions in a memory buffer is better suited for
1229      such a task.  After all that is what we do in protect.c.  Neeed
1230      to find common patterns and write a straightformward API to use
1231      them.  */
1232   assert (sizeof (size_t) <= sizeof (void*));
1233
1234   format = xtrymalloc (15+4+7*npkey+10+15+1+1);
1235   if (!format)
1236     {
1237       err = gpg_error_from_syserror ();
1238       for (i=0; array[i]; i++)
1239         gcry_mpi_release (array[i]);
1240       gcry_sexp_release (curve);
1241       gcry_sexp_release (flags);
1242       gcry_sexp_release (uri_sexp);
1243       gcry_sexp_release (comment_sexp);
1244       return err;
1245     }
1246
1247   argidx = 0;
1248   p = stpcpy (stpcpy (format, "(public-key("), algoname);
1249   p = stpcpy (p, "%S%S");       /* curve name and flags.  */
1250   args[argidx++] = &curve;
1251   args[argidx++] = &flags;
1252   for (idx=0, s=elems; idx < npkey; idx++)
1253     {
1254       *p++ = '(';
1255       *p++ = *s++;
1256       p = stpcpy (p, " %m)");
1257       assert (argidx < DIM (args));
1258       args[argidx++] = &array[idx];
1259     }
1260   *p++ = ')';
1261   if (uri)
1262     {
1263       p = stpcpy (p, "(uri %b)");
1264       assert (argidx+1 < DIM (args));
1265       args[argidx++] = (void *)&uri_length;
1266       args[argidx++] = (void *)&uri;
1267     }
1268   if (comment)
1269     {
1270       p = stpcpy (p, "(comment %b)");
1271       assert (argidx+1 < DIM (args));
1272       args[argidx++] = (void *)&comment_length;
1273       args[argidx++] = (void*)&comment;
1274     }
1275   *p++ = ')';
1276   *p = 0;
1277   assert (argidx < DIM (args));
1278   args[argidx] = NULL;
1279
1280   err = gcry_sexp_build_array (&list, NULL, format, args);
1281   xfree (format);
1282   for (i=0; array[i]; i++)
1283     gcry_mpi_release (array[i]);
1284   gcry_sexp_release (curve);
1285   gcry_sexp_release (flags);
1286   gcry_sexp_release (uri_sexp);
1287   gcry_sexp_release (comment_sexp);
1288
1289   if (!err)
1290     *result = list;
1291   return err;
1292 }
1293
1294
1295
1296 /* Check whether the the secret key identified by GRIP is available.
1297    Returns 0 is the key is available.  */
1298 int
1299 agent_key_available (const unsigned char *grip)
1300 {
1301   int result;
1302   char *fname;
1303   char hexgrip[40+4+1];
1304
1305   bin2hex (grip, 20, hexgrip);
1306   strcpy (hexgrip+40, ".key");
1307
1308   fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
1309                          hexgrip, NULL);
1310   result = !access (fname, R_OK)? 0 : -1;
1311   xfree (fname);
1312   return result;
1313 }
1314
1315
1316
1317 /* Return the information about the secret key specified by the binary
1318    keygrip GRIP.  If the key is a shadowed one the shadow information
1319    will be stored at the address R_SHADOW_INFO as an allocated
1320    S-expression.  */
1321 gpg_error_t
1322 agent_key_info_from_file (ctrl_t ctrl, const unsigned char *grip,
1323                           int *r_keytype, unsigned char **r_shadow_info)
1324 {
1325   gpg_error_t err;
1326   unsigned char *buf;
1327   size_t len;
1328   int keytype;
1329
1330   (void)ctrl;
1331
1332   if (r_keytype)
1333     *r_keytype = PRIVATE_KEY_UNKNOWN;
1334   if (r_shadow_info)
1335     *r_shadow_info = NULL;
1336
1337   {
1338     gcry_sexp_t sexp;
1339
1340     err = read_key_file (grip, &sexp);
1341     if (err)
1342       {
1343         if (gpg_err_code (err) == GPG_ERR_ENOENT)
1344           return gpg_error (GPG_ERR_NOT_FOUND);
1345         else
1346           return err;
1347       }
1348     err = make_canon_sexp (sexp, &buf, &len);
1349     gcry_sexp_release (sexp);
1350     if (err)
1351       return err;
1352   }
1353
1354   keytype = agent_private_key_type (buf);
1355   switch (keytype)
1356     {
1357     case PRIVATE_KEY_CLEAR:
1358     case PRIVATE_KEY_OPENPGP_NONE:
1359       break;
1360     case PRIVATE_KEY_PROTECTED:
1361       /* If we ever require it we could retrieve the comment fields
1362          from such a key. */
1363       break;
1364     case PRIVATE_KEY_SHADOWED:
1365       if (r_shadow_info)
1366         {
1367           const unsigned char *s;
1368           size_t n;
1369
1370           err = agent_get_shadow_info (buf, &s);
1371           if (!err)
1372             {
1373               n = gcry_sexp_canon_len (s, 0, NULL, NULL);
1374               assert (n);
1375               *r_shadow_info = xtrymalloc (n);
1376               if (!*r_shadow_info)
1377                 err = gpg_error_from_syserror ();
1378               else
1379                 memcpy (*r_shadow_info, s, n);
1380             }
1381         }
1382       break;
1383     default:
1384       err = gpg_error (GPG_ERR_BAD_SECKEY);
1385       break;
1386     }
1387
1388   if (!err && r_keytype)
1389     *r_keytype = keytype;
1390
1391   xfree (buf);
1392   return err;
1393 }
1394
1395
1396 \f
1397 /* Delete the key with GRIP from the disk after having asked for
1398    confirmation using DESC_TEXT.  If FORCE is set the function won't
1399    require a confirmation via Pinentry or warns if the key is also
1400    used by ssh.
1401
1402    Common error codes are:
1403      GPG_ERR_NO_SECKEY
1404      GPG_ERR_KEY_ON_CARD
1405      GPG_ERR_NOT_CONFIRMED
1406 */
1407 gpg_error_t
1408 agent_delete_key (ctrl_t ctrl, const char *desc_text,
1409                   const unsigned char *grip, int force)
1410 {
1411   gpg_error_t err;
1412   gcry_sexp_t s_skey = NULL;
1413   unsigned char *buf = NULL;
1414   size_t len;
1415   char *desc_text_final = NULL;
1416   char *comment = NULL;
1417   ssh_control_file_t cf = NULL;
1418   char hexgrip[40+4+1];
1419   char *default_desc = NULL;
1420
1421   err = read_key_file (grip, &s_skey);
1422   if (gpg_err_code (err) == GPG_ERR_ENOENT)
1423     err = gpg_error (GPG_ERR_NO_SECKEY);
1424   if (err)
1425     goto leave;
1426
1427   err = make_canon_sexp (s_skey, &buf, &len);
1428   if (err)
1429     goto leave;
1430
1431   switch (agent_private_key_type (buf))
1432     {
1433     case PRIVATE_KEY_CLEAR:
1434     case PRIVATE_KEY_OPENPGP_NONE:
1435     case PRIVATE_KEY_PROTECTED:
1436       bin2hex (grip, 20, hexgrip);
1437       if (!force)
1438         {
1439           if (!desc_text)
1440             {
1441               default_desc = xtryasprintf
1442           (L_("Do you really want to delete the key identified by keygrip%%0A"
1443               "  %s%%0A  %%C%%0A?"), hexgrip);
1444               desc_text = default_desc;
1445             }
1446
1447           /* Note, that we will take the comment as a C string for
1448              display purposes; i.e. all stuff beyond a Nul character is
1449              ignored.  */
1450           {
1451             gcry_sexp_t comment_sexp;
1452
1453             comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
1454             if (comment_sexp)
1455               comment = gcry_sexp_nth_string (comment_sexp, 1);
1456             gcry_sexp_release (comment_sexp);
1457           }
1458
1459           if (desc_text)
1460             err = modify_description (desc_text, comment? comment:"", s_skey,
1461                                       &desc_text_final);
1462           if (err)
1463             goto leave;
1464
1465           err = agent_get_confirmation (ctrl, desc_text_final,
1466                                         L_("Delete key"), L_("No"), 0);
1467           if (err)
1468             goto leave;
1469
1470           cf = ssh_open_control_file ();
1471           if (cf)
1472             {
1473               if (!ssh_search_control_file (cf, hexgrip, NULL, NULL, NULL))
1474                 {
1475                   err = agent_get_confirmation
1476                     (ctrl,
1477                      L_("Warning: This key is also listed for use with SSH!\n"
1478                         "Deleting the key might remove your ability to "
1479                         "access remote machines."),
1480                      L_("Delete key"), L_("No"), 0);
1481                   if (err)
1482                     goto leave;
1483                 }
1484             }
1485         }
1486       err = remove_key_file (grip);
1487       break;
1488
1489     case PRIVATE_KEY_SHADOWED:
1490       err = remove_key_file (grip);
1491       break;
1492
1493     default:
1494       log_error ("invalid private key format\n");
1495       err = gpg_error (GPG_ERR_BAD_SECKEY);
1496       break;
1497     }
1498
1499  leave:
1500   ssh_close_control_file (cf);
1501   gcry_free (comment);
1502   xfree (desc_text_final);
1503   xfree (default_desc);
1504   xfree (buf);
1505   gcry_sexp_release (s_skey);
1506   return err;
1507 }
1508
1509
1510 /* Write an S-expression formatted shadow key to our key storage.
1511    Shadow key is created by an S-expression public key in PKBUF and
1512    card's SERIALNO and the IDSTRING.  With FORCE passed as true an
1513    existing key with the given GRIP will get overwritten.  */
1514 gpg_error_t
1515 agent_write_shadow_key (const unsigned char *grip,
1516                         const char *serialno, const char *keyid,
1517                         const unsigned char *pkbuf, int force)
1518 {
1519   gpg_error_t err;
1520   unsigned char *shadow_info;
1521   unsigned char *shdkey;
1522   size_t len;
1523
1524   shadow_info = make_shadow_info (serialno, keyid);
1525   if (!shadow_info)
1526     return gpg_error_from_syserror ();
1527
1528   err = agent_shadow_key (pkbuf, shadow_info, &shdkey);
1529   xfree (shadow_info);
1530   if (err)
1531     {
1532       log_error ("shadowing the key failed: %s\n", gpg_strerror (err));
1533       return err;
1534     }
1535
1536   len = gcry_sexp_canon_len (shdkey, 0, NULL, NULL);
1537   err = agent_write_private_key (grip, shdkey, len, force);
1538   xfree (shdkey);
1539   if (err)
1540     log_error ("error writing key: %s\n", gpg_strerror (err));
1541
1542   return err;
1543 }