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