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