ssh: Mark unused arg.
[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   (void)spec;
1252
1253   innerlen = 0;
1254   for (i = 0; i < DIM(data); i++)
1255     {
1256       err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &data[i], &data_n[i], mpis[i]);
1257       if (err)
1258         goto out;
1259       innerlen += 4 + data_n[i];
1260     }
1261
1262   err = stream_write_uint32 (stream, innerlen);
1263   if (err)
1264     goto out;
1265
1266   for (i = 0; i < DIM(data); i++)
1267     {
1268       err = stream_write_string (stream, data[i], data_n[i]);
1269       if (err)
1270         goto out;
1271     }
1272
1273  out:
1274   for (i = 0; i < DIM(data); i++)
1275     xfree (data[i]);
1276   return err;
1277 }
1278
1279
1280 /*
1281    S-Expressions.
1282  */
1283
1284
1285 /* This function constructs a new S-Expression for the key identified
1286    by the KEY_SPEC, SECRET, CURVE_NAME, MPIS, and COMMENT, which is to
1287    be stored at R_SEXP.  Returns an error code.  */
1288 static gpg_error_t
1289 sexp_key_construct (gcry_sexp_t *r_sexp,
1290                     ssh_key_type_spec_t key_spec, int secret,
1291                     const char *curve_name, gcry_mpi_t *mpis,
1292                     const char *comment)
1293 {
1294   const char *key_identifier[] = { "public-key", "private-key" };
1295   gpg_error_t err;
1296   gcry_sexp_t sexp_new = NULL;
1297   void *formatbuf = NULL;
1298   void **arg_list = NULL;
1299   int arg_idx;
1300   estream_t format;
1301   const char *elems;
1302   size_t elems_n;
1303   unsigned int i, j;
1304
1305   if (secret)
1306     elems = key_spec.elems_sexp_order;
1307   else
1308     elems = key_spec.elems_key_public;
1309   elems_n = strlen (elems);
1310
1311   format = es_fopenmem (0, "a+b");
1312   if (!format)
1313     {
1314       err = gpg_error_from_syserror ();
1315       goto out;
1316     }
1317
1318   /* Key identifier, algorithm identifier, mpis, comment, and a NULL
1319      as a safeguard. */
1320   arg_list = xtrymalloc (sizeof (*arg_list) * (2 + 1 + elems_n + 1 + 1));
1321   if (!arg_list)
1322     {
1323       err = gpg_error_from_syserror ();
1324       goto out;
1325     }
1326   arg_idx = 0;
1327
1328   es_fputs ("(%s(%s", format);
1329   arg_list[arg_idx++] = &key_identifier[secret];
1330   arg_list[arg_idx++] = &key_spec.identifier;
1331   if (curve_name)
1332     {
1333       es_fputs ("(curve%s)", format);
1334       arg_list[arg_idx++] = &curve_name;
1335     }
1336
1337   for (i = 0; i < elems_n; i++)
1338     {
1339       es_fprintf (format, "(%c%%m)", elems[i]);
1340       if (secret)
1341         {
1342           for (j = 0; j < elems_n; j++)
1343             if (key_spec.elems_key_secret[j] == elems[i])
1344               break;
1345         }
1346       else
1347         j = i;
1348       arg_list[arg_idx++] = &mpis[j];
1349     }
1350   es_fputs (")(comment%s))", format);
1351   arg_list[arg_idx++] = &comment;
1352   arg_list[arg_idx] = NULL;
1353
1354   es_putc (0, format);
1355   if (es_ferror (format))
1356     {
1357       err = gpg_error_from_syserror ();
1358       goto out;
1359     }
1360   if (es_fclose_snatch (format, &formatbuf, NULL))
1361     {
1362       err = gpg_error_from_syserror ();
1363       goto out;
1364     }
1365   format = NULL;
1366
1367   err = gcry_sexp_build_array (&sexp_new, NULL, formatbuf, arg_list);
1368   if (err)
1369     goto out;
1370
1371   *r_sexp = sexp_new;
1372   err = 0;
1373
1374  out:
1375   es_fclose (format);
1376   xfree (arg_list);
1377   xfree (formatbuf);
1378
1379   return err;
1380 }
1381
1382
1383 /* This functions breaks up the key contained in the S-Expression SEXP
1384    according to KEY_SPEC.  The MPIs are bundled in a newly create
1385    list, which is to be stored in MPIS; a newly allocated string
1386    holding the curve name may be stored at RCURVE, and a comment will
1387    be stored at COMMENT; SECRET will be filled with a boolean flag
1388    specifying what kind of key it is.  Returns an error code.  */
1389 static gpg_error_t
1390 sexp_key_extract (gcry_sexp_t sexp,
1391                   ssh_key_type_spec_t key_spec, int *secret,
1392                   gcry_mpi_t **mpis, char **r_curve, char **comment)
1393 {
1394   gpg_error_t err = 0;
1395   gcry_sexp_t value_list = NULL;
1396   gcry_sexp_t value_pair = NULL;
1397   gcry_sexp_t comment_list = NULL;
1398   unsigned int i;
1399   char *comment_new = NULL;
1400   const char *data;
1401   size_t data_n;
1402   int is_secret;
1403   size_t elems_n;
1404   const char *elems;
1405   gcry_mpi_t *mpis_new = NULL;
1406   gcry_mpi_t mpi;
1407   char *curve_name = NULL;
1408
1409   data = gcry_sexp_nth_data (sexp, 0, &data_n);
1410   if (! data)
1411     {
1412       err = gpg_error (GPG_ERR_INV_SEXP);
1413       goto out;
1414     }
1415
1416   if ((data_n == 10 && !strncmp (data, "public-key", 10))
1417       || (data_n == 21 && !strncmp (data, "protected-private-key", 21))
1418       || (data_n == 20 && !strncmp (data, "shadowed-private-key", 20)))
1419     {
1420       is_secret = 0;
1421       elems = key_spec.elems_key_public;
1422     }
1423   else if (data_n == 11 && !strncmp (data, "private-key", 11))
1424     {
1425       is_secret = 1;
1426       elems = key_spec.elems_key_secret;
1427     }
1428   else
1429     {
1430       err = gpg_error (GPG_ERR_INV_SEXP);
1431       goto out;
1432     }
1433
1434   elems_n = strlen (elems);
1435   mpis_new = xtrycalloc (elems_n + 1, sizeof *mpis_new );
1436   if (!mpis_new)
1437     {
1438       err = gpg_error_from_syserror ();
1439       goto out;
1440     }
1441
1442   value_list = gcry_sexp_find_token (sexp, key_spec.identifier, 0);
1443   if (! value_list)
1444     {
1445       err = gpg_error (GPG_ERR_INV_SEXP);
1446       goto out;
1447     }
1448
1449   for (i = 0; i < elems_n; i++)
1450     {
1451       value_pair = gcry_sexp_find_token (value_list, elems + i, 1);
1452       if (! value_pair)
1453         {
1454           err = gpg_error (GPG_ERR_INV_SEXP);
1455           break;
1456         }
1457
1458       /* Note that we need to use STD format; i.e. prepend a 0x00 to
1459          indicate a positive number if the high bit is set. */
1460       mpi = gcry_sexp_nth_mpi (value_pair, 1, GCRYMPI_FMT_STD);
1461       if (! mpi)
1462         {
1463           err = gpg_error (GPG_ERR_INV_SEXP);
1464           break;
1465         }
1466       mpis_new[i] = mpi;
1467       gcry_sexp_release (value_pair);
1468       value_pair = NULL;
1469     }
1470   if (err)
1471     goto out;
1472
1473   if ((key_spec.flags & SPEC_FLAG_IS_ECDSA))
1474     {
1475       /* Parse the "curve" parameter.  We currently expect the curve
1476          name for ECC and not the parameters of the curve.  This can
1477          easily be changed but then we need to find the curve name
1478          from the parameters using gcry_pk_get_curve.  */
1479       const char *mapped;
1480
1481       value_pair = gcry_sexp_find_token (value_list, "curve", 5);
1482       if (!value_pair)
1483         {
1484           err = gpg_error (GPG_ERR_INV_CURVE);
1485           goto out;
1486         }
1487       curve_name = gcry_sexp_nth_string (value_pair, 1);
1488       if (!curve_name)
1489         {
1490           err = gpg_error (GPG_ERR_INV_CURVE); /* (Or out of core.)  */
1491           goto out;
1492         }
1493
1494       /* Fixme: The mapping should be done by using gcry_pk_get_curve
1495          et al to iterate over all name aliases.  */
1496       if (!strcmp (curve_name, "NIST P-256"))
1497         mapped = "nistp256";
1498       else if (!strcmp (curve_name, "NIST P-384"))
1499         mapped = "nistp384";
1500       else if (!strcmp (curve_name, "NIST P-521"))
1501         mapped = "nistp521";
1502       else
1503         mapped = NULL;
1504       if (mapped)
1505         {
1506           xfree (curve_name);
1507           curve_name = xtrystrdup (mapped);
1508           if (!curve_name)
1509             {
1510               err = gpg_error_from_syserror ();
1511               goto out;
1512             }
1513         }
1514       gcry_sexp_release (value_pair);
1515       value_pair = NULL;
1516     }
1517
1518   /* We do not require a comment sublist to be present here.  */
1519   data = NULL;
1520   data_n = 0;
1521
1522   comment_list = gcry_sexp_find_token (sexp, "comment", 0);
1523   if (comment_list)
1524     data = gcry_sexp_nth_data (comment_list, 1, &data_n);
1525   if (! data)
1526     {
1527       data = "(none)";
1528       data_n = 6;
1529     }
1530
1531   comment_new = make_cstring (data, data_n);
1532   if (! comment_new)
1533     {
1534       err = gpg_error_from_syserror ();
1535       goto out;
1536     }
1537
1538   if (secret)
1539     *secret = is_secret;
1540   *mpis = mpis_new;
1541   *comment = comment_new;
1542   *r_curve = curve_name;
1543
1544  out:
1545
1546   gcry_sexp_release (value_list);
1547   gcry_sexp_release (value_pair);
1548   gcry_sexp_release (comment_list);
1549
1550   if (err)
1551     {
1552       xfree (curve_name);
1553       xfree (comment_new);
1554       mpint_list_free (mpis_new);
1555     }
1556
1557   return err;
1558 }
1559
1560 /* Extract the car from SEXP, and create a newly created C-string
1561    which is to be stored in IDENTIFIER.  */
1562 static gpg_error_t
1563 sexp_extract_identifier (gcry_sexp_t sexp, char **identifier)
1564 {
1565   char *identifier_new;
1566   gcry_sexp_t sublist;
1567   const char *data;
1568   size_t data_n;
1569   gpg_error_t err;
1570
1571   identifier_new = NULL;
1572   err = 0;
1573
1574   sublist = gcry_sexp_nth (sexp, 1);
1575   if (! sublist)
1576     {
1577       err = gpg_error (GPG_ERR_INV_SEXP);
1578       goto out;
1579     }
1580
1581   data = gcry_sexp_nth_data (sublist, 0, &data_n);
1582   if (! data)
1583     {
1584       err = gpg_error (GPG_ERR_INV_SEXP);
1585       goto out;
1586     }
1587
1588   identifier_new = make_cstring (data, data_n);
1589   if (! identifier_new)
1590     {
1591       err = gpg_err_code_from_errno (errno);
1592       goto out;
1593     }
1594
1595   *identifier = identifier_new;
1596
1597  out:
1598
1599   gcry_sexp_release (sublist);
1600
1601   return err;
1602 }
1603
1604 \f
1605
1606 /*
1607
1608   Key I/O.
1609
1610 */
1611
1612 /* Search for a key specification entry.  If SSH_NAME is not NULL,
1613    search for an entry whose "ssh_name" is equal to SSH_NAME;
1614    otherwise, search for an entry whose "name" is equal to NAME.
1615    Store found entry in SPEC on success, return error otherwise.  */
1616 static gpg_error_t
1617 ssh_key_type_lookup (const char *ssh_name, const char *name,
1618                      ssh_key_type_spec_t *spec)
1619 {
1620   gpg_error_t err;
1621   unsigned int i;
1622
1623   for (i = 0; i < DIM (ssh_key_types); i++)
1624     if ((ssh_name && (! strcmp (ssh_name, ssh_key_types[i].ssh_identifier)))
1625         || (name && (! strcmp (name, ssh_key_types[i].identifier))))
1626       break;
1627
1628   if (i == DIM (ssh_key_types))
1629     err = gpg_error (GPG_ERR_NOT_FOUND);
1630   else
1631     {
1632       *spec = ssh_key_types[i];
1633       err = 0;
1634     }
1635
1636   return err;
1637 }
1638
1639
1640 /* Lookup the ssh-identifier for the ECC curve CURVE_NAME.  Returns
1641    NULL if not found.  */
1642 static const char *
1643 ssh_identifier_from_curve_name (const char *curve_name)
1644 {
1645   int i;
1646
1647   for (i = 0; i < DIM (ssh_key_types); i++)
1648     if (ssh_key_types[i].curve_name
1649         && !strcmp (ssh_key_types[i].curve_name, curve_name))
1650       return ssh_key_types[i].ssh_identifier;
1651
1652   return NULL;
1653 }
1654
1655
1656
1657 /* Receive a key from STREAM, according to the key specification given
1658    as KEY_SPEC.  Depending on SECRET, receive a secret or a public
1659    key.  If READ_COMMENT is true, receive a comment string as well.
1660    Constructs a new S-Expression from received data and stores it in
1661    KEY_NEW.  Returns zero on success or an error code.  */
1662 static gpg_error_t
1663 ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret,
1664                  int read_comment, ssh_key_type_spec_t *key_spec)
1665 {
1666   gpg_error_t err;
1667   char *key_type = NULL;
1668   char *comment = NULL;
1669   gcry_sexp_t key = NULL;
1670   ssh_key_type_spec_t spec;
1671   gcry_mpi_t *mpi_list = NULL;
1672   const char *elems;
1673   char *curve_name = NULL;
1674
1675
1676
1677   err = stream_read_cstring (stream, &key_type);
1678   if (err)
1679     goto out;
1680
1681   err = ssh_key_type_lookup (key_type, NULL, &spec);
1682   if (err)
1683     goto out;
1684
1685   if ((spec.flags & SPEC_FLAG_IS_ECDSA))
1686     {
1687       /* The format of an ECDSA key is:
1688        *   string       key_type ("ecdsa-sha2-nistp256" |
1689        *                          "ecdsa-sha2-nistp384" |
1690        *                          "ecdsa-sha2-nistp521" )
1691        *   string       ecdsa_curve_name
1692        *   string       ecdsa_public_key
1693        *   mpint        ecdsa_private
1694        *
1695        * Note that we use the mpint reader instead of the string
1696        * reader for ecsa_public_key.
1697        */
1698       unsigned char *buffer;
1699       const char *mapped;
1700
1701       err = stream_read_string (stream, 0, &buffer, NULL);
1702       if (err)
1703         goto out;
1704       curve_name = buffer;
1705       /* Fixme: Check that curve_name matches the keytype.  */
1706       /* Because Libgcrypt < 1.6 has no support for the "nistpNNN"
1707          curve names, we need to translate them here to Libgcrypt's
1708          native names.  */
1709       if (!strcmp (curve_name, "nistp256"))
1710         mapped = "NIST P-256";
1711       else if (!strcmp (curve_name, "nistp384"))
1712         mapped = "NIST P-384";
1713       else if (!strcmp (curve_name, "nistp521"))
1714         mapped = "NIST P-521";
1715       else
1716         mapped = NULL;
1717       if (mapped)
1718         {
1719           xfree (curve_name);
1720           curve_name = xtrystrdup (mapped);
1721           if (!curve_name)
1722             {
1723               err = gpg_error_from_syserror ();
1724               goto out;
1725             }
1726         }
1727   }
1728
1729   err = ssh_receive_mpint_list (stream, secret, spec, &mpi_list);
1730   if (err)
1731     goto out;
1732
1733   if (read_comment)
1734     {
1735       err = stream_read_cstring (stream, &comment);
1736       if (err)
1737         goto out;
1738     }
1739
1740   if (secret)
1741     elems = spec.elems_key_secret;
1742   else
1743     elems = spec.elems_key_public;
1744
1745   if (spec.key_modifier)
1746     {
1747       err = (*spec.key_modifier) (elems, mpi_list);
1748       if (err)
1749         goto out;
1750     }
1751
1752   err = sexp_key_construct (&key, spec, secret, curve_name, mpi_list,
1753                             comment? comment:"");
1754   if (err)
1755     goto out;
1756
1757   if (key_spec)
1758     *key_spec = spec;
1759   *key_new = key;
1760
1761  out:
1762   mpint_list_free (mpi_list);
1763   xfree (curve_name);
1764   xfree (key_type);
1765   xfree (comment);
1766
1767   return err;
1768 }
1769
1770 /* Converts a key of type TYPE, whose key material is given in MPIS,
1771    into a newly created binary blob, which is to be stored in
1772    BLOB/BLOB_SIZE.  Returns zero on success or an error code.  */
1773 static gpg_error_t
1774 ssh_convert_key_to_blob (unsigned char **blob, size_t *blob_size,
1775                          ssh_key_type_spec_t *spec,
1776                          const char *curve_name, gcry_mpi_t *mpis)
1777 {
1778   unsigned char *blob_new;
1779   long int blob_size_new;
1780   estream_t stream;
1781   gpg_error_t err;
1782   unsigned int i;
1783
1784   *blob = NULL;
1785   *blob_size = 0;
1786
1787   blob_new = NULL;
1788   stream = NULL;
1789   err = 0;
1790
1791   stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1792   if (! stream)
1793     {
1794       err = gpg_error_from_syserror ();
1795       goto out;
1796     }
1797
1798   if ((spec->flags & SPEC_FLAG_IS_ECDSA) && curve_name)
1799     {
1800       const char *sshname = ssh_identifier_from_curve_name (curve_name);
1801       if (!curve_name)
1802         {
1803           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1804           goto out;
1805         }
1806       err = stream_write_cstring (stream, sshname);
1807       if (err)
1808         goto out;
1809       err = stream_write_cstring (stream, curve_name);
1810       if (err)
1811         goto out;
1812     }
1813   else
1814     {
1815       err = stream_write_cstring (stream, spec->ssh_identifier);
1816       if (err)
1817         goto out;
1818     }
1819
1820   for (i = 0; mpis[i]; i++)
1821     if ((err = stream_write_mpi (stream, mpis[i])))
1822       goto out;
1823
1824   blob_size_new = es_ftell (stream);
1825   if (blob_size_new == -1)
1826     {
1827       err = gpg_error_from_syserror ();
1828       goto out;
1829     }
1830
1831   err = es_fseek (stream, 0, SEEK_SET);
1832   if (err)
1833     goto out;
1834
1835   blob_new = xtrymalloc (blob_size_new);
1836   if (! blob_new)
1837     {
1838       err = gpg_error_from_syserror ();
1839       goto out;
1840     }
1841
1842   err = stream_read_data (stream, blob_new, blob_size_new);
1843   if (err)
1844     goto out;
1845
1846   *blob = blob_new;
1847   *blob_size = blob_size_new;
1848
1849  out:
1850
1851   if (stream)
1852     es_fclose (stream);
1853   if (err)
1854     xfree (blob_new);
1855
1856   return err;
1857 }
1858
1859
1860 /* Write the public key KEY_PUBLIC to STREAM in SSH key format.  If
1861    OVERRIDE_COMMENT is not NULL, it will be used instead of the
1862    comment stored in the key.  */
1863 static gpg_error_t
1864 ssh_send_key_public (estream_t stream,
1865                      gcry_sexp_t key_public,
1866                      const char *override_comment)
1867 {
1868   ssh_key_type_spec_t spec;
1869   gcry_mpi_t *mpi_list = NULL;
1870   char *key_type = NULL;
1871   char *curve;
1872   char *comment = NULL;
1873   unsigned char *blob = NULL;
1874   size_t blob_n;
1875   gpg_error_t err;
1876
1877   err = sexp_extract_identifier (key_public, &key_type);
1878   if (err)
1879     goto out;
1880
1881   err = ssh_key_type_lookup (NULL, key_type, &spec);
1882   if (err)
1883     goto out;
1884
1885   err = sexp_key_extract (key_public, spec, NULL, &mpi_list, &curve, &comment);
1886   if (err)
1887     goto out;
1888
1889   err = ssh_convert_key_to_blob (&blob, &blob_n, &spec, curve, mpi_list);
1890   if (err)
1891     goto out;
1892
1893   err = stream_write_string (stream, blob, blob_n);
1894   if (err)
1895     goto out;
1896
1897   err = stream_write_cstring (stream,
1898                               override_comment? override_comment : comment);
1899
1900  out:
1901
1902   mpint_list_free (mpi_list);
1903   xfree (curve);
1904   xfree (comment);
1905   xfree (key_type);
1906   xfree (blob);
1907
1908   return err;
1909 }
1910
1911 /* Read a public key out of BLOB/BLOB_SIZE according to the key
1912    specification given as KEY_SPEC, storing the new key in KEY_PUBLIC.
1913    Returns zero on success or an error code.  */
1914 static gpg_error_t
1915 ssh_read_key_public_from_blob (unsigned char *blob, size_t blob_size,
1916                                gcry_sexp_t *key_public,
1917                                ssh_key_type_spec_t *key_spec)
1918 {
1919   estream_t blob_stream;
1920   gpg_error_t err;
1921
1922   err = 0;
1923
1924   blob_stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1925   if (! blob_stream)
1926     {
1927       err = gpg_error_from_syserror ();
1928       goto out;
1929     }
1930
1931   err = stream_write_data (blob_stream, blob, blob_size);
1932   if (err)
1933     goto out;
1934
1935   err = es_fseek (blob_stream, 0, SEEK_SET);
1936   if (err)
1937     goto out;
1938
1939   err = ssh_receive_key (blob_stream, key_public, 0, 0, key_spec);
1940
1941  out:
1942
1943   if (blob_stream)
1944     es_fclose (blob_stream);
1945
1946   return err;
1947 }
1948
1949 \f
1950
1951 /* This function calculates the key grip for the key contained in the
1952    S-Expression KEY and writes it to BUFFER, which must be large
1953    enough to hold it.  Returns usual error code.  */
1954 static gpg_error_t
1955 ssh_key_grip (gcry_sexp_t key, unsigned char *buffer)
1956 {
1957   if (!gcry_pk_get_keygrip (key, buffer))
1958     {
1959       gpg_error_t err = gcry_pk_testkey (key);
1960       return err? err : gpg_error (GPG_ERR_INTERNAL);
1961     }
1962
1963   return 0;
1964 }
1965
1966
1967 /* Converts the secret key KEY_SECRET into a public key, storing it in
1968    KEY_PUBLIC.  SPEC is the according key specification.  Returns zero
1969    on success or an error code.  */
1970 static gpg_error_t
1971 key_secret_to_public (gcry_sexp_t *key_public,
1972                       ssh_key_type_spec_t spec, gcry_sexp_t key_secret)
1973 {
1974   char *curve;
1975   char *comment;
1976   gcry_mpi_t *mpis;
1977   gpg_error_t err;
1978   int is_secret;
1979
1980   comment = NULL;
1981   mpis = NULL;
1982
1983   err = sexp_key_extract (key_secret, spec, &is_secret, &mpis,
1984                           &curve, &comment);
1985   if (err)
1986     goto out;
1987
1988   err = sexp_key_construct (key_public, spec, 0, curve, mpis, comment);
1989
1990  out:
1991
1992   mpint_list_free (mpis);
1993   xfree (comment);
1994   xfree (curve);
1995
1996   return err;
1997 }
1998
1999
2000 /* Check whether a smartcard is available and whether it has a usable
2001    key.  Store a copy of that key at R_PK and return 0.  If no key is
2002    available store NULL at R_PK and return an error code.  If CARDSN
2003    is not NULL, a string with the serial number of the card will be
2004    a malloced and stored there. */
2005 static gpg_error_t
2006 card_key_available (ctrl_t ctrl, gcry_sexp_t *r_pk, char **cardsn)
2007 {
2008   gpg_error_t err;
2009   char *authkeyid;
2010   char *serialno = NULL;
2011   unsigned char *pkbuf;
2012   size_t pkbuflen;
2013   gcry_sexp_t s_pk;
2014   unsigned char grip[20];
2015
2016   *r_pk = NULL;
2017   if (cardsn)
2018     *cardsn = NULL;
2019
2020   /* First see whether a card is available and whether the application
2021      is supported.  */
2022   err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
2023   if ( gpg_err_code (err) == GPG_ERR_CARD_REMOVED )
2024     {
2025       /* Ask for the serial number to reset the card.  */
2026       err = agent_card_serialno (ctrl, &serialno);
2027       if (err)
2028         {
2029           if (opt.verbose)
2030             log_info (_("error getting serial number of card: %s\n"),
2031                       gpg_strerror (err));
2032           return err;
2033         }
2034       log_info (_("detected card with S/N: %s\n"), serialno);
2035       err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
2036     }
2037   if (err)
2038     {
2039       log_error (_("error getting default authentication keyID of card: %s\n"),
2040                  gpg_strerror (err));
2041       xfree (serialno);
2042       return err;
2043     }
2044
2045   /* Get the S/N if we don't have it yet.  Use the fast getattr method.  */
2046   if (!serialno && (err = agent_card_getattr (ctrl, "SERIALNO", &serialno)) )
2047     {
2048       log_error (_("error getting serial number of card: %s\n"),
2049                  gpg_strerror (err));
2050       xfree (authkeyid);
2051       return err;
2052     }
2053
2054   /* Read the public key.  */
2055   err = agent_card_readkey (ctrl, authkeyid, &pkbuf);
2056   if (err)
2057     {
2058       if (opt.verbose)
2059         log_info (_("no suitable card key found: %s\n"), gpg_strerror (err));
2060       xfree (serialno);
2061       xfree (authkeyid);
2062       return err;
2063     }
2064
2065   pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
2066   err = gcry_sexp_sscan (&s_pk, NULL, (char*)pkbuf, pkbuflen);
2067   if (err)
2068     {
2069       log_error ("failed to build S-Exp from received card key: %s\n",
2070                  gpg_strerror (err));
2071       xfree (pkbuf);
2072       xfree (serialno);
2073       xfree (authkeyid);
2074       return err;
2075     }
2076
2077   err = ssh_key_grip (s_pk, grip);
2078   if (err)
2079     {
2080       log_debug ("error computing keygrip from received card key: %s\n",
2081                  gcry_strerror (err));
2082       xfree (pkbuf);
2083       gcry_sexp_release (s_pk);
2084       xfree (serialno);
2085       xfree (authkeyid);
2086       return err;
2087     }
2088
2089   if ( agent_key_available (grip) )
2090     {
2091       /* (Shadow)-key is not available in our key storage.  */
2092       unsigned char *shadow_info;
2093       unsigned char *tmp;
2094
2095       shadow_info = make_shadow_info (serialno, authkeyid);
2096       if (!shadow_info)
2097         {
2098           err = gpg_error_from_syserror ();
2099           xfree (pkbuf);
2100           gcry_sexp_release (s_pk);
2101           xfree (serialno);
2102           xfree (authkeyid);
2103           return err;
2104         }
2105       err = agent_shadow_key (pkbuf, shadow_info, &tmp);
2106       xfree (shadow_info);
2107       if (err)
2108         {
2109           log_error (_("shadowing the key failed: %s\n"), gpg_strerror (err));
2110           xfree (pkbuf);
2111           gcry_sexp_release (s_pk);
2112           xfree (serialno);
2113           xfree (authkeyid);
2114           return err;
2115         }
2116       xfree (pkbuf);
2117       pkbuf = tmp;
2118       pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
2119       assert (pkbuflen);
2120
2121       err = agent_write_private_key (grip, pkbuf, pkbuflen, 0);
2122       if (err)
2123         {
2124           log_error (_("error writing key: %s\n"), gpg_strerror (err));
2125           xfree (pkbuf);
2126           gcry_sexp_release (s_pk);
2127           xfree (serialno);
2128           xfree (authkeyid);
2129           return err;
2130         }
2131     }
2132
2133   if (cardsn)
2134     {
2135       char *dispsn;
2136
2137       /* If the card handler is able to return a short serialnumber,
2138          use that one, else use the complete serialno. */
2139       if (!agent_card_getattr (ctrl, "$DISPSERIALNO", &dispsn))
2140         {
2141           *cardsn = xtryasprintf ("cardno:%s", dispsn);
2142           xfree (dispsn);
2143         }
2144       else
2145         *cardsn = xtryasprintf ("cardno:%s", serialno);
2146       if (!*cardsn)
2147         {
2148           err = gpg_error_from_syserror ();
2149           xfree (pkbuf);
2150           gcry_sexp_release (s_pk);
2151           xfree (serialno);
2152           xfree (authkeyid);
2153           return err;
2154         }
2155     }
2156
2157   xfree (pkbuf);
2158   xfree (serialno);
2159   xfree (authkeyid);
2160   *r_pk = s_pk;
2161   return 0;
2162 }
2163
2164
2165 \f
2166
2167 /*
2168
2169   Request handler.  Each handler is provided with a CTRL context, a
2170   REQUEST object and a RESPONSE object.  The actual request is to be
2171   read from REQUEST, the response needs to be written to RESPONSE.
2172
2173 */
2174
2175
2176 /* Handler for the "request_identities" command.  */
2177 static gpg_error_t
2178 ssh_handler_request_identities (ctrl_t ctrl,
2179                                 estream_t request, estream_t response)
2180 {
2181   ssh_key_type_spec_t spec;
2182   char *key_fname = NULL;
2183   char *fnameptr;
2184   u32 key_counter;
2185   estream_t key_blobs;
2186   gcry_sexp_t key_secret;
2187   gcry_sexp_t key_public;
2188   gpg_error_t err;
2189   int ret;
2190   control_file_t cf = NULL;
2191   char *cardsn;
2192   gpg_error_t ret_err;
2193
2194   (void)request;
2195
2196   /* Prepare buffer stream.  */
2197
2198   key_secret = NULL;
2199   key_public = NULL;
2200   key_counter = 0;
2201   err = 0;
2202
2203   key_blobs = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
2204   if (! key_blobs)
2205     {
2206       err = gpg_error_from_syserror ();
2207       goto out;
2208     }
2209
2210   /* First check whether a key is currently available in the card
2211      reader - this should be allowed even without being listed in
2212      sshcontrol. */
2213
2214   if (!opt.disable_scdaemon
2215       && !card_key_available (ctrl, &key_public, &cardsn))
2216     {
2217       err = ssh_send_key_public (key_blobs, key_public, cardsn);
2218       gcry_sexp_release (key_public);
2219       key_public = NULL;
2220       xfree (cardsn);
2221       if (err)
2222         goto out;
2223
2224       key_counter++;
2225     }
2226
2227
2228   /* Prepare buffer for key name construction.  */
2229   {
2230     char *dname;
2231
2232     dname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, NULL);
2233     if (!dname)
2234       {
2235         err = gpg_err_code_from_syserror ();
2236         goto out;
2237       }
2238
2239     key_fname = xtrymalloc (strlen (dname) + 1 + 40 + 4 + 1);
2240     if (!key_fname)
2241       {
2242         err = gpg_err_code_from_syserror ();
2243         xfree (dname);
2244         goto out;
2245       }
2246     fnameptr = stpcpy (stpcpy (key_fname, dname), "/");
2247     xfree (dname);
2248   }
2249
2250   /* Then look at all the registered and non-disabled keys. */
2251   err = open_control_file (&cf, 0);
2252   if (err)
2253     goto out;
2254
2255   while (!read_control_file_item (cf))
2256     {
2257       if (!cf->item.valid)
2258         continue; /* Should not happen.  */
2259       if (cf->item.disabled)
2260         continue;
2261       assert (strlen (cf->item.hexgrip) == 40);
2262
2263       stpcpy (stpcpy (fnameptr, cf->item.hexgrip), ".key");
2264
2265       /* Read file content.  */
2266       {
2267         unsigned char *buffer;
2268         size_t buffer_n;
2269
2270         err = file_to_buffer (key_fname, &buffer, &buffer_n);
2271         if (err)
2272           {
2273             log_error ("%s:%d: key '%s' skipped: %s\n",
2274                        cf->fname, cf->lnr, cf->item.hexgrip,
2275                        gpg_strerror (err));
2276             continue;
2277           }
2278
2279         err = gcry_sexp_sscan (&key_secret, NULL, (char*)buffer, buffer_n);
2280         xfree (buffer);
2281         if (err)
2282           goto out;
2283       }
2284
2285       {
2286         char *key_type = NULL;
2287
2288         err = sexp_extract_identifier (key_secret, &key_type);
2289         if (err)
2290           goto out;
2291
2292         err = ssh_key_type_lookup (NULL, key_type, &spec);
2293         xfree (key_type);
2294         if (err)
2295           goto out;
2296       }
2297
2298       err = key_secret_to_public (&key_public, spec, key_secret);
2299       if (err)
2300         goto out;
2301
2302       gcry_sexp_release (key_secret);
2303       key_secret = NULL;
2304
2305       err = ssh_send_key_public (key_blobs, key_public, NULL);
2306       if (err)
2307         goto out;
2308
2309       gcry_sexp_release (key_public);
2310       key_public = NULL;
2311
2312       key_counter++;
2313     }
2314   err = 0;
2315
2316   ret = es_fseek (key_blobs, 0, SEEK_SET);
2317   if (ret)
2318     {
2319       err = gpg_error_from_syserror ();
2320       goto out;
2321     }
2322
2323  out:
2324   /* Send response.  */
2325
2326   gcry_sexp_release (key_secret);
2327   gcry_sexp_release (key_public);
2328
2329   if (!err)
2330     {
2331       ret_err = stream_write_byte (response, SSH_RESPONSE_IDENTITIES_ANSWER);
2332       if (!ret_err)
2333         ret_err = stream_write_uint32 (response, key_counter);
2334       if (!ret_err)
2335         ret_err = stream_copy (response, key_blobs);
2336     }
2337   else
2338     {
2339       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2340     }
2341
2342   es_fclose (key_blobs);
2343   close_control_file (cf);
2344   xfree (key_fname);
2345
2346   return ret_err;
2347 }
2348
2349
2350 /* This function hashes the data contained in DATA of size DATA_N
2351    according to the message digest algorithm specified by MD_ALGORITHM
2352    and writes the message digest to HASH, which needs to large enough
2353    for the digest.  */
2354 static gpg_error_t
2355 data_hash (unsigned char *data, size_t data_n,
2356            int md_algorithm, unsigned char *hash)
2357 {
2358   gcry_md_hash_buffer (md_algorithm, hash, data, data_n);
2359
2360   return 0;
2361 }
2362
2363 /* This function signs the data contained in CTRL, stores the created
2364    signature in newly allocated memory in SIG and it's size in SIG_N;
2365    SIG_ENCODER is the signature encoder to use.  */
2366 static gpg_error_t
2367 data_sign (ctrl_t ctrl, ssh_key_type_spec_t *spec,
2368            unsigned char **sig, size_t *sig_n)
2369 {
2370   gpg_error_t err;
2371   gcry_sexp_t signature_sexp = NULL;
2372   estream_t stream = NULL;
2373   gcry_sexp_t valuelist = NULL;
2374   gcry_sexp_t sublist = NULL;
2375   gcry_mpi_t sig_value = NULL;
2376   unsigned char *sig_blob = NULL;
2377   size_t sig_blob_n = 0;
2378   int ret;
2379   unsigned int i;
2380   const char *elems;
2381   size_t elems_n;
2382   gcry_mpi_t *mpis = NULL;
2383   char hexgrip[40+1];
2384
2385   *sig = NULL;
2386   *sig_n = 0;
2387
2388   /* Quick check to see whether we have a valid keygrip and convert it
2389      to hex.  */
2390   if (!ctrl->have_keygrip)
2391     {
2392       err = gpg_error (GPG_ERR_NO_SECKEY);
2393       goto out;
2394     }
2395   bin2hex (ctrl->keygrip, 20, hexgrip);
2396
2397   /* Ask for confirmation if needed.  */
2398   if (confirm_flag_from_sshcontrol (hexgrip))
2399     {
2400       gcry_sexp_t key;
2401       char *fpr, *prompt;
2402       char *comment = NULL;
2403
2404       err = agent_raw_key_from_file (ctrl, ctrl->keygrip, &key);
2405       if (err)
2406         goto out;
2407       err = ssh_get_fingerprint_string (key, &fpr);
2408       if (!err)
2409         {
2410           gcry_sexp_t tmpsxp = gcry_sexp_find_token (key, "comment", 0);
2411           if (tmpsxp)
2412             comment = gcry_sexp_nth_string (tmpsxp, 1);
2413           gcry_sexp_release (tmpsxp);
2414         }
2415       gcry_sexp_release (key);
2416       if (err)
2417         goto out;
2418       prompt = xtryasprintf (_("An ssh process requested the use of key%%0A"
2419                                "  %s%%0A"
2420                                "  (%s)%%0A"
2421                                "Do you want to allow this?"),
2422                              fpr, comment? comment:"");
2423       xfree (fpr);
2424       gcry_free (comment);
2425       err = agent_get_confirmation (ctrl, prompt, _("Allow"), _("Deny"), 0);
2426       xfree (prompt);
2427       if (err)
2428         goto out;
2429     }
2430
2431   /* Create signature.  */
2432   ctrl->use_auth_call = 1;
2433   err = agent_pksign_do (ctrl,
2434                          _("Please enter the passphrase "
2435                            "for the ssh key%%0A  %F%%0A  (%c)"),
2436                          &signature_sexp,
2437                          CACHE_MODE_SSH, ttl_from_sshcontrol);
2438   ctrl->use_auth_call = 0;
2439   if (err)
2440     goto out;
2441
2442   valuelist = gcry_sexp_nth (signature_sexp, 1);
2443   if (! valuelist)
2444     {
2445       err = gpg_error (GPG_ERR_INV_SEXP);
2446       goto out;
2447     }
2448
2449   stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
2450   if (! stream)
2451     {
2452       err = gpg_error_from_syserror ();
2453       goto out;
2454     }
2455
2456   err = stream_write_cstring (stream, spec->ssh_identifier);
2457   if (err)
2458     goto out;
2459
2460   elems = spec->elems_signature;
2461   elems_n = strlen (elems);
2462
2463   mpis = xtrycalloc (elems_n + 1, sizeof *mpis);
2464   if (!mpis)
2465     {
2466       err = gpg_error_from_syserror ();
2467       goto out;
2468     }
2469
2470   for (i = 0; i < elems_n; i++)
2471     {
2472       sublist = gcry_sexp_find_token (valuelist, spec->elems_signature + i, 1);
2473       if (! sublist)
2474         {
2475           err = gpg_error (GPG_ERR_INV_SEXP);
2476           break;
2477         }
2478
2479       sig_value = gcry_sexp_nth_mpi (sublist, 1, GCRYMPI_FMT_USG);
2480       if (! sig_value)
2481         {
2482           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
2483           break;
2484         }
2485       gcry_sexp_release (sublist);
2486       sublist = NULL;
2487
2488       mpis[i] = sig_value;
2489     }
2490   if (err)
2491     goto out;
2492
2493   err = spec->signature_encoder (spec, stream, mpis);
2494   if (err)
2495     goto out;
2496
2497   sig_blob_n = es_ftell (stream);
2498   if (sig_blob_n == -1)
2499     {
2500       err = gpg_error_from_syserror ();
2501       goto out;
2502     }
2503
2504   sig_blob = xtrymalloc (sig_blob_n);
2505   if (! sig_blob)
2506     {
2507       err = gpg_error_from_syserror ();
2508       goto out;
2509     }
2510
2511   ret = es_fseek (stream, 0, SEEK_SET);
2512   if (ret)
2513     {
2514       err = gpg_error_from_syserror ();
2515       goto out;
2516     }
2517
2518   err = stream_read_data (stream, sig_blob, sig_blob_n);
2519   if (err)
2520     goto out;
2521
2522   *sig = sig_blob;
2523   *sig_n = sig_blob_n;
2524
2525  out:
2526
2527   if (err)
2528     xfree (sig_blob);
2529
2530   if (stream)
2531     es_fclose (stream);
2532   gcry_sexp_release (valuelist);
2533   gcry_sexp_release (signature_sexp);
2534   gcry_sexp_release (sublist);
2535   mpint_list_free (mpis);
2536
2537   return err;
2538 }
2539
2540 /* Handler for the "sign_request" command.  */
2541 static gpg_error_t
2542 ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
2543 {
2544   gcry_sexp_t key;
2545   ssh_key_type_spec_t spec;
2546   unsigned char hash[MAX_DIGEST_LEN];
2547   unsigned int hash_n;
2548   unsigned char key_grip[20];
2549   unsigned char *key_blob;
2550   u32 key_blob_size;
2551   unsigned char *data;
2552   unsigned char *sig;
2553   size_t sig_n;
2554   u32 data_size;
2555   u32 flags;
2556   gpg_error_t err;
2557   gpg_error_t ret_err;
2558   int hash_algo;
2559
2560   key_blob = NULL;
2561   data = NULL;
2562   sig = NULL;
2563   key = NULL;
2564
2565   /* Receive key.  */
2566
2567   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2568   if (err)
2569     goto out;
2570
2571   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, &spec);
2572   if (err)
2573     goto out;
2574
2575   /* Receive data to sign.  */
2576   err = stream_read_string (request, 0, &data, &data_size);
2577   if (err)
2578     goto out;
2579
2580   /* FIXME?  */
2581   err = stream_read_uint32 (request, &flags);
2582   if (err)
2583     goto out;
2584
2585   hash_algo = spec.hash_algo;
2586   if (!hash_algo)
2587     hash_algo = GCRY_MD_SHA1;  /* Use the default.  */
2588
2589   /* Hash data.  */
2590   hash_n = gcry_md_get_algo_dlen (hash_algo);
2591   if (! hash_n)
2592     {
2593       err = gpg_error (GPG_ERR_INTERNAL);
2594       goto out;
2595     }
2596   err = data_hash (data, data_size, hash_algo, hash);
2597   if (err)
2598     goto out;
2599
2600   /* Calculate key grip.  */
2601   err = ssh_key_grip (key, key_grip);
2602   if (err)
2603     goto out;
2604
2605   /* Sign data.  */
2606
2607   ctrl->digest.algo = hash_algo;
2608   memcpy (ctrl->digest.value, hash, hash_n);
2609   ctrl->digest.valuelen = hash_n;
2610   if ((spec.flags & SPEC_FLAG_USE_PKCS1V2))
2611     ctrl->digest.raw_value = 0;
2612   else
2613     ctrl->digest.raw_value = 1;
2614   ctrl->have_keygrip = 1;
2615   memcpy (ctrl->keygrip, key_grip, 20);
2616
2617   err = data_sign (ctrl, &spec, &sig, &sig_n);
2618
2619  out:
2620
2621   /* Done.  */
2622
2623   if (! err)
2624     {
2625       ret_err = stream_write_byte (response, SSH_RESPONSE_SIGN_RESPONSE);
2626       if (ret_err)
2627         goto leave;
2628       ret_err = stream_write_string (response, sig, sig_n);
2629       if (ret_err)
2630         goto leave;
2631     }
2632   else
2633     {
2634       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2635       if (ret_err)
2636         goto leave;
2637     }
2638
2639  leave:
2640
2641   gcry_sexp_release (key);
2642   xfree (key_blob);
2643   xfree (data);
2644   xfree (sig);
2645
2646   return ret_err;
2647 }
2648
2649 /* This function extracts the comment contained in the key
2650    S-Expression KEY and stores a copy in COMMENT.  Returns usual error
2651    code.  */
2652 static gpg_error_t
2653 ssh_key_extract_comment (gcry_sexp_t key, char **comment)
2654 {
2655   gcry_sexp_t comment_list;
2656   char *comment_new;
2657   const char *data;
2658   size_t data_n;
2659   gpg_error_t err;
2660
2661   comment_list = gcry_sexp_find_token (key, "comment", 0);
2662   if (! comment_list)
2663     {
2664       err = gpg_error (GPG_ERR_INV_SEXP);
2665       goto out;
2666     }
2667
2668   data = gcry_sexp_nth_data (comment_list, 1, &data_n);
2669   if (! data)
2670     {
2671       err = gpg_error (GPG_ERR_INV_SEXP);
2672       goto out;
2673     }
2674
2675   comment_new = make_cstring (data, data_n);
2676   if (! comment_new)
2677     {
2678       err = gpg_error_from_syserror ();
2679       goto out;
2680     }
2681
2682   *comment = comment_new;
2683   err = 0;
2684
2685  out:
2686
2687   gcry_sexp_release (comment_list);
2688
2689   return err;
2690 }
2691
2692 /* This function converts the key contained in the S-Expression KEY
2693    into a buffer, which is protected by the passphrase PASSPHRASE.
2694    Returns usual error code.  */
2695 static gpg_error_t
2696 ssh_key_to_protected_buffer (gcry_sexp_t key, const char *passphrase,
2697                              unsigned char **buffer, size_t *buffer_n)
2698 {
2699   unsigned char *buffer_new;
2700   unsigned int buffer_new_n;
2701   gpg_error_t err;
2702
2703   err = 0;
2704   buffer_new_n = gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, NULL, 0);
2705   buffer_new = xtrymalloc_secure (buffer_new_n);
2706   if (! buffer_new)
2707     {
2708       err = gpg_error_from_syserror ();
2709       goto out;
2710     }
2711
2712   gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, buffer_new, buffer_new_n);
2713   /* FIXME: guarantee?  */
2714
2715   err = agent_protect (buffer_new, passphrase, buffer, buffer_n);
2716
2717  out:
2718
2719   xfree (buffer_new);
2720
2721   return err;
2722 }
2723
2724
2725
2726 /* Callback function to compare the first entered PIN with the one
2727    currently being entered. */
2728 static int
2729 reenter_compare_cb (struct pin_entry_info_s *pi)
2730 {
2731   const char *pin1 = pi->check_cb_arg;
2732
2733   if (!strcmp (pin1, pi->pin))
2734     return 0; /* okay */
2735   return -1;
2736 }
2737
2738
2739 /* Store the ssh KEY into our local key storage and protect it after
2740    asking for a passphrase.  Cache that passphrase.  TTL is the
2741    maximum caching time for that key.  If the key already exists in
2742    our key storage, don't do anything.  When entering a new key also
2743    add an entry to the sshcontrol file.  */
2744 static gpg_error_t
2745 ssh_identity_register (ctrl_t ctrl, gcry_sexp_t key, int ttl, int confirm)
2746 {
2747   gpg_error_t err;
2748   unsigned char key_grip_raw[20];
2749   char key_grip[41];
2750   unsigned char *buffer = NULL;
2751   size_t buffer_n;
2752   char *description = NULL;
2753   const char *description2 = _("Please re-enter this passphrase");
2754   char *comment = NULL;
2755   char *key_fpr = NULL;
2756   const char *initial_errtext = NULL;
2757   unsigned int i;
2758   struct pin_entry_info_s *pi = NULL, *pi2;
2759
2760   err = ssh_key_grip (key, key_grip_raw);
2761   if (err)
2762     goto out;
2763
2764   /* Check whether the key is already in our key storage.  Don't do
2765      anything then.  */
2766   if ( !agent_key_available (key_grip_raw) )
2767     goto out; /* Yes, key is available.  */
2768
2769   err = ssh_get_fingerprint_string (key, &key_fpr);
2770   if (err)
2771     goto out;
2772
2773   err = ssh_key_extract_comment (key, &comment);
2774   if (err)
2775     goto out;
2776
2777   if ( asprintf (&description,
2778                  _("Please enter a passphrase to protect"
2779                    " the received secret key%%0A"
2780                    "   %s%%0A"
2781                    "   %s%%0A"
2782                    "within gpg-agent's key storage"),
2783                  key_fpr, comment ? comment : "") < 0)
2784     {
2785       err = gpg_error_from_syserror ();
2786       goto out;
2787     }
2788
2789   pi = gcry_calloc_secure (2, sizeof (*pi) + 100 + 1);
2790   if (!pi)
2791     {
2792       err = gpg_error_from_syserror ();
2793       goto out;
2794     }
2795   pi2 = pi + (sizeof *pi + 100 + 1);
2796   pi->max_length = 100;
2797   pi->max_tries = 1;
2798   pi2->max_length = 100;
2799   pi2->max_tries = 1;
2800   pi2->check_cb = reenter_compare_cb;
2801   pi2->check_cb_arg = pi->pin;
2802
2803  next_try:
2804   err = agent_askpin (ctrl, description, NULL, initial_errtext, pi);
2805   initial_errtext = NULL;
2806   if (err)
2807     goto out;
2808
2809   /* Unless the passphrase is empty, ask to confirm it.  */
2810   if (pi->pin && *pi->pin)
2811     {
2812       err = agent_askpin (ctrl, description2, NULL, NULL, pi2);
2813       if (err == -1)
2814         { /* The re-entered one did not match and the user did not
2815              hit cancel. */
2816           initial_errtext = _("does not match - try again");
2817           goto next_try;
2818         }
2819     }
2820
2821   err = ssh_key_to_protected_buffer (key, pi->pin, &buffer, &buffer_n);
2822   if (err)
2823     goto out;
2824
2825   /* Store this key to our key storage.  */
2826   err = agent_write_private_key (key_grip_raw, buffer, buffer_n, 0);
2827   if (err)
2828     goto out;
2829
2830   /* Cache this passphrase. */
2831   for (i = 0; i < 20; i++)
2832     sprintf (key_grip + 2 * i, "%02X", key_grip_raw[i]);
2833
2834   err = agent_put_cache (key_grip, CACHE_MODE_SSH, pi->pin, ttl);
2835   if (err)
2836     goto out;
2837
2838   /* And add an entry to the sshcontrol file.  */
2839   err = add_control_entry (ctrl, key_grip, key_fpr, ttl, confirm);
2840
2841
2842  out:
2843   if (pi && pi->max_length)
2844     wipememory (pi->pin, pi->max_length);
2845   xfree (pi);
2846   xfree (buffer);
2847   xfree (comment);
2848   xfree (key_fpr);
2849   xfree (description);
2850
2851   return err;
2852 }
2853
2854
2855 /* This function removes the key contained in the S-Expression KEY
2856    from the local key storage, in case it exists there.  Returns usual
2857    error code.  FIXME: this function is a stub.  */
2858 static gpg_error_t
2859 ssh_identity_drop (gcry_sexp_t key)
2860 {
2861   unsigned char key_grip[21] = { 0 };
2862   gpg_error_t err;
2863
2864   err = ssh_key_grip (key, key_grip);
2865   if (err)
2866     goto out;
2867
2868   key_grip[sizeof (key_grip) - 1] = 0;
2869
2870   /* FIXME: What to do here - forgetting the passphrase or deleting
2871      the key from key cache?  */
2872
2873  out:
2874
2875   return err;
2876 }
2877
2878 /* Handler for the "add_identity" command.  */
2879 static gpg_error_t
2880 ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
2881 {
2882   gpg_error_t ret_err;
2883   gpg_error_t err;
2884   gcry_sexp_t key;
2885   unsigned char b;
2886   int confirm;
2887   int ttl;
2888
2889   confirm = 0;
2890   key = NULL;
2891   ttl = 0;
2892
2893   /* FIXME?  */
2894   err = ssh_receive_key (request, &key, 1, 1, NULL);
2895   if (err)
2896     goto out;
2897
2898   while (1)
2899     {
2900       err = stream_read_byte (request, &b);
2901       if (gpg_err_code (err) == GPG_ERR_EOF)
2902         {
2903           err = 0;
2904           break;
2905         }
2906
2907       switch (b)
2908         {
2909         case SSH_OPT_CONSTRAIN_LIFETIME:
2910           {
2911             u32 n = 0;
2912
2913             err = stream_read_uint32 (request, &n);
2914             if (! err)
2915               ttl = n;
2916             break;
2917           }
2918
2919         case SSH_OPT_CONSTRAIN_CONFIRM:
2920           {
2921             confirm = 1;
2922             break;
2923           }
2924
2925         default:
2926           /* FIXME: log/bad?  */
2927           break;
2928         }
2929     }
2930   if (err)
2931     goto out;
2932
2933   err = ssh_identity_register (ctrl, key, ttl, confirm);
2934
2935  out:
2936
2937   gcry_sexp_release (key);
2938
2939   if (! err)
2940     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2941   else
2942     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2943
2944   return ret_err;
2945 }
2946
2947 /* Handler for the "remove_identity" command.  */
2948 static gpg_error_t
2949 ssh_handler_remove_identity (ctrl_t ctrl,
2950                              estream_t request, estream_t response)
2951 {
2952   unsigned char *key_blob;
2953   u32 key_blob_size;
2954   gcry_sexp_t key;
2955   gpg_error_t ret_err;
2956   gpg_error_t err;
2957
2958   (void)ctrl;
2959
2960   /* Receive key.  */
2961
2962   key_blob = NULL;
2963   key = NULL;
2964
2965   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2966   if (err)
2967     goto out;
2968
2969   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, NULL);
2970   if (err)
2971     goto out;
2972
2973   err = ssh_identity_drop (key);
2974
2975  out:
2976
2977   xfree (key_blob);
2978   gcry_sexp_release (key);
2979
2980   if (! err)
2981     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2982   else
2983     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2984
2985   return ret_err;
2986 }
2987
2988 /* FIXME: stub function.  Actually useful?  */
2989 static gpg_error_t
2990 ssh_identities_remove_all (void)
2991 {
2992   gpg_error_t err;
2993
2994   err = 0;
2995
2996   /* FIXME: shall we remove _all_ cache entries or only those
2997      registered through the ssh emulation?  */
2998
2999   return err;
3000 }
3001
3002 /* Handler for the "remove_all_identities" command.  */
3003 static gpg_error_t
3004 ssh_handler_remove_all_identities (ctrl_t ctrl,
3005                                    estream_t request, estream_t response)
3006 {
3007   gpg_error_t ret_err;
3008   gpg_error_t err;
3009
3010   (void)ctrl;
3011   (void)request;
3012
3013   err = ssh_identities_remove_all ();
3014
3015   if (! err)
3016     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3017   else
3018     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3019
3020   return ret_err;
3021 }
3022
3023 /* Lock agent?  FIXME: stub function.  */
3024 static gpg_error_t
3025 ssh_lock (void)
3026 {
3027   gpg_error_t err;
3028
3029   /* FIXME */
3030   log_error ("ssh-agent's lock command is not implemented\n");
3031   err = 0;
3032
3033   return err;
3034 }
3035
3036 /* Unock agent?  FIXME: stub function.  */
3037 static gpg_error_t
3038 ssh_unlock (void)
3039 {
3040   gpg_error_t err;
3041
3042   log_error ("ssh-agent's unlock command is not implemented\n");
3043   err = 0;
3044
3045   return err;
3046 }
3047
3048 /* Handler for the "lock" command.  */
3049 static gpg_error_t
3050 ssh_handler_lock (ctrl_t ctrl, estream_t request, estream_t response)
3051 {
3052   gpg_error_t ret_err;
3053   gpg_error_t err;
3054
3055   (void)ctrl;
3056   (void)request;
3057
3058   err = ssh_lock ();
3059
3060   if (! err)
3061     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3062   else
3063     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3064
3065   return ret_err;
3066 }
3067
3068 /* Handler for the "unlock" command.  */
3069 static gpg_error_t
3070 ssh_handler_unlock (ctrl_t ctrl, estream_t request, estream_t response)
3071 {
3072   gpg_error_t ret_err;
3073   gpg_error_t err;
3074
3075   (void)ctrl;
3076   (void)request;
3077
3078   err = ssh_unlock ();
3079
3080   if (! err)
3081     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3082   else
3083     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3084
3085   return ret_err;
3086 }
3087
3088 \f
3089
3090 /* Return the request specification for the request identified by TYPE
3091    or NULL in case the requested request specification could not be
3092    found.  */
3093 static ssh_request_spec_t *
3094 request_spec_lookup (int type)
3095 {
3096   ssh_request_spec_t *spec;
3097   unsigned int i;
3098
3099   for (i = 0; i < DIM (request_specs); i++)
3100     if (request_specs[i].type == type)
3101       break;
3102   if (i == DIM (request_specs))
3103     {
3104       if (opt.verbose)
3105         log_info ("ssh request %u is not supported\n", type);
3106       spec = NULL;
3107     }
3108   else
3109     spec = request_specs + i;
3110
3111   return spec;
3112 }
3113
3114 /* Process a single request.  The request is read from and the
3115    response is written to STREAM_SOCK.  Uses CTRL as context.  Returns
3116    zero in case of success, non zero in case of failure.  */
3117 static int
3118 ssh_request_process (ctrl_t ctrl, estream_t stream_sock)
3119 {
3120   ssh_request_spec_t *spec;
3121   estream_t response;
3122   estream_t request;
3123   unsigned char request_type;
3124   gpg_error_t err;
3125   int send_err;
3126   int ret;
3127   unsigned char *request_data;
3128   u32 request_data_size;
3129   u32 response_size;
3130
3131   request_data = NULL;
3132   response = NULL;
3133   request = NULL;
3134   send_err = 0;
3135
3136   /* Create memory streams for request/response data.  The entire
3137      request will be stored in secure memory, since it might contain
3138      secret key material.  The response does not have to be stored in
3139      secure memory, since we never give out secret keys.
3140
3141      Note: we only have little secure memory, but there is NO
3142      possibility of DoS here; only trusted clients are allowed to
3143      connect to the agent.  What could happen is that the agent
3144      returns out-of-secure-memory errors on requests in case the
3145      agent's owner floods his own agent with many large messages.
3146      -moritz */
3147
3148   /* Retrieve request.  */
3149   err = stream_read_string (stream_sock, 1, &request_data, &request_data_size);
3150   if (err)
3151     goto out;
3152
3153   if (opt.verbose > 1)
3154     log_info ("received ssh request of length %u\n",
3155               (unsigned int)request_data_size);
3156
3157   if (! request_data_size)
3158     {
3159       send_err = 1;
3160       goto out;
3161       /* Broken request; FIXME.  */
3162     }
3163
3164   request_type = request_data[0];
3165   spec = request_spec_lookup (request_type);
3166   if (! spec)
3167     {
3168       send_err = 1;
3169       goto out;
3170       /* Unknown request; FIXME.  */
3171     }
3172
3173   if (spec->secret_input)
3174     request = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+");
3175   else
3176     request = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+");
3177   if (! request)
3178     {
3179       err = gpg_error_from_syserror ();
3180       goto out;
3181     }
3182   ret = es_setvbuf (request, NULL, _IONBF, 0);
3183   if (ret)
3184     {
3185       err = gpg_error_from_syserror ();
3186       goto out;
3187     }
3188   err = stream_write_data (request, request_data + 1, request_data_size - 1);
3189   if (err)
3190     goto out;
3191   es_rewind (request);
3192
3193   response = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
3194   if (! response)
3195     {
3196       err = gpg_error_from_syserror ();
3197       goto out;
3198     }
3199
3200   if (opt.verbose)
3201     log_info ("ssh request handler for %s (%u) started\n",
3202                spec->identifier, spec->type);
3203
3204   err = (*spec->handler) (ctrl, request, response);
3205
3206   if (opt.verbose)
3207     {
3208       if (err)
3209         log_info ("ssh request handler for %s (%u) failed: %s\n",
3210                   spec->identifier, spec->type, gpg_strerror (err));
3211       else
3212         log_info ("ssh request handler for %s (%u) ready\n",
3213                   spec->identifier, spec->type);
3214     }
3215
3216   if (err)
3217     {
3218       send_err = 1;
3219       goto out;
3220     }
3221
3222   response_size = es_ftell (response);
3223   if (opt.verbose > 1)
3224     log_info ("sending ssh response of length %u\n",
3225               (unsigned int)response_size);
3226
3227   err = es_fseek (response, 0, SEEK_SET);
3228   if (err)
3229     {
3230       send_err = 1;
3231       goto out;
3232     }
3233
3234   err = stream_write_uint32 (stream_sock, response_size);
3235   if (err)
3236     {
3237       send_err = 1;
3238       goto out;
3239     }
3240
3241   err = stream_copy (stream_sock, response);
3242   if (err)
3243     goto out;
3244
3245   err = es_fflush (stream_sock);
3246   if (err)
3247     goto out;
3248
3249  out:
3250
3251   if (err && es_feof (stream_sock))
3252     log_error ("error occured while processing request: %s\n",
3253                gpg_strerror (err));
3254
3255   if (send_err)
3256     {
3257       if (opt.verbose > 1)
3258         log_info ("sending ssh error response\n");
3259       err = stream_write_uint32 (stream_sock, 1);
3260       if (err)
3261         goto leave;
3262       err = stream_write_byte (stream_sock, SSH_RESPONSE_FAILURE);
3263       if (err)
3264         goto leave;
3265     }
3266
3267  leave:
3268
3269   if (request)
3270     es_fclose (request);
3271   if (response)
3272     es_fclose (response);
3273   xfree (request_data);         /* FIXME?  */
3274
3275   return !!err;
3276 }
3277
3278 /* Start serving client on SOCK_CLIENT.  */
3279 void
3280 start_command_handler_ssh (ctrl_t ctrl, gnupg_fd_t sock_client)
3281 {
3282   estream_t stream_sock = NULL;
3283   gpg_error_t err = 0;
3284   int ret;
3285
3286   /* Because the ssh protocol does not send us information about the
3287      the current TTY setting, we resort here to use those from startup
3288      or those explictly set.  */
3289   {
3290     static const char *names[] =
3291       {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
3292     int idx;
3293     const char *value;
3294
3295     for (idx=0; !err && names[idx]; idx++)
3296       if (!session_env_getenv (ctrl->session_env, names[idx])
3297           && (value = session_env_getenv (opt.startup_env, names[idx])))
3298         err = session_env_setenv (ctrl->session_env, names[idx], value);
3299
3300     if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
3301       if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
3302         err = gpg_error_from_syserror ();
3303
3304     if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
3305       if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
3306         err = gpg_error_from_syserror ();
3307
3308     if (err)
3309       {
3310         log_error ("error setting default session environment: %s\n",
3311                    gpg_strerror (err));
3312         goto out;
3313       }
3314   }
3315
3316
3317   /* Create stream from socket.  */
3318   stream_sock = es_fdopen (FD2INT(sock_client), "r+");
3319   if (!stream_sock)
3320     {
3321       err = gpg_error_from_syserror ();
3322       log_error (_("failed to create stream from socket: %s\n"),
3323                  gpg_strerror (err));
3324       goto out;
3325     }
3326   /* We have to disable the estream buffering, because the estream
3327      core doesn't know about secure memory.  */
3328   ret = es_setvbuf (stream_sock, NULL, _IONBF, 0);
3329   if (ret)
3330     {
3331       err = gpg_error_from_syserror ();
3332       log_error ("failed to disable buffering "
3333                  "on socket stream: %s\n", gpg_strerror (err));
3334       goto out;
3335     }
3336
3337   /* Main processing loop. */
3338   while ( !ssh_request_process (ctrl, stream_sock) )
3339     {
3340       /* Check wether we have reached EOF before trying to read
3341          another request.  */
3342       int c;
3343
3344       c = es_fgetc (stream_sock);
3345       if (c == EOF)
3346         break;
3347       es_ungetc (c, stream_sock);
3348     }
3349
3350   /* Reset the SCD in case it has been used. */
3351   agent_reset_scd (ctrl);
3352
3353
3354  out:
3355   if (stream_sock)
3356     es_fclose (stream_sock);
3357 }