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