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