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