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