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