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