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