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