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