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