Obscure the cached passphrases.
[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       char *pw;
295       
296       pw = agent_get_cache (cache_nonce, CACHE_MODE_NONCE);
297       if (pw)
298         {
299           rc = agent_unprotect (*keybuf, pw, NULL, &result, &resultlen);
300           xfree (pw);
301           if (!rc)
302             {
303               xfree (*keybuf);
304               *keybuf = result;
305               return 0;
306             }
307         }
308     }
309
310   /* First try to get it from the cache - if there is none or we can't
311      unprotect it, we fall back to ask the user */
312   if (cache_mode != CACHE_MODE_IGNORE)
313     {
314       char *pw;
315       
316     retry:
317       pw = agent_get_cache (hexgrip, cache_mode);
318       if (pw)
319         {
320           rc = agent_unprotect (*keybuf, pw, NULL, &result, &resultlen);
321           xfree (pw);
322           if (!rc)
323             {
324               xfree (*keybuf);
325               *keybuf = result;
326               return 0;
327             }
328           rc  = 0;
329         }
330
331       /* If the pinentry is currently in use, we wait up to 60 seconds
332          for it to close and check the cache again.  This solves a common
333          situation where several requests for unprotecting a key have
334          been made but the user is still entering the passphrase for
335          the first request.  Because all requests to agent_askpin are
336          serialized they would then pop up one after the other to
337          request the passphrase - despite that the user has already
338          entered it and is then available in the cache.  This
339          implementation is not race free but in the worst case the
340          user has to enter the passphrase only once more. */
341       if (pinentry_active_p (ctrl, 0))
342         {
343           /* Active - wait */
344           if (!pinentry_active_p (ctrl, 60))
345             {
346               /* We need to give the other thread a chance to actually put
347                  it into the cache. */
348               pth_sleep (1); 
349               goto retry;
350             }
351           /* Timeout - better call pinentry now the plain way. */
352         }
353     }
354
355   pi = gcry_calloc_secure (1, sizeof (*pi) + 100);
356   if (!pi)
357     return gpg_error_from_syserror ();
358   pi->max_length = 100;
359   pi->min_digits = 0;  /* we want a real passphrase */
360   pi->max_digits = 16;
361   pi->max_tries = 3;
362   pi->check_cb = try_unprotect_cb;
363   arg.ctrl = ctrl;
364   arg.protected_key = *keybuf;
365   arg.unprotected_key = NULL;
366   arg.change_required = 0;
367   pi->check_cb_arg = &arg;
368
369   rc = agent_askpin (ctrl, desc_text, NULL, NULL, pi);
370   if (!rc)
371     {
372       assert (arg.unprotected_key);
373       if (arg.change_required)
374         {
375           size_t canlen, erroff;
376           gcry_sexp_t s_skey;
377           
378           assert (arg.unprotected_key);
379           canlen = gcry_sexp_canon_len (arg.unprotected_key, 0, NULL, NULL);
380           rc = gcry_sexp_sscan (&s_skey, &erroff,
381                                 (char*)arg.unprotected_key, canlen);
382           if (rc)
383             {
384               log_error ("failed to build S-Exp (off=%u): %s\n",
385                          (unsigned int)erroff, gpg_strerror (rc));
386               wipememory (arg.unprotected_key, canlen);
387               xfree (arg.unprotected_key);
388               xfree (pi);
389               return rc;
390             }
391           rc = agent_protect_and_store (ctrl, s_skey);
392           gcry_sexp_release (s_skey);
393           if (rc)
394             {
395               log_error ("changing the passphrase failed: %s\n", 
396                          gpg_strerror (rc));
397               wipememory (arg.unprotected_key, canlen);
398               xfree (arg.unprotected_key);
399               xfree (pi);
400               return rc;
401             }
402         }
403       agent_put_cache (hexgrip, cache_mode, pi->pin, 
404                        lookup_ttl? lookup_ttl (hexgrip) : 0);
405       xfree (*keybuf);
406       *keybuf = arg.unprotected_key;
407     }
408   xfree (pi);
409   return rc;
410 }
411
412
413 /* Read the key identified by GRIP from the private key directory and
414    return it as an gcrypt S-expression object in RESULT.  On failure
415    returns an error code and stores NULL at RESULT. */
416 static gpg_error_t
417 read_key_file (const unsigned char *grip, gcry_sexp_t *result)
418 {
419   int rc;
420   char *fname;
421   estream_t fp;
422   struct stat st;
423   unsigned char *buf;
424   size_t buflen, erroff;
425   gcry_sexp_t s_skey;
426   char hexgrip[40+4+1];
427   
428   *result = NULL;
429
430   bin2hex (grip, 20, hexgrip);
431   strcpy (hexgrip+40, ".key");
432
433   fname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, hexgrip, NULL);
434   fp = es_fopen (fname, "rb");
435   if (!fp)
436     {
437       rc = gpg_error_from_syserror ();
438       if (gpg_err_code (rc) != GPG_ERR_ENOENT)
439         log_error ("can't open `%s': %s\n", fname, strerror (errno));
440       xfree (fname);
441       return rc;
442     }
443   
444   if (fstat (es_fileno (fp), &st))
445     {
446       rc = gpg_error_from_syserror ();
447       log_error ("can't stat `%s': %s\n", fname, strerror (errno));
448       xfree (fname);
449       es_fclose (fp);
450       return rc;
451     }
452
453   buflen = st.st_size;
454   buf = xtrymalloc (buflen+1);
455   if (!buf)
456     {
457       rc = gpg_error_from_syserror ();
458       log_error ("error allocating %zu bytes for `%s': %s\n",
459                  buflen, fname, strerror (errno));
460       xfree (fname);
461       es_fclose (fp);
462       xfree (buf);
463       return rc;
464
465     }
466
467   if (es_fread (buf, buflen, 1, fp) != 1)
468     {
469       rc = gpg_error_from_syserror ();
470       log_error ("error reading %zu bytes from `%s': %s\n", 
471                  buflen, fname, strerror (errno));
472       xfree (fname);
473       es_fclose (fp);
474       xfree (buf);
475       return rc;
476     }
477
478   /* Convert the file into a gcrypt S-expression object.  */
479   rc = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
480   xfree (fname);
481   es_fclose (fp);
482   xfree (buf);
483   if (rc)
484     {
485       log_error ("failed to build S-Exp (off=%u): %s\n",
486                  (unsigned int)erroff, gpg_strerror (rc));
487       return rc;
488     }
489   *result = s_skey;
490   return 0;
491 }
492
493
494 /* Return the secret key as an S-Exp in RESULT after locating it using
495    the GRIP.  Stores NULL at RESULT if the operation shall be diverted
496    to a token; in this case an allocated S-expression with the
497    shadow_info part from the file is stored at SHADOW_INFO.
498    CACHE_MODE defines now the cache shall be used.  DESC_TEXT may be
499    set to present a custom description for the pinentry.  LOOKUP_TTL
500    is an optional function to convey a TTL to the cache manager; we do
501    not simply pass the TTL value because the value is only needed if
502    an unprotect action was needed and looking up the TTL may have some
503    overhead (e.g. scanning the sshcontrol file).  If a CACHE_NONCE is
504    given that cache item is first tried to get a passphrase.  */
505 gpg_error_t
506 agent_key_from_file (ctrl_t ctrl, const char *cache_nonce,
507                      const char *desc_text,
508                      const unsigned char *grip, unsigned char **shadow_info,
509                      cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
510                      gcry_sexp_t *result)
511 {
512   int rc;
513   unsigned char *buf;
514   size_t len, buflen, erroff;
515   gcry_sexp_t s_skey;
516   int got_shadow_info = 0;
517   
518   *result = NULL;
519   if (shadow_info)
520     *shadow_info = NULL;
521
522   rc = read_key_file (grip, &s_skey);
523   if (rc)
524     return rc;
525
526   /* For use with the protection functions we also need the key as an
527      canonical encoded S-expression in a buffer.  Create this buffer
528      now.  */
529   rc = make_canon_sexp (s_skey, &buf, &len);
530   if (rc)
531     return rc;
532
533   switch (agent_private_key_type (buf))
534     {
535     case PRIVATE_KEY_CLEAR:
536       break; /* no unprotection needed */
537     case PRIVATE_KEY_PROTECTED:
538       {
539         gcry_sexp_t comment_sexp;
540         size_t comment_length;
541         char *desc_text_final;
542         const char *comment = NULL;
543
544         /* Note, that we will take the comment as a C string for
545            display purposes; i.e. all stuff beyond a Nul character is
546            ignored.  */
547         comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
548         if (comment_sexp)
549           comment = gcry_sexp_nth_data (comment_sexp, 1, &comment_length);
550         if (!comment)
551           {
552             comment = "";
553             comment_length = 0;
554           }
555
556         desc_text_final = NULL;
557         if (desc_text)
558           {
559             if (comment[comment_length])
560               {
561                 /* Not a C-string; create one.  We might here allocate
562                    more than actually displayed but well, that
563                    shouldn't be a problem.  */
564                 char *tmp = xtrymalloc (comment_length+1);
565                 if (!tmp)
566                   rc = gpg_error_from_syserror ();
567                 else
568                   {
569                     memcpy (tmp, comment, comment_length);
570                     tmp[comment_length] = 0;
571                     rc = modify_description (desc_text, tmp, &desc_text_final);
572                     xfree (tmp);
573                   }
574               }
575             else
576               rc = modify_description (desc_text, comment, &desc_text_final);
577           }
578
579         if (!rc)
580           {
581             rc = unprotect (ctrl, cache_nonce, desc_text_final, &buf, grip,
582                             cache_mode, lookup_ttl);
583             if (rc)
584               log_error ("failed to unprotect the secret key: %s\n",
585                          gpg_strerror (rc));
586           }
587         
588         gcry_sexp_release (comment_sexp);
589         xfree (desc_text_final);
590       }
591       break;
592     case PRIVATE_KEY_SHADOWED:
593       if (shadow_info)
594         {
595           const unsigned char *s;
596           size_t n;
597
598           rc = agent_get_shadow_info (buf, &s);
599           if (!rc)
600             {
601               n = gcry_sexp_canon_len (s, 0, NULL,NULL);
602               assert (n);
603               *shadow_info = xtrymalloc (n);
604               if (!*shadow_info)
605                 rc = out_of_core ();
606               else
607                 {
608                   memcpy (*shadow_info, s, n);
609                   rc = 0;
610                   got_shadow_info = 1;
611                 }
612             }
613           if (rc)
614             log_error ("get_shadow_info failed: %s\n", gpg_strerror (rc));
615         }
616       else
617         rc = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
618       break;
619     default:
620       log_error ("invalid private key format\n");
621       rc = gpg_error (GPG_ERR_BAD_SECKEY);
622       break;
623     }
624   gcry_sexp_release (s_skey);
625   s_skey = NULL;
626   if (rc || got_shadow_info)
627     {
628       xfree (buf);
629       return rc;
630     }
631
632   buflen = gcry_sexp_canon_len (buf, 0, NULL, NULL);
633   rc = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
634   wipememory (buf, buflen);
635   xfree (buf);
636   if (rc)
637     {
638       log_error ("failed to build S-Exp (off=%u): %s\n",
639                  (unsigned int)erroff, gpg_strerror (rc));
640       return rc;
641     }
642
643   *result = s_skey;
644   return 0;
645 }
646
647
648 /* Return the string name from the S-expression S_KEY as well as a
649    string describing the names of the parameters.  ALGONAMESIZE and
650    ELEMSSIZE give the allocated size of the provided buffers.  The
651    buffers may be NULL if not required.  If R_LIST is not NULL the top
652    level list will be stored tehre; the caller needs to release it in
653    this case.  */
654 static gpg_error_t
655 key_parms_from_sexp (gcry_sexp_t s_key, gcry_sexp_t *r_list,
656                      char *r_algoname, size_t algonamesize,
657                      char *r_elems, size_t elemssize)
658 {
659   gcry_sexp_t list, l2;
660   const char *name, *algoname, *elems;
661   size_t n;
662
663   if (r_list)
664     *r_list = NULL;
665
666   list = gcry_sexp_find_token (s_key, "shadowed-private-key", 0 );
667   if (!list)
668     list = gcry_sexp_find_token (s_key, "protected-private-key", 0 );
669   if (!list)
670     list = gcry_sexp_find_token (s_key, "private-key", 0 );
671   if (!list)
672     {
673       log_error ("invalid private key format\n");
674       return gpg_error (GPG_ERR_BAD_SECKEY);
675     }
676
677   l2 = gcry_sexp_cadr (list);
678   gcry_sexp_release (list);
679   list = l2;
680   name = gcry_sexp_nth_data (list, 0, &n);
681   if (n==3 && !memcmp (name, "rsa", 3))
682     {
683       algoname = "rsa";
684       elems = "ne";
685     }
686   else if (n==3 && !memcmp (name, "dsa", 3))
687     {
688       algoname = "dsa";
689       elems = "pqgy";
690     }
691   else if (n==3 && !memcmp (name, "elg", 3))
692     {
693       algoname = "elg";
694       elems = "pgy";
695     }
696   else
697     {
698       log_error ("unknown private key algorithm\n");
699       gcry_sexp_release (list);
700       return gpg_error (GPG_ERR_BAD_SECKEY);
701     }
702
703   if (r_algoname)
704     {
705       if (strlen (algoname) >= algonamesize)
706         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
707       strcpy (r_algoname, algoname);
708     } 
709   if (r_elems)
710     {
711       if (strlen (elems) >= elemssize)
712         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
713       strcpy (r_elems, elems);
714     }
715
716   if (r_list)
717     *r_list = list;
718   else
719     gcry_sexp_release (list);
720       
721   return 0;
722 }
723
724
725 /* Return the public key algorithm number if S_KEY is a DSA style key.
726    If it is not a DSA style key, return 0.  */
727 int 
728 agent_is_dsa_key (gcry_sexp_t s_key)
729 {
730   char algoname[6];
731
732   if (!s_key)
733     return 0;
734
735   if (key_parms_from_sexp (s_key, NULL, algoname, sizeof algoname, NULL, 0))
736     return 0; /* Error - assume it is not an DSA key.  */
737
738   if (!strcmp (algoname, "dsa"))
739     return GCRY_PK_DSA;
740   else if (!strcmp (algoname, "ecdsa"))
741     return GCRY_PK_ECDSA;
742   else
743     return 0;
744 }
745
746
747
748 /* Return the public key for the keygrip GRIP.  The result is stored
749    at RESULT.  This function extracts the public key from the private
750    key database.  On failure an error code is returned and NULL stored
751    at RESULT. */
752 gpg_error_t
753 agent_public_key_from_file (ctrl_t ctrl, 
754                             const unsigned char *grip,
755                             gcry_sexp_t *result)
756 {
757   gpg_error_t err;
758   int i, idx;
759   gcry_sexp_t s_skey;
760   char algoname[6];
761   char elems[6];
762   gcry_sexp_t uri_sexp, comment_sexp;
763   const char *uri, *comment;
764   size_t uri_length, comment_length;
765   char *format, *p;
766   void *args[4+2+2+1]; /* Size is max. # of elements + 2 for uri + 2
767                            for comment + end-of-list.  */
768   int argidx;
769   gcry_sexp_t list, l2;
770   const char *s;
771   gcry_mpi_t *array;
772
773   (void)ctrl;
774
775   *result = NULL;
776
777   err = read_key_file (grip, &s_skey);
778   if (err)
779     return err;
780
781   err = key_parms_from_sexp (s_skey, &list, 
782                             algoname, sizeof algoname,
783                             elems, sizeof elems);
784   if (err)
785     {
786       gcry_sexp_release (s_skey);
787       return err;
788     }
789
790   /* Allocate an array for the parameters and copy them out of the
791      secret key.   FIXME: We should have a generic copy function. */
792   array = xtrycalloc (strlen(elems) + 1, sizeof *array);
793   if (!array)
794     {
795       err = gpg_error_from_syserror ();
796       gcry_sexp_release (list);
797       gcry_sexp_release (s_skey);
798       return err;
799     }
800
801   for (idx=0, s=elems; *s; s++, idx++ ) 
802     {
803       l2 = gcry_sexp_find_token (list, s, 1);
804       if (!l2)
805         {
806           /* Required parameter not found.  */
807           for (i=0; i<idx; i++)
808             gcry_mpi_release (array[i]);
809           xfree (array);
810           gcry_sexp_release (list);
811           gcry_sexp_release (s_skey);
812           return gpg_error (GPG_ERR_BAD_SECKEY);
813         }
814       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
815       gcry_sexp_release (l2);
816       if (!array[idx])
817         {
818           /* Required parameter is invalid. */
819           for (i=0; i<idx; i++)
820             gcry_mpi_release (array[i]);
821           xfree (array);
822           gcry_sexp_release (list);
823           gcry_sexp_release (s_skey);
824           return gpg_error (GPG_ERR_BAD_SECKEY);
825         }
826     }
827   gcry_sexp_release (list);
828   list = NULL;
829
830   uri = NULL;
831   uri_length = 0;
832   uri_sexp = gcry_sexp_find_token (s_skey, "uri", 0);
833   if (uri_sexp)
834     uri = gcry_sexp_nth_data (uri_sexp, 1, &uri_length);
835
836   comment = NULL;
837   comment_length = 0;
838   comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
839   if (comment_sexp)
840     comment = gcry_sexp_nth_data (comment_sexp, 1, &comment_length);
841
842   gcry_sexp_release (s_skey);
843   s_skey = NULL;
844
845
846   /* FIXME: The following thing is pretty ugly code; we should
847      investigate how to make it cleaner.  Probably code to handle
848      canonical S-expressions in a memory buffer is better suited for
849      such a task.  After all that is what we do in protect.c.  Neeed
850      to find common patterns and write a straightformward API to use
851      them.  */
852   assert (sizeof (size_t) <= sizeof (void*));
853
854   format = xtrymalloc (15+7*strlen (elems)+10+15+1+1);
855   if (!format)
856     {
857       err = gpg_error_from_syserror ();
858       for (i=0; array[i]; i++)
859         gcry_mpi_release (array[i]);
860       xfree (array);
861       gcry_sexp_release (uri_sexp);
862       gcry_sexp_release (comment_sexp);
863       return err;
864     }
865
866   argidx = 0;
867   p = stpcpy (stpcpy (format, "(public-key("), algoname);
868   for (idx=0, s=elems; *s; s++, idx++ ) 
869     {
870       *p++ = '(';
871       *p++ = *s;
872       p = stpcpy (p, " %m)");
873       assert (argidx < DIM (args));
874       args[argidx++] = &array[idx];
875     }
876   *p++ = ')';
877   if (uri)
878     {
879       p = stpcpy (p, "(uri %b)");
880       assert (argidx+1 < DIM (args));
881       args[argidx++] = (void *)uri_length;
882       args[argidx++] = (void *)uri;
883     }
884   if (comment)
885     {
886       p = stpcpy (p, "(comment %b)");
887       assert (argidx+1 < DIM (args));
888       args[argidx++] = (void *)comment_length;
889       args[argidx++] = (void*)comment;
890     }
891   *p++ = ')';
892   *p = 0;
893   assert (argidx < DIM (args));
894   args[argidx] = NULL;
895     
896   err = gcry_sexp_build_array (&list, NULL, format, args);
897   xfree (format);
898   for (i=0; array[i]; i++)
899     gcry_mpi_release (array[i]);
900   xfree (array);
901   gcry_sexp_release (uri_sexp);
902   gcry_sexp_release (comment_sexp);
903
904   if (!err)
905     *result = list;
906   return err;
907 }
908
909
910
911 /* Check whether the the secret key identified by GRIP is available.
912    Returns 0 is the key is available.  */
913 int
914 agent_key_available (const unsigned char *grip)
915 {
916   int result;
917   char *fname;
918   char hexgrip[40+4+1];
919   
920   bin2hex (grip, 20, hexgrip);
921   strcpy (hexgrip+40, ".key");
922
923   fname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, hexgrip, NULL);
924   result = !access (fname, R_OK)? 0 : -1;
925   xfree (fname);
926   return result;
927 }
928
929
930
931 /* Return the information about the secret key specified by the binary
932    keygrip GRIP.  If the key is a shadowed one the shadow information
933    will be stored at the address R_SHADOW_INFO as an allocated
934    S-expression.  */
935 gpg_error_t
936 agent_key_info_from_file (ctrl_t ctrl, const unsigned char *grip,
937                           int *r_keytype, unsigned char **r_shadow_info)
938 {
939   gpg_error_t err;
940   unsigned char *buf;
941   size_t len;
942   int keytype;
943
944   (void)ctrl;
945   
946   if (r_keytype)
947     *r_keytype = PRIVATE_KEY_UNKNOWN;
948   if (r_shadow_info)
949     *r_shadow_info = NULL;
950
951   {
952     gcry_sexp_t sexp;
953     
954     err = read_key_file (grip, &sexp);
955     if (err)
956       {
957         if (gpg_err_code (err) == GPG_ERR_ENOENT)
958           return gpg_error (GPG_ERR_NOT_FOUND);
959         else
960           return err;
961       }
962     err = make_canon_sexp (sexp, &buf, &len);
963     gcry_sexp_release (sexp);
964     if (err)
965       return err;
966   }
967   
968   keytype = agent_private_key_type (buf);
969   switch (keytype)
970     {
971     case PRIVATE_KEY_CLEAR:
972       break; 
973     case PRIVATE_KEY_PROTECTED:
974       /* If we ever require it we could retrieve the comment fields
975          from such a key. */
976       break;
977     case PRIVATE_KEY_SHADOWED:
978       if (r_shadow_info)
979         {
980           const unsigned char *s;
981           size_t n;
982
983           err = agent_get_shadow_info (buf, &s);
984           if (!err)
985             {
986               n = gcry_sexp_canon_len (s, 0, NULL, NULL);
987               assert (n);
988               *r_shadow_info = xtrymalloc (n);
989               if (!*r_shadow_info)
990                 err = gpg_error_from_syserror ();
991               else
992                 memcpy (*r_shadow_info, s, n);
993             }
994         }
995       break;
996     default:
997       err = gpg_error (GPG_ERR_BAD_SECKEY);
998       break;
999     }
1000
1001   if (!err && r_keytype)
1002     *r_keytype = keytype;
1003
1004   xfree (buf);
1005   return err;
1006 }