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