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