agent: Remove useless conditions.
[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 (cache_mode == CACHE_MODE_NORMAL)
376                 agent_store_cache_hit (hexgrip);
377               if (r_passphrase)
378                 *r_passphrase = pw;
379               else
380                 xfree (pw);
381               xfree (*keybuf);
382               *keybuf = result;
383               return 0;
384             }
385           xfree (pw);
386           rc  = 0;
387         }
388       else if (cache_mode == CACHE_MODE_NORMAL)
389         {
390           /* The standard use of GPG keys is to have a signing and an
391              encryption subkey.  Commonly both use the same
392              passphrase.  We try to help the user to enter the
393              passphrase only once by silently trying the last
394              correctly entered passphrase.  Checking one additional
395              passphrase should be acceptable; despite the S2K
396              introduced delays. The assumed workflow is:
397
398                1. Read encrypted message in a MUA and thus enter a
399                   passphrase for the encryption subkey.
400
401                2. Reply to that mail with an encrypted and signed
402                   mail, thus entering the passphrase for the signing
403                   subkey.
404
405              We can often avoid the passphrase entry in the second
406              step.  We do this only in normal mode, so not to
407              interfere with unrelated cache entries.  */
408           pw = agent_get_cache (NULL, cache_mode);
409           if (pw)
410             {
411               rc = agent_unprotect (ctrl, *keybuf, pw, NULL,
412                                     &result, &resultlen);
413               if (!rc)
414                 {
415                   if (r_passphrase)
416                     *r_passphrase = pw;
417                   else
418                     xfree (pw);
419                   xfree (*keybuf);
420                   *keybuf = result;
421                   return 0;
422                 }
423               xfree (pw);
424               rc  = 0;
425             }
426         }
427
428       /* If the pinentry is currently in use, we wait up to 60 seconds
429          for it to close and check the cache again.  This solves a common
430          situation where several requests for unprotecting a key have
431          been made but the user is still entering the passphrase for
432          the first request.  Because all requests to agent_askpin are
433          serialized they would then pop up one after the other to
434          request the passphrase - despite that the user has already
435          entered it and is then available in the cache.  This
436          implementation is not race free but in the worst case the
437          user has to enter the passphrase only once more. */
438       if (pinentry_active_p (ctrl, 0))
439         {
440           /* Active - wait */
441           if (!pinentry_active_p (ctrl, 60))
442             {
443               /* We need to give the other thread a chance to actually put
444                  it into the cache. */
445               npth_sleep (1);
446               goto retry;
447             }
448           /* Timeout - better call pinentry now the plain way. */
449         }
450     }
451
452   pi = gcry_calloc_secure (1, sizeof (*pi) + 100);
453   if (!pi)
454     return gpg_error_from_syserror ();
455   pi->max_length = 100;
456   pi->min_digits = 0;  /* we want a real passphrase */
457   pi->max_digits = 16;
458   pi->max_tries = 3;
459   pi->check_cb = try_unprotect_cb;
460   arg.ctrl = ctrl;
461   arg.protected_key = *keybuf;
462   arg.unprotected_key = NULL;
463   arg.change_required = 0;
464   pi->check_cb_arg = &arg;
465
466   rc = agent_askpin (ctrl, desc_text, NULL, NULL, pi);
467   if (!rc)
468     {
469       assert (arg.unprotected_key);
470       if (arg.change_required)
471         {
472           size_t canlen, erroff;
473           gcry_sexp_t s_skey;
474
475           assert (arg.unprotected_key);
476           canlen = gcry_sexp_canon_len (arg.unprotected_key, 0, NULL, NULL);
477           rc = gcry_sexp_sscan (&s_skey, &erroff,
478                                 (char*)arg.unprotected_key, canlen);
479           if (rc)
480             {
481               log_error ("failed to build S-Exp (off=%u): %s\n",
482                          (unsigned int)erroff, gpg_strerror (rc));
483               wipememory (arg.unprotected_key, canlen);
484               xfree (arg.unprotected_key);
485               xfree (pi);
486               return rc;
487             }
488           rc = agent_protect_and_store (ctrl, s_skey, NULL);
489           gcry_sexp_release (s_skey);
490           if (rc)
491             {
492               log_error ("changing the passphrase failed: %s\n",
493                          gpg_strerror (rc));
494               wipememory (arg.unprotected_key, canlen);
495               xfree (arg.unprotected_key);
496               xfree (pi);
497               return rc;
498             }
499         }
500       else
501         {
502           agent_put_cache (hexgrip, cache_mode, pi->pin,
503                            lookup_ttl? lookup_ttl (hexgrip) : 0);
504           agent_store_cache_hit (hexgrip);
505           if (r_passphrase && *pi->pin)
506             *r_passphrase = xtrystrdup (pi->pin);
507         }
508       xfree (*keybuf);
509       *keybuf = arg.unprotected_key;
510     }
511   xfree (pi);
512   return rc;
513 }
514
515
516 /* Read the key identified by GRIP from the private key directory and
517    return it as an gcrypt S-expression object in RESULT.  On failure
518    returns an error code and stores NULL at RESULT. */
519 static gpg_error_t
520 read_key_file (const unsigned char *grip, gcry_sexp_t *result)
521 {
522   int rc;
523   char *fname;
524   estream_t fp;
525   struct stat st;
526   unsigned char *buf;
527   size_t buflen, erroff;
528   gcry_sexp_t s_skey;
529   char hexgrip[40+4+1];
530
531   *result = NULL;
532
533   bin2hex (grip, 20, hexgrip);
534   strcpy (hexgrip+40, ".key");
535
536   fname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, hexgrip, NULL);
537   fp = es_fopen (fname, "rb");
538   if (!fp)
539     {
540       rc = gpg_error_from_syserror ();
541       if (gpg_err_code (rc) != GPG_ERR_ENOENT)
542         log_error ("can't open '%s': %s\n", fname, strerror (errno));
543       xfree (fname);
544       return rc;
545     }
546
547   if (fstat (es_fileno (fp), &st))
548     {
549       rc = gpg_error_from_syserror ();
550       log_error ("can't stat '%s': %s\n", fname, strerror (errno));
551       xfree (fname);
552       es_fclose (fp);
553       return rc;
554     }
555
556   buflen = st.st_size;
557   buf = xtrymalloc (buflen+1);
558   if (!buf)
559     {
560       rc = gpg_error_from_syserror ();
561       log_error ("error allocating %zu bytes for '%s': %s\n",
562                  buflen, fname, strerror (errno));
563       xfree (fname);
564       es_fclose (fp);
565       xfree (buf);
566       return rc;
567
568     }
569
570   if (es_fread (buf, buflen, 1, fp) != 1)
571     {
572       rc = gpg_error_from_syserror ();
573       log_error ("error reading %zu bytes from '%s': %s\n",
574                  buflen, fname, strerror (errno));
575       xfree (fname);
576       es_fclose (fp);
577       xfree (buf);
578       return rc;
579     }
580
581   /* Convert the file into a gcrypt S-expression object.  */
582   rc = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
583   xfree (fname);
584   es_fclose (fp);
585   xfree (buf);
586   if (rc)
587     {
588       log_error ("failed to build S-Exp (off=%u): %s\n",
589                  (unsigned int)erroff, gpg_strerror (rc));
590       return rc;
591     }
592   *result = s_skey;
593   return 0;
594 }
595
596
597 /* Remove the key identified by GRIP from the private key directory.  */
598 static gpg_error_t
599 remove_key_file (const unsigned char *grip)
600 {
601   gpg_error_t err = 0;
602   char *fname;
603   char hexgrip[40+4+1];
604
605   bin2hex (grip, 20, hexgrip);
606   strcpy (hexgrip+40, ".key");
607   fname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, hexgrip, NULL);
608   if (gnupg_remove (fname))
609     err = gpg_error_from_syserror ();
610   xfree (fname);
611   return err;
612 }
613
614
615 /* Return the secret key as an S-Exp in RESULT after locating it using
616    the GRIP.  If the operation shall be diverted to a token, an
617    allocated S-expression with the shadow_info part from the file is
618    stored at SHADOW_INFO; if not NULL will be stored at SHADOW_INFO.
619    CACHE_MODE defines now the cache shall be used.  DESC_TEXT may be
620    set to present a custom description for the pinentry.  LOOKUP_TTL
621    is an optional function to convey a TTL to the cache manager; we do
622    not simply pass the TTL value because the value is only needed if
623    an unprotect action was needed and looking up the TTL may have some
624    overhead (e.g. scanning the sshcontrol file).  If a CACHE_NONCE is
625    given that cache item is first tried to get a passphrase.  If
626    R_PASSPHRASE is not NULL, the function succeeded and the key was
627    protected the used passphrase (entered or from the cache) is stored
628    there; if not NULL will be stored.  The caller needs to free the
629    returned passphrase.   */
630 gpg_error_t
631 agent_key_from_file (ctrl_t ctrl, const char *cache_nonce,
632                      const char *desc_text,
633                      const unsigned char *grip, unsigned char **shadow_info,
634                      cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
635                      gcry_sexp_t *result, char **r_passphrase)
636 {
637   int rc;
638   unsigned char *buf;
639   size_t len, buflen, erroff;
640   gcry_sexp_t s_skey;
641
642   *result = NULL;
643   if (shadow_info)
644     *shadow_info = NULL;
645   if (r_passphrase)
646     *r_passphrase = NULL;
647
648   rc = read_key_file (grip, &s_skey);
649   if (rc)
650     {
651       if (gpg_err_code (rc) == GPG_ERR_ENOENT)
652         rc = gpg_error (GPG_ERR_NO_SECKEY);
653       return rc;
654     }
655
656   /* For use with the protection functions we also need the key as an
657      canonical encoded S-expression in a buffer.  Create this buffer
658      now.  */
659   rc = make_canon_sexp (s_skey, &buf, &len);
660   if (rc)
661     return rc;
662
663   switch (agent_private_key_type (buf))
664     {
665     case PRIVATE_KEY_CLEAR:
666       break; /* no unprotection needed */
667     case PRIVATE_KEY_OPENPGP_NONE:
668       {
669         unsigned char *buf_new;
670         size_t buf_newlen;
671
672         rc = agent_unprotect (ctrl, buf, "", NULL, &buf_new, &buf_newlen);
673         if (rc)
674           log_error ("failed to convert unprotected openpgp key: %s\n",
675                      gpg_strerror (rc));
676         else
677           {
678             xfree (buf);
679             buf = buf_new;
680           }
681       }
682       break;
683     case PRIVATE_KEY_PROTECTED:
684       {
685         char *desc_text_final;
686         char *comment = NULL;
687
688         /* Note, that we will take the comment as a C string for
689            display purposes; i.e. all stuff beyond a Nul character is
690            ignored.  */
691         {
692           gcry_sexp_t comment_sexp;
693
694           comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
695           if (comment_sexp)
696             comment = gcry_sexp_nth_string (comment_sexp, 1);
697           gcry_sexp_release (comment_sexp);
698         }
699
700         desc_text_final = NULL;
701         if (desc_text)
702           rc = modify_description (desc_text, comment? comment:"", s_skey,
703                                    &desc_text_final);
704         gcry_free (comment);
705
706         if (!rc)
707           {
708             rc = unprotect (ctrl, cache_nonce, desc_text_final, &buf, grip,
709                             cache_mode, lookup_ttl, r_passphrase);
710             if (rc)
711               log_error ("failed to unprotect the secret key: %s\n",
712                          gpg_strerror (rc));
713           }
714
715         xfree (desc_text_final);
716       }
717       break;
718     case PRIVATE_KEY_SHADOWED:
719       if (shadow_info)
720         {
721           const unsigned char *s;
722           size_t n;
723
724           rc = agent_get_shadow_info (buf, &s);
725           if (!rc)
726             {
727               n = gcry_sexp_canon_len (s, 0, NULL,NULL);
728               assert (n);
729               *shadow_info = xtrymalloc (n);
730               if (!*shadow_info)
731                 rc = out_of_core ();
732               else
733                 {
734                   memcpy (*shadow_info, s, n);
735                   rc = 0;
736                 }
737             }
738           if (rc)
739             log_error ("get_shadow_info failed: %s\n", gpg_strerror (rc));
740         }
741       else
742         rc = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
743       break;
744     default:
745       log_error ("invalid private key format\n");
746       rc = gpg_error (GPG_ERR_BAD_SECKEY);
747       break;
748     }
749   gcry_sexp_release (s_skey);
750   s_skey = NULL;
751   if (rc)
752     {
753       xfree (buf);
754       if (r_passphrase)
755         {
756           xfree (*r_passphrase);
757           *r_passphrase = NULL;
758         }
759       return rc;
760     }
761
762   buflen = gcry_sexp_canon_len (buf, 0, NULL, NULL);
763   rc = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
764   wipememory (buf, buflen);
765   xfree (buf);
766   if (rc)
767     {
768       log_error ("failed to build S-Exp (off=%u): %s\n",
769                  (unsigned int)erroff, gpg_strerror (rc));
770       if (r_passphrase)
771         {
772           xfree (*r_passphrase);
773           *r_passphrase = NULL;
774         }
775       return rc;
776     }
777
778   *result = s_skey;
779   return 0;
780 }
781
782
783 /* Return the string name from the S-expression S_KEY as well as a
784    string describing the names of the parameters.  ALGONAMESIZE and
785    ELEMSSIZE give the allocated size of the provided buffers.  The
786    buffers may be NULL if not required.  If R_LIST is not NULL the top
787    level list will be stored there; the caller needs to release it in
788    this case.  */
789 static gpg_error_t
790 key_parms_from_sexp (gcry_sexp_t s_key, gcry_sexp_t *r_list,
791                      char *r_algoname, size_t algonamesize,
792                      char *r_elems, size_t elemssize)
793 {
794   gcry_sexp_t list, l2;
795   const char *name, *algoname, *elems;
796   size_t n;
797
798   if (r_list)
799     *r_list = NULL;
800
801   list = gcry_sexp_find_token (s_key, "shadowed-private-key", 0 );
802   if (!list)
803     list = gcry_sexp_find_token (s_key, "protected-private-key", 0 );
804   if (!list)
805     list = gcry_sexp_find_token (s_key, "private-key", 0 );
806   if (!list)
807     {
808       log_error ("invalid private key format\n");
809       return gpg_error (GPG_ERR_BAD_SECKEY);
810     }
811
812   l2 = gcry_sexp_cadr (list);
813   gcry_sexp_release (list);
814   list = l2;
815   name = gcry_sexp_nth_data (list, 0, &n);
816   if (n==3 && !memcmp (name, "rsa", 3))
817     {
818       algoname = "rsa";
819       elems = "ne";
820     }
821   else if (n==3 && !memcmp (name, "dsa", 3))
822     {
823       algoname = "dsa";
824       elems = "pqgy";
825     }
826   else if (n==3 && !memcmp (name, "ecc", 3))
827     {
828       algoname = "ecc";
829       elems = "pabgnq";
830     }
831   else if (n==5 && !memcmp (name, "ecdsa", 5))
832     {
833       algoname = "ecdsa";
834       elems = "pabgnq";
835     }
836   else if (n==4 && !memcmp (name, "ecdh", 4))
837     {
838       algoname = "ecdh";
839       elems = "pabgnq";
840     }
841   else if (n==3 && !memcmp (name, "elg", 3))
842     {
843       algoname = "elg";
844       elems = "pgy";
845     }
846   else
847     {
848       log_error ("unknown private key algorithm\n");
849       gcry_sexp_release (list);
850       return gpg_error (GPG_ERR_BAD_SECKEY);
851     }
852
853   if (r_algoname)
854     {
855       if (strlen (algoname) >= algonamesize)
856         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
857       strcpy (r_algoname, algoname);
858     }
859   if (r_elems)
860     {
861       if (strlen (elems) >= elemssize)
862         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
863       strcpy (r_elems, elems);
864     }
865
866   if (r_list)
867     *r_list = list;
868   else
869     gcry_sexp_release (list);
870
871   return 0;
872 }
873
874
875 /* Return true if KEYPARMS holds an EdDSA key.  */
876 static int
877 is_eddsa (gcry_sexp_t keyparms)
878 {
879   int result = 0;
880   gcry_sexp_t list;
881   const char *s;
882   size_t n;
883   int i;
884
885   list = gcry_sexp_find_token (keyparms, "flags", 0);
886   for (i = list ? gcry_sexp_length (list)-1 : 0; i > 0; i--)
887     {
888       s = gcry_sexp_nth_data (list, i, &n);
889       if (!s)
890         continue; /* Not a data element. */
891
892       if (n == 5 && !memcmp (s, "eddsa", 5))
893         {
894           result = 1;
895           break;
896         }
897     }
898   gcry_sexp_release (list);
899   return result;
900 }
901
902
903 /* Return the public key algorithm number if S_KEY is a DSA style key.
904    If it is not a DSA style key, return 0.  */
905 int
906 agent_is_dsa_key (gcry_sexp_t s_key)
907 {
908   int result;
909   gcry_sexp_t list;
910   char algoname[6];
911
912   if (!s_key)
913     return 0;
914
915   if (key_parms_from_sexp (s_key, &list, algoname, sizeof algoname, NULL, 0))
916     return 0; /* Error - assume it is not an DSA key.  */
917
918   if (!strcmp (algoname, "dsa"))
919     result = GCRY_PK_DSA;
920   else if (!strcmp (algoname, "ecc"))
921     {
922       if (is_eddsa (list))
923         result = 0;
924       else
925         result = GCRY_PK_ECDSA;
926     }
927   else if (!strcmp (algoname, "ecdsa"))
928     result = GCRY_PK_ECDSA;
929   else
930     result = 0;
931
932   gcry_sexp_release (list);
933   return result;
934 }
935
936
937 /* Return true if S_KEY is an EdDSA key as used with curve Ed25519.  */
938 int
939 agent_is_eddsa_key (gcry_sexp_t s_key)
940 {
941   int result;
942   gcry_sexp_t list;
943   char algoname[6];
944
945   if (!s_key)
946     return 0;
947
948   if (key_parms_from_sexp (s_key, &list, algoname, sizeof algoname, NULL, 0))
949     return 0; /* Error - assume it is not an EdDSA key.  */
950
951   if (!strcmp (algoname, "ecc") && is_eddsa (list))
952     result = 1;
953   else if (!strcmp (algoname, "eddsa")) /* backward compatibility.  */
954     result = 1;
955   else
956     result = 0;
957
958   gcry_sexp_release (list);
959   return result;
960 }
961
962
963 /* Return the key for the keygrip GRIP.  The result is stored at
964    RESULT.  This function extracts the key from the private key
965    database and returns it as an S-expression object as it is.  On
966    failure an error code is returned and NULL stored at RESULT. */
967 gpg_error_t
968 agent_raw_key_from_file (ctrl_t ctrl, const unsigned char *grip,
969                          gcry_sexp_t *result)
970 {
971   gpg_error_t err;
972   gcry_sexp_t s_skey;
973
974   (void)ctrl;
975
976   *result = NULL;
977
978   err = read_key_file (grip, &s_skey);
979   if (!err)
980     *result = s_skey;
981   return err;
982 }
983
984
985 /* Return the public key for the keygrip GRIP.  The result is stored
986    at RESULT.  This function extracts the public key from the private
987    key database.  On failure an error code is returned and NULL stored
988    at RESULT. */
989 gpg_error_t
990 agent_public_key_from_file (ctrl_t ctrl,
991                             const unsigned char *grip,
992                             gcry_sexp_t *result)
993 {
994   gpg_error_t err;
995   int i, idx;
996   gcry_sexp_t s_skey;
997   const char *algoname, *elems;
998   int npkey;
999   gcry_mpi_t array[10];
1000   gcry_sexp_t curve = NULL;
1001   gcry_sexp_t flags = NULL;
1002   gcry_sexp_t uri_sexp, comment_sexp;
1003   const char *uri, *comment;
1004   size_t uri_length, comment_length;
1005   char *format, *p;
1006   void *args[2+7+2+2+1]; /* Size is 2 + max. # of elements + 2 for uri + 2
1007                             for comment + end-of-list.  */
1008   int argidx;
1009   gcry_sexp_t list = NULL;
1010   const char *s;
1011
1012   (void)ctrl;
1013
1014   *result = NULL;
1015
1016   err = read_key_file (grip, &s_skey);
1017   if (err)
1018     return err;
1019
1020   for (i=0; i < DIM (array); i++)
1021     array[i] = NULL;
1022
1023   err = extract_private_key (s_skey, 0, &algoname, &npkey, NULL, &elems,
1024                              array, DIM (array), &curve, &flags);
1025   if (err)
1026     {
1027       gcry_sexp_release (s_skey);
1028       return err;
1029     }
1030
1031   uri = NULL;
1032   uri_length = 0;
1033   uri_sexp = gcry_sexp_find_token (s_skey, "uri", 0);
1034   if (uri_sexp)
1035     uri = gcry_sexp_nth_data (uri_sexp, 1, &uri_length);
1036
1037   comment = NULL;
1038   comment_length = 0;
1039   comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
1040   if (comment_sexp)
1041     comment = gcry_sexp_nth_data (comment_sexp, 1, &comment_length);
1042
1043   gcry_sexp_release (s_skey);
1044   s_skey = NULL;
1045
1046
1047   /* FIXME: The following thing is pretty ugly code; we should
1048      investigate how to make it cleaner.  Probably code to handle
1049      canonical S-expressions in a memory buffer is better suited for
1050      such a task.  After all that is what we do in protect.c.  Neeed
1051      to find common patterns and write a straightformward API to use
1052      them.  */
1053   assert (sizeof (size_t) <= sizeof (void*));
1054
1055   format = xtrymalloc (15+4+7*npkey+10+15+1+1);
1056   if (!format)
1057     {
1058       err = gpg_error_from_syserror ();
1059       for (i=0; array[i]; i++)
1060         gcry_mpi_release (array[i]);
1061       gcry_sexp_release (curve);
1062       gcry_sexp_release (flags);
1063       gcry_sexp_release (uri_sexp);
1064       gcry_sexp_release (comment_sexp);
1065       return err;
1066     }
1067
1068   argidx = 0;
1069   p = stpcpy (stpcpy (format, "(public-key("), algoname);
1070   p = stpcpy (p, "%S%S");       /* curve name and flags.  */
1071   args[argidx++] = &curve;
1072   args[argidx++] = &flags;
1073   for (idx=0, s=elems; idx < npkey; idx++)
1074     {
1075       *p++ = '(';
1076       *p++ = *s++;
1077       p = stpcpy (p, " %m)");
1078       assert (argidx < DIM (args));
1079       args[argidx++] = &array[idx];
1080     }
1081   *p++ = ')';
1082   if (uri)
1083     {
1084       p = stpcpy (p, "(uri %b)");
1085       assert (argidx+1 < DIM (args));
1086       args[argidx++] = (void *)&uri_length;
1087       args[argidx++] = (void *)&uri;
1088     }
1089   if (comment)
1090     {
1091       p = stpcpy (p, "(comment %b)");
1092       assert (argidx+1 < DIM (args));
1093       args[argidx++] = (void *)&comment_length;
1094       args[argidx++] = (void*)&comment;
1095     }
1096   *p++ = ')';
1097   *p = 0;
1098   assert (argidx < DIM (args));
1099   args[argidx] = NULL;
1100
1101   err = gcry_sexp_build_array (&list, NULL, format, args);
1102   xfree (format);
1103   for (i=0; array[i]; i++)
1104     gcry_mpi_release (array[i]);
1105   gcry_sexp_release (curve);
1106   gcry_sexp_release (flags);
1107   gcry_sexp_release (uri_sexp);
1108   gcry_sexp_release (comment_sexp);
1109
1110   if (!err)
1111     *result = list;
1112   return err;
1113 }
1114
1115
1116
1117 /* Check whether the the secret key identified by GRIP is available.
1118    Returns 0 is the key is available.  */
1119 int
1120 agent_key_available (const unsigned char *grip)
1121 {
1122   int result;
1123   char *fname;
1124   char hexgrip[40+4+1];
1125
1126   bin2hex (grip, 20, hexgrip);
1127   strcpy (hexgrip+40, ".key");
1128
1129   fname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, hexgrip, NULL);
1130   result = !access (fname, R_OK)? 0 : -1;
1131   xfree (fname);
1132   return result;
1133 }
1134
1135
1136
1137 /* Return the information about the secret key specified by the binary
1138    keygrip GRIP.  If the key is a shadowed one the shadow information
1139    will be stored at the address R_SHADOW_INFO as an allocated
1140    S-expression.  */
1141 gpg_error_t
1142 agent_key_info_from_file (ctrl_t ctrl, const unsigned char *grip,
1143                           int *r_keytype, unsigned char **r_shadow_info)
1144 {
1145   gpg_error_t err;
1146   unsigned char *buf;
1147   size_t len;
1148   int keytype;
1149
1150   (void)ctrl;
1151
1152   if (r_keytype)
1153     *r_keytype = PRIVATE_KEY_UNKNOWN;
1154   if (r_shadow_info)
1155     *r_shadow_info = NULL;
1156
1157   {
1158     gcry_sexp_t sexp;
1159
1160     err = read_key_file (grip, &sexp);
1161     if (err)
1162       {
1163         if (gpg_err_code (err) == GPG_ERR_ENOENT)
1164           return gpg_error (GPG_ERR_NOT_FOUND);
1165         else
1166           return err;
1167       }
1168     err = make_canon_sexp (sexp, &buf, &len);
1169     gcry_sexp_release (sexp);
1170     if (err)
1171       return err;
1172   }
1173
1174   keytype = agent_private_key_type (buf);
1175   switch (keytype)
1176     {
1177     case PRIVATE_KEY_CLEAR:
1178     case PRIVATE_KEY_OPENPGP_NONE:
1179       break;
1180     case PRIVATE_KEY_PROTECTED:
1181       /* If we ever require it we could retrieve the comment fields
1182          from such a key. */
1183       break;
1184     case PRIVATE_KEY_SHADOWED:
1185       if (r_shadow_info)
1186         {
1187           const unsigned char *s;
1188           size_t n;
1189
1190           err = agent_get_shadow_info (buf, &s);
1191           if (!err)
1192             {
1193               n = gcry_sexp_canon_len (s, 0, NULL, NULL);
1194               assert (n);
1195               *r_shadow_info = xtrymalloc (n);
1196               if (!*r_shadow_info)
1197                 err = gpg_error_from_syserror ();
1198               else
1199                 memcpy (*r_shadow_info, s, n);
1200             }
1201         }
1202       break;
1203     default:
1204       err = gpg_error (GPG_ERR_BAD_SECKEY);
1205       break;
1206     }
1207
1208   if (!err && r_keytype)
1209     *r_keytype = keytype;
1210
1211   xfree (buf);
1212   return err;
1213 }
1214
1215
1216 \f
1217 /* Delete the key with GRIP from the disk after having asked for
1218    confirmation using DESC_TEXT.  Common error codes are:
1219      GPG_ERR_NO_SECKEY
1220      GPG_ERR_KEY_ON_CARD
1221      GPG_ERR_NOT_CONFIRMED
1222 */
1223 gpg_error_t
1224 agent_delete_key (ctrl_t ctrl, const char *desc_text,
1225                   const unsigned char *grip)
1226 {
1227   gpg_error_t err;
1228   gcry_sexp_t s_skey = NULL;
1229   unsigned char *buf = NULL;
1230   size_t len;
1231   char *desc_text_final = NULL;
1232   char *comment = NULL;
1233   ssh_control_file_t cf = NULL;
1234   char hexgrip[40+4+1];
1235   char *default_desc = NULL;
1236
1237   err = read_key_file (grip, &s_skey);
1238   if (gpg_err_code (err) == GPG_ERR_ENOENT)
1239     err = gpg_error (GPG_ERR_NO_SECKEY);
1240   if (err)
1241     goto leave;
1242
1243   err = make_canon_sexp (s_skey, &buf, &len);
1244   if (err)
1245     goto leave;
1246
1247   switch (agent_private_key_type (buf))
1248     {
1249     case PRIVATE_KEY_CLEAR:
1250     case PRIVATE_KEY_OPENPGP_NONE:
1251     case PRIVATE_KEY_PROTECTED:
1252       {
1253         bin2hex (grip, 20, hexgrip);
1254         if (!desc_text)
1255           {
1256             default_desc = xtryasprintf
1257               ("Do you really want to delete the key identified by keygrip%%0A"
1258                "  %s%%0A  %%C%%0A?", hexgrip);
1259             desc_text = default_desc;
1260           }
1261
1262         /* Note, that we will take the comment as a C string for
1263            display purposes; i.e. all stuff beyond a Nul character is
1264            ignored.  */
1265         {
1266           gcry_sexp_t comment_sexp;
1267
1268           comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
1269           if (comment_sexp)
1270             comment = gcry_sexp_nth_string (comment_sexp, 1);
1271           gcry_sexp_release (comment_sexp);
1272         }
1273
1274         if (desc_text)
1275           err = modify_description (desc_text, comment? comment:"", s_skey,
1276                                     &desc_text_final);
1277         if (err)
1278           goto leave;
1279
1280         err = agent_get_confirmation (ctrl, desc_text_final,
1281                                       _("Delete key"), _("No"), 0);
1282         if (err)
1283           goto leave;
1284
1285         cf = ssh_open_control_file ();
1286         if (cf)
1287           {
1288             if (!ssh_search_control_file (cf, hexgrip, NULL, NULL, NULL))
1289               {
1290                 err = agent_get_confirmation
1291                   (ctrl,
1292                    _("Warning: This key is also listed for use with SSH!\n"
1293                      "Deleting the key might remove your ability to "
1294                      "access remote machines."),
1295                    _("Delete key"), _("No"), 0);
1296                 if (err)
1297                   goto leave;
1298               }
1299           }
1300
1301         err = remove_key_file (grip);
1302       }
1303       break;
1304
1305     case PRIVATE_KEY_SHADOWED:
1306       err = gpg_error (GPG_ERR_KEY_ON_CARD);
1307       break;
1308
1309     default:
1310       log_error ("invalid private key format\n");
1311       err = gpg_error (GPG_ERR_BAD_SECKEY);
1312       break;
1313     }
1314
1315  leave:
1316   ssh_close_control_file (cf);
1317   gcry_free (comment);
1318   xfree (desc_text_final);
1319   xfree (default_desc);
1320   xfree (buf);
1321   gcry_sexp_release (s_skey);
1322   return err;
1323 }