More agent support for gpg.
[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       estream_t stream = es_fopen (fname, "wx,mode=-rw-r");  
682       if (!stream)
683         {
684           err = gpg_error_from_syserror ();
685           log_error (_("can't create `%s': %s\n"), fname, gpg_strerror (err));
686           xfree (fname);
687           return err;
688         }
689       es_fputs (sshcontrolblurb, stream);
690       es_fclose (stream);
691       fp = fopen (fname, append? "a+":"r");
692     }
693
694   if (!fp)
695     {
696       err = gpg_error (gpg_err_code_from_errno (errno));
697       log_error (_("can't open `%s': %s\n"), fname, gpg_strerror (err));
698       xfree (fname);
699       return err;
700     }
701   
702   *r_fp = fp;  
703
704   return 0;
705 }
706
707
708 /* Search the file at stream FP from the beginning until a matching
709    HEXGRIP is found; return success in this case and store true at
710    DISABLED if the found key has been disabled.  If R_TTL is not NULL
711    a specified TTL for that key is stored there. */
712 static gpg_error_t
713 search_control_file (FILE *fp, const char *hexgrip, 
714                      int *r_disabled, int *r_ttl)
715 {
716   int c, i;
717   char *p, *pend, line[256];
718   long ttl;
719
720   assert (strlen (hexgrip) == 40 );
721
722   fseek (fp, 0, SEEK_SET);
723   clearerr (fp);
724   *r_disabled = 0;
725  next_line:
726   do
727     {
728       if (!fgets (line, DIM(line)-1, fp) )
729         {
730           if (feof (fp))
731             return gpg_error (GPG_ERR_EOF);
732           return gpg_error (gpg_err_code_from_errno (errno));
733         }
734       
735       if (!*line || line[strlen(line)-1] != '\n')
736         {
737           /* Eat until end of line */
738           while ( (c=getc (fp)) != EOF && c != '\n')
739             ;
740           return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
741                                  : GPG_ERR_INCOMPLETE_LINE);
742         }
743       
744       /* Allow for empty lines and spaces */
745       for (p=line; spacep (p); p++)
746         ;
747     }
748   while (!*p || *p == '\n' || *p == '#');
749   
750   *r_disabled = 0;
751   if (*p == '!')
752     {
753       *r_disabled = 1;
754       for (p++; spacep (p); p++)
755         ;
756     }
757
758   for (i=0; hexdigitp (p) && i < 40; p++, i++)
759     if (hexgrip[i] != (*p >= 'a'? (*p & 0xdf): *p))
760       goto next_line;
761   if (i != 40 || !(spacep (p) || *p == '\n'))
762     {
763       log_error ("invalid formatted line in ssh control file\n");
764       return gpg_error (GPG_ERR_BAD_DATA);
765     }
766
767   ttl = strtol (p, &pend, 10);
768   p = pend;
769   if (!(spacep (p) || *p == '\n') || ttl < -1)
770     {
771       log_error ("invalid TTL value in ssh control file; assuming 0\n");
772       ttl = 0;
773     }
774   if (r_ttl)
775     *r_ttl = ttl;
776
777   /* Here is the place to parse flags if we need them.  */  
778
779   return 0; /* Okay:  found it.  */
780 }
781
782
783
784 /* Add an entry to the control file to mark the key with the keygrip
785    HEXGRIP as usable for SSH; i.e. it will be returned when ssh asks
786    for it.  This function is in general used to add a key received
787    through the ssh-add function.  We can assume that the user wants to
788    allow ssh using this key. */
789 static gpg_error_t
790 add_control_entry (ctrl_t ctrl, const char *hexgrip, int ttl)
791 {
792   gpg_error_t err;
793   FILE *fp;
794   int disabled;
795
796   (void)ctrl;
797
798   err = open_control_file (&fp, 1);
799   if (err)
800     return err;
801
802   err = search_control_file (fp, hexgrip, &disabled, NULL);
803   if (err && gpg_err_code(err) == GPG_ERR_EOF)
804     {
805       struct tm *tp;
806       time_t atime = time (NULL);
807
808       /* Not yet in the file - add it. Because the file has been
809          opened in append mode, we simply need to write to it.  */
810       tp = localtime (&atime);
811       fprintf (fp, "# Key added on %04d-%02d-%02d %02d:%02d:%02d\n%s %d\n",
812                1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
813                tp->tm_hour, tp->tm_min, tp->tm_sec,
814                hexgrip, ttl);
815                
816     }
817   fclose (fp);
818   return 0;
819 }
820
821
822 /* Scan the sshcontrol file and return the TTL.  */
823 static int
824 ttl_from_sshcontrol (const char *hexgrip)
825 {
826   FILE *fp;
827   int disabled, ttl;
828
829   if (!hexgrip || strlen (hexgrip) != 40)
830     return 0;  /* Wrong input: Use global default.  */
831
832   if (open_control_file (&fp, 0))
833     return 0; /* Error: Use the global default TTL.  */
834
835   if (search_control_file (fp, hexgrip, &disabled, &ttl)
836       || disabled)
837     ttl = 0;  /* Use the global default if not found or disabled.  */
838
839   fclose (fp); 
840
841   return ttl;
842 }
843
844
845
846 \f
847
848 /*
849
850   MPI lists. 
851
852  */
853
854 /* Free the list of MPIs MPI_LIST.  */
855 static void
856 mpint_list_free (gcry_mpi_t *mpi_list)
857 {
858   if (mpi_list)
859     {
860       unsigned int i;
861
862       for (i = 0; mpi_list[i]; i++)
863         gcry_mpi_release (mpi_list[i]);
864       xfree (mpi_list);
865     }
866 }
867
868 /* Receive key material MPIs from STREAM according to KEY_SPEC;
869    depending on SECRET expect a public key or secret key.  The newly
870    allocated list of MPIs is stored in MPI_LIST.  Returns usual error
871    code.  */
872 static gpg_error_t
873 ssh_receive_mpint_list (estream_t stream, int secret,
874                         ssh_key_type_spec_t key_spec, gcry_mpi_t **mpi_list)
875 {
876   unsigned int elems_public_n;
877   const char *elems_public;
878   unsigned int elems_n;
879   const char *elems;
880   int elem_is_secret;
881   gcry_mpi_t *mpis;
882   gpg_error_t err;
883   unsigned int i;
884
885   mpis = NULL;
886   err = 0;
887   
888   if (secret)
889     elems = key_spec.elems_key_secret;
890   else
891     elems = key_spec.elems_key_public;
892   elems_n = strlen (elems);
893
894   elems_public = key_spec.elems_key_public;
895   elems_public_n = strlen (elems_public);
896
897   mpis = xtrycalloc (elems_n + 1, sizeof *mpis );
898   if (!mpis)
899     {
900       err = gpg_error_from_syserror ();
901       goto out;
902     }
903
904   elem_is_secret = 0;
905   for (i = 0; i < elems_n; i++)
906     {
907       if (secret)
908         elem_is_secret = ! strchr (elems_public, elems[i]);
909       err = stream_read_mpi (stream, elem_is_secret, &mpis[i]);
910       if (err)
911         break;
912     }
913   if (err)
914     goto out;
915
916   *mpi_list = mpis;
917
918  out:
919
920   if (err)
921     mpint_list_free (mpis);
922
923   return err;
924 }
925
926 \f
927
928 /* Key modifier function for RSA.  */
929 static gpg_error_t
930 ssh_key_modifier_rsa (const char *elems, gcry_mpi_t *mpis)
931 {
932   gcry_mpi_t p;
933   gcry_mpi_t q;
934   gcry_mpi_t u;
935
936   if (strcmp (elems, "nedupq"))
937     /* Modifying only necessary for secret keys.  */
938     goto out;
939
940   u = mpis[3];
941   p = mpis[4];
942   q = mpis[5];
943
944   if (gcry_mpi_cmp (p, q) > 0)
945     {
946       /* P shall be smaller then Q!  Swap primes.  iqmp becomes u.  */
947       gcry_mpi_t tmp;
948
949       tmp = mpis[4];
950       mpis[4] = mpis[5];
951       mpis[5] = tmp;
952     }
953   else
954     /* U needs to be recomputed.  */
955     gcry_mpi_invm (u, p, q);
956
957  out:
958
959   return 0;
960 }
961
962 /* Signature encoder function for RSA.  */
963 static gpg_error_t
964 ssh_signature_encoder_rsa (estream_t signature_blob, gcry_mpi_t *mpis)
965 {
966   unsigned char *data;
967   size_t data_n;
968   gpg_error_t err;
969   gcry_mpi_t s;
970
971   s = mpis[0];
972
973   err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &data, &data_n, s);
974   if (err)
975     goto out;
976
977   err = stream_write_string (signature_blob, data, data_n);
978   xfree (data);
979
980  out:
981
982   return err;
983 }
984
985
986 /* Signature encoder function for DSA.  */
987 static gpg_error_t
988 ssh_signature_encoder_dsa (estream_t signature_blob, gcry_mpi_t *mpis)
989 {
990   unsigned char buffer[SSH_DSA_SIGNATURE_PADDING * SSH_DSA_SIGNATURE_ELEMS];
991   unsigned char *data;
992   size_t data_n;
993   gpg_error_t err;
994   int i;
995
996   data = NULL;
997
998   for (i = 0; i < 2; i++)
999     {
1000       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &data, &data_n, mpis[i]);
1001       if (err)
1002         break;
1003
1004       if (data_n > SSH_DSA_SIGNATURE_PADDING)
1005         {
1006           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
1007           break;
1008         }
1009       
1010       memset (buffer + (i * SSH_DSA_SIGNATURE_PADDING), 0,
1011               SSH_DSA_SIGNATURE_PADDING - data_n);
1012       memcpy (buffer + (i * SSH_DSA_SIGNATURE_PADDING)
1013               + (SSH_DSA_SIGNATURE_PADDING - data_n), data, data_n);
1014
1015       xfree (data);
1016       data = NULL;
1017     }
1018   if (err)
1019     goto out;
1020
1021   err = stream_write_string (signature_blob, buffer, sizeof (buffer));
1022
1023  out:
1024
1025   xfree (data);
1026
1027   return err;
1028 }
1029
1030 /* 
1031    S-Expressions. 
1032  */
1033
1034
1035 /* This function constructs a new S-Expression for the key identified
1036    by the KEY_SPEC, SECRET, MPIS and COMMENT, which is to be stored in
1037    *SEXP.  Returns usual error code.  */
1038 static gpg_error_t
1039 sexp_key_construct (gcry_sexp_t *sexp,
1040                     ssh_key_type_spec_t key_spec, int secret,
1041                     gcry_mpi_t *mpis, const char *comment)
1042 {
1043   const char *key_identifier[] = { "public-key", "private-key" };
1044   gcry_sexp_t sexp_new;
1045   char *sexp_template;
1046   size_t sexp_template_n;
1047   gpg_error_t err;
1048   const char *elems;
1049   size_t elems_n;
1050   unsigned int i;
1051   unsigned int j;
1052   void **arg_list;
1053
1054   err = 0;
1055   sexp_new = NULL;
1056   arg_list = NULL;
1057   if (secret)
1058     elems = key_spec.elems_sexp_order;
1059   else
1060     elems = key_spec.elems_key_public;
1061   elems_n = strlen (elems);
1062
1063   /*
1064     Calculate size for sexp_template_n:
1065
1066     "(%s(%s<mpis>)(comment%s))" -> 20 + sizeof (<mpis>).
1067
1068     mpi: (X%m) -> 5.
1069
1070   */
1071   sexp_template_n = 20 + (elems_n * 5);
1072   sexp_template = xtrymalloc (sexp_template_n);
1073   if (! sexp_template)
1074     {
1075       err = gpg_error_from_syserror ();
1076       goto out;
1077     }
1078
1079   /* Key identifier, algorithm identifier, mpis, comment.  */
1080   arg_list = xtrymalloc (sizeof (*arg_list) * (2 + elems_n + 1));
1081   if (! arg_list)
1082     {
1083       err = gpg_error_from_syserror ();
1084       goto out;
1085     }
1086
1087   i = 0;
1088   arg_list[i++] = &key_identifier[secret];
1089   arg_list[i++] = &key_spec.identifier;
1090
1091   *sexp_template = 0;
1092   sexp_template_n = 0;
1093   sexp_template_n = sprintf (sexp_template + sexp_template_n, "(%%s(%%s");
1094   for (i = 0; i < elems_n; i++)
1095     {
1096       sexp_template_n += sprintf (sexp_template + sexp_template_n, "(%c%%m)",
1097                                   elems[i]);
1098       if (secret)
1099         {
1100           for (j = 0; j < elems_n; j++)
1101             if (key_spec.elems_key_secret[j] == elems[i])
1102               break;
1103         }
1104       else
1105         j = i;
1106       arg_list[i + 2] = &mpis[j];
1107     }
1108   sexp_template_n += sprintf (sexp_template + sexp_template_n,
1109                               ")(comment%%s))");
1110
1111   arg_list[i + 2] = &comment;
1112
1113   err = gcry_sexp_build_array (&sexp_new, NULL, sexp_template, arg_list);
1114   if (err)
1115     goto out;
1116
1117   *sexp = sexp_new;
1118
1119  out:
1120
1121   xfree (arg_list);
1122   xfree (sexp_template);
1123
1124   return err;
1125 }
1126
1127 /* This functions breaks up the key contained in the S-Expression SEXP
1128    according to KEY_SPEC.  The MPIs are bundled in a newly create
1129    list, which is to be stored in MPIS; a newly allocated string
1130    holding the comment will be stored in COMMENT; SECRET will be
1131    filled with a boolean flag specifying what kind of key it is.
1132    Returns usual error code.  */
1133 static gpg_error_t
1134 sexp_key_extract (gcry_sexp_t sexp,
1135                   ssh_key_type_spec_t key_spec, int *secret,
1136                   gcry_mpi_t **mpis, char **comment)
1137 {
1138   gpg_error_t err;
1139   gcry_sexp_t value_list;
1140   gcry_sexp_t value_pair;
1141   gcry_sexp_t comment_list;
1142   unsigned int i;
1143   char *comment_new;
1144   const char *data;
1145   size_t data_n;
1146   int is_secret;
1147   size_t elems_n;
1148   const char *elems;
1149   gcry_mpi_t *mpis_new;
1150   gcry_mpi_t mpi;
1151
1152   err = 0;
1153   value_list = NULL;
1154   value_pair = NULL;
1155   comment_list = NULL;
1156   comment_new = NULL;
1157   mpis_new = NULL;
1158
1159   data = gcry_sexp_nth_data (sexp, 0, &data_n);
1160   if (! data)
1161     {
1162       err = gpg_error (GPG_ERR_INV_SEXP);
1163       goto out;
1164     }
1165
1166   if ((data_n == 10 && !strncmp (data, "public-key", 10))
1167       || (data_n == 21 && !strncmp (data, "protected-private-key", 21))
1168       || (data_n == 20 && !strncmp (data, "shadowed-private-key", 20)))
1169     {
1170       is_secret = 0;
1171       elems = key_spec.elems_key_public;
1172     }
1173   else if (data_n == 11 && !strncmp (data, "private-key", 11))
1174     {
1175       is_secret = 1;
1176       elems = key_spec.elems_key_secret;
1177     }
1178   else
1179     {
1180       err = gpg_error (GPG_ERR_INV_SEXP);
1181       goto out;
1182     }
1183
1184   elems_n = strlen (elems);
1185   mpis_new = xtrycalloc (elems_n + 1, sizeof *mpis_new );
1186   if (!mpis_new)
1187     {
1188       err = gpg_error_from_syserror ();
1189       goto out;
1190     }
1191
1192   value_list = gcry_sexp_find_token (sexp, key_spec.identifier, 0);
1193   if (! value_list)
1194     {
1195       err = gpg_error (GPG_ERR_INV_SEXP);
1196       goto out;
1197     }
1198
1199   for (i = 0; i < elems_n; i++)
1200     {
1201       value_pair = gcry_sexp_find_token (value_list, elems + i, 1);
1202       if (! value_pair)
1203         {
1204           err = gpg_error (GPG_ERR_INV_SEXP);
1205           break;
1206         }
1207
1208       /* Note that we need to use STD format; i.e. prepend a 0x00 to
1209          indicate a positive number if the high bit is set. */
1210       mpi = gcry_sexp_nth_mpi (value_pair, 1, GCRYMPI_FMT_STD);
1211       if (! mpi)
1212         {
1213           err = gpg_error (GPG_ERR_INV_SEXP);
1214           break;
1215         }
1216       mpis_new[i] = mpi;
1217       gcry_sexp_release (value_pair);
1218       value_pair = NULL;
1219     }
1220   if (err)
1221     goto out;
1222
1223   /* We do not require a comment sublist to be present here.  */
1224   data = NULL;
1225   data_n = 0;
1226
1227   comment_list = gcry_sexp_find_token (sexp, "comment", 0);
1228   if (comment_list)
1229     data = gcry_sexp_nth_data (comment_list, 1, &data_n);
1230   if (! data)
1231     {
1232       data = "(none)";
1233       data_n = 6;
1234     }
1235
1236   comment_new = make_cstring (data, data_n);
1237   if (! comment_new)
1238     {
1239       err = gpg_error_from_syserror ();
1240       goto out;
1241     }
1242
1243   if (secret)
1244     *secret = is_secret;
1245   *mpis = mpis_new;
1246   *comment = comment_new;
1247
1248  out:
1249
1250   gcry_sexp_release (value_list);
1251   gcry_sexp_release (value_pair);
1252   gcry_sexp_release (comment_list);
1253   
1254   if (err)
1255     {
1256       xfree (comment_new);
1257       mpint_list_free (mpis_new);
1258     }
1259
1260   return err;
1261 }
1262
1263 /* Extract the car from SEXP, and create a newly created C-string 
1264    which is to be stored in IDENTIFIER.  */
1265 static gpg_error_t
1266 sexp_extract_identifier (gcry_sexp_t sexp, char **identifier)
1267 {
1268   char *identifier_new;
1269   gcry_sexp_t sublist;
1270   const char *data;
1271   size_t data_n;
1272   gpg_error_t err;
1273
1274   identifier_new = NULL;
1275   err = 0;
1276   
1277   sublist = gcry_sexp_nth (sexp, 1);
1278   if (! sublist)
1279     {
1280       err = gpg_error (GPG_ERR_INV_SEXP);
1281       goto out;
1282     }
1283
1284   data = gcry_sexp_nth_data (sublist, 0, &data_n);
1285   if (! data)
1286     {
1287       err = gpg_error (GPG_ERR_INV_SEXP);
1288       goto out;
1289     }
1290
1291   identifier_new = make_cstring (data, data_n);
1292   if (! identifier_new)
1293     {
1294       err = gpg_err_code_from_errno (errno);
1295       goto out;
1296     }
1297
1298   *identifier = identifier_new;
1299
1300  out:
1301
1302   gcry_sexp_release (sublist);
1303
1304   return err;
1305 }
1306
1307 \f
1308
1309 /*
1310
1311   Key I/O.
1312
1313 */
1314
1315 /* Search for a key specification entry.  If SSH_NAME is not NULL,
1316    search for an entry whose "ssh_name" is equal to SSH_NAME;
1317    otherwise, search for an entry whose "name" is equal to NAME.
1318    Store found entry in SPEC on success, return error otherwise.  */
1319 static gpg_error_t
1320 ssh_key_type_lookup (const char *ssh_name, const char *name,
1321                      ssh_key_type_spec_t *spec)
1322 {
1323   gpg_error_t err;
1324   unsigned int i;
1325
1326   for (i = 0; i < DIM (ssh_key_types); i++)
1327     if ((ssh_name && (! strcmp (ssh_name, ssh_key_types[i].ssh_identifier)))
1328         || (name && (! strcmp (name, ssh_key_types[i].identifier))))
1329       break;
1330   
1331   if (i == DIM (ssh_key_types))
1332     err = gpg_error (GPG_ERR_NOT_FOUND);
1333   else
1334     {
1335       *spec = ssh_key_types[i];
1336       err = 0;
1337     }
1338
1339   return err;
1340 }
1341
1342 /* Receive a key from STREAM, according to the key specification given
1343    as KEY_SPEC.  Depending on SECRET, receive a secret or a public
1344    key.  If READ_COMMENT is true, receive a comment string as well.
1345    Constructs a new S-Expression from received data and stores it in
1346    KEY_NEW.  Returns zero on success or an error code.  */
1347 static gpg_error_t
1348 ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret,
1349                  int read_comment, ssh_key_type_spec_t *key_spec)
1350 {
1351   gpg_error_t err;
1352   char *key_type;
1353   char *comment;
1354   gcry_sexp_t key;
1355   ssh_key_type_spec_t spec;
1356   gcry_mpi_t *mpi_list;
1357   const char *elems;
1358
1359   mpi_list = NULL;
1360   key_type = NULL;
1361   comment = "";
1362   key = NULL;
1363         
1364   err = stream_read_cstring (stream, &key_type);
1365   if (err)
1366     goto out;
1367
1368   err = ssh_key_type_lookup (key_type, NULL, &spec);
1369   if (err)
1370     goto out;
1371
1372   err = ssh_receive_mpint_list (stream, secret, spec, &mpi_list);
1373   if (err)
1374     goto out;
1375
1376   if (read_comment)
1377     {
1378       err = stream_read_cstring (stream, &comment);
1379       if (err)
1380         goto out;
1381     }
1382
1383   if (secret)
1384     elems = spec.elems_key_secret;
1385   else
1386     elems = spec.elems_key_public;
1387
1388   if (spec.key_modifier)
1389     {
1390       err = (*spec.key_modifier) (elems, mpi_list);
1391       if (err)
1392         goto out;
1393     }
1394
1395   err = sexp_key_construct (&key, spec, secret, mpi_list, comment);
1396   if (err)
1397     goto out;
1398
1399   if (key_spec)
1400     *key_spec = spec;
1401   *key_new = key;
1402   
1403  out:
1404
1405   mpint_list_free (mpi_list);
1406   xfree (key_type);
1407   if (read_comment)
1408     xfree (comment);
1409
1410   return err;
1411 }
1412
1413 /* Converts a key of type TYPE, whose key material is given in MPIS,
1414    into a newly created binary blob, which is to be stored in
1415    BLOB/BLOB_SIZE.  Returns zero on success or an error code.  */
1416 static gpg_error_t
1417 ssh_convert_key_to_blob (unsigned char **blob, size_t *blob_size,
1418                          const char *type, gcry_mpi_t *mpis)
1419 {
1420   unsigned char *blob_new;
1421   long int blob_size_new;
1422   estream_t stream;
1423   gpg_error_t err;
1424   unsigned int i;
1425
1426   *blob = NULL;
1427   *blob_size = 0;
1428
1429   blob_new = NULL;
1430   stream = NULL;
1431   err = 0;
1432
1433   stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1434   if (! stream)
1435     {
1436       err = gpg_error_from_syserror ();
1437       goto out;
1438     }
1439
1440   err = stream_write_cstring (stream, type);
1441   if (err)
1442     goto out;
1443
1444   for (i = 0; mpis[i] && (! err); i++)
1445     err = stream_write_mpi (stream, mpis[i]);
1446   if (err)
1447     goto out;
1448
1449   blob_size_new = es_ftell (stream);
1450   if (blob_size_new == -1)
1451     {
1452       err = gpg_error_from_syserror ();
1453       goto out;
1454     }
1455   
1456   err = es_fseek (stream, 0, SEEK_SET);
1457   if (err)
1458     goto out;
1459
1460   blob_new = xtrymalloc (blob_size_new);
1461   if (! blob_new)
1462     {
1463       err = gpg_error_from_syserror ();
1464       goto out;
1465     }
1466
1467   err = stream_read_data (stream, blob_new, blob_size_new);
1468   if (err)
1469     goto out;
1470
1471   *blob = blob_new;
1472   *blob_size = blob_size_new;
1473
1474  out:
1475
1476   if (stream)
1477     es_fclose (stream);
1478   if (err)
1479     xfree (blob_new);
1480
1481   return err;
1482 }
1483                               
1484
1485 /* Write the public key KEY_PUBLIC to STREAM in SSH key format.  If
1486    OVERRIDE_COMMENT is not NULL, it will be used instead of the
1487    comment stored in the key.  */
1488 static gpg_error_t
1489 ssh_send_key_public (estream_t stream, gcry_sexp_t key_public,
1490                      const char *override_comment)
1491 {
1492   ssh_key_type_spec_t spec;
1493   gcry_mpi_t *mpi_list;
1494   char *key_type;
1495   char *comment;
1496   unsigned char *blob;
1497   size_t blob_n;
1498   gpg_error_t err;
1499
1500   key_type = NULL;
1501   mpi_list = NULL;
1502   comment = NULL;
1503   blob = NULL;
1504
1505   err = sexp_extract_identifier (key_public, &key_type);
1506   if (err)
1507     goto out;
1508
1509   err = ssh_key_type_lookup (NULL, key_type, &spec);
1510   if (err)
1511     goto out;
1512
1513   err = sexp_key_extract (key_public, spec, NULL, &mpi_list, &comment);
1514   if (err)
1515     goto out;
1516
1517   err = ssh_convert_key_to_blob (&blob, &blob_n,
1518                                  spec.ssh_identifier, mpi_list);
1519   if (err)
1520     goto out;
1521   
1522   err = stream_write_string (stream, blob, blob_n);
1523   if (err)
1524     goto out;
1525
1526   err = stream_write_cstring (stream,
1527                               override_comment? override_comment : comment);
1528   
1529  out:
1530
1531   mpint_list_free (mpi_list);
1532   xfree (key_type);
1533   xfree (comment);
1534   xfree (blob);
1535
1536   return err;
1537 }
1538
1539 /* Read a public key out of BLOB/BLOB_SIZE according to the key
1540    specification given as KEY_SPEC, storing the new key in KEY_PUBLIC.
1541    Returns zero on success or an error code.  */
1542 static gpg_error_t
1543 ssh_read_key_public_from_blob (unsigned char *blob, size_t blob_size,
1544                                gcry_sexp_t *key_public,
1545                                ssh_key_type_spec_t *key_spec)
1546 {
1547   estream_t blob_stream;
1548   gpg_error_t err;
1549
1550   err = 0;
1551   
1552   blob_stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1553   if (! blob_stream)
1554     {
1555       err = gpg_error_from_syserror ();
1556       goto out;
1557     }
1558
1559   err = stream_write_data (blob_stream, blob, blob_size);
1560   if (err)
1561     goto out;
1562
1563   err = es_fseek (blob_stream, 0, SEEK_SET);
1564   if (err)
1565     goto out;
1566
1567   err = ssh_receive_key (blob_stream, key_public, 0, 0, key_spec);
1568
1569  out:
1570
1571   if (blob_stream)
1572     es_fclose (blob_stream);
1573
1574   return err;
1575 }
1576
1577 \f
1578
1579 /* This function calculates the key grip for the key contained in the
1580    S-Expression KEY and writes it to BUFFER, which must be large
1581    enough to hold it.  Returns usual error code.  */
1582 static gpg_error_t
1583 ssh_key_grip (gcry_sexp_t key, unsigned char *buffer)
1584 {
1585   if (!gcry_pk_get_keygrip (key, buffer))
1586     return gpg_error (GPG_ERR_INTERNAL);
1587
1588   return 0;
1589 }
1590
1591 /* Converts the secret key KEY_SECRET into a public key, storing it in
1592    KEY_PUBLIC.  SPEC is the according key specification.  Returns zero
1593    on success or an error code.  */
1594 static gpg_error_t
1595 key_secret_to_public (gcry_sexp_t *key_public,
1596                       ssh_key_type_spec_t spec, gcry_sexp_t key_secret)
1597 {
1598   char *comment;
1599   gcry_mpi_t *mpis;
1600   gpg_error_t err;
1601   int is_secret;
1602
1603   comment = NULL;
1604   mpis = NULL;
1605
1606   err = sexp_key_extract (key_secret, spec, &is_secret, &mpis, &comment);
1607   if (err)
1608     goto out;
1609
1610   err = sexp_key_construct (key_public, spec, 0, mpis, comment);
1611
1612  out:
1613
1614   mpint_list_free (mpis);
1615   xfree (comment);
1616
1617   return err;
1618 }
1619
1620
1621 /* Check whether a smartcard is available and whether it has a usable
1622    key.  Store a copy of that key at R_PK and return 0.  If no key is
1623    available store NULL at R_PK and return an error code.  If CARDSN
1624    is not NULL, a string with the serial number of the card will be
1625    a malloced and stored there. */
1626 static gpg_error_t
1627 card_key_available (ctrl_t ctrl, gcry_sexp_t *r_pk, char **cardsn)
1628 {
1629   gpg_error_t err;
1630   char *authkeyid;
1631   char *serialno = NULL;
1632   unsigned char *pkbuf;
1633   size_t pkbuflen;
1634   gcry_sexp_t s_pk;
1635   unsigned char grip[20];
1636
1637   *r_pk = NULL;
1638   if (cardsn)
1639     *cardsn = NULL;
1640
1641   /* First see whether a card is available and whether the application
1642      is supported.  */
1643   err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
1644   if ( gpg_err_code (err) == GPG_ERR_CARD_REMOVED )
1645     {
1646       /* Ask for the serial number to reset the card.  */
1647       err = agent_card_serialno (ctrl, &serialno);
1648       if (err)
1649         {
1650           if (opt.verbose)
1651             log_info (_("error getting serial number of card: %s\n"),
1652                       gpg_strerror (err));
1653           return err;
1654         }
1655       log_info (_("detected card with S/N: %s\n"), serialno);
1656       err = agent_card_getattr (ctrl, "$AUTHKEYID", &authkeyid);
1657     }
1658   if (err)
1659     {
1660       log_error (_("error getting default authentication keyID of card: %s\n"),
1661                  gpg_strerror (err));
1662       xfree (serialno);
1663       return err;
1664     }
1665
1666   /* Get the S/N if we don't have it yet.  Use the fast getattr method.  */
1667   if (!serialno && (err = agent_card_getattr (ctrl, "SERIALNO", &serialno)) )
1668     {
1669       log_error (_("error getting serial number of card: %s\n"),
1670                  gpg_strerror (err));
1671       xfree (authkeyid);
1672       return err;
1673     }
1674
1675   /* Read the public key.  */
1676   err = agent_card_readkey (ctrl, authkeyid, &pkbuf);
1677   if (err)
1678     {
1679       if (opt.verbose)
1680         log_info (_("no suitable card key found: %s\n"), gpg_strerror (err));
1681       xfree (serialno);
1682       xfree (authkeyid);
1683       return err;
1684     }
1685
1686   pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
1687   err = gcry_sexp_sscan (&s_pk, NULL, (char*)pkbuf, pkbuflen);
1688   if (err)
1689     {
1690       log_error ("failed to build S-Exp from received card key: %s\n",
1691                  gpg_strerror (err));
1692       xfree (pkbuf);
1693       xfree (serialno);
1694       xfree (authkeyid);
1695       return err;
1696     }
1697
1698   err = ssh_key_grip (s_pk, grip);
1699   if (err)
1700     {
1701       log_debug ("error computing keygrip from received card key: %s\n",
1702                  gcry_strerror (err));
1703       xfree (pkbuf);
1704       gcry_sexp_release (s_pk);
1705       xfree (serialno);
1706       xfree (authkeyid);
1707       return err;
1708     }
1709
1710   if ( agent_key_available (grip) )
1711     {
1712       /* (Shadow)-key is not available in our key storage.  */
1713       unsigned char *shadow_info;
1714       unsigned char *tmp;
1715       
1716       shadow_info = make_shadow_info (serialno, authkeyid);
1717       if (!shadow_info)
1718         {
1719           err = gpg_error_from_syserror ();
1720           xfree (pkbuf);
1721           gcry_sexp_release (s_pk);
1722           xfree (serialno);
1723           xfree (authkeyid);
1724           return err;
1725         }
1726       err = agent_shadow_key (pkbuf, shadow_info, &tmp);
1727       xfree (shadow_info);
1728       if (err)
1729         {
1730           log_error (_("shadowing the key failed: %s\n"), gpg_strerror (err));
1731           xfree (pkbuf);
1732           gcry_sexp_release (s_pk);
1733           xfree (serialno);
1734           xfree (authkeyid);
1735           return err;
1736         }
1737       xfree (pkbuf);
1738       pkbuf = tmp;
1739       pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
1740       assert (pkbuflen);
1741
1742       err = agent_write_private_key (grip, pkbuf, pkbuflen, 0);
1743       if (err)
1744         {
1745           log_error (_("error writing key: %s\n"), gpg_strerror (err));
1746           xfree (pkbuf);
1747           gcry_sexp_release (s_pk);
1748           xfree (serialno);
1749           xfree (authkeyid);
1750           return err;
1751         }
1752     }
1753
1754   if (cardsn)
1755     {
1756       char *dispsn;
1757
1758       /* If the card handler is able to return a short serialnumber,
1759          use that one, else use the complete serialno. */
1760       if (!agent_card_getattr (ctrl, "$DISPSERIALNO", &dispsn))
1761         {
1762           *cardsn = xtryasprintf ("cardno:%s", dispsn);
1763           xfree (dispsn);
1764         }
1765       else
1766         *cardsn = xtryasprintf ("cardno:%s", serialno);
1767       if (!*cardsn)
1768         {
1769           err = gpg_error_from_syserror ();
1770           xfree (pkbuf);
1771           gcry_sexp_release (s_pk);
1772           xfree (serialno);
1773           xfree (authkeyid);
1774           return err;
1775         }
1776     }
1777
1778   xfree (pkbuf);
1779   xfree (serialno);
1780   xfree (authkeyid);
1781   *r_pk = s_pk;
1782   return 0;
1783 }
1784
1785
1786 \f
1787
1788 /*
1789
1790   Request handler.  Each handler is provided with a CTRL context, a
1791   REQUEST object and a RESPONSE object.  The actual request is to be
1792   read from REQUEST, the response needs to be written to RESPONSE.
1793
1794 */
1795
1796
1797 /* Handler for the "request_identities" command.  */
1798 static gpg_error_t
1799 ssh_handler_request_identities (ctrl_t ctrl,
1800                                 estream_t request, estream_t response)
1801 {
1802   char *key_type;
1803   ssh_key_type_spec_t spec;
1804   struct dirent *dir_entry;
1805   char *key_directory;
1806   size_t key_directory_n;
1807   char *key_path;
1808   unsigned char *buffer;
1809   size_t buffer_n;
1810   u32 key_counter;
1811   estream_t key_blobs;
1812   gcry_sexp_t key_secret;
1813   gcry_sexp_t key_public;
1814   DIR *dir;
1815   gpg_error_t err;
1816   int ret;
1817   FILE *ctrl_fp = NULL;
1818   char *cardsn;
1819   gpg_error_t ret_err;
1820
1821   (void)request;
1822
1823   /* Prepare buffer stream.  */
1824
1825   key_directory = NULL;
1826   key_secret = NULL;
1827   key_public = NULL;
1828   key_type = NULL;
1829   key_path = NULL;
1830   key_counter = 0;
1831   buffer = NULL;
1832   dir = NULL;
1833   err = 0;
1834
1835   key_blobs = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
1836   if (! key_blobs)
1837     {
1838       err = gpg_error_from_syserror ();
1839       goto out;
1840     }
1841
1842   /* Open key directory.  */
1843   key_directory = make_filename (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, NULL);
1844   if (! key_directory)
1845     {
1846       err = gpg_err_code_from_errno (errno);
1847       goto out;
1848     }
1849   key_directory_n = strlen (key_directory);
1850   
1851   key_path = xtrymalloc (key_directory_n + 46);
1852   if (! key_path)
1853     {
1854       err = gpg_err_code_from_errno (errno);
1855       goto out;
1856     }
1857
1858   sprintf (key_path, "%s/", key_directory);
1859   sprintf (key_path + key_directory_n + 41, ".key");
1860
1861   dir = opendir (key_directory);
1862   if (! dir)
1863     {
1864       err = gpg_err_code_from_errno (errno);
1865       goto out;
1866     }
1867
1868
1869
1870   /* First check whether a key is currently available in the card
1871      reader - this should be allowed even without being listed in
1872      sshcontrol. */
1873
1874   if (!card_key_available (ctrl, &key_public, &cardsn))
1875     {
1876       err = ssh_send_key_public (key_blobs, key_public, cardsn);
1877       gcry_sexp_release (key_public);
1878       key_public = NULL;
1879       xfree (cardsn);
1880       if (err)
1881         goto out;
1882       
1883       key_counter++;
1884     }
1885
1886
1887   /* Then look at all the registered an allowed keys. */
1888
1889
1890   /* Fixme: We should better iterate over the control file and check
1891      whether the key file is there.  This is better in resepct to
1892      performance if tehre are a lot of key sin our key storage. */
1893   /* FIXME: make sure that buffer gets deallocated properly.  */
1894   err = open_control_file (&ctrl_fp, 0);
1895   if (err)
1896     goto out;
1897
1898   while ( (dir_entry = readdir (dir)) )
1899     {
1900       if ((strlen (dir_entry->d_name) == 44)
1901           && (! strncmp (dir_entry->d_name + 40, ".key", 4)))
1902         {
1903           char hexgrip[41];
1904           int disabled;
1905
1906           /* We do only want to return keys listed in our control
1907              file. */
1908           strncpy (hexgrip, dir_entry->d_name, 40);
1909           hexgrip[40] = 0;
1910           if ( strlen (hexgrip) != 40 )
1911             continue;
1912           if (search_control_file (ctrl_fp, hexgrip, &disabled, NULL)
1913               || disabled)
1914             continue;
1915
1916           strncpy (key_path + key_directory_n + 1, dir_entry->d_name, 40);
1917
1918           /* Read file content.  */
1919           err = file_to_buffer (key_path, &buffer, &buffer_n);
1920           if (err)
1921             goto out;
1922               
1923           err = gcry_sexp_sscan (&key_secret, NULL, (char*)buffer, buffer_n);
1924           if (err)
1925             goto out;
1926
1927           xfree (buffer);
1928           buffer = NULL;
1929
1930           err = sexp_extract_identifier (key_secret, &key_type);
1931           if (err)
1932             goto out;
1933
1934           err = ssh_key_type_lookup (NULL, key_type, &spec);
1935           if (err)
1936             goto out;
1937
1938           xfree (key_type);
1939           key_type = NULL;
1940
1941           err = key_secret_to_public (&key_public, spec, key_secret);
1942           if (err)
1943             goto out;
1944
1945           gcry_sexp_release (key_secret);
1946           key_secret = NULL;
1947               
1948           err = ssh_send_key_public (key_blobs, key_public, NULL);
1949           if (err)
1950             goto out;
1951
1952           gcry_sexp_release (key_public);
1953           key_public = NULL;
1954
1955           key_counter++;
1956         }
1957     }
1958   
1959   ret = es_fseek (key_blobs, 0, SEEK_SET);
1960   if (ret)
1961     {
1962       err = gpg_error_from_syserror ();
1963       goto out;
1964     }
1965
1966  out:
1967
1968   /* Send response.  */
1969
1970   gcry_sexp_release (key_secret);
1971   gcry_sexp_release (key_public);
1972
1973   if (! err)
1974     {
1975       ret_err = stream_write_byte (response, SSH_RESPONSE_IDENTITIES_ANSWER);
1976       if (ret_err)
1977         goto leave;
1978       ret_err = stream_write_uint32 (response, key_counter);
1979       if (ret_err)
1980         goto leave;
1981       ret_err = stream_copy (response, key_blobs);
1982       if (ret_err)
1983         goto leave;
1984     }
1985   else
1986     {
1987       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
1988       goto leave;
1989     };
1990
1991  leave:
1992
1993   if (key_blobs)
1994     es_fclose (key_blobs);
1995   if (dir)
1996     closedir (dir);
1997
1998   if (ctrl_fp)
1999     fclose (ctrl_fp);
2000
2001   xfree (key_directory);
2002   xfree (key_path);
2003   xfree (buffer);
2004   xfree (key_type);
2005
2006   return ret_err;
2007 }
2008
2009
2010 /* This function hashes the data contained in DATA of size DATA_N
2011    according to the message digest algorithm specified by MD_ALGORITHM
2012    and writes the message digest to HASH, which needs to large enough
2013    for the digest.  */
2014 static gpg_error_t
2015 data_hash (unsigned char *data, size_t data_n,
2016            int md_algorithm, unsigned char *hash)
2017 {
2018   gcry_md_hash_buffer (md_algorithm, hash, data, data_n);
2019
2020   return 0;
2021 }
2022
2023 /* This function signs the data contained in CTRL, stores the created
2024    signature in newly allocated memory in SIG and it's size in SIG_N;
2025    SIG_ENCODER is the signature encoder to use.  */
2026 static gpg_error_t
2027 data_sign (ctrl_t ctrl, ssh_signature_encoder_t sig_encoder,
2028            unsigned char **sig, size_t *sig_n)
2029 {
2030   gpg_error_t err;
2031   gcry_sexp_t signature_sexp = NULL;
2032   estream_t stream = NULL;
2033   gcry_sexp_t valuelist = NULL;
2034   gcry_sexp_t sublist = NULL;
2035   gcry_mpi_t sig_value = NULL;
2036   unsigned char *sig_blob = NULL;
2037   size_t sig_blob_n = 0;
2038   char *identifier = NULL;
2039   const char *identifier_raw;
2040   size_t identifier_n;
2041   ssh_key_type_spec_t spec;
2042   int ret;
2043   unsigned int i;
2044   const char *elems;
2045   size_t elems_n;
2046   gcry_mpi_t *mpis = NULL;
2047
2048   *sig = NULL;
2049   *sig_n = 0;
2050
2051   ctrl->use_auth_call = 1;
2052   err = agent_pksign_do (ctrl, NULL,
2053                          _("Please enter the passphrase "
2054                            "for the ssh key%0A  %c"), &signature_sexp,
2055                          CACHE_MODE_SSH, ttl_from_sshcontrol);
2056   ctrl->use_auth_call = 0;
2057   if (err)
2058     goto out;
2059
2060   valuelist = gcry_sexp_nth (signature_sexp, 1);
2061   if (! valuelist)
2062     {
2063       err = gpg_error (GPG_ERR_INV_SEXP);
2064       goto out;
2065     }
2066
2067   stream = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
2068   if (! stream)
2069     {
2070       err = gpg_error_from_syserror ();
2071       goto out;
2072     }
2073
2074   identifier_raw = gcry_sexp_nth_data (valuelist, 0, &identifier_n);
2075   if (! identifier_raw)
2076     {
2077       err = gpg_error (GPG_ERR_INV_SEXP);
2078       goto out;
2079     }
2080
2081   identifier = make_cstring (identifier_raw, identifier_n);
2082   if (! identifier)
2083     {
2084       err = gpg_error_from_syserror ();
2085       goto out;
2086     }
2087
2088   err = ssh_key_type_lookup (NULL, identifier, &spec);
2089   if (err)
2090     goto out;
2091
2092   err = stream_write_cstring (stream, spec.ssh_identifier);
2093   if (err)
2094     goto out;
2095
2096   elems = spec.elems_signature;
2097   elems_n = strlen (elems);
2098
2099   mpis = xtrycalloc (elems_n + 1, sizeof *mpis);
2100   if (!mpis)
2101     {
2102       err = gpg_error_from_syserror ();
2103       goto out;
2104     }
2105
2106   for (i = 0; i < elems_n; i++)
2107     {
2108       sublist = gcry_sexp_find_token (valuelist, spec.elems_signature + i, 1);
2109       if (! sublist)
2110         {
2111           err = gpg_error (GPG_ERR_INV_SEXP);
2112           break;
2113         }
2114
2115       sig_value = gcry_sexp_nth_mpi (sublist, 1, GCRYMPI_FMT_USG);
2116       if (! sig_value)
2117         {
2118           err = gpg_error (GPG_ERR_INTERNAL); /* FIXME?  */
2119           break;
2120         }
2121       gcry_sexp_release (sublist);
2122       sublist = NULL;
2123
2124       mpis[i] = sig_value;
2125     }
2126   if (err)
2127     goto out;
2128
2129   err = (*sig_encoder) (stream, mpis);
2130   if (err)
2131     goto out;
2132
2133   sig_blob_n = es_ftell (stream);
2134   if (sig_blob_n == -1)
2135     {
2136       err = gpg_error_from_syserror ();
2137       goto out;
2138     }
2139
2140   sig_blob = xtrymalloc (sig_blob_n);
2141   if (! sig_blob)
2142     {
2143       err = gpg_error_from_syserror ();
2144       goto out;
2145     }
2146
2147   ret = es_fseek (stream, 0, SEEK_SET);
2148   if (ret)
2149     {
2150       err = gpg_error_from_syserror ();
2151       goto out;
2152     }    
2153
2154   err = stream_read_data (stream, sig_blob, sig_blob_n);
2155   if (err)
2156     goto out;
2157   
2158   *sig = sig_blob;
2159   *sig_n = sig_blob_n;
2160   
2161  out:
2162
2163   if (err)
2164     xfree (sig_blob);
2165
2166   if (stream)
2167     es_fclose (stream);
2168   gcry_sexp_release (valuelist);
2169   gcry_sexp_release (signature_sexp);
2170   gcry_sexp_release (sublist);
2171   mpint_list_free (mpis);
2172   xfree (identifier);
2173
2174   return err;
2175 }
2176
2177 /* Handler for the "sign_request" command.  */
2178 static gpg_error_t
2179 ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
2180 {
2181   gcry_sexp_t key;
2182   ssh_key_type_spec_t spec;
2183   unsigned char hash[MAX_DIGEST_LEN];
2184   unsigned int hash_n;
2185   unsigned char key_grip[20];
2186   unsigned char *key_blob;
2187   u32 key_blob_size;
2188   unsigned char *data;
2189   unsigned char *sig;
2190   size_t sig_n;
2191   u32 data_size;
2192   u32 flags;
2193   gpg_error_t err;
2194   gpg_error_t ret_err;
2195
2196   key_blob = NULL;
2197   data = NULL;
2198   sig = NULL;
2199   key = NULL;
2200
2201   /* Receive key.  */
2202   
2203   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2204   if (err)
2205     goto out;
2206
2207   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, &spec);
2208   if (err)
2209     goto out;
2210
2211   /* Receive data to sign.  */
2212   err = stream_read_string (request, 0, &data, &data_size);
2213   if (err)
2214     goto out;
2215
2216   /* FIXME?  */
2217   err = stream_read_uint32 (request, &flags);
2218   if (err)
2219     goto out;
2220
2221   /* Hash data.  */
2222   hash_n = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
2223   if (! hash_n)
2224     {
2225       err = gpg_error (GPG_ERR_INTERNAL);
2226       goto out;
2227     }
2228   err = data_hash (data, data_size, GCRY_MD_SHA1, hash);
2229   if (err)
2230     goto out;
2231
2232   /* Calculate key grip.  */
2233   err = ssh_key_grip (key, key_grip);
2234   if (err)
2235     goto out;
2236
2237   /* Sign data.  */
2238
2239   ctrl->digest.algo = GCRY_MD_SHA1;
2240   memcpy (ctrl->digest.value, hash, hash_n);
2241   ctrl->digest.valuelen = hash_n;
2242   ctrl->digest.raw_value = ! (spec.flags & SPEC_FLAG_USE_PKCS1V2);
2243   ctrl->have_keygrip = 1;
2244   memcpy (ctrl->keygrip, key_grip, 20);
2245
2246   err = data_sign (ctrl, spec.signature_encoder, &sig, &sig_n);
2247   
2248  out:
2249
2250   /* Done.  */
2251
2252   if (! err)
2253     {
2254       ret_err = stream_write_byte (response, SSH_RESPONSE_SIGN_RESPONSE);
2255       if (ret_err)
2256         goto leave;
2257       ret_err = stream_write_string (response, sig, sig_n);
2258       if (ret_err)
2259         goto leave;
2260     }
2261   else
2262     {
2263       ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2264       if (ret_err)
2265         goto leave;
2266     }
2267   
2268  leave:
2269
2270   gcry_sexp_release (key);
2271   xfree (key_blob);
2272   xfree (data);
2273   xfree (sig);
2274
2275   return ret_err;
2276 }
2277
2278 /* This function extracts the comment contained in the key
2279    S-Expression KEY and stores a copy in COMMENT.  Returns usual error
2280    code.  */
2281 static gpg_error_t
2282 ssh_key_extract_comment (gcry_sexp_t key, char **comment)
2283 {
2284   gcry_sexp_t comment_list;
2285   char *comment_new;
2286   const char *data;
2287   size_t data_n;
2288   gpg_error_t err;
2289
2290   comment_list = gcry_sexp_find_token (key, "comment", 0);
2291   if (! comment_list)
2292     {
2293       err = gpg_error (GPG_ERR_INV_SEXP);
2294       goto out;
2295     }
2296   
2297   data = gcry_sexp_nth_data (comment_list, 1, &data_n);
2298   if (! data)
2299     {
2300       err = gpg_error (GPG_ERR_INV_SEXP);
2301       goto out;
2302     }
2303
2304   comment_new = make_cstring (data, data_n);
2305   if (! comment_new)
2306     {
2307       err = gpg_error_from_syserror ();
2308       goto out;
2309     }
2310
2311   *comment = comment_new;
2312   err = 0;
2313
2314  out:
2315
2316   gcry_sexp_release (comment_list);
2317
2318   return err;
2319 }
2320
2321 /* This function converts the key contained in the S-Expression KEY
2322    into a buffer, which is protected by the passphrase PASSPHRASE.
2323    Returns usual error code.  */
2324 static gpg_error_t
2325 ssh_key_to_protected_buffer (gcry_sexp_t key, const char *passphrase,
2326                              unsigned char **buffer, size_t *buffer_n)
2327 {
2328   unsigned char *buffer_new;
2329   unsigned int buffer_new_n;
2330   gpg_error_t err;
2331
2332   err = 0;
2333   buffer_new_n = gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, NULL, 0);
2334   buffer_new = xtrymalloc_secure (buffer_new_n);
2335   if (! buffer_new)
2336     {
2337       err = gpg_error_from_syserror ();
2338       goto out;
2339     }
2340   
2341   gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, buffer_new, buffer_new_n);
2342   /* FIXME: guarantee?  */
2343
2344   err = agent_protect (buffer_new, passphrase, buffer, buffer_n);
2345
2346  out:
2347
2348   xfree (buffer_new);
2349
2350   return err;
2351 }
2352
2353
2354
2355 /* Callback function to compare the first entered PIN with the one
2356    currently being entered. */
2357 static int
2358 reenter_compare_cb (struct pin_entry_info_s *pi)
2359 {
2360   const char *pin1 = pi->check_cb_arg;
2361
2362   if (!strcmp (pin1, pi->pin))
2363     return 0; /* okay */
2364   return -1;
2365 }
2366
2367 /* Store the ssh KEY into our local key storage and protect it after
2368    asking for a passphrase.  Cache that passphrase.  TTL is the
2369    maximum caching time for that key.  If the key already exists in
2370    our key storage, don't do anything.  When entering a new key also
2371    add an entry to the sshcontrol file.  */
2372 static gpg_error_t
2373 ssh_identity_register (ctrl_t ctrl, gcry_sexp_t key, int ttl)
2374 {
2375   gpg_error_t err;
2376   unsigned char key_grip_raw[20];
2377   char key_grip[41];
2378   unsigned char *buffer = NULL;
2379   size_t buffer_n;
2380   char *description = NULL;
2381   const char *description2 = _("Please re-enter this passphrase");
2382   char *comment = NULL;
2383   const char *initial_errtext = NULL;
2384   unsigned int i;
2385   struct pin_entry_info_s *pi = NULL, *pi2;
2386
2387   err = ssh_key_grip (key, key_grip_raw);
2388   if (err)
2389     goto out;
2390
2391   /* Check whether the key is already in our key storage.  Don't do
2392      anything then.  */
2393   if ( !agent_key_available (key_grip_raw) )
2394     goto out; /* Yes, key is available.  */
2395
2396   
2397   err = ssh_key_extract_comment (key, &comment);
2398   if (err)
2399     goto out;
2400
2401   if ( asprintf (&description,
2402                  _("Please enter a passphrase to protect"
2403                    " the received secret key%%0A"
2404                    "   %s%%0A"
2405                    "within gpg-agent's key storage"),
2406                  comment ? comment : "?") < 0)
2407     {
2408       err = gpg_error_from_syserror ();
2409       goto out;
2410     }
2411
2412
2413   pi = gcry_calloc_secure (2, sizeof (*pi) + 100 + 1);
2414   if (!pi)
2415     {
2416       err = gpg_error_from_syserror ();
2417       goto out;
2418     }
2419   pi2 = pi + (sizeof *pi + 100 + 1);
2420   pi->max_length = 100;
2421   pi->max_tries = 1;
2422   pi2->max_length = 100;
2423   pi2->max_tries = 1;
2424   pi2->check_cb = reenter_compare_cb;
2425   pi2->check_cb_arg = pi->pin;
2426
2427  next_try:
2428   err = agent_askpin (ctrl, description, NULL, initial_errtext, pi);
2429   initial_errtext = NULL;
2430   if (err)
2431     goto out;
2432
2433   /* Unless the passphrase is empty, ask to confirm it.  */
2434   if (pi->pin && *pi->pin)
2435     {
2436       err = agent_askpin (ctrl, description2, NULL, NULL, pi2);
2437       if (err == -1)
2438         { /* The re-entered one did not match and the user did not
2439              hit cancel. */
2440           initial_errtext = _("does not match - try again");
2441           goto next_try;
2442         }
2443     }
2444
2445   err = ssh_key_to_protected_buffer (key, pi->pin, &buffer, &buffer_n);
2446   if (err)
2447     goto out;
2448
2449   /* Store this key to our key storage.  */
2450   err = agent_write_private_key (key_grip_raw, buffer, buffer_n, 0);
2451   if (err)
2452     goto out;
2453
2454   /* Cache this passphrase. */
2455   for (i = 0; i < 20; i++)
2456     sprintf (key_grip + 2 * i, "%02X", key_grip_raw[i]);
2457
2458   err = agent_put_cache (key_grip, CACHE_MODE_SSH, pi->pin, ttl);
2459   if (err)
2460     goto out;
2461
2462   /* And add an entry to the sshcontrol file.  */
2463   err = add_control_entry (ctrl, key_grip, ttl);
2464
2465
2466  out:
2467   if (pi && pi->max_length)
2468     wipememory (pi->pin, pi->max_length);
2469   xfree (pi);
2470   xfree (buffer);
2471   xfree (comment);
2472   xfree (description); 
2473
2474   return err;
2475 }
2476
2477
2478 /* This function removes the key contained in the S-Expression KEY
2479    from the local key storage, in case it exists there.  Returns usual
2480    error code.  FIXME: this function is a stub.  */
2481 static gpg_error_t
2482 ssh_identity_drop (gcry_sexp_t key)
2483 {
2484   unsigned char key_grip[21] = { 0 };
2485   gpg_error_t err;
2486
2487   err = ssh_key_grip (key, key_grip);
2488   if (err)
2489     goto out;
2490
2491   key_grip[sizeof (key_grip) - 1] = 0;
2492
2493   /* FIXME: What to do here - forgetting the passphrase or deleting
2494      the key from key cache?  */
2495
2496  out:
2497
2498   return err;
2499 }
2500
2501 /* Handler for the "add_identity" command.  */
2502 static gpg_error_t
2503 ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
2504 {
2505   gpg_error_t ret_err;
2506   gpg_error_t err;
2507   gcry_sexp_t key;
2508   unsigned char b;
2509   int confirm;
2510   int ttl;
2511   
2512   confirm = 0;
2513   key = NULL;
2514   ttl = 0;
2515
2516   /* FIXME?  */
2517   err = ssh_receive_key (request, &key, 1, 1, NULL);
2518   if (err)
2519     goto out;
2520
2521   while (1)
2522     {
2523       err = stream_read_byte (request, &b);
2524       if (gpg_err_code (err) == GPG_ERR_EOF)
2525         {
2526           err = 0;
2527           break;
2528         }
2529
2530       switch (b)
2531         {
2532         case SSH_OPT_CONSTRAIN_LIFETIME:
2533           {
2534             u32 n = 0;
2535
2536             err = stream_read_uint32 (request, &n);
2537             if (! err)
2538               ttl = n;
2539             break;
2540           }
2541
2542         case SSH_OPT_CONSTRAIN_CONFIRM:
2543           {
2544             confirm = 1;
2545             break;
2546           }
2547
2548         default:
2549           /* FIXME: log/bad?  */
2550           break;
2551         }
2552     }
2553   if (err)
2554     goto out;
2555
2556   /* FIXME: are constraints used correctly?  */
2557
2558   err = ssh_identity_register (ctrl, key, ttl);
2559
2560  out:
2561
2562   gcry_sexp_release (key);
2563
2564   if (! err)
2565     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2566   else
2567     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2568
2569   return ret_err;
2570 }
2571
2572 /* Handler for the "remove_identity" command.  */
2573 static gpg_error_t
2574 ssh_handler_remove_identity (ctrl_t ctrl,
2575                              estream_t request, estream_t response)
2576 {
2577   unsigned char *key_blob;
2578   u32 key_blob_size;
2579   gcry_sexp_t key;
2580   gpg_error_t ret_err;
2581   gpg_error_t err;
2582
2583   (void)ctrl;
2584
2585   /* Receive key.  */
2586
2587   key_blob = NULL;
2588   key = NULL;
2589   
2590   err = stream_read_string (request, 0, &key_blob, &key_blob_size);
2591   if (err)
2592     goto out;
2593
2594   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, NULL);
2595   if (err)
2596     goto out;
2597   
2598   err = ssh_identity_drop (key);
2599
2600  out:
2601
2602   xfree (key_blob);
2603   gcry_sexp_release (key);
2604
2605   if (! err)
2606     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2607   else
2608     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2609
2610   return ret_err;
2611 }
2612
2613 /* FIXME: stub function.  Actually useful?  */
2614 static gpg_error_t
2615 ssh_identities_remove_all (void)
2616 {
2617   gpg_error_t err;
2618
2619   err = 0;
2620
2621   /* FIXME: shall we remove _all_ cache entries or only those
2622      registered through the ssh emulation?  */
2623   
2624   return err;
2625 }
2626
2627 /* Handler for the "remove_all_identities" command.  */
2628 static gpg_error_t
2629 ssh_handler_remove_all_identities (ctrl_t ctrl,
2630                                    estream_t request, estream_t response)
2631 {
2632   gpg_error_t ret_err;
2633   gpg_error_t err;
2634
2635   (void)ctrl;
2636   (void)request;
2637   
2638   err = ssh_identities_remove_all ();
2639
2640   if (! err)
2641     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2642   else
2643     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2644
2645   return ret_err;
2646 }
2647
2648 /* Lock agent?  FIXME: stub function.  */
2649 static gpg_error_t
2650 ssh_lock (void)
2651 {
2652   gpg_error_t err;
2653
2654   /* FIXME */
2655   log_error ("ssh-agent's lock command is not implemented\n");
2656   err = 0;
2657
2658   return err;
2659 }
2660
2661 /* Unock agent?  FIXME: stub function.  */
2662 static gpg_error_t
2663 ssh_unlock (void)
2664 {
2665   gpg_error_t err;
2666
2667   log_error ("ssh-agent's unlock command is not implemented\n");
2668   err = 0;
2669
2670   return err;
2671 }
2672
2673 /* Handler for the "lock" command.  */
2674 static gpg_error_t
2675 ssh_handler_lock (ctrl_t ctrl, estream_t request, estream_t response)
2676 {
2677   gpg_error_t ret_err;
2678   gpg_error_t err;
2679
2680   (void)ctrl;
2681   (void)request;
2682   
2683   err = ssh_lock ();
2684
2685   if (! err)
2686     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2687   else
2688     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2689
2690   return ret_err;
2691 }
2692
2693 /* Handler for the "unlock" command.  */
2694 static gpg_error_t
2695 ssh_handler_unlock (ctrl_t ctrl, estream_t request, estream_t response)
2696 {
2697   gpg_error_t ret_err;
2698   gpg_error_t err;
2699   
2700   (void)ctrl;
2701   (void)request;
2702
2703   err = ssh_unlock ();
2704
2705   if (! err)
2706     ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
2707   else
2708     ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
2709
2710   return ret_err;
2711 }
2712
2713 \f
2714
2715 /* Return the request specification for the request identified by TYPE
2716    or NULL in case the requested request specification could not be
2717    found.  */
2718 static ssh_request_spec_t *
2719 request_spec_lookup (int type)
2720 {
2721   ssh_request_spec_t *spec;
2722   unsigned int i;
2723
2724   for (i = 0; i < DIM (request_specs); i++)
2725     if (request_specs[i].type == type)
2726       break;
2727   if (i == DIM (request_specs))
2728     {
2729       if (opt.verbose)
2730         log_info ("ssh request %u is not supported\n", type);
2731       spec = NULL;
2732     }
2733   else
2734     spec = request_specs + i;
2735
2736   return spec;
2737 }
2738
2739 /* Process a single request.  The request is read from and the
2740    response is written to STREAM_SOCK.  Uses CTRL as context.  Returns
2741    zero in case of success, non zero in case of failure.  */
2742 static int
2743 ssh_request_process (ctrl_t ctrl, estream_t stream_sock)
2744 {
2745   ssh_request_spec_t *spec;
2746   estream_t response;
2747   estream_t request;
2748   unsigned char request_type;
2749   gpg_error_t err;
2750   int send_err;
2751   int ret;
2752   unsigned char *request_data;
2753   u32 request_data_size;
2754   u32 response_size;
2755
2756   request_data = NULL;
2757   response = NULL;
2758   request = NULL;
2759   send_err = 0;
2760
2761   /* Create memory streams for request/response data.  The entire
2762      request will be stored in secure memory, since it might contain
2763      secret key material.  The response does not have to be stored in
2764      secure memory, since we never give out secret keys. 
2765
2766      Note: we only have little secure memory, but there is NO
2767      possibility of DoS here; only trusted clients are allowed to
2768      connect to the agent.  What could happen is that the agent
2769      returns out-of-secure-memory errors on requests in case the
2770      agent's owner floods his own agent with many large messages.
2771      -moritz */
2772
2773   /* Retrieve request.  */
2774   err = stream_read_string (stream_sock, 1, &request_data, &request_data_size);
2775   if (err)
2776     goto out;
2777
2778   if (opt.verbose > 1)
2779     log_info ("received ssh request of length %u\n",
2780               (unsigned int)request_data_size);
2781
2782   if (! request_data_size)
2783     {
2784       send_err = 1;
2785       goto out;
2786       /* Broken request; FIXME.  */
2787     }
2788
2789   request_type = request_data[0];
2790   spec = request_spec_lookup (request_type);
2791   if (! spec)
2792     {
2793       send_err = 1;
2794       goto out;
2795       /* Unknown request; FIXME.  */
2796     }
2797
2798   if (spec->secret_input)
2799     request = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+");
2800   else
2801     request = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+");
2802   if (! request)
2803     {
2804       err = gpg_error_from_syserror ();
2805       goto out;
2806     }
2807   ret = es_setvbuf (request, NULL, _IONBF, 0);
2808   if (ret)
2809     {
2810       err = gpg_error_from_syserror ();
2811       goto out;
2812     }
2813   err = stream_write_data (request, request_data + 1, request_data_size - 1);
2814   if (err)
2815     goto out;
2816   es_rewind (request);
2817
2818   response = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
2819   if (! response)
2820     {
2821       err = gpg_error_from_syserror ();
2822       goto out;
2823     }
2824
2825   if (opt.verbose)
2826     log_info ("ssh request handler for %s (%u) started\n",
2827                spec->identifier, spec->type);
2828
2829   err = (*spec->handler) (ctrl, request, response);
2830
2831   if (opt.verbose)
2832     {
2833       if (err)
2834         log_info ("ssh request handler for %s (%u) failed: %s\n",
2835                   spec->identifier, spec->type, gpg_strerror (err));
2836       else
2837         log_info ("ssh request handler for %s (%u) ready\n",
2838                   spec->identifier, spec->type);
2839     }
2840
2841   if (err)
2842     {
2843       send_err = 1;
2844       goto out;
2845     }
2846
2847   response_size = es_ftell (response);
2848   if (opt.verbose > 1)
2849     log_info ("sending ssh response of length %u\n",
2850               (unsigned int)response_size);
2851
2852   err = es_fseek (response, 0, SEEK_SET);
2853   if (err)
2854     {
2855       send_err = 1;
2856       goto out;
2857     }
2858
2859   err = stream_write_uint32 (stream_sock, response_size);
2860   if (err)
2861     {
2862       send_err = 1;
2863       goto out;
2864     }
2865
2866   err = stream_copy (stream_sock, response);
2867   if (err)
2868     goto out;
2869
2870   err = es_fflush (stream_sock);
2871   if (err)
2872     goto out;
2873
2874  out:
2875
2876   if (err && es_feof (stream_sock))
2877     log_error ("error occured while processing request: %s\n",
2878                gpg_strerror (err));
2879
2880   if (send_err)
2881     {
2882       if (opt.verbose > 1)
2883         log_info ("sending ssh error response\n");
2884       err = stream_write_uint32 (stream_sock, 1);
2885       if (err)
2886         goto leave;
2887       err = stream_write_byte (stream_sock, SSH_RESPONSE_FAILURE);
2888       if (err)
2889         goto leave;
2890     }
2891
2892  leave:
2893
2894   if (request)
2895     es_fclose (request);
2896   if (response)
2897     es_fclose (response);
2898   xfree (request_data);         /* FIXME?  */
2899
2900   return !!err;
2901 }
2902
2903 /* Start serving client on SOCK_CLIENT.  */
2904 void
2905 start_command_handler_ssh (ctrl_t ctrl, gnupg_fd_t sock_client)
2906 {
2907   estream_t stream_sock = NULL;
2908   gpg_error_t err = 0;
2909   int ret;
2910
2911   /* Because the ssh protocol does not send us information about the
2912      the current TTY setting, we resort here to use those from startup
2913      or those explictly set.  */
2914   {
2915     static const char *names[] = 
2916       {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
2917     int idx;
2918     const char *value;
2919
2920     for (idx=0; !err && names[idx]; idx++)
2921       if (!session_env_getenv (ctrl->session_env, names[idx])
2922           && (value = session_env_getenv (opt.startup_env, names[idx])))
2923         err = session_env_setenv (ctrl->session_env, names[idx], value);
2924     
2925     if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
2926       if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
2927         err = gpg_error_from_syserror ();
2928
2929     if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
2930       if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
2931         err = gpg_error_from_syserror ();
2932
2933     if (err)
2934       {
2935         log_error ("error setting default session environment: %s\n", 
2936                    gpg_strerror (err));
2937         goto out;
2938       }
2939   }
2940
2941
2942   /* Create stream from socket.  */
2943   stream_sock = es_fdopen (FD2INT(sock_client), "r+");
2944   if (!stream_sock)
2945     {
2946       err = gpg_error_from_syserror ();
2947       log_error (_("failed to create stream from socket: %s\n"),
2948                  gpg_strerror (err));
2949       goto out;
2950     }
2951   /* We have to disable the estream buffering, because the estream
2952      core doesn't know about secure memory.  */
2953   ret = es_setvbuf (stream_sock, NULL, _IONBF, 0);
2954   if (ret)
2955     {
2956       err = gpg_error_from_syserror ();
2957       log_error ("failed to disable buffering "
2958                  "on socket stream: %s\n", gpg_strerror (err));
2959       goto out;
2960     }
2961
2962   /* Main processing loop. */
2963   while ( !ssh_request_process (ctrl, stream_sock) )
2964     {
2965       /* Check wether we have reached EOF before trying to read
2966          another request.  */
2967       int c;
2968
2969       c = es_fgetc (stream_sock);
2970       if (c == EOF)
2971         break;
2972       es_ungetc (c, stream_sock);
2973     }
2974
2975   /* Reset the SCD in case it has been used. */
2976   agent_reset_scd (ctrl);
2977
2978
2979  out:
2980   if (stream_sock)
2981     es_fclose (stream_sock);
2982 }