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