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