agent: Make digest algorithms for ssh fingerprints configurable.
[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    Returns usual error code.  */
2984 static gpg_error_t
2985 ssh_key_to_protected_buffer (gcry_sexp_t key, const char *passphrase,
2986                              unsigned char **buffer, size_t *buffer_n)
2987 {
2988   unsigned char *buffer_new;
2989   unsigned int buffer_new_n;
2990   gpg_error_t err;
2991
2992   buffer_new_n = gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, NULL, 0);
2993   buffer_new = xtrymalloc_secure (buffer_new_n);
2994   if (! buffer_new)
2995     {
2996       err = gpg_error_from_syserror ();
2997       goto out;
2998     }
2999
3000   gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, buffer_new, buffer_new_n);
3001   /* FIXME: guarantee?  */
3002
3003   err = agent_protect (buffer_new, passphrase, buffer, buffer_n, 0, -1);
3004
3005  out:
3006
3007   xfree (buffer_new);
3008
3009   return err;
3010 }
3011
3012
3013
3014 /* Callback function to compare the first entered PIN with the one
3015    currently being entered. */
3016 static gpg_error_t
3017 reenter_compare_cb (struct pin_entry_info_s *pi)
3018 {
3019   const char *pin1 = pi->check_cb_arg;
3020
3021   if (!strcmp (pin1, pi->pin))
3022     return 0; /* okay */
3023   return gpg_error (GPG_ERR_BAD_PASSPHRASE);
3024 }
3025
3026
3027 /* Store the ssh KEY into our local key storage and protect it after
3028    asking for a passphrase.  Cache that passphrase.  TTL is the
3029    maximum caching time for that key.  If the key already exists in
3030    our key storage, don't do anything.  When entering a key also add
3031    an entry to the sshcontrol file.  */
3032 static gpg_error_t
3033 ssh_identity_register (ctrl_t ctrl, ssh_key_type_spec_t *spec,
3034                        gcry_sexp_t key, int ttl, int confirm)
3035 {
3036   gpg_error_t err;
3037   unsigned char key_grip_raw[20];
3038   char key_grip[41];
3039   unsigned char *buffer = NULL;
3040   size_t buffer_n;
3041   char *description = NULL;
3042   const char *description2 = L_("Please re-enter this passphrase");
3043   char *comment = NULL;
3044   char *key_fpr = NULL;
3045   const char *initial_errtext = NULL;
3046   struct pin_entry_info_s *pi = NULL;
3047   struct pin_entry_info_s *pi2 = NULL;
3048
3049   err = ssh_key_grip (key, key_grip_raw);
3050   if (err)
3051     goto out;
3052
3053   bin2hex (key_grip_raw, 20, key_grip);
3054
3055   err = ssh_get_fingerprint_string (key, opt.ssh_fingerprint_digest, &key_fpr);
3056   if (err)
3057     goto out;
3058
3059   /* Check whether the key is already in our key storage.  Don't do
3060      anything then besides (re-)adding it to sshcontrol.  */
3061   if ( !agent_key_available (key_grip_raw) )
3062     goto key_exists; /* Yes, key is available.  */
3063
3064   err = ssh_key_extract_comment (key, &comment);
3065   if (err)
3066     goto out;
3067
3068   if ( asprintf (&description,
3069                  L_("Please enter a passphrase to protect"
3070                     " the received secret key%%0A"
3071                     "   %s%%0A"
3072                     "   %s%%0A"
3073                     "within gpg-agent's key storage"),
3074                  key_fpr, comment ? comment : "") < 0)
3075     {
3076       err = gpg_error_from_syserror ();
3077       goto out;
3078     }
3079
3080   pi = gcry_calloc_secure (1, sizeof (*pi) + MAX_PASSPHRASE_LEN + 1);
3081   if (!pi)
3082     {
3083       err = gpg_error_from_syserror ();
3084       goto out;
3085     }
3086   pi2 = gcry_calloc_secure (1, sizeof (*pi2) + MAX_PASSPHRASE_LEN + 1);
3087   if (!pi2)
3088     {
3089       err = gpg_error_from_syserror ();
3090       goto out;
3091     }
3092   pi->max_length = MAX_PASSPHRASE_LEN + 1;
3093   pi->max_tries = 1;
3094   pi->with_repeat = 1;
3095   pi2->max_length = MAX_PASSPHRASE_LEN + 1;
3096   pi2->max_tries = 1;
3097   pi2->check_cb = reenter_compare_cb;
3098   pi2->check_cb_arg = pi->pin;
3099
3100  next_try:
3101   err = agent_askpin (ctrl, description, NULL, initial_errtext, pi, NULL, 0);
3102   initial_errtext = NULL;
3103   if (err)
3104     goto out;
3105
3106   /* Unless the passphrase is empty or the pinentry told us that
3107      it already did the repetition check, ask to confirm it.  */
3108   if (*pi->pin && !pi->repeat_okay)
3109     {
3110       err = agent_askpin (ctrl, description2, NULL, NULL, pi2, NULL, 0);
3111       if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
3112         { /* The re-entered one did not match and the user did not
3113              hit cancel. */
3114           initial_errtext = L_("does not match - try again");
3115           goto next_try;
3116         }
3117     }
3118
3119   err = ssh_key_to_protected_buffer (key, pi->pin, &buffer, &buffer_n);
3120   if (err)
3121     goto out;
3122
3123   /* Store this key to our key storage.  */
3124   err = agent_write_private_key (key_grip_raw, buffer, buffer_n, 0);
3125   if (err)
3126     goto out;
3127
3128   /* Cache this passphrase. */
3129   err = agent_put_cache (key_grip, CACHE_MODE_SSH, pi->pin, ttl);
3130   if (err)
3131     goto out;
3132
3133  key_exists:
3134   /* And add an entry to the sshcontrol file.  */
3135   err = add_control_entry (ctrl, spec, key_grip, key, ttl, confirm);
3136
3137
3138  out:
3139   if (pi2 && pi2->max_length)
3140     wipememory (pi2->pin, pi2->max_length);
3141   xfree (pi2);
3142   if (pi && pi->max_length)
3143     wipememory (pi->pin, pi->max_length);
3144   xfree (pi);
3145   xfree (buffer);
3146   xfree (comment);
3147   xfree (key_fpr);
3148   xfree (description);
3149
3150   return err;
3151 }
3152
3153
3154 /* This function removes the key contained in the S-Expression KEY
3155    from the local key storage, in case it exists there.  Returns usual
3156    error code.  FIXME: this function is a stub.  */
3157 static gpg_error_t
3158 ssh_identity_drop (gcry_sexp_t key)
3159 {
3160   unsigned char key_grip[21] = { 0 };
3161   gpg_error_t err;
3162
3163   err = ssh_key_grip (key, key_grip);
3164   if (err)
3165     goto out;
3166
3167   key_grip[sizeof (key_grip) - 1] = 0;
3168
3169   /* FIXME: What to do here - forgetting the passphrase or deleting
3170      the key from key cache?  */
3171
3172  out:
3173
3174   return err;
3175 }
3176
3177 /* Handler for the "add_identity" command.  */
3178 static gpg_error_t
3179 ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
3180 {
3181   gpg_error_t ret_err;
3182   ssh_key_type_spec_t spec;
3183   gpg_error_t err;
3184   gcry_sexp_t key;
3185   unsigned char b;
3186   int confirm;
3187   int ttl;
3188
3189   confirm = 0;
3190   key = NULL;
3191   ttl = 0;
3192
3193   /* FIXME?  */
3194   err = ssh_receive_key (request, &key, 1, 1, &spec);
3195   if (err)
3196     goto out;
3197
3198   while (1)
3199     {
3200       err = stream_read_byte (request, &b);
3201       if (gpg_err_code (err) == GPG_ERR_EOF)
3202         {
3203           err = 0;
3204           break;
3205         }
3206
3207       switch (b)
3208         {
3209         case SSH_OPT_CONSTRAIN_LIFETIME:
3210           {
3211             u32 n = 0;
3212
3213             err = stream_read_uint32 (request, &n);
3214             if (! err)
3215               ttl = n;
3216             break;
3217           }
3218
3219         case SSH_OPT_CONSTRAIN_CONFIRM:
3220           {
3221             confirm = 1;
3222             break;
3223           }
3224
3225         default:
3226           /* FIXME: log/bad?  */
3227           break;
3228         }
3229     }
3230   if (err)
3231     goto out;
3232
3233   err = ssh_identity_register (ctrl, &spec, key, ttl, confirm);
3234
3235  out:
3236
3237   gcry_sexp_release (key);
3238
3239   if (! err)
3240     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3241   else
3242     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3243
3244   return ret_err;
3245 }
3246
3247 /* Handler for the "remove_identity" command.  */
3248 static gpg_error_t
3249 ssh_handler_remove_identity (ctrl_t ctrl,
3250                              estream_t request, estream_t response)
3251 {
3252   unsigned char *key_blob;
3253   u32 key_blob_size;
3254   gcry_sexp_t key;
3255   gpg_error_t ret_err;
3256   gpg_error_t err;
3257
3258   (void)ctrl;
3259
3260   /* Receive key.  */
3261
3262   key_blob = NULL;
3263   key = NULL;
3264
3265   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
3266   if (err)
3267     goto out;
3268
3269   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, NULL);
3270   if (err)
3271     goto out;
3272
3273   err = ssh_identity_drop (key);
3274
3275  out:
3276
3277   xfree (key_blob);
3278   gcry_sexp_release (key);
3279
3280   if (! err)
3281     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3282   else
3283     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3284
3285   return ret_err;
3286 }
3287
3288 /* FIXME: stub function.  Actually useful?  */
3289 static gpg_error_t
3290 ssh_identities_remove_all (void)
3291 {
3292   gpg_error_t err;
3293
3294   err = 0;
3295
3296   /* FIXME: shall we remove _all_ cache entries or only those
3297      registered through the ssh-agent protocol?  */
3298
3299   return err;
3300 }
3301
3302 /* Handler for the "remove_all_identities" command.  */
3303 static gpg_error_t
3304 ssh_handler_remove_all_identities (ctrl_t ctrl,
3305                                    estream_t request, estream_t response)
3306 {
3307   gpg_error_t ret_err;
3308   gpg_error_t err;
3309
3310   (void)ctrl;
3311   (void)request;
3312
3313   err = ssh_identities_remove_all ();
3314
3315   if (! err)
3316     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3317   else
3318     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3319
3320   return ret_err;
3321 }
3322
3323 /* Lock agent?  FIXME: stub function.  */
3324 static gpg_error_t
3325 ssh_lock (void)
3326 {
3327   gpg_error_t err;
3328
3329   /* FIXME */
3330   log_error ("ssh-agent's lock command is not implemented\n");
3331   err = 0;
3332
3333   return err;
3334 }
3335
3336 /* Unock agent?  FIXME: stub function.  */
3337 static gpg_error_t
3338 ssh_unlock (void)
3339 {
3340   gpg_error_t err;
3341
3342   log_error ("ssh-agent's unlock command is not implemented\n");
3343   err = 0;
3344
3345   return err;
3346 }
3347
3348 /* Handler for the "lock" command.  */
3349 static gpg_error_t
3350 ssh_handler_lock (ctrl_t ctrl, estream_t request, estream_t response)
3351 {
3352   gpg_error_t ret_err;
3353   gpg_error_t err;
3354
3355   (void)ctrl;
3356   (void)request;
3357
3358   err = ssh_lock ();
3359
3360   if (! err)
3361     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3362   else
3363     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3364
3365   return ret_err;
3366 }
3367
3368 /* Handler for the "unlock" command.  */
3369 static gpg_error_t
3370 ssh_handler_unlock (ctrl_t ctrl, estream_t request, estream_t response)
3371 {
3372   gpg_error_t ret_err;
3373   gpg_error_t err;
3374
3375   (void)ctrl;
3376   (void)request;
3377
3378   err = ssh_unlock ();
3379
3380   if (! err)
3381     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3382   else
3383     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3384
3385   return ret_err;
3386 }
3387
3388 \f
3389
3390 /* Return the request specification for the request identified by TYPE
3391    or NULL in case the requested request specification could not be
3392    found.  */
3393 static const ssh_request_spec_t *
3394 request_spec_lookup (int type)
3395 {
3396   const ssh_request_spec_t *spec;
3397   unsigned int i;
3398
3399   for (i = 0; i < DIM (request_specs); i++)
3400     if (request_specs[i].type == type)
3401       break;
3402   if (i == DIM (request_specs))
3403     {
3404       if (opt.verbose)
3405         log_info ("ssh request %u is not supported\n", type);
3406       spec = NULL;
3407     }
3408   else
3409     spec = request_specs + i;
3410
3411   return spec;
3412 }
3413
3414 /* Process a single request.  The request is read from and the
3415    response is written to STREAM_SOCK.  Uses CTRL as context.  Returns
3416    zero in case of success, non zero in case of failure.  */
3417 static int
3418 ssh_request_process (ctrl_t ctrl, estream_t stream_sock)
3419 {
3420   const ssh_request_spec_t *spec;
3421   estream_t response = NULL;
3422   estream_t request = NULL;
3423   unsigned char request_type;
3424   gpg_error_t err;
3425   int send_err = 0;
3426   int ret;
3427   unsigned char *request_data = NULL;
3428   u32 request_data_size;
3429   u32 response_size;
3430
3431   /* Create memory streams for request/response data.  The entire
3432      request will be stored in secure memory, since it might contain
3433      secret key material.  The response does not have to be stored in
3434      secure memory, since we never give out secret keys.
3435
3436      Note: we only have little secure memory, but there is NO
3437      possibility of DoS here; only trusted clients are allowed to
3438      connect to the agent.  What could happen is that the agent
3439      returns out-of-secure-memory errors on requests in case the
3440      agent's owner floods his own agent with many large messages.
3441      -moritz */
3442
3443   /* Retrieve request.  */
3444   err = stream_read_string (stream_sock, 1, &request_data, &request_data_size);
3445   if (err)
3446     goto out;
3447
3448   if (opt.verbose > 1)
3449     log_info ("received ssh request of length %u\n",
3450               (unsigned int)request_data_size);
3451
3452   if (! request_data_size)
3453     {
3454       send_err = 1;
3455       goto out;
3456       /* Broken request; FIXME.  */
3457     }
3458
3459   request_type = request_data[0];
3460   spec = request_spec_lookup (request_type);
3461   if (! spec)
3462     {
3463       send_err = 1;
3464       goto out;
3465       /* Unknown request; FIXME.  */
3466     }
3467
3468   if (spec->secret_input)
3469     request = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+b");
3470   else
3471     request = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+b");
3472   if (! request)
3473     {
3474       err = gpg_error_from_syserror ();
3475       goto out;
3476     }
3477   ret = es_setvbuf (request, NULL, _IONBF, 0);
3478   if (ret)
3479     {
3480       err = gpg_error_from_syserror ();
3481       goto out;
3482     }
3483   err = stream_write_data (request, request_data + 1, request_data_size - 1);
3484   if (err)
3485     goto out;
3486   es_rewind (request);
3487
3488   response = es_fopenmem (0, "r+b");
3489   if (! response)
3490     {
3491       err = gpg_error_from_syserror ();
3492       goto out;
3493     }
3494
3495   if (opt.verbose)
3496     log_info ("ssh request handler for %s (%u) started\n",
3497                spec->identifier, spec->type);
3498
3499   err = (*spec->handler) (ctrl, request, response);
3500
3501   if (opt.verbose)
3502     {
3503       if (err)
3504         log_info ("ssh request handler for %s (%u) failed: %s\n",
3505                   spec->identifier, spec->type, gpg_strerror (err));
3506       else
3507         log_info ("ssh request handler for %s (%u) ready\n",
3508                   spec->identifier, spec->type);
3509     }
3510
3511   if (err)
3512     {
3513       send_err = 1;
3514       goto out;
3515     }
3516
3517   response_size = es_ftell (response);
3518   if (opt.verbose > 1)
3519     log_info ("sending ssh response of length %u\n",
3520               (unsigned int)response_size);
3521
3522   err = es_fseek (response, 0, SEEK_SET);
3523   if (err)
3524     {
3525       send_err = 1;
3526       goto out;
3527     }
3528
3529   err = stream_write_uint32 (stream_sock, response_size);
3530   if (err)
3531     {
3532       send_err = 1;
3533       goto out;
3534     }
3535
3536   err = stream_copy (stream_sock, response);
3537   if (err)
3538     goto out;
3539
3540   err = es_fflush (stream_sock);
3541   if (err)
3542     goto out;
3543
3544  out:
3545
3546   if (err && es_feof (stream_sock))
3547     log_error ("error occurred while processing request: %s\n",
3548                gpg_strerror (err));
3549
3550   if (send_err)
3551     {
3552       if (opt.verbose > 1)
3553         log_info ("sending ssh error response\n");
3554       err = stream_write_uint32 (stream_sock, 1);
3555       if (err)
3556         goto leave;
3557       err = stream_write_byte (stream_sock, SSH_RESPONSE_FAILURE);
3558       if (err)
3559         goto leave;
3560     }
3561
3562  leave:
3563
3564   es_fclose (request);
3565   es_fclose (response);
3566   xfree (request_data);
3567
3568   return !!err;
3569 }
3570
3571
3572 /* Return the peer's pid.  */
3573 static unsigned long
3574 get_client_pid (int fd)
3575 {
3576   pid_t client_pid = (pid_t)0;
3577
3578 #ifdef SO_PEERCRED
3579   {
3580 #ifdef HAVE_STRUCT_SOCKPEERCRED_PID
3581     struct sockpeercred cr;
3582 #else
3583     struct ucred cr;
3584 #endif
3585     socklen_t cl = sizeof cr;
3586
3587     if (!getsockopt (fd, SOL_SOCKET, SO_PEERCRED, &cr, &cl))
3588       {
3589 #if defined (HAVE_STRUCT_SOCKPEERCRED_PID) || defined (HAVE_STRUCT_UCRED_PID)
3590         client_pid = cr.pid;
3591 #elif defined (HAVE_STRUCT_UCRED_CR_PID)
3592         client_pid = cr.cr_pid;
3593 #else
3594 #error "Unknown SO_PEERCRED struct"
3595 #endif
3596       }
3597   }
3598 #elif defined (LOCAL_PEERPID)
3599   {
3600     socklen_t len = sizeof (pid_t);
3601
3602     getsockopt (fd, SOL_LOCAL, LOCAL_PEERPID, &client_pid, &len);
3603   }
3604 #elif defined (LOCAL_PEEREID)
3605   {
3606     struct unpcbid unp;
3607     socklen_t unpl = sizeof unp;
3608
3609     if (getsockopt (fd, 0, LOCAL_PEEREID, &unp, &unpl) != -1)
3610       client_pid = unp.unp_pid;
3611   }
3612 #elif defined (HAVE_GETPEERUCRED)
3613   {
3614     ucred_t *ucred = NULL;
3615
3616     if (getpeerucred (fd, &ucred) != -1)
3617       {
3618         client_pid= ucred_getpid (ucred);
3619         ucred_free (ucred);
3620       }
3621   }
3622 #else
3623   (void)fd;
3624 #endif
3625
3626   return (unsigned long)client_pid;
3627 }
3628
3629
3630 /* Start serving client on SOCK_CLIENT.  */
3631 void
3632 start_command_handler_ssh (ctrl_t ctrl, gnupg_fd_t sock_client)
3633 {
3634   estream_t stream_sock = NULL;
3635   gpg_error_t err;
3636   int ret;
3637
3638   err = agent_copy_startup_env (ctrl);
3639   if (err)
3640     goto out;
3641
3642   ctrl->client_pid = get_client_pid (FD2INT(sock_client));
3643
3644   /* Create stream from socket.  */
3645   stream_sock = es_fdopen (FD2INT(sock_client), "r+");
3646   if (!stream_sock)
3647     {
3648       err = gpg_error_from_syserror ();
3649       log_error (_("failed to create stream from socket: %s\n"),
3650                  gpg_strerror (err));
3651       goto out;
3652     }
3653   /* We have to disable the estream buffering, because the estream
3654      core doesn't know about secure memory.  */
3655   ret = es_setvbuf (stream_sock, NULL, _IONBF, 0);
3656   if (ret)
3657     {
3658       err = gpg_error_from_syserror ();
3659       log_error ("failed to disable buffering "
3660                  "on socket stream: %s\n", gpg_strerror (err));
3661       goto out;
3662     }
3663
3664   /* Main processing loop. */
3665   while ( !ssh_request_process (ctrl, stream_sock) )
3666     {
3667       /* Check whether we have reached EOF before trying to read
3668          another request.  */
3669       int c;
3670
3671       c = es_fgetc (stream_sock);
3672       if (c == EOF)
3673         break;
3674       es_ungetc (c, stream_sock);
3675     }
3676
3677   /* Reset the SCD in case it has been used. */
3678   agent_reset_scd (ctrl);
3679
3680
3681  out:
3682   if (stream_sock)
3683     es_fclose (stream_sock);
3684 }
3685
3686
3687 #ifdef HAVE_W32_SYSTEM
3688 /* Serve one ssh-agent request.  This is used for the Putty support.
3689    REQUEST is the mmapped memory which may be accessed up to a
3690    length of MAXREQLEN.  Returns 0 on success which also indicates
3691    that a valid SSH response message is now in REQUEST.  */
3692 int
3693 serve_mmapped_ssh_request (ctrl_t ctrl,
3694                            unsigned char *request, size_t maxreqlen)
3695 {
3696   gpg_error_t err;
3697   int send_err = 0;
3698   int valid_response = 0;
3699   ssh_request_spec_t *spec;
3700   u32 msglen;
3701   estream_t request_stream, response_stream;
3702
3703   if (agent_copy_startup_env (ctrl))
3704     goto leave; /* Error setting up the environment.  */
3705
3706   if (maxreqlen < 5)
3707     goto leave; /* Caller error.  */
3708
3709   msglen = uint32_construct (request[0], request[1], request[2], request[3]);
3710   if (msglen < 1 || msglen > maxreqlen - 4)
3711     {
3712       log_error ("ssh message len (%u) out of range", (unsigned int)msglen);
3713       goto leave;
3714     }
3715
3716   spec = request_spec_lookup (request[4]);
3717   if (!spec)
3718     {
3719       send_err = 1;  /* Unknown request type.  */
3720       goto leave;
3721     }
3722
3723   /* Create a stream object with the data part of the request.  */
3724   if (spec->secret_input)
3725     request_stream = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+");
3726   else
3727     request_stream = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+");
3728   if (!request_stream)
3729     {
3730       err = gpg_error_from_syserror ();
3731       goto leave;
3732     }
3733   /* We have to disable the estream buffering, because the estream
3734      core doesn't know about secure memory.  */
3735   if (es_setvbuf (request_stream, NULL, _IONBF, 0))
3736     {
3737       err = gpg_error_from_syserror ();
3738       goto leave;
3739     }
3740   /* Copy the request to the stream but omit the request type.  */
3741   err = stream_write_data (request_stream, request + 5, msglen - 1);
3742   if (err)
3743     goto leave;
3744   es_rewind (request_stream);
3745
3746   response_stream = es_fopenmem (0, "r+b");
3747   if (!response_stream)
3748     {
3749       err = gpg_error_from_syserror ();
3750       goto leave;
3751     }
3752
3753   if (opt.verbose)
3754     log_info ("ssh request handler for %s (%u) started\n",
3755                spec->identifier, spec->type);
3756
3757   err = (*spec->handler) (ctrl, request_stream, response_stream);
3758
3759   if (opt.verbose)
3760     {
3761       if (err)
3762         log_info ("ssh request handler for %s (%u) failed: %s\n",
3763                   spec->identifier, spec->type, gpg_strerror (err));
3764       else
3765         log_info ("ssh request handler for %s (%u) ready\n",
3766                   spec->identifier, spec->type);
3767     }
3768
3769   es_fclose (request_stream);
3770   request_stream = NULL;
3771
3772   if (err)
3773     {
3774       send_err = 1;
3775       goto leave;
3776     }
3777
3778   /* Put the response back into the mmapped buffer.  */
3779   {
3780     void *response_data;
3781     size_t response_size;
3782
3783     /* NB: In contrast to the request-stream, the response stream
3784        includes the message type byte.  */
3785     if (es_fclose_snatch (response_stream, &response_data, &response_size))
3786       {
3787         log_error ("snatching ssh response failed: %s",
3788                    gpg_strerror (gpg_error_from_syserror ()));
3789         send_err = 1; /* Ooops.  */
3790         goto leave;
3791       }
3792
3793     if (opt.verbose > 1)
3794       log_info ("sending ssh response of length %u\n",
3795                 (unsigned int)response_size);
3796     if (response_size > maxreqlen - 4)
3797       {
3798         log_error ("invalid length of the ssh response: %s",
3799                    gpg_strerror (GPG_ERR_INTERNAL));
3800         es_free (response_data);
3801         send_err = 1;
3802         goto leave;
3803       }
3804
3805     request[0] = response_size >> 24;
3806     request[1] = response_size >> 16;
3807     request[2] = response_size >>  8;
3808     request[3] = response_size >>  0;
3809     memcpy (request+4, response_data, response_size);
3810     es_free (response_data);
3811     valid_response = 1;
3812   }
3813
3814  leave:
3815   if (send_err)
3816     {
3817       request[0] = 0;
3818       request[1] = 0;
3819       request[2] = 0;
3820       request[3] = 1;
3821       request[4] = SSH_RESPONSE_FAILURE;
3822       valid_response = 1;
3823     }
3824
3825   /* Reset the SCD in case it has been used. */
3826   agent_reset_scd (ctrl);
3827
3828   return valid_response? 0 : -1;
3829 }
3830 #endif /*HAVE_W32_SYSTEM*/