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