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