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