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