ssh: Cleanup sshcontrol file access code.
[gnupg.git] / agent / command-ssh.c
1 /* command-ssh.c - gpg-agent's ssh-agent emulation layer
2  * Copyright (C) 2004, 2005, 2006, 2009, 2012 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /* Only v2 of the ssh-agent protocol is implemented.  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <dirent.h>
31 #include <assert.h>
32
33 #include "agent.h"
34
35 #include "i18n.h"
36 #include "../common/ssh-utils.h"
37
38
39 \f
40
41 /* Request types. */
42 #define SSH_REQUEST_REQUEST_IDENTITIES    11
43 #define SSH_REQUEST_SIGN_REQUEST          13
44 #define SSH_REQUEST_ADD_IDENTITY          17
45 #define SSH_REQUEST_REMOVE_IDENTITY       18
46 #define SSH_REQUEST_REMOVE_ALL_IDENTITIES 19
47 #define SSH_REQUEST_LOCK                  22
48 #define SSH_REQUEST_UNLOCK                23
49 #define SSH_REQUEST_ADD_ID_CONSTRAINED    25
50
51 /* Options. */
52 #define SSH_OPT_CONSTRAIN_LIFETIME         1
53 #define SSH_OPT_CONSTRAIN_CONFIRM          2
54
55 /* Response types. */
56 #define SSH_RESPONSE_SUCCESS               6
57 #define SSH_RESPONSE_FAILURE               5
58 #define SSH_RESPONSE_IDENTITIES_ANSWER    12
59 #define SSH_RESPONSE_SIGN_RESPONSE        14
60
61 /* Other constants.  */
62 #define SSH_DSA_SIGNATURE_PADDING 20
63 #define SSH_DSA_SIGNATURE_ELEMS    2
64 #define SPEC_FLAG_USE_PKCS1V2 (1 << 0)
65
66 /* The name of the control file.  */
67 #define SSH_CONTROL_FILE_NAME "sshcontrol"
68
69 /* The blurb we put into the header of a newly created control file.  */
70 static const char sshcontrolblurb[] =
71 "# List of allowed ssh keys.  Only keys present in this file are used\n"
72 "# in the SSH protocol.  The ssh-add tool may add new entries to this\n"
73 "# file to enable them; you may also add them manually.  Comment\n"
74 "# lines, like this one, as well as empty lines are ignored.  Lines do\n"
75 "# have a certain length limit but this is not serious limitation as\n"
76 "# the format of the entries is fixed and checked by gpg-agent. A\n"
77 "# non-comment line starts with optional white spaces, followed by the\n"
78 "# keygrip of the key given as 40 hex digits, optionally followed by a\n"
79 "# the caching TTL in seconds and another optional field for arbitrary\n"
80 "# flags.   Prepend the keygrip with an '!' mark to disable it.\n"
81 "\n";
82
83
84 /* Macros.  */
85
86 /* Return a new uint32 with b0 being the most significant byte and b3
87    being the least significant byte.  */
88 #define uint32_construct(b0, b1, b2, b3) \
89   ((b0 << 24) | (b1 << 16) | (b2 << 8) | b3)
90
91 \f
92
93
94 /*
95  * Basic types.
96  */
97
98 /* Type for a request handler.  */
99 typedef gpg_error_t (*ssh_request_handler_t) (ctrl_t ctrl,
100                                               estream_t request,
101                                               estream_t response);
102
103 /* Type, which is used for associating request handlers with the
104    appropriate request IDs.  */
105 typedef struct ssh_request_spec
106 {
107   unsigned char type;
108   ssh_request_handler_t handler;
109   const char *identifier;
110   unsigned int secret_input;
111 } ssh_request_spec_t;
112
113 /* Type for "key modifier functions", which are necessary since
114    OpenSSH and GnuPG treat key material slightly different.  A key
115    modifier is called right after a new key identity has been received
116    in order to "sanitize" the material.  */
117 typedef gpg_error_t (*ssh_key_modifier_t) (const char *elems,
118                                            gcry_mpi_t *mpis);
119
120 /* The encoding of a generated signature is dependent on the
121    algorithm; therefore algorithm specific signature encoding
122    functions are necessary.  */
123 typedef gpg_error_t (*ssh_signature_encoder_t) (estream_t signature_blob,
124                                                 gcry_mpi_t *mpis);
125
126 /* Type, which is used for boundling all the algorithm specific
127    information together in a single object.  */
128 typedef struct ssh_key_type_spec
129 {
130   /* Algorithm identifier as used by OpenSSH.  */
131   const char *ssh_identifier;
132
133   /* Algorithm identifier as used by GnuPG.  */
134   const char *identifier;
135
136   /* List of MPI names for secret keys; order matches the one of the
137      agent protocol.  */
138   const char *elems_key_secret;
139
140   /* List of MPI names for public keys; order matches the one of the
141      agent protocol.  */
142   const char *elems_key_public;
143
144   /* List of MPI names for signature data.  */
145   const char *elems_signature;
146
147   /* List of MPI names for secret keys; order matches the one, which
148      is required by gpg-agent's key access layer.  */
149   const char *elems_sexp_order;
150
151   /* Key modifier function.  Key modifier functions are necessary in
152      order to fix any inconsistencies between the representation of
153      keys on the SSH and on the GnuPG side.  */
154   ssh_key_modifier_t key_modifier;
155
156   /* Signature encoder function.  Signature encoder functions are
157      necessary since the encoding of signatures depends on the used
158      algorithm.  */
159   ssh_signature_encoder_t signature_encoder;
160
161   /* Misc flags.  */
162   unsigned int flags;
163 } ssh_key_type_spec_t;
164
165
166 /* An object used to access the sshcontrol file.  */
167 struct control_file_s
168 {
169   char *fname;  /* Name of the file.  */
170   FILE *fp;     /* This is never NULL. */
171 };
172 typedef struct control_file_s *control_file_t;
173
174
175
176 /* Prototypes.  */
177 static gpg_error_t ssh_handler_request_identities (ctrl_t ctrl,
178                                                    estream_t request,
179                                                    estream_t response);
180 static gpg_error_t ssh_handler_sign_request (ctrl_t ctrl,
181                                              estream_t request,
182                                              estream_t response);
183 static gpg_error_t ssh_handler_add_identity (ctrl_t ctrl,
184                                              estream_t request,
185                                              estream_t response);
186 static gpg_error_t ssh_handler_remove_identity (ctrl_t ctrl,
187                                                 estream_t request,
188                                                 estream_t response);
189 static gpg_error_t ssh_handler_remove_all_identities (ctrl_t ctrl,
190                                                       estream_t request,
191                                                       estream_t response);
192 static gpg_error_t ssh_handler_lock (ctrl_t ctrl,
193                                      estream_t request,
194                                      estream_t response);
195 static gpg_error_t ssh_handler_unlock (ctrl_t ctrl,
196                                        estream_t request,
197                                        estream_t response);
198
199 static gpg_error_t ssh_key_modifier_rsa (const char *elems, gcry_mpi_t *mpis);
200 static gpg_error_t ssh_signature_encoder_rsa (estream_t signature_blob,
201                                               gcry_mpi_t *mpis);
202 static gpg_error_t ssh_signature_encoder_dsa (estream_t signature_blob,
203                                               gcry_mpi_t *mpis);
204
205
206
207 /* Global variables.  */
208
209
210 /* Associating request types with the corresponding request
211    handlers.  */
212
213 static ssh_request_spec_t request_specs[] =
214   {
215 #define REQUEST_SPEC_DEFINE(id, name, secret_input) \
216   { SSH_REQUEST_##id, ssh_handler_##name, #name, secret_input }
217
218     REQUEST_SPEC_DEFINE (REQUEST_IDENTITIES,    request_identities,    1),
219     REQUEST_SPEC_DEFINE (SIGN_REQUEST,          sign_request,          0),
220     REQUEST_SPEC_DEFINE (ADD_IDENTITY,          add_identity,          1),
221     REQUEST_SPEC_DEFINE (ADD_ID_CONSTRAINED,    add_identity,          1),
222     REQUEST_SPEC_DEFINE (REMOVE_IDENTITY,       remove_identity,       0),
223     REQUEST_SPEC_DEFINE (REMOVE_ALL_IDENTITIES, remove_all_identities, 0),
224     REQUEST_SPEC_DEFINE (LOCK,                  lock,                  0),
225     REQUEST_SPEC_DEFINE (UNLOCK,                unlock,                0)
226 #undef REQUEST_SPEC_DEFINE
227   };
228
229
230 /* Table holding key type specifications.  */
231 static ssh_key_type_spec_t ssh_key_types[] =
232   {
233     {
234       "ssh-rsa", "rsa", "nedupq", "en",   "s",  "nedpqu",
235       ssh_key_modifier_rsa, ssh_signature_encoder_rsa,
236       SPEC_FLAG_USE_PKCS1V2
237     },
238     {
239       "ssh-dss", "dsa", "pqgyx",  "pqgy", "rs", "pqgyx",
240       NULL,                 ssh_signature_encoder_dsa,
241       0
242     },
243   };
244
245 \f
246
247
248
249 /*
250    General utility functions.
251  */
252
253 /* A secure realloc, i.e. it makes sure to allocate secure memory if A
254    is NULL.  This is required because the standard gcry_realloc does
255    not know whether to allocate secure or normal if NULL is passed as
256    existing buffer.  */
257 static void *
258 realloc_secure (void *a, size_t n)
259 {
260   void *p;
261
262   if (a)
263     p = gcry_realloc (a, n);
264   else
265     p = gcry_malloc_secure (n);
266
267   return p;
268 }
269
270
271 /* Create and return a new C-string from DATA/DATA_N (i.e.: add
272    NUL-termination); return NULL on OOM.  */
273 static char *
274 make_cstring (const char *data, size_t data_n)
275 {
276   char *s;
277
278   s = xtrymalloc (data_n + 1);
279   if (s)
280     {
281       memcpy (s, data, data_n);
282       s[data_n] = 0;
283     }
284
285   return s;
286 }
287
288
289
290
291 /*
292    Primitive I/O functions.
293  */
294
295
296 /* Read a byte from STREAM, store it in B.  */
297 static gpg_error_t
298 stream_read_byte (estream_t stream, unsigned char *b)
299 {
300   gpg_error_t err;
301   int ret;
302
303   ret = es_fgetc (stream);
304   if (ret == EOF)
305     {
306       if (es_ferror (stream))
307         err = gpg_error_from_syserror ();
308       else
309         err = gpg_error (GPG_ERR_EOF);
310       *b = 0;
311     }
312   else
313     {
314       *b = ret & 0xFF;
315       err = 0;
316     }
317
318   return err;
319 }
320
321 /* Write the byte contained in B to STREAM.  */
322 static gpg_error_t
323 stream_write_byte (estream_t stream, unsigned char b)
324 {
325   gpg_error_t err;
326   int ret;
327
328   ret = es_fputc (b, stream);
329   if (ret == EOF)
330     err = gpg_error_from_syserror ();
331   else
332     err = 0;
333
334   return err;
335 }
336
337 /* Read a uint32 from STREAM, store it in UINT32.  */
338 static gpg_error_t
339 stream_read_uint32 (estream_t stream, u32 *uint32)
340 {
341   unsigned char buffer[4];
342   size_t bytes_read;
343   gpg_error_t err;
344   int ret;
345
346   ret = es_read (stream, buffer, sizeof (buffer), &bytes_read);
347   if (ret)
348     err = gpg_error_from_syserror ();
349   else
350     {
351       if (bytes_read != sizeof (buffer))
352         err = gpg_error (GPG_ERR_EOF);
353       else
354         {
355           u32 n;
356
357           n = uint32_construct (buffer[0], buffer[1], buffer[2], buffer[3]);
358           *uint32 = n;
359           err = 0;
360         }
361     }
362
363   return err;
364 }
365
366 /* Write the uint32 contained in UINT32 to STREAM.  */
367 static gpg_error_t
368 stream_write_uint32 (estream_t stream, u32 uint32)
369 {
370   unsigned char buffer[4];
371   gpg_error_t err;
372   int ret;
373
374   buffer[0] = uint32 >> 24;
375   buffer[1] = uint32 >> 16;
376   buffer[2] = uint32 >>  8;
377   buffer[3] = uint32 >>  0;
378
379   ret = es_write (stream, buffer, sizeof (buffer), NULL);
380   if (ret)
381     err = gpg_error_from_syserror ();
382   else
383     err = 0;
384
385   return err;
386 }
387
388 /* Read SIZE bytes from STREAM into BUFFER.  */
389 static gpg_error_t
390 stream_read_data (estream_t stream, unsigned char *buffer, size_t size)
391 {
392   gpg_error_t err;
393   size_t bytes_read;
394   int ret;
395
396   ret = es_read (stream, buffer, size, &bytes_read);
397   if (ret)
398     err = gpg_error_from_syserror ();
399   else
400     {
401       if (bytes_read != size)
402         err = gpg_error (GPG_ERR_EOF);
403       else
404         err = 0;
405     }
406
407   return err;
408 }
409
410 /* Write SIZE bytes from BUFFER to STREAM.  */
411 static gpg_error_t
412 stream_write_data (estream_t stream, const unsigned char *buffer, size_t size)
413 {
414   gpg_error_t err;
415   int ret;
416
417   ret = es_write (stream, buffer, size, NULL);
418   if (ret)
419     err = gpg_error_from_syserror ();
420   else
421     err = 0;
422
423   return err;
424 }
425
426 /* Read a binary string from STREAM into STRING, store size of string
427    in STRING_SIZE; depending on SECURE use secure memory for
428    string.  */
429 static gpg_error_t
430 stream_read_string (estream_t stream, unsigned int secure,
431                     unsigned char **string, u32 *string_size)
432 {
433   gpg_error_t err;
434   unsigned char *buffer = NULL;
435   u32 length = 0;
436
437   /* Read string length.  */
438   err = stream_read_uint32 (stream, &length);
439   if (err)
440     goto out;
441
442   /* Allocate space.  */
443   if (secure)
444     buffer = xtrymalloc_secure (length + 1);
445   else
446     buffer = xtrymalloc (length + 1);
447   if (! buffer)
448     {
449       err = gpg_error_from_syserror ();
450       goto out;
451     }
452
453   /* Read data.  */
454   err = stream_read_data (stream, buffer, length);
455   if (err)
456     goto out;
457
458   /* Finalize string object.  */
459   buffer[length] = 0;
460   *string = buffer;
461   if (string_size)
462     *string_size = length;
463
464  out:
465
466   if (err)
467     xfree (buffer);
468
469   return err;
470 }
471
472 /* Read a C-string from STREAM, store copy in STRING.  */
473 static gpg_error_t
474 stream_read_cstring (estream_t stream, char **string)
475 {
476   unsigned char *buffer;
477   gpg_error_t err;
478
479   err = stream_read_string (stream, 0, &buffer, NULL);
480   if (err)
481     goto out;
482
483   *string = (char *) buffer;
484
485  out:
486
487   return err;
488 }
489
490
491 /* Write a binary string from STRING of size STRING_N to STREAM.  */
492 static gpg_error_t
493 stream_write_string (estream_t stream,
494                      const unsigned char *string, u32 string_n)
495 {
496   gpg_error_t err;
497
498   err = stream_write_uint32 (stream, string_n);
499   if (err)
500     goto out;
501
502   err = stream_write_data (stream, string, string_n);
503
504  out:
505
506   return err;
507 }
508
509 /* Write a C-string from STRING to STREAM.  */
510 static gpg_error_t
511 stream_write_cstring (estream_t stream, const char *string)
512 {
513   gpg_error_t err;
514
515   err = stream_write_string (stream,
516                              (const unsigned char *) string, strlen (string));
517
518   return err;
519 }
520
521 /* Read an MPI from STREAM, store it in MPINT.  Depending on SECURE
522    use secure memory.  */
523 static gpg_error_t
524 stream_read_mpi (estream_t stream, unsigned int secure, gcry_mpi_t *mpint)
525 {
526   unsigned char *mpi_data;
527   u32 mpi_data_size;
528   gpg_error_t err;
529   gcry_mpi_t mpi;
530
531   mpi_data = NULL;
532
533   err = stream_read_string (stream, secure, &mpi_data, &mpi_data_size);
534   if (err)
535     goto out;
536
537   /* To avoid excessive use of secure memory we check that an MPI is
538      not too large. */
539   if (mpi_data_size > 520)
540     {
541       log_error (_("ssh keys greater than %d bits are not supported\n"), 4096);
542       err = GPG_ERR_TOO_LARGE;
543       goto out;
544     }
545
546   err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_STD, mpi_data, mpi_data_size, NULL);
547   if (err)
548     goto out;
549
550   *mpint = mpi;
551
552  out:
553
554   xfree (mpi_data);
555
556   return err;
557 }
558
559 /* Write the MPI contained in MPINT to STREAM.  */
560 static gpg_error_t
561 stream_write_mpi (estream_t stream, gcry_mpi_t mpint)
562 {
563   unsigned char *mpi_buffer;
564   size_t mpi_buffer_n;
565   gpg_error_t err;
566
567   mpi_buffer = NULL;
568
569   err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &mpi_buffer, &mpi_buffer_n, mpint);
570   if (err)
571     goto out;
572
573   err = stream_write_string (stream, mpi_buffer, mpi_buffer_n);
574
575  out:
576
577   xfree (mpi_buffer);
578
579   return err;
580 }
581
582 /* Copy data from SRC to DST until EOF is reached.  */
583 static gpg_error_t
584 stream_copy (estream_t dst, estream_t src)
585 {
586   char buffer[BUFSIZ];
587   size_t bytes_read;
588   gpg_error_t err;
589   int ret;
590
591   err = 0;
592   while (1)
593     {
594       ret = es_read (src, buffer, sizeof (buffer), &bytes_read);
595       if (ret || (! bytes_read))
596         {
597           if (ret)
598             err = gpg_error_from_syserror ();
599           break;
600         }
601       ret = es_write (dst, buffer, bytes_read, NULL);
602       if (ret)
603         {
604           err = gpg_error_from_syserror ();
605           break;
606         }
607     }
608
609   return err;
610 }
611
612
613 /* Read the content of the file specified by FILENAME into a newly
614    create buffer, which is to be stored in BUFFER; store length of
615    buffer in BUFFER_N.  */
616 static gpg_error_t
617 file_to_buffer (const char *filename, unsigned char **buffer, size_t *buffer_n)
618 {
619   unsigned char *buffer_new;
620   struct stat statbuf;
621   estream_t stream;
622   gpg_error_t err;
623   int ret;
624
625   *buffer = NULL;
626   *buffer_n = 0;
627
628   buffer_new = NULL;
629   err = 0;
630
631   stream = es_fopen (filename, "r");
632   if (! stream)
633     {
634       err = gpg_error_from_syserror ();
635       goto out;
636     }
637
638   ret = fstat (es_fileno (stream), &statbuf);
639   if (ret)
640     {
641       err = gpg_error_from_syserror ();
642       goto out;
643     }
644
645   buffer_new = xtrymalloc (statbuf.st_size);
646   if (! buffer_new)
647     {
648       err = gpg_error_from_syserror ();
649       goto out;
650     }
651
652   err = stream_read_data (stream, buffer_new, statbuf.st_size);
653   if (err)
654     goto out;
655
656   *buffer = buffer_new;
657   *buffer_n = statbuf.st_size;
658
659  out:
660
661   if (stream)
662     es_fclose (stream);
663
664   if (err)
665     xfree (buffer_new);
666
667   return err;
668 }
669
670
671
672 \f
673 /* Open the ssh control file and create it if not available.  With
674    APPEND passed as true the file will be opened in append mode,
675    otherwise in read only mode.  On success 0 is returned and a new
676    control file object stored at R_CF.  On error an error code is
677    returned and NULL is stored at R_CF.  */
678 static gpg_error_t
679 open_control_file (control_file_t *r_cf, int append)
680 {
681   gpg_error_t err;
682   control_file_t cf;
683
684   cf = xtrycalloc (1, sizeof *cf);
685   if (!cf)
686     {
687       err = gpg_error_from_syserror ();
688       goto leave;
689     }
690
691   /* Note: As soon as we start to use non blocking functions here
692      (i.e. where Pth might switch threads) we need to employ a
693      mutex.  */
694   cf->fname = make_filename_try (opt.homedir, SSH_CONTROL_FILE_NAME, NULL);
695   if (!cf->fname)
696     {
697       err = gpg_error_from_syserror ();
698       goto leave;
699     }
700   /* FIXME: With "a+" we are not able to check whether this will will
701      be created and thus the blurb needs to be written first.  */
702   cf->fp = fopen (cf->fname, append? "a+":"r");
703   if (!cf->fp && errno == ENOENT)
704     {
705       estream_t stream = es_fopen (cf->fname, "wx,mode=-rw-r");
706       if (!stream)
707         {
708           err = gpg_error_from_syserror ();
709           log_error (_("can't create `%s': %s\n"),
710                      cf->fname, gpg_strerror (err));
711           goto leave;
712         }
713       es_fputs (sshcontrolblurb, stream);
714       es_fclose (stream);
715       cf->fp = fopen (cf->fname, append? "a+":"r");
716     }
717
718   if (!cf->fp)
719     {
720       err = gpg_error_from_syserror ();
721       log_error (_("can't open `%s': %s\n"),
722                  cf->fname, gpg_strerror (err));
723       goto leave;
724     }
725
726   err = 0;
727
728  leave:
729   if (err && cf)
730     {
731       if (cf->fp)
732         fclose (cf->fp);
733       xfree (cf->fname);
734       xfree (cf);
735     }
736   else
737     *r_cf = cf;
738
739   return err;
740 }
741
742
743 static void
744 close_control_file (control_file_t cf)
745 {
746   if (!cf)
747     return;
748   fclose (cf->fp);
749   xfree (cf->fname);
750   xfree (cf);
751 }
752
753
754 /* Search the control file CF from the beginning until a matching
755    HEXGRIP is found; return success in this case and store true at
756    DISABLED if the found key has been disabled.  If R_TTL is not NULL
757    a specified TTL for that key is stored there.  If R_CONFIRM is not
758    NULL it is set to 1 if the key has the confirm flag set. */
759 static gpg_error_t
760 search_control_file (control_file_t cf, const char *hexgrip,
761                      int *r_disabled, int *r_ttl, int *r_confirm)
762 {
763   int c, i, n;
764   char *p, *pend, line[256];
765   long ttl;
766   int lnr = 0;
767
768   assert (strlen (hexgrip) == 40 );
769
770   if (r_confirm)
771     *r_confirm = 0;
772
773   fseek (cf->fp, 0, SEEK_SET);
774   clearerr (cf->fp);
775   *r_disabled = 0;
776  next_line:
777   do
778     {
779       if (!fgets (line, DIM(line)-1, cf->fp) )
780         {
781           if (feof (cf->fp))
782             return gpg_error (GPG_ERR_EOF);
783           return gpg_error_from_syserror ();
784         }
785       lnr++;
786
787       if (!*line || line[strlen(line)-1] != '\n')
788         {
789           /* Eat until end of line */
790           while ( (c=getc (cf->fp)) != EOF && c != '\n')
791             ;
792           return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
793                                  : GPG_ERR_INCOMPLETE_LINE);
794         }
795
796       /* Allow for empty lines and spaces */
797       for (p=line; spacep (p); p++)
798         ;
799     }
800   while (!*p || *p == '\n' || *p == '#');
801
802   *r_disabled = 0;
803   if (*p == '!')
804     {
805       *r_disabled = 1;
806       for (p++; spacep (p); p++)
807         ;
808     }
809
810   for (i=0; hexdigitp (p) && i < 40; p++, i++)
811     if (hexgrip[i] != (*p >= 'a'? (*p & 0xdf): *p))
812       goto next_line;
813   if (i != 40 || !(spacep (p) || *p == '\n'))
814     {
815       log_error ("invalid formatted line in `%s', line %d\n", cf->fname, lnr);
816       return gpg_error (GPG_ERR_BAD_DATA);
817     }
818
819   ttl = strtol (p, &pend, 10);
820   p = pend;
821   if (!(spacep (p) || *p == '\n') || ttl < -1)
822     {
823       log_error ("invalid TTL value in `%s', line %d; assuming 0\n",
824                  cf->fname, lnr);
825       ttl = 0;
826     }
827   if (r_ttl)
828     *r_ttl = ttl;
829
830   /* Now check for key-value pairs of the form NAME[=VALUE]. */
831   while (*p)
832     {
833       for (; spacep (p) && *p != '\n'; p++)
834         ;
835       if (!*p || *p == '\n')
836         break;
837       n = strcspn (p, "= \t\n");
838       if (p[n] == '=')
839         {
840           log_error ("assigning a value to a flag is not yet supported; "
841                      "in `%s', line %d; flag ignored\n", cf->fname, lnr);
842           p++;
843         }
844       else if (n == 7 && !memcmp (p, "confirm", 7))
845         {
846           if (r_confirm)
847             *r_confirm = 1;
848         }
849       else
850         log_error ("invalid flag `%.*s' in `%s', line %d; ignored\n",
851                    n, p, cf->fname, lnr);
852       p += n;
853     }
854
855   return 0; /* Okay:  found it.  */
856 }
857
858
859
860 /* Add an entry to the control file to mark the key with the keygrip
861    HEXGRIP as usable for SSH; i.e. it will be returned when ssh asks
862    for it.  FMTFPR is the fingerprint string.  This function is in
863    general used to add a key received through the ssh-add function.
864    We can assume that the user wants to allow ssh using this key. */
865 static gpg_error_t
866 add_control_entry (ctrl_t ctrl, const char *hexgrip, const char *fmtfpr,
867                    int ttl, int confirm)
868 {
869   gpg_error_t err;
870   control_file_t cf;
871   int disabled;
872
873   (void)ctrl;
874
875   err = open_control_file (&cf, 1);
876   if (err)
877     return err;
878
879   err = search_control_file (cf, hexgrip, &disabled, NULL, NULL);
880   if (err && gpg_err_code(err) == GPG_ERR_EOF)
881     {
882       struct tm *tp;
883       time_t atime = time (NULL);
884
885       /* Not yet in the file - add it. Because the file has been
886          opened in append mode, we simply need to write to it.  */
887       tp = localtime (&atime);
888       fprintf (cf->fp,
889                ("# Key added on: %04d-%02d-%02d %02d:%02d:%02d\n"
890                 "# Fingerprint:  %s\n"
891                 "%s %d%s\n"),
892                1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
893                tp->tm_hour, tp->tm_min, tp->tm_sec,
894                fmtfpr, hexgrip, ttl, confirm? " confirm":"");
895
896     }
897   close_control_file (cf);
898   return 0;
899 }
900
901
902 /* Scan the sshcontrol file and return the TTL.  */
903 static int
904 ttl_from_sshcontrol (const char *hexgrip)
905 {
906   control_file_t cf;
907   int disabled, ttl;
908
909   if (!hexgrip || strlen (hexgrip) != 40)
910     return 0;  /* Wrong input: Use global default.  */
911
912   if (open_control_file (&cf, 0))
913     return 0; /* Error: Use the global default TTL.  */
914
915   if (search_control_file (cf, hexgrip, &disabled, &ttl, NULL)
916       || disabled)
917     ttl = 0;  /* Use the global default if not found or disabled.  */
918
919   close_control_file (cf);
920
921   return ttl;
922 }
923
924
925 /* Scan the sshcontrol file and return the confirm flag.  */
926 static int
927 confirm_flag_from_sshcontrol (const char *hexgrip)
928 {
929   control_file_t cf;
930   int disabled, confirm;
931
932   if (!hexgrip || strlen (hexgrip) != 40)
933     return 1;  /* Wrong input: Better ask for confirmation.  */
934
935   if (open_control_file (&cf, 0))
936     return 1; /* Error: Better ask for confirmation.  */
937
938   if (search_control_file (cf, hexgrip, &disabled, NULL, &confirm)
939       || disabled)
940     confirm = 0;  /* If not found or disabled, there is no reason to
941                      ask for confirmation.  */
942
943   close_control_file (cf);
944
945   return confirm;
946 }
947
948
949
950 \f
951
952 /*
953
954   MPI lists.
955
956  */
957
958 /* Free the list of MPIs MPI_LIST.  */
959 static void
960 mpint_list_free (gcry_mpi_t *mpi_list)
961 {
962   if (mpi_list)
963     {
964       unsigned int i;
965
966       for (i = 0; mpi_list[i]; i++)
967         gcry_mpi_release (mpi_list[i]);
968       xfree (mpi_list);
969     }
970 }
971
972 /* Receive key material MPIs from STREAM according to KEY_SPEC;
973    depending on SECRET expect a public key or secret key.  The newly
974    allocated list of MPIs is stored in MPI_LIST.  Returns usual error
975    code.  */
976 static gpg_error_t
977 ssh_receive_mpint_list (estream_t stream, int secret,
978                         ssh_key_type_spec_t key_spec, gcry_mpi_t **mpi_list)
979 {
980   const char *elems_public;
981   unsigned int elems_n;
982   const char *elems;
983   int elem_is_secret;
984   gcry_mpi_t *mpis;
985   gpg_error_t err;
986   unsigned int i;
987
988   mpis = NULL;
989   err = 0;
990
991   if (secret)
992     elems = key_spec.elems_key_secret;
993   else
994     elems = key_spec.elems_key_public;
995   elems_n = strlen (elems);
996
997   elems_public = key_spec.elems_key_public;
998
999   mpis = xtrycalloc (elems_n + 1, sizeof *mpis );
1000   if (!mpis)
1001     {
1002       err = gpg_error_from_syserror ();
1003       goto out;
1004     }
1005
1006   elem_is_secret = 0;
1007   for (i = 0; i < elems_n; i++)
1008     {
1009       if (secret)
1010         elem_is_secret = ! strchr (elems_public, elems[i]);
1011       err = stream_read_mpi (stream, elem_is_secret, &mpis[i]);
1012       if (err)
1013         break;
1014     }
1015   if (err)
1016     goto out;
1017
1018   *mpi_list = mpis;
1019
1020  out:
1021
1022   if (err)
1023     mpint_list_free (mpis);
1024
1025   return err;
1026 }
1027
1028 \f
1029
1030 /* Key modifier function for RSA.  */
1031 static gpg_error_t
1032 ssh_key_modifier_rsa (const char *elems, gcry_mpi_t *mpis)
1033 {
1034   gcry_mpi_t p;
1035   gcry_mpi_t q;
1036   gcry_mpi_t u;
1037
1038   if (strcmp (elems, "nedupq"))
1039     /* Modifying only necessary for secret keys.  */
1040     goto out;
1041
1042   u = mpis[3];
1043   p = mpis[4];
1044   q = mpis[5];
1045
1046   if (gcry_mpi_cmp (p, q) > 0)
1047     {
1048       /* P shall be smaller then Q!  Swap primes.  iqmp becomes u.  */
1049       gcry_mpi_t tmp;
1050
1051       tmp = mpis[4];
1052       mpis[4] = mpis[5];
1053       mpis[5] = tmp;
1054     }
1055   else
1056     /* U needs to be recomputed.  */
1057     gcry_mpi_invm (u, p, q);
1058
1059  out:
1060
1061   return 0;
1062 }
1063
1064 /* Signature encoder function for RSA.  */
1065 static gpg_error_t
1066 ssh_signature_encoder_rsa (estream_t signature_blob, gcry_mpi_t *mpis)
1067 {
1068   unsigned char *data;
1069   size_t data_n;
1070   gpg_error_t err;
1071   gcry_mpi_t s;
1072
1073   s = mpis[0];
1074
1075   err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &data, &data_n, s);
1076   if (err)
1077     goto out;
1078
1079   err = stream_write_string (signature_blob, data, data_n);
1080   xfree (data);
1081
1082  out:
1083
1084   return err;
1085 }
1086
1087
1088 /* Signature encoder function for DSA.  */
1089 static gpg_error_t
1090 ssh_signature_encoder_dsa (estream_t signature_blob, gcry_mpi_t *mpis)
1091 {
1092   unsigned char buffer[SSH_DSA_SIGNATURE_PADDING * SSH_DSA_SIGNATURE_ELEMS];
1093   unsigned char *data;
1094   size_t data_n;
1095   gpg_error_t err;
1096   int i;
1097
1098   data = NULL;
1099
1100   for (i = 0; i < 2; i++)
1101     {
1102       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &data, &data_n, mpis[i]);
1103       if (err)
1104         break;
1105
1106       if (data_n > SSH_DSA_SIGNATURE_PADDING)
1107         {
1108           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
1109           break;
1110         }
1111
1112       memset (buffer + (i * SSH_DSA_SIGNATURE_PADDING), 0,
1113               SSH_DSA_SIGNATURE_PADDING - data_n);
1114       memcpy (buffer + (i * SSH_DSA_SIGNATURE_PADDING)
1115               + (SSH_DSA_SIGNATURE_PADDING - data_n), data, data_n);
1116
1117       xfree (data);
1118       data = NULL;
1119     }
1120   if (err)
1121     goto out;
1122
1123   err = stream_write_string (signature_blob, buffer, sizeof (buffer));
1124
1125  out:
1126
1127   xfree (data);
1128
1129   return err;
1130 }
1131
1132 /*
1133    S-Expressions.
1134  */
1135
1136
1137 /* This function constructs a new S-Expression for the key identified
1138    by the KEY_SPEC, SECRET, MPIS and COMMENT, which is to be stored in
1139    *SEXP.  Returns usual error code.  */
1140 static gpg_error_t
1141 sexp_key_construct (gcry_sexp_t *sexp,
1142                     ssh_key_type_spec_t key_spec, int secret,
1143                     gcry_mpi_t *mpis, const char *comment)
1144 {
1145   const char *key_identifier[] = { "public-key", "private-key" };
1146   gcry_sexp_t sexp_new;
1147   char *sexp_template;
1148   size_t sexp_template_n;
1149   gpg_error_t err;
1150   const char *elems;
1151   size_t elems_n;
1152   unsigned int i;
1153   unsigned int j;
1154   void **arg_list;
1155
1156   err = 0;
1157   sexp_new = NULL;
1158   arg_list = NULL;
1159   if (secret)
1160     elems = key_spec.elems_sexp_order;
1161   else
1162     elems = key_spec.elems_key_public;
1163   elems_n = strlen (elems);
1164
1165   /*
1166     Calculate size for sexp_template_n:
1167
1168     "(%s(%s<mpis>)(comment%s))" -> 20 + sizeof (<mpis>).
1169
1170     mpi: (X%m) -> 5.
1171
1172   */
1173   sexp_template_n = 20 + (elems_n * 5);
1174   sexp_template = xtrymalloc (sexp_template_n);
1175   if (! sexp_template)
1176     {
1177       err = gpg_error_from_syserror ();
1178       goto out;
1179     }
1180
1181   /* Key identifier, algorithm identifier, mpis, comment.  */
1182   arg_list = xtrymalloc (sizeof (*arg_list) * (2 + elems_n + 1));
1183   if (! arg_list)
1184     {
1185       err = gpg_error_from_syserror ();
1186       goto out;
1187     }
1188
1189   i = 0;
1190   arg_list[i++] = &key_identifier[secret];
1191   arg_list[i++] = &key_spec.identifier;
1192
1193   *sexp_template = 0;
1194   sexp_template_n = 0;
1195   sexp_template_n = sprintf (sexp_template + sexp_template_n, "(%%s(%%s");
1196   for (i = 0; i < elems_n; i++)
1197     {
1198       sexp_template_n += sprintf (sexp_template + sexp_template_n, "(%c%%m)",
1199                                   elems[i]);
1200       if (secret)
1201         {
1202           for (j = 0; j < elems_n; j++)
1203             if (key_spec.elems_key_secret[j] == elems[i])
1204               break;
1205         }
1206       else
1207         j = i;
1208       arg_list[i + 2] = &mpis[j];
1209     }
1210   sexp_template_n += sprintf (sexp_template + sexp_template_n,
1211                               ")(comment%%s))");
1212
1213   arg_list[i + 2] = &comment;
1214
1215   err = gcry_sexp_build_array (&sexp_new, NULL, sexp_template, arg_list);
1216   if (err)
1217     goto out;
1218
1219   *sexp = sexp_new;
1220
1221  out:
1222
1223   xfree (arg_list);
1224   xfree (sexp_template);
1225
1226   return err;
1227 }
1228
1229 /* This functions breaks up the key contained in the S-Expression SEXP
1230    according to KEY_SPEC.  The MPIs are bundled in a newly create
1231    list, which is to be stored in MPIS; a newly allocated string
1232    holding the comment will be stored in COMMENT; SECRET will be
1233    filled with a boolean flag specifying what kind of key it is.
1234    Returns usual error code.  */
1235 static gpg_error_t
1236 sexp_key_extract (gcry_sexp_t sexp,
1237                   ssh_key_type_spec_t key_spec, int *secret,
1238                   gcry_mpi_t **mpis, char **comment)
1239 {
1240   gpg_error_t err;
1241   gcry_sexp_t value_list;
1242   gcry_sexp_t value_pair;
1243   gcry_sexp_t comment_list;
1244   unsigned int i;
1245   char *comment_new;
1246   const char *data;
1247   size_t data_n;
1248   int is_secret;
1249   size_t elems_n;
1250   const char *elems;
1251   gcry_mpi_t *mpis_new;
1252   gcry_mpi_t mpi;
1253
1254   err = 0;
1255   value_list = NULL;
1256   value_pair = NULL;
1257   comment_list = NULL;
1258   comment_new = NULL;
1259   mpis_new = NULL;
1260
1261   data = gcry_sexp_nth_data (sexp, 0, &data_n);
1262   if (! data)
1263     {
1264       err = gpg_error (GPG_ERR_INV_SEXP);
1265       goto out;
1266     }
1267
1268   if ((data_n == 10 && !strncmp (data, "public-key", 10))
1269       || (data_n == 21 && !strncmp (data, "protected-private-key", 21))
1270       || (data_n == 20 && !strncmp (data, "shadowed-private-key", 20)))
1271     {
1272       is_secret = 0;
1273       elems = key_spec.elems_key_public;
1274     }
1275   else if (data_n == 11 && !strncmp (data, "private-key", 11))
1276     {
1277       is_secret = 1;
1278       elems = key_spec.elems_key_secret;
1279     }
1280   else
1281     {
1282       err = gpg_error (GPG_ERR_INV_SEXP);
1283       goto out;
1284     }
1285
1286   elems_n = strlen (elems);
1287   mpis_new = xtrycalloc (elems_n + 1, sizeof *mpis_new );
1288   if (!mpis_new)
1289     {
1290       err = gpg_error_from_syserror ();
1291       goto out;
1292     }
1293
1294   value_list = gcry_sexp_find_token (sexp, key_spec.identifier, 0);
1295   if (! value_list)
1296     {
1297       err = gpg_error (GPG_ERR_INV_SEXP);
1298       goto out;
1299     }
1300
1301   for (i = 0; i < elems_n; i++)
1302     {
1303       value_pair = gcry_sexp_find_token (value_list, elems + i, 1);
1304       if (! value_pair)
1305         {
1306           err = gpg_error (GPG_ERR_INV_SEXP);
1307           break;
1308         }
1309
1310       /* Note that we need to use STD format; i.e. prepend a 0x00 to
1311          indicate a positive number if the high bit is set. */
1312       mpi = gcry_sexp_nth_mpi (value_pair, 1, GCRYMPI_FMT_STD);
1313       if (! mpi)
1314         {
1315           err = gpg_error (GPG_ERR_INV_SEXP);
1316           break;
1317         }
1318       mpis_new[i] = mpi;
1319       gcry_sexp_release (value_pair);
1320       value_pair = NULL;
1321     }
1322   if (err)
1323     goto out;
1324
1325   /* We do not require a comment sublist to be present here.  */
1326   data = NULL;
1327   data_n = 0;
1328
1329   comment_list = gcry_sexp_find_token (sexp, "comment", 0);
1330   if (comment_list)
1331     data = gcry_sexp_nth_data (comment_list, 1, &data_n);
1332   if (! data)
1333     {
1334       data = "(none)";
1335       data_n = 6;
1336     }
1337
1338   comment_new = make_cstring (data, data_n);
1339   if (! comment_new)
1340     {
1341       err = gpg_error_from_syserror ();
1342       goto out;
1343     }
1344
1345   if (secret)
1346     *secret = is_secret;
1347   *mpis = mpis_new;
1348   *comment = comment_new;
1349
1350  out:
1351
1352   gcry_sexp_release (value_list);
1353   gcry_sexp_release (value_pair);
1354   gcry_sexp_release (comment_list);
1355
1356   if (err)
1357     {
1358       xfree (comment_new);
1359       mpint_list_free (mpis_new);
1360     }
1361
1362   return err;
1363 }
1364
1365 /* Extract the car from SEXP, and create a newly created C-string
1366    which is to be stored in IDENTIFIER.  */
1367 static gpg_error_t
1368 sexp_extract_identifier (gcry_sexp_t sexp, char **identifier)
1369 {
1370   char *identifier_new;
1371   gcry_sexp_t sublist;
1372   const char *data;
1373   size_t data_n;
1374   gpg_error_t err;
1375
1376   identifier_new = NULL;
1377   err = 0;
1378
1379   sublist = gcry_sexp_nth (sexp, 1);
1380   if (! sublist)
1381     {
1382       err = gpg_error (GPG_ERR_INV_SEXP);
1383       goto out;
1384     }
1385
1386   data = gcry_sexp_nth_data (sublist, 0, &data_n);
1387   if (! data)
1388     {
1389       err = gpg_error (GPG_ERR_INV_SEXP);
1390       goto out;
1391     }
1392
1393   identifier_new = make_cstring (data, data_n);
1394   if (! identifier_new)
1395     {
1396       err = gpg_err_code_from_errno (errno);
1397       goto out;
1398     }
1399
1400   *identifier = identifier_new;
1401
1402  out:
1403
1404   gcry_sexp_release (sublist);
1405
1406   return err;
1407 }
1408
1409 \f
1410
1411 /*
1412
1413   Key I/O.
1414
1415 */
1416
1417 /* Search for a key specification entry.  If SSH_NAME is not NULL,
1418    search for an entry whose "ssh_name" is equal to SSH_NAME;
1419    otherwise, search for an entry whose "name" is equal to NAME.
1420    Store found entry in SPEC on success, return error otherwise.  */
1421 static gpg_error_t
1422 ssh_key_type_lookup (const char *ssh_name, const char *name,
1423                      ssh_key_type_spec_t *spec)
1424 {
1425   gpg_error_t err;
1426   unsigned int i;
1427
1428   for (i = 0; i < DIM (ssh_key_types); i++)
1429     if ((ssh_name && (! strcmp (ssh_name, ssh_key_types[i].ssh_identifier)))
1430         || (name && (! strcmp (name, ssh_key_types[i].identifier))))
1431       break;
1432
1433   if (i == DIM (ssh_key_types))
1434     err = gpg_error (GPG_ERR_NOT_FOUND);
1435   else
1436     {
1437       *spec = ssh_key_types[i];
1438       err = 0;
1439     }
1440
1441   return err;
1442 }
1443
1444 /* Receive a key from STREAM, according to the key specification given
1445    as KEY_SPEC.  Depending on SECRET, receive a secret or a public
1446    key.  If READ_COMMENT is true, receive a comment string as well.
1447    Constructs a new S-Expression from received data and stores it in
1448    KEY_NEW.  Returns zero on success or an error code.  */
1449 static gpg_error_t
1450 ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret,
1451                  int read_comment, ssh_key_type_spec_t *key_spec)
1452 {
1453   gpg_error_t err;
1454   char *key_type = NULL;
1455   char *comment = NULL;
1456   gcry_sexp_t key = NULL;
1457   ssh_key_type_spec_t spec;
1458   gcry_mpi_t *mpi_list = NULL;
1459   const char *elems;
1460
1461   err = stream_read_cstring (stream, &key_type);
1462   if (err)
1463     goto out;
1464
1465   err = ssh_key_type_lookup (key_type, NULL, &spec);
1466   if (err)
1467     goto out;
1468
1469   err = ssh_receive_mpint_list (stream, secret, spec, &mpi_list);
1470   if (err)
1471     goto out;
1472
1473   if (read_comment)
1474     {
1475       err = stream_read_cstring (stream, &comment);
1476       if (err)
1477         goto out;
1478     }
1479
1480   if (secret)
1481     elems = spec.elems_key_secret;
1482   else
1483     elems = spec.elems_key_public;
1484
1485   if (spec.key_modifier)
1486     {
1487       err = (*spec.key_modifier) (elems, mpi_list);
1488       if (err)
1489         goto out;
1490     }
1491
1492   err = sexp_key_construct (&key, spec, secret, mpi_list, comment? comment:"");
1493   if (err)
1494     goto out;
1495
1496   if (key_spec)
1497     *key_spec = spec;
1498   *key_new = key;
1499
1500  out:
1501
1502   mpint_list_free (mpi_list);
1503   xfree (key_type);
1504   xfree (comment);
1505
1506   return err;
1507 }
1508
1509 /* Converts a key of type TYPE, whose key material is given in MPIS,
1510    into a newly created binary blob, which is to be stored in
1511    BLOB/BLOB_SIZE.  Returns zero on success or an error code.  */
1512 static gpg_error_t
1513 ssh_convert_key_to_blob (unsigned char **blob, size_t *blob_size,
1514                          const char *type, gcry_mpi_t *mpis)
1515 {
1516   unsigned char *blob_new;
1517   long int blob_size_new;
1518   estream_t stream;
1519   gpg_error_t err;
1520   unsigned int i;
1521
1522   *blob = NULL;
1523   *blob_size = 0;
1524
1525   blob_new = NULL;
1526   stream = NULL;
1527   err = 0;
1528
1529   stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1530   if (! stream)
1531     {
1532       err = gpg_error_from_syserror ();
1533       goto out;
1534     }
1535
1536   err = stream_write_cstring (stream, type);
1537   if (err)
1538     goto out;
1539
1540   for (i = 0; mpis[i] && (! err); i++)
1541     err = stream_write_mpi (stream, mpis[i]);
1542   if (err)
1543     goto out;
1544
1545   blob_size_new = es_ftell (stream);
1546   if (blob_size_new == -1)
1547     {
1548       err = gpg_error_from_syserror ();
1549       goto out;
1550     }
1551
1552   err = es_fseek (stream, 0, SEEK_SET);
1553   if (err)
1554     goto out;
1555
1556   blob_new = xtrymalloc (blob_size_new);
1557   if (! blob_new)
1558     {
1559       err = gpg_error_from_syserror ();
1560       goto out;
1561     }
1562
1563   err = stream_read_data (stream, blob_new, blob_size_new);
1564   if (err)
1565     goto out;
1566
1567   *blob = blob_new;
1568   *blob_size = blob_size_new;
1569
1570  out:
1571
1572   if (stream)
1573     es_fclose (stream);
1574   if (err)
1575     xfree (blob_new);
1576
1577   return err;
1578 }
1579
1580
1581 /* Write the public key KEY_PUBLIC to STREAM in SSH key format.  If
1582    OVERRIDE_COMMENT is not NULL, it will be used instead of the
1583    comment stored in the key.  */
1584 static gpg_error_t
1585 ssh_send_key_public (estream_t stream, gcry_sexp_t key_public,
1586                      const char *override_comment)
1587 {
1588   ssh_key_type_spec_t spec;
1589   gcry_mpi_t *mpi_list;
1590   char *key_type;
1591   char *comment;
1592   unsigned char *blob;
1593   size_t blob_n;
1594   gpg_error_t err;
1595
1596   key_type = NULL;
1597   mpi_list = NULL;
1598   comment = NULL;
1599   blob = NULL;
1600
1601   err = sexp_extract_identifier (key_public, &key_type);
1602   if (err)
1603     goto out;
1604
1605   err = ssh_key_type_lookup (NULL, key_type, &spec);
1606   if (err)
1607     goto out;
1608
1609   err = sexp_key_extract (key_public, spec, NULL, &mpi_list, &comment);
1610   if (err)
1611     goto out;
1612
1613   err = ssh_convert_key_to_blob (&blob, &blob_n,
1614                                  spec.ssh_identifier, mpi_list);
1615   if (err)
1616     goto out;
1617
1618   err = stream_write_string (stream, blob, blob_n);
1619   if (err)
1620     goto out;
1621
1622   err = stream_write_cstring (stream,
1623                               override_comment? override_comment : comment);
1624
1625  out:
1626
1627   mpint_list_free (mpi_list);
1628   xfree (key_type);
1629   xfree (comment);
1630   xfree (blob);
1631
1632   return err;
1633 }
1634
1635 /* Read a public key out of BLOB/BLOB_SIZE according to the key
1636    specification given as KEY_SPEC, storing the new key in KEY_PUBLIC.
1637    Returns zero on success or an error code.  */
1638 static gpg_error_t
1639 ssh_read_key_public_from_blob (unsigned char *blob, size_t blob_size,
1640                                gcry_sexp_t *key_public,
1641                                ssh_key_type_spec_t *key_spec)
1642 {
1643   estream_t blob_stream;
1644   gpg_error_t err;
1645
1646   err = 0;
1647
1648   blob_stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1649   if (! blob_stream)
1650     {
1651       err = gpg_error_from_syserror ();
1652       goto out;
1653     }
1654
1655   err = stream_write_data (blob_stream, blob, blob_size);
1656   if (err)
1657     goto out;
1658
1659   err = es_fseek (blob_stream, 0, SEEK_SET);
1660   if (err)
1661     goto out;
1662
1663   err = ssh_receive_key (blob_stream, key_public, 0, 0, key_spec);
1664
1665  out:
1666
1667   if (blob_stream)
1668     es_fclose (blob_stream);
1669
1670   return err;
1671 }
1672
1673 \f
1674
1675 /* This function calculates the key grip for the key contained in the
1676    S-Expression KEY and writes it to BUFFER, which must be large
1677    enough to hold it.  Returns usual error code.  */
1678 static gpg_error_t
1679 ssh_key_grip (gcry_sexp_t key, unsigned char *buffer)
1680 {
1681   if (!gcry_pk_get_keygrip (key, buffer))
1682     return gpg_error (GPG_ERR_INTERNAL);
1683
1684   return 0;
1685 }
1686
1687
1688 /* Converts the secret key KEY_SECRET into a public key, storing it in
1689    KEY_PUBLIC.  SPEC is the according key specification.  Returns zero
1690    on success or an error code.  */
1691 static gpg_error_t
1692 key_secret_to_public (gcry_sexp_t *key_public,
1693                       ssh_key_type_spec_t spec, gcry_sexp_t key_secret)
1694 {
1695   char *comment;
1696   gcry_mpi_t *mpis;
1697   gpg_error_t err;
1698   int is_secret;
1699
1700   comment = NULL;
1701   mpis = NULL;
1702
1703   err = sexp_key_extract (key_secret, spec, &is_secret, &mpis, &comment);
1704   if (err)
1705     goto out;
1706
1707   err = sexp_key_construct (key_public, spec, 0, mpis, comment);
1708
1709  out:
1710
1711   mpint_list_free (mpis);
1712   xfree (comment);
1713
1714   return err;
1715 }
1716
1717
1718 /* Check whether a smartcard is available and whether it has a usable
1719    key.  Store a copy of that key at R_PK and return 0.  If no key is
1720    available store NULL at R_PK and return an error code.  If CARDSN
1721    is not NULL, a string with the serial number of the card will be
1722    a malloced and stored there. */
1723 static gpg_error_t
1724 card_key_available (ctrl_t ctrl, gcry_sexp_t *r_pk, char **cardsn)
1725 {
1726   gpg_error_t err;
1727   char *authkeyid;
1728   char *serialno = NULL;
1729   unsigned char *pkbuf;
1730   size_t pkbuflen;
1731   gcry_sexp_t s_pk;
1732   unsigned char grip[20];
1733
1734   *r_pk = NULL;
1735   if (cardsn)
1736     *cardsn = NULL;
1737
1738   /* First see whether a card is available and whether the application
1739      is supported.  */
1740   err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
1741   if ( gpg_err_code (err) == GPG_ERR_CARD_REMOVED )
1742     {
1743       /* Ask for the serial number to reset the card.  */
1744       err = agent_card_serialno (ctrl, &serialno);
1745       if (err)
1746         {
1747           if (opt.verbose)
1748             log_info (_("error getting serial number of card: %s\n"),
1749                       gpg_strerror (err));
1750           return err;
1751         }
1752       log_info (_("detected card with S/N: %s\n"), serialno);
1753       err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
1754     }
1755   if (err)
1756     {
1757       log_error (_("no authentication key for ssh on card: %s\n"),
1758                  gpg_strerror (err));
1759       xfree (serialno);
1760       return err;
1761     }
1762
1763   /* Get the S/N if we don't have it yet.  Use the fast getattr method.  */
1764   if (!serialno && (err = agent_card_getattr (ctrl, "SERIALNO", &serialno)) )
1765     {
1766       log_error (_("error getting serial number of card: %s\n"),
1767                  gpg_strerror (err));
1768       xfree (authkeyid);
1769       return err;
1770     }
1771
1772   /* Read the public key.  */
1773   err = agent_card_readkey (ctrl, authkeyid, &pkbuf);
1774   if (err)
1775     {
1776       if (opt.verbose)
1777         log_info (_("no suitable card key found: %s\n"), gpg_strerror (err));
1778       xfree (serialno);
1779       xfree (authkeyid);
1780       return err;
1781     }
1782
1783   pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
1784   err = gcry_sexp_sscan (&s_pk, NULL, (char*)pkbuf, pkbuflen);
1785   if (err)
1786     {
1787       log_error ("failed to build S-Exp from received card key: %s\n",
1788                  gpg_strerror (err));
1789       xfree (pkbuf);
1790       xfree (serialno);
1791       xfree (authkeyid);
1792       return err;
1793     }
1794
1795   err = ssh_key_grip (s_pk, grip);
1796   if (err)
1797     {
1798       log_debug ("error computing keygrip from received card key: %s\n",
1799                  gcry_strerror (err));
1800       xfree (pkbuf);
1801       gcry_sexp_release (s_pk);
1802       xfree (serialno);
1803       xfree (authkeyid);
1804       return err;
1805     }
1806
1807   if ( agent_key_available (grip) )
1808     {
1809       /* (Shadow)-key is not available in our key storage.  */
1810       unsigned char *shadow_info;
1811       unsigned char *tmp;
1812
1813       shadow_info = make_shadow_info (serialno, authkeyid);
1814       if (!shadow_info)
1815         {
1816           err = gpg_error_from_syserror ();
1817           xfree (pkbuf);
1818           gcry_sexp_release (s_pk);
1819           xfree (serialno);
1820           xfree (authkeyid);
1821           return err;
1822         }
1823       err = agent_shadow_key (pkbuf, shadow_info, &tmp);
1824       xfree (shadow_info);
1825       if (err)
1826         {
1827           log_error (_("shadowing the key failed: %s\n"), gpg_strerror (err));
1828           xfree (pkbuf);
1829           gcry_sexp_release (s_pk);
1830           xfree (serialno);
1831           xfree (authkeyid);
1832           return err;
1833         }
1834       xfree (pkbuf);
1835       pkbuf = tmp;
1836       pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
1837       assert (pkbuflen);
1838
1839       err = agent_write_private_key (grip, pkbuf, pkbuflen, 0);
1840       if (err)
1841         {
1842           log_error (_("error writing key: %s\n"), gpg_strerror (err));
1843           xfree (pkbuf);
1844           gcry_sexp_release (s_pk);
1845           xfree (serialno);
1846           xfree (authkeyid);
1847           return err;
1848         }
1849     }
1850
1851   if (cardsn)
1852     {
1853       char *dispsn;
1854
1855       /* If the card handler is able to return a short serialnumber,
1856          use that one, else use the complete serialno. */
1857       if (!agent_card_getattr (ctrl, "$DISPSERIALNO", &dispsn))
1858         {
1859           *cardsn = xtryasprintf ("cardno:%s", dispsn);
1860           xfree (dispsn);
1861         }
1862       else
1863         *cardsn = xtryasprintf ("cardno:%s", serialno);
1864       if (!*cardsn)
1865         {
1866           err = gpg_error_from_syserror ();
1867           xfree (pkbuf);
1868           gcry_sexp_release (s_pk);
1869           xfree (serialno);
1870           xfree (authkeyid);
1871           return err;
1872         }
1873     }
1874
1875   xfree (pkbuf);
1876   xfree (serialno);
1877   xfree (authkeyid);
1878   *r_pk = s_pk;
1879   return 0;
1880 }
1881
1882
1883 \f
1884
1885 /*
1886
1887   Request handler.  Each handler is provided with a CTRL context, a
1888   REQUEST object and a RESPONSE object.  The actual request is to be
1889   read from REQUEST, the response needs to be written to RESPONSE.
1890
1891 */
1892
1893
1894 /* Handler for the "request_identities" command.  */
1895 static gpg_error_t
1896 ssh_handler_request_identities (ctrl_t ctrl,
1897                                 estream_t request, estream_t response)
1898 {
1899   char *key_type;
1900   ssh_key_type_spec_t spec;
1901   struct dirent *dir_entry;
1902   char *key_directory;
1903   size_t key_directory_n;
1904   char *key_path;
1905   unsigned char *buffer;
1906   size_t buffer_n;
1907   u32 key_counter;
1908   estream_t key_blobs;
1909   gcry_sexp_t key_secret;
1910   gcry_sexp_t key_public;
1911   DIR *dir;
1912   gpg_error_t err;
1913   int ret;
1914   control_file_t cf = NULL;
1915   char *cardsn;
1916   gpg_error_t ret_err;
1917
1918   (void)request;
1919
1920   /* Prepare buffer stream.  */
1921
1922   key_directory = NULL;
1923   key_secret = NULL;
1924   key_public = NULL;
1925   key_type = NULL;
1926   key_path = NULL;
1927   key_counter = 0;
1928   buffer = NULL;
1929   dir = NULL;
1930   err = 0;
1931
1932   key_blobs = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1933   if (! key_blobs)
1934     {
1935       err = gpg_error_from_syserror ();
1936       goto out;
1937     }
1938
1939   /* Open key directory.  */
1940   key_directory = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, NULL);
1941   if (! key_directory)
1942     {
1943       err = gpg_err_code_from_errno (errno);
1944       goto out;
1945     }
1946   key_directory_n = strlen (key_directory);
1947
1948   key_path = xtrymalloc (key_directory_n + 46);
1949   if (! key_path)
1950     {
1951       err = gpg_err_code_from_errno (errno);
1952       goto out;
1953     }
1954
1955   sprintf (key_path, "%s/", key_directory);
1956   sprintf (key_path + key_directory_n + 41, ".key");
1957
1958   dir = opendir (key_directory);
1959   if (! dir)
1960     {
1961       err = gpg_err_code_from_errno (errno);
1962       goto out;
1963     }
1964
1965
1966
1967   /* First check whether a key is currently available in the card
1968      reader - this should be allowed even without being listed in
1969      sshcontrol. */
1970
1971   if (!opt.disable_scdaemon
1972       && !card_key_available (ctrl, &key_public, &cardsn))
1973     {
1974       err = ssh_send_key_public (key_blobs, key_public, cardsn);
1975       gcry_sexp_release (key_public);
1976       key_public = NULL;
1977       xfree (cardsn);
1978       if (err)
1979         goto out;
1980
1981       key_counter++;
1982     }
1983
1984
1985   /* Then look at all the registered an allowed keys. */
1986
1987
1988   /* Fixme: We should better iterate over the control file and check
1989      whether the key file is there.  This is better in respect to
1990      performance if there are a lot of keys in our key storage. */
1991   /* FIXME: make sure that buffer gets deallocated properly.  */
1992   err = open_control_file (&cf, 0);
1993   if (err)
1994     goto out;
1995
1996   while ( (dir_entry = readdir (dir)) )
1997     {
1998       if ((strlen (dir_entry->d_name) == 44)
1999           && (! strncmp (dir_entry->d_name + 40, ".key", 4)))
2000         {
2001           char hexgrip[41];
2002           int disabled;
2003
2004           /* We do only want to return keys listed in our control
2005              file. */
2006           strncpy (hexgrip, dir_entry->d_name, 40);
2007           hexgrip[40] = 0;
2008           if ( strlen (hexgrip) != 40 )
2009             continue;
2010           if (search_control_file (cf, hexgrip, &disabled, NULL, NULL)
2011               || disabled)
2012             continue;
2013
2014           strncpy (key_path + key_directory_n + 1, dir_entry->d_name, 40);
2015
2016           /* Read file content.  */
2017           err = file_to_buffer (key_path, &buffer, &buffer_n);
2018           if (err)
2019             goto out;
2020
2021           err = gcry_sexp_sscan (&key_secret, NULL, (char*)buffer, buffer_n);
2022           if (err)
2023             goto out;
2024
2025           xfree (buffer);
2026           buffer = NULL;
2027
2028           err = sexp_extract_identifier (key_secret, &key_type);
2029           if (err)
2030             goto out;
2031
2032           err = ssh_key_type_lookup (NULL, key_type, &spec);
2033           if (err)
2034             goto out;
2035
2036           xfree (key_type);
2037           key_type = NULL;
2038
2039           err = key_secret_to_public (&key_public, spec, key_secret);
2040           if (err)
2041             goto out;
2042
2043           gcry_sexp_release (key_secret);
2044           key_secret = NULL;
2045
2046           err = ssh_send_key_public (key_blobs, key_public, NULL);
2047           if (err)
2048             goto out;
2049
2050           gcry_sexp_release (key_public);
2051           key_public = NULL;
2052
2053           key_counter++;
2054         }
2055     }
2056
2057   ret = es_fseek (key_blobs, 0, SEEK_SET);
2058   if (ret)
2059     {
2060       err = gpg_error_from_syserror ();
2061       goto out;
2062     }
2063
2064  out:
2065
2066   /* Send response.  */
2067
2068   gcry_sexp_release (key_secret);
2069   gcry_sexp_release (key_public);
2070
2071   if (! err)
2072     {
2073       ret_err = stream_write_byte (response, SSH_RESPONSE_IDENTITIES_ANSWER);
2074       if (ret_err)
2075         goto leave;
2076       ret_err = stream_write_uint32 (response, key_counter);
2077       if (ret_err)
2078         goto leave;
2079       ret_err = stream_copy (response, key_blobs);
2080       if (ret_err)
2081         goto leave;
2082     }
2083   else
2084     {
2085       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2086       goto leave;
2087     };
2088
2089  leave:
2090
2091   if (key_blobs)
2092     es_fclose (key_blobs);
2093   if (dir)
2094     closedir (dir);
2095
2096   close_control_file (cf);
2097
2098   xfree (key_directory);
2099   xfree (key_path);
2100   xfree (buffer);
2101   xfree (key_type);
2102
2103   return ret_err;
2104 }
2105
2106
2107 /* This function hashes the data contained in DATA of size DATA_N
2108    according to the message digest algorithm specified by MD_ALGORITHM
2109    and writes the message digest to HASH, which needs to large enough
2110    for the digest.  */
2111 static gpg_error_t
2112 data_hash (unsigned char *data, size_t data_n,
2113            int md_algorithm, unsigned char *hash)
2114 {
2115   gcry_md_hash_buffer (md_algorithm, hash, data, data_n);
2116
2117   return 0;
2118 }
2119
2120 /* This function signs the data contained in CTRL, stores the created
2121    signature in newly allocated memory in SIG and it's size in SIG_N;
2122    SIG_ENCODER is the signature encoder to use.  */
2123 static gpg_error_t
2124 data_sign (ctrl_t ctrl, ssh_signature_encoder_t sig_encoder,
2125            unsigned char **sig, size_t *sig_n)
2126 {
2127   gpg_error_t err;
2128   gcry_sexp_t signature_sexp = NULL;
2129   estream_t stream = NULL;
2130   gcry_sexp_t valuelist = NULL;
2131   gcry_sexp_t sublist = NULL;
2132   gcry_mpi_t sig_value = NULL;
2133   unsigned char *sig_blob = NULL;
2134   size_t sig_blob_n = 0;
2135   char *identifier = NULL;
2136   const char *identifier_raw;
2137   size_t identifier_n;
2138   ssh_key_type_spec_t spec;
2139   int ret;
2140   unsigned int i;
2141   const char *elems;
2142   size_t elems_n;
2143   gcry_mpi_t *mpis = NULL;
2144   char hexgrip[40+1];
2145
2146   *sig = NULL;
2147   *sig_n = 0;
2148
2149   /* Quick check to see whether we have a valid keygrip and convert it
2150      to hex.  */
2151   if (!ctrl->have_keygrip)
2152     {
2153       err = gpg_error (GPG_ERR_NO_SECKEY);
2154       goto out;
2155     }
2156   bin2hex (ctrl->keygrip, 20, hexgrip);
2157
2158   /* Ask for confirmation if needed.  */
2159   if (confirm_flag_from_sshcontrol (hexgrip))
2160     {
2161       gcry_sexp_t key;
2162       char *fpr, *prompt;
2163       char *comment = NULL;
2164
2165       err = agent_raw_key_from_file (ctrl, ctrl->keygrip, &key);
2166       if (err)
2167         goto out;
2168       err = ssh_get_fingerprint_string (key, &fpr);
2169       if (!err)
2170         {
2171           gcry_sexp_t tmpsxp = gcry_sexp_find_token (key, "comment", 0);
2172           if (tmpsxp)
2173             comment = gcry_sexp_nth_string (tmpsxp, 1);
2174           gcry_sexp_release (tmpsxp);
2175         }
2176       gcry_sexp_release (key);
2177       if (err)
2178         goto out;
2179       prompt = xtryasprintf (_("An ssh process requested the use of key%%0A"
2180                                "  %s%%0A"
2181                                "  (%s)%%0A"
2182                                "Do you want to allow this?"),
2183                              fpr, comment? comment:"");
2184       xfree (fpr);
2185       gcry_free (comment);
2186       err = agent_get_confirmation (ctrl, prompt, _("Allow"), _("Deny"), 0);
2187       xfree (prompt);
2188       if (err)
2189         goto out;
2190     }
2191
2192   /* Create signature.  */
2193   ctrl->use_auth_call = 1;
2194   err = agent_pksign_do (ctrl, NULL,
2195                          _("Please enter the passphrase "
2196                            "for the ssh key%%0A  %F%%0A  (%c)"),
2197                          &signature_sexp,
2198                          CACHE_MODE_SSH, ttl_from_sshcontrol);
2199   ctrl->use_auth_call = 0;
2200   if (err)
2201     goto out;
2202
2203   valuelist = gcry_sexp_nth (signature_sexp, 1);
2204   if (! valuelist)
2205     {
2206       err = gpg_error (GPG_ERR_INV_SEXP);
2207       goto out;
2208     }
2209
2210   stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
2211   if (! stream)
2212     {
2213       err = gpg_error_from_syserror ();
2214       goto out;
2215     }
2216
2217   identifier_raw = gcry_sexp_nth_data (valuelist, 0, &identifier_n);
2218   if (! identifier_raw)
2219     {
2220       err = gpg_error (GPG_ERR_INV_SEXP);
2221       goto out;
2222     }
2223
2224   identifier = make_cstring (identifier_raw, identifier_n);
2225   if (! identifier)
2226     {
2227       err = gpg_error_from_syserror ();
2228       goto out;
2229     }
2230
2231   err = ssh_key_type_lookup (NULL, identifier, &spec);
2232   if (err)
2233     goto out;
2234
2235   err = stream_write_cstring (stream, spec.ssh_identifier);
2236   if (err)
2237     goto out;
2238
2239   elems = spec.elems_signature;
2240   elems_n = strlen (elems);
2241
2242   mpis = xtrycalloc (elems_n + 1, sizeof *mpis);
2243   if (!mpis)
2244     {
2245       err = gpg_error_from_syserror ();
2246       goto out;
2247     }
2248
2249   for (i = 0; i < elems_n; i++)
2250     {
2251       sublist = gcry_sexp_find_token (valuelist, spec.elems_signature + i, 1);
2252       if (! sublist)
2253         {
2254           err = gpg_error (GPG_ERR_INV_SEXP);
2255           break;
2256         }
2257
2258       sig_value = gcry_sexp_nth_mpi (sublist, 1, GCRYMPI_FMT_USG);
2259       if (! sig_value)
2260         {
2261           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
2262           break;
2263         }
2264       gcry_sexp_release (sublist);
2265       sublist = NULL;
2266
2267       mpis[i] = sig_value;
2268     }
2269   if (err)
2270     goto out;
2271
2272   err = (*sig_encoder) (stream, mpis);
2273   if (err)
2274     goto out;
2275
2276   sig_blob_n = es_ftell (stream);
2277   if (sig_blob_n == -1)
2278     {
2279       err = gpg_error_from_syserror ();
2280       goto out;
2281     }
2282
2283   sig_blob = xtrymalloc (sig_blob_n);
2284   if (! sig_blob)
2285     {
2286       err = gpg_error_from_syserror ();
2287       goto out;
2288     }
2289
2290   ret = es_fseek (stream, 0, SEEK_SET);
2291   if (ret)
2292     {
2293       err = gpg_error_from_syserror ();
2294       goto out;
2295     }
2296
2297   err = stream_read_data (stream, sig_blob, sig_blob_n);
2298   if (err)
2299     goto out;
2300
2301   *sig = sig_blob;
2302   *sig_n = sig_blob_n;
2303
2304  out:
2305
2306   if (err)
2307     xfree (sig_blob);
2308
2309   if (stream)
2310     es_fclose (stream);
2311   gcry_sexp_release (valuelist);
2312   gcry_sexp_release (signature_sexp);
2313   gcry_sexp_release (sublist);
2314   mpint_list_free (mpis);
2315   xfree (identifier);
2316
2317   return err;
2318 }
2319
2320 /* Handler for the "sign_request" command.  */
2321 static gpg_error_t
2322 ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
2323 {
2324   gcry_sexp_t key;
2325   ssh_key_type_spec_t spec;
2326   unsigned char hash[MAX_DIGEST_LEN];
2327   unsigned int hash_n;
2328   unsigned char key_grip[20];
2329   unsigned char *key_blob;
2330   u32 key_blob_size;
2331   unsigned char *data;
2332   unsigned char *sig;
2333   size_t sig_n;
2334   u32 data_size;
2335   u32 flags;
2336   gpg_error_t err;
2337   gpg_error_t ret_err;
2338
2339   key_blob = NULL;
2340   data = NULL;
2341   sig = NULL;
2342   key = NULL;
2343
2344   /* Receive key.  */
2345
2346   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2347   if (err)
2348     goto out;
2349
2350   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, &spec);
2351   if (err)
2352     goto out;
2353
2354   /* Receive data to sign.  */
2355   err = stream_read_string (request, 0, &data, &data_size);
2356   if (err)
2357     goto out;
2358
2359   /* FIXME?  */
2360   err = stream_read_uint32 (request, &flags);
2361   if (err)
2362     goto out;
2363
2364   /* Hash data.  */
2365   hash_n = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
2366   if (! hash_n)
2367     {
2368       err = gpg_error (GPG_ERR_INTERNAL);
2369       goto out;
2370     }
2371   err = data_hash (data, data_size, GCRY_MD_SHA1, hash);
2372   if (err)
2373     goto out;
2374
2375   /* Calculate key grip.  */
2376   err = ssh_key_grip (key, key_grip);
2377   if (err)
2378     goto out;
2379
2380   /* Sign data.  */
2381
2382   ctrl->digest.algo = GCRY_MD_SHA1;
2383   memcpy (ctrl->digest.value, hash, hash_n);
2384   ctrl->digest.valuelen = hash_n;
2385   ctrl->digest.raw_value = ! (spec.flags & SPEC_FLAG_USE_PKCS1V2);
2386   ctrl->have_keygrip = 1;
2387   memcpy (ctrl->keygrip, key_grip, 20);
2388
2389   err = data_sign (ctrl, spec.signature_encoder, &sig, &sig_n);
2390
2391  out:
2392
2393   /* Done.  */
2394
2395   if (! err)
2396     {
2397       ret_err = stream_write_byte (response, SSH_RESPONSE_SIGN_RESPONSE);
2398       if (ret_err)
2399         goto leave;
2400       ret_err = stream_write_string (response, sig, sig_n);
2401       if (ret_err)
2402         goto leave;
2403     }
2404   else
2405     {
2406       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2407       if (ret_err)
2408         goto leave;
2409     }
2410
2411  leave:
2412
2413   gcry_sexp_release (key);
2414   xfree (key_blob);
2415   xfree (data);
2416   xfree (sig);
2417
2418   return ret_err;
2419 }
2420
2421 /* This function extracts the comment contained in the key
2422    S-Expression KEY and stores a copy in COMMENT.  Returns usual error
2423    code.  */
2424 static gpg_error_t
2425 ssh_key_extract_comment (gcry_sexp_t key, char **comment)
2426 {
2427   gcry_sexp_t comment_list;
2428   char *comment_new;
2429   const char *data;
2430   size_t data_n;
2431   gpg_error_t err;
2432
2433   comment_list = gcry_sexp_find_token (key, "comment", 0);
2434   if (! comment_list)
2435     {
2436       err = gpg_error (GPG_ERR_INV_SEXP);
2437       goto out;
2438     }
2439
2440   data = gcry_sexp_nth_data (comment_list, 1, &data_n);
2441   if (! data)
2442     {
2443       err = gpg_error (GPG_ERR_INV_SEXP);
2444       goto out;
2445     }
2446
2447   comment_new = make_cstring (data, data_n);
2448   if (! comment_new)
2449     {
2450       err = gpg_error_from_syserror ();
2451       goto out;
2452     }
2453
2454   *comment = comment_new;
2455   err = 0;
2456
2457  out:
2458
2459   gcry_sexp_release (comment_list);
2460
2461   return err;
2462 }
2463
2464 /* This function converts the key contained in the S-Expression KEY
2465    into a buffer, which is protected by the passphrase PASSPHRASE.
2466    Returns usual error code.  */
2467 static gpg_error_t
2468 ssh_key_to_protected_buffer (gcry_sexp_t key, const char *passphrase,
2469                              unsigned char **buffer, size_t *buffer_n)
2470 {
2471   unsigned char *buffer_new;
2472   unsigned int buffer_new_n;
2473   gpg_error_t err;
2474
2475   err = 0;
2476   buffer_new_n = gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, NULL, 0);
2477   buffer_new = xtrymalloc_secure (buffer_new_n);
2478   if (! buffer_new)
2479     {
2480       err = gpg_error_from_syserror ();
2481       goto out;
2482     }
2483
2484   gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, buffer_new, buffer_new_n);
2485   /* FIXME: guarantee?  */
2486
2487   err = agent_protect (buffer_new, passphrase, buffer, buffer_n, 0);
2488
2489  out:
2490
2491   xfree (buffer_new);
2492
2493   return err;
2494 }
2495
2496
2497
2498 /* Callback function to compare the first entered PIN with the one
2499    currently being entered. */
2500 static int
2501 reenter_compare_cb (struct pin_entry_info_s *pi)
2502 {
2503   const char *pin1 = pi->check_cb_arg;
2504
2505   if (!strcmp (pin1, pi->pin))
2506     return 0; /* okay */
2507   return -1;
2508 }
2509
2510 /* Store the ssh KEY into our local key storage and protect it after
2511    asking for a passphrase.  Cache that passphrase.  TTL is the
2512    maximum caching time for that key.  If the key already exists in
2513    our key storage, don't do anything.  When entering a new key also
2514    add an entry to the sshcontrol file.  */
2515 static gpg_error_t
2516 ssh_identity_register (ctrl_t ctrl, gcry_sexp_t key, int ttl, int confirm)
2517 {
2518   gpg_error_t err;
2519   unsigned char key_grip_raw[20];
2520   char key_grip[41];
2521   unsigned char *buffer = NULL;
2522   size_t buffer_n;
2523   char *description = NULL;
2524   const char *description2 = _("Please re-enter this passphrase");
2525   char *comment = NULL;
2526   char *key_fpr = NULL;
2527   const char *initial_errtext = NULL;
2528   unsigned int i;
2529   struct pin_entry_info_s *pi = NULL, *pi2;
2530
2531   err = ssh_key_grip (key, key_grip_raw);
2532   if (err)
2533     goto out;
2534
2535   /* Check whether the key is already in our key storage.  Don't do
2536      anything then.  */
2537   if ( !agent_key_available (key_grip_raw) )
2538     goto out; /* Yes, key is available.  */
2539
2540   err = ssh_get_fingerprint_string (key, &key_fpr);
2541   if (err)
2542     goto out;
2543
2544   err = ssh_key_extract_comment (key, &comment);
2545   if (err)
2546     goto out;
2547
2548   if ( asprintf (&description,
2549                  _("Please enter a passphrase to protect"
2550                    " the received secret key%%0A"
2551                    "   %s%%0A"
2552                    "   %s%%0A"
2553                    "within gpg-agent's key storage"),
2554                  key_fpr, comment ? comment : "") < 0)
2555     {
2556       err = gpg_error_from_syserror ();
2557       goto out;
2558     }
2559
2560
2561   pi = gcry_calloc_secure (2, sizeof (*pi) + 100 + 1);
2562   if (!pi)
2563     {
2564       err = gpg_error_from_syserror ();
2565       goto out;
2566     }
2567   pi2 = pi + (sizeof *pi + 100 + 1);
2568   pi->max_length = 100;
2569   pi->max_tries = 1;
2570   pi2->max_length = 100;
2571   pi2->max_tries = 1;
2572   pi2->check_cb = reenter_compare_cb;
2573   pi2->check_cb_arg = pi->pin;
2574
2575  next_try:
2576   err = agent_askpin (ctrl, description, NULL, initial_errtext, pi);
2577   initial_errtext = NULL;
2578   if (err)
2579     goto out;
2580
2581   /* Unless the passphrase is empty, ask to confirm it.  */
2582   if (pi->pin && *pi->pin)
2583     {
2584       err = agent_askpin (ctrl, description2, NULL, NULL, pi2);
2585       if (err == -1)
2586         { /* The re-entered one did not match and the user did not
2587              hit cancel. */
2588           initial_errtext = _("does not match - try again");
2589           goto next_try;
2590         }
2591     }
2592
2593   err = ssh_key_to_protected_buffer (key, pi->pin, &buffer, &buffer_n);
2594   if (err)
2595     goto out;
2596
2597   /* Store this key to our key storage.  */
2598   err = agent_write_private_key (key_grip_raw, buffer, buffer_n, 0);
2599   if (err)
2600     goto out;
2601
2602   /* Cache this passphrase. */
2603   for (i = 0; i < 20; i++)
2604     sprintf (key_grip + 2 * i, "%02X", key_grip_raw[i]);
2605
2606   err = agent_put_cache (key_grip, CACHE_MODE_SSH, pi->pin, ttl);
2607   if (err)
2608     goto out;
2609
2610   /* And add an entry to the sshcontrol file.  */
2611   err = add_control_entry (ctrl, key_grip, key_fpr, ttl, confirm);
2612
2613
2614  out:
2615   if (pi && pi->max_length)
2616     wipememory (pi->pin, pi->max_length);
2617   xfree (pi);
2618   xfree (buffer);
2619   xfree (comment);
2620   xfree (key_fpr);
2621   xfree (description);
2622
2623   return err;
2624 }
2625
2626
2627 /* This function removes the key contained in the S-Expression KEY
2628    from the local key storage, in case it exists there.  Returns usual
2629    error code.  FIXME: this function is a stub.  */
2630 static gpg_error_t
2631 ssh_identity_drop (gcry_sexp_t key)
2632 {
2633   unsigned char key_grip[21] = { 0 };
2634   gpg_error_t err;
2635
2636   err = ssh_key_grip (key, key_grip);
2637   if (err)
2638     goto out;
2639
2640   key_grip[sizeof (key_grip) - 1] = 0;
2641
2642   /* FIXME: What to do here - forgetting the passphrase or deleting
2643      the key from key cache?  */
2644
2645  out:
2646
2647   return err;
2648 }
2649
2650 /* Handler for the "add_identity" command.  */
2651 static gpg_error_t
2652 ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
2653 {
2654   gpg_error_t ret_err;
2655   gpg_error_t err;
2656   gcry_sexp_t key;
2657   unsigned char b;
2658   int confirm;
2659   int ttl;
2660
2661   confirm = 0;
2662   key = NULL;
2663   ttl = 0;
2664
2665   /* FIXME?  */
2666   err = ssh_receive_key (request, &key, 1, 1, NULL);
2667   if (err)
2668     goto out;
2669
2670   while (1)
2671     {
2672       err = stream_read_byte (request, &b);
2673       if (gpg_err_code (err) == GPG_ERR_EOF)
2674         {
2675           err = 0;
2676           break;
2677         }
2678
2679       switch (b)
2680         {
2681         case SSH_OPT_CONSTRAIN_LIFETIME:
2682           {
2683             u32 n = 0;
2684
2685             err = stream_read_uint32 (request, &n);
2686             if (! err)
2687               ttl = n;
2688             break;
2689           }
2690
2691         case SSH_OPT_CONSTRAIN_CONFIRM:
2692           {
2693             confirm = 1;
2694             break;
2695           }
2696
2697         default:
2698           /* FIXME: log/bad?  */
2699           break;
2700         }
2701     }
2702   if (err)
2703     goto out;
2704
2705   err = ssh_identity_register (ctrl, key, ttl, confirm);
2706
2707  out:
2708
2709   gcry_sexp_release (key);
2710
2711   if (! err)
2712     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2713   else
2714     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2715
2716   return ret_err;
2717 }
2718
2719 /* Handler for the "remove_identity" command.  */
2720 static gpg_error_t
2721 ssh_handler_remove_identity (ctrl_t ctrl,
2722                              estream_t request, estream_t response)
2723 {
2724   unsigned char *key_blob;
2725   u32 key_blob_size;
2726   gcry_sexp_t key;
2727   gpg_error_t ret_err;
2728   gpg_error_t err;
2729
2730   (void)ctrl;
2731
2732   /* Receive key.  */
2733
2734   key_blob = NULL;
2735   key = NULL;
2736
2737   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2738   if (err)
2739     goto out;
2740
2741   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, NULL);
2742   if (err)
2743     goto out;
2744
2745   err = ssh_identity_drop (key);
2746
2747  out:
2748
2749   xfree (key_blob);
2750   gcry_sexp_release (key);
2751
2752   if (! err)
2753     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2754   else
2755     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2756
2757   return ret_err;
2758 }
2759
2760 /* FIXME: stub function.  Actually useful?  */
2761 static gpg_error_t
2762 ssh_identities_remove_all (void)
2763 {
2764   gpg_error_t err;
2765
2766   err = 0;
2767
2768   /* FIXME: shall we remove _all_ cache entries or only those
2769      registered through the ssh emulation?  */
2770
2771   return err;
2772 }
2773
2774 /* Handler for the "remove_all_identities" command.  */
2775 static gpg_error_t
2776 ssh_handler_remove_all_identities (ctrl_t ctrl,
2777                                    estream_t request, estream_t response)
2778 {
2779   gpg_error_t ret_err;
2780   gpg_error_t err;
2781
2782   (void)ctrl;
2783   (void)request;
2784
2785   err = ssh_identities_remove_all ();
2786
2787   if (! err)
2788     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2789   else
2790     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2791
2792   return ret_err;
2793 }
2794
2795 /* Lock agent?  FIXME: stub function.  */
2796 static gpg_error_t
2797 ssh_lock (void)
2798 {
2799   gpg_error_t err;
2800
2801   /* FIXME */
2802   log_error ("ssh-agent's lock command is not implemented\n");
2803   err = 0;
2804
2805   return err;
2806 }
2807
2808 /* Unock agent?  FIXME: stub function.  */
2809 static gpg_error_t
2810 ssh_unlock (void)
2811 {
2812   gpg_error_t err;
2813
2814   log_error ("ssh-agent's unlock command is not implemented\n");
2815   err = 0;
2816
2817   return err;
2818 }
2819
2820 /* Handler for the "lock" command.  */
2821 static gpg_error_t
2822 ssh_handler_lock (ctrl_t ctrl, estream_t request, estream_t response)
2823 {
2824   gpg_error_t ret_err;
2825   gpg_error_t err;
2826
2827   (void)ctrl;
2828   (void)request;
2829
2830   err = ssh_lock ();
2831
2832   if (! err)
2833     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2834   else
2835     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2836
2837   return ret_err;
2838 }
2839
2840 /* Handler for the "unlock" command.  */
2841 static gpg_error_t
2842 ssh_handler_unlock (ctrl_t ctrl, estream_t request, estream_t response)
2843 {
2844   gpg_error_t ret_err;
2845   gpg_error_t err;
2846
2847   (void)ctrl;
2848   (void)request;
2849
2850   err = ssh_unlock ();
2851
2852   if (! err)
2853     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2854   else
2855     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2856
2857   return ret_err;
2858 }
2859
2860 \f
2861
2862 /* Return the request specification for the request identified by TYPE
2863    or NULL in case the requested request specification could not be
2864    found.  */
2865 static ssh_request_spec_t *
2866 request_spec_lookup (int type)
2867 {
2868   ssh_request_spec_t *spec;
2869   unsigned int i;
2870
2871   for (i = 0; i < DIM (request_specs); i++)
2872     if (request_specs[i].type == type)
2873       break;
2874   if (i == DIM (request_specs))
2875     {
2876       if (opt.verbose)
2877         log_info ("ssh request %u is not supported\n", type);
2878       spec = NULL;
2879     }
2880   else
2881     spec = request_specs + i;
2882
2883   return spec;
2884 }
2885
2886 /* Process a single request.  The request is read from and the
2887    response is written to STREAM_SOCK.  Uses CTRL as context.  Returns
2888    zero in case of success, non zero in case of failure.  */
2889 static int
2890 ssh_request_process (ctrl_t ctrl, estream_t stream_sock)
2891 {
2892   ssh_request_spec_t *spec;
2893   estream_t response;
2894   estream_t request;
2895   unsigned char request_type;
2896   gpg_error_t err;
2897   int send_err;
2898   int ret;
2899   unsigned char *request_data;
2900   u32 request_data_size;
2901   u32 response_size;
2902
2903   request_data = NULL;
2904   response = NULL;
2905   request = NULL;
2906   send_err = 0;
2907
2908   /* Create memory streams for request/response data.  The entire
2909      request will be stored in secure memory, since it might contain
2910      secret key material.  The response does not have to be stored in
2911      secure memory, since we never give out secret keys.
2912
2913      Note: we only have little secure memory, but there is NO
2914      possibility of DoS here; only trusted clients are allowed to
2915      connect to the agent.  What could happen is that the agent
2916      returns out-of-secure-memory errors on requests in case the
2917      agent's owner floods his own agent with many large messages.
2918      -moritz */
2919
2920   /* Retrieve request.  */
2921   err = stream_read_string (stream_sock, 1, &request_data, &request_data_size);
2922   if (err)
2923     goto out;
2924
2925   if (opt.verbose > 1)
2926     log_info ("received ssh request of length %u\n",
2927               (unsigned int)request_data_size);
2928
2929   if (! request_data_size)
2930     {
2931       send_err = 1;
2932       goto out;
2933       /* Broken request; FIXME.  */
2934     }
2935
2936   request_type = request_data[0];
2937   spec = request_spec_lookup (request_type);
2938   if (! spec)
2939     {
2940       send_err = 1;
2941       goto out;
2942       /* Unknown request; FIXME.  */
2943     }
2944
2945   if (spec->secret_input)
2946     request = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+");
2947   else
2948     request = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+");
2949   if (! request)
2950     {
2951       err = gpg_error_from_syserror ();
2952       goto out;
2953     }
2954   ret = es_setvbuf (request, NULL, _IONBF, 0);
2955   if (ret)
2956     {
2957       err = gpg_error_from_syserror ();
2958       goto out;
2959     }
2960   err = stream_write_data (request, request_data + 1, request_data_size - 1);
2961   if (err)
2962     goto out;
2963   es_rewind (request);
2964
2965   response = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
2966   if (! response)
2967     {
2968       err = gpg_error_from_syserror ();
2969       goto out;
2970     }
2971
2972   if (opt.verbose)
2973     log_info ("ssh request handler for %s (%u) started\n",
2974                spec->identifier, spec->type);
2975
2976   err = (*spec->handler) (ctrl, request, response);
2977
2978   if (opt.verbose)
2979     {
2980       if (err)
2981         log_info ("ssh request handler for %s (%u) failed: %s\n",
2982                   spec->identifier, spec->type, gpg_strerror (err));
2983       else
2984         log_info ("ssh request handler for %s (%u) ready\n",
2985                   spec->identifier, spec->type);
2986     }
2987
2988   if (err)
2989     {
2990       send_err = 1;
2991       goto out;
2992     }
2993
2994   response_size = es_ftell (response);
2995   if (opt.verbose > 1)
2996     log_info ("sending ssh response of length %u\n",
2997               (unsigned int)response_size);
2998
2999   err = es_fseek (response, 0, SEEK_SET);
3000   if (err)
3001     {
3002       send_err = 1;
3003       goto out;
3004     }
3005
3006   err = stream_write_uint32 (stream_sock, response_size);
3007   if (err)
3008     {
3009       send_err = 1;
3010       goto out;
3011     }
3012
3013   err = stream_copy (stream_sock, response);
3014   if (err)
3015     goto out;
3016
3017   err = es_fflush (stream_sock);
3018   if (err)
3019     goto out;
3020
3021  out:
3022
3023   if (err && es_feof (stream_sock))
3024     log_error ("error occured while processing request: %s\n",
3025                gpg_strerror (err));
3026
3027   if (send_err)
3028     {
3029       if (opt.verbose > 1)
3030         log_info ("sending ssh error response\n");
3031       err = stream_write_uint32 (stream_sock, 1);
3032       if (err)
3033         goto leave;
3034       err = stream_write_byte (stream_sock, SSH_RESPONSE_FAILURE);
3035       if (err)
3036         goto leave;
3037     }
3038
3039  leave:
3040
3041   if (request)
3042     es_fclose (request);
3043   if (response)
3044     es_fclose (response);
3045   xfree (request_data);         /* FIXME?  */
3046
3047   return !!err;
3048 }
3049
3050 /* Start serving client on SOCK_CLIENT.  */
3051 void
3052 start_command_handler_ssh (ctrl_t ctrl, gnupg_fd_t sock_client)
3053 {
3054   estream_t stream_sock = NULL;
3055   gpg_error_t err = 0;
3056   int ret;
3057
3058   /* Because the ssh protocol does not send us information about the
3059      the current TTY setting, we resort here to use those from startup
3060      or those explictly set.  */
3061   {
3062     static const char *names[] =
3063       {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
3064     int idx;
3065     const char *value;
3066
3067     for (idx=0; !err && names[idx]; idx++)
3068       if (!session_env_getenv (ctrl->session_env, names[idx])
3069           && (value = session_env_getenv (opt.startup_env, names[idx])))
3070         err = session_env_setenv (ctrl->session_env, names[idx], value);
3071
3072     if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
3073       if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
3074         err = gpg_error_from_syserror ();
3075
3076     if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
3077       if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
3078         err = gpg_error_from_syserror ();
3079
3080     if (err)
3081       {
3082         log_error ("error setting default session environment: %s\n",
3083                    gpg_strerror (err));
3084         goto out;
3085       }
3086   }
3087
3088
3089   /* Create stream from socket.  */
3090   stream_sock = es_fdopen (FD2INT(sock_client), "r+");
3091   if (!stream_sock)
3092     {
3093       err = gpg_error_from_syserror ();
3094       log_error (_("failed to create stream from socket: %s\n"),
3095                  gpg_strerror (err));
3096       goto out;
3097     }
3098   /* We have to disable the estream buffering, because the estream
3099      core doesn't know about secure memory.  */
3100   ret = es_setvbuf (stream_sock, NULL, _IONBF, 0);
3101   if (ret)
3102     {
3103       err = gpg_error_from_syserror ();
3104       log_error ("failed to disable buffering "
3105                  "on socket stream: %s\n", gpg_strerror (err));
3106       goto out;
3107     }
3108
3109   /* Main processing loop. */
3110   while ( !ssh_request_process (ctrl, stream_sock) )
3111     {
3112       /* Check wether we have reached EOF before trying to read
3113          another request.  */
3114       int c;
3115
3116       c = es_fgetc (stream_sock);
3117       if (c == EOF)
3118         break;
3119       es_ungetc (c, stream_sock);
3120     }
3121
3122   /* Reset the SCD in case it has been used. */
3123   agent_reset_scd (ctrl);
3124
3125
3126  out:
3127   if (stream_sock)
3128     es_fclose (stream_sock);
3129 }