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