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