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