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