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