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