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