Import OpenPGP keys into the agent.
[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 the public key algorithm number if S_KEY is a DSA style key.
706    If it is not a DSA style key, return 0.  */
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   if (!strcmp (algoname, "dsa"))
719     return GCRY_PK_DSA;
720   else if (!strcmp (algoname, "ecdsa"))
721     return GCRY_PK_ECDSA;
722   else
723     return 0;
724 }
725
726
727
728 /* Return the public key for the keygrip GRIP.  The result is stored
729    at RESULT.  This function extracts the public key from the private
730    key database.  On failure an error code is returned and NULL stored
731    at RESULT. */
732 gpg_error_t
733 agent_public_key_from_file (ctrl_t ctrl, 
734                             const unsigned char *grip,
735                             gcry_sexp_t *result)
736 {
737   gpg_error_t err;
738   int i, idx;
739   gcry_sexp_t s_skey;
740   char algoname[6];
741   char elems[6];
742   gcry_sexp_t uri_sexp, comment_sexp;
743   const char *uri, *comment;
744   size_t uri_length, comment_length;
745   char *format, *p;
746   void *args[4+2+2+1]; /* Size is max. # of elements + 2 for uri + 2
747                            for comment + end-of-list.  */
748   int argidx;
749   gcry_sexp_t list, l2;
750   const char *s;
751   gcry_mpi_t *array;
752
753   (void)ctrl;
754
755   *result = NULL;
756
757   err = read_key_file (grip, &s_skey);
758   if (err)
759     return err;
760
761   err = key_parms_from_sexp (s_skey, &list, 
762                             algoname, sizeof algoname,
763                             elems, sizeof elems);
764   if (err)
765     {
766       gcry_sexp_release (s_skey);
767       return err;
768     }
769
770   /* Allocate an array for the parameters and copy them out of the
771      secret key.   FIXME: We should have a generic copy function. */
772   array = xtrycalloc (strlen(elems) + 1, sizeof *array);
773   if (!array)
774     {
775       err = gpg_error_from_syserror ();
776       gcry_sexp_release (list);
777       gcry_sexp_release (s_skey);
778       return err;
779     }
780
781   for (idx=0, s=elems; *s; s++, idx++ ) 
782     {
783       l2 = gcry_sexp_find_token (list, s, 1);
784       if (!l2)
785         {
786           /* Required parameter not found.  */
787           for (i=0; i<idx; i++)
788             gcry_mpi_release (array[i]);
789           xfree (array);
790           gcry_sexp_release (list);
791           gcry_sexp_release (s_skey);
792           return gpg_error (GPG_ERR_BAD_SECKEY);
793         }
794       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
795       gcry_sexp_release (l2);
796       if (!array[idx])
797         {
798           /* Required parameter is invalid. */
799           for (i=0; i<idx; i++)
800             gcry_mpi_release (array[i]);
801           xfree (array);
802           gcry_sexp_release (list);
803           gcry_sexp_release (s_skey);
804           return gpg_error (GPG_ERR_BAD_SECKEY);
805         }
806     }
807   gcry_sexp_release (list);
808   list = NULL;
809
810   uri = NULL;
811   uri_length = 0;
812   uri_sexp = gcry_sexp_find_token (s_skey, "uri", 0);
813   if (uri_sexp)
814     uri = gcry_sexp_nth_data (uri_sexp, 1, &uri_length);
815
816   comment = NULL;
817   comment_length = 0;
818   comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
819   if (comment_sexp)
820     comment = gcry_sexp_nth_data (comment_sexp, 1, &comment_length);
821
822   gcry_sexp_release (s_skey);
823   s_skey = NULL;
824
825
826   /* FIXME: The following thing is pretty ugly code; we should
827      investigate how to make it cleaner.  Probably code to handle
828      canonical S-expressions in a memory buffer is better suited for
829      such a task.  After all that is what we do in protect.c.  Neeed
830      to find common patterns and write a straightformward API to use
831      them.  */
832   assert (sizeof (size_t) <= sizeof (void*));
833
834   format = xtrymalloc (15+7*strlen (elems)+10+15+1+1);
835   if (!format)
836     {
837       err = gpg_error_from_syserror ();
838       for (i=0; array[i]; i++)
839         gcry_mpi_release (array[i]);
840       xfree (array);
841       gcry_sexp_release (uri_sexp);
842       gcry_sexp_release (comment_sexp);
843       return err;
844     }
845
846   argidx = 0;
847   p = stpcpy (stpcpy (format, "(public-key("), algoname);
848   for (idx=0, s=elems; *s; s++, idx++ ) 
849     {
850       *p++ = '(';
851       *p++ = *s;
852       p = stpcpy (p, " %m)");
853       assert (argidx < DIM (args));
854       args[argidx++] = &array[idx];
855     }
856   *p++ = ')';
857   if (uri)
858     {
859       p = stpcpy (p, "(uri %b)");
860       assert (argidx+1 < DIM (args));
861       args[argidx++] = (void *)uri_length;
862       args[argidx++] = (void *)uri;
863     }
864   if (comment)
865     {
866       p = stpcpy (p, "(comment %b)");
867       assert (argidx+1 < DIM (args));
868       args[argidx++] = (void *)comment_length;
869       args[argidx++] = (void*)comment;
870     }
871   *p++ = ')';
872   *p = 0;
873   assert (argidx < DIM (args));
874   args[argidx] = NULL;
875     
876   err = gcry_sexp_build_array (&list, NULL, format, args);
877   xfree (format);
878   for (i=0; array[i]; i++)
879     gcry_mpi_release (array[i]);
880   xfree (array);
881   gcry_sexp_release (uri_sexp);
882   gcry_sexp_release (comment_sexp);
883
884   if (!err)
885     *result = list;
886   return err;
887 }
888
889
890
891 /* Check whether the the secret key identified by GRIP is available.
892    Returns 0 is the key is available.  */
893 int
894 agent_key_available (const unsigned char *grip)
895 {
896   int result;
897   char *fname;
898   char hexgrip[40+4+1];
899   
900   bin2hex (grip, 20, hexgrip);
901   strcpy (hexgrip+40, ".key");
902
903   fname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, hexgrip, NULL);
904   result = !access (fname, R_OK)? 0 : -1;
905   xfree (fname);
906   return result;
907 }
908
909
910
911 /* Return the information about the secret key specified by the binary
912    keygrip GRIP.  If the key is a shadowed one the shadow information
913    will be stored at the address R_SHADOW_INFO as an allocated
914    S-expression.  */
915 gpg_error_t
916 agent_key_info_from_file (ctrl_t ctrl, const unsigned char *grip,
917                           int *r_keytype, unsigned char **r_shadow_info)
918 {
919   gpg_error_t err;
920   unsigned char *buf;
921   size_t len;
922   int keytype;
923
924   (void)ctrl;
925   
926   if (r_keytype)
927     *r_keytype = PRIVATE_KEY_UNKNOWN;
928   if (r_shadow_info)
929     *r_shadow_info = NULL;
930
931   {
932     gcry_sexp_t sexp;
933     
934     err = read_key_file (grip, &sexp);
935     if (err)
936       {
937         if (gpg_err_code (err) == GPG_ERR_ENOENT)
938           return gpg_error (GPG_ERR_NOT_FOUND);
939         else
940           return err;
941       }
942     err = make_canon_sexp (sexp, &buf, &len);
943     gcry_sexp_release (sexp);
944     if (err)
945       return err;
946   }
947   
948   keytype = agent_private_key_type (buf);
949   switch (keytype)
950     {
951     case PRIVATE_KEY_CLEAR:
952       break; 
953     case PRIVATE_KEY_PROTECTED:
954       /* If we ever require it we could retrieve the comment fields
955          from such a key. */
956       break;
957     case PRIVATE_KEY_SHADOWED:
958       if (r_shadow_info)
959         {
960           const unsigned char *s;
961           size_t n;
962
963           err = agent_get_shadow_info (buf, &s);
964           if (!err)
965             {
966               n = gcry_sexp_canon_len (s, 0, NULL, NULL);
967               assert (n);
968               *r_shadow_info = xtrymalloc (n);
969               if (!*r_shadow_info)
970                 err = gpg_error_from_syserror ();
971               else
972                 memcpy (*r_shadow_info, s, n);
973             }
974         }
975       break;
976     default:
977       err = gpg_error (GPG_ERR_BAD_SECKEY);
978       break;
979     }
980
981   if (!err && r_keytype)
982     *r_keytype = keytype;
983
984   xfree (buf);
985   return err;
986 }