agent: Return NO_SECKEY instead of ENONET for PKSIGN and others.
[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     {
609       if (gpg_err_code (rc) == GPG_ERR_ENOENT)
610         rc = gpg_error (GPG_ERR_NO_SECKEY);
611       return rc;
612     }
613
614   /* For use with the protection functions we also need the key as an
615      canonical encoded S-expression in a buffer.  Create this buffer
616      now.  */
617   rc = make_canon_sexp (s_skey, &buf, &len);
618   if (rc)
619     return rc;
620
621   switch (agent_private_key_type (buf))
622     {
623     case PRIVATE_KEY_CLEAR:
624       break; /* no unprotection needed */
625     case PRIVATE_KEY_PROTECTED:
626       {
627         char *desc_text_final;
628         char *comment = NULL;
629
630         /* Note, that we will take the comment as a C string for
631            display purposes; i.e. all stuff beyond a Nul character is
632            ignored.  */
633         {
634           gcry_sexp_t comment_sexp;
635
636           comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
637           if (comment_sexp)
638             comment = gcry_sexp_nth_string (comment_sexp, 1);
639           gcry_sexp_release (comment_sexp);
640         }
641
642         desc_text_final = NULL;
643         if (desc_text)
644           rc = modify_description (desc_text, comment? comment:"", s_skey,
645                                    &desc_text_final);
646         gcry_free (comment);
647
648         if (!rc)
649           {
650             rc = unprotect (ctrl, cache_nonce, desc_text_final, &buf, grip,
651                             cache_mode, lookup_ttl, r_passphrase);
652             if (rc)
653               log_error ("failed to unprotect the secret key: %s\n",
654                          gpg_strerror (rc));
655           }
656
657         xfree (desc_text_final);
658       }
659       break;
660     case PRIVATE_KEY_SHADOWED:
661       if (shadow_info)
662         {
663           const unsigned char *s;
664           size_t n;
665
666           rc = agent_get_shadow_info (buf, &s);
667           if (!rc)
668             {
669               n = gcry_sexp_canon_len (s, 0, NULL,NULL);
670               assert (n);
671               *shadow_info = xtrymalloc (n);
672               if (!*shadow_info)
673                 rc = out_of_core ();
674               else
675                 {
676                   memcpy (*shadow_info, s, n);
677                   rc = 0;
678                 }
679             }
680           if (rc)
681             log_error ("get_shadow_info failed: %s\n", gpg_strerror (rc));
682         }
683       else
684         rc = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
685       break;
686     default:
687       log_error ("invalid private key format\n");
688       rc = gpg_error (GPG_ERR_BAD_SECKEY);
689       break;
690     }
691   gcry_sexp_release (s_skey);
692   s_skey = NULL;
693   if (rc)
694     {
695       xfree (buf);
696       if (r_passphrase)
697         {
698           xfree (*r_passphrase);
699           *r_passphrase = NULL;
700         }
701       return rc;
702     }
703
704   buflen = gcry_sexp_canon_len (buf, 0, NULL, NULL);
705   rc = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
706   wipememory (buf, buflen);
707   xfree (buf);
708   if (rc)
709     {
710       log_error ("failed to build S-Exp (off=%u): %s\n",
711                  (unsigned int)erroff, gpg_strerror (rc));
712       if (r_passphrase)
713         {
714           xfree (*r_passphrase);
715           *r_passphrase = NULL;
716         }
717       return rc;
718     }
719
720   *result = s_skey;
721   return 0;
722 }
723
724
725 /* Return the string name from the S-expression S_KEY as well as a
726    string describing the names of the parameters.  ALGONAMESIZE and
727    ELEMSSIZE give the allocated size of the provided buffers.  The
728    buffers may be NULL if not required.  If R_LIST is not NULL the top
729    level list will be stored there; the caller needs to release it in
730    this case.  */
731 static gpg_error_t
732 key_parms_from_sexp (gcry_sexp_t s_key, gcry_sexp_t *r_list,
733                      char *r_algoname, size_t algonamesize,
734                      char *r_elems, size_t elemssize)
735 {
736   gcry_sexp_t list, l2;
737   const char *name, *algoname, *elems;
738   size_t n;
739
740   if (r_list)
741     *r_list = NULL;
742
743   list = gcry_sexp_find_token (s_key, "shadowed-private-key", 0 );
744   if (!list)
745     list = gcry_sexp_find_token (s_key, "protected-private-key", 0 );
746   if (!list)
747     list = gcry_sexp_find_token (s_key, "private-key", 0 );
748   if (!list)
749     {
750       log_error ("invalid private key format\n");
751       return gpg_error (GPG_ERR_BAD_SECKEY);
752     }
753
754   l2 = gcry_sexp_cadr (list);
755   gcry_sexp_release (list);
756   list = l2;
757   name = gcry_sexp_nth_data (list, 0, &n);
758   if (n==3 && !memcmp (name, "rsa", 3))
759     {
760       algoname = "rsa";
761       elems = "ne";
762     }
763   else if (n==3 && !memcmp (name, "dsa", 3))
764     {
765       algoname = "dsa";
766       elems = "pqgy";
767     }
768   else if (n==3 && !memcmp (name, "ecc", 3))
769     {
770       algoname = "ecc";
771       elems = "pabgnq";
772     }
773   else if (n==5 && !memcmp (name, "ecdsa", 5))
774     {
775       algoname = "ecdsa";
776       elems = "pabgnq";
777     }
778   else if (n==4 && !memcmp (name, "ecdh", 4))
779     {
780       algoname = "ecdh";
781       elems = "pabgnq";
782     }
783   else if (n==3 && !memcmp (name, "elg", 3))
784     {
785       algoname = "elg";
786       elems = "pgy";
787     }
788   else
789     {
790       log_error ("unknown private key algorithm\n");
791       gcry_sexp_release (list);
792       return gpg_error (GPG_ERR_BAD_SECKEY);
793     }
794
795   if (r_algoname)
796     {
797       if (strlen (algoname) >= algonamesize)
798         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
799       strcpy (r_algoname, algoname);
800     }
801   if (r_elems)
802     {
803       if (strlen (elems) >= elemssize)
804         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
805       strcpy (r_elems, elems);
806     }
807
808   if (r_list)
809     *r_list = list;
810   else
811     gcry_sexp_release (list);
812
813   return 0;
814 }
815
816
817 /* Return true if KEYPARMS holds an EdDSA key.  */
818 static int
819 is_eddsa (gcry_sexp_t keyparms)
820 {
821   int result = 0;
822   gcry_sexp_t list;
823   const char *s;
824   size_t n;
825   int i;
826
827   list = gcry_sexp_find_token (keyparms, "flags", 0);
828   for (i = list ? gcry_sexp_length (list)-1 : 0; i > 0; i--)
829     {
830       s = gcry_sexp_nth_data (list, i, &n);
831       if (!s)
832         continue; /* Not a data element. */
833
834       if (n == 5 && !memcmp (s, "eddsa", 5))
835         {
836           result = 1;
837           break;
838         }
839     }
840   gcry_sexp_release (list);
841   return result;
842 }
843
844
845 /* Return the public key algorithm number if S_KEY is a DSA style key.
846    If it is not a DSA style key, return 0.  */
847 int
848 agent_is_dsa_key (gcry_sexp_t s_key)
849 {
850   int result;
851   gcry_sexp_t list;
852   char algoname[6];
853
854   if (!s_key)
855     return 0;
856
857   if (key_parms_from_sexp (s_key, &list, algoname, sizeof algoname, NULL, 0))
858     return 0; /* Error - assume it is not an DSA key.  */
859
860   if (!strcmp (algoname, "dsa"))
861     result = GCRY_PK_DSA;
862   else if (!strcmp (algoname, "ecc"))
863     {
864       if (is_eddsa (list))
865         result = 0;
866       else
867         result = GCRY_PK_ECDSA;
868     }
869   else if (!strcmp (algoname, "ecdsa"))
870     result = GCRY_PK_ECDSA;
871   else
872     result = 0;
873
874   gcry_sexp_release (list);
875   return result;
876 }
877
878
879 /* Return true if S_KEY is an EdDSA key as used with curve Ed25519.  */
880 int
881 agent_is_eddsa_key (gcry_sexp_t s_key)
882 {
883   int result;
884   gcry_sexp_t list;
885   char algoname[6];
886
887   if (!s_key)
888     return 0;
889
890   if (key_parms_from_sexp (s_key, &list, algoname, sizeof algoname, NULL, 0))
891     return 0; /* Error - assume it is not an EdDSA key.  */
892
893   if (!strcmp (algoname, "ecc") && is_eddsa (list))
894     result = 1;
895   else if (!strcmp (algoname, "eddsa")) /* backward compatibility.  */
896     result = 1;
897   else
898     result = 0;
899
900   gcry_sexp_release (list);
901   return result;
902 }
903
904
905 /* Return the key for the keygrip GRIP.  The result is stored at
906    RESULT.  This function extracts the key from the private key
907    database and returns it as an S-expression object as it is.  On
908    failure an error code is returned and NULL stored at RESULT. */
909 gpg_error_t
910 agent_raw_key_from_file (ctrl_t ctrl, const unsigned char *grip,
911                          gcry_sexp_t *result)
912 {
913   gpg_error_t err;
914   gcry_sexp_t s_skey;
915
916   (void)ctrl;
917
918   *result = NULL;
919
920   err = read_key_file (grip, &s_skey);
921   if (!err)
922     *result = s_skey;
923   return err;
924 }
925
926
927 /* Return the public key for the keygrip GRIP.  The result is stored
928    at RESULT.  This function extracts the public key from the private
929    key database.  On failure an error code is returned and NULL stored
930    at RESULT. */
931 gpg_error_t
932 agent_public_key_from_file (ctrl_t ctrl,
933                             const unsigned char *grip,
934                             gcry_sexp_t *result)
935 {
936   gpg_error_t err;
937   int i, idx;
938   gcry_sexp_t s_skey;
939   char algoname[6];
940   char elems[7];
941   gcry_sexp_t uri_sexp, comment_sexp;
942   const char *uri, *comment;
943   size_t uri_length, comment_length;
944   char *format, *p;
945   void *args[4+2+2+1]; /* Size is max. # of elements + 2 for uri + 2
946                            for comment + end-of-list.  */
947   int argidx;
948   gcry_sexp_t list, l2;
949   const char *s;
950   gcry_mpi_t *array;
951
952   (void)ctrl;
953
954   *result = NULL;
955
956   err = read_key_file (grip, &s_skey);
957   if (err)
958     return err;
959
960   err = key_parms_from_sexp (s_skey, &list,
961                             algoname, sizeof algoname,
962                             elems, sizeof elems);
963   if (err)
964     {
965       gcry_sexp_release (s_skey);
966       return err;
967     }
968
969   /* Allocate an array for the parameters and copy them out of the
970      secret key.   FIXME: We should have a generic copy function. */
971   array = xtrycalloc (strlen(elems) + 1, sizeof *array);
972   if (!array)
973     {
974       err = gpg_error_from_syserror ();
975       gcry_sexp_release (list);
976       gcry_sexp_release (s_skey);
977       return err;
978     }
979
980   for (idx=0, s=elems; *s; s++, idx++ )
981     {
982       l2 = gcry_sexp_find_token (list, s, 1);
983       if (!l2)
984         {
985           /* Required parameter not found.  */
986           for (i=0; i<idx; i++)
987             gcry_mpi_release (array[i]);
988           xfree (array);
989           gcry_sexp_release (list);
990           gcry_sexp_release (s_skey);
991           return gpg_error (GPG_ERR_BAD_SECKEY);
992         }
993       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
994       gcry_sexp_release (l2);
995       if (!array[idx])
996         {
997           /* Required parameter is invalid. */
998           for (i=0; i<idx; i++)
999             gcry_mpi_release (array[i]);
1000           xfree (array);
1001           gcry_sexp_release (list);
1002           gcry_sexp_release (s_skey);
1003           return gpg_error (GPG_ERR_BAD_SECKEY);
1004         }
1005     }
1006   gcry_sexp_release (list);
1007   list = NULL;
1008
1009   uri = NULL;
1010   uri_length = 0;
1011   uri_sexp = gcry_sexp_find_token (s_skey, "uri", 0);
1012   if (uri_sexp)
1013     uri = gcry_sexp_nth_data (uri_sexp, 1, &uri_length);
1014
1015   comment = NULL;
1016   comment_length = 0;
1017   comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
1018   if (comment_sexp)
1019     comment = gcry_sexp_nth_data (comment_sexp, 1, &comment_length);
1020
1021   gcry_sexp_release (s_skey);
1022   s_skey = NULL;
1023
1024
1025   /* FIXME: The following thing is pretty ugly code; we should
1026      investigate how to make it cleaner.  Probably code to handle
1027      canonical S-expressions in a memory buffer is better suited for
1028      such a task.  After all that is what we do in protect.c.  Neeed
1029      to find common patterns and write a straightformward API to use
1030      them.  */
1031   assert (sizeof (size_t) <= sizeof (void*));
1032
1033   format = xtrymalloc (15+7*strlen (elems)+10+15+1+1);
1034   if (!format)
1035     {
1036       err = gpg_error_from_syserror ();
1037       for (i=0; array[i]; i++)
1038         gcry_mpi_release (array[i]);
1039       xfree (array);
1040       gcry_sexp_release (uri_sexp);
1041       gcry_sexp_release (comment_sexp);
1042       return err;
1043     }
1044
1045   argidx = 0;
1046   p = stpcpy (stpcpy (format, "(public-key("), algoname);
1047   for (idx=0, s=elems; *s; s++, idx++ )
1048     {
1049       *p++ = '(';
1050       *p++ = *s;
1051       p = stpcpy (p, " %m)");
1052       assert (argidx < DIM (args));
1053       args[argidx++] = &array[idx];
1054     }
1055   *p++ = ')';
1056   if (uri)
1057     {
1058       p = stpcpy (p, "(uri %b)");
1059       assert (argidx+1 < DIM (args));
1060       args[argidx++] = (void *)&uri_length;
1061       args[argidx++] = (void *)&uri;
1062     }
1063   if (comment)
1064     {
1065       p = stpcpy (p, "(comment %b)");
1066       assert (argidx+1 < DIM (args));
1067       args[argidx++] = (void *)&comment_length;
1068       args[argidx++] = (void*)&comment;
1069     }
1070   *p++ = ')';
1071   *p = 0;
1072   assert (argidx < DIM (args));
1073   args[argidx] = NULL;
1074
1075   err = gcry_sexp_build_array (&list, NULL, format, args);
1076   xfree (format);
1077   for (i=0; array[i]; i++)
1078     gcry_mpi_release (array[i]);
1079   xfree (array);
1080   gcry_sexp_release (uri_sexp);
1081   gcry_sexp_release (comment_sexp);
1082
1083   if (!err)
1084     *result = list;
1085   return err;
1086 }
1087
1088
1089
1090 /* Check whether the the secret key identified by GRIP is available.
1091    Returns 0 is the key is available.  */
1092 int
1093 agent_key_available (const unsigned char *grip)
1094 {
1095   int result;
1096   char *fname;
1097   char hexgrip[40+4+1];
1098
1099   bin2hex (grip, 20, hexgrip);
1100   strcpy (hexgrip+40, ".key");
1101
1102   fname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, hexgrip, NULL);
1103   result = !access (fname, R_OK)? 0 : -1;
1104   xfree (fname);
1105   return result;
1106 }
1107
1108
1109
1110 /* Return the information about the secret key specified by the binary
1111    keygrip GRIP.  If the key is a shadowed one the shadow information
1112    will be stored at the address R_SHADOW_INFO as an allocated
1113    S-expression.  */
1114 gpg_error_t
1115 agent_key_info_from_file (ctrl_t ctrl, const unsigned char *grip,
1116                           int *r_keytype, unsigned char **r_shadow_info)
1117 {
1118   gpg_error_t err;
1119   unsigned char *buf;
1120   size_t len;
1121   int keytype;
1122
1123   (void)ctrl;
1124
1125   if (r_keytype)
1126     *r_keytype = PRIVATE_KEY_UNKNOWN;
1127   if (r_shadow_info)
1128     *r_shadow_info = NULL;
1129
1130   {
1131     gcry_sexp_t sexp;
1132
1133     err = read_key_file (grip, &sexp);
1134     if (err)
1135       {
1136         if (gpg_err_code (err) == GPG_ERR_ENOENT)
1137           return gpg_error (GPG_ERR_NOT_FOUND);
1138         else
1139           return err;
1140       }
1141     err = make_canon_sexp (sexp, &buf, &len);
1142     gcry_sexp_release (sexp);
1143     if (err)
1144       return err;
1145   }
1146
1147   keytype = agent_private_key_type (buf);
1148   switch (keytype)
1149     {
1150     case PRIVATE_KEY_CLEAR:
1151       break;
1152     case PRIVATE_KEY_PROTECTED:
1153       /* If we ever require it we could retrieve the comment fields
1154          from such a key. */
1155       break;
1156     case PRIVATE_KEY_SHADOWED:
1157       if (r_shadow_info)
1158         {
1159           const unsigned char *s;
1160           size_t n;
1161
1162           err = agent_get_shadow_info (buf, &s);
1163           if (!err)
1164             {
1165               n = gcry_sexp_canon_len (s, 0, NULL, NULL);
1166               assert (n);
1167               *r_shadow_info = xtrymalloc (n);
1168               if (!*r_shadow_info)
1169                 err = gpg_error_from_syserror ();
1170               else
1171                 memcpy (*r_shadow_info, s, n);
1172             }
1173         }
1174       break;
1175     default:
1176       err = gpg_error (GPG_ERR_BAD_SECKEY);
1177       break;
1178     }
1179
1180   if (!err && r_keytype)
1181     *r_keytype = keytype;
1182
1183   xfree (buf);
1184   return err;
1185 }
1186
1187
1188 \f
1189 /* Delete the key with GRIP from the disk after having asked for
1190    confirmation using DESC_TEXT.  Common error codes are:
1191      GPG_ERR_NO_SECKEY
1192      GPG_ERR_KEY_ON_CARD
1193      GPG_ERR_NOT_CONFIRMED
1194 */
1195 gpg_error_t
1196 agent_delete_key (ctrl_t ctrl, const char *desc_text,
1197                   const unsigned char *grip)
1198 {
1199   gpg_error_t err;
1200   gcry_sexp_t s_skey = NULL;
1201   unsigned char *buf = NULL;
1202   size_t len;
1203   char *desc_text_final = NULL;
1204   char *comment = NULL;
1205   ssh_control_file_t cf = NULL;
1206   char hexgrip[40+4+1];
1207   char *default_desc = NULL;
1208
1209   err = read_key_file (grip, &s_skey);
1210   if (gpg_err_code (err) == GPG_ERR_ENOENT)
1211     err = gpg_error (GPG_ERR_NO_SECKEY);
1212   if (err)
1213     goto leave;
1214
1215   err = make_canon_sexp (s_skey, &buf, &len);
1216   if (err)
1217     goto leave;
1218
1219   switch (agent_private_key_type (buf))
1220     {
1221     case PRIVATE_KEY_CLEAR:
1222     case PRIVATE_KEY_PROTECTED:
1223       {
1224         bin2hex (grip, 20, hexgrip);
1225         if (!desc_text)
1226           {
1227             default_desc = xtryasprintf
1228               ("Do you really want to delete the key identified by keygrip%%0A"
1229                "  %s%%0A  %%C%%0A?", hexgrip);
1230             desc_text = default_desc;
1231           }
1232
1233         /* Note, that we will take the comment as a C string for
1234            display purposes; i.e. all stuff beyond a Nul character is
1235            ignored.  */
1236         {
1237           gcry_sexp_t comment_sexp;
1238
1239           comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
1240           if (comment_sexp)
1241             comment = gcry_sexp_nth_string (comment_sexp, 1);
1242           gcry_sexp_release (comment_sexp);
1243         }
1244
1245         if (desc_text)
1246           err = modify_description (desc_text, comment? comment:"", s_skey,
1247                                     &desc_text_final);
1248         if (err)
1249           goto leave;
1250
1251         err = agent_get_confirmation (ctrl, desc_text_final,
1252                                       _("Delete key"), _("No"), 0);
1253         if (err)
1254           goto leave;
1255
1256         cf = ssh_open_control_file ();
1257         if (cf)
1258           {
1259             if (!ssh_search_control_file (cf, hexgrip, NULL, NULL, NULL))
1260               {
1261                 err = agent_get_confirmation
1262                   (ctrl,
1263                    _("Warning: This key is also listed for use with SSH!\n"
1264                      "Deleting the key might remove your ability to "
1265                      "access remote machines."),
1266                    _("Delete key"), _("No"), 0);
1267                 if (err)
1268                   goto leave;
1269               }
1270           }
1271
1272         err = remove_key_file (grip);
1273       }
1274       break;
1275
1276     case PRIVATE_KEY_SHADOWED:
1277       err = gpg_error (GPG_ERR_KEY_ON_CARD);
1278       break;
1279
1280     default:
1281       log_error ("invalid private key format\n");
1282       err = gpg_error (GPG_ERR_BAD_SECKEY);
1283       break;
1284     }
1285
1286  leave:
1287   ssh_close_control_file (cf);
1288   gcry_free (comment);
1289   xfree (desc_text_final);
1290   xfree (default_desc);
1291   xfree (buf);
1292   gcry_sexp_release (s_skey);
1293   return err;
1294 }