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