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