ssh: Rewrite a function for better maintainability
[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 *r_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   gpg_error_t err;
1199   gcry_sexp_t sexp_new = NULL;
1200   char *formatbuf = NULL;
1201   void **arg_list = NULL;
1202   int arg_idx;
1203   estream_t format;
1204   const char *elems;
1205   size_t elems_n;
1206   unsigned int i, j;
1207
1208   if (secret)
1209     elems = key_spec.elems_sexp_order;
1210   else
1211     elems = key_spec.elems_key_public;
1212   elems_n = strlen (elems);
1213
1214   format = es_fopenmem (0, "a+b");
1215   if (!format)
1216     {
1217       err = gpg_error_from_syserror ();
1218       goto out;
1219     }
1220
1221   /* Key identifier, algorithm identifier, mpis, comment, and a NULL
1222      as a safeguard. */
1223   arg_list = xtrymalloc (sizeof (*arg_list) * (2 + elems_n + 1 + 1));
1224   if (!arg_list)
1225     {
1226       err = gpg_error_from_syserror ();
1227       goto out;
1228     }
1229   arg_idx = 0;
1230
1231   es_fputs ("(%s(%s", format);
1232   arg_list[arg_idx++] = &key_identifier[secret];
1233   arg_list[arg_idx++] = &key_spec.identifier;
1234
1235   for (i = 0; i < elems_n; i++)
1236     {
1237       es_fprintf (format, "(%c%%m)", elems[i]);
1238       if (secret)
1239         {
1240           for (j = 0; j < elems_n; j++)
1241             if (key_spec.elems_key_secret[j] == elems[i])
1242               break;
1243         }
1244       else
1245         j = i;
1246       arg_list[arg_idx++] = &mpis[j];
1247     }
1248   es_fputs (")(comment%s))", format);
1249   arg_list[arg_idx++] = &comment;
1250   arg_list[arg_idx] = NULL;
1251
1252   es_putc (0, format);
1253   if (es_ferror (format))
1254     {
1255       err = gpg_error_from_syserror ();
1256       goto out;
1257     }
1258   if (es_fclose_snatch (format, &formatbuf, NULL))
1259     {
1260       err = gpg_error_from_syserror ();
1261       goto out;
1262     }
1263   format = NULL;
1264
1265   log_debug ("sexp formatbuf='%s' nargs=%d\n", formatbuf, arg_idx);
1266   err = gcry_sexp_build_array (&sexp_new, NULL, formatbuf, arg_list);
1267   if (err)
1268     goto out;
1269
1270   *r_sexp = sexp_new;
1271   err = 0;
1272
1273  out:
1274   es_fclose (format);
1275   xfree (arg_list);
1276   xfree (formatbuf);
1277
1278   return err;
1279 }
1280
1281
1282 /* This functions breaks up the key contained in the S-Expression SEXP
1283    according to KEY_SPEC.  The MPIs are bundled in a newly create
1284    list, which is to be stored in MPIS; a newly allocated string
1285    holding the comment will be stored in COMMENT; SECRET will be
1286    filled with a boolean flag specifying what kind of key it is.
1287    Returns usual error code.  */
1288 static gpg_error_t
1289 sexp_key_extract (gcry_sexp_t sexp,
1290                   ssh_key_type_spec_t key_spec, int *secret,
1291                   gcry_mpi_t **mpis, char **comment)
1292 {
1293   gpg_error_t err;
1294   gcry_sexp_t value_list;
1295   gcry_sexp_t value_pair;
1296   gcry_sexp_t comment_list;
1297   unsigned int i;
1298   char *comment_new;
1299   const char *data;
1300   size_t data_n;
1301   int is_secret;
1302   size_t elems_n;
1303   const char *elems;
1304   gcry_mpi_t *mpis_new;
1305   gcry_mpi_t mpi;
1306
1307   err = 0;
1308   value_list = NULL;
1309   value_pair = NULL;
1310   comment_list = NULL;
1311   comment_new = NULL;
1312   mpis_new = NULL;
1313
1314   data = gcry_sexp_nth_data (sexp, 0, &data_n);
1315   if (! data)
1316     {
1317       err = gpg_error (GPG_ERR_INV_SEXP);
1318       goto out;
1319     }
1320
1321   if ((data_n == 10 && !strncmp (data, "public-key", 10))
1322       || (data_n == 21 && !strncmp (data, "protected-private-key", 21))
1323       || (data_n == 20 && !strncmp (data, "shadowed-private-key", 20)))
1324     {
1325       is_secret = 0;
1326       elems = key_spec.elems_key_public;
1327     }
1328   else if (data_n == 11 && !strncmp (data, "private-key", 11))
1329     {
1330       is_secret = 1;
1331       elems = key_spec.elems_key_secret;
1332     }
1333   else
1334     {
1335       err = gpg_error (GPG_ERR_INV_SEXP);
1336       goto out;
1337     }
1338
1339   elems_n = strlen (elems);
1340   mpis_new = xtrycalloc (elems_n + 1, sizeof *mpis_new );
1341   if (!mpis_new)
1342     {
1343       err = gpg_error_from_syserror ();
1344       goto out;
1345     }
1346
1347   value_list = gcry_sexp_find_token (sexp, key_spec.identifier, 0);
1348   if (! value_list)
1349     {
1350       err = gpg_error (GPG_ERR_INV_SEXP);
1351       goto out;
1352     }
1353
1354   for (i = 0; i < elems_n; i++)
1355     {
1356       value_pair = gcry_sexp_find_token (value_list, elems + i, 1);
1357       if (! value_pair)
1358         {
1359           err = gpg_error (GPG_ERR_INV_SEXP);
1360           break;
1361         }
1362
1363       /* Note that we need to use STD format; i.e. prepend a 0x00 to
1364          indicate a positive number if the high bit is set. */
1365       mpi = gcry_sexp_nth_mpi (value_pair, 1, GCRYMPI_FMT_STD);
1366       if (! mpi)
1367         {
1368           err = gpg_error (GPG_ERR_INV_SEXP);
1369           break;
1370         }
1371       mpis_new[i] = mpi;
1372       gcry_sexp_release (value_pair);
1373       value_pair = NULL;
1374     }
1375   if (err)
1376     goto out;
1377
1378   /* We do not require a comment sublist to be present here.  */
1379   data = NULL;
1380   data_n = 0;
1381
1382   comment_list = gcry_sexp_find_token (sexp, "comment", 0);
1383   if (comment_list)
1384     data = gcry_sexp_nth_data (comment_list, 1, &data_n);
1385   if (! data)
1386     {
1387       data = "(none)";
1388       data_n = 6;
1389     }
1390
1391   comment_new = make_cstring (data, data_n);
1392   if (! comment_new)
1393     {
1394       err = gpg_error_from_syserror ();
1395       goto out;
1396     }
1397
1398   if (secret)
1399     *secret = is_secret;
1400   *mpis = mpis_new;
1401   *comment = comment_new;
1402
1403  out:
1404
1405   gcry_sexp_release (value_list);
1406   gcry_sexp_release (value_pair);
1407   gcry_sexp_release (comment_list);
1408
1409   if (err)
1410     {
1411       xfree (comment_new);
1412       mpint_list_free (mpis_new);
1413     }
1414
1415   return err;
1416 }
1417
1418 /* Extract the car from SEXP, and create a newly created C-string
1419    which is to be stored in IDENTIFIER.  */
1420 static gpg_error_t
1421 sexp_extract_identifier (gcry_sexp_t sexp, char **identifier)
1422 {
1423   char *identifier_new;
1424   gcry_sexp_t sublist;
1425   const char *data;
1426   size_t data_n;
1427   gpg_error_t err;
1428
1429   identifier_new = NULL;
1430   err = 0;
1431
1432   sublist = gcry_sexp_nth (sexp, 1);
1433   if (! sublist)
1434     {
1435       err = gpg_error (GPG_ERR_INV_SEXP);
1436       goto out;
1437     }
1438
1439   data = gcry_sexp_nth_data (sublist, 0, &data_n);
1440   if (! data)
1441     {
1442       err = gpg_error (GPG_ERR_INV_SEXP);
1443       goto out;
1444     }
1445
1446   identifier_new = make_cstring (data, data_n);
1447   if (! identifier_new)
1448     {
1449       err = gpg_err_code_from_errno (errno);
1450       goto out;
1451     }
1452
1453   *identifier = identifier_new;
1454
1455  out:
1456
1457   gcry_sexp_release (sublist);
1458
1459   return err;
1460 }
1461
1462 \f
1463
1464 /*
1465
1466   Key I/O.
1467
1468 */
1469
1470 /* Search for a key specification entry.  If SSH_NAME is not NULL,
1471    search for an entry whose "ssh_name" is equal to SSH_NAME;
1472    otherwise, search for an entry whose "name" is equal to NAME.
1473    Store found entry in SPEC on success, return error otherwise.  */
1474 static gpg_error_t
1475 ssh_key_type_lookup (const char *ssh_name, const char *name,
1476                      ssh_key_type_spec_t *spec)
1477 {
1478   gpg_error_t err;
1479   unsigned int i;
1480
1481   for (i = 0; i < DIM (ssh_key_types); i++)
1482     if ((ssh_name && (! strcmp (ssh_name, ssh_key_types[i].ssh_identifier)))
1483         || (name && (! strcmp (name, ssh_key_types[i].identifier))))
1484       break;
1485
1486   if (i == DIM (ssh_key_types))
1487     err = gpg_error (GPG_ERR_NOT_FOUND);
1488   else
1489     {
1490       *spec = ssh_key_types[i];
1491       err = 0;
1492     }
1493
1494   return err;
1495 }
1496
1497 /* Receive a key from STREAM, according to the key specification given
1498    as KEY_SPEC.  Depending on SECRET, receive a secret or a public
1499    key.  If READ_COMMENT is true, receive a comment string as well.
1500    Constructs a new S-Expression from received data and stores it in
1501    KEY_NEW.  Returns zero on success or an error code.  */
1502 static gpg_error_t
1503 ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret,
1504                  int read_comment, ssh_key_type_spec_t *key_spec)
1505 {
1506   gpg_error_t err;
1507   char *key_type = NULL;
1508   char *comment = NULL;
1509   gcry_sexp_t key = NULL;
1510   ssh_key_type_spec_t spec;
1511   gcry_mpi_t *mpi_list = NULL;
1512   const char *elems;
1513
1514
1515   err = stream_read_cstring (stream, &key_type);
1516   if (err)
1517     goto out;
1518
1519   err = ssh_key_type_lookup (key_type, NULL, &spec);
1520   if (err)
1521     goto out;
1522
1523   err = ssh_receive_mpint_list (stream, secret, spec, &mpi_list);
1524   if (err)
1525     goto out;
1526
1527   if (read_comment)
1528     {
1529       err = stream_read_cstring (stream, &comment);
1530       if (err)
1531         goto out;
1532     }
1533
1534   if (secret)
1535     elems = spec.elems_key_secret;
1536   else
1537     elems = spec.elems_key_public;
1538
1539   if (spec.key_modifier)
1540     {
1541       err = (*spec.key_modifier) (elems, mpi_list);
1542       if (err)
1543         goto out;
1544     }
1545
1546   err = sexp_key_construct (&key, spec, secret, mpi_list, comment? comment:"");
1547   if (err)
1548     goto out;
1549
1550   if (key_spec)
1551     *key_spec = spec;
1552   *key_new = key;
1553
1554  out:
1555
1556   mpint_list_free (mpi_list);
1557   xfree (key_type);
1558   xfree (comment);
1559
1560   return err;
1561 }
1562
1563 /* Converts a key of type TYPE, whose key material is given in MPIS,
1564    into a newly created binary blob, which is to be stored in
1565    BLOB/BLOB_SIZE.  Returns zero on success or an error code.  */
1566 static gpg_error_t
1567 ssh_convert_key_to_blob (unsigned char **blob, size_t *blob_size,
1568                          const char *type, gcry_mpi_t *mpis)
1569 {
1570   unsigned char *blob_new;
1571   long int blob_size_new;
1572   estream_t stream;
1573   gpg_error_t err;
1574   unsigned int i;
1575
1576   *blob = NULL;
1577   *blob_size = 0;
1578
1579   blob_new = NULL;
1580   stream = NULL;
1581   err = 0;
1582
1583   stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1584   if (! stream)
1585     {
1586       err = gpg_error_from_syserror ();
1587       goto out;
1588     }
1589
1590   err = stream_write_cstring (stream, type);
1591   if (err)
1592     goto out;
1593
1594   for (i = 0; mpis[i] && (! err); i++)
1595     err = stream_write_mpi (stream, mpis[i]);
1596   if (err)
1597     goto out;
1598
1599   blob_size_new = es_ftell (stream);
1600   if (blob_size_new == -1)
1601     {
1602       err = gpg_error_from_syserror ();
1603       goto out;
1604     }
1605
1606   err = es_fseek (stream, 0, SEEK_SET);
1607   if (err)
1608     goto out;
1609
1610   blob_new = xtrymalloc (blob_size_new);
1611   if (! blob_new)
1612     {
1613       err = gpg_error_from_syserror ();
1614       goto out;
1615     }
1616
1617   err = stream_read_data (stream, blob_new, blob_size_new);
1618   if (err)
1619     goto out;
1620
1621   *blob = blob_new;
1622   *blob_size = blob_size_new;
1623
1624  out:
1625
1626   if (stream)
1627     es_fclose (stream);
1628   if (err)
1629     xfree (blob_new);
1630
1631   return err;
1632 }
1633
1634
1635 /* Write the public key KEY_PUBLIC to STREAM in SSH key format.  If
1636    OVERRIDE_COMMENT is not NULL, it will be used instead of the
1637    comment stored in the key.  */
1638 static gpg_error_t
1639 ssh_send_key_public (estream_t stream, gcry_sexp_t key_public,
1640                      const char *override_comment)
1641 {
1642   ssh_key_type_spec_t spec;
1643   gcry_mpi_t *mpi_list;
1644   char *key_type;
1645   char *comment;
1646   unsigned char *blob;
1647   size_t blob_n;
1648   gpg_error_t err;
1649
1650   key_type = NULL;
1651   mpi_list = NULL;
1652   comment = NULL;
1653   blob = NULL;
1654
1655   err = sexp_extract_identifier (key_public, &key_type);
1656   if (err)
1657     goto out;
1658
1659   err = ssh_key_type_lookup (NULL, key_type, &spec);
1660   if (err)
1661     goto out;
1662
1663   err = sexp_key_extract (key_public, spec, NULL, &mpi_list, &comment);
1664   if (err)
1665     goto out;
1666
1667   err = ssh_convert_key_to_blob (&blob, &blob_n,
1668                                  spec.ssh_identifier, mpi_list);
1669   if (err)
1670     goto out;
1671
1672   err = stream_write_string (stream, blob, blob_n);
1673   if (err)
1674     goto out;
1675
1676   err = stream_write_cstring (stream,
1677                               override_comment? override_comment : comment);
1678
1679  out:
1680
1681   mpint_list_free (mpi_list);
1682   xfree (key_type);
1683   xfree (comment);
1684   xfree (blob);
1685
1686   return err;
1687 }
1688
1689 /* Read a public key out of BLOB/BLOB_SIZE according to the key
1690    specification given as KEY_SPEC, storing the new key in KEY_PUBLIC.
1691    Returns zero on success or an error code.  */
1692 static gpg_error_t
1693 ssh_read_key_public_from_blob (unsigned char *blob, size_t blob_size,
1694                                gcry_sexp_t *key_public,
1695                                ssh_key_type_spec_t *key_spec)
1696 {
1697   estream_t blob_stream;
1698   gpg_error_t err;
1699
1700   err = 0;
1701
1702   blob_stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1703   if (! blob_stream)
1704     {
1705       err = gpg_error_from_syserror ();
1706       goto out;
1707     }
1708
1709   err = stream_write_data (blob_stream, blob, blob_size);
1710   if (err)
1711     goto out;
1712
1713   err = es_fseek (blob_stream, 0, SEEK_SET);
1714   if (err)
1715     goto out;
1716
1717   err = ssh_receive_key (blob_stream, key_public, 0, 0, key_spec);
1718
1719  out:
1720
1721   if (blob_stream)
1722     es_fclose (blob_stream);
1723
1724   return err;
1725 }
1726
1727 \f
1728
1729 /* This function calculates the key grip for the key contained in the
1730    S-Expression KEY and writes it to BUFFER, which must be large
1731    enough to hold it.  Returns usual error code.  */
1732 static gpg_error_t
1733 ssh_key_grip (gcry_sexp_t key, unsigned char *buffer)
1734 {
1735   if (!gcry_pk_get_keygrip (key, buffer))
1736     return gpg_error (GPG_ERR_INTERNAL);
1737
1738   return 0;
1739 }
1740
1741
1742 /* Converts the secret key KEY_SECRET into a public key, storing it in
1743    KEY_PUBLIC.  SPEC is the according key specification.  Returns zero
1744    on success or an error code.  */
1745 static gpg_error_t
1746 key_secret_to_public (gcry_sexp_t *key_public,
1747                       ssh_key_type_spec_t spec, gcry_sexp_t key_secret)
1748 {
1749   char *comment;
1750   gcry_mpi_t *mpis;
1751   gpg_error_t err;
1752   int is_secret;
1753
1754   comment = NULL;
1755   mpis = NULL;
1756
1757   err = sexp_key_extract (key_secret, spec, &is_secret, &mpis, &comment);
1758   if (err)
1759     goto out;
1760
1761   err = sexp_key_construct (key_public, spec, 0, mpis, comment);
1762
1763  out:
1764
1765   mpint_list_free (mpis);
1766   xfree (comment);
1767
1768   return err;
1769 }
1770
1771
1772 /* Check whether a smartcard is available and whether it has a usable
1773    key.  Store a copy of that key at R_PK and return 0.  If no key is
1774    available store NULL at R_PK and return an error code.  If CARDSN
1775    is not NULL, a string with the serial number of the card will be
1776    a malloced and stored there. */
1777 static gpg_error_t
1778 card_key_available (ctrl_t ctrl, gcry_sexp_t *r_pk, char **cardsn)
1779 {
1780   gpg_error_t err;
1781   char *authkeyid;
1782   char *serialno = NULL;
1783   unsigned char *pkbuf;
1784   size_t pkbuflen;
1785   gcry_sexp_t s_pk;
1786   unsigned char grip[20];
1787
1788   *r_pk = NULL;
1789   if (cardsn)
1790     *cardsn = NULL;
1791
1792   /* First see whether a card is available and whether the application
1793      is supported.  */
1794   err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
1795   if ( gpg_err_code (err) == GPG_ERR_CARD_REMOVED )
1796     {
1797       /* Ask for the serial number to reset the card.  */
1798       err = agent_card_serialno (ctrl, &serialno);
1799       if (err)
1800         {
1801           if (opt.verbose)
1802             log_info (_("error getting serial number of card: %s\n"),
1803                       gpg_strerror (err));
1804           return err;
1805         }
1806       log_info (_("detected card with S/N: %s\n"), serialno);
1807       err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
1808     }
1809   if (err)
1810     {
1811       log_error (_("error getting default authentication keyID of card: %s\n"),
1812                  gpg_strerror (err));
1813       xfree (serialno);
1814       return err;
1815     }
1816
1817   /* Get the S/N if we don't have it yet.  Use the fast getattr method.  */
1818   if (!serialno && (err = agent_card_getattr (ctrl, "SERIALNO", &serialno)) )
1819     {
1820       log_error (_("error getting serial number of card: %s\n"),
1821                  gpg_strerror (err));
1822       xfree (authkeyid);
1823       return err;
1824     }
1825
1826   /* Read the public key.  */
1827   err = agent_card_readkey (ctrl, authkeyid, &pkbuf);
1828   if (err)
1829     {
1830       if (opt.verbose)
1831         log_info (_("no suitable card key found: %s\n"), gpg_strerror (err));
1832       xfree (serialno);
1833       xfree (authkeyid);
1834       return err;
1835     }
1836
1837   pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
1838   err = gcry_sexp_sscan (&s_pk, NULL, (char*)pkbuf, pkbuflen);
1839   if (err)
1840     {
1841       log_error ("failed to build S-Exp from received card key: %s\n",
1842                  gpg_strerror (err));
1843       xfree (pkbuf);
1844       xfree (serialno);
1845       xfree (authkeyid);
1846       return err;
1847     }
1848
1849   err = ssh_key_grip (s_pk, grip);
1850   if (err)
1851     {
1852       log_debug ("error computing keygrip from received card key: %s\n",
1853                  gcry_strerror (err));
1854       xfree (pkbuf);
1855       gcry_sexp_release (s_pk);
1856       xfree (serialno);
1857       xfree (authkeyid);
1858       return err;
1859     }
1860
1861   if ( agent_key_available (grip) )
1862     {
1863       /* (Shadow)-key is not available in our key storage.  */
1864       unsigned char *shadow_info;
1865       unsigned char *tmp;
1866
1867       shadow_info = make_shadow_info (serialno, authkeyid);
1868       if (!shadow_info)
1869         {
1870           err = gpg_error_from_syserror ();
1871           xfree (pkbuf);
1872           gcry_sexp_release (s_pk);
1873           xfree (serialno);
1874           xfree (authkeyid);
1875           return err;
1876         }
1877       err = agent_shadow_key (pkbuf, shadow_info, &tmp);
1878       xfree (shadow_info);
1879       if (err)
1880         {
1881           log_error (_("shadowing the key failed: %s\n"), gpg_strerror (err));
1882           xfree (pkbuf);
1883           gcry_sexp_release (s_pk);
1884           xfree (serialno);
1885           xfree (authkeyid);
1886           return err;
1887         }
1888       xfree (pkbuf);
1889       pkbuf = tmp;
1890       pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
1891       assert (pkbuflen);
1892
1893       err = agent_write_private_key (grip, pkbuf, pkbuflen, 0);
1894       if (err)
1895         {
1896           log_error (_("error writing key: %s\n"), gpg_strerror (err));
1897           xfree (pkbuf);
1898           gcry_sexp_release (s_pk);
1899           xfree (serialno);
1900           xfree (authkeyid);
1901           return err;
1902         }
1903     }
1904
1905   if (cardsn)
1906     {
1907       char *dispsn;
1908
1909       /* If the card handler is able to return a short serialnumber,
1910          use that one, else use the complete serialno. */
1911       if (!agent_card_getattr (ctrl, "$DISPSERIALNO", &dispsn))
1912         {
1913           *cardsn = xtryasprintf ("cardno:%s", dispsn);
1914           xfree (dispsn);
1915         }
1916       else
1917         *cardsn = xtryasprintf ("cardno:%s", serialno);
1918       if (!*cardsn)
1919         {
1920           err = gpg_error_from_syserror ();
1921           xfree (pkbuf);
1922           gcry_sexp_release (s_pk);
1923           xfree (serialno);
1924           xfree (authkeyid);
1925           return err;
1926         }
1927     }
1928
1929   xfree (pkbuf);
1930   xfree (serialno);
1931   xfree (authkeyid);
1932   *r_pk = s_pk;
1933   return 0;
1934 }
1935
1936
1937 \f
1938
1939 /*
1940
1941   Request handler.  Each handler is provided with a CTRL context, a
1942   REQUEST object and a RESPONSE object.  The actual request is to be
1943   read from REQUEST, the response needs to be written to RESPONSE.
1944
1945 */
1946
1947
1948 /* Handler for the "request_identities" command.  */
1949 static gpg_error_t
1950 ssh_handler_request_identities (ctrl_t ctrl,
1951                                 estream_t request, estream_t response)
1952 {
1953   ssh_key_type_spec_t spec;
1954   char *key_fname = NULL;
1955   char *fnameptr;
1956   u32 key_counter;
1957   estream_t key_blobs;
1958   gcry_sexp_t key_secret;
1959   gcry_sexp_t key_public;
1960   gpg_error_t err;
1961   int ret;
1962   control_file_t cf = NULL;
1963   char *cardsn;
1964   gpg_error_t ret_err;
1965
1966   (void)request;
1967
1968   /* Prepare buffer stream.  */
1969
1970   key_secret = NULL;
1971   key_public = NULL;
1972   key_counter = 0;
1973   err = 0;
1974
1975   key_blobs = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1976   if (! key_blobs)
1977     {
1978       err = gpg_error_from_syserror ();
1979       goto out;
1980     }
1981
1982   /* First check whether a key is currently available in the card
1983      reader - this should be allowed even without being listed in
1984      sshcontrol. */
1985
1986   if (!opt.disable_scdaemon
1987       && !card_key_available (ctrl, &key_public, &cardsn))
1988     {
1989       err = ssh_send_key_public (key_blobs, key_public, cardsn);
1990       gcry_sexp_release (key_public);
1991       key_public = NULL;
1992       xfree (cardsn);
1993       if (err)
1994         goto out;
1995
1996       key_counter++;
1997     }
1998
1999
2000   /* Prepare buffer for key name construction.  */
2001   {
2002     char *dname;
2003
2004     dname = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, NULL);
2005     if (!dname)
2006       {
2007         err = gpg_err_code_from_syserror ();
2008         goto out;
2009       }
2010
2011     key_fname = xtrymalloc (strlen (dname) + 1 + 40 + 4 + 1);
2012     if (!key_fname)
2013       {
2014         err = gpg_err_code_from_syserror ();
2015         xfree (dname);
2016         goto out;
2017       }
2018     fnameptr = stpcpy (stpcpy (key_fname, dname), "/");
2019     xfree (dname);
2020   }
2021
2022   /* Then look at all the registered and non-disabled keys. */
2023   err = open_control_file (&cf, 0);
2024   if (err)
2025     goto out;
2026
2027   while (!read_control_file_item (cf))
2028     {
2029       if (!cf->item.valid)
2030         continue; /* Should not happen.  */
2031       if (cf->item.disabled)
2032         continue;
2033       assert (strlen (cf->item.hexgrip) == 40);
2034
2035       stpcpy (stpcpy (fnameptr, cf->item.hexgrip), ".key");
2036
2037       /* Read file content.  */
2038       {
2039         unsigned char *buffer;
2040         size_t buffer_n;
2041
2042         err = file_to_buffer (key_fname, &buffer, &buffer_n);
2043         if (err)
2044           {
2045             log_error ("%s:%d: key '%s' skipped: %s\n",
2046                        cf->fname, cf->lnr, cf->item.hexgrip,
2047                        gpg_strerror (err));
2048             continue;
2049           }
2050
2051         err = gcry_sexp_sscan (&key_secret, NULL, (char*)buffer, buffer_n);
2052         xfree (buffer);
2053         if (err)
2054           goto out;
2055       }
2056
2057       {
2058         char *key_type = NULL;
2059
2060         err = sexp_extract_identifier (key_secret, &key_type);
2061         if (err)
2062           goto out;
2063
2064         err = ssh_key_type_lookup (NULL, key_type, &spec);
2065         xfree (key_type);
2066         if (err)
2067           goto out;
2068       }
2069
2070       err = key_secret_to_public (&key_public, spec, key_secret);
2071       if (err)
2072         goto out;
2073
2074       gcry_sexp_release (key_secret);
2075       key_secret = NULL;
2076
2077       err = ssh_send_key_public (key_blobs, key_public, NULL);
2078       if (err)
2079         goto out;
2080
2081       gcry_sexp_release (key_public);
2082       key_public = NULL;
2083
2084       key_counter++;
2085     }
2086   err = 0;
2087
2088   ret = es_fseek (key_blobs, 0, SEEK_SET);
2089   if (ret)
2090     {
2091       err = gpg_error_from_syserror ();
2092       goto out;
2093     }
2094
2095  out:
2096   /* Send response.  */
2097
2098   gcry_sexp_release (key_secret);
2099   gcry_sexp_release (key_public);
2100
2101   if (!err)
2102     {
2103       ret_err = stream_write_byte (response, SSH_RESPONSE_IDENTITIES_ANSWER);
2104       if (!ret_err)
2105         ret_err = stream_write_uint32 (response, key_counter);
2106       if (!ret_err)
2107         ret_err = stream_copy (response, key_blobs);
2108     }
2109   else
2110     {
2111       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2112     }
2113
2114   es_fclose (key_blobs);
2115   close_control_file (cf);
2116   xfree (key_fname);
2117
2118   return ret_err;
2119 }
2120
2121
2122 /* This function hashes the data contained in DATA of size DATA_N
2123    according to the message digest algorithm specified by MD_ALGORITHM
2124    and writes the message digest to HASH, which needs to large enough
2125    for the digest.  */
2126 static gpg_error_t
2127 data_hash (unsigned char *data, size_t data_n,
2128            int md_algorithm, unsigned char *hash)
2129 {
2130   gcry_md_hash_buffer (md_algorithm, hash, data, data_n);
2131
2132   return 0;
2133 }
2134
2135 /* This function signs the data contained in CTRL, stores the created
2136    signature in newly allocated memory in SIG and it's size in SIG_N;
2137    SIG_ENCODER is the signature encoder to use.  */
2138 static gpg_error_t
2139 data_sign (ctrl_t ctrl, ssh_signature_encoder_t sig_encoder,
2140            unsigned char **sig, size_t *sig_n)
2141 {
2142   gpg_error_t err;
2143   gcry_sexp_t signature_sexp = NULL;
2144   estream_t stream = NULL;
2145   gcry_sexp_t valuelist = NULL;
2146   gcry_sexp_t sublist = NULL;
2147   gcry_mpi_t sig_value = NULL;
2148   unsigned char *sig_blob = NULL;
2149   size_t sig_blob_n = 0;
2150   char *identifier = NULL;
2151   const char *identifier_raw;
2152   size_t identifier_n;
2153   ssh_key_type_spec_t spec;
2154   int ret;
2155   unsigned int i;
2156   const char *elems;
2157   size_t elems_n;
2158   gcry_mpi_t *mpis = NULL;
2159   char hexgrip[40+1];
2160
2161   *sig = NULL;
2162   *sig_n = 0;
2163
2164   /* Quick check to see whether we have a valid keygrip and convert it
2165      to hex.  */
2166   if (!ctrl->have_keygrip)
2167     {
2168       err = gpg_error (GPG_ERR_NO_SECKEY);
2169       goto out;
2170     }
2171   bin2hex (ctrl->keygrip, 20, hexgrip);
2172
2173   /* Ask for confirmation if needed.  */
2174   if (confirm_flag_from_sshcontrol (hexgrip))
2175     {
2176       gcry_sexp_t key;
2177       char *fpr, *prompt;
2178       char *comment = NULL;
2179
2180       err = agent_raw_key_from_file (ctrl, ctrl->keygrip, &key);
2181       if (err)
2182         goto out;
2183       err = ssh_get_fingerprint_string (key, &fpr);
2184       if (!err)
2185         {
2186           gcry_sexp_t tmpsxp = gcry_sexp_find_token (key, "comment", 0);
2187           if (tmpsxp)
2188             comment = gcry_sexp_nth_string (tmpsxp, 1);
2189           gcry_sexp_release (tmpsxp);
2190         }
2191       gcry_sexp_release (key);
2192       if (err)
2193         goto out;
2194       prompt = xtryasprintf (_("An ssh process requested the use of key%%0A"
2195                                "  %s%%0A"
2196                                "  (%s)%%0A"
2197                                "Do you want to allow this?"),
2198                              fpr, comment? comment:"");
2199       xfree (fpr);
2200       gcry_free (comment);
2201       err = agent_get_confirmation (ctrl, prompt, _("Allow"), _("Deny"), 0);
2202       xfree (prompt);
2203       if (err)
2204         goto out;
2205     }
2206
2207   /* Create signature.  */
2208   ctrl->use_auth_call = 1;
2209   err = agent_pksign_do (ctrl,
2210                          _("Please enter the passphrase "
2211                            "for the ssh key%%0A  %F%%0A  (%c)"),
2212                          &signature_sexp,
2213                          CACHE_MODE_SSH, ttl_from_sshcontrol);
2214   ctrl->use_auth_call = 0;
2215   if (err)
2216     goto out;
2217
2218   valuelist = gcry_sexp_nth (signature_sexp, 1);
2219   if (! valuelist)
2220     {
2221       err = gpg_error (GPG_ERR_INV_SEXP);
2222       goto out;
2223     }
2224
2225   stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
2226   if (! stream)
2227     {
2228       err = gpg_error_from_syserror ();
2229       goto out;
2230     }
2231
2232   identifier_raw = gcry_sexp_nth_data (valuelist, 0, &identifier_n);
2233   if (! identifier_raw)
2234     {
2235       err = gpg_error (GPG_ERR_INV_SEXP);
2236       goto out;
2237     }
2238
2239   identifier = make_cstring (identifier_raw, identifier_n);
2240   if (! identifier)
2241     {
2242       err = gpg_error_from_syserror ();
2243       goto out;
2244     }
2245
2246   err = ssh_key_type_lookup (NULL, identifier, &spec);
2247   if (err)
2248     goto out;
2249
2250   err = stream_write_cstring (stream, spec.ssh_identifier);
2251   if (err)
2252     goto out;
2253
2254   elems = spec.elems_signature;
2255   elems_n = strlen (elems);
2256
2257   mpis = xtrycalloc (elems_n + 1, sizeof *mpis);
2258   if (!mpis)
2259     {
2260       err = gpg_error_from_syserror ();
2261       goto out;
2262     }
2263
2264   for (i = 0; i < elems_n; i++)
2265     {
2266       sublist = gcry_sexp_find_token (valuelist, spec.elems_signature + i, 1);
2267       if (! sublist)
2268         {
2269           err = gpg_error (GPG_ERR_INV_SEXP);
2270           break;
2271         }
2272
2273       sig_value = gcry_sexp_nth_mpi (sublist, 1, GCRYMPI_FMT_USG);
2274       if (! sig_value)
2275         {
2276           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
2277           break;
2278         }
2279       gcry_sexp_release (sublist);
2280       sublist = NULL;
2281
2282       mpis[i] = sig_value;
2283     }
2284   if (err)
2285     goto out;
2286
2287   err = (*sig_encoder) (stream, mpis);
2288   if (err)
2289     goto out;
2290
2291   sig_blob_n = es_ftell (stream);
2292   if (sig_blob_n == -1)
2293     {
2294       err = gpg_error_from_syserror ();
2295       goto out;
2296     }
2297
2298   sig_blob = xtrymalloc (sig_blob_n);
2299   if (! sig_blob)
2300     {
2301       err = gpg_error_from_syserror ();
2302       goto out;
2303     }
2304
2305   ret = es_fseek (stream, 0, SEEK_SET);
2306   if (ret)
2307     {
2308       err = gpg_error_from_syserror ();
2309       goto out;
2310     }
2311
2312   err = stream_read_data (stream, sig_blob, sig_blob_n);
2313   if (err)
2314     goto out;
2315
2316   *sig = sig_blob;
2317   *sig_n = sig_blob_n;
2318
2319  out:
2320
2321   if (err)
2322     xfree (sig_blob);
2323
2324   if (stream)
2325     es_fclose (stream);
2326   gcry_sexp_release (valuelist);
2327   gcry_sexp_release (signature_sexp);
2328   gcry_sexp_release (sublist);
2329   mpint_list_free (mpis);
2330   xfree (identifier);
2331
2332   return err;
2333 }
2334
2335 /* Handler for the "sign_request" command.  */
2336 static gpg_error_t
2337 ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
2338 {
2339   gcry_sexp_t key;
2340   ssh_key_type_spec_t spec;
2341   unsigned char hash[MAX_DIGEST_LEN];
2342   unsigned int hash_n;
2343   unsigned char key_grip[20];
2344   unsigned char *key_blob;
2345   u32 key_blob_size;
2346   unsigned char *data;
2347   unsigned char *sig;
2348   size_t sig_n;
2349   u32 data_size;
2350   u32 flags;
2351   gpg_error_t err;
2352   gpg_error_t ret_err;
2353
2354   key_blob = NULL;
2355   data = NULL;
2356   sig = NULL;
2357   key = NULL;
2358
2359   /* Receive key.  */
2360
2361   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2362   if (err)
2363     goto out;
2364
2365   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, &spec);
2366   if (err)
2367     goto out;
2368
2369   /* Receive data to sign.  */
2370   err = stream_read_string (request, 0, &data, &data_size);
2371   if (err)
2372     goto out;
2373
2374   /* FIXME?  */
2375   err = stream_read_uint32 (request, &flags);
2376   if (err)
2377     goto out;
2378
2379   /* Hash data.  */
2380   hash_n = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
2381   if (! hash_n)
2382     {
2383       err = gpg_error (GPG_ERR_INTERNAL);
2384       goto out;
2385     }
2386   err = data_hash (data, data_size, GCRY_MD_SHA1, hash);
2387   if (err)
2388     goto out;
2389
2390   /* Calculate key grip.  */
2391   err = ssh_key_grip (key, key_grip);
2392   if (err)
2393     goto out;
2394
2395   /* Sign data.  */
2396
2397   ctrl->digest.algo = GCRY_MD_SHA1;
2398   memcpy (ctrl->digest.value, hash, hash_n);
2399   ctrl->digest.valuelen = hash_n;
2400   ctrl->digest.raw_value = ! (spec.flags & SPEC_FLAG_USE_PKCS1V2);
2401   ctrl->have_keygrip = 1;
2402   memcpy (ctrl->keygrip, key_grip, 20);
2403
2404   err = data_sign (ctrl, spec.signature_encoder, &sig, &sig_n);
2405
2406  out:
2407
2408   /* Done.  */
2409
2410   if (! err)
2411     {
2412       ret_err = stream_write_byte (response, SSH_RESPONSE_SIGN_RESPONSE);
2413       if (ret_err)
2414         goto leave;
2415       ret_err = stream_write_string (response, sig, sig_n);
2416       if (ret_err)
2417         goto leave;
2418     }
2419   else
2420     {
2421       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2422       if (ret_err)
2423         goto leave;
2424     }
2425
2426  leave:
2427
2428   gcry_sexp_release (key);
2429   xfree (key_blob);
2430   xfree (data);
2431   xfree (sig);
2432
2433   return ret_err;
2434 }
2435
2436 /* This function extracts the comment contained in the key
2437    S-Expression KEY and stores a copy in COMMENT.  Returns usual error
2438    code.  */
2439 static gpg_error_t
2440 ssh_key_extract_comment (gcry_sexp_t key, char **comment)
2441 {
2442   gcry_sexp_t comment_list;
2443   char *comment_new;
2444   const char *data;
2445   size_t data_n;
2446   gpg_error_t err;
2447
2448   comment_list = gcry_sexp_find_token (key, "comment", 0);
2449   if (! comment_list)
2450     {
2451       err = gpg_error (GPG_ERR_INV_SEXP);
2452       goto out;
2453     }
2454
2455   data = gcry_sexp_nth_data (comment_list, 1, &data_n);
2456   if (! data)
2457     {
2458       err = gpg_error (GPG_ERR_INV_SEXP);
2459       goto out;
2460     }
2461
2462   comment_new = make_cstring (data, data_n);
2463   if (! comment_new)
2464     {
2465       err = gpg_error_from_syserror ();
2466       goto out;
2467     }
2468
2469   *comment = comment_new;
2470   err = 0;
2471
2472  out:
2473
2474   gcry_sexp_release (comment_list);
2475
2476   return err;
2477 }
2478
2479 /* This function converts the key contained in the S-Expression KEY
2480    into a buffer, which is protected by the passphrase PASSPHRASE.
2481    Returns usual error code.  */
2482 static gpg_error_t
2483 ssh_key_to_protected_buffer (gcry_sexp_t key, const char *passphrase,
2484                              unsigned char **buffer, size_t *buffer_n)
2485 {
2486   unsigned char *buffer_new;
2487   unsigned int buffer_new_n;
2488   gpg_error_t err;
2489
2490   err = 0;
2491   buffer_new_n = gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, NULL, 0);
2492   buffer_new = xtrymalloc_secure (buffer_new_n);
2493   if (! buffer_new)
2494     {
2495       err = gpg_error_from_syserror ();
2496       goto out;
2497     }
2498
2499   gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, buffer_new, buffer_new_n);
2500   /* FIXME: guarantee?  */
2501
2502   err = agent_protect (buffer_new, passphrase, buffer, buffer_n);
2503
2504  out:
2505
2506   xfree (buffer_new);
2507
2508   return err;
2509 }
2510
2511
2512
2513 /* Callback function to compare the first entered PIN with the one
2514    currently being entered. */
2515 static int
2516 reenter_compare_cb (struct pin_entry_info_s *pi)
2517 {
2518   const char *pin1 = pi->check_cb_arg;
2519
2520   if (!strcmp (pin1, pi->pin))
2521     return 0; /* okay */
2522   return -1;
2523 }
2524
2525 /* Store the ssh KEY into our local key storage and protect it after
2526    asking for a passphrase.  Cache that passphrase.  TTL is the
2527    maximum caching time for that key.  If the key already exists in
2528    our key storage, don't do anything.  When entering a new key also
2529    add an entry to the sshcontrol file.  */
2530 static gpg_error_t
2531 ssh_identity_register (ctrl_t ctrl, gcry_sexp_t key, int ttl, int confirm)
2532 {
2533   gpg_error_t err;
2534   unsigned char key_grip_raw[20];
2535   char key_grip[41];
2536   unsigned char *buffer = NULL;
2537   size_t buffer_n;
2538   char *description = NULL;
2539   const char *description2 = _("Please re-enter this passphrase");
2540   char *comment = NULL;
2541   char *key_fpr = NULL;
2542   const char *initial_errtext = NULL;
2543   unsigned int i;
2544   struct pin_entry_info_s *pi = NULL, *pi2;
2545
2546   err = ssh_key_grip (key, key_grip_raw);
2547   if (err)
2548     goto out;
2549
2550   /* Check whether the key is already in our key storage.  Don't do
2551      anything then.  */
2552   if ( !agent_key_available (key_grip_raw) )
2553     goto out; /* Yes, key is available.  */
2554
2555   err = ssh_get_fingerprint_string (key, &key_fpr);
2556   if (err)
2557     goto out;
2558
2559   err = ssh_key_extract_comment (key, &comment);
2560   if (err)
2561     goto out;
2562
2563   if ( asprintf (&description,
2564                  _("Please enter a passphrase to protect"
2565                    " the received secret key%%0A"
2566                    "   %s%%0A"
2567                    "   %s%%0A"
2568                    "within gpg-agent's key storage"),
2569                  key_fpr, comment ? comment : "") < 0)
2570     {
2571       err = gpg_error_from_syserror ();
2572       goto out;
2573     }
2574
2575
2576   pi = gcry_calloc_secure (2, sizeof (*pi) + 100 + 1);
2577   if (!pi)
2578     {
2579       err = gpg_error_from_syserror ();
2580       goto out;
2581     }
2582   pi2 = pi + (sizeof *pi + 100 + 1);
2583   pi->max_length = 100;
2584   pi->max_tries = 1;
2585   pi2->max_length = 100;
2586   pi2->max_tries = 1;
2587   pi2->check_cb = reenter_compare_cb;
2588   pi2->check_cb_arg = pi->pin;
2589
2590  next_try:
2591   err = agent_askpin (ctrl, description, NULL, initial_errtext, pi);
2592   initial_errtext = NULL;
2593   if (err)
2594     goto out;
2595
2596   /* Unless the passphrase is empty, ask to confirm it.  */
2597   if (pi->pin && *pi->pin)
2598     {
2599       err = agent_askpin (ctrl, description2, NULL, NULL, pi2);
2600       if (err == -1)
2601         { /* The re-entered one did not match and the user did not
2602              hit cancel. */
2603           initial_errtext = _("does not match - try again");
2604           goto next_try;
2605         }
2606     }
2607
2608   err = ssh_key_to_protected_buffer (key, pi->pin, &buffer, &buffer_n);
2609   if (err)
2610     goto out;
2611
2612   /* Store this key to our key storage.  */
2613   err = agent_write_private_key (key_grip_raw, buffer, buffer_n, 0);
2614   if (err)
2615     goto out;
2616
2617   /* Cache this passphrase. */
2618   for (i = 0; i < 20; i++)
2619     sprintf (key_grip + 2 * i, "%02X", key_grip_raw[i]);
2620
2621   err = agent_put_cache (key_grip, CACHE_MODE_SSH, pi->pin, ttl);
2622   if (err)
2623     goto out;
2624
2625   /* And add an entry to the sshcontrol file.  */
2626   err = add_control_entry (ctrl, key_grip, key_fpr, ttl, confirm);
2627
2628
2629  out:
2630   if (pi && pi->max_length)
2631     wipememory (pi->pin, pi->max_length);
2632   xfree (pi);
2633   xfree (buffer);
2634   xfree (comment);
2635   xfree (key_fpr);
2636   xfree (description);
2637
2638   return err;
2639 }
2640
2641
2642 /* This function removes the key contained in the S-Expression KEY
2643    from the local key storage, in case it exists there.  Returns usual
2644    error code.  FIXME: this function is a stub.  */
2645 static gpg_error_t
2646 ssh_identity_drop (gcry_sexp_t key)
2647 {
2648   unsigned char key_grip[21] = { 0 };
2649   gpg_error_t err;
2650
2651   err = ssh_key_grip (key, key_grip);
2652   if (err)
2653     goto out;
2654
2655   key_grip[sizeof (key_grip) - 1] = 0;
2656
2657   /* FIXME: What to do here - forgetting the passphrase or deleting
2658      the key from key cache?  */
2659
2660  out:
2661
2662   return err;
2663 }
2664
2665 /* Handler for the "add_identity" command.  */
2666 static gpg_error_t
2667 ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
2668 {
2669   gpg_error_t ret_err;
2670   gpg_error_t err;
2671   gcry_sexp_t key;
2672   unsigned char b;
2673   int confirm;
2674   int ttl;
2675
2676   confirm = 0;
2677   key = NULL;
2678   ttl = 0;
2679
2680   /* FIXME?  */
2681   err = ssh_receive_key (request, &key, 1, 1, NULL);
2682   if (err)
2683     goto out;
2684
2685   while (1)
2686     {
2687       err = stream_read_byte (request, &b);
2688       if (gpg_err_code (err) == GPG_ERR_EOF)
2689         {
2690           err = 0;
2691           break;
2692         }
2693
2694       switch (b)
2695         {
2696         case SSH_OPT_CONSTRAIN_LIFETIME:
2697           {
2698             u32 n = 0;
2699
2700             err = stream_read_uint32 (request, &n);
2701             if (! err)
2702               ttl = n;
2703             break;
2704           }
2705
2706         case SSH_OPT_CONSTRAIN_CONFIRM:
2707           {
2708             confirm = 1;
2709             break;
2710           }
2711
2712         default:
2713           /* FIXME: log/bad?  */
2714           break;
2715         }
2716     }
2717   if (err)
2718     goto out;
2719
2720   err = ssh_identity_register (ctrl, key, ttl, confirm);
2721
2722  out:
2723
2724   gcry_sexp_release (key);
2725
2726   if (! err)
2727     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2728   else
2729     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2730
2731   return ret_err;
2732 }
2733
2734 /* Handler for the "remove_identity" command.  */
2735 static gpg_error_t
2736 ssh_handler_remove_identity (ctrl_t ctrl,
2737                              estream_t request, estream_t response)
2738 {
2739   unsigned char *key_blob;
2740   u32 key_blob_size;
2741   gcry_sexp_t key;
2742   gpg_error_t ret_err;
2743   gpg_error_t err;
2744
2745   (void)ctrl;
2746
2747   /* Receive key.  */
2748
2749   key_blob = NULL;
2750   key = NULL;
2751
2752   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2753   if (err)
2754     goto out;
2755
2756   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, NULL);
2757   if (err)
2758     goto out;
2759
2760   err = ssh_identity_drop (key);
2761
2762  out:
2763
2764   xfree (key_blob);
2765   gcry_sexp_release (key);
2766
2767   if (! err)
2768     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2769   else
2770     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2771
2772   return ret_err;
2773 }
2774
2775 /* FIXME: stub function.  Actually useful?  */
2776 static gpg_error_t
2777 ssh_identities_remove_all (void)
2778 {
2779   gpg_error_t err;
2780
2781   err = 0;
2782
2783   /* FIXME: shall we remove _all_ cache entries or only those
2784      registered through the ssh emulation?  */
2785
2786   return err;
2787 }
2788
2789 /* Handler for the "remove_all_identities" command.  */
2790 static gpg_error_t
2791 ssh_handler_remove_all_identities (ctrl_t ctrl,
2792                                    estream_t request, estream_t response)
2793 {
2794   gpg_error_t ret_err;
2795   gpg_error_t err;
2796
2797   (void)ctrl;
2798   (void)request;
2799
2800   err = ssh_identities_remove_all ();
2801
2802   if (! err)
2803     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2804   else
2805     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2806
2807   return ret_err;
2808 }
2809
2810 /* Lock agent?  FIXME: stub function.  */
2811 static gpg_error_t
2812 ssh_lock (void)
2813 {
2814   gpg_error_t err;
2815
2816   /* FIXME */
2817   log_error ("ssh-agent's lock command is not implemented\n");
2818   err = 0;
2819
2820   return err;
2821 }
2822
2823 /* Unock agent?  FIXME: stub function.  */
2824 static gpg_error_t
2825 ssh_unlock (void)
2826 {
2827   gpg_error_t err;
2828
2829   log_error ("ssh-agent's unlock command is not implemented\n");
2830   err = 0;
2831
2832   return err;
2833 }
2834
2835 /* Handler for the "lock" command.  */
2836 static gpg_error_t
2837 ssh_handler_lock (ctrl_t ctrl, estream_t request, estream_t response)
2838 {
2839   gpg_error_t ret_err;
2840   gpg_error_t err;
2841
2842   (void)ctrl;
2843   (void)request;
2844
2845   err = ssh_lock ();
2846
2847   if (! err)
2848     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2849   else
2850     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2851
2852   return ret_err;
2853 }
2854
2855 /* Handler for the "unlock" command.  */
2856 static gpg_error_t
2857 ssh_handler_unlock (ctrl_t ctrl, estream_t request, estream_t response)
2858 {
2859   gpg_error_t ret_err;
2860   gpg_error_t err;
2861
2862   (void)ctrl;
2863   (void)request;
2864
2865   err = ssh_unlock ();
2866
2867   if (! err)
2868     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2869   else
2870     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2871
2872   return ret_err;
2873 }
2874
2875 \f
2876
2877 /* Return the request specification for the request identified by TYPE
2878    or NULL in case the requested request specification could not be
2879    found.  */
2880 static ssh_request_spec_t *
2881 request_spec_lookup (int type)
2882 {
2883   ssh_request_spec_t *spec;
2884   unsigned int i;
2885
2886   for (i = 0; i < DIM (request_specs); i++)
2887     if (request_specs[i].type == type)
2888       break;
2889   if (i == DIM (request_specs))
2890     {
2891       if (opt.verbose)
2892         log_info ("ssh request %u is not supported\n", type);
2893       spec = NULL;
2894     }
2895   else
2896     spec = request_specs + i;
2897
2898   return spec;
2899 }
2900
2901 /* Process a single request.  The request is read from and the
2902    response is written to STREAM_SOCK.  Uses CTRL as context.  Returns
2903    zero in case of success, non zero in case of failure.  */
2904 static int
2905 ssh_request_process (ctrl_t ctrl, estream_t stream_sock)
2906 {
2907   ssh_request_spec_t *spec;
2908   estream_t response;
2909   estream_t request;
2910   unsigned char request_type;
2911   gpg_error_t err;
2912   int send_err;
2913   int ret;
2914   unsigned char *request_data;
2915   u32 request_data_size;
2916   u32 response_size;
2917
2918   request_data = NULL;
2919   response = NULL;
2920   request = NULL;
2921   send_err = 0;
2922
2923   /* Create memory streams for request/response data.  The entire
2924      request will be stored in secure memory, since it might contain
2925      secret key material.  The response does not have to be stored in
2926      secure memory, since we never give out secret keys.
2927
2928      Note: we only have little secure memory, but there is NO
2929      possibility of DoS here; only trusted clients are allowed to
2930      connect to the agent.  What could happen is that the agent
2931      returns out-of-secure-memory errors on requests in case the
2932      agent's owner floods his own agent with many large messages.
2933      -moritz */
2934
2935   /* Retrieve request.  */
2936   err = stream_read_string (stream_sock, 1, &request_data, &request_data_size);
2937   if (err)
2938     goto out;
2939
2940   if (opt.verbose > 1)
2941     log_info ("received ssh request of length %u\n",
2942               (unsigned int)request_data_size);
2943
2944   if (! request_data_size)
2945     {
2946       send_err = 1;
2947       goto out;
2948       /* Broken request; FIXME.  */
2949     }
2950
2951   request_type = request_data[0];
2952   spec = request_spec_lookup (request_type);
2953   if (! spec)
2954     {
2955       send_err = 1;
2956       goto out;
2957       /* Unknown request; FIXME.  */
2958     }
2959
2960   if (spec->secret_input)
2961     request = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+");
2962   else
2963     request = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+");
2964   if (! request)
2965     {
2966       err = gpg_error_from_syserror ();
2967       goto out;
2968     }
2969   ret = es_setvbuf (request, NULL, _IONBF, 0);
2970   if (ret)
2971     {
2972       err = gpg_error_from_syserror ();
2973       goto out;
2974     }
2975   err = stream_write_data (request, request_data + 1, request_data_size - 1);
2976   if (err)
2977     goto out;
2978   es_rewind (request);
2979
2980   response = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
2981   if (! response)
2982     {
2983       err = gpg_error_from_syserror ();
2984       goto out;
2985     }
2986
2987   if (opt.verbose)
2988     log_info ("ssh request handler for %s (%u) started\n",
2989                spec->identifier, spec->type);
2990
2991   err = (*spec->handler) (ctrl, request, response);
2992
2993   if (opt.verbose)
2994     {
2995       if (err)
2996         log_info ("ssh request handler for %s (%u) failed: %s\n",
2997                   spec->identifier, spec->type, gpg_strerror (err));
2998       else
2999         log_info ("ssh request handler for %s (%u) ready\n",
3000                   spec->identifier, spec->type);
3001     }
3002
3003   if (err)
3004     {
3005       send_err = 1;
3006       goto out;
3007     }
3008
3009   response_size = es_ftell (response);
3010   if (opt.verbose > 1)
3011     log_info ("sending ssh response of length %u\n",
3012               (unsigned int)response_size);
3013
3014   err = es_fseek (response, 0, SEEK_SET);
3015   if (err)
3016     {
3017       send_err = 1;
3018       goto out;
3019     }
3020
3021   err = stream_write_uint32 (stream_sock, response_size);
3022   if (err)
3023     {
3024       send_err = 1;
3025       goto out;
3026     }
3027
3028   err = stream_copy (stream_sock, response);
3029   if (err)
3030     goto out;
3031
3032   err = es_fflush (stream_sock);
3033   if (err)
3034     goto out;
3035
3036  out:
3037
3038   if (err && es_feof (stream_sock))
3039     log_error ("error occured while processing request: %s\n",
3040                gpg_strerror (err));
3041
3042   if (send_err)
3043     {
3044       if (opt.verbose > 1)
3045         log_info ("sending ssh error response\n");
3046       err = stream_write_uint32 (stream_sock, 1);
3047       if (err)
3048         goto leave;
3049       err = stream_write_byte (stream_sock, SSH_RESPONSE_FAILURE);
3050       if (err)
3051         goto leave;
3052     }
3053
3054  leave:
3055
3056   if (request)
3057     es_fclose (request);
3058   if (response)
3059     es_fclose (response);
3060   xfree (request_data);         /* FIXME?  */
3061
3062   return !!err;
3063 }
3064
3065 /* Start serving client on SOCK_CLIENT.  */
3066 void
3067 start_command_handler_ssh (ctrl_t ctrl, gnupg_fd_t sock_client)
3068 {
3069   estream_t stream_sock = NULL;
3070   gpg_error_t err = 0;
3071   int ret;
3072
3073   /* Because the ssh protocol does not send us information about the
3074      the current TTY setting, we resort here to use those from startup
3075      or those explictly set.  */
3076   {
3077     static const char *names[] =
3078       {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
3079     int idx;
3080     const char *value;
3081
3082     for (idx=0; !err && names[idx]; idx++)
3083       if (!session_env_getenv (ctrl->session_env, names[idx])
3084           && (value = session_env_getenv (opt.startup_env, names[idx])))
3085         err = session_env_setenv (ctrl->session_env, names[idx], value);
3086
3087     if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
3088       if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
3089         err = gpg_error_from_syserror ();
3090
3091     if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
3092       if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
3093         err = gpg_error_from_syserror ();
3094
3095     if (err)
3096       {
3097         log_error ("error setting default session environment: %s\n",
3098                    gpg_strerror (err));
3099         goto out;
3100       }
3101   }
3102
3103
3104   /* Create stream from socket.  */
3105   stream_sock = es_fdopen (FD2INT(sock_client), "r+");
3106   if (!stream_sock)
3107     {
3108       err = gpg_error_from_syserror ();
3109       log_error (_("failed to create stream from socket: %s\n"),
3110                  gpg_strerror (err));
3111       goto out;
3112     }
3113   /* We have to disable the estream buffering, because the estream
3114      core doesn't know about secure memory.  */
3115   ret = es_setvbuf (stream_sock, NULL, _IONBF, 0);
3116   if (ret)
3117     {
3118       err = gpg_error_from_syserror ();
3119       log_error ("failed to disable buffering "
3120                  "on socket stream: %s\n", gpg_strerror (err));
3121       goto out;
3122     }
3123
3124   /* Main processing loop. */
3125   while ( !ssh_request_process (ctrl, stream_sock) )
3126     {
3127       /* Check wether we have reached EOF before trying to read
3128          another request.  */
3129       int c;
3130
3131       c = es_fgetc (stream_sock);
3132       if (c == EOF)
3133         break;
3134       es_ungetc (c, stream_sock);
3135     }
3136
3137   /* Reset the SCD in case it has been used. */
3138   agent_reset_scd (ctrl);
3139
3140
3141  out:
3142   if (stream_sock)
3143     es_fclose (stream_sock);
3144 }