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