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