agent: Simplify stream_read_cstring.
[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 theres 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   err = 0;
2580
2581   key_blobs = es_fopenmem (0, "r+b");
2582   if (! key_blobs)
2583     {
2584       err = gpg_error_from_syserror ();
2585       goto out;
2586     }
2587
2588   /* First check whether a key is currently available in the card
2589      reader - this should be allowed even without being listed in
2590      sshcontrol. */
2591
2592   if (!opt.disable_scdaemon)
2593     {
2594       char *serialno;
2595       strlist_t card_list, sl;
2596
2597       err = card_key_list (ctrl, &serialno, &card_list);
2598       if (err)
2599         {
2600           if (opt.verbose)
2601             log_info (_("error getting list of cards: %s\n"),
2602                       gpg_strerror (err));
2603           goto scd_out;
2604         }
2605
2606       for (sl = card_list; sl; sl = sl->next)
2607         {
2608           char *serialno0;
2609           char *cardsn;
2610
2611           err = agent_card_serialno (ctrl, &serialno0, sl->d);
2612           if (err)
2613             {
2614               if (opt.verbose)
2615                 log_info (_("error getting serial number of card: %s\n"),
2616                           gpg_strerror (err));
2617               continue;
2618             }
2619
2620           xfree (serialno0);
2621           if (card_key_available (ctrl, &key_public, &cardsn))
2622             continue;
2623
2624           err = ssh_send_key_public (key_blobs, key_public, cardsn);
2625           gcry_sexp_release (key_public);
2626           key_public = NULL;
2627           xfree (cardsn);
2628           if (err)
2629             {
2630               xfree (serialno);
2631               free_strlist (card_list);
2632               goto out;
2633             }
2634
2635           key_counter++;
2636         }
2637
2638       xfree (serialno);
2639       free_strlist (card_list);
2640     }
2641
2642  scd_out:
2643   /* Then look at all the registered and non-disabled keys. */
2644   err = open_control_file (&cf, 0);
2645   if (err)
2646     goto out;
2647
2648   while (!read_control_file_item (cf))
2649     {
2650       unsigned char grip[20];
2651
2652       if (!cf->item.valid)
2653         continue; /* Should not happen.  */
2654       if (cf->item.disabled)
2655         continue;
2656       assert (strlen (cf->item.hexgrip) == 40);
2657       hex2bin (cf->item.hexgrip, grip, sizeof (grip));
2658
2659       err = agent_public_key_from_file (ctrl, grip, &key_public);
2660       if (err)
2661         {
2662           log_error ("%s:%d: key '%s' skipped: %s\n",
2663                      cf->fname, cf->lnr, cf->item.hexgrip,
2664                      gpg_strerror (err));
2665           continue;
2666         }
2667
2668       err = ssh_send_key_public (key_blobs, key_public, NULL);
2669       if (err)
2670         goto out;
2671       gcry_sexp_release (key_public);
2672       key_public = NULL;
2673
2674       key_counter++;
2675     }
2676   err = 0;
2677
2678   ret = es_fseek (key_blobs, 0, SEEK_SET);
2679   if (ret)
2680     {
2681       err = gpg_error_from_syserror ();
2682       goto out;
2683     }
2684
2685  out:
2686   /* Send response.  */
2687
2688   gcry_sexp_release (key_public);
2689
2690   if (!err)
2691     {
2692       ret_err = stream_write_byte (response, SSH_RESPONSE_IDENTITIES_ANSWER);
2693       if (!ret_err)
2694         ret_err = stream_write_uint32 (response, key_counter);
2695       if (!ret_err)
2696         ret_err = stream_copy (response, key_blobs);
2697     }
2698   else
2699     {
2700       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2701     }
2702
2703   es_fclose (key_blobs);
2704   close_control_file (cf);
2705
2706   return ret_err;
2707 }
2708
2709
2710 /* This function hashes the data contained in DATA of size DATA_N
2711    according to the message digest algorithm specified by MD_ALGORITHM
2712    and writes the message digest to HASH, which needs to large enough
2713    for the digest.  */
2714 static gpg_error_t
2715 data_hash (unsigned char *data, size_t data_n,
2716            int md_algorithm, unsigned char *hash)
2717 {
2718   gcry_md_hash_buffer (md_algorithm, hash, data, data_n);
2719
2720   return 0;
2721 }
2722
2723
2724 /* This function signs the data described by CTRL. If HASH is not
2725    NULL, (HASH,HASHLEN) overrides the hash stored in CTRL.  This is to
2726    allow the use of signature algorithms that implement the hashing
2727    internally (e.g. Ed25519).  On success the created signature is
2728    stored in ssh format at R_SIG and it's size at R_SIGLEN; the caller
2729    must use es_free to releaase this memory.  */
2730 static gpg_error_t
2731 data_sign (ctrl_t ctrl, ssh_key_type_spec_t *spec,
2732            const void *hash, size_t hashlen,
2733            unsigned char **r_sig, size_t *r_siglen)
2734 {
2735   gpg_error_t err;
2736   gcry_sexp_t signature_sexp = NULL;
2737   estream_t stream = NULL;
2738   void *blob = NULL;
2739   size_t bloblen;
2740   char hexgrip[40+1];
2741
2742   *r_sig = NULL;
2743   *r_siglen = 0;
2744
2745   /* Quick check to see whether we have a valid keygrip and convert it
2746      to hex.  */
2747   if (!ctrl->have_keygrip)
2748     {
2749       err = gpg_error (GPG_ERR_NO_SECKEY);
2750       goto out;
2751     }
2752   bin2hex (ctrl->keygrip, 20, hexgrip);
2753
2754   /* Ask for confirmation if needed.  */
2755   if (confirm_flag_from_sshcontrol (hexgrip))
2756     {
2757       gcry_sexp_t key;
2758       char *fpr, *prompt;
2759       char *comment = NULL;
2760
2761       err = agent_raw_key_from_file (ctrl, ctrl->keygrip, &key);
2762       if (err)
2763         goto out;
2764       err = ssh_get_fingerprint_string (key, &fpr);
2765       if (!err)
2766         {
2767           gcry_sexp_t tmpsxp = gcry_sexp_find_token (key, "comment", 0);
2768           if (tmpsxp)
2769             comment = gcry_sexp_nth_string (tmpsxp, 1);
2770           gcry_sexp_release (tmpsxp);
2771         }
2772       gcry_sexp_release (key);
2773       if (err)
2774         goto out;
2775       prompt = xtryasprintf (L_("An ssh process requested the use of key%%0A"
2776                                 "  %s%%0A"
2777                                 "  (%s)%%0A"
2778                                 "Do you want to allow this?"),
2779                              fpr, comment? comment:"");
2780       xfree (fpr);
2781       gcry_free (comment);
2782       err = agent_get_confirmation (ctrl, prompt, L_("Allow"), L_("Deny"), 0);
2783       xfree (prompt);
2784       if (err)
2785         goto out;
2786     }
2787
2788   /* Create signature.  */
2789   ctrl->use_auth_call = 1;
2790   err = agent_pksign_do (ctrl, NULL,
2791                          L_("Please enter the passphrase "
2792                             "for the ssh key%%0A  %F%%0A  (%c)"),
2793                          &signature_sexp,
2794                          CACHE_MODE_SSH, ttl_from_sshcontrol,
2795                          hash, hashlen);
2796   ctrl->use_auth_call = 0;
2797   if (err)
2798     goto out;
2799
2800   stream = es_fopenmem (0, "r+b");
2801   if (!stream)
2802     {
2803       err = gpg_error_from_syserror ();
2804       goto out;
2805     }
2806
2807   err = stream_write_cstring (stream, spec->ssh_identifier);
2808   if (err)
2809     goto out;
2810
2811   err = spec->signature_encoder (spec, stream, signature_sexp);
2812   if (err)
2813     goto out;
2814
2815   err = es_fclose_snatch (stream, &blob, &bloblen);
2816   if (err)
2817     goto out;
2818   stream = NULL;
2819
2820   *r_sig = blob; blob = NULL;
2821   *r_siglen = bloblen;
2822
2823  out:
2824   xfree (blob);
2825   es_fclose (stream);
2826   gcry_sexp_release (signature_sexp);
2827
2828   return err;
2829 }
2830
2831
2832 /* Handler for the "sign_request" command.  */
2833 static gpg_error_t
2834 ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
2835 {
2836   gcry_sexp_t key = NULL;
2837   ssh_key_type_spec_t spec;
2838   unsigned char hash[MAX_DIGEST_LEN];
2839   unsigned int hash_n;
2840   unsigned char key_grip[20];
2841   unsigned char *key_blob = NULL;
2842   u32 key_blob_size;
2843   unsigned char *data = NULL;
2844   unsigned char *sig = NULL;
2845   size_t sig_n;
2846   u32 data_size;
2847   u32 flags;
2848   gpg_error_t err;
2849   gpg_error_t ret_err;
2850   int hash_algo;
2851
2852   /* Receive key.  */
2853
2854   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2855   if (err)
2856     goto out;
2857
2858   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, &spec);
2859   if (err)
2860     goto out;
2861
2862   /* Receive data to sign.  */
2863   err = stream_read_string (request, 0, &data, &data_size);
2864   if (err)
2865     goto out;
2866
2867   /* FIXME?  */
2868   err = stream_read_uint32 (request, &flags);
2869   if (err)
2870     goto out;
2871
2872   hash_algo = spec.hash_algo;
2873   if (!hash_algo)
2874     hash_algo = GCRY_MD_SHA1;  /* Use the default.  */
2875   ctrl->digest.algo = hash_algo;
2876   if ((spec.flags & SPEC_FLAG_USE_PKCS1V2))
2877     ctrl->digest.raw_value = 0;
2878   else
2879     ctrl->digest.raw_value = 1;
2880
2881   /* Calculate key grip.  */
2882   err = ssh_key_grip (key, key_grip);
2883   if (err)
2884     goto out;
2885   ctrl->have_keygrip = 1;
2886   memcpy (ctrl->keygrip, key_grip, 20);
2887
2888   /* Hash data unless we use EdDSA.  */
2889   if ((spec.flags & SPEC_FLAG_IS_EdDSA))
2890     {
2891       ctrl->digest.valuelen = 0;
2892     }
2893   else
2894     {
2895       hash_n = gcry_md_get_algo_dlen (hash_algo);
2896       if (!hash_n)
2897         {
2898           err = gpg_error (GPG_ERR_INTERNAL);
2899           goto out;
2900         }
2901       err = data_hash (data, data_size, hash_algo, hash);
2902       if (err)
2903         goto out;
2904       memcpy (ctrl->digest.value, hash, hash_n);
2905       ctrl->digest.valuelen = hash_n;
2906     }
2907
2908   /* Sign data.  */
2909   if ((spec.flags & SPEC_FLAG_IS_EdDSA))
2910     err = data_sign (ctrl, &spec, data, data_size, &sig, &sig_n);
2911   else
2912     err = data_sign (ctrl, &spec, NULL, 0, &sig, &sig_n);
2913
2914  out:
2915   /* Done.  */
2916   if (!err)
2917     {
2918       ret_err = stream_write_byte (response, SSH_RESPONSE_SIGN_RESPONSE);
2919       if (ret_err)
2920         goto leave;
2921       ret_err = stream_write_string (response, sig, sig_n);
2922       if (ret_err)
2923         goto leave;
2924     }
2925   else
2926     {
2927       log_error ("ssh sign request failed: %s <%s>\n",
2928                  gpg_strerror (err), gpg_strsource (err));
2929       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2930       if (ret_err)
2931         goto leave;
2932     }
2933
2934  leave:
2935
2936   gcry_sexp_release (key);
2937   xfree (key_blob);
2938   xfree (data);
2939   es_free (sig);
2940
2941   return ret_err;
2942 }
2943
2944
2945 /* This function extracts the comment contained in the key
2946    s-expression KEY and stores a copy in COMMENT.  Returns usual error
2947    code.  */
2948 static gpg_error_t
2949 ssh_key_extract_comment (gcry_sexp_t key, char **r_comment)
2950 {
2951   gcry_sexp_t comment_list;
2952
2953   *r_comment = NULL;
2954
2955   comment_list = gcry_sexp_find_token (key, "comment", 0);
2956   if (!comment_list)
2957     return gpg_error (GPG_ERR_INV_SEXP);
2958
2959   *r_comment = gcry_sexp_nth_string (comment_list, 1);
2960   gcry_sexp_release (comment_list);
2961   if (!*r_comment)
2962     return gpg_error (GPG_ERR_INV_SEXP);
2963
2964   return 0;
2965 }
2966
2967
2968 /* This function converts the key contained in the S-Expression KEY
2969    into a buffer, which is protected by the passphrase PASSPHRASE.
2970    Returns usual error code.  */
2971 static gpg_error_t
2972 ssh_key_to_protected_buffer (gcry_sexp_t key, const char *passphrase,
2973                              unsigned char **buffer, size_t *buffer_n)
2974 {
2975   unsigned char *buffer_new;
2976   unsigned int buffer_new_n;
2977   gpg_error_t err;
2978
2979   err = 0;
2980   buffer_new_n = gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, NULL, 0);
2981   buffer_new = xtrymalloc_secure (buffer_new_n);
2982   if (! buffer_new)
2983     {
2984       err = gpg_error_from_syserror ();
2985       goto out;
2986     }
2987
2988   gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, buffer_new, buffer_new_n);
2989   /* FIXME: guarantee?  */
2990
2991   err = agent_protect (buffer_new, passphrase, buffer, buffer_n, 0, -1);
2992
2993  out:
2994
2995   xfree (buffer_new);
2996
2997   return err;
2998 }
2999
3000
3001
3002 /* Callback function to compare the first entered PIN with the one
3003    currently being entered. */
3004 static gpg_error_t
3005 reenter_compare_cb (struct pin_entry_info_s *pi)
3006 {
3007   const char *pin1 = pi->check_cb_arg;
3008
3009   if (!strcmp (pin1, pi->pin))
3010     return 0; /* okay */
3011   return gpg_error (GPG_ERR_BAD_PASSPHRASE);
3012 }
3013
3014
3015 /* Store the ssh KEY into our local key storage and protect it after
3016    asking for a passphrase.  Cache that passphrase.  TTL is the
3017    maximum caching time for that key.  If the key already exists in
3018    our key storage, don't do anything.  When entering a key also add
3019    an entry to the sshcontrol file.  */
3020 static gpg_error_t
3021 ssh_identity_register (ctrl_t ctrl, ssh_key_type_spec_t *spec,
3022                        gcry_sexp_t key, int ttl, int confirm)
3023 {
3024   gpg_error_t err;
3025   unsigned char key_grip_raw[20];
3026   char key_grip[41];
3027   unsigned char *buffer = NULL;
3028   size_t buffer_n;
3029   char *description = NULL;
3030   const char *description2 = L_("Please re-enter this passphrase");
3031   char *comment = NULL;
3032   char *key_fpr = NULL;
3033   const char *initial_errtext = NULL;
3034   struct pin_entry_info_s *pi = NULL;
3035   struct pin_entry_info_s *pi2 = NULL;
3036
3037   err = ssh_key_grip (key, key_grip_raw);
3038   if (err)
3039     goto out;
3040
3041   bin2hex (key_grip_raw, 20, key_grip);
3042
3043   err = ssh_get_fingerprint_string (key, &key_fpr);
3044   if (err)
3045     goto out;
3046
3047   /* Check whether the key is already in our key storage.  Don't do
3048      anything then besides (re-)adding it to sshcontrol.  */
3049   if ( !agent_key_available (key_grip_raw) )
3050     goto key_exists; /* Yes, key is available.  */
3051
3052   err = ssh_key_extract_comment (key, &comment);
3053   if (err)
3054     goto out;
3055
3056   if ( asprintf (&description,
3057                  L_("Please enter a passphrase to protect"
3058                     " the received secret key%%0A"
3059                     "   %s%%0A"
3060                     "   %s%%0A"
3061                     "within gpg-agent's key storage"),
3062                  key_fpr, comment ? comment : "") < 0)
3063     {
3064       err = gpg_error_from_syserror ();
3065       goto out;
3066     }
3067
3068   pi = gcry_calloc_secure (1, sizeof (*pi) + MAX_PASSPHRASE_LEN + 1);
3069   if (!pi)
3070     {
3071       err = gpg_error_from_syserror ();
3072       goto out;
3073     }
3074   pi2 = gcry_calloc_secure (1, sizeof (*pi2) + MAX_PASSPHRASE_LEN + 1);
3075   if (!pi2)
3076     {
3077       err = gpg_error_from_syserror ();
3078       goto out;
3079     }
3080   pi->max_length = MAX_PASSPHRASE_LEN + 1;
3081   pi->max_tries = 1;
3082   pi->with_repeat = 1;
3083   pi2->max_length = MAX_PASSPHRASE_LEN + 1;
3084   pi2->max_tries = 1;
3085   pi2->check_cb = reenter_compare_cb;
3086   pi2->check_cb_arg = pi->pin;
3087
3088  next_try:
3089   err = agent_askpin (ctrl, description, NULL, initial_errtext, pi, NULL, 0);
3090   initial_errtext = NULL;
3091   if (err)
3092     goto out;
3093
3094   /* Unless the passphrase is empty or the pinentry told us that
3095      it already did the repetition check, ask to confirm it.  */
3096   if (*pi->pin && !pi->repeat_okay)
3097     {
3098       err = agent_askpin (ctrl, description2, NULL, NULL, pi2, NULL, 0);
3099       if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
3100         { /* The re-entered one did not match and the user did not
3101              hit cancel. */
3102           initial_errtext = L_("does not match - try again");
3103           goto next_try;
3104         }
3105     }
3106
3107   err = ssh_key_to_protected_buffer (key, pi->pin, &buffer, &buffer_n);
3108   if (err)
3109     goto out;
3110
3111   /* Store this key to our key storage.  */
3112   err = agent_write_private_key (key_grip_raw, buffer, buffer_n, 0);
3113   if (err)
3114     goto out;
3115
3116   /* Cache this passphrase. */
3117   err = agent_put_cache (key_grip, CACHE_MODE_SSH, pi->pin, ttl);
3118   if (err)
3119     goto out;
3120
3121  key_exists:
3122   /* And add an entry to the sshcontrol file.  */
3123   err = add_control_entry (ctrl, spec, key_grip, key_fpr, ttl, confirm);
3124
3125
3126  out:
3127   if (pi2 && pi2->max_length)
3128     wipememory (pi2->pin, pi2->max_length);
3129   xfree (pi2);
3130   if (pi && pi->max_length)
3131     wipememory (pi->pin, pi->max_length);
3132   xfree (pi);
3133   xfree (buffer);
3134   xfree (comment);
3135   xfree (key_fpr);
3136   xfree (description);
3137
3138   return err;
3139 }
3140
3141
3142 /* This function removes the key contained in the S-Expression KEY
3143    from the local key storage, in case it exists there.  Returns usual
3144    error code.  FIXME: this function is a stub.  */
3145 static gpg_error_t
3146 ssh_identity_drop (gcry_sexp_t key)
3147 {
3148   unsigned char key_grip[21] = { 0 };
3149   gpg_error_t err;
3150
3151   err = ssh_key_grip (key, key_grip);
3152   if (err)
3153     goto out;
3154
3155   key_grip[sizeof (key_grip) - 1] = 0;
3156
3157   /* FIXME: What to do here - forgetting the passphrase or deleting
3158      the key from key cache?  */
3159
3160  out:
3161
3162   return err;
3163 }
3164
3165 /* Handler for the "add_identity" command.  */
3166 static gpg_error_t
3167 ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
3168 {
3169   gpg_error_t ret_err;
3170   ssh_key_type_spec_t spec;
3171   gpg_error_t err;
3172   gcry_sexp_t key;
3173   unsigned char b;
3174   int confirm;
3175   int ttl;
3176
3177   confirm = 0;
3178   key = NULL;
3179   ttl = 0;
3180
3181   /* FIXME?  */
3182   err = ssh_receive_key (request, &key, 1, 1, &spec);
3183   if (err)
3184     goto out;
3185
3186   while (1)
3187     {
3188       err = stream_read_byte (request, &b);
3189       if (gpg_err_code (err) == GPG_ERR_EOF)
3190         {
3191           err = 0;
3192           break;
3193         }
3194
3195       switch (b)
3196         {
3197         case SSH_OPT_CONSTRAIN_LIFETIME:
3198           {
3199             u32 n = 0;
3200
3201             err = stream_read_uint32 (request, &n);
3202             if (! err)
3203               ttl = n;
3204             break;
3205           }
3206
3207         case SSH_OPT_CONSTRAIN_CONFIRM:
3208           {
3209             confirm = 1;
3210             break;
3211           }
3212
3213         default:
3214           /* FIXME: log/bad?  */
3215           break;
3216         }
3217     }
3218   if (err)
3219     goto out;
3220
3221   err = ssh_identity_register (ctrl, &spec, key, ttl, confirm);
3222
3223  out:
3224
3225   gcry_sexp_release (key);
3226
3227   if (! err)
3228     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3229   else
3230     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3231
3232   return ret_err;
3233 }
3234
3235 /* Handler for the "remove_identity" command.  */
3236 static gpg_error_t
3237 ssh_handler_remove_identity (ctrl_t ctrl,
3238                              estream_t request, estream_t response)
3239 {
3240   unsigned char *key_blob;
3241   u32 key_blob_size;
3242   gcry_sexp_t key;
3243   gpg_error_t ret_err;
3244   gpg_error_t err;
3245
3246   (void)ctrl;
3247
3248   /* Receive key.  */
3249
3250   key_blob = NULL;
3251   key = NULL;
3252
3253   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
3254   if (err)
3255     goto out;
3256
3257   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, NULL);
3258   if (err)
3259     goto out;
3260
3261   err = ssh_identity_drop (key);
3262
3263  out:
3264
3265   xfree (key_blob);
3266   gcry_sexp_release (key);
3267
3268   if (! err)
3269     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3270   else
3271     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3272
3273   return ret_err;
3274 }
3275
3276 /* FIXME: stub function.  Actually useful?  */
3277 static gpg_error_t
3278 ssh_identities_remove_all (void)
3279 {
3280   gpg_error_t err;
3281
3282   err = 0;
3283
3284   /* FIXME: shall we remove _all_ cache entries or only those
3285      registered through the ssh-agent protocol?  */
3286
3287   return err;
3288 }
3289
3290 /* Handler for the "remove_all_identities" command.  */
3291 static gpg_error_t
3292 ssh_handler_remove_all_identities (ctrl_t ctrl,
3293                                    estream_t request, estream_t response)
3294 {
3295   gpg_error_t ret_err;
3296   gpg_error_t err;
3297
3298   (void)ctrl;
3299   (void)request;
3300
3301   err = ssh_identities_remove_all ();
3302
3303   if (! err)
3304     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3305   else
3306     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3307
3308   return ret_err;
3309 }
3310
3311 /* Lock agent?  FIXME: stub function.  */
3312 static gpg_error_t
3313 ssh_lock (void)
3314 {
3315   gpg_error_t err;
3316
3317   /* FIXME */
3318   log_error ("ssh-agent's lock command is not implemented\n");
3319   err = 0;
3320
3321   return err;
3322 }
3323
3324 /* Unock agent?  FIXME: stub function.  */
3325 static gpg_error_t
3326 ssh_unlock (void)
3327 {
3328   gpg_error_t err;
3329
3330   log_error ("ssh-agent's unlock command is not implemented\n");
3331   err = 0;
3332
3333   return err;
3334 }
3335
3336 /* Handler for the "lock" command.  */
3337 static gpg_error_t
3338 ssh_handler_lock (ctrl_t ctrl, estream_t request, estream_t response)
3339 {
3340   gpg_error_t ret_err;
3341   gpg_error_t err;
3342
3343   (void)ctrl;
3344   (void)request;
3345
3346   err = ssh_lock ();
3347
3348   if (! err)
3349     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3350   else
3351     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3352
3353   return ret_err;
3354 }
3355
3356 /* Handler for the "unlock" command.  */
3357 static gpg_error_t
3358 ssh_handler_unlock (ctrl_t ctrl, estream_t request, estream_t response)
3359 {
3360   gpg_error_t ret_err;
3361   gpg_error_t err;
3362
3363   (void)ctrl;
3364   (void)request;
3365
3366   err = ssh_unlock ();
3367
3368   if (! err)
3369     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
3370   else
3371     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
3372
3373   return ret_err;
3374 }
3375
3376 \f
3377
3378 /* Return the request specification for the request identified by TYPE
3379    or NULL in case the requested request specification could not be
3380    found.  */
3381 static ssh_request_spec_t *
3382 request_spec_lookup (int type)
3383 {
3384   ssh_request_spec_t *spec;
3385   unsigned int i;
3386
3387   for (i = 0; i < DIM (request_specs); i++)
3388     if (request_specs[i].type == type)
3389       break;
3390   if (i == DIM (request_specs))
3391     {
3392       if (opt.verbose)
3393         log_info ("ssh request %u is not supported\n", type);
3394       spec = NULL;
3395     }
3396   else
3397     spec = request_specs + i;
3398
3399   return spec;
3400 }
3401
3402 /* Process a single request.  The request is read from and the
3403    response is written to STREAM_SOCK.  Uses CTRL as context.  Returns
3404    zero in case of success, non zero in case of failure.  */
3405 static int
3406 ssh_request_process (ctrl_t ctrl, estream_t stream_sock)
3407 {
3408   ssh_request_spec_t *spec;
3409   estream_t response = NULL;
3410   estream_t request = NULL;
3411   unsigned char request_type;
3412   gpg_error_t err;
3413   int send_err = 0;
3414   int ret;
3415   unsigned char *request_data = NULL;
3416   u32 request_data_size;
3417   u32 response_size;
3418
3419   /* Create memory streams for request/response data.  The entire
3420      request will be stored in secure memory, since it might contain
3421      secret key material.  The response does not have to be stored in
3422      secure memory, since we never give out secret keys.
3423
3424      Note: we only have little secure memory, but there is NO
3425      possibility of DoS here; only trusted clients are allowed to
3426      connect to the agent.  What could happen is that the agent
3427      returns out-of-secure-memory errors on requests in case the
3428      agent's owner floods his own agent with many large messages.
3429      -moritz */
3430
3431   /* Retrieve request.  */
3432   err = stream_read_string (stream_sock, 1, &request_data, &request_data_size);
3433   if (err)
3434     goto out;
3435
3436   if (opt.verbose > 1)
3437     log_info ("received ssh request of length %u\n",
3438               (unsigned int)request_data_size);
3439
3440   if (! request_data_size)
3441     {
3442       send_err = 1;
3443       goto out;
3444       /* Broken request; FIXME.  */
3445     }
3446
3447   request_type = request_data[0];
3448   spec = request_spec_lookup (request_type);
3449   if (! spec)
3450     {
3451       send_err = 1;
3452       goto out;
3453       /* Unknown request; FIXME.  */
3454     }
3455
3456   if (spec->secret_input)
3457     request = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+b");
3458   else
3459     request = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+b");
3460   if (! request)
3461     {
3462       err = gpg_error_from_syserror ();
3463       goto out;
3464     }
3465   ret = es_setvbuf (request, NULL, _IONBF, 0);
3466   if (ret)
3467     {
3468       err = gpg_error_from_syserror ();
3469       goto out;
3470     }
3471   err = stream_write_data (request, request_data + 1, request_data_size - 1);
3472   if (err)
3473     goto out;
3474   es_rewind (request);
3475
3476   response = es_fopenmem (0, "r+b");
3477   if (! response)
3478     {
3479       err = gpg_error_from_syserror ();
3480       goto out;
3481     }
3482
3483   if (opt.verbose)
3484     log_info ("ssh request handler for %s (%u) started\n",
3485                spec->identifier, spec->type);
3486
3487   err = (*spec->handler) (ctrl, request, response);
3488
3489   if (opt.verbose)
3490     {
3491       if (err)
3492         log_info ("ssh request handler for %s (%u) failed: %s\n",
3493                   spec->identifier, spec->type, gpg_strerror (err));
3494       else
3495         log_info ("ssh request handler for %s (%u) ready\n",
3496                   spec->identifier, spec->type);
3497     }
3498
3499   if (err)
3500     {
3501       send_err = 1;
3502       goto out;
3503     }
3504
3505   response_size = es_ftell (response);
3506   if (opt.verbose > 1)
3507     log_info ("sending ssh response of length %u\n",
3508               (unsigned int)response_size);
3509
3510   err = es_fseek (response, 0, SEEK_SET);
3511   if (err)
3512     {
3513       send_err = 1;
3514       goto out;
3515     }
3516
3517   err = stream_write_uint32 (stream_sock, response_size);
3518   if (err)
3519     {
3520       send_err = 1;
3521       goto out;
3522     }
3523
3524   err = stream_copy (stream_sock, response);
3525   if (err)
3526     goto out;
3527
3528   err = es_fflush (stream_sock);
3529   if (err)
3530     goto out;
3531
3532  out:
3533
3534   if (err && es_feof (stream_sock))
3535     log_error ("error occurred while processing request: %s\n",
3536                gpg_strerror (err));
3537
3538   if (send_err)
3539     {
3540       if (opt.verbose > 1)
3541         log_info ("sending ssh error response\n");
3542       err = stream_write_uint32 (stream_sock, 1);
3543       if (err)
3544         goto leave;
3545       err = stream_write_byte (stream_sock, SSH_RESPONSE_FAILURE);
3546       if (err)
3547         goto leave;
3548     }
3549
3550  leave:
3551
3552   es_fclose (request);
3553   es_fclose (response);
3554   xfree (request_data);
3555
3556   return !!err;
3557 }
3558
3559
3560 /* Return the peer's pid.  */
3561 static unsigned long
3562 get_client_pid (int fd)
3563 {
3564   pid_t client_pid = (pid_t)0;
3565
3566 #ifdef SO_PEERCRED
3567   {
3568 #ifdef HAVE_STRUCT_SOCKPEERCRED_PID
3569     struct sockpeercred cr;
3570 #else
3571     struct ucred cr;
3572 #endif
3573     socklen_t cl = sizeof cr;
3574
3575     if (!getsockopt (fd, SOL_SOCKET, SO_PEERCRED, &cr, &cl))
3576       {
3577 #if defined (HAVE_STRUCT_SOCKPEERCRED_PID) || defined (HAVE_STRUCT_UCRED_PID)
3578         client_pid = cr.pid;
3579 #elif defined (HAVE_STRUCT_UCRED_CR_PID)
3580         client_pid = cr.cr_pid;
3581 #else
3582 #error "Unknown SO_PEERCRED struct"
3583 #endif
3584       }
3585   }
3586 #elif defined (LOCAL_PEERPID)
3587   {
3588     socklen_t len = sizeof (pid_t);
3589
3590     getsockopt (fd, SOL_LOCAL, LOCAL_PEERPID, &client_pid, &len);
3591   }
3592 #elif defined (LOCAL_PEEREID)
3593   {
3594     struct unpcbid unp;
3595     socklen_t unpl = sizeof unp;
3596
3597     if (getsockopt (fd, 0, LOCAL_PEEREID, &unp, &unpl) != -1)
3598       client_pid = unp.unp_pid;
3599   }
3600 #elif defined (HAVE_GETPEERUCRED)
3601   {
3602     ucred_t *ucred = NULL;
3603
3604     if (getpeerucred (fd, &ucred) != -1)
3605       {
3606         client_pid= ucred_getpid (ucred);
3607         ucred_free (ucred);
3608       }
3609   }
3610 #else
3611   (void)fd;
3612 #endif
3613
3614   return (unsigned long)client_pid;
3615 }
3616
3617
3618 /* Start serving client on SOCK_CLIENT.  */
3619 void
3620 start_command_handler_ssh (ctrl_t ctrl, gnupg_fd_t sock_client)
3621 {
3622   estream_t stream_sock = NULL;
3623   gpg_error_t err;
3624   int ret;
3625
3626   err = agent_copy_startup_env (ctrl);
3627   if (err)
3628     goto out;
3629
3630   ctrl->client_pid = get_client_pid (FD2INT(sock_client));
3631
3632   /* Create stream from socket.  */
3633   stream_sock = es_fdopen (FD2INT(sock_client), "r+");
3634   if (!stream_sock)
3635     {
3636       err = gpg_error_from_syserror ();
3637       log_error (_("failed to create stream from socket: %s\n"),
3638                  gpg_strerror (err));
3639       goto out;
3640     }
3641   /* We have to disable the estream buffering, because the estream
3642      core doesn't know about secure memory.  */
3643   ret = es_setvbuf (stream_sock, NULL, _IONBF, 0);
3644   if (ret)
3645     {
3646       err = gpg_error_from_syserror ();
3647       log_error ("failed to disable buffering "
3648                  "on socket stream: %s\n", gpg_strerror (err));
3649       goto out;
3650     }
3651
3652   /* Main processing loop. */
3653   while ( !ssh_request_process (ctrl, stream_sock) )
3654     {
3655       /* Check wether we have reached EOF before trying to read
3656          another request.  */
3657       int c;
3658
3659       c = es_fgetc (stream_sock);
3660       if (c == EOF)
3661         break;
3662       es_ungetc (c, stream_sock);
3663     }
3664
3665   /* Reset the SCD in case it has been used. */
3666   agent_reset_scd (ctrl);
3667
3668
3669  out:
3670   if (stream_sock)
3671     es_fclose (stream_sock);
3672 }
3673
3674
3675 #ifdef HAVE_W32_SYSTEM
3676 /* Serve one ssh-agent request.  This is used for the Putty support.
3677    REQUEST is the mmapped memory which may be accessed up to a
3678    length of MAXREQLEN.  Returns 0 on success which also indicates
3679    that a valid SSH response message is now in REQUEST.  */
3680 int
3681 serve_mmapped_ssh_request (ctrl_t ctrl,
3682                            unsigned char *request, size_t maxreqlen)
3683 {
3684   gpg_error_t err;
3685   int send_err = 0;
3686   int valid_response = 0;
3687   ssh_request_spec_t *spec;
3688   u32 msglen;
3689   estream_t request_stream, response_stream;
3690
3691   if (agent_copy_startup_env (ctrl))
3692     goto leave; /* Error setting up the environment.  */
3693
3694   if (maxreqlen < 5)
3695     goto leave; /* Caller error.  */
3696
3697   msglen = uint32_construct (request[0], request[1], request[2], request[3]);
3698   if (msglen < 1 || msglen > maxreqlen - 4)
3699     {
3700       log_error ("ssh message len (%u) out of range", (unsigned int)msglen);
3701       goto leave;
3702     }
3703
3704   spec = request_spec_lookup (request[4]);
3705   if (!spec)
3706     {
3707       send_err = 1;  /* Unknown request type.  */
3708       goto leave;
3709     }
3710
3711   /* Create a stream object with the data part of the request.  */
3712   if (spec->secret_input)
3713     request_stream = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+");
3714   else
3715     request_stream = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+");
3716   if (!request_stream)
3717     {