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