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