agent: Protect commit 135b1e3 against misbehaving Libgcrypt.
[gnupg.git] / agent / command-ssh.c
1 /* command-ssh.c - gpg-agent's ssh-agent emulation layer
2  * Copyright (C) 2004-2006, 2009, 2012 Free Software Foundation, Inc.
3  * Copyright (C) 2004-2006, 2009, 2012-2014 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* Only v2 of the ssh-agent protocol is implemented.  Relevant RFCs
22    are:
23
24    RFC-4250 - Protocol Assigned Numbers
25    RFC-4251 - Protocol Architecture
26    RFC-4252 - Authentication Protocol
27    RFC-4253 - Transport Layer Protocol
28    RFC-5656 - ECC support
29
30    The protocol for the agent is defined in OpenSSH's PROTOCL.agent
31    file.
32   */
33
34 #include <config.h>
35
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <errno.h>
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <assert.h>
43
44 #include "agent.h"
45
46 #include "i18n.h"
47 #include "../common/ssh-utils.h"
48
49
50 \f
51
52 /* Request types. */
53 #define SSH_REQUEST_REQUEST_IDENTITIES    11
54 #define SSH_REQUEST_SIGN_REQUEST          13
55 #define SSH_REQUEST_ADD_IDENTITY          17
56 #define SSH_REQUEST_REMOVE_IDENTITY       18
57 #define SSH_REQUEST_REMOVE_ALL_IDENTITIES 19
58 #define SSH_REQUEST_LOCK                  22
59 #define SSH_REQUEST_UNLOCK                23
60 #define SSH_REQUEST_ADD_ID_CONSTRAINED    25
61
62 /* Options. */
63 #define SSH_OPT_CONSTRAIN_LIFETIME         1
64 #define SSH_OPT_CONSTRAIN_CONFIRM          2
65
66 /* Response types. */
67 #define SSH_RESPONSE_SUCCESS               6
68 #define SSH_RESPONSE_FAILURE               5
69 #define SSH_RESPONSE_IDENTITIES_ANSWER    12
70 #define SSH_RESPONSE_SIGN_RESPONSE        14
71
72 /* Other constants.  */
73 #define SSH_DSA_SIGNATURE_PADDING 20
74 #define SSH_DSA_SIGNATURE_ELEMS    2
75 #define SPEC_FLAG_USE_PKCS1V2 (1 << 0)
76 #define SPEC_FLAG_IS_ECDSA    (1 << 1)
77 #define SPEC_FLAG_IS_EdDSA    (1 << 2)  /*(lowercase 'd' on purpose.)*/
78
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   if (r_disabled)
1035     *r_disabled = 0;
1036   if (r_ttl)
1037     *r_ttl = 0;
1038   if (r_confirm)
1039     *r_confirm = 0;
1040
1041   rewind_control_file (cf);
1042   while (!(err=read_control_file_item (cf)))
1043     {
1044       if (!cf->item.valid)
1045         continue; /* Should not happen.  */
1046       if (!strcmp (hexgrip, cf->item.hexgrip))
1047         break;
1048     }
1049   if (!err)
1050     {
1051       if (r_disabled)
1052         *r_disabled = cf->item.disabled;
1053       if (r_ttl)
1054         *r_ttl = cf->item.ttl;
1055       if (r_confirm)
1056         *r_confirm = cf->item.confirm;
1057     }
1058   return err;
1059 }
1060
1061
1062
1063 /* Add an entry to the control file to mark the key with the keygrip
1064    HEXGRIP as usable for SSH; i.e. it will be returned when ssh asks
1065    for it.  FMTFPR is the fingerprint string.  This function is in
1066    general used to add a key received through the ssh-add function.
1067    We can assume that the user wants to allow ssh using this key. */
1068 static gpg_error_t
1069 add_control_entry (ctrl_t ctrl, ssh_key_type_spec_t *spec,
1070                    const char *hexgrip, const char *fmtfpr,
1071                    int ttl, int confirm)
1072 {
1073   gpg_error_t err;
1074   ssh_control_file_t cf;
1075   int disabled;
1076
1077   (void)ctrl;
1078
1079   err = open_control_file (&cf, 1);
1080   if (err)
1081     return err;
1082
1083   err = search_control_file (cf, hexgrip, &disabled, NULL, NULL);
1084   if (err && gpg_err_code(err) == GPG_ERR_EOF)
1085     {
1086       struct tm *tp;
1087       time_t atime = time (NULL);
1088
1089       /* Not yet in the file - add it. Because the file has been
1090          opened in append mode, we simply need to write to it.  */
1091       tp = localtime (&atime);
1092       fprintf (cf->fp,
1093                ("# %s key added on: %04d-%02d-%02d %02d:%02d:%02d\n"
1094                 "# MD5 Fingerprint:  %s\n"
1095                 "%s %d%s\n"),
1096                spec->name,
1097                1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
1098                tp->tm_hour, tp->tm_min, tp->tm_sec,
1099                fmtfpr, hexgrip, ttl, confirm? " confirm":"");
1100
1101     }
1102   close_control_file (cf);
1103   return 0;
1104 }
1105
1106
1107 /* Scan the sshcontrol file and return the TTL.  */
1108 static int
1109 ttl_from_sshcontrol (const char *hexgrip)
1110 {
1111   ssh_control_file_t cf;
1112   int disabled, ttl;
1113
1114   if (!hexgrip || strlen (hexgrip) != 40)
1115     return 0;  /* Wrong input: Use global default.  */
1116
1117   if (open_control_file (&cf, 0))
1118     return 0; /* Error: Use the global default TTL.  */
1119
1120   if (search_control_file (cf, hexgrip, &disabled, &ttl, NULL)
1121       || disabled)
1122     ttl = 0;  /* Use the global default if not found or disabled.  */
1123
1124   close_control_file (cf);
1125
1126   return ttl;
1127 }
1128
1129
1130 /* Scan the sshcontrol file and return the confirm flag.  */
1131 static int
1132 confirm_flag_from_sshcontrol (const char *hexgrip)
1133 {
1134   ssh_control_file_t cf;
1135   int disabled, confirm;
1136
1137   if (!hexgrip || strlen (hexgrip) != 40)
1138     return 1;  /* Wrong input: Better ask for confirmation.  */
1139
1140   if (open_control_file (&cf, 0))
1141     return 1; /* Error: Better ask for confirmation.  */
1142
1143   if (search_control_file (cf, hexgrip, &disabled, NULL, &confirm)
1144       || disabled)
1145     confirm = 0;  /* If not found or disabled, there is no reason to
1146                      ask for confirmation.  */
1147
1148   close_control_file (cf);
1149
1150   return confirm;
1151 }
1152
1153
1154 \f
1155
1156 /* Open the ssh control file for reading.  This is a public version of
1157    open_control_file.  The caller must use ssh_close_control_file to
1158    release the retruned handle.  */
1159 ssh_control_file_t
1160 ssh_open_control_file (void)
1161 {
1162   ssh_control_file_t cf;
1163
1164   /* Then look at all the registered and non-disabled keys. */
1165   if (open_control_file (&cf, 0))
1166     return NULL;
1167   return cf;
1168 }
1169
1170 /* Close an ssh control file handle.  This is the public version of
1171    close_control_file.  CF may be NULL.  */
1172 void
1173 ssh_close_control_file (ssh_control_file_t cf)
1174 {
1175   close_control_file (cf);
1176 }
1177
1178 /* Read the next item from the ssh control file.  The function returns
1179    0 if a item was read, GPG_ERR_EOF on eof or another error value.
1180    R_HEXGRIP shall either be null or a BUFFER of at least 41 byte.
1181    R_DISABLED, R_TTLm and R_CONFIRM return flags from the control
1182    file; they are only set on success. */
1183 gpg_error_t
1184 ssh_read_control_file (ssh_control_file_t cf,
1185                        char *r_hexgrip,
1186                        int *r_disabled, int *r_ttl, int *r_confirm)
1187 {
1188   gpg_error_t err;
1189
1190   do
1191     err = read_control_file_item (cf);
1192   while (!err && !cf->item.valid);
1193   if (!err)
1194     {
1195       if (r_hexgrip)
1196         strcpy (r_hexgrip, cf->item.hexgrip);
1197       if (r_disabled)
1198         *r_disabled = cf->item.disabled;
1199       if (r_ttl)
1200         *r_ttl = cf->item.ttl;
1201       if (r_confirm)
1202         *r_confirm = cf->item.confirm;
1203     }
1204   return err;
1205 }
1206
1207
1208 /* Search for a key with HEXGRIP in sshcontrol and return all
1209    info.  */
1210 gpg_error_t
1211 ssh_search_control_file (ssh_control_file_t cf,
1212                          const char *hexgrip,
1213                          int *r_disabled, int *r_ttl, int *r_confirm)
1214 {
1215   gpg_error_t err;
1216   int i;
1217   const char *s;
1218   char uphexgrip[41];
1219
1220   /* We need to make sure that HEXGRIP is all uppercase.  The easiest
1221      way to do this and also check its length is by copying to a
1222      second buffer. */
1223   for (i=0, s=hexgrip; i < 40 && *s; s++, i++)
1224     uphexgrip[i] = *s >= 'a'? (*s & 0xdf): *s;
1225   uphexgrip[i] = 0;
1226   if (i != 40)
1227     err = gpg_error (GPG_ERR_INV_LENGTH);
1228   else
1229     err = search_control_file (cf, uphexgrip, r_disabled, r_ttl, r_confirm);
1230   if (gpg_err_code (err) == GPG_ERR_EOF)
1231     err = gpg_error (GPG_ERR_NOT_FOUND);
1232   return err;
1233 }
1234
1235
1236 \f
1237
1238 /*
1239
1240   MPI lists.
1241
1242  */
1243
1244 /* Free the list of MPIs MPI_LIST.  */
1245 static void
1246 mpint_list_free (gcry_mpi_t *mpi_list)
1247 {
1248   if (mpi_list)
1249     {
1250       unsigned int i;
1251
1252       for (i = 0; mpi_list[i]; i++)
1253         gcry_mpi_release (mpi_list[i]);
1254       xfree (mpi_list);
1255     }
1256 }
1257
1258 /* Receive key material MPIs from STREAM according to KEY_SPEC;
1259    depending on SECRET expect a public key or secret key.  The newly
1260    allocated list of MPIs is stored in MPI_LIST.  Returns usual error
1261    code.  */
1262 static gpg_error_t
1263 ssh_receive_mpint_list (estream_t stream, int secret,
1264                         ssh_key_type_spec_t key_spec, gcry_mpi_t **mpi_list)
1265 {
1266   const char *elems_public;
1267   unsigned int elems_n;
1268   const char *elems;
1269   int elem_is_secret;
1270   gcry_mpi_t *mpis;
1271   gpg_error_t err;
1272   unsigned int i;
1273
1274   mpis = NULL;
1275   err = 0;
1276
1277   if (secret)
1278     elems = key_spec.elems_key_secret;
1279   else
1280     elems = key_spec.elems_key_public;
1281   elems_n = strlen (elems);
1282
1283   elems_public = key_spec.elems_key_public;
1284
1285   mpis = xtrycalloc (elems_n + 1, sizeof *mpis );
1286   if (!mpis)
1287     {
1288       err = gpg_error_from_syserror ();
1289       goto out;
1290     }
1291
1292   elem_is_secret = 0;
1293   for (i = 0; i < elems_n; i++)
1294     {
1295       if (secret)
1296         elem_is_secret = ! strchr (elems_public, elems[i]);
1297       err = stream_read_mpi (stream, elem_is_secret, &mpis[i]);
1298       if (err)
1299         break;
1300     }
1301   if (err)
1302     goto out;
1303
1304   *mpi_list = mpis;
1305
1306  out:
1307
1308   if (err)
1309     mpint_list_free (mpis);
1310
1311   return err;
1312 }
1313
1314 \f
1315
1316 /* Key modifier function for RSA.  */
1317 static gpg_error_t
1318 ssh_key_modifier_rsa (const char *elems, gcry_mpi_t *mpis)
1319 {
1320   gcry_mpi_t p;
1321   gcry_mpi_t q;
1322   gcry_mpi_t u;
1323
1324   if (strcmp (elems, "nedupq"))
1325     /* Modifying only necessary for secret keys.  */
1326     goto out;
1327
1328   u = mpis[3];
1329   p = mpis[4];
1330   q = mpis[5];
1331
1332   if (gcry_mpi_cmp (p, q) > 0)
1333     {
1334       /* P shall be smaller then Q!  Swap primes.  iqmp becomes u.  */
1335       gcry_mpi_t tmp;
1336
1337       tmp = mpis[4];
1338       mpis[4] = mpis[5];
1339       mpis[5] = tmp;
1340     }
1341   else
1342     /* U needs to be recomputed.  */
1343     gcry_mpi_invm (u, p, q);
1344
1345  out:
1346
1347   return 0;
1348 }
1349
1350 /* Signature encoder function for RSA.  */
1351 static gpg_error_t
1352 ssh_signature_encoder_rsa (ssh_key_type_spec_t *spec,
1353                            estream_t signature_blob,
1354                            gcry_sexp_t s_signature)
1355 {
1356   gpg_error_t err = 0;
1357   gcry_sexp_t valuelist = NULL;
1358   gcry_sexp_t sublist = NULL;
1359   gcry_mpi_t sig_value = NULL;
1360   gcry_mpi_t *mpis = NULL;
1361   const char *elems;
1362   size_t elems_n;
1363   int i;
1364
1365   unsigned char *data;
1366   size_t data_n;
1367   gcry_mpi_t s;
1368
1369   valuelist = gcry_sexp_nth (s_signature, 1);
1370   if (!valuelist)
1371     {
1372       err = gpg_error (GPG_ERR_INV_SEXP);
1373       goto out;
1374     }
1375
1376   elems = spec->elems_signature;
1377   elems_n = strlen (elems);
1378
1379   mpis = xtrycalloc (elems_n + 1, sizeof *mpis);
1380   if (!mpis)
1381     {
1382       err = gpg_error_from_syserror ();
1383       goto out;
1384     }
1385
1386   for (i = 0; i < elems_n; i++)
1387     {
1388       sublist = gcry_sexp_find_token (valuelist, spec->elems_signature + i, 1);
1389       if (!sublist)
1390         {
1391           err = gpg_error (GPG_ERR_INV_SEXP);
1392           break;
1393         }
1394
1395       sig_value = gcry_sexp_nth_mpi (sublist, 1, GCRYMPI_FMT_USG);
1396       if (!sig_value)
1397         {
1398           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
1399           break;
1400         }
1401       gcry_sexp_release (sublist);
1402       sublist = NULL;
1403
1404       mpis[i] = sig_value;
1405     }
1406   if (err)
1407     goto out;
1408
1409   /* RSA specific */
1410   s = mpis[0];
1411
1412   err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &data, &data_n, s);
1413   if (err)
1414     goto out;
1415
1416   err = stream_write_string (signature_blob, data, data_n);
1417   xfree (data);
1418
1419  out:
1420   gcry_sexp_release (valuelist);
1421   gcry_sexp_release (sublist);
1422   mpint_list_free (mpis);
1423   return err;
1424 }
1425
1426
1427 /* Signature encoder function for DSA.  */
1428 static gpg_error_t
1429 ssh_signature_encoder_dsa (ssh_key_type_spec_t *spec,
1430                            estream_t signature_blob,
1431                            gcry_sexp_t s_signature)
1432 {
1433   gpg_error_t err = 0;
1434   gcry_sexp_t valuelist = NULL;
1435   gcry_sexp_t sublist = NULL;
1436   gcry_mpi_t sig_value = NULL;
1437   gcry_mpi_t *mpis = NULL;
1438   const char *elems;
1439   size_t elems_n;
1440   int i;
1441
1442   unsigned char buffer[SSH_DSA_SIGNATURE_PADDING * SSH_DSA_SIGNATURE_ELEMS];
1443   unsigned char *data = NULL;
1444   size_t data_n;
1445
1446   valuelist = gcry_sexp_nth (s_signature, 1);
1447   if (!valuelist)
1448     {
1449       err = gpg_error (GPG_ERR_INV_SEXP);
1450       goto out;
1451     }
1452
1453   elems = spec->elems_signature;
1454   elems_n = strlen (elems);
1455
1456   mpis = xtrycalloc (elems_n + 1, sizeof *mpis);
1457   if (!mpis)
1458     {
1459       err = gpg_error_from_syserror ();
1460       goto out;
1461     }
1462
1463   for (i = 0; i < elems_n; i++)
1464     {
1465       sublist = gcry_sexp_find_token (valuelist, spec->elems_signature + i, 1);
1466       if (!sublist)
1467         {
1468           err = gpg_error (GPG_ERR_INV_SEXP);
1469           break;
1470         }
1471
1472       sig_value = gcry_sexp_nth_mpi (sublist, 1, GCRYMPI_FMT_USG);
1473       if (!sig_value)
1474         {
1475           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
1476           break;
1477         }
1478       gcry_sexp_release (sublist);
1479       sublist = NULL;
1480
1481       mpis[i] = sig_value;
1482     }
1483   if (err)
1484     goto out;
1485
1486   /* DSA specific code.  */
1487
1488   /* FIXME: Why this complicated code?  Why collecting boths mpis in a
1489      buffer instead of writing them out one after the other?  */
1490   for (i = 0; i < 2; i++)
1491     {
1492       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &data, &data_n, mpis[i]);
1493       if (err)
1494         break;
1495
1496       if (data_n > SSH_DSA_SIGNATURE_PADDING)
1497         {
1498           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
1499           break;
1500         }
1501
1502       memset (buffer + (i * SSH_DSA_SIGNATURE_PADDING), 0,
1503               SSH_DSA_SIGNATURE_PADDING - data_n);
1504       memcpy (buffer + (i * SSH_DSA_SIGNATURE_PADDING)
1505               + (SSH_DSA_SIGNATURE_PADDING - data_n), data, data_n);
1506
1507       xfree (data);
1508       data = NULL;
1509     }
1510   if (err)
1511     goto out;
1512
1513   err = stream_write_string (signature_blob, buffer, sizeof (buffer));
1514
1515  out:
1516   xfree (data);
1517   gcry_sexp_release (valuelist);
1518   gcry_sexp_release (sublist);
1519   mpint_list_free (mpis);
1520   return err;
1521 }
1522
1523
1524 /* Signature encoder function for ECDSA.  */
1525 static gpg_error_t
1526 ssh_signature_encoder_ecdsa (ssh_key_type_spec_t *spec,
1527                              estream_t stream, gcry_sexp_t s_signature)
1528 {
1529   gpg_error_t err = 0;
1530   gcry_sexp_t valuelist = NULL;
1531   gcry_sexp_t sublist = NULL;
1532   gcry_mpi_t sig_value = NULL;
1533   gcry_mpi_t *mpis = NULL;
1534   const char *elems;
1535   size_t elems_n;
1536   int i;
1537
1538   unsigned char *data[2] = {NULL, NULL};
1539   size_t data_n[2];
1540   size_t innerlen;
1541
1542   valuelist = gcry_sexp_nth (s_signature, 1);
1543   if (!valuelist)
1544     {
1545       err = gpg_error (GPG_ERR_INV_SEXP);
1546       goto out;
1547     }
1548
1549   elems = spec->elems_signature;
1550   elems_n = strlen (elems);
1551
1552   mpis = xtrycalloc (elems_n + 1, sizeof *mpis);
1553   if (!mpis)
1554     {
1555       err = gpg_error_from_syserror ();
1556       goto out;
1557     }
1558
1559   for (i = 0; i < elems_n; i++)
1560     {
1561       sublist = gcry_sexp_find_token (valuelist, spec->elems_signature + i, 1);
1562       if (!sublist)
1563         {
1564           err = gpg_error (GPG_ERR_INV_SEXP);
1565           break;
1566         }
1567
1568       sig_value = gcry_sexp_nth_mpi (sublist, 1, GCRYMPI_FMT_USG);
1569       if (!sig_value)
1570         {
1571           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
1572           break;
1573         }
1574       gcry_sexp_release (sublist);
1575       sublist = NULL;
1576
1577       mpis[i] = sig_value;
1578     }
1579   if (err)
1580     goto out;
1581
1582   /* ECDSA specific */
1583
1584   innerlen = 0;
1585   for (i = 0; i < DIM(data); i++)
1586     {
1587       err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &data[i], &data_n[i], mpis[i]);
1588       if (err)
1589         goto out;
1590       innerlen += 4 + data_n[i];
1591     }
1592
1593   err = stream_write_uint32 (stream, innerlen);
1594   if (err)
1595     goto out;
1596
1597   for (i = 0; i < DIM(data); i++)
1598     {
1599       err = stream_write_string (stream, data[i], data_n[i]);
1600       if (err)
1601         goto out;
1602     }
1603
1604  out:
1605   for (i = 0; i < DIM(data); i++)
1606     xfree (data[i]);
1607   gcry_sexp_release (valuelist);
1608   gcry_sexp_release (sublist);
1609   mpint_list_free (mpis);
1610   return err;
1611 }
1612
1613
1614 /* Signature encoder function for EdDSA.  */
1615 static gpg_error_t
1616 ssh_signature_encoder_eddsa (ssh_key_type_spec_t *spec,
1617                              estream_t stream, gcry_sexp_t s_signature)
1618 {
1619   gpg_error_t err = 0;
1620   gcry_sexp_t valuelist = NULL;
1621   gcry_sexp_t sublist = NULL;
1622   const char *elems;
1623   size_t elems_n;
1624   int i;
1625
1626   unsigned char *data[2] = {NULL, NULL};
1627   size_t data_n[2];
1628   size_t totallen = 0;
1629
1630   valuelist = gcry_sexp_nth (s_signature, 1);
1631   if (!valuelist)
1632     {
1633       err = gpg_error (GPG_ERR_INV_SEXP);
1634       goto out;
1635     }
1636
1637   elems = spec->elems_signature;
1638   elems_n = strlen (elems);
1639
1640   if (elems_n != DIM(data))
1641     {
1642       err = gpg_error (GPG_ERR_INV_SEXP);
1643       goto out;
1644     }
1645
1646   for (i = 0; i < DIM(data); i++)
1647     {
1648       sublist = gcry_sexp_find_token (valuelist, spec->elems_signature + i, 1);
1649       if (!sublist)
1650         {
1651           err = gpg_error (GPG_ERR_INV_SEXP);
1652           break;
1653         }
1654
1655       data[i] = gcry_sexp_nth_buffer (sublist, 1, &data_n[i]);
1656       if (!data[i])
1657         {
1658           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
1659           break;
1660         }
1661       totallen += data_n[i];
1662       gcry_sexp_release (sublist);
1663       sublist = NULL;
1664     }
1665   if (err)
1666     goto out;
1667
1668   err = stream_write_uint32 (stream, totallen);
1669   if (err)
1670     goto out;
1671
1672   for (i = 0; i < DIM(data); i++)
1673     {
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           if (*p_elems == 'q' && datalen)
1968             { /* Remove the prefix 0x40.  */
1969               data++;
1970               datalen--;
1971             }
1972           err = stream_write_string (stream, data, datalen);
1973           if (err)
1974             goto out;
1975         }
1976       else
1977         {
1978           gcry_mpi_t mpi;
1979
1980           /* Note that we need to use STD format; i.e. prepend a 0x00
1981              to indicate a positive number if the high bit is set. */
1982           mpi = gcry_sexp_nth_mpi (value_pair, 1, GCRYMPI_FMT_STD);
1983           if (!mpi)
1984             {
1985               err = gpg_error (GPG_ERR_INV_SEXP);
1986               goto out;
1987             }
1988           err = stream_write_mpi (stream, mpi);
1989           gcry_mpi_release (mpi);
1990           if (err)
1991             goto out;
1992         }
1993     }
1994
1995   if (es_fclose_snatch (stream, &blob, &blob_size))
1996     {
1997       err = gpg_error_from_syserror ();
1998       goto out;
1999     }
2000   stream = NULL;
2001
2002   *r_blob = blob;
2003   blob = NULL;
2004   *r_blob_size = blob_size;
2005
2006  out:
2007   gcry_sexp_release (value_list);
2008   gcry_sexp_release (value_pair);
2009   xfree (curve_name);
2010   es_fclose (stream);
2011   es_free (blob);
2012
2013   return err;
2014 }
2015
2016 /* Extract the car from SEXP, and create a newly created C-string
2017    which is to be stored in IDENTIFIER.  */
2018 static gpg_error_t
2019 sexp_extract_identifier (gcry_sexp_t sexp, char **identifier)
2020 {
2021   char *identifier_new;
2022   gcry_sexp_t sublist;
2023   const char *data;
2024   size_t data_n;
2025   gpg_error_t err;
2026
2027   identifier_new = NULL;
2028   err = 0;
2029
2030   sublist = gcry_sexp_nth (sexp, 1);
2031   if (! sublist)
2032     {
2033       err = gpg_error (GPG_ERR_INV_SEXP);
2034       goto out;
2035     }
2036
2037   data = gcry_sexp_nth_data (sublist, 0, &data_n);
2038   if (! data)
2039     {
2040       err = gpg_error (GPG_ERR_INV_SEXP);
2041       goto out;
2042     }
2043
2044   identifier_new = make_cstring (data, data_n);
2045   if (! identifier_new)
2046     {
2047       err = gpg_err_code_from_errno (errno);
2048       goto out;
2049     }
2050
2051   *identifier = identifier_new;
2052
2053  out:
2054
2055   gcry_sexp_release (sublist);
2056
2057   return err;
2058 }
2059
2060 \f
2061
2062 /*
2063
2064   Key I/O.
2065
2066 */
2067
2068 /* Search for a key specification entry.  If SSH_NAME is not NULL,
2069    search for an entry whose "ssh_name" is equal to SSH_NAME;
2070    otherwise, search for an entry whose "name" is equal to NAME.
2071    Store found entry in SPEC on success, return error otherwise.  */
2072 static gpg_error_t
2073 ssh_key_type_lookup (const char *ssh_name, const char *name,
2074                      ssh_key_type_spec_t *spec)
2075 {
2076   gpg_error_t err;
2077   unsigned int i;
2078
2079   /* FIXME: Although this sees to work, it not be correct if the
2080      lookup is done via name which might be "ecc" but actually it need
2081      to check the flags to see whether it is eddsa or ecdsa.  Maybe
2082      the entire parameter controlled logic is too complicated and we
2083      would do better by just switching on the ssh_name.  */
2084   for (i = 0; i < DIM (ssh_key_types); i++)
2085     if ((ssh_name && (! strcmp (ssh_name, ssh_key_types[i].ssh_identifier)))
2086         || (name && (! strcmp (name, ssh_key_types[i].identifier))))
2087       break;
2088
2089   if (i == DIM (ssh_key_types))
2090     err = gpg_error (GPG_ERR_NOT_FOUND);
2091   else
2092     {
2093       *spec = ssh_key_types[i];
2094       err = 0;
2095     }
2096
2097   return err;
2098 }
2099
2100
2101 /* Receive a key from STREAM, according to the key specification given
2102    as KEY_SPEC.  Depending on SECRET, receive a secret or a public
2103    key.  If READ_COMMENT is true, receive a comment string as well.
2104    Constructs a new S-Expression from received data and stores it in
2105    KEY_NEW.  Returns zero on success or an error code.  */
2106 static gpg_error_t
2107 ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret,
2108                  int read_comment, ssh_key_type_spec_t *key_spec)
2109 {
2110   gpg_error_t err;
2111   char *key_type = NULL;
2112   char *comment = NULL;
2113   gcry_sexp_t key = NULL;
2114   ssh_key_type_spec_t spec;
2115   gcry_mpi_t *mpi_list = NULL;
2116   const char *elems;
2117   char *curve_name = NULL;
2118
2119
2120   err = stream_read_cstring (stream, &key_type);
2121   if (err)
2122     goto out;
2123
2124   err = ssh_key_type_lookup (key_type, NULL, &spec);
2125   if (err)
2126     goto out;
2127
2128   if ((spec.flags & SPEC_FLAG_IS_EdDSA))
2129     {
2130       /* The format of an EdDSA key is:
2131        *   string       key_type ("ssh-ed25519")
2132        *   string       public_key
2133        *   string       private_key
2134        *
2135        * Note that the private key is the concatenation of the private
2136        * key with the public key.  Thus theres are 64 bytes; however
2137        * we only want the real 32 byte private key - Libgcrypt expects
2138        * this.
2139        */
2140       mpi_list = xtrycalloc (3, sizeof *mpi_list);
2141       if (!mpi_list)
2142         {
2143           err = gpg_error_from_syserror ();
2144           goto out;
2145         }
2146
2147       err = stream_read_blob (stream, 0, &mpi_list[0]);
2148       if (err)
2149         goto out;
2150       if (secret)
2151         {
2152           u32 len = 0;
2153           unsigned char *buffer;
2154
2155           /* Read string length.  */
2156           err = stream_read_uint32 (stream, &len);
2157           if (err)
2158             goto out;
2159           if (len != 32 && len != 64)
2160             {
2161               err = gpg_error (GPG_ERR_BAD_SECKEY);
2162               goto out;
2163             }
2164           buffer = xtrymalloc_secure (32);
2165           if (!buffer)
2166             {
2167               err = gpg_error_from_syserror ();
2168               goto out;
2169             }
2170           err = stream_read_data (stream, buffer, 32);
2171           if (err)
2172             {
2173               xfree (buffer);
2174               goto out;
2175             }
2176           mpi_list[1] = gcry_mpi_set_opaque (NULL, buffer, 8*32);
2177           buffer = NULL;
2178           if (len == 64)
2179             {
2180               err = stream_read_skip (stream, 32);
2181               if (err)
2182                 goto out;
2183             }
2184         }
2185     }
2186   else if ((spec.flags & SPEC_FLAG_IS_ECDSA))
2187     {
2188       /* The format of an ECDSA key is:
2189        *   string       key_type ("ecdsa-sha2-nistp256" |
2190        *                          "ecdsa-sha2-nistp384" |
2191        *                          "ecdsa-sha2-nistp521" )
2192        *   string       ecdsa_curve_name
2193        *   string       ecdsa_public_key
2194        *   mpint        ecdsa_private
2195        *
2196        * Note that we use the mpint reader instead of the string
2197        * reader for ecsa_public_key.
2198        */
2199       unsigned char *buffer;
2200       const char *mapped;
2201
2202       err = stream_read_string (stream, 0, &buffer, NULL);
2203       if (err)
2204         goto out;
2205       curve_name = buffer;
2206       /* Fixme: Check that curve_name matches the keytype.  */
2207       /* Because Libgcrypt < 1.6 has no support for the "nistpNNN"
2208          curve names, we need to translate them here to Libgcrypt's
2209          native names.  */
2210       if (!strcmp (curve_name, "nistp256"))
2211         mapped = "NIST P-256";
2212       else if (!strcmp (curve_name, "nistp384"))
2213         mapped = "NIST P-384";
2214       else if (!strcmp (curve_name, "nistp521"))
2215         mapped = "NIST P-521";
2216       else
2217         mapped = NULL;
2218       if (mapped)
2219         {
2220           xfree (curve_name);
2221           curve_name = xtrystrdup (mapped);
2222           if (!curve_name)
2223             {
2224               err = gpg_error_from_syserror ();
2225               goto out;
2226             }
2227         }
2228
2229       err = ssh_receive_mpint_list (stream, secret, spec, &mpi_list);
2230       if (err)
2231         goto out;
2232     }
2233   else
2234     {
2235       err = ssh_receive_mpint_list (stream, secret, spec, &mpi_list);
2236       if (err)
2237         goto out;
2238     }
2239
2240   if (read_comment)
2241     {
2242       err = stream_read_cstring (stream, &comment);
2243       if (err)
2244         goto out;
2245     }
2246
2247   if (secret)
2248     elems = spec.elems_key_secret;
2249   else
2250     elems = spec.elems_key_public;
2251
2252   if (spec.key_modifier)
2253     {
2254       err = (*spec.key_modifier) (elems, mpi_list);
2255       if (err)
2256         goto out;
2257     }
2258
2259   if ((spec.flags & SPEC_FLAG_IS_EdDSA))
2260     {
2261       if (secret)
2262         {
2263           err = gcry_sexp_build (&key, NULL,
2264                                  "(private-key(ecc(curve \"Ed25519\")"
2265                                  "(flags eddsa)(q %m)(d %m))"
2266                                  "(comment%s))",
2267                                  mpi_list[0], mpi_list[1],
2268                                  comment? comment:"");
2269         }
2270       else
2271         {
2272           err = gcry_sexp_build (&key, NULL,
2273                                  "(public-key(ecc(curve \"Ed25519\")"
2274                                  "(flags eddsa)(q %m))"
2275                                  "(comment%s))",
2276                                  mpi_list[0],
2277                                  comment? comment:"");
2278         }
2279     }
2280   else
2281     {
2282       err = sexp_key_construct (&key, spec, secret, curve_name, mpi_list,
2283                                 comment? comment:"");
2284       if (err)
2285         goto out;
2286     }
2287
2288   if (key_spec)
2289     *key_spec = spec;
2290   *key_new = key;
2291
2292  out:
2293   mpint_list_free (mpi_list);
2294   xfree (curve_name);
2295   xfree (key_type);
2296   xfree (comment);
2297
2298   return err;
2299 }
2300
2301
2302 /* Write the public key from KEY to STREAM in SSH key format.  If
2303    OVERRIDE_COMMENT is not NULL, it will be used instead of the
2304    comment stored in the key.  */
2305 static gpg_error_t
2306 ssh_send_key_public (estream_t stream, gcry_sexp_t key,
2307                      const char *override_comment)
2308 {
2309   ssh_key_type_spec_t spec;
2310   char *key_type = NULL;
2311   char *comment = NULL;
2312   void *blob = NULL;
2313   size_t bloblen;
2314   gpg_error_t err;
2315
2316   err = sexp_extract_identifier (key, &key_type);
2317   if (err)
2318     goto out;
2319
2320   err = ssh_key_type_lookup (NULL, key_type, &spec);
2321   if (err)
2322     goto out;
2323
2324   err = ssh_key_to_blob (key, 0, spec, &blob, &bloblen);
2325   if (err)
2326     goto out;
2327
2328   err = stream_write_string (stream, blob, bloblen);
2329   if (err)
2330     goto out;
2331
2332   if (override_comment)
2333     err = stream_write_cstring (stream, override_comment);
2334   else
2335     {
2336       err = ssh_key_extract_comment (key, &comment);
2337       if (err)
2338         err = stream_write_cstring (stream, "(none)");
2339       else
2340         err = stream_write_cstring (stream, comment);
2341     }
2342   if (err)
2343     goto out;
2344
2345  out:
2346   xfree (key_type);
2347   xfree (comment);
2348   es_free (blob);
2349
2350   return err;
2351 }
2352
2353
2354 /* Read a public key out of BLOB/BLOB_SIZE according to the key
2355    specification given as KEY_SPEC, storing the new key in KEY_PUBLIC.
2356    Returns zero on success or an error code.  */
2357 static gpg_error_t
2358 ssh_read_key_public_from_blob (unsigned char *blob, size_t blob_size,
2359                                gcry_sexp_t *key_public,
2360                                ssh_key_type_spec_t *key_spec)
2361 {
2362   gpg_error_t err;
2363   estream_t blob_stream;
2364
2365   blob_stream = es_fopenmem (0, "r+b");
2366   if (!blob_stream)
2367     {
2368       err = gpg_error_from_syserror ();
2369       goto out;
2370     }
2371
2372   err = stream_write_data (blob_stream, blob, blob_size);
2373   if (err)
2374     goto out;
2375
2376   err = es_fseek (blob_stream, 0, SEEK_SET);
2377   if (err)
2378     goto out;
2379
2380   err = ssh_receive_key (blob_stream, key_public, 0, 0, key_spec);
2381
2382  out:
2383   es_fclose (blob_stream);
2384   return err;
2385 }
2386
2387 \f
2388
2389 /* This function calculates the key grip for the key contained in the
2390    S-Expression KEY and writes it to BUFFER, which must be large
2391    enough to hold it.  Returns usual error code.  */
2392 static gpg_error_t
2393 ssh_key_grip (gcry_sexp_t key, unsigned char *buffer)
2394 {
2395   if (!gcry_pk_get_keygrip (key, buffer))
2396     {
2397       gpg_error_t err = gcry_pk_testkey (key);
2398       return err? err : gpg_error (GPG_ERR_INTERNAL);
2399     }
2400
2401   return 0;
2402 }
2403
2404
2405 /* Check whether a smartcard is available and whether it has a usable
2406    key.  Store a copy of that key at R_PK and return 0.  If no key is
2407    available store NULL at R_PK and return an error code.  If CARDSN
2408    is not NULL, a string with the serial number of the card will be
2409    a malloced and stored there. */
2410 static gpg_error_t
2411 card_key_available (ctrl_t ctrl, gcry_sexp_t *r_pk, char **cardsn)
2412 {
2413   gpg_error_t err;
2414   char *authkeyid;
2415   char *serialno = NULL;
2416   unsigned char *pkbuf;
2417   size_t pkbuflen;
2418   gcry_sexp_t s_pk;
2419   unsigned char grip[20];
2420
2421   *r_pk = NULL;
2422   if (cardsn)
2423     *cardsn = NULL;
2424
2425   /* First see whether a card is available and whether the application
2426      is supported.  */
2427   err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
2428   if ( gpg_err_code (err) == GPG_ERR_CARD_REMOVED )
2429     {
2430       /* Ask for the serial number to reset the card.  */
2431       err = agent_card_serialno (ctrl, &serialno);
2432       if (err)
2433         {
2434           if (opt.verbose)
2435             log_info (_("error getting serial number of card: %s\n"),
2436                       gpg_strerror (err));
2437           return err;
2438         }
2439       log_info (_("detected card with S/N: %s\n"), serialno);
2440       err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
2441     }
2442   if (err)
2443     {
2444       log_error (_("no authentication key for ssh on card: %s\n"),
2445                  gpg_strerror (err));
2446       xfree (serialno);
2447       return err;
2448     }
2449
2450   /* Get the S/N if we don't have it yet.  Use the fast getattr method.  */
2451   if (!serialno && (err = agent_card_getattr (ctrl, "SERIALNO", &serialno)) )
2452     {
2453       log_error (_("error getting serial number of card: %s\n"),
2454                  gpg_strerror (err));
2455       xfree (authkeyid);
2456       return err;
2457     }
2458
2459   /* Read the public key.  */
2460   err = agent_card_readkey (ctrl, authkeyid, &pkbuf);
2461   if (err)
2462     {
2463       if (opt.verbose)
2464         log_info (_("no suitable card key found: %s\n"), gpg_strerror (err));
2465       xfree (serialno);
2466       xfree (authkeyid);
2467       return err;
2468     }
2469
2470   pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
2471   err = gcry_sexp_sscan (&s_pk, NULL, (char*)pkbuf, pkbuflen);
2472   if (err)
2473     {
2474       log_error ("failed to build S-Exp from received card key: %s\n",
2475                  gpg_strerror (err));
2476       xfree (pkbuf);
2477       xfree (serialno);
2478       xfree (authkeyid);
2479       return err;
2480     }
2481
2482   err = ssh_key_grip (s_pk, grip);
2483   if (err)
2484     {
2485       log_debug ("error computing keygrip from received card key: %s\n",
2486                  gcry_strerror (err));
2487       xfree (pkbuf);
2488       gcry_sexp_release (s_pk);
2489       xfree (serialno);
2490       xfree (authkeyid);
2491       return err;
2492     }
2493
2494   if ( agent_key_available (grip) )
2495     {
2496       /* (Shadow)-key is not available in our key storage.  */
2497       unsigned char *shadow_info;
2498       unsigned char *tmp;
2499
2500       shadow_info = make_shadow_info (serialno, authkeyid);
2501       if (!shadow_info)
2502         {
2503           err = gpg_error_from_syserror ();
2504           xfree (pkbuf);
2505           gcry_sexp_release (s_pk);
2506           xfree (serialno);
2507           xfree (authkeyid);
2508           return err;
2509         }
2510       err = agent_shadow_key (pkbuf, shadow_info, &tmp);
2511       xfree (shadow_info);
2512       if (err)
2513         {
2514           log_error (_("shadowing the key failed: %s\n"), gpg_strerror (err));
2515           xfree (pkbuf);
2516           gcry_sexp_release (s_pk);
2517           xfree (serialno);
2518           xfree (authkeyid);
2519           return err;
2520         }
2521       xfree (pkbuf);
2522       pkbuf = tmp;
2523       pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
2524       assert (pkbuflen);
2525
2526       err = agent_write_private_key (grip, pkbuf, pkbuflen, 0);
2527       if (err)
2528         {
2529           log_error (_("error writing key: %s\n"), gpg_strerror (err));
2530           xfree (pkbuf);
2531           gcry_sexp_release (s_pk);
2532           xfree (serialno);
2533           xfree (authkeyid);
2534           return err;
2535         }
2536     }
2537
2538   if (cardsn)
2539     {
2540       char *dispsn;
2541
2542       /* If the card handler is able to return a short serialnumber,
2543          use that one, else use the complete serialno. */
2544       if (!agent_card_getattr (ctrl, "$DISPSERIALNO", &dispsn))
2545         {
2546           *cardsn = xtryasprintf ("cardno:%s", dispsn);
2547           xfree (dispsn);
2548         }
2549       else
2550         *cardsn = xtryasprintf ("cardno:%s", serialno);
2551       if (!*cardsn)
2552         {
2553           err = gpg_error_from_syserror ();
2554           xfree (pkbuf);
2555           gcry_sexp_release (s_pk);
2556           xfree (serialno);
2557           xfree (authkeyid);
2558           return err;
2559         }
2560     }
2561
2562   xfree (pkbuf);
2563   xfree (serialno);
2564   xfree (authkeyid);
2565   *r_pk = s_pk;
2566   return 0;
2567 }
2568
2569
2570 \f
2571
2572 /*
2573
2574   Request handler.  Each handler is provided with a CTRL context, a
2575   REQUEST object and a RESPONSE object.  The actual request is to be
2576   read from REQUEST, the response needs to be written to RESPONSE.
2577
2578 */
2579
2580
2581 /* Handler for the "request_identities" command.  */
2582 static gpg_error_t
2583 ssh_handler_request_identities (ctrl_t ctrl,
2584                                 estream_t request, estream_t response)
2585 {
2586   ssh_key_type_spec_t spec;
2587   char *key_fname = NULL;
2588   char *fnameptr;
2589   u32 key_counter;
2590   estream_t key_blobs;
2591   gcry_sexp_t key_secret;
2592   gcry_sexp_t key_public;
2593   gpg_error_t err;
2594   int ret;
2595   ssh_control_file_t cf = NULL;
2596   char *cardsn;
2597   gpg_error_t ret_err;
2598
2599   (void)request;
2600
2601   /* Prepare buffer stream.  */
2602
2603   key_secret = NULL;
2604   key_public = NULL;
2605   key_counter = 0;
2606   err = 0;
2607
2608   key_blobs = es_fopenmem (0, "r+b");
2609   if (! key_blobs)
2610     {
2611       err = gpg_error_from_syserror ();
2612       goto out;
2613     }
2614
2615   /* First check whether a key is currently available in the card
2616      reader - this should be allowed even without being listed in
2617      sshcontrol. */
2618
2619   if (!opt.disable_scdaemon
2620       && !card_key_available (ctrl, &key_public, &cardsn))
2621     {
2622       err = ssh_send_key_public (key_blobs, key_public, cardsn);
2623       gcry_sexp_release (key_public);
2624       key_public = NULL;
2625       xfree (cardsn);
2626       if (err)
2627         goto out;
2628
2629       key_counter++;
2630     }
2631
2632
2633   /* Prepare buffer for key name construction.  */
2634   {
2635     char *dname;
2636
2637     dname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, NULL);
2638     if (!dname)
2639       {
2640         err = gpg_err_code_from_syserror ();
2641         goto out;
2642       }
2643
2644     key_fname = xtrymalloc (strlen (dname) + 1 + 40 + 4 + 1);
2645     if (!key_fname)
2646       {
2647         err = gpg_err_code_from_syserror ();
2648         xfree (dname);
2649         goto out;
2650       }
2651     fnameptr = stpcpy (stpcpy (key_fname, dname), "/");
2652     xfree (dname);
2653   }
2654
2655   /* Then look at all the registered and non-disabled keys. */
2656   err = open_control_file (&cf, 0);
2657   if (err)
2658     goto out;
2659
2660   while (!read_control_file_item (cf))
2661     {
2662       if (!cf->item.valid)
2663         continue; /* Should not happen.  */
2664       if (cf->item.disabled)
2665         continue;
2666       assert (strlen (cf->item.hexgrip) == 40);
2667
2668       stpcpy (stpcpy (fnameptr, cf->item.hexgrip), ".key");
2669
2670       /* Read file content.  */
2671       {
2672         unsigned char *buffer;
2673         size_t buffer_n;
2674
2675         err = file_to_buffer (key_fname, &buffer, &buffer_n);
2676         if (err)
2677           {
2678             log_error ("%s:%d: key '%s' skipped: %s\n",
2679                        cf->fname, cf->lnr, cf->item.hexgrip,
2680                        gpg_strerror (err));
2681             continue;
2682           }
2683
2684         err = gcry_sexp_sscan (&key_secret, NULL, (char*)buffer, buffer_n);
2685         xfree (buffer);
2686         if (err)
2687           goto out;
2688       }
2689
2690       {
2691         char *key_type = NULL;
2692
2693         err = sexp_extract_identifier (key_secret, &key_type);
2694         if (err)
2695           goto out;
2696
2697         err = ssh_key_type_lookup (NULL, key_type, &spec);
2698         xfree (key_type);
2699         if (err)
2700           goto out;
2701       }
2702
2703       err = ssh_send_key_public (key_blobs, key_secret, NULL);
2704       if (err)
2705         goto out;
2706       gcry_sexp_release (key_secret);
2707       key_secret = NULL;
2708
2709       key_counter++;
2710     }
2711   err = 0;
2712
2713   ret = es_fseek (key_blobs, 0, SEEK_SET);
2714   if (ret)
2715     {
2716       err = gpg_error_from_syserror ();
2717       goto out;
2718     }
2719
2720  out:
2721   /* Send response.  */
2722
2723   gcry_sexp_release (key_secret);
2724   gcry_sexp_release (key_public);
2725
2726   if (!err)
2727     {
2728       ret_err = stream_write_byte (response, SSH_RESPONSE_IDENTITIES_ANSWER);
2729       if (!ret_err)
2730         ret_err = stream_write_uint32 (response, key_counter);
2731       if (!ret_err)
2732         ret_err = stream_copy (response, key_blobs);
2733     }
2734   else
2735     {
2736       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2737     }
2738
2739   es_fclose (key_blobs);
2740   close_control_file (cf);
2741   xfree (key_fname);
2742
2743   return ret_err;
2744 }
2745
2746
2747 /* This function hashes the data contained in DATA of size DATA_N
2748    according to the message digest algorithm specified by MD_ALGORITHM
2749    and writes the message digest to HASH, which needs to large enough
2750    for the digest.  */
2751 static gpg_error_t
2752 data_hash (unsigned char *data, size_t data_n,
2753            int md_algorithm, unsigned char *hash)
2754 {
2755   gcry_md_hash_buffer (md_algorithm, hash, data, data_n);
2756
2757   return 0;
2758 }
2759
2760
2761 /* This function signs the data described by CTRL. If HASH is is not
2762    NULL, (HASH,HASHLEN) overrides the hash stored in CTRL.  This is to
2763    allow the use of signature algorithms that implement the hashing
2764    internally (e.g. Ed25519).  On success the created signature is
2765    stored in ssh format at R_SIG and it's size at R_SIGLEN; the caller
2766    must use es_free to releaase this memory.  */
2767 static gpg_error_t
2768 data_sign (ctrl_t ctrl, ssh_key_type_spec_t *spec,
2769            const void *hash, size_t hashlen,
2770            unsigned char **r_sig, size_t *r_siglen)
2771 {
2772   gpg_error_t err;
2773   gcry_sexp_t signature_sexp = NULL;
2774   estream_t stream = NULL;
2775   void *blob = NULL;
2776   size_t bloblen;
2777   char hexgrip[40+1];
2778
2779   *r_sig = NULL;
2780   *r_siglen = 0;
2781
2782   /* Quick check to see whether we have a valid keygrip and convert it
2783      to hex.  */
2784   if (!ctrl->have_keygrip)
2785     {
2786       err = gpg_error (GPG_ERR_NO_SECKEY);
2787       goto out;
2788     }
2789   bin2hex (ctrl->keygrip, 20, hexgrip);
2790
2791   /* Ask for confirmation if needed.  */
2792   if (confirm_flag_from_sshcontrol (hexgrip))
2793     {
2794       gcry_sexp_t key;
2795       char *fpr, *prompt;
2796       char *comment = NULL;
2797
2798       err = agent_raw_key_from_file (ctrl, ctrl->keygrip, &key);
2799       if (err)
2800         goto out;
2801       err = ssh_get_fingerprint_string (key, &fpr);
2802       if (!err)
2803         {
2804           gcry_sexp_t tmpsxp = gcry_sexp_find_token (key, "comment", 0);
2805           if (tmpsxp)
2806             comment = gcry_sexp_nth_string (tmpsxp, 1);
2807           gcry_sexp_release (tmpsxp);
2808         }
2809       gcry_sexp_release (key);
2810       if (err)
2811         goto out;
2812       prompt = xtryasprintf (L_("An ssh process requested the use of key%%0A"
2813                                 "  %s%%0A"
2814                                 "  (%s)%%0A"
2815                                 "Do you want to allow this?"),
2816                              fpr, comment? comment:"");
2817       xfree (fpr);
2818       gcry_free (comment);
2819       err = agent_get_confirmation (ctrl, prompt, L_("Allow"), L_("Deny"), 0);
2820       xfree (prompt);
2821       if (err)
2822         goto out;
2823     }
2824
2825   /* Create signature.  */
2826   ctrl->use_auth_call = 1;
2827   err = agent_pksign_do (ctrl, NULL,
2828                          L_("Please enter the passphrase "
2829                             "for the ssh key%%0A  %F%%0A  (%c)"),
2830                          &signature_sexp,
2831                          CACHE_MODE_SSH, ttl_from_sshcontrol,
2832                          hash, hashlen);
2833   ctrl->use_auth_call = 0;
2834   if (err)
2835     goto out;
2836
2837   stream = es_fopenmem (0, "r+b");
2838   if (!stream)
2839     {
2840       err = gpg_error_from_syserror ();
2841       goto out;
2842     }
2843
2844   err = stream_write_cstring (stream, spec->ssh_identifier);
2845   if (err)
2846     goto out;
2847
2848   err = spec->signature_encoder (spec, stream, signature_sexp);
2849   if (err)
2850     goto out;
2851
2852   err = es_fclose_snatch (stream, &blob, &bloblen);
2853   if (err)
2854     goto out;
2855   stream = NULL;
2856
2857   *r_sig = blob; blob = NULL;
2858   *r_siglen = bloblen;
2859
2860  out:
2861   xfree (blob);
2862   es_fclose (stream);
2863   gcry_sexp_release (signature_sexp);
2864
2865   return err;
2866 }
2867
2868
2869 /* Handler for the "sign_request" command.  */
2870 static gpg_error_t
2871 ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
2872 {
2873   gcry_sexp_t key = NULL;
2874   ssh_key_type_spec_t spec;
2875   unsigned char hash[MAX_DIGEST_LEN];
2876   unsigned int hash_n;
2877   unsigned char key_grip[20];
2878   unsigned char *key_blob = NULL;
2879   u32 key_blob_size;
2880   unsigned char *data = NULL;
2881   unsigned char *sig = NULL;
2882   size_t sig_n;
2883   u32 data_size;
2884   u32 flags;
2885   gpg_error_t err;
2886   gpg_error_t ret_err;
2887   int hash_algo;
2888
2889   /* Receive key.  */
2890
2891   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2892   if (err)
2893     goto out;
2894
2895   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, &spec);
2896   if (err)
2897     goto out;
2898
2899   /* Receive data to sign.  */
2900   err = stream_read_string (request, 0, &data, &data_size);
2901   if (err)
2902     goto out;
2903
2904   /* FIXME?  */
2905   err = stream_read_uint32 (request, &flags);
2906   if (err)
2907     goto out;
2908
2909   hash_algo = spec.hash_algo;
2910   if (!hash_algo)
2911     hash_algo = GCRY_MD_SHA1;  /* Use the default.  */
2912   ctrl->digest.algo = hash_algo;
2913   if ((spec.flags & SPEC_FLAG_USE_PKCS1V2))
2914     ctrl->digest.raw_value = 0;
2915   else
2916     ctrl->digest.raw_value = 1;
2917
2918   /* Calculate key grip.  */
2919   err = ssh_key_grip (key, key_grip);
2920   if (err)
2921     goto out;
2922   ctrl->have_keygrip = 1;
2923   memcpy (ctrl->keygrip, key_grip, 20);
2924
2925   /* Hash data unless we use EdDSA.  */
2926   if ((spec.flags & SPEC_FLAG_IS_EdDSA))
2927     {
2928       ctrl->digest.valuelen = 0;
2929     }
2930   else
2931     {
2932       hash_n = gcry_md_get_algo_dlen (hash_algo);
2933       if (!hash_n)
2934         {
2935           err = gpg_error (GPG_ERR_INTERNAL);
2936           goto out;
2937         }
2938       err = data_hash (data, data_size, hash_algo, hash);
2939       if (err)
2940         goto out;
2941       memcpy (ctrl->digest.value, hash, hash_n);
2942       ctrl->digest.valuelen = hash_n;
2943     }
2944
2945   /* Sign data.  */
2946   if ((spec.flags & SPEC_FLAG_IS_EdDSA))
2947     err = data_sign (ctrl, &spec, data, data_size, &sig, &sig_n);
2948   else
2949     err = data_sign (ctrl, &spec, NULL, 0, &sig, &sig_n);
2950
2951  out:
2952   /* Done.  */
2953   if (!err)
2954     {
2955       ret_err = stream_write_byte (response, SSH_RESPONSE_SIGN_RESPONSE);
2956       if (ret_err)
2957         goto leave;
2958       ret_err = stream_write_string (response, sig, sig_n);
2959       if (ret_err)
2960         goto leave;
2961     }
2962   else
2963     {
2964       log_error ("ssh sign request failed: %s <%s>\n",
2965                  gpg_strerror (err), gpg_strsource (err));
2966       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2967       if (ret_err)
2968         goto leave;
2969     }
2970
2971  leave:
2972
2973   gcry_sexp_release (key);
2974   xfree (key_blob);
2975   xfree (data);
2976   es_free (sig);
2977
2978   return ret_err;
2979 }
2980
2981
2982 /* This function extracts the comment contained in the key
2983    s-expression KEY and stores a copy in COMMENT.  Returns usual error
2984    code.  */
2985 static gpg_error_t
2986 ssh_key_extract_comment (gcry_sexp_t key, char **r_comment)
2987 {
2988   gcry_sexp_t comment_list;
2989
2990   *r_comment = NULL;
2991
2992   comment_list = gcry_sexp_find_token (key, "comment", 0);
2993   if (!comment_list)
2994     return gpg_error (GPG_ERR_INV_SEXP);
2995
2996   *r_comment = gcry_sexp_nth_string (comment_list, 1);
2997   gcry_sexp_release (comment_list);
2998   if (!*r_comment)
2999     return gpg_error (GPG_ERR_INV_SEXP);
3000
3001   return 0;
3002 }
3003
3004
3005 /* This function converts the key contained in the S-Expression KEY
3006    into a buffer, which is protected by the passphrase PASSPHRASE.
3007    Returns usual error code.  */
3008 static gpg_error_t
3009 ssh_key_to_protected_buffer (gcry_sexp_t key, const char *passphrase,
3010                              unsigned char **buffer, size_t *buffer_n)
3011 {
3012   unsigned char *buffer_new;
3013   unsigned int buffer_new_n;
3014   gpg_error_t err;
3015
3016   err = 0;
3017   buffer_new_n = gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, NULL, 0);
3018   buffer_new = xtrymalloc_secure (buffer_new_n);
3019   if (! buffer_new)
3020     {
3021       err = gpg_error_from_syserror ();
3022       goto out;
3023     }
3024
3025   gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, buffer_new, buffer_new_n);
3026   /* FIXME: guarantee?  */
3027
3028   err = agent_protect (buffer_new, passphrase, buffer, buffer_n, 0);
3029
3030  out:
3031
3032   xfree (buffer_new);
3033
3034   return err;
3035 }
3036
3037
3038
3039 /* Callback function to compare the first entered PIN with the one
3040    currently being entered. */
3041 static int
3042 reenter_compare_cb (struct pin_entry_info_s *pi)
3043 {
3044   const char *pin1 = pi->check_cb_arg;
3045
3046   if (!strcmp (pin1, pi->pin))
3047     return 0; /* okay */
3048   return -1;
3049 }
3050
3051
3052 /* Store the ssh KEY into our local key storage and protect it after
3053    asking for a passphrase.  Cache that passphrase.  TTL is the
3054    maximum caching time for that key.  If the key already exists in
3055    our key storage, don't do anything.  When entering a new key also
3056    add an entry to the sshcontrol file.  */
3057 static gpg_error_t
3058 ssh_identity_register (ctrl_t ctrl, ssh_key_type_spec_t *spec,
3059                        gcry_sexp_t key, int ttl, int confirm)
3060 {
3061   gpg_error_t err;
3062   unsigned char key_grip_raw[20];
3063   char key_grip[41];
3064   unsigned char *buffer = NULL;
3065   size_t buffer_n;
3066   char *description = NULL;
3067   const char *description2 = L_("Please re-enter this passphrase");
3068   char *comment = NULL;
3069   char *key_fpr = NULL;
3070   const char *initial_errtext = NULL;
3071   struct pin_entry_info_s *pi = NULL, *pi2;
3072
3073   err = ssh_key_grip (key, key_grip_raw);
3074   if (err)
3075     goto out;
3076
3077   /* Check whether the key is already in our key storage.  Don't do
3078      anything then.  */
3079   if ( !agent_key_available (key_grip_raw) )
3080     goto out; /* Yes, key is available.  */
3081
3082   err = ssh_get_fingerprint_string (key, &key_fpr);
3083   if (err)
3084     goto out;
3085
3086   err = ssh_key_extract_comment (key, &comment);
3087   if (err)
3088     goto out;
3089
3090   if ( asprintf (&description,
3091                  L_("Please enter a passphrase to protect"
3092                     " the received secret key%%0A"
3093                     "   %s%%0A"
3094                     "   %s%%0A"
3095                     "within gpg-agent's key storage"),
3096                  key_fpr, comment ? comment : "") < 0)
3097     {
3098       err = gpg_error_from_syserror ();
3099       goto out;
3100     }
3101
3102   pi = gcry_calloc_secure (2, sizeof (*pi) + MAX_PASSPHRASE_LEN + 1);
3103   if (!pi)
3104     {
3105       err = gpg_error_from_syserror ();
3106       goto out;
3107     }
3108   pi2 = pi + (sizeof *pi + MAX_PASSPHRASE_LEN + 1);
3109   pi->max_length = MAX_PASSPHRASE_LEN + 1;
3110   pi->max_tries = 1;
3111   pi->with_repeat = 1;
3112   pi2->max_length = MAX_PASSPHRASE_LEN + 1;
3113   pi2->max_tries = 1;
3114   pi2->check_cb = reenter_compare_cb;
3115   pi2->check_cb_arg = pi->pin;
3116
3117  next_try:
3118   err = agent_askpin (ctrl, description, NULL, initial_errtext, pi, NULL, 0);
3119   initial_errtext = NULL;
3120   if (err)
3121     goto out;
3122
3123   /* Unless the passphrase is empty or the pinentry told us that
3124      it already did the repetition check, ask to confirm it.  */
3125   if (*pi->pin && !pi->repeat_okay)
3126     {
3127       err = agent_askpin (ctrl, description2, NULL, NULL, pi2, NULL, 0);
3128       if (err == -1)
3129         { /* The re-entered one did not match and the user did not
3130              hit cancel. */
3131           initial_errtext = L_("does not match - try again");
3132           goto next_try;
3133         }
3134     }
3135
3136   err = ssh_key_to_protected_buffer (key, pi->pin, &buffer, &buffer_n);
3137   if (err)
3138     goto out;
3139
3140   /* Store this key to our key storage.  */
3141   err = agent_write_private_key (key_grip_raw, buffer, buffer_n, 0);
3142   if (err)
3143     goto out;
3144
3145   /* Cache this passphrase. */
3146   bin2hex (key_grip_raw, 20, key_grip);
3147   err = agent_put_cache (key_grip, CACHE_MODE_SSH, pi->pin, ttl);
3148   if (err)
3149     goto out;
3150
3151   /* And add an entry to the sshcontrol file.  */
3152   err = add_control_entry (ctrl, spec, key_grip, key_fpr, ttl, confirm);
3153
3154
3155  out:
3156   if (pi && pi->max_length)
3157     wipememory (pi->pin, pi->max_length);
3158   xfree (pi);
3159   xfree (buffer);
3160   xfree (comment);
3161   xfree (key_fpr);
3162   xfree (description);
3163
3164   return err;
3165 }
3166
3167
3168 /* This function removes the key contained in the S-Expression KEY
3169    from the local key storage, in case it exists there.  Returns usual
3170    error code.  FIXME: this function is a stub.  */
3171 static gpg_error_t
3172 ssh_identity_drop (gcry_sexp_t key)
3173 {
3174   unsigned char key_grip[21] = { 0 };
3175   gpg_error_t err;
3176
3177   err = ssh_key_grip (key, key_grip);
3178   if (err)
3179     goto out;
3180
3181   key_grip[sizeof (key_grip) - 1] = 0;
3182
3183   /* FIXME: What to do here - forgetting the passphrase or deleting
3184      the key from key cache?  */
3185
3186  out:
3187
3188   return err;
3189 }
3190
3191 /* Handler for the "add_identity" command.  */
3192 static gpg_error_t
3193 ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
3194 {
3195   gpg_error_t ret_err;
3196   ssh_key_type_spec_t spec;
3197   gpg_error_t err;
3198   gcry_sexp_t key;
3199   unsigned char b;
3200   int confirm;
3201   int ttl;
3202
3203   confirm = 0;
3204   key = NULL;
3205   ttl = 0;
3206
3207   /* FIXME?  */
3208   err = ssh_receive_key (request, &key, 1, 1, &spec);
3209   if (err)
3210     goto out;
3211
3212   while (1)
3213     {
3214       err = stream_read_byte (request, &b);
3215       if (gpg_err_code (err) == GPG_ERR_EOF)
3216         {
3217           err = 0;
3218           break;
3219         }
3220
3221       switch (b)
3222         {
3223         case SSH_OPT_CONSTRAIN_LIFETIME:
3224           {
3225             u32 n = 0;
3226
3227             err = stream_read_uint32 (request, &n);
3228             if (! err)
3229               ttl = n;
3230             break;
3231           }
3232
3233         case SSH_OPT_CONSTRAIN_CONFIRM:
3234           {
3235             confirm = 1;
3236             break;
3237           }
3238
3239         default:
3240           /* FIXME: log/bad?  */
3241           break;
3242         }
3243     }
3244   if (err)
3245     goto out;
3246
3247   err = ssh_identity_register (ctrl, &spec, key, ttl, confirm);
3248
3249  out:
3250
3251   gcry_sexp_release (key);
3252
3253   if (! err)
3254     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3255   else
3256     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3257
3258   return ret_err;
3259 }
3260
3261 /* Handler for the "remove_identity" command.  */
3262 static gpg_error_t
3263 ssh_handler_remove_identity (ctrl_t ctrl,
3264                              estream_t request, estream_t response)
3265 {
3266   unsigned char *key_blob;
3267   u32 key_blob_size;
3268   gcry_sexp_t key;
3269   gpg_error_t ret_err;
3270   gpg_error_t err;
3271
3272   (void)ctrl;
3273
3274   /* Receive key.  */
3275
3276   key_blob = NULL;
3277   key = NULL;
3278
3279   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
3280   if (err)
3281     goto out;
3282
3283   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, NULL);
3284   if (err)
3285     goto out;
3286
3287   err = ssh_identity_drop (key);
3288
3289  out:
3290
3291   xfree (key_blob);
3292   gcry_sexp_release (key);
3293
3294   if (! err)
3295     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3296   else
3297     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3298
3299   return ret_err;
3300 }
3301
3302 /* FIXME: stub function.  Actually useful?  */
3303 static gpg_error_t
3304 ssh_identities_remove_all (void)
3305 {
3306   gpg_error_t err;
3307
3308   err = 0;
3309
3310   /* FIXME: shall we remove _all_ cache entries or only those
3311      registered through the ssh emulation?  */
3312
3313   return err;
3314 }
3315
3316 /* Handler for the "remove_all_identities" command.  */
3317 static gpg_error_t
3318 ssh_handler_remove_all_identities (ctrl_t ctrl,
3319                                    estream_t request, estream_t response)
3320 {
3321   gpg_error_t ret_err;
3322   gpg_error_t err;
3323
3324   (void)ctrl;
3325   (void)request;
3326
3327   err = ssh_identities_remove_all ();
3328
3329   if (! err)
3330     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3331   else
3332     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3333
3334   return ret_err;
3335 }
3336
3337 /* Lock agent?  FIXME: stub function.  */
3338 static gpg_error_t
3339 ssh_lock (void)
3340 {
3341   gpg_error_t err;
3342
3343   /* FIXME */
3344   log_error ("ssh-agent's lock command is not implemented\n");
3345   err = 0;
3346
3347   return err;
3348 }
3349
3350 /* Unock agent?  FIXME: stub function.  */
3351 static gpg_error_t
3352 ssh_unlock (void)
3353 {
3354   gpg_error_t err;
3355
3356   log_error ("ssh-agent's unlock command is not implemented\n");
3357   err = 0;
3358
3359   return err;
3360 }
3361
3362 /* Handler for the "lock" command.  */
3363 static gpg_error_t
3364 ssh_handler_lock (ctrl_t ctrl, estream_t request, estream_t response)
3365 {
3366   gpg_error_t ret_err;
3367   gpg_error_t err;
3368
3369   (void)ctrl;
3370   (void)request;
3371
3372   err = ssh_lock ();
3373
3374   if (! err)
3375     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3376   else
3377     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3378
3379   return ret_err;
3380 }
3381
3382 /* Handler for the "unlock" command.  */
3383 static gpg_error_t
3384 ssh_handler_unlock (ctrl_t ctrl, estream_t request, estream_t response)
3385 {
3386   gpg_error_t ret_err;
3387   gpg_error_t err;
3388
3389   (void)ctrl;
3390   (void)request;
3391
3392   err = ssh_unlock ();
3393
3394   if (! err)
3395     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3396   else
3397     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3398
3399   return ret_err;
3400 }
3401
3402 \f
3403
3404 /* Return the request specification for the request identified by TYPE
3405    or NULL in case the requested request specification could not be
3406    found.  */
3407 static ssh_request_spec_t *
3408 request_spec_lookup (int type)
3409 {
3410   ssh_request_spec_t *spec;
3411   unsigned int i;
3412
3413   for (i = 0; i < DIM (request_specs); i++)
3414     if (request_specs[i].type == type)
3415       break;
3416   if (i == DIM (request_specs))
3417     {
3418       if (opt.verbose)
3419         log_info ("ssh request %u is not supported\n", type);
3420       spec = NULL;
3421     }
3422   else
3423     spec = request_specs + i;
3424
3425   return spec;
3426 }
3427
3428 /* Process a single request.  The request is read from and the
3429    response is written to STREAM_SOCK.  Uses CTRL as context.  Returns
3430    zero in case of success, non zero in case of failure.  */
3431 static int
3432 ssh_request_process (ctrl_t ctrl, estream_t stream_sock)
3433 {
3434   ssh_request_spec_t *spec;
3435   estream_t response = NULL;
3436   estream_t request = NULL;
3437   unsigned char request_type;
3438   gpg_error_t err;
3439   int send_err = 0;
3440   int ret;
3441   unsigned char *request_data = NULL;
3442   u32 request_data_size;
3443   u32 response_size;
3444
3445   /* Create memory streams for request/response data.  The entire
3446      request will be stored in secure memory, since it might contain
3447      secret key material.  The response does not have to be stored in
3448      secure memory, since we never give out secret keys.
3449
3450      Note: we only have little secure memory, but there is NO
3451      possibility of DoS here; only trusted clients are allowed to
3452      connect to the agent.  What could happen is that the agent
3453      returns out-of-secure-memory errors on requests in case the
3454      agent's owner floods his own agent with many large messages.
3455      -moritz */
3456
3457   /* Retrieve request.  */
3458   err = stream_read_string (stream_sock, 1, &request_data, &request_data_size);
3459   if (err)
3460     goto out;
3461
3462   if (opt.verbose > 1)
3463     log_info ("received ssh request of length %u\n",
3464               (unsigned int)request_data_size);
3465
3466   if (! request_data_size)
3467     {
3468       send_err = 1;
3469       goto out;
3470       /* Broken request; FIXME.  */
3471     }
3472
3473   request_type = request_data[0];
3474   spec = request_spec_lookup (request_type);
3475   if (! spec)
3476     {
3477       send_err = 1;
3478       goto out;
3479       /* Unknown request; FIXME.  */
3480     }
3481
3482   if (spec->secret_input)
3483     request = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+b");
3484   else
3485     request = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+b");
3486   if (! request)
3487     {
3488       err = gpg_error_from_syserror ();
3489       goto out;
3490     }
3491   ret = es_setvbuf (request, NULL, _IONBF, 0);
3492   if (ret)
3493     {
3494       err = gpg_error_from_syserror ();
3495       goto out;
3496     }
3497   err = stream_write_data (request, request_data + 1, request_data_size - 1);
3498   if (err)
3499     goto out;
3500   es_rewind (request);
3501
3502   response = es_fopenmem (0, "r+b");
3503   if (! response)
3504     {
3505       err = gpg_error_from_syserror ();
3506       goto out;
3507     }
3508
3509   if (opt.verbose)
3510     log_info ("ssh request handler for %s (%u) started\n",
3511                spec->identifier, spec->type);
3512
3513   err = (*spec->handler) (ctrl, request, response);
3514
3515   if (opt.verbose)
3516     {
3517       if (err)
3518         log_info ("ssh request handler for %s (%u) failed: %s\n",
3519                   spec->identifier, spec->type, gpg_strerror (err));
3520       else
3521         log_info ("ssh request handler for %s (%u) ready\n",
3522                   spec->identifier, spec->type);
3523     }
3524
3525   if (err)
3526     {
3527       send_err = 1;
3528       goto out;
3529     }
3530
3531   response_size = es_ftell (response);
3532   if (opt.verbose > 1)
3533     log_info ("sending ssh response of length %u\n",
3534               (unsigned int)response_size);
3535
3536   err = es_fseek (response, 0, SEEK_SET);
3537   if (err)
3538     {
3539       send_err = 1;
3540       goto out;
3541     }
3542
3543   err = stream_write_uint32 (stream_sock, response_size);
3544   if (err)
3545     {
3546       send_err = 1;
3547       goto out;
3548     }
3549
3550   err = stream_copy (stream_sock, response);
3551   if (err)
3552     goto out;
3553
3554   err = es_fflush (stream_sock);
3555   if (err)
3556     goto out;
3557
3558  out:
3559
3560   if (err && es_feof (stream_sock))
3561     log_error ("error occured while processing request: %s\n",
3562                gpg_strerror (err));
3563
3564   if (send_err)
3565     {
3566       if (opt.verbose > 1)
3567         log_info ("sending ssh error response\n");
3568       err = stream_write_uint32 (stream_sock, 1);
3569       if (err)
3570         goto leave;
3571       err = stream_write_byte (stream_sock, SSH_RESPONSE_FAILURE);
3572       if (err)
3573         goto leave;
3574     }
3575
3576  leave:
3577
3578   es_fclose (request);
3579   es_fclose (response);
3580   xfree (request_data);
3581
3582   return !!err;
3583 }
3584
3585
3586 /* Start serving client on SOCK_CLIENT.  */
3587 void
3588 start_command_handler_ssh (ctrl_t ctrl, gnupg_fd_t sock_client)
3589 {
3590   estream_t stream_sock = NULL;
3591   gpg_error_t err;
3592   int ret;
3593
3594   err = agent_copy_startup_env (ctrl);
3595   if (err)
3596     goto out;
3597
3598   /* Create stream from socket.  */
3599   stream_sock = es_fdopen (FD2INT(sock_client), "r+");
3600   if (!stream_sock)
3601     {
3602       err = gpg_error_from_syserror ();
3603       log_error (_("failed to create stream from socket: %s\n"),
3604                  gpg_strerror (err));
3605       goto out;
3606     }
3607   /* We have to disable the estream buffering, because the estream
3608      core doesn't know about secure memory.  */
3609   ret = es_setvbuf (stream_sock, NULL, _IONBF, 0);
3610   if (ret)
3611     {
3612       err = gpg_error_from_syserror ();
3613       log_error ("failed to disable buffering "
3614                  "on socket stream: %s\n", gpg_strerror (err));
3615       goto out;
3616     }
3617
3618   /* Main processing loop. */
3619   while ( !ssh_request_process (ctrl, stream_sock) )
3620     {
3621       /* Check wether we have reached EOF before trying to read
3622          another request.  */
3623       int c;
3624
3625       c = es_fgetc (stream_sock);
3626       if (c == EOF)
3627         break;
3628       es_ungetc (c, stream_sock);
3629     }
3630
3631   /* Reset the SCD in case it has been used. */
3632   agent_reset_scd (ctrl);
3633
3634
3635  out:
3636   if (stream_sock)
3637     es_fclose (stream_sock);
3638 }
3639
3640
3641 #ifdef HAVE_W32_SYSTEM
3642 /* Serve one ssh-agent request.  This is used for the Putty support.
3643    REQUEST is the the mmapped memory which may be accessed up to a
3644    length of MAXREQLEN.  Returns 0 on success which also indicates
3645    that a valid SSH response message is now in REQUEST.  */
3646 int
3647 serve_mmapped_ssh_request (ctrl_t ctrl,
3648                            unsigned char *request, size_t maxreqlen)
3649 {
3650   gpg_error_t err;
3651   int send_err = 0;
3652   int valid_response = 0;
3653   ssh_request_spec_t *spec;
3654   u32 msglen;
3655   estream_t request_stream, response_stream;
3656
3657   if (agent_copy_startup_env (ctrl))
3658     goto leave; /* Error setting up the environment.  */
3659
3660   if (maxreqlen < 5)
3661     goto leave; /* Caller error.  */
3662
3663   msglen = uint32_construct (request[0], request[1], request[2], request[3]);
3664   if (msglen < 1 || msglen > maxreqlen - 4)
3665     {
3666       log_error ("ssh message len (%u) out of range", (unsigned int)msglen);
3667       goto leave;
3668     }
3669
3670   spec = request_spec_lookup (request[4]);
3671   if (!spec)
3672     {
3673       send_err = 1;  /* Unknown request type.  */
3674       goto leave;
3675     }
3676
3677   /* Create a stream object with the data part of the request.  */
3678   if (spec->secret_input)
3679     request_stream = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+");
3680   else
3681     request_stream = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+");
3682   if (!request_stream)
3683     {
3684       err = gpg_error_from_syserror ();
3685       goto leave;
3686     }
3687   /* We have to disable the estream buffering, because the estream
3688      core doesn't know about secure memory.  */
3689   if (es_setvbuf (request_stream, NULL, _IONBF, 0))
3690     {
3691       err = gpg_error_from_syserror ();
3692       goto leave;
3693     }
3694   /* Copy the request to the stream but omit the request type.  */
3695   err = stream_write_data (request_stream, request + 5, msglen - 1);
3696   if (err)
3697     goto leave;
3698   es_rewind (request_stream);
3699
3700   response_stream = es_fopenmem (0, "r+b");
3701   if (!response_stream)
3702     {
3703       err = gpg_error_from_syserror ();
3704       goto leave;
3705     }
3706
3707   if (opt.verbose)
3708     log_info ("ssh request handler for %s (%u) started\n",
3709                spec->identifier, spec->type);
3710
3711   err = (*spec->handler) (ctrl, request_stream, response_stream);
3712
3713   if (opt.verbose)
3714     {
3715       if (err)
3716         log_info ("ssh request handler for %s (%u) failed: %s\n",
3717                   spec->identifier, spec->type, gpg_strerror (err));
3718       else
3719         log_info ("ssh request handler for %s (%u) ready\n",
3720                   spec->identifier, spec->type);
3721     }
3722
3723   es_fclose (request_stream);
3724   request_stream = NULL;
3725
3726   if (err)
3727     {
3728       send_err = 1;
3729       goto leave;
3730     }
3731
3732   /* Put the response back into the mmapped buffer.  */
3733   {
3734     void *response_data;
3735     size_t response_size;
3736
3737     /* NB: In contrast to the request-stream, the response stream
3738        includes the the message type byte.  */
3739     if (es_fclose_snatch (response_stream, &response_data, &response_size))
3740       {
3741         log_error ("snatching ssh response failed: %s",
3742                    gpg_strerror (gpg_error_from_syserror ()));
3743         send_err = 1; /* Ooops.  */
3744         goto leave;
3745       }
3746
3747     if (opt.verbose > 1)
3748       log_info ("sending ssh response of length %u\n",
3749                 (unsigned int)response_size);
3750     if (response_size > maxreqlen - 4)
3751       {
3752         log_error ("invalid length of the ssh response: %s",
3753                    gpg_strerror (GPG_ERR_INTERNAL));
3754         es_free (response_data);
3755         send_err = 1;
3756         goto leave;
3757       }
3758
3759     request[0] = response_size >> 24;
3760     request[1] = response_size >> 16;
3761     request[2] = response_size >>  8;
3762     request[3] = response_size >>  0;
3763     memcpy (request+4, response_data, response_size);
3764     es_free (response_data);
3765     valid_response = 1;
3766   }
3767
3768  leave:
3769   if (send_err)
3770     {
3771       request[0] = 0;
3772       request[1] = 0;
3773       request[2] = 0;
3774       request[3] = 1;
3775       request[4] = SSH_RESPONSE_FAILURE;
3776       valid_response = 1;
3777     }
3778
3779   /* Reset the SCD in case it has been used. */
3780   agent_reset_scd (ctrl);
3781
3782   return valid_response? 0 : -1;
3783 }
3784 #endif /*HAVE_W32_SYSTEM*/