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