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