]> asedeno.scripts.mit.edu Git - PuTTY.git/blob - ssh.c
Log identifying information for the other end of connections.
[PuTTY.git] / ssh.c
1 /*
2  * SSH backend.
3  */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <stdarg.h>
8 #include <assert.h>
9 #include <limits.h>
10 #include <signal.h>
11
12 #include "putty.h"
13 #include "tree234.h"
14 #include "ssh.h"
15 #ifndef NO_GSSAPI
16 #include "sshgssc.h"
17 #include "sshgss.h"
18 #endif
19
20 #ifndef FALSE
21 #define FALSE 0
22 #endif
23 #ifndef TRUE
24 #define TRUE 1
25 #endif
26
27 /*
28  * Packet type contexts, so that ssh2_pkt_type can correctly decode
29  * the ambiguous type numbers back into the correct type strings.
30  */
31 typedef enum {
32     SSH2_PKTCTX_NOKEX,
33     SSH2_PKTCTX_DHGROUP,
34     SSH2_PKTCTX_DHGEX,
35     SSH2_PKTCTX_ECDHKEX,
36     SSH2_PKTCTX_RSAKEX
37 } Pkt_KCtx;
38 typedef enum {
39     SSH2_PKTCTX_NOAUTH,
40     SSH2_PKTCTX_PUBLICKEY,
41     SSH2_PKTCTX_PASSWORD,
42     SSH2_PKTCTX_GSSAPI,
43     SSH2_PKTCTX_KBDINTER
44 } Pkt_ACtx;
45
46 static const char *const ssh2_disconnect_reasons[] = {
47     NULL,
48     "host not allowed to connect",
49     "protocol error",
50     "key exchange failed",
51     "host authentication failed",
52     "MAC error",
53     "compression error",
54     "service not available",
55     "protocol version not supported",
56     "host key not verifiable",
57     "connection lost",
58     "by application",
59     "too many connections",
60     "auth cancelled by user",
61     "no more auth methods available",
62     "illegal user name",
63 };
64
65 /*
66  * Various remote-bug flags.
67  */
68 #define BUG_CHOKES_ON_SSH1_IGNORE                 1
69 #define BUG_SSH2_HMAC                             2
70 #define BUG_NEEDS_SSH1_PLAIN_PASSWORD             4
71 #define BUG_CHOKES_ON_RSA                         8
72 #define BUG_SSH2_RSA_PADDING                     16
73 #define BUG_SSH2_DERIVEKEY                       32
74 #define BUG_SSH2_REKEY                           64
75 #define BUG_SSH2_PK_SESSIONID                   128
76 #define BUG_SSH2_MAXPKT                         256
77 #define BUG_CHOKES_ON_SSH2_IGNORE               512
78 #define BUG_CHOKES_ON_WINADJ                   1024
79 #define BUG_SENDS_LATE_REQUEST_REPLY           2048
80 #define BUG_SSH2_OLDGEX                        4096
81
82 #define DH_MIN_SIZE 1024
83 #define DH_MAX_SIZE 8192
84
85 /*
86  * Codes for terminal modes.
87  * Most of these are the same in SSH-1 and SSH-2.
88  * This list is derived from RFC 4254 and
89  * SSH-1 RFC-1.2.31.
90  */
91 static const struct {
92     const char* const mode;
93     int opcode;
94     enum { TTY_OP_CHAR, TTY_OP_BOOL } type;
95 } ssh_ttymodes[] = {
96     /* "V" prefix discarded for special characters relative to SSH specs */
97     { "INTR",         1, TTY_OP_CHAR },
98     { "QUIT",         2, TTY_OP_CHAR },
99     { "ERASE",        3, TTY_OP_CHAR },
100     { "KILL",         4, TTY_OP_CHAR },
101     { "EOF",          5, TTY_OP_CHAR },
102     { "EOL",          6, TTY_OP_CHAR },
103     { "EOL2",         7, TTY_OP_CHAR },
104     { "START",        8, TTY_OP_CHAR },
105     { "STOP",         9, TTY_OP_CHAR },
106     { "SUSP",        10, TTY_OP_CHAR },
107     { "DSUSP",       11, TTY_OP_CHAR },
108     { "REPRINT",     12, TTY_OP_CHAR },
109     { "WERASE",      13, TTY_OP_CHAR },
110     { "LNEXT",       14, TTY_OP_CHAR },
111     { "FLUSH",       15, TTY_OP_CHAR },
112     { "SWTCH",       16, TTY_OP_CHAR },
113     { "STATUS",      17, TTY_OP_CHAR },
114     { "DISCARD",     18, TTY_OP_CHAR },
115     { "IGNPAR",      30, TTY_OP_BOOL },
116     { "PARMRK",      31, TTY_OP_BOOL },
117     { "INPCK",       32, TTY_OP_BOOL },
118     { "ISTRIP",      33, TTY_OP_BOOL },
119     { "INLCR",       34, TTY_OP_BOOL },
120     { "IGNCR",       35, TTY_OP_BOOL },
121     { "ICRNL",       36, TTY_OP_BOOL },
122     { "IUCLC",       37, TTY_OP_BOOL },
123     { "IXON",        38, TTY_OP_BOOL },
124     { "IXANY",       39, TTY_OP_BOOL },
125     { "IXOFF",       40, TTY_OP_BOOL },
126     { "IMAXBEL",     41, TTY_OP_BOOL },
127     { "ISIG",        50, TTY_OP_BOOL },
128     { "ICANON",      51, TTY_OP_BOOL },
129     { "XCASE",       52, TTY_OP_BOOL },
130     { "ECHO",        53, TTY_OP_BOOL },
131     { "ECHOE",       54, TTY_OP_BOOL },
132     { "ECHOK",       55, TTY_OP_BOOL },
133     { "ECHONL",      56, TTY_OP_BOOL },
134     { "NOFLSH",      57, TTY_OP_BOOL },
135     { "TOSTOP",      58, TTY_OP_BOOL },
136     { "IEXTEN",      59, TTY_OP_BOOL },
137     { "ECHOCTL",     60, TTY_OP_BOOL },
138     { "ECHOKE",      61, TTY_OP_BOOL },
139     { "PENDIN",      62, TTY_OP_BOOL }, /* XXX is this a real mode? */
140     { "OPOST",       70, TTY_OP_BOOL },
141     { "OLCUC",       71, TTY_OP_BOOL },
142     { "ONLCR",       72, TTY_OP_BOOL },
143     { "OCRNL",       73, TTY_OP_BOOL },
144     { "ONOCR",       74, TTY_OP_BOOL },
145     { "ONLRET",      75, TTY_OP_BOOL },
146     { "CS7",         90, TTY_OP_BOOL },
147     { "CS8",         91, TTY_OP_BOOL },
148     { "PARENB",      92, TTY_OP_BOOL },
149     { "PARODD",      93, TTY_OP_BOOL }
150 };
151
152 /* Miscellaneous other tty-related constants. */
153 #define SSH_TTY_OP_END            0
154 /* The opcodes for ISPEED/OSPEED differ between SSH-1 and SSH-2. */
155 #define SSH1_TTY_OP_ISPEED      192
156 #define SSH1_TTY_OP_OSPEED      193
157 #define SSH2_TTY_OP_ISPEED      128
158 #define SSH2_TTY_OP_OSPEED      129
159
160 /* Helper functions for parsing tty-related config. */
161 static unsigned int ssh_tty_parse_specchar(char *s)
162 {
163     unsigned int ret;
164     if (*s) {
165         char *next = NULL;
166         ret = ctrlparse(s, &next);
167         if (!next) ret = s[0];
168     } else {
169         ret = 255; /* special value meaning "don't set" */
170     }
171     return ret;
172 }
173 static unsigned int ssh_tty_parse_boolean(char *s)
174 {
175     if (stricmp(s, "yes") == 0 ||
176         stricmp(s, "on") == 0 ||
177         stricmp(s, "true") == 0 ||
178         stricmp(s, "+") == 0)
179         return 1; /* true */
180     else if (stricmp(s, "no") == 0 ||
181              stricmp(s, "off") == 0 ||
182              stricmp(s, "false") == 0 ||
183              stricmp(s, "-") == 0)
184         return 0; /* false */
185     else
186         return (atoi(s) != 0);
187 }
188
189 #define translate(x) if (type == x) return #x
190 #define translatek(x,ctx) if (type == x && (pkt_kctx == ctx)) return #x
191 #define translatea(x,ctx) if (type == x && (pkt_actx == ctx)) return #x
192 static const char *ssh1_pkt_type(int type)
193 {
194     translate(SSH1_MSG_DISCONNECT);
195     translate(SSH1_SMSG_PUBLIC_KEY);
196     translate(SSH1_CMSG_SESSION_KEY);
197     translate(SSH1_CMSG_USER);
198     translate(SSH1_CMSG_AUTH_RSA);
199     translate(SSH1_SMSG_AUTH_RSA_CHALLENGE);
200     translate(SSH1_CMSG_AUTH_RSA_RESPONSE);
201     translate(SSH1_CMSG_AUTH_PASSWORD);
202     translate(SSH1_CMSG_REQUEST_PTY);
203     translate(SSH1_CMSG_WINDOW_SIZE);
204     translate(SSH1_CMSG_EXEC_SHELL);
205     translate(SSH1_CMSG_EXEC_CMD);
206     translate(SSH1_SMSG_SUCCESS);
207     translate(SSH1_SMSG_FAILURE);
208     translate(SSH1_CMSG_STDIN_DATA);
209     translate(SSH1_SMSG_STDOUT_DATA);
210     translate(SSH1_SMSG_STDERR_DATA);
211     translate(SSH1_CMSG_EOF);
212     translate(SSH1_SMSG_EXIT_STATUS);
213     translate(SSH1_MSG_CHANNEL_OPEN_CONFIRMATION);
214     translate(SSH1_MSG_CHANNEL_OPEN_FAILURE);
215     translate(SSH1_MSG_CHANNEL_DATA);
216     translate(SSH1_MSG_CHANNEL_CLOSE);
217     translate(SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION);
218     translate(SSH1_SMSG_X11_OPEN);
219     translate(SSH1_CMSG_PORT_FORWARD_REQUEST);
220     translate(SSH1_MSG_PORT_OPEN);
221     translate(SSH1_CMSG_AGENT_REQUEST_FORWARDING);
222     translate(SSH1_SMSG_AGENT_OPEN);
223     translate(SSH1_MSG_IGNORE);
224     translate(SSH1_CMSG_EXIT_CONFIRMATION);
225     translate(SSH1_CMSG_X11_REQUEST_FORWARDING);
226     translate(SSH1_CMSG_AUTH_RHOSTS_RSA);
227     translate(SSH1_MSG_DEBUG);
228     translate(SSH1_CMSG_REQUEST_COMPRESSION);
229     translate(SSH1_CMSG_AUTH_TIS);
230     translate(SSH1_SMSG_AUTH_TIS_CHALLENGE);
231     translate(SSH1_CMSG_AUTH_TIS_RESPONSE);
232     translate(SSH1_CMSG_AUTH_CCARD);
233     translate(SSH1_SMSG_AUTH_CCARD_CHALLENGE);
234     translate(SSH1_CMSG_AUTH_CCARD_RESPONSE);
235     return "unknown";
236 }
237 static const char *ssh2_pkt_type(Pkt_KCtx pkt_kctx, Pkt_ACtx pkt_actx,
238                                  int type)
239 {
240     translatea(SSH2_MSG_USERAUTH_GSSAPI_RESPONSE,SSH2_PKTCTX_GSSAPI);
241     translatea(SSH2_MSG_USERAUTH_GSSAPI_TOKEN,SSH2_PKTCTX_GSSAPI);
242     translatea(SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE,SSH2_PKTCTX_GSSAPI);
243     translatea(SSH2_MSG_USERAUTH_GSSAPI_ERROR,SSH2_PKTCTX_GSSAPI);
244     translatea(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK,SSH2_PKTCTX_GSSAPI);
245     translatea(SSH2_MSG_USERAUTH_GSSAPI_MIC, SSH2_PKTCTX_GSSAPI);
246     translate(SSH2_MSG_DISCONNECT);
247     translate(SSH2_MSG_IGNORE);
248     translate(SSH2_MSG_UNIMPLEMENTED);
249     translate(SSH2_MSG_DEBUG);
250     translate(SSH2_MSG_SERVICE_REQUEST);
251     translate(SSH2_MSG_SERVICE_ACCEPT);
252     translate(SSH2_MSG_KEXINIT);
253     translate(SSH2_MSG_NEWKEYS);
254     translatek(SSH2_MSG_KEXDH_INIT, SSH2_PKTCTX_DHGROUP);
255     translatek(SSH2_MSG_KEXDH_REPLY, SSH2_PKTCTX_DHGROUP);
256     translatek(SSH2_MSG_KEX_DH_GEX_REQUEST_OLD, SSH2_PKTCTX_DHGEX);
257     translatek(SSH2_MSG_KEX_DH_GEX_REQUEST, SSH2_PKTCTX_DHGEX);
258     translatek(SSH2_MSG_KEX_DH_GEX_GROUP, SSH2_PKTCTX_DHGEX);
259     translatek(SSH2_MSG_KEX_DH_GEX_INIT, SSH2_PKTCTX_DHGEX);
260     translatek(SSH2_MSG_KEX_DH_GEX_REPLY, SSH2_PKTCTX_DHGEX);
261     translatek(SSH2_MSG_KEXRSA_PUBKEY, SSH2_PKTCTX_RSAKEX);
262     translatek(SSH2_MSG_KEXRSA_SECRET, SSH2_PKTCTX_RSAKEX);
263     translatek(SSH2_MSG_KEXRSA_DONE, SSH2_PKTCTX_RSAKEX);
264     translatek(SSH2_MSG_KEX_ECDH_INIT, SSH2_PKTCTX_ECDHKEX);
265     translatek(SSH2_MSG_KEX_ECDH_REPLY, SSH2_PKTCTX_ECDHKEX);
266     translate(SSH2_MSG_USERAUTH_REQUEST);
267     translate(SSH2_MSG_USERAUTH_FAILURE);
268     translate(SSH2_MSG_USERAUTH_SUCCESS);
269     translate(SSH2_MSG_USERAUTH_BANNER);
270     translatea(SSH2_MSG_USERAUTH_PK_OK, SSH2_PKTCTX_PUBLICKEY);
271     translatea(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ, SSH2_PKTCTX_PASSWORD);
272     translatea(SSH2_MSG_USERAUTH_INFO_REQUEST, SSH2_PKTCTX_KBDINTER);
273     translatea(SSH2_MSG_USERAUTH_INFO_RESPONSE, SSH2_PKTCTX_KBDINTER);
274     translate(SSH2_MSG_GLOBAL_REQUEST);
275     translate(SSH2_MSG_REQUEST_SUCCESS);
276     translate(SSH2_MSG_REQUEST_FAILURE);
277     translate(SSH2_MSG_CHANNEL_OPEN);
278     translate(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
279     translate(SSH2_MSG_CHANNEL_OPEN_FAILURE);
280     translate(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
281     translate(SSH2_MSG_CHANNEL_DATA);
282     translate(SSH2_MSG_CHANNEL_EXTENDED_DATA);
283     translate(SSH2_MSG_CHANNEL_EOF);
284     translate(SSH2_MSG_CHANNEL_CLOSE);
285     translate(SSH2_MSG_CHANNEL_REQUEST);
286     translate(SSH2_MSG_CHANNEL_SUCCESS);
287     translate(SSH2_MSG_CHANNEL_FAILURE);
288     return "unknown";
289 }
290 #undef translate
291 #undef translatec
292
293 /* Enumeration values for fields in SSH-1 packets */
294 enum {
295     PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM,
296 };
297
298 /*
299  * Coroutine mechanics for the sillier bits of the code. If these
300  * macros look impenetrable to you, you might find it helpful to
301  * read
302  * 
303  *   http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
304  * 
305  * which explains the theory behind these macros.
306  * 
307  * In particular, if you are getting `case expression not constant'
308  * errors when building with MS Visual Studio, this is because MS's
309  * Edit and Continue debugging feature causes their compiler to
310  * violate ANSI C. To disable Edit and Continue debugging:
311  * 
312  *  - right-click ssh.c in the FileView
313  *  - click Settings
314  *  - select the C/C++ tab and the General category
315  *  - under `Debug info:', select anything _other_ than `Program
316  *    Database for Edit and Continue'.
317  */
318 #define crBegin(v)      { int *crLine = &v; switch(v) { case 0:;
319 #define crBeginState    crBegin(s->crLine)
320 #define crStateP(t, v)                          \
321     struct t *s;                                \
322     if (!(v)) { s = (v) = snew(struct t); s->crLine = 0; }      \
323     s = (v);
324 #define crState(t)      crStateP(t, ssh->t)
325 #define crFinish(z)     } *crLine = 0; return (z); }
326 #define crFinishV       } *crLine = 0; return; }
327 #define crFinishFree(z) } sfree(s); return (z); }
328 #define crFinishFreeV   } sfree(s); return; }
329 #define crReturn(z)     \
330         do {\
331             *crLine =__LINE__; return (z); case __LINE__:;\
332         } while (0)
333 #define crReturnV       \
334         do {\
335             *crLine=__LINE__; return; case __LINE__:;\
336         } while (0)
337 #define crStop(z)       do{ *crLine = 0; return (z); }while(0)
338 #define crStopV         do{ *crLine = 0; return; }while(0)
339 #define crWaitUntil(c)  do { crReturn(0); } while (!(c))
340 #define crWaitUntilV(c) do { crReturnV; } while (!(c))
341
342 struct Packet;
343
344 static struct Packet *ssh1_pkt_init(int pkt_type);
345 static struct Packet *ssh2_pkt_init(int pkt_type);
346 static void ssh_pkt_ensure(struct Packet *, int length);
347 static void ssh_pkt_adddata(struct Packet *, const void *data, int len);
348 static void ssh_pkt_addbyte(struct Packet *, unsigned char value);
349 static void ssh2_pkt_addbool(struct Packet *, unsigned char value);
350 static void ssh_pkt_adduint32(struct Packet *, unsigned long value);
351 static void ssh_pkt_addstring_start(struct Packet *);
352 static void ssh_pkt_addstring_str(struct Packet *, const char *data);
353 static void ssh_pkt_addstring_data(struct Packet *, const char *data, int len);
354 static void ssh_pkt_addstring(struct Packet *, const char *data);
355 static unsigned char *ssh2_mpint_fmt(Bignum b, int *len);
356 static void ssh1_pkt_addmp(struct Packet *, Bignum b);
357 static void ssh2_pkt_addmp(struct Packet *, Bignum b);
358 static int ssh2_pkt_construct(Ssh, struct Packet *);
359 static void ssh2_pkt_send(Ssh, struct Packet *);
360 static void ssh2_pkt_send_noqueue(Ssh, struct Packet *);
361 static int do_ssh1_login(Ssh ssh, const unsigned char *in, int inlen,
362                          struct Packet *pktin);
363 static void do_ssh2_authconn(Ssh ssh, const unsigned char *in, int inlen,
364                              struct Packet *pktin);
365 static void ssh2_channel_check_close(struct ssh_channel *c);
366 static void ssh_channel_destroy(struct ssh_channel *c);
367
368 /*
369  * Buffer management constants. There are several of these for
370  * various different purposes:
371  * 
372  *  - SSH1_BUFFER_LIMIT is the amount of backlog that must build up
373  *    on a local data stream before we throttle the whole SSH
374  *    connection (in SSH-1 only). Throttling the whole connection is
375  *    pretty drastic so we set this high in the hope it won't
376  *    happen very often.
377  * 
378  *  - SSH_MAX_BACKLOG is the amount of backlog that must build up
379  *    on the SSH connection itself before we defensively throttle
380  *    _all_ local data streams. This is pretty drastic too (though
381  *    thankfully unlikely in SSH-2 since the window mechanism should
382  *    ensure that the server never has any need to throttle its end
383  *    of the connection), so we set this high as well.
384  * 
385  *  - OUR_V2_WINSIZE is the maximum window size we present on SSH-2
386  *    channels.
387  *
388  *  - OUR_V2_BIGWIN is the window size we advertise for the only
389  *    channel in a simple connection.  It must be <= INT_MAX.
390  *
391  *  - OUR_V2_MAXPKT is the official "maximum packet size" we send
392  *    to the remote side. This actually has nothing to do with the
393  *    size of the _packet_, but is instead a limit on the amount
394  *    of data we're willing to receive in a single SSH2 channel
395  *    data message.
396  *
397  *  - OUR_V2_PACKETLIMIT is actually the maximum size of SSH
398  *    _packet_ we're prepared to cope with.  It must be a multiple
399  *    of the cipher block size, and must be at least 35000.
400  */
401
402 #define SSH1_BUFFER_LIMIT 32768
403 #define SSH_MAX_BACKLOG 32768
404 #define OUR_V2_WINSIZE 16384
405 #define OUR_V2_BIGWIN 0x7fffffff
406 #define OUR_V2_MAXPKT 0x4000UL
407 #define OUR_V2_PACKETLIMIT 0x9000UL
408
409 const static struct ssh_signkey *hostkey_algs[] = {
410     &ssh_ecdsa_ed25519,
411     &ssh_ecdsa_nistp256, &ssh_ecdsa_nistp384, &ssh_ecdsa_nistp521,
412     &ssh_rsa, &ssh_dss
413 };
414
415 const static struct ssh_mac *macs[] = {
416     &ssh_hmac_sha256, &ssh_hmac_sha1, &ssh_hmac_sha1_96, &ssh_hmac_md5
417 };
418 const static struct ssh_mac *buggymacs[] = {
419     &ssh_hmac_sha1_buggy, &ssh_hmac_sha1_96_buggy, &ssh_hmac_md5
420 };
421
422 static void *ssh_comp_none_init(void)
423 {
424     return NULL;
425 }
426 static void ssh_comp_none_cleanup(void *handle)
427 {
428 }
429 static int ssh_comp_none_block(void *handle, unsigned char *block, int len,
430                                unsigned char **outblock, int *outlen)
431 {
432     return 0;
433 }
434 static int ssh_comp_none_disable(void *handle)
435 {
436     return 0;
437 }
438 const static struct ssh_compress ssh_comp_none = {
439     "none", NULL,
440     ssh_comp_none_init, ssh_comp_none_cleanup, ssh_comp_none_block,
441     ssh_comp_none_init, ssh_comp_none_cleanup, ssh_comp_none_block,
442     ssh_comp_none_disable, NULL
443 };
444 extern const struct ssh_compress ssh_zlib;
445 const static struct ssh_compress *compressions[] = {
446     &ssh_zlib, &ssh_comp_none
447 };
448
449 enum {                                 /* channel types */
450     CHAN_MAINSESSION,
451     CHAN_X11,
452     CHAN_AGENT,
453     CHAN_SOCKDATA,
454     CHAN_SOCKDATA_DORMANT,             /* one the remote hasn't confirmed */
455     /*
456      * CHAN_SHARING indicates a channel which is tracked here on
457      * behalf of a connection-sharing downstream. We do almost nothing
458      * with these channels ourselves: all messages relating to them
459      * get thrown straight to sshshare.c and passed on almost
460      * unmodified to downstream.
461      */
462     CHAN_SHARING,
463     /*
464      * CHAN_ZOMBIE is used to indicate a channel for which we've
465      * already destroyed the local data source: for instance, if a
466      * forwarded port experiences a socket error on the local side, we
467      * immediately destroy its local socket and turn the SSH channel
468      * into CHAN_ZOMBIE.
469      */
470     CHAN_ZOMBIE
471 };
472
473 typedef void (*handler_fn_t)(Ssh ssh, struct Packet *pktin);
474 typedef void (*chandler_fn_t)(Ssh ssh, struct Packet *pktin, void *ctx);
475 typedef void (*cchandler_fn_t)(struct ssh_channel *, struct Packet *, void *);
476
477 /*
478  * Each channel has a queue of outstanding CHANNEL_REQUESTS and their
479  * handlers.
480  */
481 struct outstanding_channel_request {
482     cchandler_fn_t handler;
483     void *ctx;
484     struct outstanding_channel_request *next;
485 };
486
487 /*
488  * 2-3-4 tree storing channels.
489  */
490 struct ssh_channel {
491     Ssh ssh;                           /* pointer back to main context */
492     unsigned remoteid, localid;
493     int type;
494     /* True if we opened this channel but server hasn't confirmed. */
495     int halfopen;
496     /*
497      * In SSH-1, this value contains four bits:
498      * 
499      *   1   We have sent SSH1_MSG_CHANNEL_CLOSE.
500      *   2   We have sent SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
501      *   4   We have received SSH1_MSG_CHANNEL_CLOSE.
502      *   8   We have received SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
503      * 
504      * A channel is completely finished with when all four bits are set.
505      *
506      * In SSH-2, the four bits mean:
507      *
508      *   1   We have sent SSH2_MSG_CHANNEL_EOF.
509      *   2   We have sent SSH2_MSG_CHANNEL_CLOSE.
510      *   4   We have received SSH2_MSG_CHANNEL_EOF.
511      *   8   We have received SSH2_MSG_CHANNEL_CLOSE.
512      *
513      * A channel is completely finished with when we have both sent
514      * and received CLOSE.
515      *
516      * The symbolic constants below use the SSH-2 terminology, which
517      * is a bit confusing in SSH-1, but we have to use _something_.
518      */
519 #define CLOSES_SENT_EOF    1
520 #define CLOSES_SENT_CLOSE  2
521 #define CLOSES_RCVD_EOF    4
522 #define CLOSES_RCVD_CLOSE  8
523     int closes;
524
525     /*
526      * This flag indicates that an EOF is pending on the outgoing side
527      * of the channel: that is, wherever we're getting the data for
528      * this channel has sent us some data followed by EOF. We can't
529      * actually send the EOF until we've finished sending the data, so
530      * we set this flag instead to remind us to do so once our buffer
531      * is clear.
532      */
533     int pending_eof;
534
535     /*
536      * True if this channel is causing the underlying connection to be
537      * throttled.
538      */
539     int throttling_conn;
540     union {
541         struct ssh2_data_channel {
542             bufchain outbuffer;
543             unsigned remwindow, remmaxpkt;
544             /* locwindow is signed so we can cope with excess data. */
545             int locwindow, locmaxwin;
546             /*
547              * remlocwin is the amount of local window that we think
548              * the remote end had available to it after it sent the
549              * last data packet or window adjust ack.
550              */
551             int remlocwin;
552             /*
553              * These store the list of channel requests that haven't
554              * been acked.
555              */
556             struct outstanding_channel_request *chanreq_head, *chanreq_tail;
557             enum { THROTTLED, UNTHROTTLING, UNTHROTTLED } throttle_state;
558         } v2;
559     } v;
560     union {
561         struct ssh_agent_channel {
562             unsigned char *message;
563             unsigned char msglen[4];
564             unsigned lensofar, totallen;
565             int outstanding_requests;
566         } a;
567         struct ssh_x11_channel {
568             struct X11Connection *xconn;
569             int initial;
570         } x11;
571         struct ssh_pfd_channel {
572             struct PortForwarding *pf;
573         } pfd;
574         struct ssh_sharing_channel {
575             void *ctx;
576         } sharing;
577     } u;
578 };
579
580 /*
581  * 2-3-4 tree storing remote->local port forwardings. SSH-1 and SSH-2
582  * use this structure in different ways, reflecting SSH-2's
583  * altogether saner approach to port forwarding.
584  * 
585  * In SSH-1, you arrange a remote forwarding by sending the server
586  * the remote port number, and the local destination host:port.
587  * When a connection comes in, the server sends you back that
588  * host:port pair, and you connect to it. This is a ready-made
589  * security hole if you're not on the ball: a malicious server
590  * could send you back _any_ host:port pair, so if you trustingly
591  * connect to the address it gives you then you've just opened the
592  * entire inside of your corporate network just by connecting
593  * through it to a dodgy SSH server. Hence, we must store a list of
594  * host:port pairs we _are_ trying to forward to, and reject a
595  * connection request from the server if it's not in the list.
596  * 
597  * In SSH-2, each side of the connection minds its own business and
598  * doesn't send unnecessary information to the other. You arrange a
599  * remote forwarding by sending the server just the remote port
600  * number. When a connection comes in, the server tells you which
601  * of its ports was connected to; and _you_ have to remember what
602  * local host:port pair went with that port number.
603  * 
604  * Hence, in SSH-1 this structure is indexed by destination
605  * host:port pair, whereas in SSH-2 it is indexed by source port.
606  */
607 struct ssh_portfwd; /* forward declaration */
608
609 struct ssh_rportfwd {
610     unsigned sport, dport;
611     char *shost, *dhost;
612     char *sportdesc;
613     void *share_ctx;
614     struct ssh_portfwd *pfrec;
615 };
616
617 static void free_rportfwd(struct ssh_rportfwd *pf)
618 {
619     if (pf) {
620         sfree(pf->sportdesc);
621         sfree(pf->shost);
622         sfree(pf->dhost);
623         sfree(pf);
624     }
625 }
626
627 /*
628  * Separately to the rportfwd tree (which is for looking up port
629  * open requests from the server), a tree of _these_ structures is
630  * used to keep track of all the currently open port forwardings,
631  * so that we can reconfigure in mid-session if the user requests
632  * it.
633  */
634 struct ssh_portfwd {
635     enum { DESTROY, KEEP, CREATE } status;
636     int type;
637     unsigned sport, dport;
638     char *saddr, *daddr;
639     char *sserv, *dserv;
640     struct ssh_rportfwd *remote;
641     int addressfamily;
642     struct PortListener *local;
643 };
644 #define free_portfwd(pf) ( \
645     ((pf) ? (sfree((pf)->saddr), sfree((pf)->daddr), \
646              sfree((pf)->sserv), sfree((pf)->dserv)) : (void)0 ), sfree(pf) )
647
648 struct Packet {
649     long length;            /* length of packet: see below */
650     long forcepad;          /* SSH-2: force padding to at least this length */
651     int type;               /* only used for incoming packets */
652     unsigned long sequence; /* SSH-2 incoming sequence number */
653     unsigned char *data;    /* allocated storage */
654     unsigned char *body;    /* offset of payload within `data' */
655     long savedpos;          /* dual-purpose saved packet position: see below */
656     long maxlen;            /* amount of storage allocated for `data' */
657     long encrypted_len;     /* for SSH-2 total-size counting */
658
659     /*
660      * A note on the 'length' and 'savedpos' fields above.
661      *
662      * Incoming packets are set up so that pkt->length is measured
663      * relative to pkt->body, which itself points to a few bytes after
664      * pkt->data (skipping some uninteresting header fields including
665      * the packet type code). The ssh_pkt_get* functions all expect
666      * this setup, and they also use pkt->savedpos to indicate how far
667      * through the packet being decoded they've got - and that, too,
668      * is an offset from pkt->body rather than pkt->data.
669      *
670      * During construction of an outgoing packet, however, pkt->length
671      * is measured relative to the base pointer pkt->data, and
672      * pkt->body is not really used for anything until the packet is
673      * ready for sending. In this mode, pkt->savedpos is reused as a
674      * temporary variable by the addstring functions, which write out
675      * a string length field and then keep going back and updating it
676      * as more data is appended to the subsequent string data field;
677      * pkt->savedpos stores the offset (again relative to pkt->data)
678      * of the start of the string data field.
679      */
680
681     /* Extra metadata used in SSH packet logging mode, allowing us to
682      * log in the packet header line that the packet came from a
683      * connection-sharing downstream and what if anything unusual was
684      * done to it. The additional_log_text field is expected to be a
685      * static string - it will not be freed. */
686     unsigned downstream_id;
687     const char *additional_log_text;
688 };
689
690 static void ssh1_protocol(Ssh ssh, const void *vin, int inlen,
691                           struct Packet *pktin);
692 static void ssh2_protocol(Ssh ssh, const void *vin, int inlen,
693                           struct Packet *pktin);
694 static void ssh2_bare_connection_protocol(Ssh ssh, const void *vin, int inlen,
695                                           struct Packet *pktin);
696 static void ssh1_protocol_setup(Ssh ssh);
697 static void ssh2_protocol_setup(Ssh ssh);
698 static void ssh2_bare_connection_protocol_setup(Ssh ssh);
699 static void ssh_size(void *handle, int width, int height);
700 static void ssh_special(void *handle, Telnet_Special);
701 static int ssh2_try_send(struct ssh_channel *c);
702 static void ssh2_add_channel_data(struct ssh_channel *c,
703                                   const char *buf, int len);
704 static void ssh_throttle_all(Ssh ssh, int enable, int bufsize);
705 static void ssh2_set_window(struct ssh_channel *c, int newwin);
706 static int ssh_sendbuffer(void *handle);
707 static int ssh_do_close(Ssh ssh, int notify_exit);
708 static unsigned long ssh_pkt_getuint32(struct Packet *pkt);
709 static int ssh2_pkt_getbool(struct Packet *pkt);
710 static void ssh_pkt_getstring(struct Packet *pkt, char **p, int *length);
711 static void ssh2_timer(void *ctx, unsigned long now);
712 static void do_ssh2_transport(Ssh ssh, const void *vin, int inlen,
713                               struct Packet *pktin);
714 static void ssh2_msg_unexpected(Ssh ssh, struct Packet *pktin);
715
716 struct rdpkt1_state_tag {
717     long len, pad, biglen, to_read;
718     unsigned long realcrc, gotcrc;
719     unsigned char *p;
720     int i;
721     int chunk;
722     struct Packet *pktin;
723 };
724
725 struct rdpkt2_state_tag {
726     long len, pad, payload, packetlen, maclen;
727     int i;
728     int cipherblk;
729     unsigned long incoming_sequence;
730     struct Packet *pktin;
731 };
732
733 struct rdpkt2_bare_state_tag {
734     char length[4];
735     long packetlen;
736     int i;
737     unsigned long incoming_sequence;
738     struct Packet *pktin;
739 };
740
741 struct queued_handler;
742 struct queued_handler {
743     int msg1, msg2;
744     chandler_fn_t handler;
745     void *ctx;
746     struct queued_handler *next;
747 };
748
749 struct ssh_tag {
750     const struct plug_function_table *fn;
751     /* the above field _must_ be first in the structure */
752
753     char *v_c, *v_s;
754     void *exhash;
755
756     Socket s;
757
758     void *ldisc;
759     void *logctx;
760
761     unsigned char session_key[32];
762     int v1_compressing;
763     int v1_remote_protoflags;
764     int v1_local_protoflags;
765     int agentfwd_enabled;
766     int X11_fwd_enabled;
767     int remote_bugs;
768     const struct ssh_cipher *cipher;
769     void *v1_cipher_ctx;
770     void *crcda_ctx;
771     const struct ssh2_cipher *cscipher, *sccipher;
772     void *cs_cipher_ctx, *sc_cipher_ctx;
773     const struct ssh_mac *csmac, *scmac;
774     int csmac_etm, scmac_etm;
775     void *cs_mac_ctx, *sc_mac_ctx;
776     const struct ssh_compress *cscomp, *sccomp;
777     void *cs_comp_ctx, *sc_comp_ctx;
778     const struct ssh_kex *kex;
779     const struct ssh_signkey *hostkey;
780     char *hostkey_str; /* string representation, for easy checking in rekeys */
781     unsigned char v2_session_id[SSH2_KEX_MAX_HASH_LEN];
782     int v2_session_id_len;
783     void *kex_ctx;
784
785     int bare_connection;
786     int attempting_connshare;
787     void *connshare;
788
789     char *savedhost;
790     int savedport;
791     int send_ok;
792     int echoing, editing;
793
794     void *frontend;
795
796     int ospeed, ispeed;                /* temporaries */
797     int term_width, term_height;
798
799     tree234 *channels;                 /* indexed by local id */
800     struct ssh_channel *mainchan;      /* primary session channel */
801     int ncmode;                        /* is primary channel direct-tcpip? */
802     int exitcode;
803     int close_expected;
804     int clean_exit;
805
806     tree234 *rportfwds, *portfwds;
807
808     enum {
809         SSH_STATE_PREPACKET,
810         SSH_STATE_BEFORE_SIZE,
811         SSH_STATE_INTERMED,
812         SSH_STATE_SESSION,
813         SSH_STATE_CLOSED
814     } state;
815
816     int size_needed, eof_needed;
817     int sent_console_eof;
818     int got_pty;           /* affects EOF behaviour on main channel */
819
820     struct Packet **queue;
821     int queuelen, queuesize;
822     int queueing;
823     unsigned char *deferred_send_data;
824     int deferred_len, deferred_size;
825
826     /*
827      * Gross hack: pscp will try to start SFTP but fall back to
828      * scp1 if that fails. This variable is the means by which
829      * scp.c can reach into the SSH code and find out which one it
830      * got.
831      */
832     int fallback_cmd;
833
834     bufchain banner;    /* accumulates banners during do_ssh2_authconn */
835
836     Pkt_KCtx pkt_kctx;
837     Pkt_ACtx pkt_actx;
838
839     struct X11Display *x11disp;
840     struct X11FakeAuth *x11auth;
841     tree234 *x11authtree;
842
843     int version;
844     int conn_throttle_count;
845     int overall_bufsize;
846     int throttled_all;
847     int v1_stdout_throttling;
848     unsigned long v2_outgoing_sequence;
849
850     int ssh1_rdpkt_crstate;
851     int ssh2_rdpkt_crstate;
852     int ssh2_bare_rdpkt_crstate;
853     int ssh_gotdata_crstate;
854     int do_ssh1_connection_crstate;
855
856     void *do_ssh_init_state;
857     void *do_ssh1_login_state;
858     void *do_ssh2_transport_state;
859     void *do_ssh2_authconn_state;
860     void *do_ssh_connection_init_state;
861
862     struct rdpkt1_state_tag rdpkt1_state;
863     struct rdpkt2_state_tag rdpkt2_state;
864     struct rdpkt2_bare_state_tag rdpkt2_bare_state;
865
866     /* SSH-1 and SSH-2 use this for different things, but both use it */
867     int protocol_initial_phase_done;
868
869     void (*protocol) (Ssh ssh, const void *vin, int inlen,
870                       struct Packet *pkt);
871     struct Packet *(*s_rdpkt) (Ssh ssh, const unsigned char **data,
872                                int *datalen);
873     int (*do_ssh_init)(Ssh ssh, unsigned char c);
874
875     /*
876      * We maintain our own copy of a Conf structure here. That way,
877      * when we're passed a new one for reconfiguration, we can check
878      * the differences and potentially reconfigure port forwardings
879      * etc in mid-session.
880      */
881     Conf *conf;
882
883     /*
884      * Values cached out of conf so as to avoid the tree234 lookup
885      * cost every time they're used.
886      */
887     int logomitdata;
888
889     /*
890      * Dynamically allocated username string created during SSH
891      * login. Stored in here rather than in the coroutine state so
892      * that it'll be reliably freed if we shut down the SSH session
893      * at some unexpected moment.
894      */
895     char *username;
896
897     /*
898      * Used to transfer data back from async callbacks.
899      */
900     void *agent_response;
901     int agent_response_len;
902     int user_response;
903
904     /*
905      * The SSH connection can be set as `frozen', meaning we are
906      * not currently accepting incoming data from the network. This
907      * is slightly more serious than setting the _socket_ as
908      * frozen, because we may already have had data passed to us
909      * from the network which we need to delay processing until
910      * after the freeze is lifted, so we also need a bufchain to
911      * store that data.
912      */
913     int frozen;
914     bufchain queued_incoming_data;
915
916     /*
917      * Dispatch table for packet types that we may have to deal
918      * with at any time.
919      */
920     handler_fn_t packet_dispatch[256];
921
922     /*
923      * Queues of one-off handler functions for success/failure
924      * indications from a request.
925      */
926     struct queued_handler *qhead, *qtail;
927     handler_fn_t q_saved_handler1, q_saved_handler2;
928
929     /*
930      * This module deals with sending keepalives.
931      */
932     Pinger pinger;
933
934     /*
935      * Track incoming and outgoing data sizes and time, for
936      * size-based rekeys.
937      */
938     unsigned long incoming_data_size, outgoing_data_size, deferred_data_size;
939     unsigned long max_data_size;
940     int kex_in_progress;
941     unsigned long next_rekey, last_rekey;
942     const char *deferred_rekey_reason;
943
944     /*
945      * Fully qualified host name, which we need if doing GSSAPI.
946      */
947     char *fullhostname;
948
949 #ifndef NO_GSSAPI
950     /*
951      * GSSAPI libraries for this session.
952      */
953     struct ssh_gss_liblist *gsslibs;
954 #endif
955 };
956
957 #define logevent(s) logevent(ssh->frontend, s)
958
959 /* logevent, only printf-formatted. */
960 static void logeventf(Ssh ssh, const char *fmt, ...)
961 {
962     va_list ap;
963     char *buf;
964
965     va_start(ap, fmt);
966     buf = dupvprintf(fmt, ap);
967     va_end(ap);
968     logevent(buf);
969     sfree(buf);
970 }
971
972 static void bomb_out(Ssh ssh, char *text)
973 {
974     ssh_do_close(ssh, FALSE);
975     logevent(text);
976     connection_fatal(ssh->frontend, "%s", text);
977     sfree(text);
978 }
979
980 #define bombout(msg) bomb_out(ssh, dupprintf msg)
981
982 /* Helper function for common bits of parsing ttymodes. */
983 static void parse_ttymodes(Ssh ssh,
984                            void (*do_mode)(void *data, char *mode, char *val),
985                            void *data)
986 {
987     char *key, *val;
988
989     for (val = conf_get_str_strs(ssh->conf, CONF_ttymodes, NULL, &key);
990          val != NULL;
991          val = conf_get_str_strs(ssh->conf, CONF_ttymodes, key, &key)) {
992         /*
993          * val[0] is either 'V', indicating that an explicit value
994          * follows it, or 'A' indicating that we should pass the
995          * value through from the local environment via get_ttymode.
996          */
997         if (val[0] == 'A') {
998             val = get_ttymode(ssh->frontend, key);
999             if (val) {
1000                 do_mode(data, key, val);
1001                 sfree(val);
1002             }
1003         } else
1004             do_mode(data, key, val + 1);               /* skip the 'V' */
1005     }
1006 }
1007
1008 static int ssh_channelcmp(void *av, void *bv)
1009 {
1010     struct ssh_channel *a = (struct ssh_channel *) av;
1011     struct ssh_channel *b = (struct ssh_channel *) bv;
1012     if (a->localid < b->localid)
1013         return -1;
1014     if (a->localid > b->localid)
1015         return +1;
1016     return 0;
1017 }
1018 static int ssh_channelfind(void *av, void *bv)
1019 {
1020     unsigned *a = (unsigned *) av;
1021     struct ssh_channel *b = (struct ssh_channel *) bv;
1022     if (*a < b->localid)
1023         return -1;
1024     if (*a > b->localid)
1025         return +1;
1026     return 0;
1027 }
1028
1029 static int ssh_rportcmp_ssh1(void *av, void *bv)
1030 {
1031     struct ssh_rportfwd *a = (struct ssh_rportfwd *) av;
1032     struct ssh_rportfwd *b = (struct ssh_rportfwd *) bv;
1033     int i;
1034     if ( (i = strcmp(a->dhost, b->dhost)) != 0)
1035         return i < 0 ? -1 : +1;
1036     if (a->dport > b->dport)
1037         return +1;
1038     if (a->dport < b->dport)
1039         return -1;
1040     return 0;
1041 }
1042
1043 static int ssh_rportcmp_ssh2(void *av, void *bv)
1044 {
1045     struct ssh_rportfwd *a = (struct ssh_rportfwd *) av;
1046     struct ssh_rportfwd *b = (struct ssh_rportfwd *) bv;
1047     int i;
1048     if ( (i = strcmp(a->shost, b->shost)) != 0)
1049         return i < 0 ? -1 : +1;
1050     if (a->sport > b->sport)
1051         return +1;
1052     if (a->sport < b->sport)
1053         return -1;
1054     return 0;
1055 }
1056
1057 /*
1058  * Special form of strcmp which can cope with NULL inputs. NULL is
1059  * defined to sort before even the empty string.
1060  */
1061 static int nullstrcmp(const char *a, const char *b)
1062 {
1063     if (a == NULL && b == NULL)
1064         return 0;
1065     if (a == NULL)
1066         return -1;
1067     if (b == NULL)
1068         return +1;
1069     return strcmp(a, b);
1070 }
1071
1072 static int ssh_portcmp(void *av, void *bv)
1073 {
1074     struct ssh_portfwd *a = (struct ssh_portfwd *) av;
1075     struct ssh_portfwd *b = (struct ssh_portfwd *) bv;
1076     int i;
1077     if (a->type > b->type)
1078         return +1;
1079     if (a->type < b->type)
1080         return -1;
1081     if (a->addressfamily > b->addressfamily)
1082         return +1;
1083     if (a->addressfamily < b->addressfamily)
1084         return -1;
1085     if ( (i = nullstrcmp(a->saddr, b->saddr)) != 0)
1086         return i < 0 ? -1 : +1;
1087     if (a->sport > b->sport)
1088         return +1;
1089     if (a->sport < b->sport)
1090         return -1;
1091     if (a->type != 'D') {
1092         if ( (i = nullstrcmp(a->daddr, b->daddr)) != 0)
1093             return i < 0 ? -1 : +1;
1094         if (a->dport > b->dport)
1095             return +1;
1096         if (a->dport < b->dport)
1097             return -1;
1098     }
1099     return 0;
1100 }
1101
1102 static int alloc_channel_id(Ssh ssh)
1103 {
1104     const unsigned CHANNEL_NUMBER_OFFSET = 256;
1105     unsigned low, high, mid;
1106     int tsize;
1107     struct ssh_channel *c;
1108
1109     /*
1110      * First-fit allocation of channel numbers: always pick the
1111      * lowest unused one. To do this, binary-search using the
1112      * counted B-tree to find the largest channel ID which is in a
1113      * contiguous sequence from the beginning. (Precisely
1114      * everything in that sequence must have ID equal to its tree
1115      * index plus CHANNEL_NUMBER_OFFSET.)
1116      */
1117     tsize = count234(ssh->channels);
1118
1119     low = -1;
1120     high = tsize;
1121     while (high - low > 1) {
1122         mid = (high + low) / 2;
1123         c = index234(ssh->channels, mid);
1124         if (c->localid == mid + CHANNEL_NUMBER_OFFSET)
1125             low = mid;                 /* this one is fine */
1126         else
1127             high = mid;                /* this one is past it */
1128     }
1129     /*
1130      * Now low points to either -1, or the tree index of the
1131      * largest ID in the initial sequence.
1132      */
1133     {
1134         unsigned i = low + 1 + CHANNEL_NUMBER_OFFSET;
1135         assert(NULL == find234(ssh->channels, &i, ssh_channelfind));
1136     }
1137     return low + 1 + CHANNEL_NUMBER_OFFSET;
1138 }
1139
1140 static void c_write_stderr(int trusted, const char *buf, int len)
1141 {
1142     int i;
1143     for (i = 0; i < len; i++)
1144         if (buf[i] != '\r' && (trusted || buf[i] == '\n' || (buf[i] & 0x60)))
1145             fputc(buf[i], stderr);
1146 }
1147
1148 static void c_write(Ssh ssh, const char *buf, int len)
1149 {
1150     if (flags & FLAG_STDERR)
1151         c_write_stderr(1, buf, len);
1152     else
1153         from_backend(ssh->frontend, 1, buf, len);
1154 }
1155
1156 static void c_write_untrusted(Ssh ssh, const char *buf, int len)
1157 {
1158     if (flags & FLAG_STDERR)
1159         c_write_stderr(0, buf, len);
1160     else
1161         from_backend_untrusted(ssh->frontend, buf, len);
1162 }
1163
1164 static void c_write_str(Ssh ssh, const char *buf)
1165 {
1166     c_write(ssh, buf, strlen(buf));
1167 }
1168
1169 static void ssh_free_packet(struct Packet *pkt)
1170 {
1171     sfree(pkt->data);
1172     sfree(pkt);
1173 }
1174 static struct Packet *ssh_new_packet(void)
1175 {
1176     struct Packet *pkt = snew(struct Packet);
1177
1178     pkt->body = pkt->data = NULL;
1179     pkt->maxlen = 0;
1180
1181     return pkt;
1182 }
1183
1184 static void ssh1_log_incoming_packet(Ssh ssh, struct Packet *pkt)
1185 {
1186     int nblanks = 0;
1187     struct logblank_t blanks[4];
1188     char *str;
1189     int slen;
1190
1191     pkt->savedpos = 0;
1192
1193     if (ssh->logomitdata &&
1194         (pkt->type == SSH1_SMSG_STDOUT_DATA ||
1195          pkt->type == SSH1_SMSG_STDERR_DATA ||
1196          pkt->type == SSH1_MSG_CHANNEL_DATA)) {
1197         /* "Session data" packets - omit the data string. */
1198         if (pkt->type == SSH1_MSG_CHANNEL_DATA)
1199             ssh_pkt_getuint32(pkt);    /* skip channel id */
1200         blanks[nblanks].offset = pkt->savedpos + 4;
1201         blanks[nblanks].type = PKTLOG_OMIT;
1202         ssh_pkt_getstring(pkt, &str, &slen);
1203         if (str) {
1204             blanks[nblanks].len = slen;
1205             nblanks++;
1206         }
1207     }
1208     log_packet(ssh->logctx, PKT_INCOMING, pkt->type,
1209                ssh1_pkt_type(pkt->type),
1210                pkt->body, pkt->length, nblanks, blanks, NULL,
1211                0, NULL);
1212 }
1213
1214 static void ssh1_log_outgoing_packet(Ssh ssh, struct Packet *pkt)
1215 {
1216     int nblanks = 0;
1217     struct logblank_t blanks[4];
1218     char *str;
1219     int slen;
1220
1221     /*
1222      * For outgoing packets, pkt->length represents the length of the
1223      * whole packet starting at pkt->data (including some header), and
1224      * pkt->body refers to the point within that where the log-worthy
1225      * payload begins. However, incoming packets expect pkt->length to
1226      * represent only the payload length (that is, it's measured from
1227      * pkt->body not from pkt->data). Temporarily adjust our outgoing
1228      * packet to conform to the incoming-packet semantics, so that we
1229      * can analyse it with the ssh_pkt_get functions.
1230      */
1231     pkt->length -= (pkt->body - pkt->data);
1232     pkt->savedpos = 0;
1233
1234     if (ssh->logomitdata &&
1235         (pkt->type == SSH1_CMSG_STDIN_DATA ||
1236          pkt->type == SSH1_MSG_CHANNEL_DATA)) {
1237         /* "Session data" packets - omit the data string. */
1238         if (pkt->type == SSH1_MSG_CHANNEL_DATA)
1239             ssh_pkt_getuint32(pkt);    /* skip channel id */
1240         blanks[nblanks].offset = pkt->savedpos + 4;
1241         blanks[nblanks].type = PKTLOG_OMIT;
1242         ssh_pkt_getstring(pkt, &str, &slen);
1243         if (str) {
1244             blanks[nblanks].len = slen;
1245             nblanks++;
1246         }
1247     }
1248
1249     if ((pkt->type == SSH1_CMSG_AUTH_PASSWORD ||
1250          pkt->type == SSH1_CMSG_AUTH_TIS_RESPONSE ||
1251          pkt->type == SSH1_CMSG_AUTH_CCARD_RESPONSE) &&
1252         conf_get_int(ssh->conf, CONF_logomitpass)) {
1253         /* If this is a password or similar packet, blank the password(s). */
1254         blanks[nblanks].offset = 0;
1255         blanks[nblanks].len = pkt->length;
1256         blanks[nblanks].type = PKTLOG_BLANK;
1257         nblanks++;
1258     } else if (pkt->type == SSH1_CMSG_X11_REQUEST_FORWARDING &&
1259                conf_get_int(ssh->conf, CONF_logomitpass)) {
1260         /*
1261          * If this is an X forwarding request packet, blank the fake
1262          * auth data.
1263          *
1264          * Note that while we blank the X authentication data here, we
1265          * don't take any special action to blank the start of an X11
1266          * channel, so using MIT-MAGIC-COOKIE-1 and actually opening
1267          * an X connection without having session blanking enabled is
1268          * likely to leak your cookie into the log.
1269          */
1270         pkt->savedpos = 0;
1271         ssh_pkt_getstring(pkt, &str, &slen);
1272         blanks[nblanks].offset = pkt->savedpos;
1273         blanks[nblanks].type = PKTLOG_BLANK;
1274         ssh_pkt_getstring(pkt, &str, &slen);
1275         if (str) {
1276             blanks[nblanks].len = pkt->savedpos - blanks[nblanks].offset;
1277             nblanks++;
1278         }
1279     }
1280
1281     log_packet(ssh->logctx, PKT_OUTGOING, pkt->data[12],
1282                ssh1_pkt_type(pkt->data[12]),
1283                pkt->body, pkt->length,
1284                nblanks, blanks, NULL, 0, NULL);
1285
1286     /*
1287      * Undo the above adjustment of pkt->length, to put the packet
1288      * back in the state we found it.
1289      */
1290     pkt->length += (pkt->body - pkt->data);
1291 }
1292
1293 /*
1294  * Collect incoming data in the incoming packet buffer.
1295  * Decipher and verify the packet when it is completely read.
1296  * Drop SSH1_MSG_DEBUG and SSH1_MSG_IGNORE packets.
1297  * Update the *data and *datalen variables.
1298  * Return a Packet structure when a packet is completed.
1299  */
1300 static struct Packet *ssh1_rdpkt(Ssh ssh, const unsigned char **data,
1301                                  int *datalen)
1302 {
1303     struct rdpkt1_state_tag *st = &ssh->rdpkt1_state;
1304
1305     crBegin(ssh->ssh1_rdpkt_crstate);
1306
1307     st->pktin = ssh_new_packet();
1308
1309     st->pktin->type = 0;
1310     st->pktin->length = 0;
1311
1312     for (st->i = st->len = 0; st->i < 4; st->i++) {
1313         while ((*datalen) == 0)
1314             crReturn(NULL);
1315         st->len = (st->len << 8) + **data;
1316         (*data)++, (*datalen)--;
1317     }
1318
1319     st->pad = 8 - (st->len % 8);
1320     st->biglen = st->len + st->pad;
1321     st->pktin->length = st->len - 5;
1322
1323     if (st->biglen < 0) {
1324         bombout(("Extremely large packet length from server suggests"
1325                  " data stream corruption"));
1326         ssh_free_packet(st->pktin);
1327         crStop(NULL);
1328     }
1329
1330     st->pktin->maxlen = st->biglen;
1331     st->pktin->data = snewn(st->biglen + APIEXTRA, unsigned char);
1332
1333     st->to_read = st->biglen;
1334     st->p = st->pktin->data;
1335     while (st->to_read > 0) {
1336         st->chunk = st->to_read;
1337         while ((*datalen) == 0)
1338             crReturn(NULL);
1339         if (st->chunk > (*datalen))
1340             st->chunk = (*datalen);
1341         memcpy(st->p, *data, st->chunk);
1342         *data += st->chunk;
1343         *datalen -= st->chunk;
1344         st->p += st->chunk;
1345         st->to_read -= st->chunk;
1346     }
1347
1348     if (ssh->cipher && detect_attack(ssh->crcda_ctx, st->pktin->data,
1349                                      st->biglen, NULL)) {
1350         bombout(("Network attack (CRC compensation) detected!"));
1351         ssh_free_packet(st->pktin);
1352         crStop(NULL);
1353     }
1354
1355     if (ssh->cipher)
1356         ssh->cipher->decrypt(ssh->v1_cipher_ctx, st->pktin->data, st->biglen);
1357
1358     st->realcrc = crc32_compute(st->pktin->data, st->biglen - 4);
1359     st->gotcrc = GET_32BIT(st->pktin->data + st->biglen - 4);
1360     if (st->gotcrc != st->realcrc) {
1361         bombout(("Incorrect CRC received on packet"));
1362         ssh_free_packet(st->pktin);
1363         crStop(NULL);
1364     }
1365
1366     st->pktin->body = st->pktin->data + st->pad + 1;
1367
1368     if (ssh->v1_compressing) {
1369         unsigned char *decompblk;
1370         int decomplen;
1371         if (!zlib_decompress_block(ssh->sc_comp_ctx,
1372                                    st->pktin->body - 1, st->pktin->length + 1,
1373                                    &decompblk, &decomplen)) {
1374             bombout(("Zlib decompression encountered invalid data"));
1375             ssh_free_packet(st->pktin);
1376             crStop(NULL);
1377         }
1378
1379         if (st->pktin->maxlen < st->pad + decomplen) {
1380             st->pktin->maxlen = st->pad + decomplen;
1381             st->pktin->data = sresize(st->pktin->data,
1382                                       st->pktin->maxlen + APIEXTRA,
1383                                       unsigned char);
1384             st->pktin->body = st->pktin->data + st->pad + 1;
1385         }
1386
1387         memcpy(st->pktin->body - 1, decompblk, decomplen);
1388         sfree(decompblk);
1389         st->pktin->length = decomplen - 1;
1390     }
1391
1392     st->pktin->type = st->pktin->body[-1];
1393
1394     /*
1395      * Now pktin->body and pktin->length identify the semantic content
1396      * of the packet, excluding the initial type byte.
1397      */
1398
1399     if (ssh->logctx)
1400         ssh1_log_incoming_packet(ssh, st->pktin);
1401
1402     st->pktin->savedpos = 0;
1403
1404     crFinish(st->pktin);
1405 }
1406
1407 static void ssh2_log_incoming_packet(Ssh ssh, struct Packet *pkt)
1408 {
1409     int nblanks = 0;
1410     struct logblank_t blanks[4];
1411     char *str;
1412     int slen;
1413
1414     pkt->savedpos = 0;
1415
1416     if (ssh->logomitdata &&
1417         (pkt->type == SSH2_MSG_CHANNEL_DATA ||
1418          pkt->type == SSH2_MSG_CHANNEL_EXTENDED_DATA)) {
1419         /* "Session data" packets - omit the data string. */
1420         ssh_pkt_getuint32(pkt);    /* skip channel id */
1421         if (pkt->type == SSH2_MSG_CHANNEL_EXTENDED_DATA)
1422             ssh_pkt_getuint32(pkt);    /* skip extended data type */
1423         blanks[nblanks].offset = pkt->savedpos + 4;
1424         blanks[nblanks].type = PKTLOG_OMIT;
1425         ssh_pkt_getstring(pkt, &str, &slen);
1426         if (str) {
1427             blanks[nblanks].len = slen;
1428             nblanks++;
1429         }
1430     }
1431
1432     log_packet(ssh->logctx, PKT_INCOMING, pkt->type,
1433                ssh2_pkt_type(ssh->pkt_kctx, ssh->pkt_actx, pkt->type),
1434                pkt->body, pkt->length, nblanks, blanks, &pkt->sequence,
1435                0, NULL);
1436 }
1437
1438 static void ssh2_log_outgoing_packet(Ssh ssh, struct Packet *pkt)
1439 {
1440     int nblanks = 0;
1441     struct logblank_t blanks[4];
1442     char *str;
1443     int slen;
1444
1445     /*
1446      * For outgoing packets, pkt->length represents the length of the
1447      * whole packet starting at pkt->data (including some header), and
1448      * pkt->body refers to the point within that where the log-worthy
1449      * payload begins. However, incoming packets expect pkt->length to
1450      * represent only the payload length (that is, it's measured from
1451      * pkt->body not from pkt->data). Temporarily adjust our outgoing
1452      * packet to conform to the incoming-packet semantics, so that we
1453      * can analyse it with the ssh_pkt_get functions.
1454      */
1455     pkt->length -= (pkt->body - pkt->data);
1456     pkt->savedpos = 0;
1457
1458     if (ssh->logomitdata &&
1459         (pkt->type == SSH2_MSG_CHANNEL_DATA ||
1460          pkt->type == SSH2_MSG_CHANNEL_EXTENDED_DATA)) {
1461         /* "Session data" packets - omit the data string. */
1462         ssh_pkt_getuint32(pkt);    /* skip channel id */
1463         if (pkt->type == SSH2_MSG_CHANNEL_EXTENDED_DATA)
1464             ssh_pkt_getuint32(pkt);    /* skip extended data type */
1465         blanks[nblanks].offset = pkt->savedpos + 4;
1466         blanks[nblanks].type = PKTLOG_OMIT;
1467         ssh_pkt_getstring(pkt, &str, &slen);
1468         if (str) {
1469             blanks[nblanks].len = slen;
1470             nblanks++;
1471         }
1472     }
1473
1474     if (pkt->type == SSH2_MSG_USERAUTH_REQUEST &&
1475         conf_get_int(ssh->conf, CONF_logomitpass)) {
1476         /* If this is a password packet, blank the password(s). */
1477         pkt->savedpos = 0;
1478         ssh_pkt_getstring(pkt, &str, &slen);
1479         ssh_pkt_getstring(pkt, &str, &slen);
1480         ssh_pkt_getstring(pkt, &str, &slen);
1481         if (slen == 8 && !memcmp(str, "password", 8)) {
1482             ssh2_pkt_getbool(pkt);
1483             /* Blank the password field. */
1484             blanks[nblanks].offset = pkt->savedpos;
1485             blanks[nblanks].type = PKTLOG_BLANK;
1486             ssh_pkt_getstring(pkt, &str, &slen);
1487             if (str) {
1488                 blanks[nblanks].len = pkt->savedpos - blanks[nblanks].offset;
1489                 nblanks++;
1490                 /* If there's another password field beyond it (change of
1491                  * password), blank that too. */
1492                 ssh_pkt_getstring(pkt, &str, &slen);
1493                 if (str)
1494                     blanks[nblanks-1].len =
1495                         pkt->savedpos - blanks[nblanks].offset;
1496             }
1497         }
1498     } else if (ssh->pkt_actx == SSH2_PKTCTX_KBDINTER &&
1499                pkt->type == SSH2_MSG_USERAUTH_INFO_RESPONSE &&
1500                conf_get_int(ssh->conf, CONF_logomitpass)) {
1501         /* If this is a keyboard-interactive response packet, blank
1502          * the responses. */
1503         pkt->savedpos = 0;
1504         ssh_pkt_getuint32(pkt);
1505         blanks[nblanks].offset = pkt->savedpos;
1506         blanks[nblanks].type = PKTLOG_BLANK;
1507         while (1) {
1508             ssh_pkt_getstring(pkt, &str, &slen);
1509             if (!str)
1510                 break;
1511         }
1512         blanks[nblanks].len = pkt->savedpos - blanks[nblanks].offset;
1513         nblanks++;
1514     } else if (pkt->type == SSH2_MSG_CHANNEL_REQUEST &&
1515                conf_get_int(ssh->conf, CONF_logomitpass)) {
1516         /*
1517          * If this is an X forwarding request packet, blank the fake
1518          * auth data.
1519          *
1520          * Note that while we blank the X authentication data here, we
1521          * don't take any special action to blank the start of an X11
1522          * channel, so using MIT-MAGIC-COOKIE-1 and actually opening
1523          * an X connection without having session blanking enabled is
1524          * likely to leak your cookie into the log.
1525          */
1526         pkt->savedpos = 0;
1527         ssh_pkt_getuint32(pkt);
1528         ssh_pkt_getstring(pkt, &str, &slen);
1529         if (slen == 7 && !memcmp(str, "x11-req", 0)) {
1530             ssh2_pkt_getbool(pkt);
1531             ssh2_pkt_getbool(pkt);
1532             ssh_pkt_getstring(pkt, &str, &slen);
1533             blanks[nblanks].offset = pkt->savedpos;
1534             blanks[nblanks].type = PKTLOG_BLANK;
1535             ssh_pkt_getstring(pkt, &str, &slen);
1536             if (str) {
1537                 blanks[nblanks].len = pkt->savedpos - blanks[nblanks].offset;
1538                 nblanks++;
1539             }
1540         }
1541     }
1542
1543     log_packet(ssh->logctx, PKT_OUTGOING, pkt->data[5],
1544                ssh2_pkt_type(ssh->pkt_kctx, ssh->pkt_actx, pkt->data[5]),
1545                pkt->body, pkt->length, nblanks, blanks,
1546                &ssh->v2_outgoing_sequence,
1547                pkt->downstream_id, pkt->additional_log_text);
1548
1549     /*
1550      * Undo the above adjustment of pkt->length, to put the packet
1551      * back in the state we found it.
1552      */
1553     pkt->length += (pkt->body - pkt->data);
1554 }
1555
1556 static struct Packet *ssh2_rdpkt(Ssh ssh, const unsigned char **data,
1557                                  int *datalen)
1558 {
1559     struct rdpkt2_state_tag *st = &ssh->rdpkt2_state;
1560
1561     crBegin(ssh->ssh2_rdpkt_crstate);
1562
1563     st->pktin = ssh_new_packet();
1564
1565     st->pktin->type = 0;
1566     st->pktin->length = 0;
1567     if (ssh->sccipher)
1568         st->cipherblk = ssh->sccipher->blksize;
1569     else
1570         st->cipherblk = 8;
1571     if (st->cipherblk < 8)
1572         st->cipherblk = 8;
1573     st->maclen = ssh->scmac ? ssh->scmac->len : 0;
1574
1575     if (ssh->sccipher && (ssh->sccipher->flags & SSH_CIPHER_IS_CBC) &&
1576         ssh->scmac && !ssh->scmac_etm) {
1577         /*
1578          * When dealing with a CBC-mode cipher, we want to avoid the
1579          * possibility of an attacker's tweaking the ciphertext stream
1580          * so as to cause us to feed the same block to the block
1581          * cipher more than once and thus leak information
1582          * (VU#958563).  The way we do this is not to take any
1583          * decisions on the basis of anything we've decrypted until
1584          * we've verified it with a MAC.  That includes the packet
1585          * length, so we just read data and check the MAC repeatedly,
1586          * and when the MAC passes, see if the length we've got is
1587          * plausible.
1588          *
1589          * This defence is unnecessary in OpenSSH ETM mode, because
1590          * the whole point of ETM mode is that the attacker can't
1591          * tweak the ciphertext stream at all without the MAC
1592          * detecting it before we decrypt anything.
1593          */
1594
1595         /* May as well allocate the whole lot now. */
1596         st->pktin->data = snewn(OUR_V2_PACKETLIMIT + st->maclen + APIEXTRA,
1597                                 unsigned char);
1598
1599         /* Read an amount corresponding to the MAC. */
1600         for (st->i = 0; st->i < st->maclen; st->i++) {
1601             while ((*datalen) == 0)
1602                 crReturn(NULL);
1603             st->pktin->data[st->i] = *(*data)++;
1604             (*datalen)--;
1605         }
1606
1607         st->packetlen = 0;
1608         {
1609             unsigned char seq[4];
1610             ssh->scmac->start(ssh->sc_mac_ctx);
1611             PUT_32BIT(seq, st->incoming_sequence);
1612             ssh->scmac->bytes(ssh->sc_mac_ctx, seq, 4);
1613         }
1614
1615         for (;;) { /* Once around this loop per cipher block. */
1616             /* Read another cipher-block's worth, and tack it onto the end. */
1617             for (st->i = 0; st->i < st->cipherblk; st->i++) {
1618                 while ((*datalen) == 0)
1619                     crReturn(NULL);
1620                 st->pktin->data[st->packetlen+st->maclen+st->i] = *(*data)++;
1621                 (*datalen)--;
1622             }
1623             /* Decrypt one more block (a little further back in the stream). */
1624             ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
1625                                    st->pktin->data + st->packetlen,
1626                                    st->cipherblk);
1627             /* Feed that block to the MAC. */
1628             ssh->scmac->bytes(ssh->sc_mac_ctx,
1629                               st->pktin->data + st->packetlen, st->cipherblk);
1630             st->packetlen += st->cipherblk;
1631             /* See if that gives us a valid packet. */
1632             if (ssh->scmac->verresult(ssh->sc_mac_ctx,
1633                                       st->pktin->data + st->packetlen) &&
1634                 ((st->len = toint(GET_32BIT(st->pktin->data))) ==
1635                  st->packetlen-4))
1636                     break;
1637             if (st->packetlen >= OUR_V2_PACKETLIMIT) {
1638                 bombout(("No valid incoming packet found"));
1639                 ssh_free_packet(st->pktin);
1640                 crStop(NULL);
1641             }       
1642         }
1643         st->pktin->maxlen = st->packetlen + st->maclen;
1644         st->pktin->data = sresize(st->pktin->data,
1645                                   st->pktin->maxlen + APIEXTRA,
1646                                   unsigned char);
1647     } else if (ssh->scmac && ssh->scmac_etm) {
1648         st->pktin->data = snewn(4 + APIEXTRA, unsigned char);
1649
1650         /*
1651          * OpenSSH encrypt-then-MAC mode: the packet length is
1652          * unencrypted.
1653          */
1654         for (st->i = st->len = 0; st->i < 4; st->i++) {
1655             while ((*datalen) == 0)
1656                 crReturn(NULL);
1657             st->pktin->data[st->i] = *(*data)++;
1658             (*datalen)--;
1659         }
1660         st->len = toint(GET_32BIT(st->pktin->data));
1661
1662         /*
1663          * _Completely_ silly lengths should be stomped on before they
1664          * do us any more damage.
1665          */
1666         if (st->len < 0 || st->len > OUR_V2_PACKETLIMIT ||
1667             st->len % st->cipherblk != 0) {
1668             bombout(("Incoming packet length field was garbled"));
1669             ssh_free_packet(st->pktin);
1670             crStop(NULL);
1671         }
1672
1673         /*
1674          * So now we can work out the total packet length.
1675          */
1676         st->packetlen = st->len + 4;
1677
1678         /*
1679          * Allocate memory for the rest of the packet.
1680          */
1681         st->pktin->maxlen = st->packetlen + st->maclen;
1682         st->pktin->data = sresize(st->pktin->data,
1683                                   st->pktin->maxlen + APIEXTRA,
1684                                   unsigned char);
1685
1686         /*
1687          * Read the remainder of the packet.
1688          */
1689         for (st->i = 4; st->i < st->packetlen + st->maclen; st->i++) {
1690             while ((*datalen) == 0)
1691                 crReturn(NULL);
1692             st->pktin->data[st->i] = *(*data)++;
1693             (*datalen)--;
1694         }
1695
1696         /*
1697          * Check the MAC.
1698          */
1699         if (ssh->scmac
1700             && !ssh->scmac->verify(ssh->sc_mac_ctx, st->pktin->data,
1701                                    st->len + 4, st->incoming_sequence)) {
1702             bombout(("Incorrect MAC received on packet"));
1703             ssh_free_packet(st->pktin);
1704             crStop(NULL);
1705         }
1706
1707         /* Decrypt everything between the length field and the MAC. */
1708         if (ssh->sccipher)
1709             ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
1710                                    st->pktin->data + 4,
1711                                    st->packetlen - 4);
1712     } else {
1713         st->pktin->data = snewn(st->cipherblk + APIEXTRA, unsigned char);
1714
1715         /*
1716          * Acquire and decrypt the first block of the packet. This will
1717          * contain the length and padding details.
1718          */
1719         for (st->i = st->len = 0; st->i < st->cipherblk; st->i++) {
1720             while ((*datalen) == 0)
1721                 crReturn(NULL);
1722             st->pktin->data[st->i] = *(*data)++;
1723             (*datalen)--;
1724         }
1725
1726         if (ssh->sccipher)
1727             ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
1728                                    st->pktin->data, st->cipherblk);
1729
1730         /*
1731          * Now get the length figure.
1732          */
1733         st->len = toint(GET_32BIT(st->pktin->data));
1734
1735         /*
1736          * _Completely_ silly lengths should be stomped on before they
1737          * do us any more damage.
1738          */
1739         if (st->len < 0 || st->len > OUR_V2_PACKETLIMIT ||
1740             (st->len + 4) % st->cipherblk != 0) {
1741             bombout(("Incoming packet was garbled on decryption"));
1742             ssh_free_packet(st->pktin);
1743             crStop(NULL);
1744         }
1745
1746         /*
1747          * So now we can work out the total packet length.
1748          */
1749         st->packetlen = st->len + 4;
1750
1751         /*
1752          * Allocate memory for the rest of the packet.
1753          */
1754         st->pktin->maxlen = st->packetlen + st->maclen;
1755         st->pktin->data = sresize(st->pktin->data,
1756                                   st->pktin->maxlen + APIEXTRA,
1757                                   unsigned char);
1758
1759         /*
1760          * Read and decrypt the remainder of the packet.
1761          */
1762         for (st->i = st->cipherblk; st->i < st->packetlen + st->maclen;
1763              st->i++) {
1764             while ((*datalen) == 0)
1765                 crReturn(NULL);
1766             st->pktin->data[st->i] = *(*data)++;
1767             (*datalen)--;
1768         }
1769         /* Decrypt everything _except_ the MAC. */
1770         if (ssh->sccipher)
1771             ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
1772                                    st->pktin->data + st->cipherblk,
1773                                    st->packetlen - st->cipherblk);
1774
1775         /*
1776          * Check the MAC.
1777          */
1778         if (ssh->scmac
1779             && !ssh->scmac->verify(ssh->sc_mac_ctx, st->pktin->data,
1780                                    st->len + 4, st->incoming_sequence)) {
1781             bombout(("Incorrect MAC received on packet"));
1782             ssh_free_packet(st->pktin);
1783             crStop(NULL);
1784         }
1785     }
1786     /* Get and sanity-check the amount of random padding. */
1787     st->pad = st->pktin->data[4];
1788     if (st->pad < 4 || st->len - st->pad < 1) {
1789         bombout(("Invalid padding length on received packet"));
1790         ssh_free_packet(st->pktin);
1791         crStop(NULL);
1792     }
1793     /*
1794      * This enables us to deduce the payload length.
1795      */
1796     st->payload = st->len - st->pad - 1;
1797
1798     st->pktin->length = st->payload + 5;
1799     st->pktin->encrypted_len = st->packetlen;
1800
1801     st->pktin->sequence = st->incoming_sequence++;
1802
1803     st->pktin->length = st->packetlen - st->pad;
1804     assert(st->pktin->length >= 0);
1805
1806     /*
1807      * Decompress packet payload.
1808      */
1809     {
1810         unsigned char *newpayload;
1811         int newlen;
1812         if (ssh->sccomp &&
1813             ssh->sccomp->decompress(ssh->sc_comp_ctx,
1814                                     st->pktin->data + 5, st->pktin->length - 5,
1815                                     &newpayload, &newlen)) {
1816             if (st->pktin->maxlen < newlen + 5) {
1817                 st->pktin->maxlen = newlen + 5;
1818                 st->pktin->data = sresize(st->pktin->data,
1819                                           st->pktin->maxlen + APIEXTRA,
1820                                           unsigned char);
1821             }
1822             st->pktin->length = 5 + newlen;
1823             memcpy(st->pktin->data + 5, newpayload, newlen);
1824             sfree(newpayload);
1825         }
1826     }
1827
1828     /*
1829      * pktin->body and pktin->length should identify the semantic
1830      * content of the packet, excluding the initial type byte.
1831      */
1832     st->pktin->type = st->pktin->data[5];
1833     st->pktin->body = st->pktin->data + 6;
1834     st->pktin->length -= 6;
1835     assert(st->pktin->length >= 0);    /* one last double-check */
1836
1837     if (ssh->logctx)
1838         ssh2_log_incoming_packet(ssh, st->pktin);
1839
1840     st->pktin->savedpos = 0;
1841
1842     crFinish(st->pktin);
1843 }
1844
1845 static struct Packet *ssh2_bare_connection_rdpkt(Ssh ssh,
1846                                                  const unsigned char **data,
1847                                                  int *datalen)
1848 {
1849     struct rdpkt2_bare_state_tag *st = &ssh->rdpkt2_bare_state;
1850
1851     crBegin(ssh->ssh2_bare_rdpkt_crstate);
1852
1853     /*
1854      * Read the packet length field.
1855      */
1856     for (st->i = 0; st->i < 4; st->i++) {
1857         while ((*datalen) == 0)
1858             crReturn(NULL);
1859         st->length[st->i] = *(*data)++;
1860         (*datalen)--;
1861     }
1862
1863     st->packetlen = toint(GET_32BIT_MSB_FIRST(st->length));
1864     if (st->packetlen <= 0 || st->packetlen >= OUR_V2_PACKETLIMIT) {
1865         bombout(("Invalid packet length received"));
1866         crStop(NULL);
1867     }
1868
1869     st->pktin = ssh_new_packet();
1870     st->pktin->data = snewn(st->packetlen, unsigned char);
1871
1872     st->pktin->encrypted_len = st->packetlen;
1873
1874     st->pktin->sequence = st->incoming_sequence++;
1875
1876     /*
1877      * Read the remainder of the packet.
1878      */
1879     for (st->i = 0; st->i < st->packetlen; st->i++) {
1880         while ((*datalen) == 0)
1881             crReturn(NULL);
1882         st->pktin->data[st->i] = *(*data)++;
1883         (*datalen)--;
1884     }
1885
1886     /*
1887      * pktin->body and pktin->length should identify the semantic
1888      * content of the packet, excluding the initial type byte.
1889      */
1890     st->pktin->type = st->pktin->data[0];
1891     st->pktin->body = st->pktin->data + 1;
1892     st->pktin->length = st->packetlen - 1;
1893
1894     /*
1895      * Log incoming packet, possibly omitting sensitive fields.
1896      */
1897     if (ssh->logctx)
1898         ssh2_log_incoming_packet(ssh, st->pktin);
1899
1900     st->pktin->savedpos = 0;
1901
1902     crFinish(st->pktin);
1903 }
1904
1905 static int s_wrpkt_prepare(Ssh ssh, struct Packet *pkt, int *offset_p)
1906 {
1907     int pad, biglen, i, pktoffs;
1908     unsigned long crc;
1909 #ifdef __SC__
1910     /*
1911      * XXX various versions of SC (including 8.8.4) screw up the
1912      * register allocation in this function and use the same register
1913      * (D6) for len and as a temporary, with predictable results.  The
1914      * following sledgehammer prevents this.
1915      */
1916     volatile
1917 #endif
1918     int len;
1919
1920     if (ssh->logctx)
1921         ssh1_log_outgoing_packet(ssh, pkt);
1922
1923     if (ssh->v1_compressing) {
1924         unsigned char *compblk;
1925         int complen;
1926         zlib_compress_block(ssh->cs_comp_ctx,
1927                             pkt->data + 12, pkt->length - 12,
1928                             &compblk, &complen);
1929         ssh_pkt_ensure(pkt, complen + 2);   /* just in case it's got bigger */
1930         memcpy(pkt->data + 12, compblk, complen);
1931         sfree(compblk);
1932         pkt->length = complen + 12;
1933     }
1934
1935     ssh_pkt_ensure(pkt, pkt->length + 4); /* space for CRC */
1936     pkt->length += 4;
1937     len = pkt->length - 4 - 8;  /* len(type+data+CRC) */
1938     pad = 8 - (len % 8);
1939     pktoffs = 8 - pad;
1940     biglen = len + pad;         /* len(padding+type+data+CRC) */
1941
1942     for (i = pktoffs; i < 4+8; i++)
1943         pkt->data[i] = random_byte();
1944     crc = crc32_compute(pkt->data + pktoffs + 4, biglen - 4); /* all ex len */
1945     PUT_32BIT(pkt->data + pktoffs + 4 + biglen - 4, crc);
1946     PUT_32BIT(pkt->data + pktoffs, len);
1947
1948     if (ssh->cipher)
1949         ssh->cipher->encrypt(ssh->v1_cipher_ctx,
1950                              pkt->data + pktoffs + 4, biglen);
1951
1952     if (offset_p) *offset_p = pktoffs;
1953     return biglen + 4;          /* len(length+padding+type+data+CRC) */
1954 }
1955
1956 static int s_write(Ssh ssh, void *data, int len)
1957 {
1958     if (ssh->logctx)
1959         log_packet(ssh->logctx, PKT_OUTGOING, -1, NULL, data, len,
1960                    0, NULL, NULL, 0, NULL);
1961     if (!ssh->s)
1962         return 0;
1963     return sk_write(ssh->s, (char *)data, len);
1964 }
1965
1966 static void s_wrpkt(Ssh ssh, struct Packet *pkt)
1967 {
1968     int len, backlog, offset;
1969     len = s_wrpkt_prepare(ssh, pkt, &offset);
1970     backlog = s_write(ssh, pkt->data + offset, len);
1971     if (backlog > SSH_MAX_BACKLOG)
1972         ssh_throttle_all(ssh, 1, backlog);
1973     ssh_free_packet(pkt);
1974 }
1975
1976 static void s_wrpkt_defer(Ssh ssh, struct Packet *pkt)
1977 {
1978     int len, offset;
1979     len = s_wrpkt_prepare(ssh, pkt, &offset);
1980     if (ssh->deferred_len + len > ssh->deferred_size) {
1981         ssh->deferred_size = ssh->deferred_len + len + 128;
1982         ssh->deferred_send_data = sresize(ssh->deferred_send_data,
1983                                           ssh->deferred_size,
1984                                           unsigned char);
1985     }
1986     memcpy(ssh->deferred_send_data + ssh->deferred_len,
1987            pkt->data + offset, len);
1988     ssh->deferred_len += len;
1989     ssh_free_packet(pkt);
1990 }
1991
1992 /*
1993  * Construct a SSH-1 packet with the specified contents.
1994  * (This all-at-once interface used to be the only one, but now SSH-1
1995  * packets can also be constructed incrementally.)
1996  */
1997 static struct Packet *construct_packet(Ssh ssh, int pkttype, va_list ap)
1998 {
1999     int argtype;
2000     Bignum bn;
2001     struct Packet *pkt;
2002
2003     pkt = ssh1_pkt_init(pkttype);
2004
2005     while ((argtype = va_arg(ap, int)) != PKT_END) {
2006         unsigned char *argp, argchar;
2007         char *sargp;
2008         unsigned long argint;
2009         int arglen;
2010         switch (argtype) {
2011           /* Actual fields in the packet */
2012           case PKT_INT:
2013             argint = va_arg(ap, int);
2014             ssh_pkt_adduint32(pkt, argint);
2015             break;
2016           case PKT_CHAR:
2017             argchar = (unsigned char) va_arg(ap, int);
2018             ssh_pkt_addbyte(pkt, argchar);
2019             break;
2020           case PKT_DATA:
2021             argp = va_arg(ap, unsigned char *);
2022             arglen = va_arg(ap, int);
2023             ssh_pkt_adddata(pkt, argp, arglen);
2024             break;
2025           case PKT_STR:
2026             sargp = va_arg(ap, char *);
2027             ssh_pkt_addstring(pkt, sargp);
2028             break;
2029           case PKT_BIGNUM:
2030             bn = va_arg(ap, Bignum);
2031             ssh1_pkt_addmp(pkt, bn);
2032             break;
2033         }
2034     }
2035
2036     return pkt;
2037 }
2038
2039 static void send_packet(Ssh ssh, int pkttype, ...)
2040 {
2041     struct Packet *pkt;
2042     va_list ap;
2043     va_start(ap, pkttype);
2044     pkt = construct_packet(ssh, pkttype, ap);
2045     va_end(ap);
2046     s_wrpkt(ssh, pkt);
2047 }
2048
2049 static void defer_packet(Ssh ssh, int pkttype, ...)
2050 {
2051     struct Packet *pkt;
2052     va_list ap;
2053     va_start(ap, pkttype);
2054     pkt = construct_packet(ssh, pkttype, ap);
2055     va_end(ap);
2056     s_wrpkt_defer(ssh, pkt);
2057 }
2058
2059 static int ssh_versioncmp(const char *a, const char *b)
2060 {
2061     char *ae, *be;
2062     unsigned long av, bv;
2063
2064     av = strtoul(a, &ae, 10);
2065     bv = strtoul(b, &be, 10);
2066     if (av != bv)
2067         return (av < bv ? -1 : +1);
2068     if (*ae == '.')
2069         ae++;
2070     if (*be == '.')
2071         be++;
2072     av = strtoul(ae, &ae, 10);
2073     bv = strtoul(be, &be, 10);
2074     if (av != bv)
2075         return (av < bv ? -1 : +1);
2076     return 0;
2077 }
2078
2079 /*
2080  * Utility routines for putting an SSH-protocol `string' and
2081  * `uint32' into a hash state.
2082  */
2083 static void hash_string(const struct ssh_hash *h, void *s, void *str, int len)
2084 {
2085     unsigned char lenblk[4];
2086     PUT_32BIT(lenblk, len);
2087     h->bytes(s, lenblk, 4);
2088     h->bytes(s, str, len);
2089 }
2090
2091 static void hash_uint32(const struct ssh_hash *h, void *s, unsigned i)
2092 {
2093     unsigned char intblk[4];
2094     PUT_32BIT(intblk, i);
2095     h->bytes(s, intblk, 4);
2096 }
2097
2098 /*
2099  * Packet construction functions. Mostly shared between SSH-1 and SSH-2.
2100  */
2101 static void ssh_pkt_ensure(struct Packet *pkt, int length)
2102 {
2103     if (pkt->maxlen < length) {
2104         unsigned char *body = pkt->body;
2105         int offset = body ? body - pkt->data : 0;
2106         pkt->maxlen = length + 256;
2107         pkt->data = sresize(pkt->data, pkt->maxlen + APIEXTRA, unsigned char);
2108         if (body) pkt->body = pkt->data + offset;
2109     }
2110 }
2111 static void ssh_pkt_adddata(struct Packet *pkt, const void *data, int len)
2112 {
2113     pkt->length += len;
2114     ssh_pkt_ensure(pkt, pkt->length);
2115     memcpy(pkt->data + pkt->length - len, data, len);
2116 }
2117 static void ssh_pkt_addbyte(struct Packet *pkt, unsigned char byte)
2118 {
2119     ssh_pkt_adddata(pkt, &byte, 1);
2120 }
2121 static void ssh2_pkt_addbool(struct Packet *pkt, unsigned char value)
2122 {
2123     ssh_pkt_adddata(pkt, &value, 1);
2124 }
2125 static void ssh_pkt_adduint32(struct Packet *pkt, unsigned long value)
2126 {
2127     unsigned char x[4];
2128     PUT_32BIT(x, value);
2129     ssh_pkt_adddata(pkt, x, 4);
2130 }
2131 static void ssh_pkt_addstring_start(struct Packet *pkt)
2132 {
2133     ssh_pkt_adduint32(pkt, 0);
2134     pkt->savedpos = pkt->length;
2135 }
2136 static void ssh_pkt_addstring_data(struct Packet *pkt, const char *data,
2137                                    int len)
2138 {
2139     ssh_pkt_adddata(pkt, data, len);
2140     PUT_32BIT(pkt->data + pkt->savedpos - 4, pkt->length - pkt->savedpos);
2141 }
2142 static void ssh_pkt_addstring_str(struct Packet *pkt, const char *data)
2143 {
2144   ssh_pkt_addstring_data(pkt, data, strlen(data));
2145 }
2146 static void ssh_pkt_addstring(struct Packet *pkt, const char *data)
2147 {
2148     ssh_pkt_addstring_start(pkt);
2149     ssh_pkt_addstring_str(pkt, data);
2150 }
2151 static void ssh1_pkt_addmp(struct Packet *pkt, Bignum b)
2152 {
2153     int len = ssh1_bignum_length(b);
2154     unsigned char *data = snewn(len, unsigned char);
2155     (void) ssh1_write_bignum(data, b);
2156     ssh_pkt_adddata(pkt, data, len);
2157     sfree(data);
2158 }
2159 static unsigned char *ssh2_mpint_fmt(Bignum b, int *len)
2160 {
2161     unsigned char *p;
2162     int i, n = (bignum_bitcount(b) + 7) / 8;
2163     p = snewn(n + 1, unsigned char);
2164     p[0] = 0;
2165     for (i = 1; i <= n; i++)
2166         p[i] = bignum_byte(b, n - i);
2167     i = 0;
2168     while (i <= n && p[i] == 0 && (p[i + 1] & 0x80) == 0)
2169         i++;
2170     memmove(p, p + i, n + 1 - i);
2171     *len = n + 1 - i;
2172     return p;
2173 }
2174 static void ssh2_pkt_addmp(struct Packet *pkt, Bignum b)
2175 {
2176     unsigned char *p;
2177     int len;
2178     p = ssh2_mpint_fmt(b, &len);
2179     ssh_pkt_addstring_start(pkt);
2180     ssh_pkt_addstring_data(pkt, (char *)p, len);
2181     sfree(p);
2182 }
2183
2184 static struct Packet *ssh1_pkt_init(int pkt_type)
2185 {
2186     struct Packet *pkt = ssh_new_packet();
2187     pkt->length = 4 + 8;            /* space for length + max padding */
2188     ssh_pkt_addbyte(pkt, pkt_type);
2189     pkt->body = pkt->data + pkt->length;
2190     pkt->type = pkt_type;
2191     pkt->downstream_id = 0;
2192     pkt->additional_log_text = NULL;
2193     return pkt;
2194 }
2195
2196 /* For legacy code (SSH-1 and -2 packet construction used to be separate) */
2197 #define ssh2_pkt_ensure(pkt, length) ssh_pkt_ensure(pkt, length)
2198 #define ssh2_pkt_adddata(pkt, data, len) ssh_pkt_adddata(pkt, data, len)
2199 #define ssh2_pkt_addbyte(pkt, byte) ssh_pkt_addbyte(pkt, byte)
2200 #define ssh2_pkt_adduint32(pkt, value) ssh_pkt_adduint32(pkt, value)
2201 #define ssh2_pkt_addstring_start(pkt) ssh_pkt_addstring_start(pkt)
2202 #define ssh2_pkt_addstring_str(pkt, data) ssh_pkt_addstring_str(pkt, data)
2203 #define ssh2_pkt_addstring_data(pkt, data, len) ssh_pkt_addstring_data(pkt, data, len)
2204 #define ssh2_pkt_addstring(pkt, data) ssh_pkt_addstring(pkt, data)
2205
2206 static struct Packet *ssh2_pkt_init(int pkt_type)
2207 {
2208     struct Packet *pkt = ssh_new_packet();
2209     pkt->length = 5; /* space for packet length + padding length */
2210     pkt->forcepad = 0;
2211     pkt->type = pkt_type;
2212     ssh_pkt_addbyte(pkt, (unsigned char) pkt_type);
2213     pkt->body = pkt->data + pkt->length; /* after packet type */
2214     pkt->downstream_id = 0;
2215     pkt->additional_log_text = NULL;
2216     return pkt;
2217 }
2218
2219 /*
2220  * Construct an SSH-2 final-form packet: compress it, encrypt it,
2221  * put the MAC on it. Final packet, ready to be sent, is stored in
2222  * pkt->data. Total length is returned.
2223  */
2224 static int ssh2_pkt_construct(Ssh ssh, struct Packet *pkt)
2225 {
2226     int cipherblk, maclen, padding, unencrypted_prefix, i;
2227
2228     if (ssh->logctx)
2229         ssh2_log_outgoing_packet(ssh, pkt);
2230
2231     if (ssh->bare_connection) {
2232         /*
2233          * Trivial packet construction for the bare connection
2234          * protocol.
2235          */
2236         PUT_32BIT(pkt->data + 1, pkt->length - 5);
2237         pkt->body = pkt->data + 1;
2238         ssh->v2_outgoing_sequence++;   /* only for diagnostics, really */
2239         return pkt->length - 1;
2240     }
2241
2242     /*
2243      * Compress packet payload.
2244      */
2245     {
2246         unsigned char *newpayload;
2247         int newlen;
2248         if (ssh->cscomp &&
2249             ssh->cscomp->compress(ssh->cs_comp_ctx, pkt->data + 5,
2250                                   pkt->length - 5,
2251                                   &newpayload, &newlen)) {
2252             pkt->length = 5;
2253             ssh2_pkt_adddata(pkt, newpayload, newlen);
2254             sfree(newpayload);
2255         }
2256     }
2257
2258     /*
2259      * Add padding. At least four bytes, and must also bring total
2260      * length (minus MAC) up to a multiple of the block size.
2261      * If pkt->forcepad is set, make sure the packet is at least that size
2262      * after padding.
2263      */
2264     cipherblk = ssh->cscipher ? ssh->cscipher->blksize : 8;  /* block size */
2265     cipherblk = cipherblk < 8 ? 8 : cipherblk;  /* or 8 if blksize < 8 */
2266     padding = 4;
2267     unencrypted_prefix = (ssh->csmac && ssh->csmac_etm) ? 4 : 0;
2268     if (pkt->length + padding < pkt->forcepad)
2269         padding = pkt->forcepad - pkt->length;
2270     padding +=
2271         (cipherblk - (pkt->length - unencrypted_prefix + padding) % cipherblk)
2272         % cipherblk;
2273     assert(padding <= 255);
2274     maclen = ssh->csmac ? ssh->csmac->len : 0;
2275     ssh2_pkt_ensure(pkt, pkt->length + padding + maclen);
2276     pkt->data[4] = padding;
2277     for (i = 0; i < padding; i++)
2278         pkt->data[pkt->length + i] = random_byte();
2279     PUT_32BIT(pkt->data, pkt->length + padding - 4);
2280     if (ssh->csmac && ssh->csmac_etm) {
2281         /*
2282          * OpenSSH-defined encrypt-then-MAC protocol.
2283          */
2284         if (ssh->cscipher)
2285             ssh->cscipher->encrypt(ssh->cs_cipher_ctx,
2286                                    pkt->data + 4, pkt->length + padding - 4);
2287         ssh->csmac->generate(ssh->cs_mac_ctx, pkt->data,
2288                              pkt->length + padding,
2289                              ssh->v2_outgoing_sequence);
2290     } else {
2291         /*
2292          * SSH-2 standard protocol.
2293          */
2294         if (ssh->csmac)
2295             ssh->csmac->generate(ssh->cs_mac_ctx, pkt->data,
2296                                  pkt->length + padding,
2297                                  ssh->v2_outgoing_sequence);
2298         if (ssh->cscipher)
2299             ssh->cscipher->encrypt(ssh->cs_cipher_ctx,
2300                                    pkt->data, pkt->length + padding);
2301     }
2302
2303     ssh->v2_outgoing_sequence++;       /* whether or not we MACed */
2304     pkt->encrypted_len = pkt->length + padding;
2305
2306     /* Ready-to-send packet starts at pkt->data. We return length. */
2307     pkt->body = pkt->data;
2308     return pkt->length + padding + maclen;
2309 }
2310
2311 /*
2312  * Routines called from the main SSH code to send packets. There
2313  * are quite a few of these, because we have two separate
2314  * mechanisms for delaying the sending of packets:
2315  * 
2316  *  - In order to send an IGNORE message and a password message in
2317  *    a single fixed-length blob, we require the ability to
2318  *    concatenate the encrypted forms of those two packets _into_ a
2319  *    single blob and then pass it to our <network.h> transport
2320  *    layer in one go. Hence, there's a deferment mechanism which
2321  *    works after packet encryption.
2322  * 
2323  *  - In order to avoid sending any connection-layer messages
2324  *    during repeat key exchange, we have to queue up any such
2325  *    outgoing messages _before_ they are encrypted (and in
2326  *    particular before they're allocated sequence numbers), and
2327  *    then send them once we've finished.
2328  * 
2329  * I call these mechanisms `defer' and `queue' respectively, so as
2330  * to distinguish them reasonably easily.
2331  * 
2332  * The functions send_noqueue() and defer_noqueue() free the packet
2333  * structure they are passed. Every outgoing packet goes through
2334  * precisely one of these functions in its life; packets passed to
2335  * ssh2_pkt_send() or ssh2_pkt_defer() either go straight to one of
2336  * these or get queued, and then when the queue is later emptied
2337  * the packets are all passed to defer_noqueue().
2338  *
2339  * When using a CBC-mode cipher, it's necessary to ensure that an
2340  * attacker can't provide data to be encrypted using an IV that they
2341  * know.  We ensure this by prefixing each packet that might contain
2342  * user data with an SSH_MSG_IGNORE.  This is done using the deferral
2343  * mechanism, so in this case send_noqueue() ends up redirecting to
2344  * defer_noqueue().  If you don't like this inefficiency, don't use
2345  * CBC.
2346  */
2347
2348 static void ssh2_pkt_defer_noqueue(Ssh, struct Packet *, int);
2349 static void ssh_pkt_defersend(Ssh);
2350
2351 /*
2352  * Send an SSH-2 packet immediately, without queuing or deferring.
2353  */
2354 static void ssh2_pkt_send_noqueue(Ssh ssh, struct Packet *pkt)
2355 {
2356     int len;
2357     int backlog;
2358     if (ssh->cscipher != NULL && (ssh->cscipher->flags & SSH_CIPHER_IS_CBC)) {
2359         /* We need to send two packets, so use the deferral mechanism. */
2360         ssh2_pkt_defer_noqueue(ssh, pkt, FALSE);
2361         ssh_pkt_defersend(ssh);
2362         return;
2363     }
2364     len = ssh2_pkt_construct(ssh, pkt);
2365     backlog = s_write(ssh, pkt->body, len);
2366     if (backlog > SSH_MAX_BACKLOG)
2367         ssh_throttle_all(ssh, 1, backlog);
2368
2369     ssh->outgoing_data_size += pkt->encrypted_len;
2370     if (!ssh->kex_in_progress &&
2371         !ssh->bare_connection &&
2372         ssh->max_data_size != 0 &&
2373         ssh->outgoing_data_size > ssh->max_data_size)
2374         do_ssh2_transport(ssh, "too much data sent", -1, NULL);
2375
2376     ssh_free_packet(pkt);
2377 }
2378
2379 /*
2380  * Defer an SSH-2 packet.
2381  */
2382 static void ssh2_pkt_defer_noqueue(Ssh ssh, struct Packet *pkt, int noignore)
2383 {
2384     int len;
2385     if (ssh->cscipher != NULL && (ssh->cscipher->flags & SSH_CIPHER_IS_CBC) &&
2386         ssh->deferred_len == 0 && !noignore &&
2387         !(ssh->remote_bugs & BUG_CHOKES_ON_SSH2_IGNORE)) {
2388         /*
2389          * Interpose an SSH_MSG_IGNORE to ensure that user data don't
2390          * get encrypted with a known IV.
2391          */
2392         struct Packet *ipkt = ssh2_pkt_init(SSH2_MSG_IGNORE);
2393         ssh2_pkt_addstring_start(ipkt);
2394         ssh2_pkt_defer_noqueue(ssh, ipkt, TRUE);
2395     }
2396     len = ssh2_pkt_construct(ssh, pkt);
2397     if (ssh->deferred_len + len > ssh->deferred_size) {
2398         ssh->deferred_size = ssh->deferred_len + len + 128;
2399         ssh->deferred_send_data = sresize(ssh->deferred_send_data,
2400                                           ssh->deferred_size,
2401                                           unsigned char);
2402     }
2403     memcpy(ssh->deferred_send_data + ssh->deferred_len, pkt->body, len);
2404     ssh->deferred_len += len;
2405     ssh->deferred_data_size += pkt->encrypted_len;
2406     ssh_free_packet(pkt);
2407 }
2408
2409 /*
2410  * Queue an SSH-2 packet.
2411  */
2412 static void ssh2_pkt_queue(Ssh ssh, struct Packet *pkt)
2413 {
2414     assert(ssh->queueing);
2415
2416     if (ssh->queuelen >= ssh->queuesize) {
2417         ssh->queuesize = ssh->queuelen + 32;
2418         ssh->queue = sresize(ssh->queue, ssh->queuesize, struct Packet *);
2419     }
2420
2421     ssh->queue[ssh->queuelen++] = pkt;
2422 }
2423
2424 /*
2425  * Either queue or send a packet, depending on whether queueing is
2426  * set.
2427  */
2428 static void ssh2_pkt_send(Ssh ssh, struct Packet *pkt)
2429 {
2430     if (ssh->queueing)
2431         ssh2_pkt_queue(ssh, pkt);
2432     else
2433         ssh2_pkt_send_noqueue(ssh, pkt);
2434 }
2435
2436 /*
2437  * Either queue or defer a packet, depending on whether queueing is
2438  * set.
2439  */
2440 static void ssh2_pkt_defer(Ssh ssh, struct Packet *pkt)
2441 {
2442     if (ssh->queueing)
2443         ssh2_pkt_queue(ssh, pkt);
2444     else
2445         ssh2_pkt_defer_noqueue(ssh, pkt, FALSE);
2446 }
2447
2448 /*
2449  * Send the whole deferred data block constructed by
2450  * ssh2_pkt_defer() or SSH-1's defer_packet().
2451  * 
2452  * The expected use of the defer mechanism is that you call
2453  * ssh2_pkt_defer() a few times, then call ssh_pkt_defersend(). If
2454  * not currently queueing, this simply sets up deferred_send_data
2455  * and then sends it. If we _are_ currently queueing, the calls to
2456  * ssh2_pkt_defer() put the deferred packets on to the queue
2457  * instead, and therefore ssh_pkt_defersend() has no deferred data
2458  * to send. Hence, there's no need to make it conditional on
2459  * ssh->queueing.
2460  */
2461 static void ssh_pkt_defersend(Ssh ssh)
2462 {
2463     int backlog;
2464     backlog = s_write(ssh, ssh->deferred_send_data, ssh->deferred_len);
2465     ssh->deferred_len = ssh->deferred_size = 0;
2466     sfree(ssh->deferred_send_data);
2467     ssh->deferred_send_data = NULL;
2468     if (backlog > SSH_MAX_BACKLOG)
2469         ssh_throttle_all(ssh, 1, backlog);
2470
2471     ssh->outgoing_data_size += ssh->deferred_data_size;
2472     if (!ssh->kex_in_progress &&
2473         !ssh->bare_connection &&
2474         ssh->max_data_size != 0 &&
2475         ssh->outgoing_data_size > ssh->max_data_size)
2476         do_ssh2_transport(ssh, "too much data sent", -1, NULL);
2477     ssh->deferred_data_size = 0;
2478 }
2479
2480 /*
2481  * Send a packet whose length needs to be disguised (typically
2482  * passwords or keyboard-interactive responses).
2483  */
2484 static void ssh2_pkt_send_with_padding(Ssh ssh, struct Packet *pkt,
2485                                        int padsize)
2486 {
2487 #if 0
2488     if (0) {
2489         /*
2490          * The simplest way to do this is to adjust the
2491          * variable-length padding field in the outgoing packet.
2492          * 
2493          * Currently compiled out, because some Cisco SSH servers
2494          * don't like excessively padded packets (bah, why's it
2495          * always Cisco?)
2496          */
2497         pkt->forcepad = padsize;
2498         ssh2_pkt_send(ssh, pkt);
2499     } else
2500 #endif
2501     {
2502         /*
2503          * If we can't do that, however, an alternative approach is
2504          * to use the pkt_defer mechanism to bundle the packet
2505          * tightly together with an SSH_MSG_IGNORE such that their
2506          * combined length is a constant. So first we construct the
2507          * final form of this packet and defer its sending.
2508          */
2509         ssh2_pkt_defer(ssh, pkt);
2510
2511         /*
2512          * Now construct an SSH_MSG_IGNORE which includes a string
2513          * that's an exact multiple of the cipher block size. (If
2514          * the cipher is NULL so that the block size is
2515          * unavailable, we don't do this trick at all, because we
2516          * gain nothing by it.)
2517          */
2518         if (ssh->cscipher &&
2519             !(ssh->remote_bugs & BUG_CHOKES_ON_SSH2_IGNORE)) {
2520             int stringlen, i;
2521
2522             stringlen = (256 - ssh->deferred_len);
2523             stringlen += ssh->cscipher->blksize - 1;
2524             stringlen -= (stringlen % ssh->cscipher->blksize);
2525             if (ssh->cscomp) {
2526                 /*
2527                  * Temporarily disable actual compression, so we
2528                  * can guarantee to get this string exactly the
2529                  * length we want it. The compression-disabling
2530                  * routine should return an integer indicating how
2531                  * many bytes we should adjust our string length
2532                  * by.
2533                  */
2534                 stringlen -=
2535                     ssh->cscomp->disable_compression(ssh->cs_comp_ctx);
2536             }
2537             pkt = ssh2_pkt_init(SSH2_MSG_IGNORE);
2538             ssh2_pkt_addstring_start(pkt);
2539             for (i = 0; i < stringlen; i++) {
2540                 char c = (char) random_byte();
2541                 ssh2_pkt_addstring_data(pkt, &c, 1);
2542             }
2543             ssh2_pkt_defer(ssh, pkt);
2544         }
2545         ssh_pkt_defersend(ssh);
2546     }
2547 }
2548
2549 /*
2550  * Send all queued SSH-2 packets. We send them by means of
2551  * ssh2_pkt_defer_noqueue(), in case they included a pair of
2552  * packets that needed to be lumped together.
2553  */
2554 static void ssh2_pkt_queuesend(Ssh ssh)
2555 {
2556     int i;
2557
2558     assert(!ssh->queueing);
2559
2560     for (i = 0; i < ssh->queuelen; i++)
2561         ssh2_pkt_defer_noqueue(ssh, ssh->queue[i], FALSE);
2562     ssh->queuelen = 0;
2563
2564     ssh_pkt_defersend(ssh);
2565 }
2566
2567 #if 0
2568 void bndebug(char *string, Bignum b)
2569 {
2570     unsigned char *p;
2571     int i, len;
2572     p = ssh2_mpint_fmt(b, &len);
2573     debug(("%s", string));
2574     for (i = 0; i < len; i++)
2575         debug((" %02x", p[i]));
2576     debug(("\n"));
2577     sfree(p);
2578 }
2579 #endif
2580
2581 static void hash_mpint(const struct ssh_hash *h, void *s, Bignum b)
2582 {
2583     unsigned char *p;
2584     int len;
2585     p = ssh2_mpint_fmt(b, &len);
2586     hash_string(h, s, p, len);
2587     sfree(p);
2588 }
2589
2590 /*
2591  * Packet decode functions for both SSH-1 and SSH-2.
2592  */
2593 static unsigned long ssh_pkt_getuint32(struct Packet *pkt)
2594 {
2595     unsigned long value;
2596     if (pkt->length - pkt->savedpos < 4)
2597         return 0;                      /* arrgh, no way to decline (FIXME?) */
2598     value = GET_32BIT(pkt->body + pkt->savedpos);
2599     pkt->savedpos += 4;
2600     return value;
2601 }
2602 static int ssh2_pkt_getbool(struct Packet *pkt)
2603 {
2604     unsigned long value;
2605     if (pkt->length - pkt->savedpos < 1)
2606         return 0;                      /* arrgh, no way to decline (FIXME?) */
2607     value = pkt->body[pkt->savedpos] != 0;
2608     pkt->savedpos++;
2609     return value;
2610 }
2611 static void ssh_pkt_getstring(struct Packet *pkt, char **p, int *length)
2612 {
2613     int len;
2614     *p = NULL;
2615     *length = 0;
2616     if (pkt->length - pkt->savedpos < 4)
2617         return;
2618     len = toint(GET_32BIT(pkt->body + pkt->savedpos));
2619     if (len < 0)
2620         return;
2621     *length = len;
2622     pkt->savedpos += 4;
2623     if (pkt->length - pkt->savedpos < *length)
2624         return;
2625     *p = (char *)(pkt->body + pkt->savedpos);
2626     pkt->savedpos += *length;
2627 }
2628 static void *ssh_pkt_getdata(struct Packet *pkt, int length)
2629 {
2630     if (pkt->length - pkt->savedpos < length)
2631         return NULL;
2632     pkt->savedpos += length;
2633     return pkt->body + (pkt->savedpos - length);
2634 }
2635 static int ssh1_pkt_getrsakey(struct Packet *pkt, struct RSAKey *key,
2636                               const unsigned char **keystr)
2637 {
2638     int j;
2639
2640     j = makekey(pkt->body + pkt->savedpos,
2641                 pkt->length - pkt->savedpos,
2642                 key, keystr, 0);
2643
2644     if (j < 0)
2645         return FALSE;
2646     
2647     pkt->savedpos += j;
2648     assert(pkt->savedpos < pkt->length);
2649
2650     return TRUE;
2651 }
2652 static Bignum ssh1_pkt_getmp(struct Packet *pkt)
2653 {
2654     int j;
2655     Bignum b;
2656
2657     j = ssh1_read_bignum(pkt->body + pkt->savedpos,
2658                          pkt->length - pkt->savedpos, &b);
2659
2660     if (j < 0)
2661         return NULL;
2662
2663     pkt->savedpos += j;
2664     return b;
2665 }
2666 static Bignum ssh2_pkt_getmp(struct Packet *pkt)
2667 {
2668     char *p;
2669     int length;
2670     Bignum b;
2671
2672     ssh_pkt_getstring(pkt, &p, &length);
2673     if (!p)
2674         return NULL;
2675     if (p[0] & 0x80)
2676         return NULL;
2677     b = bignum_from_bytes((unsigned char *)p, length);
2678     return b;
2679 }
2680
2681 /*
2682  * Helper function to add an SSH-2 signature blob to a packet.
2683  * Expects to be shown the public key blob as well as the signature
2684  * blob. Normally works just like ssh2_pkt_addstring, but will
2685  * fiddle with the signature packet if necessary for
2686  * BUG_SSH2_RSA_PADDING.
2687  */
2688 static void ssh2_add_sigblob(Ssh ssh, struct Packet *pkt,
2689                              void *pkblob_v, int pkblob_len,
2690                              void *sigblob_v, int sigblob_len)
2691 {
2692     unsigned char *pkblob = (unsigned char *)pkblob_v;
2693     unsigned char *sigblob = (unsigned char *)sigblob_v;
2694
2695     /* dmemdump(pkblob, pkblob_len); */
2696     /* dmemdump(sigblob, sigblob_len); */
2697
2698     /*
2699      * See if this is in fact an ssh-rsa signature and a buggy
2700      * server; otherwise we can just do this the easy way.
2701      */
2702     if ((ssh->remote_bugs & BUG_SSH2_RSA_PADDING) && pkblob_len > 4+7+4 &&
2703         (GET_32BIT(pkblob) == 7 && !memcmp(pkblob+4, "ssh-rsa", 7))) {
2704         int pos, len, siglen;
2705
2706         /*
2707          * Find the byte length of the modulus.
2708          */
2709
2710         pos = 4+7;                     /* skip over "ssh-rsa" */
2711         len = toint(GET_32BIT(pkblob+pos)); /* get length of exponent */
2712         if (len < 0 || len > pkblob_len - pos - 4)
2713             goto give_up;
2714         pos += 4 + len;                /* skip over exponent */
2715         if (pkblob_len - pos < 4)
2716             goto give_up;
2717         len = toint(GET_32BIT(pkblob+pos)); /* find length of modulus */
2718         if (len < 0 || len > pkblob_len - pos - 4)
2719             goto give_up;
2720         pos += 4;                      /* find modulus itself */
2721         while (len > 0 && pkblob[pos] == 0)
2722             len--, pos++;
2723         /* debug(("modulus length is %d\n", len)); */
2724
2725         /*
2726          * Now find the signature integer.
2727          */
2728         pos = 4+7;                     /* skip over "ssh-rsa" */
2729         if (sigblob_len < pos+4)
2730             goto give_up;
2731         siglen = toint(GET_32BIT(sigblob+pos));
2732         if (siglen != sigblob_len - pos - 4)
2733             goto give_up;
2734         /* debug(("signature length is %d\n", siglen)); */
2735
2736         if (len != siglen) {
2737             unsigned char newlen[4];
2738             ssh2_pkt_addstring_start(pkt);
2739             ssh2_pkt_addstring_data(pkt, (char *)sigblob, pos);
2740             /* dmemdump(sigblob, pos); */
2741             pos += 4;                  /* point to start of actual sig */
2742             PUT_32BIT(newlen, len);
2743             ssh2_pkt_addstring_data(pkt, (char *)newlen, 4);
2744             /* dmemdump(newlen, 4); */
2745             newlen[0] = 0;
2746             while (len-- > siglen) {
2747                 ssh2_pkt_addstring_data(pkt, (char *)newlen, 1);
2748                 /* dmemdump(newlen, 1); */
2749             }
2750             ssh2_pkt_addstring_data(pkt, (char *)(sigblob+pos), siglen);
2751             /* dmemdump(sigblob+pos, siglen); */
2752             return;
2753         }
2754
2755         /* Otherwise fall through and do it the easy way. We also come
2756          * here as a fallback if we discover above that the key blob
2757          * is misformatted in some way. */
2758       give_up:;
2759     }
2760
2761     ssh2_pkt_addstring_start(pkt);
2762     ssh2_pkt_addstring_data(pkt, (char *)sigblob, sigblob_len);
2763 }
2764
2765 /*
2766  * Examine the remote side's version string and compare it against
2767  * a list of known buggy implementations.
2768  */
2769 static void ssh_detect_bugs(Ssh ssh, char *vstring)
2770 {
2771     char *imp;                         /* pointer to implementation part */
2772     imp = vstring;
2773     imp += strcspn(imp, "-");
2774     if (*imp) imp++;
2775     imp += strcspn(imp, "-");
2776     if (*imp) imp++;
2777
2778     ssh->remote_bugs = 0;
2779
2780     /*
2781      * General notes on server version strings:
2782      *  - Not all servers reporting "Cisco-1.25" have all the bugs listed
2783      *    here -- in particular, we've heard of one that's perfectly happy
2784      *    with SSH1_MSG_IGNOREs -- but this string never seems to change,
2785      *    so we can't distinguish them.
2786      */
2787     if (conf_get_int(ssh->conf, CONF_sshbug_ignore1) == FORCE_ON ||
2788         (conf_get_int(ssh->conf, CONF_sshbug_ignore1) == AUTO &&
2789          (!strcmp(imp, "1.2.18") || !strcmp(imp, "1.2.19") ||
2790           !strcmp(imp, "1.2.20") || !strcmp(imp, "1.2.21") ||
2791           !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25") ||
2792           !strcmp(imp, "OSU_1.4alpha3") || !strcmp(imp, "OSU_1.5alpha4")))) {
2793         /*
2794          * These versions don't support SSH1_MSG_IGNORE, so we have
2795          * to use a different defence against password length
2796          * sniffing.
2797          */
2798         ssh->remote_bugs |= BUG_CHOKES_ON_SSH1_IGNORE;
2799         logevent("We believe remote version has SSH-1 ignore bug");
2800     }
2801
2802     if (conf_get_int(ssh->conf, CONF_sshbug_plainpw1) == FORCE_ON ||
2803         (conf_get_int(ssh->conf, CONF_sshbug_plainpw1) == AUTO &&
2804          (!strcmp(imp, "Cisco-1.25") || !strcmp(imp, "OSU_1.4alpha3")))) {
2805         /*
2806          * These versions need a plain password sent; they can't
2807          * handle having a null and a random length of data after
2808          * the password.
2809          */
2810         ssh->remote_bugs |= BUG_NEEDS_SSH1_PLAIN_PASSWORD;
2811         logevent("We believe remote version needs a plain SSH-1 password");
2812     }
2813
2814     if (conf_get_int(ssh->conf, CONF_sshbug_rsa1) == FORCE_ON ||
2815         (conf_get_int(ssh->conf, CONF_sshbug_rsa1) == AUTO &&
2816          (!strcmp(imp, "Cisco-1.25")))) {
2817         /*
2818          * These versions apparently have no clue whatever about
2819          * RSA authentication and will panic and die if they see
2820          * an AUTH_RSA message.
2821          */
2822         ssh->remote_bugs |= BUG_CHOKES_ON_RSA;
2823         logevent("We believe remote version can't handle SSH-1 RSA authentication");
2824     }
2825
2826     if (conf_get_int(ssh->conf, CONF_sshbug_hmac2) == FORCE_ON ||
2827         (conf_get_int(ssh->conf, CONF_sshbug_hmac2) == AUTO &&
2828          !wc_match("* VShell", imp) &&
2829          (wc_match("2.1.0*", imp) || wc_match("2.0.*", imp) ||
2830           wc_match("2.2.0*", imp) || wc_match("2.3.0*", imp) ||
2831           wc_match("2.1 *", imp)))) {
2832         /*
2833          * These versions have the HMAC bug.
2834          */
2835         ssh->remote_bugs |= BUG_SSH2_HMAC;
2836         logevent("We believe remote version has SSH-2 HMAC bug");
2837     }
2838
2839     if (conf_get_int(ssh->conf, CONF_sshbug_derivekey2) == FORCE_ON ||
2840         (conf_get_int(ssh->conf, CONF_sshbug_derivekey2) == AUTO &&
2841          !wc_match("* VShell", imp) &&
2842          (wc_match("2.0.0*", imp) || wc_match("2.0.10*", imp) ))) {
2843         /*
2844          * These versions have the key-derivation bug (failing to
2845          * include the literal shared secret in the hashes that
2846          * generate the keys).
2847          */
2848         ssh->remote_bugs |= BUG_SSH2_DERIVEKEY;
2849         logevent("We believe remote version has SSH-2 key-derivation bug");
2850     }
2851
2852     if (conf_get_int(ssh->conf, CONF_sshbug_rsapad2) == FORCE_ON ||
2853         (conf_get_int(ssh->conf, CONF_sshbug_rsapad2) == AUTO &&
2854          (wc_match("OpenSSH_2.[5-9]*", imp) ||
2855           wc_match("OpenSSH_3.[0-2]*", imp) ||
2856           wc_match("mod_sftp/0.[0-8]*", imp) ||
2857           wc_match("mod_sftp/0.9.[0-8]", imp)))) {
2858         /*
2859          * These versions have the SSH-2 RSA padding bug.
2860          */
2861         ssh->remote_bugs |= BUG_SSH2_RSA_PADDING;
2862         logevent("We believe remote version has SSH-2 RSA padding bug");
2863     }
2864
2865     if (conf_get_int(ssh->conf, CONF_sshbug_pksessid2) == FORCE_ON ||
2866         (conf_get_int(ssh->conf, CONF_sshbug_pksessid2) == AUTO &&
2867          wc_match("OpenSSH_2.[0-2]*", imp))) {
2868         /*
2869          * These versions have the SSH-2 session-ID bug in
2870          * public-key authentication.
2871          */
2872         ssh->remote_bugs |= BUG_SSH2_PK_SESSIONID;
2873         logevent("We believe remote version has SSH-2 public-key-session-ID bug");
2874     }
2875
2876     if (conf_get_int(ssh->conf, CONF_sshbug_rekey2) == FORCE_ON ||
2877         (conf_get_int(ssh->conf, CONF_sshbug_rekey2) == AUTO &&
2878          (wc_match("DigiSSH_2.0", imp) ||
2879           wc_match("OpenSSH_2.[0-4]*", imp) ||
2880           wc_match("OpenSSH_2.5.[0-3]*", imp) ||
2881           wc_match("Sun_SSH_1.0", imp) ||
2882           wc_match("Sun_SSH_1.0.1", imp) ||
2883           /* All versions <= 1.2.6 (they changed their format in 1.2.7) */
2884           wc_match("WeOnlyDo-*", imp)))) {
2885         /*
2886          * These versions have the SSH-2 rekey bug.
2887          */
2888         ssh->remote_bugs |= BUG_SSH2_REKEY;
2889         logevent("We believe remote version has SSH-2 rekey bug");
2890     }
2891
2892     if (conf_get_int(ssh->conf, CONF_sshbug_maxpkt2) == FORCE_ON ||
2893         (conf_get_int(ssh->conf, CONF_sshbug_maxpkt2) == AUTO &&
2894          (wc_match("1.36_sshlib GlobalSCAPE", imp) ||
2895           wc_match("1.36 sshlib: GlobalScape", imp)))) {
2896         /*
2897          * This version ignores our makpkt and needs to be throttled.
2898          */
2899         ssh->remote_bugs |= BUG_SSH2_MAXPKT;
2900         logevent("We believe remote version ignores SSH-2 maximum packet size");
2901     }
2902
2903     if (conf_get_int(ssh->conf, CONF_sshbug_ignore2) == FORCE_ON) {
2904         /*
2905          * Servers that don't support SSH2_MSG_IGNORE. Currently,
2906          * none detected automatically.
2907          */
2908         ssh->remote_bugs |= BUG_CHOKES_ON_SSH2_IGNORE;
2909         logevent("We believe remote version has SSH-2 ignore bug");
2910     }
2911
2912     if (conf_get_int(ssh->conf, CONF_sshbug_oldgex2) == FORCE_ON ||
2913         (conf_get_int(ssh->conf, CONF_sshbug_oldgex2) == AUTO &&
2914          (wc_match("OpenSSH_2.[235]*", imp)))) {
2915         /*
2916          * These versions only support the original (pre-RFC4419)
2917          * SSH-2 GEX request, and disconnect with a protocol error if
2918          * we use the newer version.
2919          */
2920         ssh->remote_bugs |= BUG_SSH2_OLDGEX;
2921         logevent("We believe remote version has outdated SSH-2 GEX");
2922     }
2923
2924     if (conf_get_int(ssh->conf, CONF_sshbug_winadj) == FORCE_ON) {
2925         /*
2926          * Servers that don't support our winadj request for one
2927          * reason or another. Currently, none detected automatically.
2928          */
2929         ssh->remote_bugs |= BUG_CHOKES_ON_WINADJ;
2930         logevent("We believe remote version has winadj bug");
2931     }
2932
2933     if (conf_get_int(ssh->conf, CONF_sshbug_chanreq) == FORCE_ON ||
2934         (conf_get_int(ssh->conf, CONF_sshbug_chanreq) == AUTO &&
2935          (wc_match("OpenSSH_[2-5].*", imp) ||
2936           wc_match("OpenSSH_6.[0-6]*", imp) ||
2937           wc_match("dropbear_0.[2-4][0-9]*", imp) ||
2938           wc_match("dropbear_0.5[01]*", imp)))) {
2939         /*
2940          * These versions have the SSH-2 channel request bug.
2941          * OpenSSH 6.7 and above do not:
2942          * https://bugzilla.mindrot.org/show_bug.cgi?id=1818
2943          * dropbear_0.52 and above do not:
2944          * https://secure.ucc.asn.au/hg/dropbear/rev/cd02449b709c
2945          */
2946         ssh->remote_bugs |= BUG_SENDS_LATE_REQUEST_REPLY;
2947         logevent("We believe remote version has SSH-2 channel request bug");
2948     }
2949 }
2950
2951 /*
2952  * The `software version' part of an SSH version string is required
2953  * to contain no spaces or minus signs.
2954  */
2955 static void ssh_fix_verstring(char *str)
2956 {
2957     /* Eat "<protoversion>-". */
2958     while (*str && *str != '-') str++;
2959     assert(*str == '-'); str++;
2960
2961     /* Convert minus signs and spaces in the remaining string into
2962      * underscores. */
2963     while (*str) {
2964         if (*str == '-' || *str == ' ')
2965             *str = '_';
2966         str++;
2967     }
2968 }
2969
2970 /*
2971  * Send an appropriate SSH version string.
2972  */
2973 static void ssh_send_verstring(Ssh ssh, const char *protoname, char *svers)
2974 {
2975     char *verstring;
2976
2977     if (ssh->version == 2) {
2978         /*
2979          * Construct a v2 version string.
2980          */
2981         verstring = dupprintf("%s2.0-%s\015\012", protoname, sshver);
2982     } else {
2983         /*
2984          * Construct a v1 version string.
2985          */
2986         assert(!strcmp(protoname, "SSH-")); /* no v1 bare connection protocol */
2987         verstring = dupprintf("SSH-%s-%s\012",
2988                               (ssh_versioncmp(svers, "1.5") <= 0 ?
2989                                svers : "1.5"),
2990                               sshver);
2991     }
2992
2993     ssh_fix_verstring(verstring + strlen(protoname));
2994
2995     if (ssh->version == 2) {
2996         size_t len;
2997         /*
2998          * Record our version string.
2999          */
3000         len = strcspn(verstring, "\015\012");
3001         ssh->v_c = snewn(len + 1, char);
3002         memcpy(ssh->v_c, verstring, len);
3003         ssh->v_c[len] = 0;
3004     }
3005
3006     logeventf(ssh, "We claim version: %.*s",
3007               strcspn(verstring, "\015\012"), verstring);
3008     s_write(ssh, verstring, strlen(verstring));
3009     sfree(verstring);
3010 }
3011
3012 static int do_ssh_init(Ssh ssh, unsigned char c)
3013 {
3014     static const char protoname[] = "SSH-";
3015
3016     struct do_ssh_init_state {
3017         int crLine;
3018         int vslen;
3019         char version[10];
3020         char *vstring;
3021         int vstrsize;
3022         int i;
3023         int proto1, proto2;
3024     };
3025     crState(do_ssh_init_state);
3026     
3027     crBeginState;
3028
3029     /* Search for a line beginning with the protocol name prefix in
3030      * the input. */
3031     for (;;) {
3032         for (s->i = 0; protoname[s->i]; s->i++) {
3033             if ((char)c != protoname[s->i]) goto no;
3034             crReturn(1);
3035         }
3036         break;
3037       no:
3038         while (c != '\012')
3039             crReturn(1);
3040         crReturn(1);
3041     }
3042
3043     s->vstrsize = sizeof(protoname) + 16;
3044     s->vstring = snewn(s->vstrsize, char);
3045     strcpy(s->vstring, protoname);
3046     s->vslen = strlen(protoname);
3047     s->i = 0;
3048     while (1) {
3049         if (s->vslen >= s->vstrsize - 1) {
3050             s->vstrsize += 16;
3051             s->vstring = sresize(s->vstring, s->vstrsize, char);
3052         }
3053         s->vstring[s->vslen++] = c;
3054         if (s->i >= 0) {
3055             if (c == '-') {
3056                 s->version[s->i] = '\0';
3057                 s->i = -1;
3058             } else if (s->i < sizeof(s->version) - 1)
3059                 s->version[s->i++] = c;
3060         } else if (c == '\012')
3061             break;
3062         crReturn(1);                   /* get another char */
3063     }
3064
3065     ssh->agentfwd_enabled = FALSE;
3066     ssh->rdpkt2_state.incoming_sequence = 0;
3067
3068     s->vstring[s->vslen] = 0;
3069     s->vstring[strcspn(s->vstring, "\015\012")] = '\0';/* remove EOL chars */
3070     logeventf(ssh, "Server version: %s", s->vstring);
3071     ssh_detect_bugs(ssh, s->vstring);
3072
3073     /*
3074      * Decide which SSH protocol version to support.
3075      */
3076
3077     /* Anything strictly below "2.0" means protocol 1 is supported. */
3078     s->proto1 = ssh_versioncmp(s->version, "2.0") < 0;
3079     /* Anything greater or equal to "1.99" means protocol 2 is supported. */
3080     s->proto2 = ssh_versioncmp(s->version, "1.99") >= 0;
3081
3082     if (conf_get_int(ssh->conf, CONF_sshprot) == 0 && !s->proto1) {
3083         bombout(("SSH protocol version 1 required by configuration but "
3084                  "not provided by server"));
3085         crStop(0);
3086     }
3087     if (conf_get_int(ssh->conf, CONF_sshprot) == 3 && !s->proto2) {
3088         bombout(("SSH protocol version 2 required by configuration but "
3089                  "not provided by server"));
3090         crStop(0);
3091     }
3092
3093     if (s->proto2 && (conf_get_int(ssh->conf, CONF_sshprot) >= 2 || !s->proto1))
3094         ssh->version = 2;
3095     else
3096         ssh->version = 1;
3097
3098     logeventf(ssh, "Using SSH protocol version %d", ssh->version);
3099
3100     /* Send the version string, if we haven't already */
3101     if (conf_get_int(ssh->conf, CONF_sshprot) != 3)
3102         ssh_send_verstring(ssh, protoname, s->version);
3103
3104     if (ssh->version == 2) {
3105         size_t len;
3106         /*
3107          * Record their version string.
3108          */
3109         len = strcspn(s->vstring, "\015\012");
3110         ssh->v_s = snewn(len + 1, char);
3111         memcpy(ssh->v_s, s->vstring, len);
3112         ssh->v_s[len] = 0;
3113             
3114         /*
3115          * Initialise SSH-2 protocol.
3116          */
3117         ssh->protocol = ssh2_protocol;
3118         ssh2_protocol_setup(ssh);
3119         ssh->s_rdpkt = ssh2_rdpkt;
3120     } else {
3121         /*
3122          * Initialise SSH-1 protocol.
3123          */
3124         ssh->protocol = ssh1_protocol;
3125         ssh1_protocol_setup(ssh);
3126         ssh->s_rdpkt = ssh1_rdpkt;
3127     }
3128     if (ssh->version == 2)
3129         do_ssh2_transport(ssh, NULL, -1, NULL);
3130
3131     update_specials_menu(ssh->frontend);
3132     ssh->state = SSH_STATE_BEFORE_SIZE;
3133     ssh->pinger = pinger_new(ssh->conf, &ssh_backend, ssh);
3134
3135     sfree(s->vstring);
3136
3137     crFinish(0);
3138 }
3139
3140 static int do_ssh_connection_init(Ssh ssh, unsigned char c)
3141 {
3142     /*
3143      * Ordinary SSH begins with the banner "SSH-x.y-...". This is just
3144      * the ssh-connection part, extracted and given a trivial binary
3145      * packet protocol, so we replace 'SSH-' at the start with a new
3146      * name. In proper SSH style (though of course this part of the
3147      * proper SSH protocol _isn't_ subject to this kind of
3148      * DNS-domain-based extension), we define the new name in our
3149      * extension space.
3150      */
3151     static const char protoname[] =
3152         "SSHCONNECTION@putty.projects.tartarus.org-";
3153
3154     struct do_ssh_connection_init_state {
3155         int crLine;
3156         int vslen;
3157         char version[10];
3158         char *vstring;
3159         int vstrsize;
3160         int i;
3161     };
3162     crState(do_ssh_connection_init_state);
3163     
3164     crBeginState;
3165
3166     /* Search for a line beginning with the protocol name prefix in
3167      * the input. */
3168     for (;;) {
3169         for (s->i = 0; protoname[s->i]; s->i++) {
3170             if ((char)c != protoname[s->i]) goto no;
3171             crReturn(1);
3172         }
3173         break;
3174       no:
3175         while (c != '\012')
3176             crReturn(1);
3177         crReturn(1);
3178     }
3179
3180     s->vstrsize = sizeof(protoname) + 16;
3181     s->vstring = snewn(s->vstrsize, char);
3182     strcpy(s->vstring, protoname);
3183     s->vslen = strlen(protoname);
3184     s->i = 0;
3185     while (1) {
3186         if (s->vslen >= s->vstrsize - 1) {
3187             s->vstrsize += 16;
3188             s->vstring = sresize(s->vstring, s->vstrsize, char);
3189         }
3190         s->vstring[s->vslen++] = c;
3191         if (s->i >= 0) {
3192             if (c == '-') {
3193                 s->version[s->i] = '\0';
3194                 s->i = -1;
3195             } else if (s->i < sizeof(s->version) - 1)
3196                 s->version[s->i++] = c;
3197         } else if (c == '\012')
3198             break;
3199         crReturn(1);                   /* get another char */
3200     }
3201
3202     ssh->agentfwd_enabled = FALSE;
3203     ssh->rdpkt2_bare_state.incoming_sequence = 0;
3204
3205     s->vstring[s->vslen] = 0;
3206     s->vstring[strcspn(s->vstring, "\015\012")] = '\0';/* remove EOL chars */
3207     logeventf(ssh, "Server version: %s", s->vstring);
3208     ssh_detect_bugs(ssh, s->vstring);
3209
3210     /*
3211      * Decide which SSH protocol version to support. This is easy in
3212      * bare ssh-connection mode: only 2.0 is legal.
3213      */
3214     if (ssh_versioncmp(s->version, "2.0") < 0) {
3215         bombout(("Server announces compatibility with SSH-1 in bare ssh-connection protocol"));
3216         crStop(0);
3217     }
3218     if (conf_get_int(ssh->conf, CONF_sshprot) == 0) {
3219         bombout(("Bare ssh-connection protocol cannot be run in SSH-1-only mode"));
3220         crStop(0);
3221     }
3222
3223     ssh->version = 2;
3224
3225     logeventf(ssh, "Using bare ssh-connection protocol");
3226
3227     /* Send the version string, if we haven't already */
3228     ssh_send_verstring(ssh, protoname, s->version);
3229
3230     /*
3231      * Initialise bare connection protocol.
3232      */
3233     ssh->protocol = ssh2_bare_connection_protocol;
3234     ssh2_bare_connection_protocol_setup(ssh);
3235     ssh->s_rdpkt = ssh2_bare_connection_rdpkt;
3236
3237     update_specials_menu(ssh->frontend);
3238     ssh->state = SSH_STATE_BEFORE_SIZE;
3239     ssh->pinger = pinger_new(ssh->conf, &ssh_backend, ssh);
3240
3241     /*
3242      * Get authconn (really just conn) under way.
3243      */
3244     do_ssh2_authconn(ssh, NULL, 0, NULL);
3245
3246     sfree(s->vstring);
3247
3248     crFinish(0);
3249 }
3250
3251 static void ssh_process_incoming_data(Ssh ssh,
3252                                       const unsigned char **data, int *datalen)
3253 {
3254     struct Packet *pktin;
3255
3256     pktin = ssh->s_rdpkt(ssh, data, datalen);
3257     if (pktin) {
3258         ssh->protocol(ssh, NULL, 0, pktin);
3259         ssh_free_packet(pktin);
3260     }
3261 }
3262
3263 static void ssh_queue_incoming_data(Ssh ssh,
3264                                     const unsigned char **data, int *datalen)
3265 {
3266     bufchain_add(&ssh->queued_incoming_data, *data, *datalen);
3267     *data += *datalen;
3268     *datalen = 0;
3269 }
3270
3271 static void ssh_process_queued_incoming_data(Ssh ssh)
3272 {
3273     void *vdata;
3274     const unsigned char *data;
3275     int len, origlen;
3276
3277     while (!ssh->frozen && bufchain_size(&ssh->queued_incoming_data)) {
3278         bufchain_prefix(&ssh->queued_incoming_data, &vdata, &len);
3279         data = vdata;
3280         origlen = len;
3281
3282         while (!ssh->frozen && len > 0)
3283             ssh_process_incoming_data(ssh, &data, &len);
3284
3285         if (origlen > len)
3286             bufchain_consume(&ssh->queued_incoming_data, origlen - len);
3287     }
3288 }
3289
3290 static void ssh_set_frozen(Ssh ssh, int frozen)
3291 {
3292     if (ssh->s)
3293         sk_set_frozen(ssh->s, frozen);
3294     ssh->frozen = frozen;
3295 }
3296
3297 static void ssh_gotdata(Ssh ssh, const unsigned char *data, int datalen)
3298 {
3299     /* Log raw data, if we're in that mode. */
3300     if (ssh->logctx)
3301         log_packet(ssh->logctx, PKT_INCOMING, -1, NULL, data, datalen,
3302                    0, NULL, NULL, 0, NULL);
3303
3304     crBegin(ssh->ssh_gotdata_crstate);
3305
3306     /*
3307      * To begin with, feed the characters one by one to the
3308      * protocol initialisation / selection function do_ssh_init().
3309      * When that returns 0, we're done with the initial greeting
3310      * exchange and can move on to packet discipline.
3311      */
3312     while (1) {
3313         int ret;                       /* need not be kept across crReturn */
3314         if (datalen == 0)
3315             crReturnV;                 /* more data please */
3316         ret = ssh->do_ssh_init(ssh, *data);
3317         data++;
3318         datalen--;
3319         if (ret == 0)
3320             break;
3321     }
3322
3323     /*
3324      * We emerge from that loop when the initial negotiation is
3325      * over and we have selected an s_rdpkt function. Now pass
3326      * everything to s_rdpkt, and then pass the resulting packets
3327      * to the proper protocol handler.
3328      */
3329
3330     while (1) {
3331         while (bufchain_size(&ssh->queued_incoming_data) > 0 || datalen > 0) {
3332             if (ssh->frozen) {
3333                 ssh_queue_incoming_data(ssh, &data, &datalen);
3334                 /* This uses up all data and cannot cause anything interesting
3335                  * to happen; indeed, for anything to happen at all, we must
3336                  * return, so break out. */
3337                 break;
3338             } else if (bufchain_size(&ssh->queued_incoming_data) > 0) {
3339                 /* This uses up some or all data, and may freeze the
3340                  * session. */
3341                 ssh_process_queued_incoming_data(ssh);
3342             } else {
3343                 /* This uses up some or all data, and may freeze the
3344                  * session. */
3345                 ssh_process_incoming_data(ssh, &data, &datalen);
3346             }
3347             /* FIXME this is probably EBW. */
3348             if (ssh->state == SSH_STATE_CLOSED)
3349                 return;
3350         }
3351         /* We're out of data. Go and get some more. */
3352         crReturnV;
3353     }
3354     crFinishV;
3355 }
3356
3357 static int ssh_do_close(Ssh ssh, int notify_exit)
3358 {
3359     int ret = 0;
3360     struct ssh_channel *c;
3361
3362     ssh->state = SSH_STATE_CLOSED;
3363     expire_timer_context(ssh);
3364     if (ssh->s) {
3365         sk_close(ssh->s);
3366         ssh->s = NULL;
3367         if (notify_exit)
3368             notify_remote_exit(ssh->frontend);
3369         else
3370             ret = 1;
3371     }
3372     /*
3373      * Now we must shut down any port- and X-forwarded channels going
3374      * through this connection.
3375      */
3376     if (ssh->channels) {
3377         while (NULL != (c = index234(ssh->channels, 0))) {
3378             switch (c->type) {
3379               case CHAN_X11:
3380                 x11_close(c->u.x11.xconn);
3381                 break;
3382               case CHAN_SOCKDATA:
3383               case CHAN_SOCKDATA_DORMANT:
3384                 pfd_close(c->u.pfd.pf);
3385                 break;
3386             }
3387             del234(ssh->channels, c); /* moving next one to index 0 */
3388             if (ssh->version == 2)
3389                 bufchain_clear(&c->v.v2.outbuffer);
3390             sfree(c);
3391         }
3392     }
3393     /*
3394      * Go through port-forwardings, and close any associated
3395      * listening sockets.
3396      */
3397     if (ssh->portfwds) {
3398         struct ssh_portfwd *pf;
3399         while (NULL != (pf = index234(ssh->portfwds, 0))) {
3400             /* Dispose of any listening socket. */
3401             if (pf->local)
3402                 pfl_terminate(pf->local);
3403             del234(ssh->portfwds, pf); /* moving next one to index 0 */
3404             free_portfwd(pf);
3405         }
3406         freetree234(ssh->portfwds);
3407         ssh->portfwds = NULL;
3408     }
3409
3410     /*
3411      * Also stop attempting to connection-share.
3412      */
3413     if (ssh->connshare) {
3414         sharestate_free(ssh->connshare);
3415         ssh->connshare = NULL;
3416     }
3417
3418     return ret;
3419 }
3420
3421 static void ssh_socket_log(Plug plug, int type, SockAddr addr, int port,
3422                            const char *error_msg, int error_code)
3423 {
3424     Ssh ssh = (Ssh) plug;
3425     char addrbuf[256], *msg;
3426
3427     if (ssh->attempting_connshare) {
3428         /*
3429          * While we're attempting connection sharing, don't loudly log
3430          * everything that happens. Real TCP connections need to be
3431          * logged when we _start_ trying to connect, because it might
3432          * be ages before they respond if something goes wrong; but
3433          * connection sharing is local and quick to respond, and it's
3434          * sufficient to simply wait and see whether it worked
3435          * afterwards.
3436          */
3437     } else {
3438         sk_getaddr(addr, addrbuf, lenof(addrbuf));
3439
3440         if (type == 0) {
3441             if (sk_addr_needs_port(addr)) {
3442                 msg = dupprintf("Connecting to %s port %d", addrbuf, port);
3443             } else {
3444                 msg = dupprintf("Connecting to %s", addrbuf);
3445             }
3446         } else {
3447             msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg);
3448         }
3449
3450         logevent(msg);
3451         sfree(msg);
3452     }
3453 }
3454
3455 void ssh_connshare_log(Ssh ssh, int event, const char *logtext,
3456                        const char *ds_err, const char *us_err)
3457 {
3458     if (event == SHARE_NONE) {
3459         /* In this case, 'logtext' is an error message indicating a
3460          * reason why connection sharing couldn't be set up _at all_.
3461          * Failing that, ds_err and us_err indicate why we couldn't be
3462          * a downstream and an upstream respectively. */
3463         if (logtext) {
3464             logeventf(ssh, "Could not set up connection sharing: %s", logtext);
3465         } else {
3466             if (ds_err)
3467                 logeventf(ssh, "Could not set up connection sharing"
3468                           " as downstream: %s", ds_err);
3469             if (us_err)
3470                 logeventf(ssh, "Could not set up connection sharing"
3471                           " as upstream: %s", us_err);
3472         }
3473     } else if (event == SHARE_DOWNSTREAM) {
3474         /* In this case, 'logtext' is a local endpoint address */
3475         logeventf(ssh, "Using existing shared connection at %s", logtext);
3476         /* Also we should mention this in the console window to avoid
3477          * confusing users as to why this window doesn't behave the
3478          * usual way. */
3479         if ((flags & FLAG_VERBOSE) || (flags & FLAG_INTERACTIVE)) {
3480             c_write_str(ssh,"Reusing a shared connection to this server.\r\n");
3481         }
3482     } else if (event == SHARE_UPSTREAM) {
3483         /* In this case, 'logtext' is a local endpoint address too */
3484         logeventf(ssh, "Sharing this connection at %s", logtext);
3485     }
3486 }
3487
3488 static int ssh_closing(Plug plug, const char *error_msg, int error_code,
3489                        int calling_back)
3490 {
3491     Ssh ssh = (Ssh) plug;
3492     int need_notify = ssh_do_close(ssh, FALSE);
3493
3494     if (!error_msg) {
3495         if (!ssh->close_expected)
3496             error_msg = "Server unexpectedly closed network connection";
3497         else
3498             error_msg = "Server closed network connection";
3499     }
3500
3501     if (ssh->close_expected && ssh->clean_exit && ssh->exitcode < 0)
3502         ssh->exitcode = 0;
3503
3504     if (need_notify)
3505         notify_remote_exit(ssh->frontend);
3506
3507     if (error_msg)
3508         logevent(error_msg);
3509     if (!ssh->close_expected || !ssh->clean_exit)
3510         connection_fatal(ssh->frontend, "%s", error_msg);
3511     return 0;
3512 }
3513
3514 static int ssh_receive(Plug plug, int urgent, char *data, int len)
3515 {
3516     Ssh ssh = (Ssh) plug;
3517     ssh_gotdata(ssh, (unsigned char *)data, len);
3518     if (ssh->state == SSH_STATE_CLOSED) {
3519         ssh_do_close(ssh, TRUE);
3520         return 0;
3521     }
3522     return 1;
3523 }
3524
3525 static void ssh_sent(Plug plug, int bufsize)
3526 {
3527     Ssh ssh = (Ssh) plug;
3528     /*
3529      * If the send backlog on the SSH socket itself clears, we
3530      * should unthrottle the whole world if it was throttled.
3531      */
3532     if (bufsize < SSH_MAX_BACKLOG)
3533         ssh_throttle_all(ssh, 0, bufsize);
3534 }
3535
3536 /*
3537  * Connect to specified host and port.
3538  * Returns an error message, or NULL on success.
3539  * Also places the canonical host name into `realhost'. It must be
3540  * freed by the caller.
3541  */
3542 static const char *connect_to_host(Ssh ssh, const char *host, int port,
3543                                    char **realhost, int nodelay, int keepalive)
3544 {
3545     static const struct plug_function_table fn_table = {
3546         ssh_socket_log,
3547         ssh_closing,
3548         ssh_receive,
3549         ssh_sent,
3550         NULL
3551     };
3552
3553     SockAddr addr;
3554     const char *err;
3555     char *loghost;
3556     int addressfamily, sshprot;
3557     
3558     loghost = conf_get_str(ssh->conf, CONF_loghost);
3559     if (*loghost) {
3560         char *tmphost;
3561         char *colon;
3562
3563         tmphost = dupstr(loghost);
3564         ssh->savedport = 22;           /* default ssh port */
3565
3566         /*
3567          * A colon suffix on the hostname string also lets us affect
3568          * savedport. (Unless there are multiple colons, in which case
3569          * we assume this is an unbracketed IPv6 literal.)
3570          */
3571         colon = host_strrchr(tmphost, ':');
3572         if (colon && colon == host_strchr(tmphost, ':')) {
3573             *colon++ = '\0';
3574             if (*colon)
3575                 ssh->savedport = atoi(colon);
3576         }
3577
3578         ssh->savedhost = host_strduptrim(tmphost);
3579         sfree(tmphost);
3580     } else {
3581         ssh->savedhost = host_strduptrim(host);
3582         if (port < 0)
3583             port = 22;                 /* default ssh port */
3584         ssh->savedport = port;
3585     }
3586
3587     ssh->fn = &fn_table;               /* make 'ssh' usable as a Plug */
3588
3589     /*
3590      * Try connection-sharing, in case that means we don't open a
3591      * socket after all. ssh_connection_sharing_init will connect to a
3592      * previously established upstream if it can, and failing that,
3593      * establish a listening socket for _us_ to be the upstream. In
3594      * the latter case it will return NULL just as if it had done
3595      * nothing, because here we only need to care if we're a
3596      * downstream and need to do our connection setup differently.
3597      */
3598     ssh->connshare = NULL;
3599     ssh->attempting_connshare = TRUE;  /* affects socket logging behaviour */
3600     ssh->s = ssh_connection_sharing_init(ssh->savedhost, ssh->savedport,
3601                                          ssh->conf, ssh, &ssh->connshare);
3602     ssh->attempting_connshare = FALSE;
3603     if (ssh->s != NULL) {
3604         /*
3605          * We are a downstream.
3606          */
3607         ssh->bare_connection = TRUE;
3608         ssh->do_ssh_init = do_ssh_connection_init;
3609         ssh->fullhostname = NULL;
3610         *realhost = dupstr(host);      /* best we can do */
3611     } else {
3612         /*
3613          * We're not a downstream, so open a normal socket.
3614          */
3615         ssh->do_ssh_init = do_ssh_init;
3616
3617         /*
3618          * Try to find host.
3619          */
3620         addressfamily = conf_get_int(ssh->conf, CONF_addressfamily);
3621         logeventf(ssh, "Looking up host \"%s\"%s", host,
3622                   (addressfamily == ADDRTYPE_IPV4 ? " (IPv4)" :
3623                    (addressfamily == ADDRTYPE_IPV6 ? " (IPv6)" : "")));
3624         addr = name_lookup(host, port, realhost, ssh->conf, addressfamily);
3625         if ((err = sk_addr_error(addr)) != NULL) {
3626             sk_addr_free(addr);
3627             return err;
3628         }
3629         ssh->fullhostname = dupstr(*realhost);   /* save in case of GSSAPI */
3630
3631         ssh->s = new_connection(addr, *realhost, port,
3632                                 0, 1, nodelay, keepalive,
3633                                 (Plug) ssh, ssh->conf);
3634         if ((err = sk_socket_error(ssh->s)) != NULL) {
3635             ssh->s = NULL;
3636             notify_remote_exit(ssh->frontend);
3637             return err;
3638         }
3639     }
3640
3641     /*
3642      * If the SSH version number's fixed, set it now, and if it's SSH-2,
3643      * send the version string too.
3644      */
3645     sshprot = conf_get_int(ssh->conf, CONF_sshprot);
3646     if (sshprot == 0)
3647         ssh->version = 1;
3648     if (sshprot == 3 && !ssh->bare_connection) {
3649         ssh->version = 2;
3650         ssh_send_verstring(ssh, "SSH-", NULL);
3651     }
3652
3653     /*
3654      * loghost, if configured, overrides realhost.
3655      */
3656     if (*loghost) {
3657         sfree(*realhost);
3658         *realhost = dupstr(loghost);
3659     }
3660
3661     return NULL;
3662 }
3663
3664 /*
3665  * Throttle or unthrottle the SSH connection.
3666  */
3667 static void ssh_throttle_conn(Ssh ssh, int adjust)
3668 {
3669     int old_count = ssh->conn_throttle_count;
3670     ssh->conn_throttle_count += adjust;
3671     assert(ssh->conn_throttle_count >= 0);
3672     if (ssh->conn_throttle_count && !old_count) {
3673         ssh_set_frozen(ssh, 1);
3674     } else if (!ssh->conn_throttle_count && old_count) {
3675         ssh_set_frozen(ssh, 0);
3676     }
3677 }
3678
3679 /*
3680  * Throttle or unthrottle _all_ local data streams (for when sends
3681  * on the SSH connection itself back up).
3682  */
3683 static void ssh_throttle_all(Ssh ssh, int enable, int bufsize)
3684 {
3685     int i;
3686     struct ssh_channel *c;
3687
3688     if (enable == ssh->throttled_all)
3689         return;
3690     ssh->throttled_all = enable;
3691     ssh->overall_bufsize = bufsize;
3692     if (!ssh->channels)
3693         return;
3694     for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
3695         switch (c->type) {
3696           case CHAN_MAINSESSION:
3697             /*
3698              * This is treated separately, outside the switch.
3699              */
3700             break;
3701           case CHAN_X11:
3702             x11_override_throttle(c->u.x11.xconn, enable);
3703             break;
3704           case CHAN_AGENT:
3705             /* Agent channels require no buffer management. */
3706             break;
3707           case CHAN_SOCKDATA:
3708             pfd_override_throttle(c->u.pfd.pf, enable);
3709             break;
3710         }
3711     }
3712 }
3713
3714 static void ssh_agent_callback(void *sshv, void *reply, int replylen)
3715 {
3716     Ssh ssh = (Ssh) sshv;
3717
3718     ssh->agent_response = reply;
3719     ssh->agent_response_len = replylen;
3720
3721     if (ssh->version == 1)
3722         do_ssh1_login(ssh, NULL, -1, NULL);
3723     else
3724         do_ssh2_authconn(ssh, NULL, -1, NULL);
3725 }
3726
3727 static void ssh_dialog_callback(void *sshv, int ret)
3728 {
3729     Ssh ssh = (Ssh) sshv;
3730
3731     ssh->user_response = ret;
3732
3733     if (ssh->version == 1)
3734         do_ssh1_login(ssh, NULL, -1, NULL);
3735     else
3736         do_ssh2_transport(ssh, NULL, -1, NULL);
3737
3738     /*
3739      * This may have unfrozen the SSH connection, so do a
3740      * queued-data run.
3741      */
3742     ssh_process_queued_incoming_data(ssh);
3743 }
3744
3745 static void ssh_agentf_callback(void *cv, void *reply, int replylen)
3746 {
3747     struct ssh_channel *c = (struct ssh_channel *)cv;
3748     Ssh ssh = c->ssh;
3749     const void *sentreply = reply;
3750
3751     c->u.a.outstanding_requests--;
3752     if (!sentreply) {
3753         /* Fake SSH_AGENT_FAILURE. */
3754         sentreply = "\0\0\0\1\5";
3755         replylen = 5;
3756     }
3757     if (ssh->version == 2) {
3758         ssh2_add_channel_data(c, sentreply, replylen);
3759         ssh2_try_send(c);
3760     } else {
3761         send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
3762                     PKT_INT, c->remoteid,
3763                     PKT_INT, replylen,
3764                     PKT_DATA, sentreply, replylen,
3765                     PKT_END);
3766     }
3767     if (reply)
3768         sfree(reply);
3769     /*
3770      * If we've already seen an incoming EOF but haven't sent an
3771      * outgoing one, this may be the moment to send it.
3772      */
3773     if (c->u.a.outstanding_requests == 0 && (c->closes & CLOSES_RCVD_EOF))
3774         sshfwd_write_eof(c);
3775 }
3776
3777 /*
3778  * Client-initiated disconnection. Send a DISCONNECT if `wire_reason'
3779  * non-NULL, otherwise just close the connection. `client_reason' == NULL
3780  * => log `wire_reason'.
3781  */
3782 static void ssh_disconnect(Ssh ssh, const char *client_reason,
3783                            const char *wire_reason,
3784                            int code, int clean_exit)
3785 {
3786     char *error;
3787     if (!client_reason)
3788         client_reason = wire_reason;
3789     if (client_reason)
3790         error = dupprintf("Disconnected: %s", client_reason);
3791     else
3792         error = dupstr("Disconnected");
3793     if (wire_reason) {
3794         if (ssh->version == 1) {
3795             send_packet(ssh, SSH1_MSG_DISCONNECT, PKT_STR, wire_reason,
3796                         PKT_END);
3797         } else if (ssh->version == 2) {
3798             struct Packet *pktout = ssh2_pkt_init(SSH2_MSG_DISCONNECT);
3799             ssh2_pkt_adduint32(pktout, code);
3800             ssh2_pkt_addstring(pktout, wire_reason);
3801             ssh2_pkt_addstring(pktout, "en");   /* language tag */
3802             ssh2_pkt_send_noqueue(ssh, pktout);
3803         }
3804     }
3805     ssh->close_expected = TRUE;
3806     ssh->clean_exit = clean_exit;
3807     ssh_closing((Plug)ssh, error, 0, 0);
3808     sfree(error);
3809 }
3810
3811 int verify_ssh_manual_host_key(Ssh ssh, const char *fingerprint,
3812                                const struct ssh_signkey *ssh2keytype,
3813                                void *ssh2keydata)
3814 {
3815     if (!conf_get_str_nthstrkey(ssh->conf, CONF_ssh_manual_hostkeys, 0)) {
3816         return -1;                     /* no manual keys configured */
3817     }
3818
3819     if (fingerprint) {
3820         /*
3821          * The fingerprint string we've been given will have things
3822          * like 'ssh-rsa 2048' at the front of it. Strip those off and
3823          * narrow down to just the colon-separated hex block at the
3824          * end of the string.
3825          */
3826         const char *p = strrchr(fingerprint, ' ');
3827         fingerprint = p ? p+1 : fingerprint;
3828         /* Quick sanity checks, including making sure it's in lowercase */
3829         assert(strlen(fingerprint) == 16*3 - 1);
3830         assert(fingerprint[2] == ':');
3831         assert(fingerprint[strspn(fingerprint, "0123456789abcdef:")] == 0);
3832
3833         if (conf_get_str_str_opt(ssh->conf, CONF_ssh_manual_hostkeys,
3834                                  fingerprint))
3835             return 1;                  /* success */
3836     }
3837
3838     if (ssh2keydata) {
3839         /*
3840          * Construct the base64-encoded public key blob and see if
3841          * that's listed.
3842          */
3843         unsigned char *binblob;
3844         char *base64blob;
3845         int binlen, atoms, i;
3846         binblob = ssh2keytype->public_blob(ssh2keydata, &binlen);
3847         atoms = (binlen + 2) / 3;
3848         base64blob = snewn(atoms * 4 + 1, char);
3849         for (i = 0; i < atoms; i++)
3850             base64_encode_atom(binblob + 3*i, binlen - 3*i, base64blob + 4*i);
3851         base64blob[atoms * 4] = '\0';
3852         sfree(binblob);
3853         if (conf_get_str_str_opt(ssh->conf, CONF_ssh_manual_hostkeys,
3854                                  base64blob)) {
3855             sfree(base64blob);
3856             return 1;                  /* success */
3857         }
3858         sfree(base64blob);
3859     }
3860
3861     return 0;
3862 }
3863
3864 /*
3865  * Handle the key exchange and user authentication phases.
3866  */
3867 static int do_ssh1_login(Ssh ssh, const unsigned char *in, int inlen,
3868                          struct Packet *pktin)
3869 {
3870     int i, j, ret;
3871     unsigned char cookie[8], *ptr;
3872     struct MD5Context md5c;
3873     struct do_ssh1_login_state {
3874         int crLine;
3875         int len;
3876         unsigned char *rsabuf;
3877         const unsigned char *keystr1, *keystr2;
3878         unsigned long supported_ciphers_mask, supported_auths_mask;
3879         int tried_publickey, tried_agent;
3880         int tis_auth_refused, ccard_auth_refused;
3881         unsigned char session_id[16];
3882         int cipher_type;
3883         void *publickey_blob;
3884         int publickey_bloblen;
3885         char *publickey_comment;
3886         int privatekey_available, privatekey_encrypted;
3887         prompts_t *cur_prompt;
3888         char c;
3889         int pwpkt_type;
3890         unsigned char request[5], *response, *p;
3891         int responselen;
3892         int keyi, nkeys;
3893         int authed;
3894         struct RSAKey key;
3895         Bignum challenge;
3896         char *commentp;
3897         int commentlen;
3898         int dlgret;
3899         Filename *keyfile;
3900         struct RSAKey servkey, hostkey;
3901     };
3902     crState(do_ssh1_login_state);
3903
3904     crBeginState;
3905
3906     if (!pktin)
3907         crWaitUntil(pktin);
3908
3909     if (pktin->type != SSH1_SMSG_PUBLIC_KEY) {
3910         bombout(("Public key packet not received"));
3911         crStop(0);
3912     }
3913
3914     logevent("Received public keys");
3915
3916     ptr = ssh_pkt_getdata(pktin, 8);
3917     if (!ptr) {
3918         bombout(("SSH-1 public key packet stopped before random cookie"));
3919         crStop(0);
3920     }
3921     memcpy(cookie, ptr, 8);
3922
3923     if (!ssh1_pkt_getrsakey(pktin, &s->servkey, &s->keystr1) ||
3924         !ssh1_pkt_getrsakey(pktin, &s->hostkey, &s->keystr2)) { 
3925         bombout(("Failed to read SSH-1 public keys from public key packet"));
3926         crStop(0);
3927     }
3928
3929     /*
3930      * Log the host key fingerprint.
3931      */
3932     {
3933         char logmsg[80];
3934         logevent("Host key fingerprint is:");
3935         strcpy(logmsg, "      ");
3936         s->hostkey.comment = NULL;
3937         rsa_fingerprint(logmsg + strlen(logmsg),
3938                         sizeof(logmsg) - strlen(logmsg), &s->hostkey);
3939         logevent(logmsg);
3940     }
3941
3942     ssh->v1_remote_protoflags = ssh_pkt_getuint32(pktin);
3943     s->supported_ciphers_mask = ssh_pkt_getuint32(pktin);
3944     s->supported_auths_mask = ssh_pkt_getuint32(pktin);
3945     if ((ssh->remote_bugs & BUG_CHOKES_ON_RSA))
3946         s->supported_auths_mask &= ~(1 << SSH1_AUTH_RSA);
3947
3948     ssh->v1_local_protoflags =
3949         ssh->v1_remote_protoflags & SSH1_PROTOFLAGS_SUPPORTED;
3950     ssh->v1_local_protoflags |= SSH1_PROTOFLAG_SCREEN_NUMBER;
3951
3952     MD5Init(&md5c);
3953     MD5Update(&md5c, s->keystr2, s->hostkey.bytes);
3954     MD5Update(&md5c, s->keystr1, s->servkey.bytes);
3955     MD5Update(&md5c, cookie, 8);
3956     MD5Final(s->session_id, &md5c);
3957
3958     for (i = 0; i < 32; i++)
3959         ssh->session_key[i] = random_byte();
3960
3961     /*
3962      * Verify that the `bits' and `bytes' parameters match.
3963      */
3964     if (s->hostkey.bits > s->hostkey.bytes * 8 ||
3965         s->servkey.bits > s->servkey.bytes * 8) {
3966         bombout(("SSH-1 public keys were badly formatted"));
3967         crStop(0);
3968     }
3969
3970     s->len = (s->hostkey.bytes > s->servkey.bytes ?
3971               s->hostkey.bytes : s->servkey.bytes);
3972
3973     s->rsabuf = snewn(s->len, unsigned char);
3974
3975     /*
3976      * Verify the host key.
3977      */
3978     {
3979         /*
3980          * First format the key into a string.
3981          */
3982         int len = rsastr_len(&s->hostkey);
3983         char fingerprint[100];
3984         char *keystr = snewn(len, char);
3985         rsastr_fmt(keystr, &s->hostkey);
3986         rsa_fingerprint(fingerprint, sizeof(fingerprint), &s->hostkey);
3987
3988         /* First check against manually configured host keys. */
3989         s->dlgret = verify_ssh_manual_host_key(ssh, fingerprint, NULL, NULL);
3990         if (s->dlgret == 0) {          /* did not match */
3991             bombout(("Host key did not appear in manually configured list"));
3992             sfree(keystr);
3993             crStop(0);
3994         } else if (s->dlgret < 0) { /* none configured; use standard handling */
3995             ssh_set_frozen(ssh, 1);
3996             s->dlgret = verify_ssh_host_key(ssh->frontend,
3997                                             ssh->savedhost, ssh->savedport,
3998                                             "rsa", keystr, fingerprint,
3999                                             ssh_dialog_callback, ssh);
4000             sfree(keystr);
4001             if (s->dlgret < 0) {
4002                 do {
4003                     crReturn(0);
4004                     if (pktin) {
4005                         bombout(("Unexpected data from server while waiting"
4006                                  " for user host key response"));
4007                         crStop(0);
4008                     }
4009                 } while (pktin || inlen > 0);
4010                 s->dlgret = ssh->user_response;
4011             }
4012             ssh_set_frozen(ssh, 0);
4013
4014             if (s->dlgret == 0) {
4015                 ssh_disconnect(ssh, "User aborted at host key verification",
4016                                NULL, 0, TRUE);
4017                 crStop(0);
4018             }
4019         } else {
4020             sfree(keystr);
4021         }
4022     }
4023
4024     for (i = 0; i < 32; i++) {
4025         s->rsabuf[i] = ssh->session_key[i];
4026         if (i < 16)
4027             s->rsabuf[i] ^= s->session_id[i];
4028     }
4029
4030     if (s->hostkey.bytes > s->servkey.bytes) {
4031         ret = rsaencrypt(s->rsabuf, 32, &s->servkey);
4032         if (ret)
4033             ret = rsaencrypt(s->rsabuf, s->servkey.bytes, &s->hostkey);
4034     } else {
4035         ret = rsaencrypt(s->rsabuf, 32, &s->hostkey);
4036         if (ret)
4037             ret = rsaencrypt(s->rsabuf, s->hostkey.bytes, &s->servkey);
4038     }
4039     if (!ret) {
4040         bombout(("SSH-1 public key encryptions failed due to bad formatting"));
4041         crStop(0);      
4042     }
4043
4044     logevent("Encrypted session key");
4045
4046     {
4047         int cipher_chosen = 0, warn = 0;
4048         const char *cipher_string = NULL;
4049         int i;
4050         for (i = 0; !cipher_chosen && i < CIPHER_MAX; i++) {
4051             int next_cipher = conf_get_int_int(ssh->conf,
4052                                                CONF_ssh_cipherlist, i);
4053             if (next_cipher == CIPHER_WARN) {
4054                 /* If/when we choose a cipher, warn about it */
4055                 warn = 1;
4056             } else if (next_cipher == CIPHER_AES) {
4057                 /* XXX Probably don't need to mention this. */
4058                 logevent("AES not supported in SSH-1, skipping");
4059             } else {
4060                 switch (next_cipher) {
4061                   case CIPHER_3DES:     s->cipher_type = SSH_CIPHER_3DES;
4062                                         cipher_string = "3DES"; break;
4063                   case CIPHER_BLOWFISH: s->cipher_type = SSH_CIPHER_BLOWFISH;
4064                                         cipher_string = "Blowfish"; break;
4065                   case CIPHER_DES:      s->cipher_type = SSH_CIPHER_DES;
4066                                         cipher_string = "single-DES"; break;
4067                 }
4068                 if (s->supported_ciphers_mask & (1 << s->cipher_type))
4069                     cipher_chosen = 1;
4070             }
4071         }
4072         if (!cipher_chosen) {
4073             if ((s->supported_ciphers_mask & (1 << SSH_CIPHER_3DES)) == 0)
4074                 bombout(("Server violates SSH-1 protocol by not "
4075                          "supporting 3DES encryption"));
4076             else
4077                 /* shouldn't happen */
4078                 bombout(("No supported ciphers found"));
4079             crStop(0);
4080         }
4081
4082         /* Warn about chosen cipher if necessary. */
4083         if (warn) {
4084             ssh_set_frozen(ssh, 1);
4085             s->dlgret = askalg(ssh->frontend, "cipher", cipher_string,
4086                                ssh_dialog_callback, ssh);
4087             if (s->dlgret < 0) {
4088                 do {
4089                     crReturn(0);
4090                     if (pktin) {
4091                         bombout(("Unexpected data from server while waiting"
4092                                  " for user response"));
4093                         crStop(0);
4094                     }
4095                 } while (pktin || inlen > 0);
4096                 s->dlgret = ssh->user_response;
4097             }
4098             ssh_set_frozen(ssh, 0);
4099             if (s->dlgret == 0) {
4100                 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
4101                                0, TRUE);
4102                 crStop(0);
4103             }
4104         }
4105     }
4106
4107     switch (s->cipher_type) {
4108       case SSH_CIPHER_3DES:
4109         logevent("Using 3DES encryption");
4110         break;
4111       case SSH_CIPHER_DES:
4112         logevent("Using single-DES encryption");
4113         break;
4114       case SSH_CIPHER_BLOWFISH:
4115         logevent("Using Blowfish encryption");
4116         break;
4117     }
4118
4119     send_packet(ssh, SSH1_CMSG_SESSION_KEY,
4120                 PKT_CHAR, s->cipher_type,
4121                 PKT_DATA, cookie, 8,
4122                 PKT_CHAR, (s->len * 8) >> 8, PKT_CHAR, (s->len * 8) & 0xFF,
4123                 PKT_DATA, s->rsabuf, s->len,
4124                 PKT_INT, ssh->v1_local_protoflags, PKT_END);
4125
4126     logevent("Trying to enable encryption...");
4127
4128     sfree(s->rsabuf);
4129
4130     ssh->cipher = (s->cipher_type == SSH_CIPHER_BLOWFISH ? &ssh_blowfish_ssh1 :
4131                    s->cipher_type == SSH_CIPHER_DES ? &ssh_des :
4132                    &ssh_3des);
4133     ssh->v1_cipher_ctx = ssh->cipher->make_context();
4134     ssh->cipher->sesskey(ssh->v1_cipher_ctx, ssh->session_key);
4135     logeventf(ssh, "Initialised %s encryption", ssh->cipher->text_name);
4136
4137     ssh->crcda_ctx = crcda_make_context();
4138     logevent("Installing CRC compensation attack detector");
4139
4140     if (s->servkey.modulus) {
4141         sfree(s->servkey.modulus);
4142         s->servkey.modulus = NULL;
4143     }
4144     if (s->servkey.exponent) {
4145         sfree(s->servkey.exponent);
4146         s->servkey.exponent = NULL;
4147     }
4148     if (s->hostkey.modulus) {
4149         sfree(s->hostkey.modulus);
4150         s->hostkey.modulus = NULL;
4151     }
4152     if (s->hostkey.exponent) {
4153         sfree(s->hostkey.exponent);
4154         s->hostkey.exponent = NULL;
4155     }
4156     crWaitUntil(pktin);
4157
4158     if (pktin->type != SSH1_SMSG_SUCCESS) {
4159         bombout(("Encryption not successfully enabled"));
4160         crStop(0);
4161     }
4162
4163     logevent("Successfully started encryption");
4164
4165     fflush(stdout); /* FIXME eh? */
4166     {
4167         if ((ssh->username = get_remote_username(ssh->conf)) == NULL) {
4168             int ret; /* need not be kept over crReturn */
4169             s->cur_prompt = new_prompts(ssh->frontend);
4170             s->cur_prompt->to_server = TRUE;
4171             s->cur_prompt->name = dupstr("SSH login name");
4172             add_prompt(s->cur_prompt, dupstr("login as: "), TRUE);
4173             ret = get_userpass_input(s->cur_prompt, NULL, 0);
4174             while (ret < 0) {
4175                 ssh->send_ok = 1;
4176                 crWaitUntil(!pktin);
4177                 ret = get_userpass_input(s->cur_prompt, in, inlen);
4178                 ssh->send_ok = 0;
4179             }
4180             if (!ret) {
4181                 /*
4182                  * Failed to get a username. Terminate.
4183                  */
4184                 free_prompts(s->cur_prompt);
4185                 ssh_disconnect(ssh, "No username provided", NULL, 0, TRUE);
4186                 crStop(0);
4187             }
4188             ssh->username = dupstr(s->cur_prompt->prompts[0]->result);
4189             free_prompts(s->cur_prompt);
4190         }
4191
4192         send_packet(ssh, SSH1_CMSG_USER, PKT_STR, ssh->username, PKT_END);
4193         {
4194             char *userlog = dupprintf("Sent username \"%s\"", ssh->username);
4195             logevent(userlog);
4196             if (flags & FLAG_INTERACTIVE &&
4197                 (!((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)))) {
4198                 c_write_str(ssh, userlog);
4199                 c_write_str(ssh, "\r\n");
4200             }
4201             sfree(userlog);
4202         }
4203     }
4204
4205     crWaitUntil(pktin);
4206
4207     if ((s->supported_auths_mask & (1 << SSH1_AUTH_RSA)) == 0) {
4208         /* We must not attempt PK auth. Pretend we've already tried it. */
4209         s->tried_publickey = s->tried_agent = 1;
4210     } else {
4211         s->tried_publickey = s->tried_agent = 0;
4212     }
4213     s->tis_auth_refused = s->ccard_auth_refused = 0;
4214     /*
4215      * Load the public half of any configured keyfile for later use.
4216      */
4217     s->keyfile = conf_get_filename(ssh->conf, CONF_keyfile);
4218     if (!filename_is_null(s->keyfile)) {
4219         int keytype;
4220         logeventf(ssh, "Reading key file \"%.150s\"",
4221                   filename_to_str(s->keyfile));
4222         keytype = key_type(s->keyfile);
4223         if (keytype == SSH_KEYTYPE_SSH1 ||
4224             keytype == SSH_KEYTYPE_SSH1_PUBLIC) {
4225             const char *error;
4226             if (rsakey_pubblob(s->keyfile,
4227                                &s->publickey_blob, &s->publickey_bloblen,
4228                                &s->publickey_comment, &error)) {
4229                 s->privatekey_available = (keytype == SSH_KEYTYPE_SSH1);
4230                 if (!s->privatekey_available)
4231                     logeventf(ssh, "Key file contains public key only");
4232                 s->privatekey_encrypted = rsakey_encrypted(s->keyfile,
4233                                                            NULL);
4234             } else {
4235                 char *msgbuf;
4236                 logeventf(ssh, "Unable to load key (%s)", error);
4237                 msgbuf = dupprintf("Unable to load key file "
4238                                    "\"%.150s\" (%s)\r\n",
4239                                    filename_to_str(s->keyfile),
4240                                    error);
4241                 c_write_str(ssh, msgbuf);
4242                 sfree(msgbuf);
4243                 s->publickey_blob = NULL;
4244             }
4245         } else {
4246             char *msgbuf;
4247             logeventf(ssh, "Unable to use this key file (%s)",
4248                       key_type_to_str(keytype));
4249             msgbuf = dupprintf("Unable to use key file \"%.150s\""
4250                                " (%s)\r\n",
4251                                filename_to_str(s->keyfile),
4252                                key_type_to_str(keytype));
4253             c_write_str(ssh, msgbuf);
4254             sfree(msgbuf);
4255             s->publickey_blob = NULL;
4256         }
4257     } else
4258         s->publickey_blob = NULL;
4259
4260     while (pktin->type == SSH1_SMSG_FAILURE) {
4261         s->pwpkt_type = SSH1_CMSG_AUTH_PASSWORD;
4262
4263         if (conf_get_int(ssh->conf, CONF_tryagent) && agent_exists() && !s->tried_agent) {
4264             /*
4265              * Attempt RSA authentication using Pageant.
4266              */
4267             void *r;
4268
4269             s->authed = FALSE;
4270             s->tried_agent = 1;
4271             logevent("Pageant is running. Requesting keys.");
4272
4273             /* Request the keys held by the agent. */
4274             PUT_32BIT(s->request, 1);
4275             s->request[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES;
4276             if (!agent_query(s->request, 5, &r, &s->responselen,
4277                              ssh_agent_callback, ssh)) {
4278                 do {
4279                     crReturn(0);
4280                     if (pktin) {
4281                         bombout(("Unexpected data from server while waiting"
4282                                  " for agent response"));
4283                         crStop(0);
4284                     }
4285                 } while (pktin || inlen > 0);
4286                 r = ssh->agent_response;
4287                 s->responselen = ssh->agent_response_len;
4288             }
4289             s->response = (unsigned char *) r;
4290             if (s->response && s->responselen >= 5 &&
4291                 s->response[4] == SSH1_AGENT_RSA_IDENTITIES_ANSWER) {
4292                 s->p = s->response + 5;
4293                 s->nkeys = toint(GET_32BIT(s->p));
4294                 if (s->nkeys < 0) {
4295                     logeventf(ssh, "Pageant reported negative key count %d",
4296                               s->nkeys);
4297                     s->nkeys = 0;
4298                 }
4299                 s->p += 4;
4300                 logeventf(ssh, "Pageant has %d SSH-1 keys", s->nkeys);
4301                 for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) {
4302                     unsigned char *pkblob = s->p;
4303                     s->p += 4;
4304                     {
4305                         int n, ok = FALSE;
4306                         do {           /* do while (0) to make breaking easy */
4307                             n = ssh1_read_bignum
4308                                 (s->p, toint(s->responselen-(s->p-s->response)),
4309                                  &s->key.exponent);
4310                             if (n < 0)
4311                                 break;
4312                             s->p += n;
4313                             n = ssh1_read_bignum
4314                                 (s->p, toint(s->responselen-(s->p-s->response)),
4315                                  &s->key.modulus);
4316                             if (n < 0)
4317                                 break;
4318                             s->p += n;
4319                             if (s->responselen - (s->p-s->response) < 4)
4320                                 break;
4321                             s->commentlen = toint(GET_32BIT(s->p));
4322                             s->p += 4;
4323                             if (s->commentlen < 0 ||
4324                                 toint(s->responselen - (s->p-s->response)) <
4325                                 s->commentlen)
4326                                 break;
4327                             s->commentp = (char *)s->p;
4328                             s->p += s->commentlen;
4329                             ok = TRUE;
4330                         } while (0);
4331                         if (!ok) {
4332                             logevent("Pageant key list packet was truncated");
4333                             break;
4334                         }
4335                     }
4336                     if (s->publickey_blob) {
4337                         if (!memcmp(pkblob, s->publickey_blob,
4338                                     s->publickey_bloblen)) {
4339                             logeventf(ssh, "Pageant key #%d matches "
4340                                       "configured key file", s->keyi);
4341                             s->tried_publickey = 1;
4342                         } else
4343                             /* Skip non-configured key */
4344                             continue;
4345                     }
4346                     logeventf(ssh, "Trying Pageant key #%d", s->keyi);
4347                     send_packet(ssh, SSH1_CMSG_AUTH_RSA,
4348                                 PKT_BIGNUM, s->key.modulus, PKT_END);
4349                     crWaitUntil(pktin);
4350                     if (pktin->type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
4351                         logevent("Key refused");
4352                         continue;
4353                     }
4354                     logevent("Received RSA challenge");
4355                     if ((s->challenge = ssh1_pkt_getmp(pktin)) == NULL) {
4356                         bombout(("Server's RSA challenge was badly formatted"));
4357                         crStop(0);
4358                     }
4359
4360                     {
4361                         char *agentreq, *q, *ret;
4362                         void *vret;
4363                         int len, retlen;
4364                         len = 1 + 4;   /* message type, bit count */
4365                         len += ssh1_bignum_length(s->key.exponent);
4366                         len += ssh1_bignum_length(s->key.modulus);
4367                         len += ssh1_bignum_length(s->challenge);
4368                         len += 16;     /* session id */
4369                         len += 4;      /* response format */
4370                         agentreq = snewn(4 + len, char);
4371                         PUT_32BIT(agentreq, len);
4372                         q = agentreq + 4;
4373                         *q++ = SSH1_AGENTC_RSA_CHALLENGE;
4374                         PUT_32BIT(q, bignum_bitcount(s->key.modulus));
4375                         q += 4;
4376                         q += ssh1_write_bignum(q, s->key.exponent);
4377                         q += ssh1_write_bignum(q, s->key.modulus);
4378                         q += ssh1_write_bignum(q, s->challenge);
4379                         memcpy(q, s->session_id, 16);
4380                         q += 16;
4381                         PUT_32BIT(q, 1);        /* response format */
4382                         if (!agent_query(agentreq, len + 4, &vret, &retlen,
4383                                          ssh_agent_callback, ssh)) {
4384                             sfree(agentreq);
4385                             do {
4386                                 crReturn(0);
4387                                 if (pktin) {
4388                                     bombout(("Unexpected data from server"
4389                                              " while waiting for agent"
4390                                              " response"));
4391                                     crStop(0);
4392                                 }
4393                             } while (pktin || inlen > 0);
4394                             vret = ssh->agent_response;
4395                             retlen = ssh->agent_response_len;
4396                         } else
4397                             sfree(agentreq);
4398                         ret = vret;
4399                         if (ret) {
4400                             if (ret[4] == SSH1_AGENT_RSA_RESPONSE) {
4401                                 logevent("Sending Pageant's response");
4402                                 send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
4403                                             PKT_DATA, ret + 5, 16,
4404                                             PKT_END);
4405                                 sfree(ret);
4406                                 crWaitUntil(pktin);
4407                                 if (pktin->type == SSH1_SMSG_SUCCESS) {
4408                                     logevent
4409                                         ("Pageant's response accepted");
4410                                     if (flags & FLAG_VERBOSE) {
4411                                         c_write_str(ssh, "Authenticated using"
4412                                                     " RSA key \"");
4413                                         c_write(ssh, s->commentp,
4414                                                 s->commentlen);
4415                                         c_write_str(ssh, "\" from agent\r\n");
4416                                     }
4417                                     s->authed = TRUE;
4418                                 } else
4419                                     logevent
4420                                         ("Pageant's response not accepted");
4421                             } else {
4422                                 logevent
4423                                     ("Pageant failed to answer challenge");
4424                                 sfree(ret);
4425                             }
4426                         } else {
4427                             logevent("No reply received from Pageant");
4428                         }
4429                     }
4430                     freebn(s->key.exponent);
4431                     freebn(s->key.modulus);
4432                     freebn(s->challenge);
4433                     if (s->authed)
4434                         break;
4435                 }
4436                 sfree(s->response);
4437                 if (s->publickey_blob && !s->tried_publickey)
4438                     logevent("Configured key file not in Pageant");
4439             } else {
4440                 logevent("Failed to get reply from Pageant");
4441             }
4442             if (s->authed)
4443                 break;
4444         }
4445         if (s->publickey_blob && s->privatekey_available &&
4446             !s->tried_publickey) {
4447             /*
4448              * Try public key authentication with the specified
4449              * key file.
4450              */
4451             int got_passphrase; /* need not be kept over crReturn */
4452             if (flags & FLAG_VERBOSE)
4453                 c_write_str(ssh, "Trying public key authentication.\r\n");
4454             s->keyfile = conf_get_filename(ssh->conf, CONF_keyfile);
4455             logeventf(ssh, "Trying public key \"%s\"",
4456                       filename_to_str(s->keyfile));
4457             s->tried_publickey = 1;
4458             got_passphrase = FALSE;
4459             while (!got_passphrase) {
4460                 /*
4461                  * Get a passphrase, if necessary.
4462                  */
4463                 char *passphrase = NULL;    /* only written after crReturn */
4464                 const char *error;
4465                 if (!s->privatekey_encrypted) {
4466                     if (flags & FLAG_VERBOSE)
4467                         c_write_str(ssh, "No passphrase required.\r\n");
4468                     passphrase = NULL;
4469                 } else {
4470                     int ret; /* need not be kept over crReturn */
4471                     s->cur_prompt = new_prompts(ssh->frontend);
4472                     s->cur_prompt->to_server = FALSE;
4473                     s->cur_prompt->name = dupstr("SSH key passphrase");
4474                     add_prompt(s->cur_prompt,
4475                                dupprintf("Passphrase for key \"%.100s\": ",
4476                                          s->publickey_comment), FALSE);
4477                     ret = get_userpass_input(s->cur_prompt, NULL, 0);
4478                     while (ret < 0) {
4479                         ssh->send_ok = 1;
4480                         crWaitUntil(!pktin);
4481                         ret = get_userpass_input(s->cur_prompt, in, inlen);
4482                         ssh->send_ok = 0;
4483                     }
4484                     if (!ret) {
4485                         /* Failed to get a passphrase. Terminate. */
4486                         free_prompts(s->cur_prompt);
4487                         ssh_disconnect(ssh, NULL, "Unable to authenticate",
4488                                        0, TRUE);
4489                         crStop(0);
4490                     }
4491                     passphrase = dupstr(s->cur_prompt->prompts[0]->result);
4492                     free_prompts(s->cur_prompt);
4493                 }
4494                 /*
4495                  * Try decrypting key with passphrase.
4496                  */
4497                 s->keyfile = conf_get_filename(ssh->conf, CONF_keyfile);
4498                 ret = loadrsakey(s->keyfile, &s->key, passphrase,
4499                                  &error);
4500                 if (passphrase) {
4501                     smemclr(passphrase, strlen(passphrase));
4502                     sfree(passphrase);
4503                 }
4504                 if (ret == 1) {
4505                     /* Correct passphrase. */
4506                     got_passphrase = TRUE;
4507                 } else if (ret == 0) {
4508                     c_write_str(ssh, "Couldn't load private key from ");
4509                     c_write_str(ssh, filename_to_str(s->keyfile));
4510                     c_write_str(ssh, " (");
4511                     c_write_str(ssh, error);
4512                     c_write_str(ssh, ").\r\n");
4513                     got_passphrase = FALSE;
4514                     break;             /* go and try something else */
4515                 } else if (ret == -1) {
4516                     c_write_str(ssh, "Wrong passphrase.\r\n"); /* FIXME */
4517                     got_passphrase = FALSE;
4518                     /* and try again */
4519                 } else {
4520                     assert(0 && "unexpected return from loadrsakey()");
4521                     got_passphrase = FALSE;   /* placate optimisers */
4522                 }
4523             }
4524
4525             if (got_passphrase) {
4526
4527                 /*
4528                  * Send a public key attempt.
4529                  */
4530                 send_packet(ssh, SSH1_CMSG_AUTH_RSA,
4531                             PKT_BIGNUM, s->key.modulus, PKT_END);
4532
4533                 crWaitUntil(pktin);
4534                 if (pktin->type == SSH1_SMSG_FAILURE) {
4535                     c_write_str(ssh, "Server refused our public key.\r\n");
4536                     continue;          /* go and try something else */
4537                 }
4538                 if (pktin->type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
4539                     bombout(("Bizarre response to offer of public key"));
4540                     crStop(0);
4541                 }
4542
4543                 {
4544                     int i;
4545                     unsigned char buffer[32];
4546                     Bignum challenge, response;
4547
4548                     if ((challenge = ssh1_pkt_getmp(pktin)) == NULL) {
4549                         bombout(("Server's RSA challenge was badly formatted"));
4550                         crStop(0);
4551                     }
4552                     response = rsadecrypt(challenge, &s->key);
4553                     freebn(s->key.private_exponent);/* burn the evidence */
4554
4555                     for (i = 0; i < 32; i++) {
4556                         buffer[i] = bignum_byte(response, 31 - i);
4557                     }
4558
4559                     MD5Init(&md5c);
4560                     MD5Update(&md5c, buffer, 32);
4561                     MD5Update(&md5c, s->session_id, 16);
4562                     MD5Final(buffer, &md5c);
4563
4564                     send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
4565                                 PKT_DATA, buffer, 16, PKT_END);
4566
4567                     freebn(challenge);
4568                     freebn(response);
4569                 }
4570
4571                 crWaitUntil(pktin);
4572                 if (pktin->type == SSH1_SMSG_FAILURE) {
4573                     if (flags & FLAG_VERBOSE)
4574                         c_write_str(ssh, "Failed to authenticate with"
4575                                     " our public key.\r\n");
4576                     continue;          /* go and try something else */
4577                 } else if (pktin->type != SSH1_SMSG_SUCCESS) {
4578                     bombout(("Bizarre response to RSA authentication response"));
4579                     crStop(0);
4580                 }
4581
4582                 break;                 /* we're through! */
4583             }
4584
4585         }
4586
4587         /*
4588          * Otherwise, try various forms of password-like authentication.
4589          */
4590         s->cur_prompt = new_prompts(ssh->frontend);
4591
4592         if (conf_get_int(ssh->conf, CONF_try_tis_auth) &&
4593             (s->supported_auths_mask & (1 << SSH1_AUTH_TIS)) &&
4594             !s->tis_auth_refused) {
4595             s->pwpkt_type = SSH1_CMSG_AUTH_TIS_RESPONSE;
4596             logevent("Requested TIS authentication");
4597             send_packet(ssh, SSH1_CMSG_AUTH_TIS, PKT_END);
4598             crWaitUntil(pktin);
4599             if (pktin->type != SSH1_SMSG_AUTH_TIS_CHALLENGE) {
4600                 logevent("TIS authentication declined");
4601                 if (flags & FLAG_INTERACTIVE)
4602                     c_write_str(ssh, "TIS authentication refused.\r\n");
4603                 s->tis_auth_refused = 1;
4604                 continue;
4605             } else {
4606                 char *challenge;
4607                 int challengelen;
4608                 char *instr_suf, *prompt;
4609
4610                 ssh_pkt_getstring(pktin, &challenge, &challengelen);
4611                 if (!challenge) {
4612                     bombout(("TIS challenge packet was badly formed"));
4613                     crStop(0);
4614                 }
4615                 logevent("Received TIS challenge");
4616                 s->cur_prompt->to_server = TRUE;
4617                 s->cur_prompt->name = dupstr("SSH TIS authentication");
4618                 /* Prompt heuristic comes from OpenSSH */
4619                 if (memchr(challenge, '\n', challengelen)) {
4620                     instr_suf = dupstr("");
4621                     prompt = dupprintf("%.*s", challengelen, challenge);
4622                 } else {
4623                     instr_suf = dupprintf("%.*s", challengelen, challenge);
4624                     prompt = dupstr("Response: ");
4625                 }
4626                 s->cur_prompt->instruction =
4627                     dupprintf("Using TIS authentication.%s%s",
4628                               (*instr_suf) ? "\n" : "",
4629                               instr_suf);
4630                 s->cur_prompt->instr_reqd = TRUE;
4631                 add_prompt(s->cur_prompt, prompt, FALSE);
4632                 sfree(instr_suf);
4633             }
4634         }
4635         if (conf_get_int(ssh->conf, CONF_try_tis_auth) &&
4636             (s->supported_auths_mask & (1 << SSH1_AUTH_CCARD)) &&
4637             !s->ccard_auth_refused) {
4638             s->pwpkt_type = SSH1_CMSG_AUTH_CCARD_RESPONSE;
4639             logevent("Requested CryptoCard authentication");
4640             send_packet(ssh, SSH1_CMSG_AUTH_CCARD, PKT_END);
4641             crWaitUntil(pktin);
4642             if (pktin->type != SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
4643                 logevent("CryptoCard authentication declined");
4644                 c_write_str(ssh, "CryptoCard authentication refused.\r\n");
4645                 s->ccard_auth_refused = 1;
4646                 continue;
4647             } else {
4648                 char *challenge;
4649                 int challengelen;
4650                 char *instr_suf, *prompt;
4651
4652                 ssh_pkt_getstring(pktin, &challenge, &challengelen);
4653                 if (!challenge) {
4654                     bombout(("CryptoCard challenge packet was badly formed"));
4655                     crStop(0);
4656                 }
4657                 logevent("Received CryptoCard challenge");
4658                 s->cur_prompt->to_server = TRUE;
4659                 s->cur_prompt->name = dupstr("SSH CryptoCard authentication");
4660                 s->cur_prompt->name_reqd = FALSE;
4661                 /* Prompt heuristic comes from OpenSSH */
4662                 if (memchr(challenge, '\n', challengelen)) {
4663                     instr_suf = dupstr("");
4664                     prompt = dupprintf("%.*s", challengelen, challenge);
4665                 } else {
4666                     instr_suf = dupprintf("%.*s", challengelen, challenge);
4667                     prompt = dupstr("Response: ");
4668                 }
4669                 s->cur_prompt->instruction =
4670                     dupprintf("Using CryptoCard authentication.%s%s",
4671                               (*instr_suf) ? "\n" : "",
4672                               instr_suf);
4673                 s->cur_prompt->instr_reqd = TRUE;
4674                 add_prompt(s->cur_prompt, prompt, FALSE);
4675                 sfree(instr_suf);
4676             }
4677         }
4678         if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
4679             if ((s->supported_auths_mask & (1 << SSH1_AUTH_PASSWORD)) == 0) {
4680                 bombout(("No supported authentication methods available"));
4681                 crStop(0);
4682             }
4683             s->cur_prompt->to_server = TRUE;
4684             s->cur_prompt->name = dupstr("SSH password");
4685             add_prompt(s->cur_prompt, dupprintf("%s@%s's password: ",
4686                                                 ssh->username, ssh->savedhost),
4687                        FALSE);
4688         }
4689
4690         /*
4691          * Show password prompt, having first obtained it via a TIS
4692          * or CryptoCard exchange if we're doing TIS or CryptoCard
4693          * authentication.
4694          */
4695         {
4696             int ret; /* need not be kept over crReturn */
4697             ret = get_userpass_input(s->cur_prompt, NULL, 0);
4698             while (ret < 0) {
4699                 ssh->send_ok = 1;
4700                 crWaitUntil(!pktin);
4701                 ret = get_userpass_input(s->cur_prompt, in, inlen);
4702                 ssh->send_ok = 0;
4703             }
4704             if (!ret) {
4705                 /*
4706                  * Failed to get a password (for example
4707                  * because one was supplied on the command line
4708                  * which has already failed to work). Terminate.
4709                  */
4710                 free_prompts(s->cur_prompt);
4711                 ssh_disconnect(ssh, NULL, "Unable to authenticate", 0, TRUE);
4712                 crStop(0);
4713             }
4714         }
4715
4716         if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
4717             /*
4718              * Defence against traffic analysis: we send a
4719              * whole bunch of packets containing strings of
4720              * different lengths. One of these strings is the
4721              * password, in a SSH1_CMSG_AUTH_PASSWORD packet.
4722              * The others are all random data in
4723              * SSH1_MSG_IGNORE packets. This way a passive
4724              * listener can't tell which is the password, and
4725              * hence can't deduce the password length.
4726              * 
4727              * Anybody with a password length greater than 16
4728              * bytes is going to have enough entropy in their
4729              * password that a listener won't find it _that_
4730              * much help to know how long it is. So what we'll
4731              * do is:
4732              * 
4733              *  - if password length < 16, we send 15 packets
4734              *    containing string lengths 1 through 15
4735              * 
4736              *  - otherwise, we let N be the nearest multiple
4737              *    of 8 below the password length, and send 8
4738              *    packets containing string lengths N through
4739              *    N+7. This won't obscure the order of
4740              *    magnitude of the password length, but it will
4741              *    introduce a bit of extra uncertainty.
4742              * 
4743              * A few servers can't deal with SSH1_MSG_IGNORE, at
4744              * least in this context. For these servers, we need
4745              * an alternative defence. We make use of the fact
4746              * that the password is interpreted as a C string:
4747              * so we can append a NUL, then some random data.
4748              * 
4749              * A few servers can deal with neither SSH1_MSG_IGNORE
4750              * here _nor_ a padded password string.
4751              * For these servers we are left with no defences
4752              * against password length sniffing.
4753              */
4754             if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE) &&
4755                 !(ssh->remote_bugs & BUG_NEEDS_SSH1_PLAIN_PASSWORD)) {
4756                 /*
4757                  * The server can deal with SSH1_MSG_IGNORE, so
4758                  * we can use the primary defence.
4759                  */
4760                 int bottom, top, pwlen, i;
4761                 char *randomstr;
4762
4763                 pwlen = strlen(s->cur_prompt->prompts[0]->result);
4764                 if (pwlen < 16) {
4765                     bottom = 0;    /* zero length passwords are OK! :-) */
4766                     top = 15;
4767                 } else {
4768                     bottom = pwlen & ~7;
4769                     top = bottom + 7;
4770                 }
4771
4772                 assert(pwlen >= bottom && pwlen <= top);
4773
4774                 randomstr = snewn(top + 1, char);
4775
4776                 for (i = bottom; i <= top; i++) {
4777                     if (i == pwlen) {
4778                         defer_packet(ssh, s->pwpkt_type,
4779                                      PKT_STR,s->cur_prompt->prompts[0]->result,
4780                                      PKT_END);
4781                     } else {
4782                         for (j = 0; j < i; j++) {
4783                             do {
4784                                 randomstr[j] = random_byte();
4785                             } while (randomstr[j] == '\0');
4786                         }
4787                         randomstr[i] = '\0';
4788                         defer_packet(ssh, SSH1_MSG_IGNORE,
4789                                      PKT_STR, randomstr, PKT_END);
4790                     }
4791                 }
4792                 logevent("Sending password with camouflage packets");
4793                 ssh_pkt_defersend(ssh);
4794                 sfree(randomstr);
4795             } 
4796             else if (!(ssh->remote_bugs & BUG_NEEDS_SSH1_PLAIN_PASSWORD)) {
4797                 /*
4798                  * The server can't deal with SSH1_MSG_IGNORE
4799                  * but can deal with padded passwords, so we
4800                  * can use the secondary defence.
4801                  */
4802                 char string[64];
4803                 char *ss;
4804                 int len;
4805
4806                 len = strlen(s->cur_prompt->prompts[0]->result);
4807                 if (len < sizeof(string)) {
4808                     ss = string;
4809                     strcpy(string, s->cur_prompt->prompts[0]->result);
4810                     len++;             /* cover the zero byte */
4811                     while (len < sizeof(string)) {
4812                         string[len++] = (char) random_byte();
4813                     }
4814                 } else {
4815                     ss = s->cur_prompt->prompts[0]->result;
4816                 }
4817                 logevent("Sending length-padded password");
4818                 send_packet(ssh, s->pwpkt_type,
4819                             PKT_INT, len, PKT_DATA, ss, len,
4820                             PKT_END);
4821             } else {
4822                 /*
4823                  * The server is believed unable to cope with
4824                  * any of our password camouflage methods.
4825                  */
4826                 int len;
4827                 len = strlen(s->cur_prompt->prompts[0]->result);
4828                 logevent("Sending unpadded password");
4829                 send_packet(ssh, s->pwpkt_type,
4830                             PKT_INT, len,
4831                             PKT_DATA, s->cur_prompt->prompts[0]->result, len,
4832                             PKT_END);
4833             }
4834         } else {
4835             send_packet(ssh, s->pwpkt_type,
4836                         PKT_STR, s->cur_prompt->prompts[0]->result,
4837                         PKT_END);
4838         }
4839         logevent("Sent password");
4840         free_prompts(s->cur_prompt);
4841         crWaitUntil(pktin);
4842         if (pktin->type == SSH1_SMSG_FAILURE) {
4843             if (flags & FLAG_VERBOSE)
4844                 c_write_str(ssh, "Access denied\r\n");
4845             logevent("Authentication refused");
4846         } else if (pktin->type != SSH1_SMSG_SUCCESS) {
4847             bombout(("Strange packet received, type %d", pktin->type));
4848             crStop(0);
4849         }
4850     }
4851
4852     /* Clear up */
4853     if (s->publickey_blob) {
4854         sfree(s->publickey_blob);
4855         sfree(s->publickey_comment);
4856     }
4857
4858     logevent("Authentication successful");
4859
4860     crFinish(1);
4861 }
4862
4863 static void ssh_channel_try_eof(struct ssh_channel *c)
4864 {
4865     Ssh ssh = c->ssh;
4866     assert(c->pending_eof);          /* precondition for calling us */
4867     if (c->halfopen)
4868         return;                 /* can't close: not even opened yet */
4869     if (ssh->version == 2 && bufchain_size(&c->v.v2.outbuffer) > 0)
4870         return;              /* can't send EOF: pending outgoing data */
4871
4872     c->pending_eof = FALSE;            /* we're about to send it */
4873     if (ssh->version == 1) {
4874         send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE, PKT_INT, c->remoteid,
4875                     PKT_END);
4876         c->closes |= CLOSES_SENT_EOF;
4877     } else {
4878         struct Packet *pktout;
4879         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_EOF);
4880         ssh2_pkt_adduint32(pktout, c->remoteid);
4881         ssh2_pkt_send(ssh, pktout);
4882         c->closes |= CLOSES_SENT_EOF;
4883         ssh2_channel_check_close(c);
4884     }
4885 }
4886
4887 Conf *sshfwd_get_conf(struct ssh_channel *c)
4888 {
4889     Ssh ssh = c->ssh;
4890     return ssh->conf;
4891 }
4892
4893 void sshfwd_write_eof(struct ssh_channel *c)
4894 {
4895     Ssh ssh = c->ssh;
4896
4897     if (ssh->state == SSH_STATE_CLOSED)
4898         return;
4899
4900     if (c->closes & CLOSES_SENT_EOF)
4901         return;
4902
4903     c->pending_eof = TRUE;
4904     ssh_channel_try_eof(c);
4905 }
4906
4907 void sshfwd_unclean_close(struct ssh_channel *c, const char *err)
4908 {
4909     Ssh ssh = c->ssh;
4910
4911     if (ssh->state == SSH_STATE_CLOSED)
4912         return;
4913
4914     switch (c->type) {
4915       case CHAN_X11:
4916         x11_close(c->u.x11.xconn);
4917         logeventf(ssh, "Forwarded X11 connection terminated due to local "
4918                   "error: %s", err);
4919         break;
4920       case CHAN_SOCKDATA:
4921       case CHAN_SOCKDATA_DORMANT:
4922         pfd_close(c->u.pfd.pf);
4923         logeventf(ssh, "Forwarded port closed due to local error: %s", err);
4924         break;
4925     }
4926     c->type = CHAN_ZOMBIE;
4927     c->pending_eof = FALSE;   /* this will confuse a zombie channel */
4928
4929     ssh2_channel_check_close(c);
4930 }
4931
4932 int sshfwd_write(struct ssh_channel *c, char *buf, int len)
4933 {
4934     Ssh ssh = c->ssh;
4935
4936     if (ssh->state == SSH_STATE_CLOSED)
4937         return 0;
4938
4939     if (ssh->version == 1) {
4940         send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
4941                     PKT_INT, c->remoteid,
4942                     PKT_INT, len, PKT_DATA, buf, len,
4943                     PKT_END);
4944         /*
4945          * In SSH-1 we can return 0 here - implying that forwarded
4946          * connections are never individually throttled - because
4947          * the only circumstance that can cause throttling will be
4948          * the whole SSH connection backing up, in which case
4949          * _everything_ will be throttled as a whole.
4950          */
4951         return 0;
4952     } else {
4953         ssh2_add_channel_data(c, buf, len);
4954         return ssh2_try_send(c);
4955     }
4956 }
4957
4958 void sshfwd_unthrottle(struct ssh_channel *c, int bufsize)
4959 {
4960     Ssh ssh = c->ssh;
4961     int buflimit;
4962
4963     if (ssh->state == SSH_STATE_CLOSED)
4964         return;
4965
4966     if (ssh->version == 1) {
4967         buflimit = SSH1_BUFFER_LIMIT;
4968     } else {
4969         buflimit = c->v.v2.locmaxwin;
4970         ssh2_set_window(c, bufsize < buflimit ? buflimit - bufsize : 0);
4971     }
4972     if (c->throttling_conn && bufsize <= buflimit) {
4973         c->throttling_conn = 0;
4974         ssh_throttle_conn(ssh, -1);
4975     }
4976 }
4977
4978 static void ssh_queueing_handler(Ssh ssh, struct Packet *pktin)
4979 {
4980     struct queued_handler *qh = ssh->qhead;
4981
4982     assert(qh != NULL);
4983
4984     assert(pktin->type == qh->msg1 || pktin->type == qh->msg2);
4985
4986     if (qh->msg1 > 0) {
4987         assert(ssh->packet_dispatch[qh->msg1] == ssh_queueing_handler);
4988         ssh->packet_dispatch[qh->msg1] = ssh->q_saved_handler1;
4989     }
4990     if (qh->msg2 > 0) {
4991         assert(ssh->packet_dispatch[qh->msg2] == ssh_queueing_handler);
4992         ssh->packet_dispatch[qh->msg2] = ssh->q_saved_handler2;
4993     }
4994
4995     if (qh->next) {
4996         ssh->qhead = qh->next;
4997
4998         if (ssh->qhead->msg1 > 0) {
4999             ssh->q_saved_handler1 = ssh->packet_dispatch[ssh->qhead->msg1];
5000             ssh->packet_dispatch[ssh->qhead->msg1] = ssh_queueing_handler;
5001         }
5002         if (ssh->qhead->msg2 > 0) {
5003             ssh->q_saved_handler2 = ssh->packet_dispatch[ssh->qhead->msg2];
5004             ssh->packet_dispatch[ssh->qhead->msg2] = ssh_queueing_handler;
5005         }
5006     } else {
5007         ssh->qhead = ssh->qtail = NULL;
5008     }
5009
5010     qh->handler(ssh, pktin, qh->ctx);
5011
5012     sfree(qh);
5013 }
5014
5015 static void ssh_queue_handler(Ssh ssh, int msg1, int msg2,
5016                               chandler_fn_t handler, void *ctx)
5017 {
5018     struct queued_handler *qh;
5019
5020     qh = snew(struct queued_handler);
5021     qh->msg1 = msg1;
5022     qh->msg2 = msg2;
5023     qh->handler = handler;
5024     qh->ctx = ctx;
5025     qh->next = NULL;
5026
5027     if (ssh->qtail == NULL) {
5028         ssh->qhead = qh;
5029
5030         if (qh->msg1 > 0) {
5031             ssh->q_saved_handler1 = ssh->packet_dispatch[ssh->qhead->msg1];
5032             ssh->packet_dispatch[qh->msg1] = ssh_queueing_handler;
5033         }
5034         if (qh->msg2 > 0) {
5035             ssh->q_saved_handler2 = ssh->packet_dispatch[ssh->qhead->msg2];
5036             ssh->packet_dispatch[qh->msg2] = ssh_queueing_handler;
5037         }
5038     } else {
5039         ssh->qtail->next = qh;
5040     }
5041     ssh->qtail = qh;
5042 }
5043
5044 static void ssh_rportfwd_succfail(Ssh ssh, struct Packet *pktin, void *ctx)
5045 {
5046     struct ssh_rportfwd *rpf, *pf = (struct ssh_rportfwd *)ctx;
5047
5048     if (pktin->type == (ssh->version == 1 ? SSH1_SMSG_SUCCESS :
5049                         SSH2_MSG_REQUEST_SUCCESS)) {
5050         logeventf(ssh, "Remote port forwarding from %s enabled",
5051                   pf->sportdesc);
5052     } else {
5053         logeventf(ssh, "Remote port forwarding from %s refused",
5054                   pf->sportdesc);
5055
5056         rpf = del234(ssh->rportfwds, pf);
5057         assert(rpf == pf);
5058         pf->pfrec->remote = NULL;
5059         free_rportfwd(pf);
5060     }
5061 }
5062
5063 int ssh_alloc_sharing_rportfwd(Ssh ssh, const char *shost, int sport,
5064                                void *share_ctx)
5065 {
5066     struct ssh_rportfwd *pf = snew(struct ssh_rportfwd);
5067     pf->dhost = NULL;
5068     pf->dport = 0;
5069     pf->share_ctx = share_ctx;
5070     pf->shost = dupstr(shost);
5071     pf->sport = sport;
5072     pf->sportdesc = NULL;
5073     if (!ssh->rportfwds) {
5074         assert(ssh->version == 2);
5075         ssh->rportfwds = newtree234(ssh_rportcmp_ssh2);
5076     }
5077     if (add234(ssh->rportfwds, pf) != pf) {
5078         sfree(pf->shost);
5079         sfree(pf);
5080         return FALSE;
5081     }
5082     return TRUE;
5083 }
5084
5085 static void ssh_sharing_global_request_response(Ssh ssh, struct Packet *pktin,
5086                                                 void *ctx)
5087 {
5088     share_got_pkt_from_server(ctx, pktin->type,
5089                               pktin->body, pktin->length);
5090 }
5091
5092 void ssh_sharing_queue_global_request(Ssh ssh, void *share_ctx)
5093 {
5094     ssh_queue_handler(ssh, SSH2_MSG_REQUEST_SUCCESS, SSH2_MSG_REQUEST_FAILURE,
5095                       ssh_sharing_global_request_response, share_ctx);
5096 }
5097
5098 static void ssh_setup_portfwd(Ssh ssh, Conf *conf)
5099 {
5100     struct ssh_portfwd *epf;
5101     int i;
5102     char *key, *val;
5103
5104     if (!ssh->portfwds) {
5105         ssh->portfwds = newtree234(ssh_portcmp);
5106     } else {
5107         /*
5108          * Go through the existing port forwardings and tag them
5109          * with status==DESTROY. Any that we want to keep will be
5110          * re-enabled (status==KEEP) as we go through the
5111          * configuration and find out which bits are the same as
5112          * they were before.
5113          */
5114         struct ssh_portfwd *epf;
5115         int i;
5116         for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
5117             epf->status = DESTROY;
5118     }
5119
5120     for (val = conf_get_str_strs(conf, CONF_portfwd, NULL, &key);
5121          val != NULL;
5122          val = conf_get_str_strs(conf, CONF_portfwd, key, &key)) {
5123         char *kp, *kp2, *vp, *vp2;
5124         char address_family, type;
5125         int sport,dport,sserv,dserv;
5126         char *sports, *dports, *saddr, *host;
5127
5128         kp = key;
5129
5130         address_family = 'A';
5131         type = 'L';
5132         if (*kp == 'A' || *kp == '4' || *kp == '6')
5133             address_family = *kp++;
5134         if (*kp == 'L' || *kp == 'R')
5135             type = *kp++;
5136
5137         if ((kp2 = host_strchr(kp, ':')) != NULL) {
5138             /*
5139              * There's a colon in the middle of the source port
5140              * string, which means that the part before it is
5141              * actually a source address.
5142              */
5143             char *saddr_tmp = dupprintf("%.*s", (int)(kp2 - kp), kp);
5144             saddr = host_strduptrim(saddr_tmp);
5145             sfree(saddr_tmp);
5146             sports = kp2+1;
5147         } else {
5148             saddr = NULL;
5149             sports = kp;
5150         }
5151         sport = atoi(sports);
5152         sserv = 0;
5153         if (sport == 0) {
5154             sserv = 1;
5155             sport = net_service_lookup(sports);
5156             if (!sport) {
5157                 logeventf(ssh, "Service lookup failed for source"
5158                           " port \"%s\"", sports);
5159             }
5160         }
5161
5162         if (type == 'L' && !strcmp(val, "D")) {
5163             /* dynamic forwarding */
5164             host = NULL;
5165             dports = NULL;
5166             dport = -1;
5167             dserv = 0;
5168             type = 'D';
5169         } else {
5170             /* ordinary forwarding */
5171             vp = val;
5172             vp2 = vp + host_strcspn(vp, ":");
5173             host = dupprintf("%.*s", (int)(vp2 - vp), vp);
5174             if (*vp2)
5175                 vp2++;
5176             dports = vp2;
5177             dport = atoi(dports);
5178             dserv = 0;
5179             if (dport == 0) {
5180                 dserv = 1;
5181                 dport = net_service_lookup(dports);
5182                 if (!dport) {
5183                     logeventf(ssh, "Service lookup failed for destination"
5184                               " port \"%s\"", dports);
5185                 }
5186             }
5187         }
5188
5189         if (sport && dport) {
5190             /* Set up a description of the source port. */
5191             struct ssh_portfwd *pfrec, *epfrec;
5192
5193             pfrec = snew(struct ssh_portfwd);
5194             pfrec->type = type;
5195             pfrec->saddr = saddr;
5196             pfrec->sserv = sserv ? dupstr(sports) : NULL;
5197             pfrec->sport = sport;
5198             pfrec->daddr = host;
5199             pfrec->dserv = dserv ? dupstr(dports) : NULL;
5200             pfrec->dport = dport;
5201             pfrec->local = NULL;
5202             pfrec->remote = NULL;
5203             pfrec->addressfamily = (address_family == '4' ? ADDRTYPE_IPV4 :
5204                                     address_family == '6' ? ADDRTYPE_IPV6 :
5205                                     ADDRTYPE_UNSPEC);
5206
5207             epfrec = add234(ssh->portfwds, pfrec);
5208             if (epfrec != pfrec) {
5209                 if (epfrec->status == DESTROY) {
5210                     /*
5211                      * We already have a port forwarding up and running
5212                      * with precisely these parameters. Hence, no need
5213                      * to do anything; simply re-tag the existing one
5214                      * as KEEP.
5215                      */
5216                     epfrec->status = KEEP;
5217                 }
5218                 /*
5219                  * Anything else indicates that there was a duplicate
5220                  * in our input, which we'll silently ignore.
5221                  */
5222                 free_portfwd(pfrec);
5223             } else {
5224                 pfrec->status = CREATE;
5225             }
5226         } else {
5227             sfree(saddr);
5228             sfree(host);
5229         }
5230     }
5231
5232     /*
5233      * Now go through and destroy any port forwardings which were
5234      * not re-enabled.
5235      */
5236     for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
5237         if (epf->status == DESTROY) {
5238             char *message;
5239
5240             message = dupprintf("%s port forwarding from %s%s%d",
5241                                 epf->type == 'L' ? "local" :
5242                                 epf->type == 'R' ? "remote" : "dynamic",
5243                                 epf->saddr ? epf->saddr : "",
5244                                 epf->saddr ? ":" : "",
5245                                 epf->sport);
5246
5247             if (epf->type != 'D') {
5248                 char *msg2 = dupprintf("%s to %s:%d", message,
5249                                        epf->daddr, epf->dport);
5250                 sfree(message);
5251                 message = msg2;
5252             }
5253
5254             logeventf(ssh, "Cancelling %s", message);
5255             sfree(message);
5256
5257             /* epf->remote or epf->local may be NULL if setting up a
5258              * forwarding failed. */
5259             if (epf->remote) {
5260                 struct ssh_rportfwd *rpf = epf->remote;
5261                 struct Packet *pktout;
5262
5263                 /*
5264                  * Cancel the port forwarding at the server
5265                  * end.
5266                  */
5267                 if (ssh->version == 1) {
5268                     /*
5269                      * We cannot cancel listening ports on the
5270                      * server side in SSH-1! There's no message
5271                      * to support it. Instead, we simply remove
5272                      * the rportfwd record from the local end
5273                      * so that any connections the server tries
5274                      * to make on it are rejected.
5275                      */
5276                 } else {
5277                     pktout = ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST);
5278                     ssh2_pkt_addstring(pktout, "cancel-tcpip-forward");
5279                     ssh2_pkt_addbool(pktout, 0);/* _don't_ want reply */
5280                     if (epf->saddr) {
5281                         ssh2_pkt_addstring(pktout, epf->saddr);
5282                     } else if (conf_get_int(conf, CONF_rport_acceptall)) {
5283                         /* XXX: rport_acceptall may not represent
5284                          * what was used to open the original connection,
5285                          * since it's reconfigurable. */
5286                         ssh2_pkt_addstring(pktout, "");
5287                     } else {
5288                         ssh2_pkt_addstring(pktout, "localhost");
5289                     }
5290                     ssh2_pkt_adduint32(pktout, epf->sport);
5291                     ssh2_pkt_send(ssh, pktout);
5292                 }
5293
5294                 del234(ssh->rportfwds, rpf);
5295                 free_rportfwd(rpf);
5296             } else if (epf->local) {
5297                 pfl_terminate(epf->local);
5298             }
5299
5300             delpos234(ssh->portfwds, i);
5301             free_portfwd(epf);
5302             i--;                       /* so we don't skip one in the list */
5303         }
5304
5305     /*
5306      * And finally, set up any new port forwardings (status==CREATE).
5307      */
5308     for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
5309         if (epf->status == CREATE) {
5310             char *sportdesc, *dportdesc;
5311             sportdesc = dupprintf("%s%s%s%s%d%s",
5312                                   epf->saddr ? epf->saddr : "",
5313                                   epf->saddr ? ":" : "",
5314                                   epf->sserv ? epf->sserv : "",
5315                                   epf->sserv ? "(" : "",
5316                                   epf->sport,
5317                                   epf->sserv ? ")" : "");
5318             if (epf->type == 'D') {
5319                 dportdesc = NULL;
5320             } else {
5321                 dportdesc = dupprintf("%s:%s%s%d%s",
5322                                       epf->daddr,
5323                                       epf->dserv ? epf->dserv : "",
5324                                       epf->dserv ? "(" : "",
5325                                       epf->dport,
5326                                       epf->dserv ? ")" : "");
5327             }
5328
5329             if (epf->type == 'L') {
5330                 char *err = pfl_listen(epf->daddr, epf->dport,
5331                                        epf->saddr, epf->sport,
5332                                        ssh, conf, &epf->local,
5333                                        epf->addressfamily);
5334
5335                 logeventf(ssh, "Local %sport %s forwarding to %s%s%s",
5336                           epf->addressfamily == ADDRTYPE_IPV4 ? "IPv4 " :
5337                           epf->addressfamily == ADDRTYPE_IPV6 ? "IPv6 " : "",
5338                           sportdesc, dportdesc,
5339                           err ? " failed: " : "", err ? err : "");
5340                 if (err)
5341                     sfree(err);
5342             } else if (epf->type == 'D') {
5343                 char *err = pfl_listen(NULL, -1, epf->saddr, epf->sport,
5344                                        ssh, conf, &epf->local,
5345                                        epf->addressfamily);
5346
5347                 logeventf(ssh, "Local %sport %s SOCKS dynamic forwarding%s%s",
5348                           epf->addressfamily == ADDRTYPE_IPV4 ? "IPv4 " :
5349                           epf->addressfamily == ADDRTYPE_IPV6 ? "IPv6 " : "",
5350                           sportdesc,
5351                           err ? " failed: " : "", err ? err : "");
5352
5353                 if (err)
5354                     sfree(err);
5355             } else {
5356                 struct ssh_rportfwd *pf;
5357
5358                 /*
5359                  * Ensure the remote port forwardings tree exists.
5360                  */
5361                 if (!ssh->rportfwds) {
5362                     if (ssh->version == 1)
5363                         ssh->rportfwds = newtree234(ssh_rportcmp_ssh1);
5364                     else
5365                         ssh->rportfwds = newtree234(ssh_rportcmp_ssh2);
5366                 }
5367
5368                 pf = snew(struct ssh_rportfwd);
5369                 pf->share_ctx = NULL;
5370                 pf->dhost = dupstr(epf->daddr);
5371                 pf->dport = epf->dport;
5372                 if (epf->saddr) {
5373                     pf->shost = dupstr(epf->saddr);
5374                 } else if (conf_get_int(conf, CONF_rport_acceptall)) {
5375                     pf->shost = dupstr("");
5376                 } else {
5377                     pf->shost = dupstr("localhost");
5378                 }
5379                 pf->sport = epf->sport;
5380                 if (add234(ssh->rportfwds, pf) != pf) {
5381                     logeventf(ssh, "Duplicate remote port forwarding to %s:%d",
5382                               epf->daddr, epf->dport);
5383                     sfree(pf);
5384                 } else {
5385                     logeventf(ssh, "Requesting remote port %s"
5386                               " forward to %s", sportdesc, dportdesc);
5387
5388                     pf->sportdesc = sportdesc;
5389                     sportdesc = NULL;
5390                     epf->remote = pf;
5391                     pf->pfrec = epf;
5392
5393                     if (ssh->version == 1) {
5394                         send_packet(ssh, SSH1_CMSG_PORT_FORWARD_REQUEST,
5395                                     PKT_INT, epf->sport,
5396                                     PKT_STR, epf->daddr,
5397                                     PKT_INT, epf->dport,
5398                                     PKT_END);
5399                         ssh_queue_handler(ssh, SSH1_SMSG_SUCCESS,
5400                                           SSH1_SMSG_FAILURE,
5401                                           ssh_rportfwd_succfail, pf);
5402                     } else {
5403                         struct Packet *pktout;
5404                         pktout = ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST);
5405                         ssh2_pkt_addstring(pktout, "tcpip-forward");
5406                         ssh2_pkt_addbool(pktout, 1);/* want reply */
5407                         ssh2_pkt_addstring(pktout, pf->shost);
5408                         ssh2_pkt_adduint32(pktout, pf->sport);
5409                         ssh2_pkt_send(ssh, pktout);
5410
5411                         ssh_queue_handler(ssh, SSH2_MSG_REQUEST_SUCCESS,
5412                                           SSH2_MSG_REQUEST_FAILURE,
5413                                           ssh_rportfwd_succfail, pf);
5414                     }
5415                 }
5416             }
5417             sfree(sportdesc);
5418             sfree(dportdesc);
5419         }
5420 }
5421
5422 static void ssh1_smsg_stdout_stderr_data(Ssh ssh, struct Packet *pktin)
5423 {
5424     char *string;
5425     int stringlen, bufsize;
5426
5427     ssh_pkt_getstring(pktin, &string, &stringlen);
5428     if (string == NULL) {
5429         bombout(("Incoming terminal data packet was badly formed"));
5430         return;
5431     }
5432
5433     bufsize = from_backend(ssh->frontend, pktin->type == SSH1_SMSG_STDERR_DATA,
5434                            string, stringlen);
5435     if (!ssh->v1_stdout_throttling && bufsize > SSH1_BUFFER_LIMIT) {
5436         ssh->v1_stdout_throttling = 1;
5437         ssh_throttle_conn(ssh, +1);
5438     }
5439 }
5440
5441 static void ssh1_smsg_x11_open(Ssh ssh, struct Packet *pktin)
5442 {
5443     /* Remote side is trying to open a channel to talk to our
5444      * X-Server. Give them back a local channel number. */
5445     struct ssh_channel *c;
5446     int remoteid = ssh_pkt_getuint32(pktin);
5447
5448     logevent("Received X11 connect request");
5449     /* Refuse if X11 forwarding is disabled. */
5450     if (!ssh->X11_fwd_enabled) {
5451         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
5452                     PKT_INT, remoteid, PKT_END);
5453         logevent("Rejected X11 connect request");
5454     } else {
5455         c = snew(struct ssh_channel);
5456         c->ssh = ssh;
5457
5458         c->u.x11.xconn = x11_init(ssh->x11authtree, c, NULL, -1);
5459         c->remoteid = remoteid;
5460         c->halfopen = FALSE;
5461         c->localid = alloc_channel_id(ssh);
5462         c->closes = 0;
5463         c->pending_eof = FALSE;
5464         c->throttling_conn = 0;
5465         c->type = CHAN_X11;     /* identify channel type */
5466         add234(ssh->channels, c);
5467         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
5468                     PKT_INT, c->remoteid, PKT_INT,
5469                     c->localid, PKT_END);
5470         logevent("Opened X11 forward channel");
5471     }
5472 }
5473
5474 static void ssh1_smsg_agent_open(Ssh ssh, struct Packet *pktin)
5475 {
5476     /* Remote side is trying to open a channel to talk to our
5477      * agent. Give them back a local channel number. */
5478     struct ssh_channel *c;
5479     int remoteid = ssh_pkt_getuint32(pktin);
5480
5481     /* Refuse if agent forwarding is disabled. */
5482     if (!ssh->agentfwd_enabled) {
5483         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
5484                     PKT_INT, remoteid, PKT_END);
5485     } else {
5486         c = snew(struct ssh_channel);
5487         c->ssh = ssh;
5488         c->remoteid = remoteid;
5489         c->halfopen = FALSE;
5490         c->localid = alloc_channel_id(ssh);
5491         c->closes = 0;
5492         c->pending_eof = FALSE;
5493         c->throttling_conn = 0;
5494         c->type = CHAN_AGENT;   /* identify channel type */
5495         c->u.a.lensofar = 0;
5496         c->u.a.message = NULL;
5497         c->u.a.outstanding_requests = 0;
5498         add234(ssh->channels, c);
5499         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
5500                     PKT_INT, c->remoteid, PKT_INT, c->localid,
5501                     PKT_END);
5502     }
5503 }
5504
5505 static void ssh1_msg_port_open(Ssh ssh, struct Packet *pktin)
5506 {
5507     /* Remote side is trying to open a channel to talk to a
5508      * forwarded port. Give them back a local channel number. */
5509     struct ssh_rportfwd pf, *pfp;
5510     int remoteid;
5511     int hostsize, port;
5512     char *host;
5513     char *err;
5514
5515     remoteid = ssh_pkt_getuint32(pktin);
5516     ssh_pkt_getstring(pktin, &host, &hostsize);
5517     port = ssh_pkt_getuint32(pktin);
5518
5519     pf.dhost = dupprintf("%.*s", hostsize, host);
5520     pf.dport = port;
5521     pfp = find234(ssh->rportfwds, &pf, NULL);
5522
5523     if (pfp == NULL) {
5524         logeventf(ssh, "Rejected remote port open request for %s:%d",
5525                   pf.dhost, port);
5526         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
5527                     PKT_INT, remoteid, PKT_END);
5528     } else {
5529         struct ssh_channel *c = snew(struct ssh_channel);
5530         c->ssh = ssh;
5531
5532         logeventf(ssh, "Received remote port open request for %s:%d",
5533                   pf.dhost, port);
5534         err = pfd_connect(&c->u.pfd.pf, pf.dhost, port,
5535                           c, ssh->conf, pfp->pfrec->addressfamily);
5536         if (err != NULL) {
5537             logeventf(ssh, "Port open failed: %s", err);
5538             sfree(err);
5539             sfree(c);
5540             send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
5541                         PKT_INT, remoteid, PKT_END);
5542         } else {
5543             c->remoteid = remoteid;
5544             c->halfopen = FALSE;
5545             c->localid = alloc_channel_id(ssh);
5546             c->closes = 0;
5547             c->pending_eof = FALSE;
5548             c->throttling_conn = 0;
5549             c->type = CHAN_SOCKDATA;    /* identify channel type */
5550             add234(ssh->channels, c);
5551             send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
5552                         PKT_INT, c->remoteid, PKT_INT,
5553                         c->localid, PKT_END);
5554             logevent("Forwarded port opened successfully");
5555         }
5556     }
5557
5558     sfree(pf.dhost);
5559 }
5560
5561 static void ssh1_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin)
5562 {
5563     unsigned int remoteid = ssh_pkt_getuint32(pktin);
5564     unsigned int localid = ssh_pkt_getuint32(pktin);
5565     struct ssh_channel *c;
5566
5567     c = find234(ssh->channels, &remoteid, ssh_channelfind);
5568     if (c && c->type == CHAN_SOCKDATA_DORMANT) {
5569         c->remoteid = localid;
5570         c->halfopen = FALSE;
5571         c->type = CHAN_SOCKDATA;
5572         c->throttling_conn = 0;
5573         pfd_confirm(c->u.pfd.pf);
5574     }
5575
5576     if (c && c->pending_eof) {
5577         /*
5578          * We have a pending close on this channel,
5579          * which we decided on before the server acked
5580          * the channel open. So now we know the
5581          * remoteid, we can close it again.
5582          */
5583         ssh_channel_try_eof(c);
5584     }
5585 }
5586
5587 static void ssh1_msg_channel_open_failure(Ssh ssh, struct Packet *pktin)
5588 {
5589     unsigned int remoteid = ssh_pkt_getuint32(pktin);
5590     struct ssh_channel *c;
5591
5592     c = find234(ssh->channels, &remoteid, ssh_channelfind);
5593     if (c && c->type == CHAN_SOCKDATA_DORMANT) {
5594         logevent("Forwarded connection refused by server");
5595         pfd_close(c->u.pfd.pf);
5596         del234(ssh->channels, c);
5597         sfree(c);
5598     }
5599 }
5600
5601 static void ssh1_msg_channel_close(Ssh ssh, struct Packet *pktin)
5602 {
5603     /* Remote side closes a channel. */
5604     unsigned i = ssh_pkt_getuint32(pktin);
5605     struct ssh_channel *c;
5606     c = find234(ssh->channels, &i, ssh_channelfind);
5607     if (c && !c->halfopen) {
5608
5609         if (pktin->type == SSH1_MSG_CHANNEL_CLOSE &&
5610             !(c->closes & CLOSES_RCVD_EOF)) {
5611             /*
5612              * Received CHANNEL_CLOSE, which we translate into
5613              * outgoing EOF.
5614              */
5615             int send_close = FALSE;
5616
5617             c->closes |= CLOSES_RCVD_EOF;
5618
5619             switch (c->type) {
5620               case CHAN_X11:
5621                 if (c->u.x11.xconn)
5622                     x11_send_eof(c->u.x11.xconn);
5623                 else
5624                     send_close = TRUE;
5625                 break;
5626               case CHAN_SOCKDATA:
5627                 if (c->u.pfd.pf)
5628                     pfd_send_eof(c->u.pfd.pf);
5629                 else
5630                     send_close = TRUE;
5631                 break;
5632               case CHAN_AGENT:
5633                 send_close = TRUE;
5634                 break;
5635             }
5636
5637             if (send_close && !(c->closes & CLOSES_SENT_EOF)) {
5638                 send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE, PKT_INT, c->remoteid,
5639                             PKT_END);
5640                 c->closes |= CLOSES_SENT_EOF;
5641             }
5642         }
5643
5644         if (pktin->type == SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION &&
5645             !(c->closes & CLOSES_RCVD_CLOSE)) {
5646
5647             if (!(c->closes & CLOSES_SENT_EOF)) {
5648                 bombout(("Received CHANNEL_CLOSE_CONFIRMATION for channel %d"
5649                          " for which we never sent CHANNEL_CLOSE\n", i));
5650             }
5651
5652             c->closes |= CLOSES_RCVD_CLOSE;
5653         }
5654
5655         if (!((CLOSES_SENT_EOF | CLOSES_RCVD_EOF) & ~c->closes) &&
5656             !(c->closes & CLOSES_SENT_CLOSE)) {
5657             send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION,
5658                         PKT_INT, c->remoteid, PKT_END);
5659             c->closes |= CLOSES_SENT_CLOSE;
5660         }
5661
5662         if (!((CLOSES_SENT_CLOSE | CLOSES_RCVD_CLOSE) & ~c->closes))
5663             ssh_channel_destroy(c);
5664     } else {
5665         bombout(("Received CHANNEL_CLOSE%s for %s channel %d\n",
5666                  pktin->type == SSH1_MSG_CHANNEL_CLOSE ? "" :
5667                  "_CONFIRMATION", c ? "half-open" : "nonexistent",
5668                  i));
5669     }
5670 }
5671
5672 static void ssh1_msg_channel_data(Ssh ssh, struct Packet *pktin)
5673 {
5674     /* Data sent down one of our channels. */
5675     int i = ssh_pkt_getuint32(pktin);
5676     char *p;
5677     int len;
5678     struct ssh_channel *c;
5679
5680     ssh_pkt_getstring(pktin, &p, &len);
5681
5682     c = find234(ssh->channels, &i, ssh_channelfind);
5683     if (c) {
5684         int bufsize = 0;
5685         switch (c->type) {
5686           case CHAN_X11:
5687             bufsize = x11_send(c->u.x11.xconn, p, len);
5688             break;
5689           case CHAN_SOCKDATA:
5690             bufsize = pfd_send(c->u.pfd.pf, p, len);
5691             break;
5692           case CHAN_AGENT:
5693             /* Data for an agent message. Buffer it. */
5694             while (len > 0) {
5695                 if (c->u.a.lensofar < 4) {
5696                     unsigned int l = min(4 - c->u.a.lensofar, (unsigned)len);
5697                     memcpy(c->u.a.msglen + c->u.a.lensofar, p,
5698                            l);
5699                     p += l;
5700                     len -= l;
5701                     c->u.a.lensofar += l;
5702                 }
5703                 if (c->u.a.lensofar == 4) {
5704                     c->u.a.totallen =
5705                         4 + GET_32BIT(c->u.a.msglen);
5706                     c->u.a.message = snewn(c->u.a.totallen,
5707                                            unsigned char);
5708                     memcpy(c->u.a.message, c->u.a.msglen, 4);
5709                 }
5710                 if (c->u.a.lensofar >= 4 && len > 0) {
5711                     unsigned int l =
5712                         min(c->u.a.totallen - c->u.a.lensofar,
5713                             (unsigned)len);
5714                     memcpy(c->u.a.message + c->u.a.lensofar, p,
5715                            l);
5716                     p += l;
5717                     len -= l;
5718                     c->u.a.lensofar += l;
5719                 }
5720                 if (c->u.a.lensofar == c->u.a.totallen) {
5721                     void *reply;
5722                     int replylen;
5723                     c->u.a.outstanding_requests++;
5724                     if (agent_query(c->u.a.message,
5725                                     c->u.a.totallen,
5726                                     &reply, &replylen,
5727                                     ssh_agentf_callback, c))
5728                         ssh_agentf_callback(c, reply, replylen);
5729                     sfree(c->u.a.message);
5730                     c->u.a.lensofar = 0;
5731                 }
5732             }
5733             bufsize = 0;   /* agent channels never back up */
5734             break;
5735         }
5736         if (!c->throttling_conn && bufsize > SSH1_BUFFER_LIMIT) {
5737             c->throttling_conn = 1;
5738             ssh_throttle_conn(ssh, +1);
5739         }
5740     }
5741 }
5742
5743 static void ssh1_smsg_exit_status(Ssh ssh, struct Packet *pktin)
5744 {
5745     ssh->exitcode = ssh_pkt_getuint32(pktin);
5746     logeventf(ssh, "Server sent command exit status %d", ssh->exitcode);
5747     send_packet(ssh, SSH1_CMSG_EXIT_CONFIRMATION, PKT_END);
5748     /*
5749      * In case `helpful' firewalls or proxies tack
5750      * extra human-readable text on the end of the
5751      * session which we might mistake for another
5752      * encrypted packet, we close the session once
5753      * we've sent EXIT_CONFIRMATION.
5754      */
5755     ssh_disconnect(ssh, NULL, NULL, 0, TRUE);
5756 }
5757
5758 /* Helper function to deal with sending tty modes for REQUEST_PTY */
5759 static void ssh1_send_ttymode(void *data, char *mode, char *val)
5760 {
5761     struct Packet *pktout = (struct Packet *)data;
5762     int i = 0;
5763     unsigned int arg = 0;
5764     while (strcmp(mode, ssh_ttymodes[i].mode) != 0) i++;
5765     if (i == lenof(ssh_ttymodes)) return;
5766     switch (ssh_ttymodes[i].type) {
5767       case TTY_OP_CHAR:
5768         arg = ssh_tty_parse_specchar(val);
5769         break;
5770       case TTY_OP_BOOL:
5771         arg = ssh_tty_parse_boolean(val);
5772         break;
5773     }
5774     ssh2_pkt_addbyte(pktout, ssh_ttymodes[i].opcode);
5775     ssh2_pkt_addbyte(pktout, arg);
5776 }
5777
5778 int ssh_agent_forwarding_permitted(Ssh ssh)
5779 {
5780     return conf_get_int(ssh->conf, CONF_agentfwd) && agent_exists();
5781 }
5782
5783 static void do_ssh1_connection(Ssh ssh, const unsigned char *in, int inlen,
5784                                struct Packet *pktin)
5785 {
5786     crBegin(ssh->do_ssh1_connection_crstate);
5787
5788     ssh->packet_dispatch[SSH1_SMSG_STDOUT_DATA] = 
5789         ssh->packet_dispatch[SSH1_SMSG_STDERR_DATA] =
5790         ssh1_smsg_stdout_stderr_data;
5791
5792     ssh->packet_dispatch[SSH1_MSG_CHANNEL_OPEN_CONFIRMATION] =
5793         ssh1_msg_channel_open_confirmation;
5794     ssh->packet_dispatch[SSH1_MSG_CHANNEL_OPEN_FAILURE] =
5795         ssh1_msg_channel_open_failure;
5796     ssh->packet_dispatch[SSH1_MSG_CHANNEL_CLOSE] =
5797         ssh->packet_dispatch[SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION] =
5798         ssh1_msg_channel_close;
5799     ssh->packet_dispatch[SSH1_MSG_CHANNEL_DATA] = ssh1_msg_channel_data;
5800     ssh->packet_dispatch[SSH1_SMSG_EXIT_STATUS] = ssh1_smsg_exit_status;
5801
5802     if (ssh_agent_forwarding_permitted(ssh)) {
5803         logevent("Requesting agent forwarding");
5804         send_packet(ssh, SSH1_CMSG_AGENT_REQUEST_FORWARDING, PKT_END);
5805         do {
5806             crReturnV;
5807         } while (!pktin);
5808         if (pktin->type != SSH1_SMSG_SUCCESS
5809             && pktin->type != SSH1_SMSG_FAILURE) {
5810             bombout(("Protocol confusion"));
5811             crStopV;
5812         } else if (pktin->type == SSH1_SMSG_FAILURE) {
5813             logevent("Agent forwarding refused");
5814         } else {
5815             logevent("Agent forwarding enabled");
5816             ssh->agentfwd_enabled = TRUE;
5817             ssh->packet_dispatch[SSH1_SMSG_AGENT_OPEN] = ssh1_smsg_agent_open;
5818         }
5819     }
5820
5821     if (conf_get_int(ssh->conf, CONF_x11_forward)) {
5822         ssh->x11disp =
5823             x11_setup_display(conf_get_str(ssh->conf, CONF_x11_display),
5824                               ssh->conf);
5825         if (!ssh->x11disp) {
5826             /* FIXME: return an error message from x11_setup_display */
5827             logevent("X11 forwarding not enabled: unable to"
5828                      " initialise X display");
5829         } else {
5830             ssh->x11auth = x11_invent_fake_auth
5831                 (ssh->x11authtree, conf_get_int(ssh->conf, CONF_x11_auth));
5832             ssh->x11auth->disp = ssh->x11disp;
5833
5834             logevent("Requesting X11 forwarding");
5835             if (ssh->v1_local_protoflags & SSH1_PROTOFLAG_SCREEN_NUMBER) {
5836                 send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
5837                             PKT_STR, ssh->x11auth->protoname,
5838                             PKT_STR, ssh->x11auth->datastring,
5839                             PKT_INT, ssh->x11disp->screennum,
5840                             PKT_END);
5841             } else {
5842                 send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
5843                             PKT_STR, ssh->x11auth->protoname,
5844                             PKT_STR, ssh->x11auth->datastring,
5845                             PKT_END);
5846             }
5847             do {
5848                 crReturnV;
5849             } while (!pktin);
5850             if (pktin->type != SSH1_SMSG_SUCCESS
5851                 && pktin->type != SSH1_SMSG_FAILURE) {
5852                 bombout(("Protocol confusion"));
5853                 crStopV;
5854             } else if (pktin->type == SSH1_SMSG_FAILURE) {
5855                 logevent("X11 forwarding refused");
5856             } else {
5857                 logevent("X11 forwarding enabled");
5858                 ssh->X11_fwd_enabled = TRUE;
5859                 ssh->packet_dispatch[SSH1_SMSG_X11_OPEN] = ssh1_smsg_x11_open;
5860             }
5861         }
5862     }
5863
5864     ssh_setup_portfwd(ssh, ssh->conf);
5865     ssh->packet_dispatch[SSH1_MSG_PORT_OPEN] = ssh1_msg_port_open;
5866
5867     if (!conf_get_int(ssh->conf, CONF_nopty)) {
5868         struct Packet *pkt;
5869         /* Unpick the terminal-speed string. */
5870         /* XXX perhaps we should allow no speeds to be sent. */
5871         ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
5872         sscanf(conf_get_str(ssh->conf, CONF_termspeed), "%d,%d", &ssh->ospeed, &ssh->ispeed);
5873         /* Send the pty request. */
5874         pkt = ssh1_pkt_init(SSH1_CMSG_REQUEST_PTY);
5875         ssh_pkt_addstring(pkt, conf_get_str(ssh->conf, CONF_termtype));
5876         ssh_pkt_adduint32(pkt, ssh->term_height);
5877         ssh_pkt_adduint32(pkt, ssh->term_width);
5878         ssh_pkt_adduint32(pkt, 0); /* width in pixels */
5879         ssh_pkt_adduint32(pkt, 0); /* height in pixels */
5880         parse_ttymodes(ssh, ssh1_send_ttymode, (void *)pkt);
5881         ssh_pkt_addbyte(pkt, SSH1_TTY_OP_ISPEED);
5882         ssh_pkt_adduint32(pkt, ssh->ispeed);
5883         ssh_pkt_addbyte(pkt, SSH1_TTY_OP_OSPEED);
5884         ssh_pkt_adduint32(pkt, ssh->ospeed);
5885         ssh_pkt_addbyte(pkt, SSH_TTY_OP_END);
5886         s_wrpkt(ssh, pkt);
5887         ssh->state = SSH_STATE_INTERMED;
5888         do {
5889             crReturnV;
5890         } while (!pktin);
5891         if (pktin->type != SSH1_SMSG_SUCCESS
5892             && pktin->type != SSH1_SMSG_FAILURE) {
5893             bombout(("Protocol confusion"));
5894             crStopV;
5895         } else if (pktin->type == SSH1_SMSG_FAILURE) {
5896             c_write_str(ssh, "Server refused to allocate pty\r\n");
5897             ssh->editing = ssh->echoing = 1;
5898         } else {
5899             logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
5900                       ssh->ospeed, ssh->ispeed);
5901             ssh->got_pty = TRUE;
5902         }
5903     } else {
5904         ssh->editing = ssh->echoing = 1;
5905     }
5906
5907     if (conf_get_int(ssh->conf, CONF_compression)) {
5908         send_packet(ssh, SSH1_CMSG_REQUEST_COMPRESSION, PKT_INT, 6, PKT_END);
5909         do {
5910             crReturnV;
5911         } while (!pktin);
5912         if (pktin->type != SSH1_SMSG_SUCCESS
5913             && pktin->type != SSH1_SMSG_FAILURE) {
5914             bombout(("Protocol confusion"));
5915             crStopV;
5916         } else if (pktin->type == SSH1_SMSG_FAILURE) {
5917             c_write_str(ssh, "Server refused to compress\r\n");
5918         }
5919         logevent("Started compression");
5920         ssh->v1_compressing = TRUE;
5921         ssh->cs_comp_ctx = zlib_compress_init();
5922         logevent("Initialised zlib (RFC1950) compression");
5923         ssh->sc_comp_ctx = zlib_decompress_init();
5924         logevent("Initialised zlib (RFC1950) decompression");
5925     }
5926
5927     /*
5928      * Start the shell or command.
5929      * 
5930      * Special case: if the first-choice command is an SSH-2
5931      * subsystem (hence not usable here) and the second choice
5932      * exists, we fall straight back to that.
5933      */
5934     {
5935         char *cmd = conf_get_str(ssh->conf, CONF_remote_cmd);
5936         
5937         if (conf_get_int(ssh->conf, CONF_ssh_subsys) &&
5938             conf_get_str(ssh->conf, CONF_remote_cmd2)) {
5939             cmd = conf_get_str(ssh->conf, CONF_remote_cmd2);
5940             ssh->fallback_cmd = TRUE;
5941         }
5942         if (*cmd)
5943             send_packet(ssh, SSH1_CMSG_EXEC_CMD, PKT_STR, cmd, PKT_END);
5944         else
5945             send_packet(ssh, SSH1_CMSG_EXEC_SHELL, PKT_END);
5946         logevent("Started session");
5947     }
5948
5949     ssh->state = SSH_STATE_SESSION;
5950     if (ssh->size_needed)
5951         ssh_size(ssh, ssh->term_width, ssh->term_height);
5952     if (ssh->eof_needed)
5953         ssh_special(ssh, TS_EOF);
5954
5955     if (ssh->ldisc)
5956         ldisc_echoedit_update(ssh->ldisc);  /* cause ldisc to notice changes */
5957     ssh->send_ok = 1;
5958     ssh->channels = newtree234(ssh_channelcmp);
5959     while (1) {
5960
5961         /*
5962          * By this point, most incoming packets are already being
5963          * handled by the dispatch table, and we need only pay
5964          * attention to the unusual ones.
5965          */
5966
5967         crReturnV;
5968         if (pktin) {
5969             if (pktin->type == SSH1_SMSG_SUCCESS) {
5970                 /* may be from EXEC_SHELL on some servers */
5971             } else if (pktin->type == SSH1_SMSG_FAILURE) {
5972                 /* may be from EXEC_SHELL on some servers
5973                  * if no pty is available or in other odd cases. Ignore */
5974             } else {
5975                 bombout(("Strange packet received: type %d", pktin->type));
5976                 crStopV;
5977             }
5978         } else {
5979             while (inlen > 0) {
5980                 int len = min(inlen, 512);
5981                 send_packet(ssh, SSH1_CMSG_STDIN_DATA,
5982                             PKT_INT, len, PKT_DATA, in, len,
5983                             PKT_END);
5984                 in += len;
5985                 inlen -= len;
5986             }
5987         }
5988     }
5989
5990     crFinishV;
5991 }
5992
5993 /*
5994  * Handle the top-level SSH-2 protocol.
5995  */
5996 static void ssh1_msg_debug(Ssh ssh, struct Packet *pktin)
5997 {
5998     char *msg;
5999     int msglen;
6000
6001     ssh_pkt_getstring(pktin, &msg, &msglen);
6002     logeventf(ssh, "Remote debug message: %.*s", msglen, msg);
6003 }
6004
6005 static void ssh1_msg_disconnect(Ssh ssh, struct Packet *pktin)
6006 {
6007     /* log reason code in disconnect message */
6008     char *msg;
6009     int msglen;
6010
6011     ssh_pkt_getstring(pktin, &msg, &msglen);
6012     bombout(("Server sent disconnect message:\n\"%.*s\"", msglen, msg));
6013 }
6014
6015 static void ssh_msg_ignore(Ssh ssh, struct Packet *pktin)
6016 {
6017     /* Do nothing, because we're ignoring it! Duhh. */
6018 }
6019
6020 static void ssh1_protocol_setup(Ssh ssh)
6021 {
6022     int i;
6023
6024     /*
6025      * Most messages are handled by the coroutines.
6026      */
6027     for (i = 0; i < 256; i++)
6028         ssh->packet_dispatch[i] = NULL;
6029
6030     /*
6031      * These special message types we install handlers for.
6032      */
6033     ssh->packet_dispatch[SSH1_MSG_DISCONNECT] = ssh1_msg_disconnect;
6034     ssh->packet_dispatch[SSH1_MSG_IGNORE] = ssh_msg_ignore;
6035     ssh->packet_dispatch[SSH1_MSG_DEBUG] = ssh1_msg_debug;
6036 }
6037
6038 static void ssh1_protocol(Ssh ssh, const void *vin, int inlen,
6039                           struct Packet *pktin)
6040 {
6041     const unsigned char *in = (const unsigned char *)vin;
6042     if (ssh->state == SSH_STATE_CLOSED)
6043         return;
6044
6045     if (pktin && ssh->packet_dispatch[pktin->type]) {
6046         ssh->packet_dispatch[pktin->type](ssh, pktin);
6047         return;
6048     }
6049
6050     if (!ssh->protocol_initial_phase_done) {
6051         if (do_ssh1_login(ssh, in, inlen, pktin))
6052             ssh->protocol_initial_phase_done = TRUE;
6053         else
6054             return;
6055     }
6056
6057     do_ssh1_connection(ssh, in, inlen, pktin);
6058 }
6059
6060 /*
6061  * Utility routines for decoding comma-separated strings in KEXINIT.
6062  */
6063 static int first_in_commasep_string(char const *needle, char const *haystack,
6064                                     int haylen)
6065 {
6066     int needlen;
6067     if (!needle || !haystack)          /* protect against null pointers */
6068         return 0;
6069     needlen = strlen(needle);
6070
6071     if (haylen >= needlen &&       /* haystack is long enough */
6072         !memcmp(needle, haystack, needlen) &&   /* initial match */
6073         (haylen == needlen || haystack[needlen] == ',')
6074         /* either , or EOS follows */
6075         )
6076         return 1;
6077     return 0;
6078 }
6079
6080 static int in_commasep_string(char const *needle, char const *haystack,
6081                               int haylen)
6082 {
6083     char *p;
6084
6085     if (!needle || !haystack)          /* protect against null pointers */
6086         return 0;
6087     /*
6088      * Is it at the start of the string?
6089      */
6090     if (first_in_commasep_string(needle, haystack, haylen))
6091         return 1;
6092     /*
6093      * If not, search for the next comma and resume after that.
6094      * If no comma found, terminate.
6095      */
6096     p = memchr(haystack, ',', haylen);
6097     if (!p) return 0;
6098     /* + 1 to skip over comma */
6099     return in_commasep_string(needle, p + 1, haylen - (p + 1 - haystack));
6100 }
6101
6102 /*
6103  * Add a value to the comma-separated string at the end of the packet.
6104  * If the value is already in the string, don't bother adding it again.
6105  */
6106 static void ssh2_pkt_addstring_commasep(struct Packet *pkt, const char *data)
6107 {
6108     if (in_commasep_string(data, (char *)pkt->data + pkt->savedpos,
6109                            pkt->length - pkt->savedpos)) return;
6110     if (pkt->length - pkt->savedpos > 0)
6111         ssh_pkt_addstring_str(pkt, ",");
6112     ssh_pkt_addstring_str(pkt, data);
6113 }
6114
6115
6116 /*
6117  * SSH-2 key creation method.
6118  * (Currently assumes 2 lots of any hash are sufficient to generate
6119  * keys/IVs for any cipher/MAC. SSH2_MKKEY_ITERS documents this assumption.)
6120  */
6121 #define SSH2_MKKEY_ITERS (2)
6122 static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H, char chr,
6123                        unsigned char *keyspace)
6124 {
6125     const struct ssh_hash *h = ssh->kex->hash;
6126     void *s;
6127     /* First hlen bytes. */
6128     s = h->init();
6129     if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY))
6130         hash_mpint(h, s, K);
6131     h->bytes(s, H, h->hlen);
6132     h->bytes(s, &chr, 1);
6133     h->bytes(s, ssh->v2_session_id, ssh->v2_session_id_len);
6134     h->final(s, keyspace);
6135     /* Next hlen bytes. */
6136     s = h->init();
6137     if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY))
6138         hash_mpint(h, s, K);
6139     h->bytes(s, H, h->hlen);
6140     h->bytes(s, keyspace, h->hlen);
6141     h->final(s, keyspace + h->hlen);
6142 }
6143
6144 /*
6145  * Handle the SSH-2 transport layer.
6146  */
6147 static void do_ssh2_transport(Ssh ssh, const void *vin, int inlen,
6148                              struct Packet *pktin)
6149 {
6150     const unsigned char *in = (const unsigned char *)vin;
6151     enum kexlist {
6152         KEXLIST_KEX, KEXLIST_HOSTKEY, KEXLIST_CSCIPHER, KEXLIST_SCCIPHER,
6153         KEXLIST_CSMAC, KEXLIST_SCMAC, KEXLIST_CSCOMP, KEXLIST_SCCOMP,
6154         NKEXLIST
6155     };
6156     const char * kexlist_descr[NKEXLIST] = {
6157         "key exchange algorithm", "host key algorithm",
6158         "client-to-server cipher", "server-to-client cipher",
6159         "client-to-server MAC", "server-to-client MAC",
6160         "client-to-server compression method",
6161         "server-to-client compression method" };
6162     struct do_ssh2_transport_state {
6163         int crLine;
6164         int nbits, pbits, warn_kex, warn_cscipher, warn_sccipher;
6165         Bignum p, g, e, f, K;
6166         void *our_kexinit;
6167         int our_kexinitlen;
6168         int kex_init_value, kex_reply_value;
6169         const struct ssh_mac **maclist;
6170         int nmacs;
6171         const struct ssh2_cipher *cscipher_tobe;
6172         const struct ssh2_cipher *sccipher_tobe;
6173         const struct ssh_mac *csmac_tobe;
6174         const struct ssh_mac *scmac_tobe;
6175         int csmac_etm_tobe, scmac_etm_tobe;
6176         const struct ssh_compress *cscomp_tobe;
6177         const struct ssh_compress *sccomp_tobe;
6178         char *hostkeydata, *sigdata, *rsakeydata, *keystr, *fingerprint;
6179         int hostkeylen, siglen, rsakeylen;
6180         void *hkey;                    /* actual host key */
6181         void *rsakey;                  /* for RSA kex */
6182         void *eckey;                   /* for ECDH kex */
6183         unsigned char exchange_hash[SSH2_KEX_MAX_HASH_LEN];
6184         int n_preferred_kex;
6185         const struct ssh_kexes *preferred_kex[KEX_MAX];
6186         int n_preferred_ciphers;
6187         const struct ssh2_ciphers *preferred_ciphers[CIPHER_MAX];
6188         const struct ssh_compress *preferred_comp;
6189         int userauth_succeeded;     /* for delayed compression */
6190         int pending_compression;
6191         int got_session_id, activated_authconn;
6192         struct Packet *pktout;
6193         int dlgret;
6194         int guessok;
6195         int ignorepkt;
6196 #define MAXKEXLIST 16
6197         struct kexinit_algorithm {
6198             const char *name;
6199             union {
6200                 struct {
6201                     const struct ssh_kex *kex;
6202                     int warn;
6203                 } kex;
6204                 const struct ssh_signkey *hostkey;
6205                 struct {
6206                     const struct ssh2_cipher *cipher;
6207                     int warn;
6208                 } cipher;
6209                 struct {
6210                     const struct ssh_mac *mac;
6211                     int etm;
6212                 } mac;
6213                 const struct ssh_compress *comp;
6214             } u;
6215         } kexlists[NKEXLIST][MAXKEXLIST];
6216     };
6217     crState(do_ssh2_transport_state);
6218
6219     assert(!ssh->bare_connection);
6220
6221     crBeginState;
6222
6223     s->cscipher_tobe = s->sccipher_tobe = NULL;
6224     s->csmac_tobe = s->scmac_tobe = NULL;
6225     s->cscomp_tobe = s->sccomp_tobe = NULL;
6226
6227     s->got_session_id = s->activated_authconn = FALSE;
6228     s->userauth_succeeded = FALSE;
6229     s->pending_compression = FALSE;
6230
6231     /*
6232      * Be prepared to work around the buggy MAC problem.
6233      */
6234     if (ssh->remote_bugs & BUG_SSH2_HMAC)
6235         s->maclist = buggymacs, s->nmacs = lenof(buggymacs);
6236     else
6237         s->maclist = macs, s->nmacs = lenof(macs);
6238
6239   begin_key_exchange:
6240     ssh->pkt_kctx = SSH2_PKTCTX_NOKEX;
6241     {
6242         int i, j, k, n, warn;
6243
6244         /*
6245          * Set up the preferred key exchange. (NULL => warn below here)
6246          */
6247         s->n_preferred_kex = 0;
6248         for (i = 0; i < KEX_MAX; i++) {
6249             switch (conf_get_int_int(ssh->conf, CONF_ssh_kexlist, i)) {
6250               case KEX_DHGEX:
6251                 s->preferred_kex[s->n_preferred_kex++] =
6252                     &ssh_diffiehellman_gex;
6253                 break;
6254               case KEX_DHGROUP14:
6255                 s->preferred_kex[s->n_preferred_kex++] =
6256                     &ssh_diffiehellman_group14;
6257                 break;
6258               case KEX_DHGROUP1:
6259                 s->preferred_kex[s->n_preferred_kex++] =
6260                     &ssh_diffiehellman_group1;
6261                 break;
6262               case KEX_RSA:
6263                 s->preferred_kex[s->n_preferred_kex++] =
6264                     &ssh_rsa_kex;
6265                 break;
6266               case KEX_ECDH:
6267                 s->preferred_kex[s->n_preferred_kex++] =
6268                     &ssh_ecdh_kex;
6269                 break;
6270               case KEX_WARN:
6271                 /* Flag for later. Don't bother if it's the last in
6272                  * the list. */
6273                 if (i < KEX_MAX - 1) {
6274                     s->preferred_kex[s->n_preferred_kex++] = NULL;
6275                 }
6276                 break;
6277             }
6278         }
6279
6280         /*
6281          * Set up the preferred ciphers. (NULL => warn below here)
6282          */
6283         s->n_preferred_ciphers = 0;
6284         for (i = 0; i < CIPHER_MAX; i++) {
6285             switch (conf_get_int_int(ssh->conf, CONF_ssh_cipherlist, i)) {
6286               case CIPHER_BLOWFISH:
6287                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_blowfish;
6288                 break;
6289               case CIPHER_DES:
6290                 if (conf_get_int(ssh->conf, CONF_ssh2_des_cbc)) {
6291                     s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_des;
6292                 }
6293                 break;
6294               case CIPHER_3DES:
6295                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_3des;
6296                 break;
6297               case CIPHER_AES:
6298                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_aes;
6299                 break;
6300               case CIPHER_ARCFOUR:
6301                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_arcfour;
6302                 break;
6303               case CIPHER_WARN:
6304                 /* Flag for later. Don't bother if it's the last in
6305                  * the list. */
6306                 if (i < CIPHER_MAX - 1) {
6307                     s->preferred_ciphers[s->n_preferred_ciphers++] = NULL;
6308                 }
6309                 break;
6310             }
6311         }
6312
6313         /*
6314          * Set up preferred compression.
6315          */
6316         if (conf_get_int(ssh->conf, CONF_compression))
6317             s->preferred_comp = &ssh_zlib;
6318         else
6319             s->preferred_comp = &ssh_comp_none;
6320
6321         /*
6322          * Enable queueing of outgoing auth- or connection-layer
6323          * packets while we are in the middle of a key exchange.
6324          */
6325         ssh->queueing = TRUE;
6326
6327         /*
6328          * Flag that KEX is in progress.
6329          */
6330         ssh->kex_in_progress = TRUE;
6331
6332         for (i = 0; i < NKEXLIST; i++)
6333             for (j = 0; j < MAXKEXLIST; j++)
6334                 s->kexlists[i][j].name = NULL;
6335         /* List key exchange algorithms. */
6336         n = 0;
6337         warn = FALSE;
6338         for (i = 0; i < s->n_preferred_kex; i++) {
6339             const struct ssh_kexes *k = s->preferred_kex[i];
6340             if (!k) warn = TRUE;
6341             else for (j = 0; j < k->nkexes; j++) {
6342                 assert(n < MAXKEXLIST);
6343                 s->kexlists[KEXLIST_KEX][n].name = k->list[j]->name;
6344                 s->kexlists[KEXLIST_KEX][n].u.kex.kex = k->list[j];
6345                 s->kexlists[KEXLIST_KEX][n].u.kex.warn = warn;
6346                 n++;
6347             }
6348         }
6349         /* List server host key algorithms. */
6350         if (!s->got_session_id) {
6351             /*
6352              * In the first key exchange, we list all the algorithms
6353              * we're prepared to cope with.
6354              */
6355             n = 0;
6356             for (i = 0; i < lenof(hostkey_algs); i++) {
6357                 assert(n < MAXKEXLIST);
6358                 s->kexlists[KEXLIST_HOSTKEY][n].name = hostkey_algs[i]->name;
6359                 s->kexlists[KEXLIST_HOSTKEY][n].u.hostkey = hostkey_algs[i];
6360                 n++;
6361             }
6362         } else {
6363             /*
6364              * In subsequent key exchanges, we list only the kex
6365              * algorithm that was selected in the first key exchange,
6366              * so that we keep getting the same host key and hence
6367              * don't have to interrupt the user's session to ask for
6368              * reverification.
6369              */
6370             assert(ssh->kex);
6371             s->kexlists[KEXLIST_HOSTKEY][0].name = ssh->hostkey->name;
6372             s->kexlists[KEXLIST_HOSTKEY][0].u.hostkey = ssh->hostkey;
6373         }
6374         /* List encryption algorithms (client->server then server->client). */
6375         for (k = KEXLIST_CSCIPHER; k <= KEXLIST_SCCIPHER; k++) {
6376             n = 0;
6377             warn = FALSE;
6378             for (i = 0; i < s->n_preferred_ciphers; i++) {
6379                 const struct ssh2_ciphers *c = s->preferred_ciphers[i];
6380                 if (!c) warn = TRUE;
6381                 else for (j = 0; j < c->nciphers; j++) {
6382                     assert(n < MAXKEXLIST);
6383                     s->kexlists[k][n].name =  c->list[j]->name;
6384                     s->kexlists[k][n].u.cipher.cipher = c->list[j];
6385                     s->kexlists[k][n].u.cipher.warn = warn;
6386                     n++;
6387                 }
6388             }
6389         }
6390         /* List MAC algorithms (client->server then server->client). */
6391         for (j = KEXLIST_CSMAC; j <= KEXLIST_SCMAC; j++) {
6392             n = 0;
6393             for (i = 0; i < s->nmacs; i++) {
6394                 assert(n < MAXKEXLIST);
6395                 s->kexlists[j][n].name =  s->maclist[i]->name;
6396                 s->kexlists[j][n].u.mac.mac = s->maclist[i];
6397                 s->kexlists[j][n].u.mac.etm = FALSE;
6398                 n++;
6399             }
6400             for (i = 0; i < s->nmacs; i++)
6401                 /* For each MAC, there may also be an ETM version,
6402                  * which we list second. */
6403                 if (s->maclist[i]->etm_name) {
6404                     assert(n < MAXKEXLIST);
6405                     s->kexlists[j][n].name =  s->maclist[i]->etm_name;
6406                     s->kexlists[j][n].u.mac.mac = s->maclist[i];
6407                     s->kexlists[j][n].u.mac.etm = TRUE;
6408                     n++;
6409                 }
6410         }
6411         /* List client->server compression algorithms,
6412          * then server->client compression algorithms. (We use the
6413          * same set twice.) */
6414         for (j = KEXLIST_CSCOMP; j <= KEXLIST_SCCOMP; j++) {
6415             assert(lenof(compressions) > 1);
6416             /* Prefer non-delayed versions */
6417             s->kexlists[j][0].name = s->preferred_comp->name;
6418             s->kexlists[j][0].u.comp = s->preferred_comp;
6419             /* We don't even list delayed versions of algorithms until
6420              * they're allowed to be used, to avoid a race. See the end of
6421              * this function. */
6422             n = 1;
6423             if (s->userauth_succeeded && s->preferred_comp->delayed_name) {
6424                 s->kexlists[j][1].name = s->preferred_comp->delayed_name;
6425                 s->kexlists[j][1].u.comp = s->preferred_comp;
6426                 n = 2;
6427             }
6428             for (i = 0; i < lenof(compressions); i++) {
6429                 const struct ssh_compress *c = compressions[i];
6430                 s->kexlists[j][n].name = c->name;
6431                 s->kexlists[j][n].u.comp = c;
6432                 n++;
6433                 if (s->userauth_succeeded && c->delayed_name) {
6434                     s->kexlists[j][n].name = c->delayed_name;
6435                     s->kexlists[j][n].u.comp = c;
6436                     n++;
6437                 }
6438             }
6439         }
6440         /*
6441          * Construct and send our key exchange packet.
6442          */
6443         s->pktout = ssh2_pkt_init(SSH2_MSG_KEXINIT);
6444         for (i = 0; i < 16; i++)
6445             ssh2_pkt_addbyte(s->pktout, (unsigned char) random_byte());
6446         for (i = 0; i < NKEXLIST; i++) {
6447             ssh2_pkt_addstring_start(s->pktout);
6448             for (j = 0; j < MAXKEXLIST; j++) {
6449                 if (s->kexlists[i][j].name == NULL) break;
6450                 ssh2_pkt_addstring_commasep(s->pktout, s->kexlists[i][j].name);
6451             }
6452         }
6453         /* List client->server languages. Empty list. */
6454         ssh2_pkt_addstring_start(s->pktout);
6455         /* List server->client languages. Empty list. */
6456         ssh2_pkt_addstring_start(s->pktout);
6457         /* First KEX packet does _not_ follow, because we're not that brave. */
6458         ssh2_pkt_addbool(s->pktout, FALSE);
6459         /* Reserved. */
6460         ssh2_pkt_adduint32(s->pktout, 0);
6461     }
6462
6463     s->our_kexinitlen = s->pktout->length - 5;
6464     s->our_kexinit = snewn(s->our_kexinitlen, unsigned char);
6465     memcpy(s->our_kexinit, s->pktout->data + 5, s->our_kexinitlen); 
6466
6467     ssh2_pkt_send_noqueue(ssh, s->pktout);
6468
6469     if (!pktin)
6470         crWaitUntilV(pktin);
6471
6472     /*
6473      * Now examine the other side's KEXINIT to see what we're up
6474      * to.
6475      */
6476     {
6477         char *str;
6478         int i, j, len;
6479
6480         if (pktin->type != SSH2_MSG_KEXINIT) {
6481             bombout(("expected key exchange packet from server"));
6482             crStopV;
6483         }
6484         ssh->kex = NULL;
6485         ssh->hostkey = NULL;
6486         s->cscipher_tobe = NULL;
6487         s->sccipher_tobe = NULL;
6488         s->csmac_tobe = NULL;
6489         s->scmac_tobe = NULL;
6490         s->cscomp_tobe = NULL;
6491         s->sccomp_tobe = NULL;
6492         s->warn_kex = s->warn_cscipher = s->warn_sccipher = FALSE;
6493
6494         pktin->savedpos += 16;          /* skip garbage cookie */
6495
6496         s->guessok = FALSE;
6497         for (i = 0; i < NKEXLIST; i++) {
6498             ssh_pkt_getstring(pktin, &str, &len);
6499             if (!str) {
6500                 bombout(("KEXINIT packet was incomplete"));
6501                 crStopV;
6502             }
6503             for (j = 0; j < MAXKEXLIST; j++) {
6504                 struct kexinit_algorithm *alg = &s->kexlists[i][j];
6505                 if (alg->name == NULL) break;
6506                 if (in_commasep_string(alg->name, str, len)) {
6507                     /* We've found a matching algorithm. */
6508                     if (i == KEXLIST_KEX || i == KEXLIST_HOSTKEY) {
6509                         /* Check if we might need to ignore first kex pkt */
6510                         if (j != 0 ||
6511                             !first_in_commasep_string(alg->name, str, len))
6512                             s->guessok = FALSE;
6513                     }
6514                     if (i == KEXLIST_KEX) {
6515                         ssh->kex = alg->u.kex.kex;
6516                         s->warn_kex = alg->u.kex.warn;
6517                     } else if (i == KEXLIST_HOSTKEY) {
6518                         ssh->hostkey = alg->u.hostkey;
6519                     } else if (i == KEXLIST_CSCIPHER) {
6520                         s->cscipher_tobe = alg->u.cipher.cipher;
6521                         s->warn_cscipher = alg->u.cipher.warn;
6522                     } else if (i == KEXLIST_SCCIPHER) {
6523                         s->sccipher_tobe = alg->u.cipher.cipher;
6524                         s->warn_sccipher = alg->u.cipher.warn;
6525                     } else if (i == KEXLIST_CSMAC) {
6526                         s->csmac_tobe = alg->u.mac.mac;
6527                         s->csmac_etm_tobe = alg->u.mac.etm;
6528                     } else if (i == KEXLIST_SCMAC) {
6529                         s->scmac_tobe = alg->u.mac.mac;
6530                         s->scmac_etm_tobe = alg->u.mac.etm;
6531                     } else if (i == KEXLIST_CSCOMP) {
6532                         s->cscomp_tobe = alg->u.comp;
6533                     } else if (i == KEXLIST_SCCOMP) {
6534                         s->sccomp_tobe = alg->u.comp;
6535                     }
6536                     goto matched;
6537                 }
6538                 if ((i == KEXLIST_CSCOMP || i == KEXLIST_SCCOMP) &&
6539                     in_commasep_string(alg->u.comp->delayed_name, str, len))
6540                     s->pending_compression = TRUE;  /* try this later */
6541             }
6542             bombout(("Couldn't agree a %s ((available: %.*s)",
6543                      kexlist_descr[i], len, str));
6544             crStopV;
6545           matched:;
6546         }
6547         if (s->pending_compression) {
6548             logevent("Server supports delayed compression; "
6549                      "will try this later");
6550         }
6551         ssh_pkt_getstring(pktin, &str, &len);  /* client->server language */
6552         ssh_pkt_getstring(pktin, &str, &len);  /* server->client language */
6553         s->ignorepkt = ssh2_pkt_getbool(pktin) && !s->guessok;
6554
6555         ssh->exhash = ssh->kex->hash->init();
6556         hash_string(ssh->kex->hash, ssh->exhash, ssh->v_c, strlen(ssh->v_c));
6557         hash_string(ssh->kex->hash, ssh->exhash, ssh->v_s, strlen(ssh->v_s));
6558         hash_string(ssh->kex->hash, ssh->exhash,
6559             s->our_kexinit, s->our_kexinitlen);
6560         sfree(s->our_kexinit);
6561         /* Include the type byte in the hash of server's KEXINIT */
6562         hash_string(ssh->kex->hash, ssh->exhash,
6563                     pktin->body - 1, pktin->length + 1);
6564
6565         if (s->warn_kex) {
6566             ssh_set_frozen(ssh, 1);
6567             s->dlgret = askalg(ssh->frontend, "key-exchange algorithm",
6568                                ssh->kex->name,
6569                                ssh_dialog_callback, ssh);
6570             if (s->dlgret < 0) {
6571                 do {
6572                     crReturnV;
6573                     if (pktin) {
6574                         bombout(("Unexpected data from server while"
6575                                  " waiting for user response"));
6576                         crStopV;
6577                     }
6578                 } while (pktin || inlen > 0);
6579                 s->dlgret = ssh->user_response;
6580             }
6581             ssh_set_frozen(ssh, 0);
6582             if (s->dlgret == 0) {
6583                 ssh_disconnect(ssh, "User aborted at kex warning", NULL,
6584                                0, TRUE);
6585                 crStopV;
6586             }
6587         }
6588
6589         if (s->warn_cscipher) {
6590             ssh_set_frozen(ssh, 1);
6591             s->dlgret = askalg(ssh->frontend,
6592                                "client-to-server cipher",
6593                                s->cscipher_tobe->name,
6594                                ssh_dialog_callback, ssh);
6595             if (s->dlgret < 0) {
6596                 do {
6597                     crReturnV;
6598                     if (pktin) {
6599                         bombout(("Unexpected data from server while"
6600                                  " waiting for user response"));
6601                         crStopV;
6602                     }
6603                 } while (pktin || inlen > 0);
6604                 s->dlgret = ssh->user_response;
6605             }
6606             ssh_set_frozen(ssh, 0);
6607             if (s->dlgret == 0) {
6608                 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
6609                                0, TRUE);
6610                 crStopV;
6611             }
6612         }
6613
6614         if (s->warn_sccipher) {
6615             ssh_set_frozen(ssh, 1);
6616             s->dlgret = askalg(ssh->frontend,
6617                                "server-to-client cipher",
6618                                s->sccipher_tobe->name,
6619                                ssh_dialog_callback, ssh);
6620             if (s->dlgret < 0) {
6621                 do {
6622                     crReturnV;
6623                     if (pktin) {
6624                         bombout(("Unexpected data from server while"
6625                                  " waiting for user response"));
6626                         crStopV;
6627                     }
6628                 } while (pktin || inlen > 0);
6629                 s->dlgret = ssh->user_response;
6630             }
6631             ssh_set_frozen(ssh, 0);
6632             if (s->dlgret == 0) {
6633                 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
6634                                0, TRUE);
6635                 crStopV;
6636             }
6637         }
6638
6639         if (s->ignorepkt) /* first_kex_packet_follows */
6640             crWaitUntilV(pktin);                /* Ignore packet */
6641     }
6642
6643     if (ssh->kex->main_type == KEXTYPE_DH) {
6644         /*
6645          * Work out the number of bits of key we will need from the
6646          * key exchange. We start with the maximum key length of
6647          * either cipher...
6648          */
6649         {
6650             int csbits, scbits;
6651
6652             csbits = s->cscipher_tobe->keylen;
6653             scbits = s->sccipher_tobe->keylen;
6654             s->nbits = (csbits > scbits ? csbits : scbits);
6655         }
6656         /* The keys only have hlen-bit entropy, since they're based on
6657          * a hash. So cap the key size at hlen bits. */
6658         if (s->nbits > ssh->kex->hash->hlen * 8)
6659             s->nbits = ssh->kex->hash->hlen * 8;
6660
6661         /*
6662          * If we're doing Diffie-Hellman group exchange, start by
6663          * requesting a group.
6664          */
6665         if (dh_is_gex(ssh->kex)) {
6666             logevent("Doing Diffie-Hellman group exchange");
6667             ssh->pkt_kctx = SSH2_PKTCTX_DHGEX;
6668             /*
6669              * Work out how big a DH group we will need to allow that
6670              * much data.
6671              */
6672             s->pbits = 512 << ((s->nbits - 1) / 64);
6673             if (s->pbits < DH_MIN_SIZE)
6674                 s->pbits = DH_MIN_SIZE;
6675             if (s->pbits > DH_MAX_SIZE)
6676                 s->pbits = DH_MAX_SIZE;
6677             if ((ssh->remote_bugs & BUG_SSH2_OLDGEX)) {
6678                 s->pktout = ssh2_pkt_init(SSH2_MSG_KEX_DH_GEX_REQUEST_OLD);
6679                 ssh2_pkt_adduint32(s->pktout, s->pbits);
6680             } else {
6681                 s->pktout = ssh2_pkt_init(SSH2_MSG_KEX_DH_GEX_REQUEST);
6682                 ssh2_pkt_adduint32(s->pktout, DH_MIN_SIZE);
6683                 ssh2_pkt_adduint32(s->pktout, s->pbits);
6684                 ssh2_pkt_adduint32(s->pktout, DH_MAX_SIZE);
6685             }
6686             ssh2_pkt_send_noqueue(ssh, s->pktout);
6687
6688             crWaitUntilV(pktin);
6689             if (pktin->type != SSH2_MSG_KEX_DH_GEX_GROUP) {
6690                 bombout(("expected key exchange group packet from server"));
6691                 crStopV;
6692             }
6693             s->p = ssh2_pkt_getmp(pktin);
6694             s->g = ssh2_pkt_getmp(pktin);
6695             if (!s->p || !s->g) {
6696                 bombout(("unable to read mp-ints from incoming group packet"));
6697                 crStopV;
6698             }
6699             ssh->kex_ctx = dh_setup_gex(s->p, s->g);
6700             s->kex_init_value = SSH2_MSG_KEX_DH_GEX_INIT;
6701             s->kex_reply_value = SSH2_MSG_KEX_DH_GEX_REPLY;
6702         } else {
6703             ssh->pkt_kctx = SSH2_PKTCTX_DHGROUP;
6704             ssh->kex_ctx = dh_setup_group(ssh->kex);
6705             s->kex_init_value = SSH2_MSG_KEXDH_INIT;
6706             s->kex_reply_value = SSH2_MSG_KEXDH_REPLY;
6707             logeventf(ssh, "Using Diffie-Hellman with standard group \"%s\"",
6708                       ssh->kex->groupname);
6709         }
6710
6711         logeventf(ssh, "Doing Diffie-Hellman key exchange with hash %s",
6712                   ssh->kex->hash->text_name);
6713         /*
6714          * Now generate and send e for Diffie-Hellman.
6715          */
6716         set_busy_status(ssh->frontend, BUSY_CPU); /* this can take a while */
6717         s->e = dh_create_e(ssh->kex_ctx, s->nbits * 2);
6718         s->pktout = ssh2_pkt_init(s->kex_init_value);
6719         ssh2_pkt_addmp(s->pktout, s->e);
6720         ssh2_pkt_send_noqueue(ssh, s->pktout);
6721
6722         set_busy_status(ssh->frontend, BUSY_WAITING); /* wait for server */
6723         crWaitUntilV(pktin);
6724         if (pktin->type != s->kex_reply_value) {
6725             bombout(("expected key exchange reply packet from server"));
6726             crStopV;
6727         }
6728         set_busy_status(ssh->frontend, BUSY_CPU); /* cogitate */
6729         ssh_pkt_getstring(pktin, &s->hostkeydata, &s->hostkeylen);
6730         s->hkey = ssh->hostkey->newkey(ssh->hostkey,
6731                                        s->hostkeydata, s->hostkeylen);
6732         s->f = ssh2_pkt_getmp(pktin);
6733         if (!s->f) {
6734             bombout(("unable to parse key exchange reply packet"));
6735             crStopV;
6736         }
6737         ssh_pkt_getstring(pktin, &s->sigdata, &s->siglen);
6738
6739         {
6740             const char *err = dh_validate_f(ssh->kex_ctx, s->f);
6741             if (err) {
6742                 bombout(("key exchange reply failed validation: %s", err));
6743                 crStopV;
6744             }
6745         }
6746         s->K = dh_find_K(ssh->kex_ctx, s->f);
6747
6748         /* We assume everything from now on will be quick, and it might
6749          * involve user interaction. */
6750         set_busy_status(ssh->frontend, BUSY_NOT);
6751
6752         hash_string(ssh->kex->hash, ssh->exhash, s->hostkeydata, s->hostkeylen);
6753         if (dh_is_gex(ssh->kex)) {
6754             if (!(ssh->remote_bugs & BUG_SSH2_OLDGEX))
6755                 hash_uint32(ssh->kex->hash, ssh->exhash, DH_MIN_SIZE);
6756             hash_uint32(ssh->kex->hash, ssh->exhash, s->pbits);
6757             if (!(ssh->remote_bugs & BUG_SSH2_OLDGEX))
6758                 hash_uint32(ssh->kex->hash, ssh->exhash, DH_MAX_SIZE);
6759             hash_mpint(ssh->kex->hash, ssh->exhash, s->p);
6760             hash_mpint(ssh->kex->hash, ssh->exhash, s->g);
6761         }
6762         hash_mpint(ssh->kex->hash, ssh->exhash, s->e);
6763         hash_mpint(ssh->kex->hash, ssh->exhash, s->f);
6764
6765         dh_cleanup(ssh->kex_ctx);
6766         freebn(s->f);
6767         if (dh_is_gex(ssh->kex)) {
6768             freebn(s->g);
6769             freebn(s->p);
6770         }
6771     } else if (ssh->kex->main_type == KEXTYPE_ECDH) {
6772
6773         logeventf(ssh, "Doing ECDH key exchange with hash %s",
6774                   ssh->kex->hash->text_name);
6775         ssh->pkt_kctx = SSH2_PKTCTX_ECDHKEX;
6776
6777         s->eckey = ssh_ecdhkex_newkey(ssh->kex);
6778         if (!s->eckey) {
6779             bombout(("Unable to generate key for ECDH"));
6780             crStopV;
6781         }
6782
6783         {
6784             char *publicPoint;
6785             int publicPointLength;
6786             publicPoint = ssh_ecdhkex_getpublic(s->eckey, &publicPointLength);
6787             if (!publicPoint) {
6788                 ssh_ecdhkex_freekey(s->eckey);
6789                 bombout(("Unable to encode public key for ECDH"));
6790                 crStopV;
6791             }
6792             s->pktout = ssh2_pkt_init(SSH2_MSG_KEX_ECDH_INIT);
6793             ssh2_pkt_addstring_start(s->pktout);
6794             ssh2_pkt_addstring_data(s->pktout, publicPoint, publicPointLength);
6795             sfree(publicPoint);
6796         }
6797
6798         ssh2_pkt_send_noqueue(ssh, s->pktout);
6799
6800         crWaitUntilV(pktin);
6801         if (pktin->type != SSH2_MSG_KEX_ECDH_REPLY) {
6802             ssh_ecdhkex_freekey(s->eckey);
6803             bombout(("expected ECDH reply packet from server"));
6804             crStopV;
6805         }
6806
6807         ssh_pkt_getstring(pktin, &s->hostkeydata, &s->hostkeylen);
6808         hash_string(ssh->kex->hash, ssh->exhash, s->hostkeydata, s->hostkeylen);
6809         s->hkey = ssh->hostkey->newkey(ssh->hostkey,
6810                                        s->hostkeydata, s->hostkeylen);
6811
6812         {
6813             char *publicPoint;
6814             int publicPointLength;
6815             publicPoint = ssh_ecdhkex_getpublic(s->eckey, &publicPointLength);
6816             if (!publicPoint) {
6817                 ssh_ecdhkex_freekey(s->eckey);
6818                 bombout(("Unable to encode public key for ECDH hash"));
6819                 crStopV;
6820             }
6821             hash_string(ssh->kex->hash, ssh->exhash,
6822                         publicPoint, publicPointLength);
6823             sfree(publicPoint);
6824         }
6825
6826         {
6827             char *keydata;
6828             int keylen;
6829             ssh_pkt_getstring(pktin, &keydata, &keylen);
6830             hash_string(ssh->kex->hash, ssh->exhash, keydata, keylen);
6831             s->K = ssh_ecdhkex_getkey(s->eckey, keydata, keylen);
6832             if (!s->K) {
6833                 ssh_ecdhkex_freekey(s->eckey);
6834                 bombout(("point received in ECDH was not valid"));
6835                 crStopV;
6836             }
6837         }
6838
6839         ssh_pkt_getstring(pktin, &s->sigdata, &s->siglen);
6840
6841         ssh_ecdhkex_freekey(s->eckey);
6842     } else {
6843         logeventf(ssh, "Doing RSA key exchange with hash %s",
6844                   ssh->kex->hash->text_name);
6845         ssh->pkt_kctx = SSH2_PKTCTX_RSAKEX;
6846         /*
6847          * RSA key exchange. First expect a KEXRSA_PUBKEY packet
6848          * from the server.
6849          */
6850         crWaitUntilV(pktin);
6851         if (pktin->type != SSH2_MSG_KEXRSA_PUBKEY) {
6852             bombout(("expected RSA public key packet from server"));
6853             crStopV;
6854         }
6855
6856         ssh_pkt_getstring(pktin, &s->hostkeydata, &s->hostkeylen);
6857         hash_string(ssh->kex->hash, ssh->exhash,
6858                     s->hostkeydata, s->hostkeylen);
6859         s->hkey = ssh->hostkey->newkey(ssh->hostkey,
6860                                        s->hostkeydata, s->hostkeylen);
6861
6862         {
6863             char *keydata;
6864             ssh_pkt_getstring(pktin, &keydata, &s->rsakeylen);
6865             s->rsakeydata = snewn(s->rsakeylen, char);
6866             memcpy(s->rsakeydata, keydata, s->rsakeylen);
6867         }
6868
6869         s->rsakey = ssh_rsakex_newkey(s->rsakeydata, s->rsakeylen);
6870         if (!s->rsakey) {
6871             sfree(s->rsakeydata);
6872             bombout(("unable to parse RSA public key from server"));
6873             crStopV;
6874         }
6875
6876         hash_string(ssh->kex->hash, ssh->exhash, s->rsakeydata, s->rsakeylen);
6877
6878         /*
6879          * Next, set up a shared secret K, of precisely KLEN -
6880          * 2*HLEN - 49 bits, where KLEN is the bit length of the
6881          * RSA key modulus and HLEN is the bit length of the hash
6882          * we're using.
6883          */
6884         {
6885             int klen = ssh_rsakex_klen(s->rsakey);
6886             int nbits = klen - (2*ssh->kex->hash->hlen*8 + 49);
6887             int i, byte = 0;
6888             unsigned char *kstr1, *kstr2, *outstr;
6889             int kstr1len, kstr2len, outstrlen;
6890
6891             s->K = bn_power_2(nbits - 1);
6892
6893             for (i = 0; i < nbits; i++) {
6894                 if ((i & 7) == 0) {
6895                     byte = random_byte();
6896                 }
6897                 bignum_set_bit(s->K, i, (byte >> (i & 7)) & 1);
6898             }
6899
6900             /*
6901              * Encode this as an mpint.
6902              */
6903             kstr1 = ssh2_mpint_fmt(s->K, &kstr1len);
6904             kstr2 = snewn(kstr2len = 4 + kstr1len, unsigned char);
6905             PUT_32BIT(kstr2, kstr1len);
6906             memcpy(kstr2 + 4, kstr1, kstr1len);
6907
6908             /*
6909              * Encrypt it with the given RSA key.
6910              */
6911             outstrlen = (klen + 7) / 8;
6912             outstr = snewn(outstrlen, unsigned char);
6913             ssh_rsakex_encrypt(ssh->kex->hash, kstr2, kstr2len,
6914                                outstr, outstrlen, s->rsakey);
6915
6916             /*
6917              * And send it off in a return packet.
6918              */
6919             s->pktout = ssh2_pkt_init(SSH2_MSG_KEXRSA_SECRET);
6920             ssh2_pkt_addstring_start(s->pktout);
6921             ssh2_pkt_addstring_data(s->pktout, (char *)outstr, outstrlen);
6922             ssh2_pkt_send_noqueue(ssh, s->pktout);
6923
6924             hash_string(ssh->kex->hash, ssh->exhash, outstr, outstrlen);
6925
6926             sfree(kstr2);
6927             sfree(kstr1);
6928             sfree(outstr);
6929         }
6930
6931         ssh_rsakex_freekey(s->rsakey);
6932
6933         crWaitUntilV(pktin);
6934         if (pktin->type != SSH2_MSG_KEXRSA_DONE) {
6935             sfree(s->rsakeydata);
6936             bombout(("expected signature packet from server"));
6937             crStopV;
6938         }
6939
6940         ssh_pkt_getstring(pktin, &s->sigdata, &s->siglen);
6941
6942         sfree(s->rsakeydata);
6943     }
6944
6945     hash_mpint(ssh->kex->hash, ssh->exhash, s->K);
6946     assert(ssh->kex->hash->hlen <= sizeof(s->exchange_hash));
6947     ssh->kex->hash->final(ssh->exhash, s->exchange_hash);
6948
6949     ssh->kex_ctx = NULL;
6950
6951 #if 0
6952     debug(("Exchange hash is:\n"));
6953     dmemdump(s->exchange_hash, ssh->kex->hash->hlen);
6954 #endif
6955
6956     if (!s->hkey ||
6957         !ssh->hostkey->verifysig(s->hkey, s->sigdata, s->siglen,
6958                                  (char *)s->exchange_hash,
6959                                  ssh->kex->hash->hlen)) {
6960         bombout(("Server's host key did not match the signature supplied"));
6961         crStopV;
6962     }
6963
6964     s->keystr = ssh->hostkey->fmtkey(s->hkey);
6965     if (!s->got_session_id) {
6966         /*
6967          * Authenticate remote host: verify host key. (We've already
6968          * checked the signature of the exchange hash.)
6969          */
6970         s->fingerprint = ssh2_fingerprint(ssh->hostkey, s->hkey);
6971         logevent("Host key fingerprint is:");
6972         logevent(s->fingerprint);
6973         /* First check against manually configured host keys. */
6974         s->dlgret = verify_ssh_manual_host_key(ssh, s->fingerprint,
6975                                                ssh->hostkey, s->hkey);
6976         if (s->dlgret == 0) {          /* did not match */
6977             bombout(("Host key did not appear in manually configured list"));
6978             crStopV;
6979         } else if (s->dlgret < 0) { /* none configured; use standard handling */
6980             ssh_set_frozen(ssh, 1);
6981             s->dlgret = verify_ssh_host_key(ssh->frontend,
6982                                             ssh->savedhost, ssh->savedport,
6983                                             ssh->hostkey->keytype, s->keystr,
6984                                             s->fingerprint,
6985                                             ssh_dialog_callback, ssh);
6986             if (s->dlgret < 0) {
6987                 do {
6988                     crReturnV;
6989                     if (pktin) {
6990                         bombout(("Unexpected data from server while waiting"
6991                                  " for user host key response"));
6992                         crStopV;
6993                     }
6994                 } while (pktin || inlen > 0);
6995                 s->dlgret = ssh->user_response;
6996             }
6997             ssh_set_frozen(ssh, 0);
6998             if (s->dlgret == 0) {
6999                 ssh_disconnect(ssh, "Aborted at host key verification", NULL,
7000                                0, TRUE);
7001                 crStopV;
7002             }
7003         }
7004         sfree(s->fingerprint);
7005         /*
7006          * Save this host key, to check against the one presented in
7007          * subsequent rekeys.
7008          */
7009         ssh->hostkey_str = s->keystr;
7010     } else {
7011         /*
7012          * In a rekey, we never present an interactive host key
7013          * verification request to the user. Instead, we simply
7014          * enforce that the key we're seeing this time is identical to
7015          * the one we saw before.
7016          */
7017         if (strcmp(ssh->hostkey_str, s->keystr)) {
7018             bombout(("Host key was different in repeat key exchange"));
7019             crStopV;
7020         }
7021         sfree(s->keystr);
7022     }
7023     ssh->hostkey->freekey(s->hkey);
7024
7025     /*
7026      * The exchange hash from the very first key exchange is also
7027      * the session id, used in session key construction and
7028      * authentication.
7029      */
7030     if (!s->got_session_id) {
7031         assert(sizeof(s->exchange_hash) <= sizeof(ssh->v2_session_id));
7032         memcpy(ssh->v2_session_id, s->exchange_hash,
7033                sizeof(s->exchange_hash));
7034         ssh->v2_session_id_len = ssh->kex->hash->hlen;
7035         assert(ssh->v2_session_id_len <= sizeof(ssh->v2_session_id));
7036         s->got_session_id = TRUE;
7037     }
7038
7039     /*
7040      * Send SSH2_MSG_NEWKEYS.
7041      */
7042     s->pktout = ssh2_pkt_init(SSH2_MSG_NEWKEYS);
7043     ssh2_pkt_send_noqueue(ssh, s->pktout);
7044     ssh->outgoing_data_size = 0;       /* start counting from here */
7045
7046     /*
7047      * We've sent client NEWKEYS, so create and initialise
7048      * client-to-server session keys.
7049      */
7050     if (ssh->cs_cipher_ctx)
7051         ssh->cscipher->free_context(ssh->cs_cipher_ctx);
7052     ssh->cscipher = s->cscipher_tobe;
7053     ssh->cs_cipher_ctx = ssh->cscipher->make_context();
7054
7055     if (ssh->cs_mac_ctx)
7056         ssh->csmac->free_context(ssh->cs_mac_ctx);
7057     ssh->csmac = s->csmac_tobe;
7058     ssh->csmac_etm = s->csmac_etm_tobe;
7059     ssh->cs_mac_ctx = ssh->csmac->make_context();
7060
7061     if (ssh->cs_comp_ctx)
7062         ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
7063     ssh->cscomp = s->cscomp_tobe;
7064     ssh->cs_comp_ctx = ssh->cscomp->compress_init();
7065
7066     /*
7067      * Set IVs on client-to-server keys. Here we use the exchange
7068      * hash from the _first_ key exchange.
7069      */
7070     {
7071         unsigned char keyspace[SSH2_KEX_MAX_HASH_LEN * SSH2_MKKEY_ITERS];
7072         assert(sizeof(keyspace) >= ssh->kex->hash->hlen * SSH2_MKKEY_ITERS);
7073         ssh2_mkkey(ssh,s->K,s->exchange_hash,'C',keyspace);
7074         assert((ssh->cscipher->keylen+7) / 8 <=
7075                ssh->kex->hash->hlen * SSH2_MKKEY_ITERS);
7076         ssh->cscipher->setkey(ssh->cs_cipher_ctx, keyspace);
7077         ssh2_mkkey(ssh,s->K,s->exchange_hash,'A',keyspace);
7078         assert(ssh->cscipher->blksize <=
7079                ssh->kex->hash->hlen * SSH2_MKKEY_ITERS);
7080         ssh->cscipher->setiv(ssh->cs_cipher_ctx, keyspace);
7081         ssh2_mkkey(ssh,s->K,s->exchange_hash,'E',keyspace);
7082         assert(ssh->csmac->len <=
7083                ssh->kex->hash->hlen * SSH2_MKKEY_ITERS);
7084         ssh->csmac->setkey(ssh->cs_mac_ctx, keyspace);
7085         smemclr(keyspace, sizeof(keyspace));
7086     }
7087
7088     logeventf(ssh, "Initialised %.200s client->server encryption",
7089               ssh->cscipher->text_name);
7090     logeventf(ssh, "Initialised %.200s client->server MAC algorithm%s",
7091               ssh->csmac->text_name,
7092               ssh->csmac_etm ? " (in ETM mode)" : "");
7093     if (ssh->cscomp->text_name)
7094         logeventf(ssh, "Initialised %s compression",
7095                   ssh->cscomp->text_name);
7096
7097     /*
7098      * Now our end of the key exchange is complete, we can send all
7099      * our queued higher-layer packets.
7100      */
7101     ssh->queueing = FALSE;
7102     ssh2_pkt_queuesend(ssh);
7103
7104     /*
7105      * Expect SSH2_MSG_NEWKEYS from server.
7106      */
7107     crWaitUntilV(pktin);
7108     if (pktin->type != SSH2_MSG_NEWKEYS) {
7109         bombout(("expected new-keys packet from server"));
7110         crStopV;
7111     }
7112     ssh->incoming_data_size = 0;       /* start counting from here */
7113
7114     /*
7115      * We've seen server NEWKEYS, so create and initialise
7116      * server-to-client session keys.
7117      */
7118     if (ssh->sc_cipher_ctx)
7119         ssh->sccipher->free_context(ssh->sc_cipher_ctx);
7120     ssh->sccipher = s->sccipher_tobe;
7121     ssh->sc_cipher_ctx = ssh->sccipher->make_context();
7122
7123     if (ssh->sc_mac_ctx)
7124         ssh->scmac->free_context(ssh->sc_mac_ctx);
7125     ssh->scmac = s->scmac_tobe;
7126     ssh->scmac_etm = s->scmac_etm_tobe;
7127     ssh->sc_mac_ctx = ssh->scmac->make_context();
7128
7129     if (ssh->sc_comp_ctx)
7130         ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
7131     ssh->sccomp = s->sccomp_tobe;
7132     ssh->sc_comp_ctx = ssh->sccomp->decompress_init();
7133
7134     /*
7135      * Set IVs on server-to-client keys. Here we use the exchange
7136      * hash from the _first_ key exchange.
7137      */
7138     {
7139         unsigned char keyspace[SSH2_KEX_MAX_HASH_LEN * SSH2_MKKEY_ITERS];
7140         assert(sizeof(keyspace) >= ssh->kex->hash->hlen * SSH2_MKKEY_ITERS);
7141         ssh2_mkkey(ssh,s->K,s->exchange_hash,'D',keyspace);
7142         assert((ssh->sccipher->keylen+7) / 8 <=
7143                ssh->kex->hash->hlen * SSH2_MKKEY_ITERS);
7144         ssh->sccipher->setkey(ssh->sc_cipher_ctx, keyspace);
7145         ssh2_mkkey(ssh,s->K,s->exchange_hash,'B',keyspace);
7146         assert(ssh->sccipher->blksize <=
7147                ssh->kex->hash->hlen * SSH2_MKKEY_ITERS);
7148         ssh->sccipher->setiv(ssh->sc_cipher_ctx, keyspace);
7149         ssh2_mkkey(ssh,s->K,s->exchange_hash,'F',keyspace);
7150         assert(ssh->scmac->len <=
7151                ssh->kex->hash->hlen * SSH2_MKKEY_ITERS);
7152         ssh->scmac->setkey(ssh->sc_mac_ctx, keyspace);
7153         smemclr(keyspace, sizeof(keyspace));
7154     }
7155     logeventf(ssh, "Initialised %.200s server->client encryption",
7156               ssh->sccipher->text_name);
7157     logeventf(ssh, "Initialised %.200s server->client MAC algorithm%s",
7158               ssh->scmac->text_name,
7159               ssh->scmac_etm ? " (in ETM mode)" : "");
7160     if (ssh->sccomp->text_name)
7161         logeventf(ssh, "Initialised %s decompression",
7162                   ssh->sccomp->text_name);
7163
7164     /*
7165      * Free shared secret.
7166      */
7167     freebn(s->K);
7168
7169     /*
7170      * Key exchange is over. Loop straight back round if we have a
7171      * deferred rekey reason.
7172      */
7173     if (ssh->deferred_rekey_reason) {
7174         logevent(ssh->deferred_rekey_reason);
7175         pktin = NULL;
7176         ssh->deferred_rekey_reason = NULL;
7177         goto begin_key_exchange;
7178     }
7179
7180     /*
7181      * Otherwise, schedule a timer for our next rekey.
7182      */
7183     ssh->kex_in_progress = FALSE;
7184     ssh->last_rekey = GETTICKCOUNT();
7185     if (conf_get_int(ssh->conf, CONF_ssh_rekey_time) != 0)
7186         ssh->next_rekey = schedule_timer(conf_get_int(ssh->conf, CONF_ssh_rekey_time)*60*TICKSPERSEC,
7187                                          ssh2_timer, ssh);
7188
7189     /*
7190      * Now we're encrypting. Begin returning 1 to the protocol main
7191      * function so that other things can run on top of the
7192      * transport. If we ever see a KEXINIT, we must go back to the
7193      * start.
7194      * 
7195      * We _also_ go back to the start if we see pktin==NULL and
7196      * inlen negative, because this is a special signal meaning
7197      * `initiate client-driven rekey', and `in' contains a message
7198      * giving the reason for the rekey.
7199      *
7200      * inlen==-1 means always initiate a rekey;
7201      * inlen==-2 means that userauth has completed successfully and
7202      *   we should consider rekeying (for delayed compression).
7203      */
7204     while (!((pktin && pktin->type == SSH2_MSG_KEXINIT) ||
7205              (!pktin && inlen < 0))) {
7206         wait_for_rekey:
7207         if (!ssh->protocol_initial_phase_done) {
7208             ssh->protocol_initial_phase_done = TRUE;
7209             /*
7210              * Allow authconn to initialise itself.
7211              */
7212             do_ssh2_authconn(ssh, NULL, 0, NULL);
7213         }
7214         crReturnV;
7215     }
7216     if (pktin) {
7217         logevent("Server initiated key re-exchange");
7218     } else {
7219         if (inlen == -2) {
7220             /* 
7221              * authconn has seen a USERAUTH_SUCCEEDED. Time to enable
7222              * delayed compression, if it's available.
7223              *
7224              * draft-miller-secsh-compression-delayed-00 says that you
7225              * negotiate delayed compression in the first key exchange, and
7226              * both sides start compressing when the server has sent
7227              * USERAUTH_SUCCESS. This has a race condition -- the server
7228              * can't know when the client has seen it, and thus which incoming
7229              * packets it should treat as compressed.
7230              *
7231              * Instead, we do the initial key exchange without offering the
7232              * delayed methods, but note if the server offers them; when we
7233              * get here, if a delayed method was available that was higher
7234              * on our list than what we got, we initiate a rekey in which we
7235              * _do_ list the delayed methods (and hopefully get it as a
7236              * result). Subsequent rekeys will do the same.
7237              */
7238             assert(!s->userauth_succeeded); /* should only happen once */
7239             s->userauth_succeeded = TRUE;
7240             if (!s->pending_compression)
7241                 /* Can't see any point rekeying. */
7242                 goto wait_for_rekey;       /* this is utterly horrid */
7243             /* else fall through to rekey... */
7244             s->pending_compression = FALSE;
7245         }
7246         /*
7247          * Now we've decided to rekey.
7248          *
7249          * Special case: if the server bug is set that doesn't
7250          * allow rekeying, we give a different log message and
7251          * continue waiting. (If such a server _initiates_ a rekey,
7252          * we process it anyway!)
7253          */
7254         if ((ssh->remote_bugs & BUG_SSH2_REKEY)) {
7255             logeventf(ssh, "Server bug prevents key re-exchange (%s)",
7256                       (char *)in);
7257             /* Reset the counters, so that at least this message doesn't
7258              * hit the event log _too_ often. */
7259             ssh->outgoing_data_size = 0;
7260             ssh->incoming_data_size = 0;
7261             if (conf_get_int(ssh->conf, CONF_ssh_rekey_time) != 0) {
7262                 ssh->next_rekey =
7263                     schedule_timer(conf_get_int(ssh->conf, CONF_ssh_rekey_time)*60*TICKSPERSEC,
7264                                    ssh2_timer, ssh);
7265             }
7266             goto wait_for_rekey;       /* this is still utterly horrid */
7267         } else {
7268             logeventf(ssh, "Initiating key re-exchange (%s)", (char *)in);
7269         }
7270     }
7271     goto begin_key_exchange;
7272
7273     crFinishV;
7274 }
7275
7276 /*
7277  * Add data to an SSH-2 channel output buffer.
7278  */
7279 static void ssh2_add_channel_data(struct ssh_channel *c, const char *buf,
7280                                   int len)
7281 {
7282     bufchain_add(&c->v.v2.outbuffer, buf, len);
7283 }
7284
7285 /*
7286  * Attempt to send data on an SSH-2 channel.
7287  */
7288 static int ssh2_try_send(struct ssh_channel *c)
7289 {
7290     Ssh ssh = c->ssh;
7291     struct Packet *pktout;
7292     int ret;
7293
7294     while (c->v.v2.remwindow > 0 && bufchain_size(&c->v.v2.outbuffer) > 0) {
7295         int len;
7296         void *data;
7297         bufchain_prefix(&c->v.v2.outbuffer, &data, &len);
7298         if ((unsigned)len > c->v.v2.remwindow)
7299             len = c->v.v2.remwindow;
7300         if ((unsigned)len > c->v.v2.remmaxpkt)
7301             len = c->v.v2.remmaxpkt;
7302         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_DATA);
7303         ssh2_pkt_adduint32(pktout, c->remoteid);
7304         ssh2_pkt_addstring_start(pktout);
7305         ssh2_pkt_addstring_data(pktout, data, len);
7306         ssh2_pkt_send(ssh, pktout);
7307         bufchain_consume(&c->v.v2.outbuffer, len);
7308         c->v.v2.remwindow -= len;
7309     }
7310
7311     /*
7312      * After having sent as much data as we can, return the amount
7313      * still buffered.
7314      */
7315     ret = bufchain_size(&c->v.v2.outbuffer);
7316
7317     /*
7318      * And if there's no data pending but we need to send an EOF, send
7319      * it.
7320      */
7321     if (!ret && c->pending_eof)
7322         ssh_channel_try_eof(c);
7323
7324     return ret;
7325 }
7326
7327 static void ssh2_try_send_and_unthrottle(Ssh ssh, struct ssh_channel *c)
7328 {
7329     int bufsize;
7330     if (c->closes & CLOSES_SENT_EOF)
7331         return;                   /* don't send on channels we've EOFed */
7332     bufsize = ssh2_try_send(c);
7333     if (bufsize == 0) {
7334         switch (c->type) {
7335           case CHAN_MAINSESSION:
7336             /* stdin need not receive an unthrottle
7337              * notification since it will be polled */
7338             break;
7339           case CHAN_X11:
7340             x11_unthrottle(c->u.x11.xconn);
7341             break;
7342           case CHAN_AGENT:
7343             /* agent sockets are request/response and need no
7344              * buffer management */
7345             break;
7346           case CHAN_SOCKDATA:
7347             pfd_unthrottle(c->u.pfd.pf);
7348             break;
7349         }
7350     }
7351 }
7352
7353 static int ssh_is_simple(Ssh ssh)
7354 {
7355     /*
7356      * We use the 'simple' variant of the SSH protocol if we're asked
7357      * to, except not if we're also doing connection-sharing (either
7358      * tunnelling our packets over an upstream or expecting to be
7359      * tunnelled over ourselves), since then the assumption that we
7360      * have only one channel to worry about is not true after all.
7361      */
7362     return (conf_get_int(ssh->conf, CONF_ssh_simple) &&
7363             !ssh->bare_connection && !ssh->connshare);
7364 }
7365
7366 /*
7367  * Set up most of a new ssh_channel for SSH-2.
7368  */
7369 static void ssh2_channel_init(struct ssh_channel *c)
7370 {
7371     Ssh ssh = c->ssh;
7372     c->localid = alloc_channel_id(ssh);
7373     c->closes = 0;
7374     c->pending_eof = FALSE;
7375     c->throttling_conn = FALSE;
7376     c->v.v2.locwindow = c->v.v2.locmaxwin = c->v.v2.remlocwin =
7377         ssh_is_simple(ssh) ? OUR_V2_BIGWIN : OUR_V2_WINSIZE;
7378     c->v.v2.chanreq_head = NULL;
7379     c->v.v2.throttle_state = UNTHROTTLED;
7380     bufchain_init(&c->v.v2.outbuffer);
7381 }
7382
7383 /*
7384  * Construct the common parts of a CHANNEL_OPEN.
7385  */
7386 static struct Packet *ssh2_chanopen_init(struct ssh_channel *c,
7387                                          const char *type)
7388 {
7389     struct Packet *pktout;
7390
7391     pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
7392     ssh2_pkt_addstring(pktout, type);
7393     ssh2_pkt_adduint32(pktout, c->localid);
7394     ssh2_pkt_adduint32(pktout, c->v.v2.locwindow);/* our window size */
7395     ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT);      /* our max pkt size */
7396     return pktout;
7397 }
7398
7399 /*
7400  * CHANNEL_FAILURE doesn't come with any indication of what message
7401  * caused it, so we have to keep track of the outstanding
7402  * CHANNEL_REQUESTs ourselves.
7403  */
7404 static void ssh2_queue_chanreq_handler(struct ssh_channel *c,
7405                                        cchandler_fn_t handler, void *ctx)
7406 {
7407     struct outstanding_channel_request *ocr =
7408         snew(struct outstanding_channel_request);
7409
7410     assert(!(c->closes & (CLOSES_SENT_CLOSE | CLOSES_RCVD_CLOSE)));
7411     ocr->handler = handler;
7412     ocr->ctx = ctx;
7413     ocr->next = NULL;
7414     if (!c->v.v2.chanreq_head)
7415         c->v.v2.chanreq_head = ocr;
7416     else
7417         c->v.v2.chanreq_tail->next = ocr;
7418     c->v.v2.chanreq_tail = ocr;
7419 }
7420
7421 /*
7422  * Construct the common parts of a CHANNEL_REQUEST.  If handler is not
7423  * NULL then a reply will be requested and the handler will be called
7424  * when it arrives.  The returned packet is ready to have any
7425  * request-specific data added and be sent.  Note that if a handler is
7426  * provided, it's essential that the request actually be sent.
7427  *
7428  * The handler will usually be passed the response packet in pktin. If
7429  * pktin is NULL, this means that no reply will ever be forthcoming
7430  * (e.g. because the entire connection is being destroyed, or because
7431  * the server initiated channel closure before we saw the response)
7432  * and the handler should free any storage it's holding.
7433  */
7434 static struct Packet *ssh2_chanreq_init(struct ssh_channel *c,
7435                                         const char *type,
7436                                         cchandler_fn_t handler, void *ctx)
7437 {
7438     struct Packet *pktout;
7439
7440     assert(!(c->closes & (CLOSES_SENT_CLOSE | CLOSES_RCVD_CLOSE)));
7441     pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7442     ssh2_pkt_adduint32(pktout, c->remoteid);
7443     ssh2_pkt_addstring(pktout, type);
7444     ssh2_pkt_addbool(pktout, handler != NULL);
7445     if (handler != NULL)
7446         ssh2_queue_chanreq_handler(c, handler, ctx);
7447     return pktout;
7448 }
7449
7450 /*
7451  * Potentially enlarge the window on an SSH-2 channel.
7452  */
7453 static void ssh2_handle_winadj_response(struct ssh_channel *, struct Packet *,
7454                                         void *);
7455 static void ssh2_set_window(struct ssh_channel *c, int newwin)
7456 {
7457     Ssh ssh = c->ssh;
7458
7459     /*
7460      * Never send WINDOW_ADJUST for a channel that the remote side has
7461      * already sent EOF on; there's no point, since it won't be
7462      * sending any more data anyway. Ditto if _we've_ already sent
7463      * CLOSE.
7464      */
7465     if (c->closes & (CLOSES_RCVD_EOF | CLOSES_SENT_CLOSE))
7466         return;
7467
7468     /*
7469      * Also, never widen the window for an X11 channel when we're
7470      * still waiting to see its initial auth and may yet hand it off
7471      * to a downstream.
7472      */
7473     if (c->type == CHAN_X11 && c->u.x11.initial)
7474         return;
7475
7476     /*
7477      * If the remote end has a habit of ignoring maxpkt, limit the
7478      * window so that it has no choice (assuming it doesn't ignore the
7479      * window as well).
7480      */
7481     if ((ssh->remote_bugs & BUG_SSH2_MAXPKT) && newwin > OUR_V2_MAXPKT)
7482         newwin = OUR_V2_MAXPKT;
7483
7484     /*
7485      * Only send a WINDOW_ADJUST if there's significantly more window
7486      * available than the other end thinks there is.  This saves us
7487      * sending a WINDOW_ADJUST for every character in a shell session.
7488      *
7489      * "Significant" is arbitrarily defined as half the window size.
7490      */
7491     if (newwin / 2 >= c->v.v2.locwindow) {
7492         struct Packet *pktout;
7493         unsigned *up;
7494
7495         /*
7496          * In order to keep track of how much window the client
7497          * actually has available, we'd like it to acknowledge each
7498          * WINDOW_ADJUST.  We can't do that directly, so we accompany
7499          * it with a CHANNEL_REQUEST that has to be acknowledged.
7500          *
7501          * This is only necessary if we're opening the window wide.
7502          * If we're not, then throughput is being constrained by
7503          * something other than the maximum window size anyway.
7504          */
7505         if (newwin == c->v.v2.locmaxwin &&
7506             !(ssh->remote_bugs & BUG_CHOKES_ON_WINADJ)) {
7507             up = snew(unsigned);
7508             *up = newwin - c->v.v2.locwindow;
7509             pktout = ssh2_chanreq_init(c, "winadj@putty.projects.tartarus.org",
7510                                        ssh2_handle_winadj_response, up);
7511             ssh2_pkt_send(ssh, pktout);
7512
7513             if (c->v.v2.throttle_state != UNTHROTTLED)
7514                 c->v.v2.throttle_state = UNTHROTTLING;
7515         } else {
7516             /* Pretend the WINDOW_ADJUST was acked immediately. */
7517             c->v.v2.remlocwin = newwin;
7518             c->v.v2.throttle_state = THROTTLED;
7519         }
7520         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
7521         ssh2_pkt_adduint32(pktout, c->remoteid);
7522         ssh2_pkt_adduint32(pktout, newwin - c->v.v2.locwindow);
7523         ssh2_pkt_send(ssh, pktout);
7524         c->v.v2.locwindow = newwin;
7525     }
7526 }
7527
7528 /*
7529  * Find the channel associated with a message.  If there's no channel,
7530  * or it's not properly open, make a noise about it and return NULL.
7531  */
7532 static struct ssh_channel *ssh2_channel_msg(Ssh ssh, struct Packet *pktin)
7533 {
7534     unsigned localid = ssh_pkt_getuint32(pktin);
7535     struct ssh_channel *c;
7536
7537     c = find234(ssh->channels, &localid, ssh_channelfind);
7538     if (!c ||
7539         (c->type != CHAN_SHARING && c->halfopen &&
7540          pktin->type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION &&
7541          pktin->type != SSH2_MSG_CHANNEL_OPEN_FAILURE)) {
7542         char *buf = dupprintf("Received %s for %s channel %u",
7543                               ssh2_pkt_type(ssh->pkt_kctx, ssh->pkt_actx,
7544                                             pktin->type),
7545                               c ? "half-open" : "nonexistent", localid);
7546         ssh_disconnect(ssh, NULL, buf, SSH2_DISCONNECT_PROTOCOL_ERROR, FALSE);
7547         sfree(buf);
7548         return NULL;
7549     }
7550     return c;
7551 }
7552
7553 static void ssh2_handle_winadj_response(struct ssh_channel *c,
7554                                         struct Packet *pktin, void *ctx)
7555 {
7556     unsigned *sizep = ctx;
7557
7558     /*
7559      * Winadj responses should always be failures. However, at least
7560      * one server ("boks_sshd") is known to return SUCCESS for channel
7561      * requests it's never heard of, such as "winadj@putty". Raised
7562      * with foxt.com as bug 090916-090424, but for the sake of a quiet
7563      * life, we don't worry about what kind of response we got.
7564      */
7565
7566     c->v.v2.remlocwin += *sizep;
7567     sfree(sizep);
7568     /*
7569      * winadj messages are only sent when the window is fully open, so
7570      * if we get an ack of one, we know any pending unthrottle is
7571      * complete.
7572      */
7573     if (c->v.v2.throttle_state == UNTHROTTLING)
7574         c->v.v2.throttle_state = UNTHROTTLED;
7575 }
7576
7577 static void ssh2_msg_channel_response(Ssh ssh, struct Packet *pktin)
7578 {
7579     struct ssh_channel *c = ssh2_channel_msg(ssh, pktin);
7580     struct outstanding_channel_request *ocr;
7581
7582     if (!c) return;
7583     if (c->type == CHAN_SHARING) {
7584         share_got_pkt_from_server(c->u.sharing.ctx, pktin->type,
7585                                   pktin->body, pktin->length);
7586         return;
7587     }
7588     ocr = c->v.v2.chanreq_head;
7589     if (!ocr) {
7590         ssh2_msg_unexpected(ssh, pktin);
7591         return;
7592     }
7593     ocr->handler(c, pktin, ocr->ctx);
7594     c->v.v2.chanreq_head = ocr->next;
7595     sfree(ocr);
7596     /*
7597      * We may now initiate channel-closing procedures, if that
7598      * CHANNEL_REQUEST was the last thing outstanding before we send
7599      * CHANNEL_CLOSE.
7600      */
7601     ssh2_channel_check_close(c);
7602 }
7603
7604 static void ssh2_msg_channel_window_adjust(Ssh ssh, struct Packet *pktin)
7605 {
7606     struct ssh_channel *c;
7607     c = ssh2_channel_msg(ssh, pktin);
7608     if (!c)
7609         return;
7610     if (c->type == CHAN_SHARING) {
7611         share_got_pkt_from_server(c->u.sharing.ctx, pktin->type,
7612                                   pktin->body, pktin->length);
7613         return;
7614     }
7615     if (!(c->closes & CLOSES_SENT_EOF)) {
7616         c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
7617         ssh2_try_send_and_unthrottle(ssh, c);
7618     }
7619 }
7620
7621 static void ssh2_msg_channel_data(Ssh ssh, struct Packet *pktin)
7622 {
7623     char *data;
7624     int length;
7625     struct ssh_channel *c;
7626     c = ssh2_channel_msg(ssh, pktin);
7627     if (!c)
7628         return;
7629     if (c->type == CHAN_SHARING) {
7630         share_got_pkt_from_server(c->u.sharing.ctx, pktin->type,
7631                                   pktin->body, pktin->length);
7632         return;
7633     }
7634     if (pktin->type == SSH2_MSG_CHANNEL_EXTENDED_DATA &&
7635         ssh_pkt_getuint32(pktin) != SSH2_EXTENDED_DATA_STDERR)
7636         return;                        /* extended but not stderr */
7637     ssh_pkt_getstring(pktin, &data, &length);
7638     if (data) {
7639         int bufsize = 0;
7640         c->v.v2.locwindow -= length;
7641         c->v.v2.remlocwin -= length;
7642         switch (c->type) {
7643           case CHAN_MAINSESSION:
7644             bufsize =
7645                 from_backend(ssh->frontend, pktin->type ==
7646                              SSH2_MSG_CHANNEL_EXTENDED_DATA,
7647                              data, length);
7648             break;
7649           case CHAN_X11:
7650             bufsize = x11_send(c->u.x11.xconn, data, length);
7651             break;
7652           case CHAN_SOCKDATA:
7653             bufsize = pfd_send(c->u.pfd.pf, data, length);
7654             break;
7655           case CHAN_AGENT:
7656             while (length > 0) {
7657                 if (c->u.a.lensofar < 4) {
7658                     unsigned int l = min(4 - c->u.a.lensofar,
7659                                          (unsigned)length);
7660                     memcpy(c->u.a.msglen + c->u.a.lensofar,
7661                            data, l);
7662                     data += l;
7663                     length -= l;
7664                     c->u.a.lensofar += l;
7665                 }
7666                 if (c->u.a.lensofar == 4) {
7667                     c->u.a.totallen =
7668                         4 + GET_32BIT(c->u.a.msglen);
7669                     c->u.a.message = snewn(c->u.a.totallen,
7670                                            unsigned char);
7671                     memcpy(c->u.a.message, c->u.a.msglen, 4);
7672                 }
7673                 if (c->u.a.lensofar >= 4 && length > 0) {
7674                     unsigned int l =
7675                         min(c->u.a.totallen - c->u.a.lensofar,
7676                             (unsigned)length);
7677                     memcpy(c->u.a.message + c->u.a.lensofar,
7678                            data, l);
7679                     data += l;
7680                     length -= l;
7681                     c->u.a.lensofar += l;
7682                 }
7683                 if (c->u.a.lensofar == c->u.a.totallen) {
7684                     void *reply;
7685                     int replylen;
7686                     c->u.a.outstanding_requests++;
7687                     if (agent_query(c->u.a.message,
7688                                     c->u.a.totallen,
7689                                     &reply, &replylen,
7690                                     ssh_agentf_callback, c))
7691                         ssh_agentf_callback(c, reply, replylen);
7692                     sfree(c->u.a.message);
7693                     c->u.a.message = NULL;
7694                     c->u.a.lensofar = 0;
7695                 }
7696             }
7697             bufsize = 0;
7698             break;
7699         }
7700         /*
7701          * If it looks like the remote end hit the end of its window,
7702          * and we didn't want it to do that, think about using a
7703          * larger window.
7704          */
7705         if (c->v.v2.remlocwin <= 0 && c->v.v2.throttle_state == UNTHROTTLED &&
7706             c->v.v2.locmaxwin < 0x40000000)
7707             c->v.v2.locmaxwin += OUR_V2_WINSIZE;
7708         /*
7709          * If we are not buffering too much data,
7710          * enlarge the window again at the remote side.
7711          * If we are buffering too much, we may still
7712          * need to adjust the window if the server's
7713          * sent excess data.
7714          */
7715         ssh2_set_window(c, bufsize < c->v.v2.locmaxwin ?
7716                         c->v.v2.locmaxwin - bufsize : 0);
7717         /*
7718          * If we're either buffering way too much data, or if we're
7719          * buffering anything at all and we're in "simple" mode,
7720          * throttle the whole channel.
7721          */
7722         if ((bufsize > c->v.v2.locmaxwin || (ssh_is_simple(ssh) && bufsize>0))
7723             && !c->throttling_conn) {
7724             c->throttling_conn = 1;
7725             ssh_throttle_conn(ssh, +1);
7726         }
7727     }
7728 }
7729
7730 static void ssh_check_termination(Ssh ssh)
7731 {
7732     if (ssh->version == 2 &&
7733         !conf_get_int(ssh->conf, CONF_ssh_no_shell) &&
7734         count234(ssh->channels) == 0 &&
7735         !(ssh->connshare && share_ndownstreams(ssh->connshare) > 0)) {
7736         /*
7737          * We used to send SSH_MSG_DISCONNECT here, because I'd
7738          * believed that _every_ conforming SSH-2 connection had to
7739          * end with a disconnect being sent by at least one side;
7740          * apparently I was wrong and it's perfectly OK to
7741          * unceremoniously slam the connection shut when you're done,
7742          * and indeed OpenSSH feels this is more polite than sending a
7743          * DISCONNECT. So now we don't.
7744          */
7745         ssh_disconnect(ssh, "All channels closed", NULL, 0, TRUE);
7746     }
7747 }
7748
7749 void ssh_sharing_downstream_connected(Ssh ssh, unsigned id,
7750                                       const char *peerinfo)
7751 {
7752     if (peerinfo)
7753         logeventf(ssh, "Connection sharing downstream #%u connected from %s",
7754                   id, peerinfo);
7755     else
7756         logeventf(ssh, "Connection sharing downstream #%u connected", id);
7757 }
7758
7759 void ssh_sharing_downstream_disconnected(Ssh ssh, unsigned id)
7760 {
7761     logeventf(ssh, "Connection sharing downstream #%u disconnected", id);
7762     ssh_check_termination(ssh);
7763 }
7764
7765 void ssh_sharing_logf(Ssh ssh, unsigned id, const char *logfmt, ...)
7766 {
7767     va_list ap;
7768     char *buf;
7769
7770     va_start(ap, logfmt);
7771     buf = dupvprintf(logfmt, ap);
7772     va_end(ap);
7773     if (id)
7774         logeventf(ssh, "Connection sharing downstream #%u: %s", id, buf);
7775     else
7776         logeventf(ssh, "Connection sharing: %s", buf);
7777     sfree(buf);
7778 }
7779
7780 static void ssh_channel_destroy(struct ssh_channel *c)
7781 {
7782     Ssh ssh = c->ssh;
7783
7784     switch (c->type) {
7785       case CHAN_MAINSESSION:
7786         ssh->mainchan = NULL;
7787         update_specials_menu(ssh->frontend);
7788         break;
7789       case CHAN_X11:
7790         if (c->u.x11.xconn != NULL)
7791             x11_close(c->u.x11.xconn);
7792         logevent("Forwarded X11 connection terminated");
7793         break;
7794       case CHAN_AGENT:
7795         sfree(c->u.a.message);
7796         break;
7797       case CHAN_SOCKDATA:
7798         if (c->u.pfd.pf != NULL)
7799             pfd_close(c->u.pfd.pf);
7800         logevent("Forwarded port closed");
7801         break;
7802     }
7803
7804     del234(ssh->channels, c);
7805     if (ssh->version == 2) {
7806         bufchain_clear(&c->v.v2.outbuffer);
7807         assert(c->v.v2.chanreq_head == NULL);
7808     }
7809     sfree(c);
7810
7811     /*
7812      * If that was the last channel left open, we might need to
7813      * terminate.
7814      */
7815     ssh_check_termination(ssh);
7816 }
7817
7818 static void ssh2_channel_check_close(struct ssh_channel *c)
7819 {
7820     Ssh ssh = c->ssh;
7821     struct Packet *pktout;
7822
7823     if (c->halfopen) {
7824         /*
7825          * If we've sent out our own CHANNEL_OPEN but not yet seen
7826          * either OPEN_CONFIRMATION or OPEN_FAILURE in response, then
7827          * it's too early to be sending close messages of any kind.
7828          */
7829         return;
7830     }
7831
7832     if ((!((CLOSES_SENT_EOF | CLOSES_RCVD_EOF) & ~c->closes) ||
7833          c->type == CHAN_ZOMBIE) &&
7834         !c->v.v2.chanreq_head &&
7835         !(c->closes & CLOSES_SENT_CLOSE)) {
7836         /*
7837          * We have both sent and received EOF (or the channel is a
7838          * zombie), and we have no outstanding channel requests, which
7839          * means the channel is in final wind-up. But we haven't sent
7840          * CLOSE, so let's do so now.
7841          */
7842         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE);
7843         ssh2_pkt_adduint32(pktout, c->remoteid);
7844         ssh2_pkt_send(ssh, pktout);
7845         c->closes |= CLOSES_SENT_EOF | CLOSES_SENT_CLOSE;
7846     }
7847
7848     if (!((CLOSES_SENT_CLOSE | CLOSES_RCVD_CLOSE) & ~c->closes)) {
7849         assert(c->v.v2.chanreq_head == NULL);
7850         /*
7851          * We have both sent and received CLOSE, which means we're
7852          * completely done with the channel.
7853          */
7854         ssh_channel_destroy(c);
7855     }
7856 }
7857
7858 static void ssh2_channel_got_eof(struct ssh_channel *c)
7859 {
7860     if (c->closes & CLOSES_RCVD_EOF)
7861         return;                        /* already seen EOF */
7862     c->closes |= CLOSES_RCVD_EOF;
7863
7864     if (c->type == CHAN_X11) {
7865         x11_send_eof(c->u.x11.xconn);
7866     } else if (c->type == CHAN_AGENT) {
7867         if (c->u.a.outstanding_requests == 0) {
7868             /* Manufacture an outgoing EOF in response to the incoming one. */
7869             sshfwd_write_eof(c);
7870         }
7871     } else if (c->type == CHAN_SOCKDATA) {
7872         pfd_send_eof(c->u.pfd.pf);
7873     } else if (c->type == CHAN_MAINSESSION) {
7874         Ssh ssh = c->ssh;
7875
7876         if (!ssh->sent_console_eof &&
7877             (from_backend_eof(ssh->frontend) || ssh->got_pty)) {
7878             /*
7879              * Either from_backend_eof told us that the front end
7880              * wants us to close the outgoing side of the connection
7881              * as soon as we see EOF from the far end, or else we've
7882              * unilaterally decided to do that because we've allocated
7883              * a remote pty and hence EOF isn't a particularly
7884              * meaningful concept.
7885              */
7886             sshfwd_write_eof(c);
7887         }
7888         ssh->sent_console_eof = TRUE;
7889     }
7890
7891     ssh2_channel_check_close(c);
7892 }
7893
7894 static void ssh2_msg_channel_eof(Ssh ssh, struct Packet *pktin)
7895 {
7896     struct ssh_channel *c;
7897
7898     c = ssh2_channel_msg(ssh, pktin);
7899     if (!c)
7900         return;
7901     if (c->type == CHAN_SHARING) {
7902         share_got_pkt_from_server(c->u.sharing.ctx, pktin->type,
7903                                   pktin->body, pktin->length);
7904         return;
7905     }
7906     ssh2_channel_got_eof(c);
7907 }
7908
7909 static void ssh2_msg_channel_close(Ssh ssh, struct Packet *pktin)
7910 {
7911     struct ssh_channel *c;
7912
7913     c = ssh2_channel_msg(ssh, pktin);
7914     if (!c)
7915         return;
7916     if (c->type == CHAN_SHARING) {
7917         share_got_pkt_from_server(c->u.sharing.ctx, pktin->type,
7918                                   pktin->body, pktin->length);
7919         return;
7920     }
7921
7922     /*
7923      * When we receive CLOSE on a channel, we assume it comes with an
7924      * implied EOF if we haven't seen EOF yet.
7925      */
7926     ssh2_channel_got_eof(c);
7927
7928     if (!(ssh->remote_bugs & BUG_SENDS_LATE_REQUEST_REPLY)) {
7929         /*
7930          * It also means we stop expecting to see replies to any
7931          * outstanding channel requests, so clean those up too.
7932          * (ssh_chanreq_init will enforce by assertion that we don't
7933          * subsequently put anything back on this list.)
7934          */
7935         while (c->v.v2.chanreq_head) {
7936             struct outstanding_channel_request *ocr = c->v.v2.chanreq_head;
7937             ocr->handler(c, NULL, ocr->ctx);
7938             c->v.v2.chanreq_head = ocr->next;
7939             sfree(ocr);
7940         }
7941     }
7942
7943     /*
7944      * And we also send an outgoing EOF, if we haven't already, on the
7945      * assumption that CLOSE is a pretty forceful announcement that
7946      * the remote side is doing away with the entire channel. (If it
7947      * had wanted to send us EOF and continue receiving data from us,
7948      * it would have just sent CHANNEL_EOF.)
7949      */
7950     if (!(c->closes & CLOSES_SENT_EOF)) {
7951         /*
7952          * Make sure we don't read any more from whatever our local
7953          * data source is for this channel.
7954          */
7955         switch (c->type) {
7956           case CHAN_MAINSESSION:
7957             ssh->send_ok = 0;     /* stop trying to read from stdin */
7958             break;
7959           case CHAN_X11:
7960             x11_override_throttle(c->u.x11.xconn, 1);
7961             break;
7962           case CHAN_SOCKDATA:
7963             pfd_override_throttle(c->u.pfd.pf, 1);
7964             break;
7965         }
7966
7967         /*
7968          * Abandon any buffered data we still wanted to send to this
7969          * channel. Receiving a CHANNEL_CLOSE is an indication that
7970          * the server really wants to get on and _destroy_ this
7971          * channel, and it isn't going to send us any further
7972          * WINDOW_ADJUSTs to permit us to send pending stuff.
7973          */
7974         bufchain_clear(&c->v.v2.outbuffer);
7975
7976         /*
7977          * Send outgoing EOF.
7978          */
7979         sshfwd_write_eof(c);
7980     }
7981
7982     /*
7983      * Now process the actual close.
7984      */
7985     if (!(c->closes & CLOSES_RCVD_CLOSE)) {
7986         c->closes |= CLOSES_RCVD_CLOSE;
7987         ssh2_channel_check_close(c);
7988     }
7989 }
7990
7991 static void ssh2_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin)
7992 {
7993     struct ssh_channel *c;
7994
7995     c = ssh2_channel_msg(ssh, pktin);
7996     if (!c)
7997         return;
7998     if (c->type == CHAN_SHARING) {
7999         share_got_pkt_from_server(c->u.sharing.ctx, pktin->type,
8000                                   pktin->body, pktin->length);
8001         return;
8002     }
8003     assert(c->halfopen); /* ssh2_channel_msg will have enforced this */
8004     c->remoteid = ssh_pkt_getuint32(pktin);
8005     c->halfopen = FALSE;
8006     c->v.v2.remwindow = ssh_pkt_getuint32(pktin);
8007     c->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
8008
8009     if (c->type == CHAN_SOCKDATA_DORMANT) {
8010         c->type = CHAN_SOCKDATA;
8011         if (c->u.pfd.pf)
8012             pfd_confirm(c->u.pfd.pf);
8013     } else if (c->type == CHAN_ZOMBIE) {
8014         /*
8015          * This case can occur if a local socket error occurred
8016          * between us sending out CHANNEL_OPEN and receiving
8017          * OPEN_CONFIRMATION. In this case, all we can do is
8018          * immediately initiate close proceedings now that we know the
8019          * server's id to put in the close message.
8020          */
8021         ssh2_channel_check_close(c);
8022     } else {
8023         /*
8024          * We never expect to receive OPEN_CONFIRMATION for any
8025          * *other* channel type (since only local-to-remote port
8026          * forwardings cause us to send CHANNEL_OPEN after the main
8027          * channel is live - all other auxiliary channel types are
8028          * initiated from the server end). It's safe to enforce this
8029          * by assertion rather than by ssh_disconnect, because the
8030          * real point is that we never constructed a half-open channel
8031          * structure in the first place with any type other than the
8032          * above.
8033          */
8034         assert(!"Funny channel type in ssh2_msg_channel_open_confirmation");
8035     }
8036
8037     if (c->pending_eof)
8038         ssh_channel_try_eof(c);        /* in case we had a pending EOF */
8039 }
8040
8041 static void ssh2_msg_channel_open_failure(Ssh ssh, struct Packet *pktin)
8042 {
8043     static const char *const reasons[] = {
8044         "<unknown reason code>",
8045             "Administratively prohibited",
8046             "Connect failed",
8047             "Unknown channel type",
8048             "Resource shortage",
8049     };
8050     unsigned reason_code;
8051     char *reason_string;
8052     int reason_length;
8053     struct ssh_channel *c;
8054
8055     c = ssh2_channel_msg(ssh, pktin);
8056     if (!c)
8057         return;
8058     if (c->type == CHAN_SHARING) {
8059         share_got_pkt_from_server(c->u.sharing.ctx, pktin->type,
8060                                   pktin->body, pktin->length);
8061         return;
8062     }
8063     assert(c->halfopen); /* ssh2_channel_msg will have enforced this */
8064
8065     if (c->type == CHAN_SOCKDATA_DORMANT) {
8066         reason_code = ssh_pkt_getuint32(pktin);
8067         if (reason_code >= lenof(reasons))
8068             reason_code = 0; /* ensure reasons[reason_code] in range */
8069         ssh_pkt_getstring(pktin, &reason_string, &reason_length);
8070         logeventf(ssh, "Forwarded connection refused by server: %s [%.*s]",
8071                   reasons[reason_code], reason_length, reason_string);
8072
8073         pfd_close(c->u.pfd.pf);
8074     } else if (c->type == CHAN_ZOMBIE) {
8075         /*
8076          * This case can occur if a local socket error occurred
8077          * between us sending out CHANNEL_OPEN and receiving
8078          * OPEN_FAILURE. In this case, we need do nothing except allow
8079          * the code below to throw the half-open channel away.
8080          */
8081     } else {
8082         /*
8083          * We never expect to receive OPEN_FAILURE for any *other*
8084          * channel type (since only local-to-remote port forwardings
8085          * cause us to send CHANNEL_OPEN after the main channel is
8086          * live - all other auxiliary channel types are initiated from
8087          * the server end). It's safe to enforce this by assertion
8088          * rather than by ssh_disconnect, because the real point is
8089          * that we never constructed a half-open channel structure in
8090          * the first place with any type other than the above.
8091          */
8092         assert(!"Funny channel type in ssh2_msg_channel_open_failure");
8093     }
8094
8095     del234(ssh->channels, c);
8096     sfree(c);
8097 }
8098
8099 static void ssh2_msg_channel_request(Ssh ssh, struct Packet *pktin)
8100 {
8101     char *type;
8102     int typelen, want_reply;
8103     int reply = SSH2_MSG_CHANNEL_FAILURE; /* default */
8104     struct ssh_channel *c;
8105     struct Packet *pktout;
8106
8107     c = ssh2_channel_msg(ssh, pktin);
8108     if (!c)
8109         return;
8110     if (c->type == CHAN_SHARING) {
8111         share_got_pkt_from_server(c->u.sharing.ctx, pktin->type,
8112                                   pktin->body, pktin->length);
8113         return;
8114     }
8115     ssh_pkt_getstring(pktin, &type, &typelen);
8116     want_reply = ssh2_pkt_getbool(pktin);
8117
8118     if (c->closes & CLOSES_SENT_CLOSE) {
8119         /*
8120          * We don't reply to channel requests after we've sent
8121          * CHANNEL_CLOSE for the channel, because our reply might
8122          * cross in the network with the other side's CHANNEL_CLOSE
8123          * and arrive after they have wound the channel up completely.
8124          */
8125         want_reply = FALSE;
8126     }
8127
8128     /*
8129      * Having got the channel number, we now look at
8130      * the request type string to see if it's something
8131      * we recognise.
8132      */
8133     if (c == ssh->mainchan) {
8134         /*
8135          * We recognise "exit-status" and "exit-signal" on
8136          * the primary channel.
8137          */
8138         if (typelen == 11 &&
8139             !memcmp(type, "exit-status", 11)) {
8140
8141             ssh->exitcode = ssh_pkt_getuint32(pktin);
8142             logeventf(ssh, "Server sent command exit status %d",
8143                       ssh->exitcode);
8144             reply = SSH2_MSG_CHANNEL_SUCCESS;
8145
8146         } else if (typelen == 11 &&
8147                    !memcmp(type, "exit-signal", 11)) {
8148
8149             int is_plausible = TRUE, is_int = FALSE;
8150             char *fmt_sig = NULL, *fmt_msg = NULL;
8151             char *msg;
8152             int msglen = 0, core = FALSE;
8153             /* ICK: older versions of OpenSSH (e.g. 3.4p1)
8154              * provide an `int' for the signal, despite its
8155              * having been a `string' in the drafts of RFC 4254 since at
8156              * least 2001. (Fixed in session.c 1.147.) Try to
8157              * infer which we can safely parse it as. */
8158             {
8159                 unsigned char *p = pktin->body +
8160                     pktin->savedpos;
8161                 long len = pktin->length - pktin->savedpos;
8162                 unsigned long num = GET_32BIT(p); /* what is it? */
8163                 /* If it's 0, it hardly matters; assume string */
8164                 if (num == 0) {
8165                     is_int = FALSE;
8166                 } else {
8167                     int maybe_int = FALSE, maybe_str = FALSE;
8168 #define CHECK_HYPOTHESIS(offset, result)                                \
8169                     do                                                  \
8170                     {                                                   \
8171                         int q = toint(offset);                          \
8172                         if (q >= 0 && q+4 <= len) {                     \
8173                             q = toint(q + 4 + GET_32BIT(p+q));          \
8174                             if (q >= 0 && q+4 <= len &&                 \
8175                                 ((q = toint(q + 4 + GET_32BIT(p+q))) != 0) && \
8176                                 q == len)                               \
8177                                 result = TRUE;                          \
8178                         }                                               \
8179                     } while(0)
8180                     CHECK_HYPOTHESIS(4+1, maybe_int);
8181                     CHECK_HYPOTHESIS(4+num+1, maybe_str);
8182 #undef CHECK_HYPOTHESIS
8183                     if (maybe_int && !maybe_str)
8184                         is_int = TRUE;
8185                     else if (!maybe_int && maybe_str)
8186                         is_int = FALSE;
8187                     else
8188                         /* Crikey. Either or neither. Panic. */
8189                         is_plausible = FALSE;
8190                 }
8191             }
8192             ssh->exitcode = 128;       /* means `unknown signal' */
8193             if (is_plausible) {
8194                 if (is_int) {
8195                     /* Old non-standard OpenSSH. */
8196                     int signum = ssh_pkt_getuint32(pktin);
8197                     fmt_sig = dupprintf(" %d", signum);
8198                     ssh->exitcode = 128 + signum;
8199                 } else {
8200                     /* As per RFC 4254. */
8201                     char *sig;
8202                     int siglen;
8203                     ssh_pkt_getstring(pktin, &sig, &siglen);
8204                     /* Signal name isn't supposed to be blank, but
8205                      * let's cope gracefully if it is. */
8206                     if (siglen) {
8207                         fmt_sig = dupprintf(" \"%.*s\"",
8208                                             siglen, sig);
8209                     }
8210
8211                     /*
8212                      * Really hideous method of translating the
8213                      * signal description back into a locally
8214                      * meaningful number.
8215                      */
8216
8217                     if (0)
8218                         ;
8219 #define TRANSLATE_SIGNAL(s) \
8220     else if (siglen == lenof(#s)-1 && !memcmp(sig, #s, siglen)) \
8221         ssh->exitcode = 128 + SIG ## s
8222 #ifdef SIGABRT
8223                     TRANSLATE_SIGNAL(ABRT);
8224 #endif
8225 #ifdef SIGALRM
8226                     TRANSLATE_SIGNAL(ALRM);
8227 #endif
8228 #ifdef SIGFPE
8229                     TRANSLATE_SIGNAL(FPE);
8230 #endif
8231 #ifdef SIGHUP
8232                     TRANSLATE_SIGNAL(HUP);
8233 #endif
8234 #ifdef SIGILL
8235                     TRANSLATE_SIGNAL(ILL);
8236 #endif
8237 #ifdef SIGINT
8238                     TRANSLATE_SIGNAL(INT);
8239 #endif
8240 #ifdef SIGKILL
8241                     TRANSLATE_SIGNAL(KILL);
8242 #endif
8243 #ifdef SIGPIPE
8244                     TRANSLATE_SIGNAL(PIPE);
8245 #endif
8246 #ifdef SIGQUIT
8247                     TRANSLATE_SIGNAL(QUIT);
8248 #endif
8249 #ifdef SIGSEGV
8250                     TRANSLATE_SIGNAL(SEGV);
8251 #endif
8252 #ifdef SIGTERM
8253                     TRANSLATE_SIGNAL(TERM);
8254 #endif
8255 #ifdef SIGUSR1
8256                     TRANSLATE_SIGNAL(USR1);
8257 #endif
8258 #ifdef SIGUSR2
8259                     TRANSLATE_SIGNAL(USR2);
8260 #endif
8261 #undef TRANSLATE_SIGNAL
8262                     else
8263                         ssh->exitcode = 128;
8264                 }
8265                 core = ssh2_pkt_getbool(pktin);
8266                 ssh_pkt_getstring(pktin, &msg, &msglen);
8267                 if (msglen) {
8268                     fmt_msg = dupprintf(" (\"%.*s\")", msglen, msg);
8269                 }
8270                 /* ignore lang tag */
8271             } /* else don't attempt to parse */
8272             logeventf(ssh, "Server exited on signal%s%s%s",
8273                       fmt_sig ? fmt_sig : "",
8274                       core ? " (core dumped)" : "",
8275                       fmt_msg ? fmt_msg : "");
8276             sfree(fmt_sig);
8277             sfree(fmt_msg);
8278             reply = SSH2_MSG_CHANNEL_SUCCESS;
8279
8280         }
8281     } else {
8282         /*
8283          * This is a channel request we don't know
8284          * about, so we now either ignore the request
8285          * or respond with CHANNEL_FAILURE, depending
8286          * on want_reply.
8287          */
8288         reply = SSH2_MSG_CHANNEL_FAILURE;
8289     }
8290     if (want_reply) {
8291         pktout = ssh2_pkt_init(reply);
8292         ssh2_pkt_adduint32(pktout, c->remoteid);
8293         ssh2_pkt_send(ssh, pktout);
8294     }
8295 }
8296
8297 static void ssh2_msg_global_request(Ssh ssh, struct Packet *pktin)
8298 {
8299     char *type;
8300     int typelen, want_reply;
8301     struct Packet *pktout;
8302
8303     ssh_pkt_getstring(pktin, &type, &typelen);
8304     want_reply = ssh2_pkt_getbool(pktin);
8305
8306     /*
8307      * We currently don't support any global requests
8308      * at all, so we either ignore the request or
8309      * respond with REQUEST_FAILURE, depending on
8310      * want_reply.
8311      */
8312     if (want_reply) {
8313         pktout = ssh2_pkt_init(SSH2_MSG_REQUEST_FAILURE);
8314         ssh2_pkt_send(ssh, pktout);
8315     }
8316 }
8317
8318 struct X11FakeAuth *ssh_sharing_add_x11_display(Ssh ssh, int authtype,
8319                                                 void *share_cs,
8320                                                 void *share_chan)
8321 {
8322     struct X11FakeAuth *auth;
8323
8324     /*
8325      * Make up a new set of fake X11 auth data, and add it to the tree
8326      * of currently valid ones with an indication of the sharing
8327      * context that it's relevant to.
8328      */
8329     auth = x11_invent_fake_auth(ssh->x11authtree, authtype);
8330     auth->share_cs = share_cs;
8331     auth->share_chan = share_chan;
8332
8333     return auth;
8334 }
8335
8336 void ssh_sharing_remove_x11_display(Ssh ssh, struct X11FakeAuth *auth)
8337 {
8338     del234(ssh->x11authtree, auth);
8339     x11_free_fake_auth(auth);
8340 }
8341
8342 static void ssh2_msg_channel_open(Ssh ssh, struct Packet *pktin)
8343 {
8344     char *type;
8345     int typelen;
8346     char *peeraddr;
8347     int peeraddrlen;
8348     int peerport;
8349     const char *error = NULL;
8350     struct ssh_channel *c;
8351     unsigned remid, winsize, pktsize;
8352     unsigned our_winsize_override = 0;
8353     struct Packet *pktout;
8354
8355     ssh_pkt_getstring(pktin, &type, &typelen);
8356     c = snew(struct ssh_channel);
8357     c->ssh = ssh;
8358
8359     remid = ssh_pkt_getuint32(pktin);
8360     winsize = ssh_pkt_getuint32(pktin);
8361     pktsize = ssh_pkt_getuint32(pktin);
8362
8363     if (typelen == 3 && !memcmp(type, "x11", 3)) {
8364         char *addrstr;
8365
8366         ssh_pkt_getstring(pktin, &peeraddr, &peeraddrlen);
8367         addrstr = snewn(peeraddrlen+1, char);
8368         memcpy(addrstr, peeraddr, peeraddrlen);
8369         addrstr[peeraddrlen] = '\0';
8370         peerport = ssh_pkt_getuint32(pktin);
8371
8372         logeventf(ssh, "Received X11 connect request from %s:%d",
8373                   addrstr, peerport);
8374
8375         if (!ssh->X11_fwd_enabled && !ssh->connshare)
8376             error = "X11 forwarding is not enabled";
8377         else {
8378             c->u.x11.xconn = x11_init(ssh->x11authtree, c,
8379                                       addrstr, peerport);
8380             c->type = CHAN_X11;
8381             c->u.x11.initial = TRUE;
8382
8383             /*
8384              * If we are a connection-sharing upstream, then we should
8385              * initially present a very small window, adequate to take
8386              * the X11 initial authorisation packet but not much more.
8387              * Downstream will then present us a larger window (by
8388              * fiat of the connection-sharing protocol) and we can
8389              * guarantee to send a positive-valued WINDOW_ADJUST.
8390              */
8391             if (ssh->connshare)
8392                 our_winsize_override = 128;
8393
8394             logevent("Opened X11 forward channel");
8395         }
8396
8397         sfree(addrstr);
8398     } else if (typelen == 15 &&
8399                !memcmp(type, "forwarded-tcpip", 15)) {
8400         struct ssh_rportfwd pf, *realpf;
8401         char *shost;
8402         int shostlen;
8403         ssh_pkt_getstring(pktin, &shost, &shostlen);/* skip address */
8404         pf.shost = dupprintf("%.*s", shostlen, shost);
8405         pf.sport = ssh_pkt_getuint32(pktin);
8406         ssh_pkt_getstring(pktin, &peeraddr, &peeraddrlen);
8407         peerport = ssh_pkt_getuint32(pktin);
8408         realpf = find234(ssh->rportfwds, &pf, NULL);
8409         logeventf(ssh, "Received remote port %s:%d open request "
8410                   "from %s:%d", pf.shost, pf.sport, peeraddr, peerport);
8411         sfree(pf.shost);
8412
8413         if (realpf == NULL) {
8414             error = "Remote port is not recognised";
8415         } else {
8416             char *err;
8417
8418             if (realpf->share_ctx) {
8419                 /*
8420                  * This port forwarding is on behalf of a
8421                  * connection-sharing downstream, so abandon our own
8422                  * channel-open procedure and just pass the message on
8423                  * to sshshare.c.
8424                  */
8425                 share_got_pkt_from_server(realpf->share_ctx, pktin->type,
8426                                           pktin->body, pktin->length);
8427                 sfree(c);
8428                 return;
8429             }
8430
8431             err = pfd_connect(&c->u.pfd.pf, realpf->dhost, realpf->dport,
8432                               c, ssh->conf, realpf->pfrec->addressfamily);
8433             logeventf(ssh, "Attempting to forward remote port to "
8434                       "%s:%d", realpf->dhost, realpf->dport);
8435             if (err != NULL) {
8436                 logeventf(ssh, "Port open failed: %s", err);
8437                 sfree(err);
8438                 error = "Port open failed";
8439             } else {
8440                 logevent("Forwarded port opened successfully");
8441                 c->type = CHAN_SOCKDATA;
8442             }
8443         }
8444     } else if (typelen == 22 &&
8445                !memcmp(type, "auth-agent@openssh.com", 22)) {
8446         if (!ssh->agentfwd_enabled)
8447             error = "Agent forwarding is not enabled";
8448         else {
8449             c->type = CHAN_AGENT;       /* identify channel type */
8450             c->u.a.lensofar = 0;
8451             c->u.a.message = NULL;
8452             c->u.a.outstanding_requests = 0;
8453         }
8454     } else {
8455         error = "Unsupported channel type requested";
8456     }
8457
8458     c->remoteid = remid;
8459     c->halfopen = FALSE;
8460     if (error) {
8461         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_FAILURE);
8462         ssh2_pkt_adduint32(pktout, c->remoteid);
8463         ssh2_pkt_adduint32(pktout, SSH2_OPEN_CONNECT_FAILED);
8464         ssh2_pkt_addstring(pktout, error);
8465         ssh2_pkt_addstring(pktout, "en");       /* language tag */
8466         ssh2_pkt_send(ssh, pktout);
8467         logeventf(ssh, "Rejected channel open: %s", error);
8468         sfree(c);
8469     } else {
8470         ssh2_channel_init(c);
8471         c->v.v2.remwindow = winsize;
8472         c->v.v2.remmaxpkt = pktsize;
8473         if (our_winsize_override) {
8474             c->v.v2.locwindow = c->v.v2.locmaxwin = c->v.v2.remlocwin =
8475                 our_winsize_override;
8476         }
8477         add234(ssh->channels, c);
8478         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
8479         ssh2_pkt_adduint32(pktout, c->remoteid);
8480         ssh2_pkt_adduint32(pktout, c->localid);
8481         ssh2_pkt_adduint32(pktout, c->v.v2.locwindow);
8482         ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT);      /* our max pkt size */
8483         ssh2_pkt_send(ssh, pktout);
8484     }
8485 }
8486
8487 void sshfwd_x11_sharing_handover(struct ssh_channel *c,
8488                                  void *share_cs, void *share_chan,
8489                                  const char *peer_addr, int peer_port,
8490                                  int endian, int protomajor, int protominor,
8491                                  const void *initial_data, int initial_len)
8492 {
8493     /*
8494      * This function is called when we've just discovered that an X
8495      * forwarding channel on which we'd been handling the initial auth
8496      * ourselves turns out to be destined for a connection-sharing
8497      * downstream. So we turn the channel into a CHAN_SHARING, meaning
8498      * that we completely stop tracking windows and buffering data and
8499      * just pass more or less unmodified SSH messages back and forth.
8500      */
8501     c->type = CHAN_SHARING;
8502     c->u.sharing.ctx = share_cs;
8503     share_setup_x11_channel(share_cs, share_chan,
8504                             c->localid, c->remoteid, c->v.v2.remwindow,
8505                             c->v.v2.remmaxpkt, c->v.v2.locwindow,
8506                             peer_addr, peer_port, endian,
8507                             protomajor, protominor,
8508                             initial_data, initial_len);
8509 }
8510
8511 void sshfwd_x11_is_local(struct ssh_channel *c)
8512 {
8513     /*
8514      * This function is called when we've just discovered that an X
8515      * forwarding channel is _not_ destined for a connection-sharing
8516      * downstream but we're going to handle it ourselves. We stop
8517      * presenting a cautiously small window and go into ordinary data
8518      * exchange mode.
8519      */
8520     c->u.x11.initial = FALSE;
8521     ssh2_set_window(c, ssh_is_simple(c->ssh) ? OUR_V2_BIGWIN : OUR_V2_WINSIZE);
8522 }
8523
8524 /*
8525  * Buffer banner messages for later display at some convenient point,
8526  * if we're going to display them.
8527  */
8528 static void ssh2_msg_userauth_banner(Ssh ssh, struct Packet *pktin)
8529 {
8530     /* Arbitrary limit to prevent unbounded inflation of buffer */
8531     if (conf_get_int(ssh->conf, CONF_ssh_show_banner) &&
8532         bufchain_size(&ssh->banner) <= 131072) {
8533         char *banner = NULL;
8534         int size = 0;
8535         ssh_pkt_getstring(pktin, &banner, &size);
8536         if (banner)
8537             bufchain_add(&ssh->banner, banner, size);
8538     }
8539 }
8540
8541 /* Helper function to deal with sending tty modes for "pty-req" */
8542 static void ssh2_send_ttymode(void *data, char *mode, char *val)
8543 {
8544     struct Packet *pktout = (struct Packet *)data;
8545     int i = 0;
8546     unsigned int arg = 0;
8547     while (strcmp(mode, ssh_ttymodes[i].mode) != 0) i++;
8548     if (i == lenof(ssh_ttymodes)) return;
8549     switch (ssh_ttymodes[i].type) {
8550       case TTY_OP_CHAR:
8551         arg = ssh_tty_parse_specchar(val);
8552         break;
8553       case TTY_OP_BOOL:
8554         arg = ssh_tty_parse_boolean(val);
8555         break;
8556     }
8557     ssh2_pkt_addbyte(pktout, ssh_ttymodes[i].opcode);
8558     ssh2_pkt_adduint32(pktout, arg);
8559 }
8560
8561 static void ssh2_setup_x11(struct ssh_channel *c, struct Packet *pktin,
8562                            void *ctx)
8563 {
8564     struct ssh2_setup_x11_state {
8565         int crLine;
8566     };
8567     Ssh ssh = c->ssh;
8568     struct Packet *pktout;
8569     crStateP(ssh2_setup_x11_state, ctx);
8570
8571     crBeginState;
8572
8573     logevent("Requesting X11 forwarding");
8574     pktout = ssh2_chanreq_init(ssh->mainchan, "x11-req",
8575                                ssh2_setup_x11, s);
8576     ssh2_pkt_addbool(pktout, 0);               /* many connections */
8577     ssh2_pkt_addstring(pktout, ssh->x11auth->protoname);
8578     ssh2_pkt_addstring(pktout, ssh->x11auth->datastring);
8579     ssh2_pkt_adduint32(pktout, ssh->x11disp->screennum);
8580     ssh2_pkt_send(ssh, pktout);
8581
8582     /* Wait to be called back with either a response packet, or NULL
8583      * meaning clean up and free our data */
8584     crReturnV;
8585
8586     if (pktin) {
8587         if (pktin->type == SSH2_MSG_CHANNEL_SUCCESS) {
8588             logevent("X11 forwarding enabled");
8589             ssh->X11_fwd_enabled = TRUE;
8590         } else
8591             logevent("X11 forwarding refused");
8592     }
8593
8594     crFinishFreeV;
8595 }
8596
8597 static void ssh2_setup_agent(struct ssh_channel *c, struct Packet *pktin,
8598                                    void *ctx)
8599 {
8600     struct ssh2_setup_agent_state {
8601         int crLine;
8602     };
8603     Ssh ssh = c->ssh;
8604     struct Packet *pktout;
8605     crStateP(ssh2_setup_agent_state, ctx);
8606
8607     crBeginState;
8608
8609     logevent("Requesting OpenSSH-style agent forwarding");
8610     pktout = ssh2_chanreq_init(ssh->mainchan, "auth-agent-req@openssh.com",
8611                                ssh2_setup_agent, s);
8612     ssh2_pkt_send(ssh, pktout);
8613
8614     /* Wait to be called back with either a response packet, or NULL
8615      * meaning clean up and free our data */
8616     crReturnV;
8617
8618     if (pktin) {
8619         if (pktin->type == SSH2_MSG_CHANNEL_SUCCESS) {
8620             logevent("Agent forwarding enabled");
8621             ssh->agentfwd_enabled = TRUE;
8622         } else
8623             logevent("Agent forwarding refused");
8624     }
8625
8626     crFinishFreeV;
8627 }
8628
8629 static void ssh2_setup_pty(struct ssh_channel *c, struct Packet *pktin,
8630                                  void *ctx)
8631 {
8632     struct ssh2_setup_pty_state {
8633         int crLine;
8634     };
8635     Ssh ssh = c->ssh;
8636     struct Packet *pktout;
8637     crStateP(ssh2_setup_pty_state, ctx);
8638
8639     crBeginState;
8640
8641     /* Unpick the terminal-speed string. */
8642     /* XXX perhaps we should allow no speeds to be sent. */
8643     ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
8644     sscanf(conf_get_str(ssh->conf, CONF_termspeed), "%d,%d", &ssh->ospeed, &ssh->ispeed);
8645     /* Build the pty request. */
8646     pktout = ssh2_chanreq_init(ssh->mainchan, "pty-req",
8647                                ssh2_setup_pty, s);
8648     ssh2_pkt_addstring(pktout, conf_get_str(ssh->conf, CONF_termtype));
8649     ssh2_pkt_adduint32(pktout, ssh->term_width);
8650     ssh2_pkt_adduint32(pktout, ssh->term_height);
8651     ssh2_pkt_adduint32(pktout, 0);             /* pixel width */
8652     ssh2_pkt_adduint32(pktout, 0);             /* pixel height */
8653     ssh2_pkt_addstring_start(pktout);
8654     parse_ttymodes(ssh, ssh2_send_ttymode, (void *)pktout);
8655     ssh2_pkt_addbyte(pktout, SSH2_TTY_OP_ISPEED);
8656     ssh2_pkt_adduint32(pktout, ssh->ispeed);
8657     ssh2_pkt_addbyte(pktout, SSH2_TTY_OP_OSPEED);
8658     ssh2_pkt_adduint32(pktout, ssh->ospeed);
8659     ssh2_pkt_addstring_data(pktout, "\0", 1); /* TTY_OP_END */
8660     ssh2_pkt_send(ssh, pktout);
8661     ssh->state = SSH_STATE_INTERMED;
8662
8663     /* Wait to be called back with either a response packet, or NULL
8664      * meaning clean up and free our data */
8665     crReturnV;
8666
8667     if (pktin) {
8668         if (pktin->type == SSH2_MSG_CHANNEL_SUCCESS) {
8669             logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
8670                       ssh->ospeed, ssh->ispeed);
8671             ssh->got_pty = TRUE;
8672         } else {
8673             c_write_str(ssh, "Server refused to allocate pty\r\n");
8674             ssh->editing = ssh->echoing = 1;
8675         }
8676     }
8677
8678     crFinishFreeV;
8679 }
8680
8681 static void ssh2_setup_env(struct ssh_channel *c, struct Packet *pktin,
8682                            void *ctx)
8683 {
8684     struct ssh2_setup_env_state {
8685         int crLine;
8686         int num_env, env_left, env_ok;
8687     };
8688     Ssh ssh = c->ssh;
8689     struct Packet *pktout;
8690     crStateP(ssh2_setup_env_state, ctx);
8691
8692     crBeginState;
8693
8694     /*
8695      * Send environment variables.
8696      * 
8697      * Simplest thing here is to send all the requests at once, and
8698      * then wait for a whole bunch of successes or failures.
8699      */
8700     s->num_env = 0;
8701     {
8702         char *key, *val;
8703
8704         for (val = conf_get_str_strs(ssh->conf, CONF_environmt, NULL, &key);
8705              val != NULL;
8706              val = conf_get_str_strs(ssh->conf, CONF_environmt, key, &key)) {
8707             pktout = ssh2_chanreq_init(ssh->mainchan, "env", ssh2_setup_env, s);
8708             ssh2_pkt_addstring(pktout, key);
8709             ssh2_pkt_addstring(pktout, val);
8710             ssh2_pkt_send(ssh, pktout);
8711
8712             s->num_env++;
8713         }
8714         if (s->num_env)
8715             logeventf(ssh, "Sent %d environment variables", s->num_env);
8716     }
8717
8718     if (s->num_env) {
8719         s->env_ok = 0;
8720         s->env_left = s->num_env;
8721
8722         while (s->env_left > 0) {
8723             /* Wait to be called back with either a response packet,
8724              * or NULL meaning clean up and free our data */
8725             crReturnV;
8726             if (!pktin) goto out;
8727             if (pktin->type == SSH2_MSG_CHANNEL_SUCCESS)
8728                 s->env_ok++;
8729             s->env_left--;
8730         }
8731
8732         if (s->env_ok == s->num_env) {
8733             logevent("All environment variables successfully set");
8734         } else if (s->env_ok == 0) {
8735             logevent("All environment variables refused");
8736             c_write_str(ssh, "Server refused to set environment variables\r\n");
8737         } else {
8738             logeventf(ssh, "%d environment variables refused",
8739                       s->num_env - s->env_ok);
8740             c_write_str(ssh, "Server refused to set all environment variables\r\n");
8741         }
8742     }
8743   out:;
8744     crFinishFreeV;
8745 }
8746
8747 /*
8748  * Handle the SSH-2 userauth and connection layers.
8749  */
8750 static void ssh2_msg_authconn(Ssh ssh, struct Packet *pktin)
8751 {
8752     do_ssh2_authconn(ssh, NULL, 0, pktin);
8753 }
8754
8755 static void ssh2_response_authconn(struct ssh_channel *c, struct Packet *pktin,
8756                                    void *ctx)
8757 {
8758     if (pktin)
8759         do_ssh2_authconn(c->ssh, NULL, 0, pktin);
8760 }
8761
8762 static void do_ssh2_authconn(Ssh ssh, const unsigned char *in, int inlen,
8763                              struct Packet *pktin)
8764 {
8765     struct do_ssh2_authconn_state {
8766         int crLine;
8767         enum {
8768             AUTH_TYPE_NONE,
8769                 AUTH_TYPE_PUBLICKEY,
8770                 AUTH_TYPE_PUBLICKEY_OFFER_LOUD,
8771                 AUTH_TYPE_PUBLICKEY_OFFER_QUIET,
8772                 AUTH_TYPE_PASSWORD,
8773                 AUTH_TYPE_GSSAPI,      /* always QUIET */
8774                 AUTH_TYPE_KEYBOARD_INTERACTIVE,
8775                 AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
8776         } type;
8777         int done_service_req;
8778         int gotit, need_pw, can_pubkey, can_passwd, can_keyb_inter;
8779         int tried_pubkey_config, done_agent;
8780 #ifndef NO_GSSAPI
8781         int can_gssapi;
8782         int tried_gssapi;
8783 #endif
8784         int kbd_inter_refused;
8785         int we_are_in, userauth_success;
8786         prompts_t *cur_prompt;
8787         int num_prompts;
8788         char *username;
8789         char *password;
8790         int got_username;
8791         void *publickey_blob;
8792         int publickey_bloblen;
8793         int privatekey_available, privatekey_encrypted;
8794         char *publickey_algorithm;
8795         char *publickey_comment;
8796         unsigned char agent_request[5], *agent_response, *agentp;
8797         int agent_responselen;
8798         unsigned char *pkblob_in_agent;
8799         int keyi, nkeys;
8800         char *pkblob, *alg, *commentp;
8801         int pklen, alglen, commentlen;
8802         int siglen, retlen, len;
8803         char *q, *agentreq, *ret;
8804         int try_send;
8805         struct Packet *pktout;
8806         Filename *keyfile;
8807 #ifndef NO_GSSAPI
8808         struct ssh_gss_library *gsslib;
8809         Ssh_gss_ctx gss_ctx;
8810         Ssh_gss_buf gss_buf;
8811         Ssh_gss_buf gss_rcvtok, gss_sndtok;
8812         Ssh_gss_name gss_srv_name;
8813         Ssh_gss_stat gss_stat;
8814 #endif
8815     };
8816     crState(do_ssh2_authconn_state);
8817
8818     crBeginState;
8819
8820     /* Register as a handler for all the messages this coroutine handles. */
8821     ssh->packet_dispatch[SSH2_MSG_SERVICE_ACCEPT] = ssh2_msg_authconn;
8822     ssh->packet_dispatch[SSH2_MSG_USERAUTH_REQUEST] = ssh2_msg_authconn;
8823     ssh->packet_dispatch[SSH2_MSG_USERAUTH_FAILURE] = ssh2_msg_authconn;
8824     ssh->packet_dispatch[SSH2_MSG_USERAUTH_SUCCESS] = ssh2_msg_authconn;
8825     ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = ssh2_msg_authconn;
8826     ssh->packet_dispatch[SSH2_MSG_USERAUTH_PK_OK] = ssh2_msg_authconn;
8827     /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ] = ssh2_msg_authconn; duplicate case value */
8828     /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_REQUEST] = ssh2_msg_authconn; duplicate case value */
8829     ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_RESPONSE] = ssh2_msg_authconn;
8830     ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] = ssh2_msg_authconn;
8831     ssh->packet_dispatch[SSH2_MSG_REQUEST_SUCCESS] = ssh2_msg_authconn;
8832     ssh->packet_dispatch[SSH2_MSG_REQUEST_FAILURE] = ssh2_msg_authconn;
8833     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] = ssh2_msg_authconn;
8834     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] = ssh2_msg_authconn;
8835     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] = ssh2_msg_authconn;
8836     ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] = ssh2_msg_authconn;
8837     ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] = ssh2_msg_authconn;
8838     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] = ssh2_msg_authconn;
8839     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = ssh2_msg_authconn;
8840     ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = ssh2_msg_authconn;
8841     
8842     s->done_service_req = FALSE;
8843     s->we_are_in = s->userauth_success = FALSE;
8844     s->agent_response = NULL;
8845 #ifndef NO_GSSAPI
8846     s->tried_gssapi = FALSE;
8847 #endif
8848
8849     if (!ssh->bare_connection) {
8850         if (!conf_get_int(ssh->conf, CONF_ssh_no_userauth)) {
8851             /*
8852              * Request userauth protocol, and await a response to it.
8853              */
8854             s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST);
8855             ssh2_pkt_addstring(s->pktout, "ssh-userauth");
8856             ssh2_pkt_send(ssh, s->pktout);
8857             crWaitUntilV(pktin);
8858             if (pktin->type == SSH2_MSG_SERVICE_ACCEPT)
8859                 s->done_service_req = TRUE;
8860         }
8861         if (!s->done_service_req) {
8862             /*
8863              * Request connection protocol directly, without authentication.
8864              */
8865             s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST);
8866             ssh2_pkt_addstring(s->pktout, "ssh-connection");
8867             ssh2_pkt_send(ssh, s->pktout);
8868             crWaitUntilV(pktin);
8869             if (pktin->type == SSH2_MSG_SERVICE_ACCEPT) {
8870                 s->we_are_in = TRUE; /* no auth required */
8871             } else {
8872                 bombout(("Server refused service request"));
8873                 crStopV;
8874             }
8875         }
8876     } else {
8877         s->we_are_in = TRUE;
8878     }
8879
8880     /* Arrange to be able to deal with any BANNERs that come in.
8881      * (We do this now as packets may come in during the next bit.) */
8882     bufchain_init(&ssh->banner);
8883     ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] =
8884         ssh2_msg_userauth_banner;
8885
8886     /*
8887      * Misc one-time setup for authentication.
8888      */
8889     s->publickey_blob = NULL;
8890     if (!s->we_are_in) {
8891
8892         /*
8893          * Load the public half of any configured public key file
8894          * for later use.
8895          */
8896         s->keyfile = conf_get_filename(ssh->conf, CONF_keyfile);
8897         if (!filename_is_null(s->keyfile)) {
8898             int keytype;
8899             logeventf(ssh, "Reading key file \"%.150s\"",
8900                       filename_to_str(s->keyfile));
8901             keytype = key_type(s->keyfile);
8902             if (keytype == SSH_KEYTYPE_SSH2 ||
8903                 keytype == SSH_KEYTYPE_SSH2_PUBLIC_RFC4716 ||
8904                 keytype == SSH_KEYTYPE_SSH2_PUBLIC_OPENSSH) {
8905                 const char *error;
8906                 s->publickey_blob =
8907                     ssh2_userkey_loadpub(s->keyfile,
8908                                          &s->publickey_algorithm,
8909                                          &s->publickey_bloblen, 
8910                                          &s->publickey_comment, &error);
8911                 if (s->publickey_blob) {
8912                     s->privatekey_available = (keytype == SSH_KEYTYPE_SSH2);
8913                     if (!s->privatekey_available)
8914                         logeventf(ssh, "Key file contains public key only");
8915                     s->privatekey_encrypted =
8916                         ssh2_userkey_encrypted(s->keyfile, NULL);
8917                 } else {
8918                     char *msgbuf;
8919                     logeventf(ssh, "Unable to load key (%s)", 
8920                               error);
8921                     msgbuf = dupprintf("Unable to load key file "
8922                                        "\"%.150s\" (%s)\r\n",
8923                                        filename_to_str(s->keyfile),
8924                                        error);
8925                     c_write_str(ssh, msgbuf);
8926                     sfree(msgbuf);
8927                 }
8928             } else {
8929                 char *msgbuf;
8930                 logeventf(ssh, "Unable to use this key file (%s)",
8931                           key_type_to_str(keytype));
8932                 msgbuf = dupprintf("Unable to use key file \"%.150s\""
8933                                    " (%s)\r\n",
8934                                    filename_to_str(s->keyfile),
8935                                    key_type_to_str(keytype));
8936                 c_write_str(ssh, msgbuf);
8937                 sfree(msgbuf);
8938                 s->publickey_blob = NULL;
8939             }
8940         }
8941
8942         /*
8943          * Find out about any keys Pageant has (but if there's a
8944          * public key configured, filter out all others).
8945          */
8946         s->nkeys = 0;
8947         s->agent_response = NULL;
8948         s->pkblob_in_agent = NULL;
8949         if (conf_get_int(ssh->conf, CONF_tryagent) && agent_exists()) {
8950
8951             void *r;
8952
8953             logevent("Pageant is running. Requesting keys.");
8954
8955             /* Request the keys held by the agent. */
8956             PUT_32BIT(s->agent_request, 1);
8957             s->agent_request[4] = SSH2_AGENTC_REQUEST_IDENTITIES;
8958             if (!agent_query(s->agent_request, 5, &r, &s->agent_responselen,
8959                              ssh_agent_callback, ssh)) {
8960                 do {
8961                     crReturnV;
8962                     if (pktin) {
8963                         bombout(("Unexpected data from server while"
8964                                  " waiting for agent response"));
8965                         crStopV;
8966                     }
8967                 } while (pktin || inlen > 0);
8968                 r = ssh->agent_response;
8969                 s->agent_responselen = ssh->agent_response_len;
8970             }
8971             s->agent_response = (unsigned char *) r;
8972             if (s->agent_response && s->agent_responselen >= 5 &&
8973                 s->agent_response[4] == SSH2_AGENT_IDENTITIES_ANSWER) {
8974                 int keyi;
8975                 unsigned char *p;
8976                 p = s->agent_response + 5;
8977                 s->nkeys = toint(GET_32BIT(p));
8978
8979                 /*
8980                  * Vet the Pageant response to ensure that the key
8981                  * count and blob lengths make sense.
8982                  */
8983                 if (s->nkeys < 0) {
8984                     logeventf(ssh, "Pageant response contained a negative"
8985                               " key count %d", s->nkeys);
8986                     s->nkeys = 0;
8987                     goto done_agent_query;
8988                 } else {
8989                     unsigned char *q = p + 4;
8990                     int lenleft = s->agent_responselen - 5 - 4;
8991
8992                     for (keyi = 0; keyi < s->nkeys; keyi++) {
8993                         int bloblen, commentlen;
8994                         if (lenleft < 4) {
8995                             logeventf(ssh, "Pageant response was truncated");
8996                             s->nkeys = 0;
8997                             goto done_agent_query;
8998                         }
8999                         bloblen = toint(GET_32BIT(q));
9000                         if (bloblen < 0 || bloblen > lenleft) {
9001                             logeventf(ssh, "Pageant response was truncated");
9002                             s->nkeys = 0;
9003                             goto done_agent_query;
9004                         }
9005                         lenleft -= 4 + bloblen;
9006                         q += 4 + bloblen;
9007                         commentlen = toint(GET_32BIT(q));
9008                         if (commentlen < 0 || commentlen > lenleft) {
9009                             logeventf(ssh, "Pageant response was truncated");
9010                             s->nkeys = 0;
9011                             goto done_agent_query;
9012                         }
9013                         lenleft -= 4 + commentlen;
9014                         q += 4 + commentlen;
9015                     }
9016                 }
9017
9018                 p += 4;
9019                 logeventf(ssh, "Pageant has %d SSH-2 keys", s->nkeys);
9020                 if (s->publickey_blob) {
9021                     /* See if configured key is in agent. */
9022                     for (keyi = 0; keyi < s->nkeys; keyi++) {
9023                         s->pklen = toint(GET_32BIT(p));
9024                         if (s->pklen == s->publickey_bloblen &&
9025                             !memcmp(p+4, s->publickey_blob,
9026                                     s->publickey_bloblen)) {
9027                             logeventf(ssh, "Pageant key #%d matches "
9028                                       "configured key file", keyi);
9029                             s->keyi = keyi;
9030                             s->pkblob_in_agent = p;
9031                             break;
9032                         }
9033                         p += 4 + s->pklen;
9034                         p += toint(GET_32BIT(p)) + 4; /* comment */
9035                     }
9036                     if (!s->pkblob_in_agent) {
9037                         logevent("Configured key file not in Pageant");
9038                         s->nkeys = 0;
9039                     }
9040                 }
9041             } else {
9042                 logevent("Failed to get reply from Pageant");
9043             }
9044           done_agent_query:;
9045         }
9046
9047     }
9048
9049     /*
9050      * We repeat this whole loop, including the username prompt,
9051      * until we manage a successful authentication. If the user
9052      * types the wrong _password_, they can be sent back to the
9053      * beginning to try another username, if this is configured on.
9054      * (If they specify a username in the config, they are never
9055      * asked, even if they do give a wrong password.)
9056      * 
9057      * I think this best serves the needs of
9058      * 
9059      *  - the people who have no configuration, no keys, and just
9060      *    want to try repeated (username,password) pairs until they
9061      *    type both correctly
9062      * 
9063      *  - people who have keys and configuration but occasionally
9064      *    need to fall back to passwords
9065      * 
9066      *  - people with a key held in Pageant, who might not have
9067      *    logged in to a particular machine before; so they want to
9068      *    type a username, and then _either_ their key will be
9069      *    accepted, _or_ they will type a password. If they mistype
9070      *    the username they will want to be able to get back and
9071      *    retype it!
9072      */
9073     s->got_username = FALSE;
9074     while (!s->we_are_in) {
9075         /*
9076          * Get a username.
9077          */
9078         if (s->got_username && !conf_get_int(ssh->conf, CONF_change_username)) {
9079             /*
9080              * We got a username last time round this loop, and
9081              * with change_username turned off we don't try to get
9082              * it again.
9083              */
9084         } else if ((ssh->username = get_remote_username(ssh->conf)) == NULL) {
9085             int ret; /* need not be kept over crReturn */
9086             s->cur_prompt = new_prompts(ssh->frontend);
9087             s->cur_prompt->to_server = TRUE;
9088             s->cur_prompt->name = dupstr("SSH login name");
9089             add_prompt(s->cur_prompt, dupstr("login as: "), TRUE); 
9090             ret = get_userpass_input(s->cur_prompt, NULL, 0);
9091             while (ret < 0) {
9092                 ssh->send_ok = 1;
9093                 crWaitUntilV(!pktin);
9094                 ret = get_userpass_input(s->cur_prompt, in, inlen);
9095                 ssh->send_ok = 0;
9096             }
9097             if (!ret) {
9098                 /*
9099                  * get_userpass_input() failed to get a username.
9100                  * Terminate.
9101                  */
9102                 free_prompts(s->cur_prompt);
9103                 ssh_disconnect(ssh, "No username provided", NULL, 0, TRUE);
9104                 crStopV;
9105             }
9106             ssh->username = dupstr(s->cur_prompt->prompts[0]->result);
9107             free_prompts(s->cur_prompt);
9108         } else {
9109             char *stuff;
9110             if ((flags & FLAG_VERBOSE) || (flags & FLAG_INTERACTIVE)) {
9111                 stuff = dupprintf("Using username \"%s\".\r\n", ssh->username);
9112                 c_write_str(ssh, stuff);
9113                 sfree(stuff);
9114             }
9115         }
9116         s->got_username = TRUE;
9117
9118         /*
9119          * Send an authentication request using method "none": (a)
9120          * just in case it succeeds, and (b) so that we know what
9121          * authentication methods we can usefully try next.
9122          */
9123         ssh->pkt_actx = SSH2_PKTCTX_NOAUTH;
9124
9125         s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
9126         ssh2_pkt_addstring(s->pktout, ssh->username);
9127         ssh2_pkt_addstring(s->pktout, "ssh-connection");/* service requested */
9128         ssh2_pkt_addstring(s->pktout, "none");    /* method */
9129         ssh2_pkt_send(ssh, s->pktout);
9130         s->type = AUTH_TYPE_NONE;
9131         s->gotit = FALSE;
9132         s->we_are_in = FALSE;
9133
9134         s->tried_pubkey_config = FALSE;
9135         s->kbd_inter_refused = FALSE;
9136
9137         /* Reset agent request state. */
9138         s->done_agent = FALSE;
9139         if (s->agent_response) {
9140             if (s->pkblob_in_agent) {
9141                 s->agentp = s->pkblob_in_agent;
9142             } else {
9143                 s->agentp = s->agent_response + 5 + 4;
9144                 s->keyi = 0;
9145             }
9146         }
9147
9148         while (1) {
9149             char *methods = NULL;
9150             int methlen = 0;
9151
9152             /*
9153              * Wait for the result of the last authentication request.
9154              */
9155             if (!s->gotit)
9156                 crWaitUntilV(pktin);
9157             /*
9158              * Now is a convenient point to spew any banner material
9159              * that we've accumulated. (This should ensure that when
9160              * we exit the auth loop, we haven't any left to deal
9161              * with.)
9162              */
9163             {
9164                 int size = bufchain_size(&ssh->banner);
9165                 /*
9166                  * Don't show the banner if we're operating in
9167                  * non-verbose non-interactive mode. (It's probably
9168                  * a script, which means nobody will read the
9169                  * banner _anyway_, and moreover the printing of
9170                  * the banner will screw up processing on the
9171                  * output of (say) plink.)
9172                  */
9173                 if (size && (flags & (FLAG_VERBOSE | FLAG_INTERACTIVE))) {
9174                     char *banner = snewn(size, char);
9175                     bufchain_fetch(&ssh->banner, banner, size);
9176                     c_write_untrusted(ssh, banner, size);
9177                     sfree(banner);
9178                 }
9179                 bufchain_clear(&ssh->banner);
9180             }
9181             if (pktin->type == SSH2_MSG_USERAUTH_SUCCESS) {
9182                 logevent("Access granted");
9183                 s->we_are_in = s->userauth_success = TRUE;
9184                 break;
9185             }
9186
9187             if (pktin->type != SSH2_MSG_USERAUTH_FAILURE && s->type != AUTH_TYPE_GSSAPI) {
9188                 bombout(("Strange packet received during authentication: "
9189                          "type %d", pktin->type));
9190                 crStopV;
9191             }
9192
9193             s->gotit = FALSE;
9194
9195             /*
9196              * OK, we're now sitting on a USERAUTH_FAILURE message, so
9197              * we can look at the string in it and know what we can
9198              * helpfully try next.
9199              */
9200             if (pktin->type == SSH2_MSG_USERAUTH_FAILURE) {
9201                 ssh_pkt_getstring(pktin, &methods, &methlen);
9202                 if (!ssh2_pkt_getbool(pktin)) {
9203                     /*
9204                      * We have received an unequivocal Access
9205                      * Denied. This can translate to a variety of
9206                      * messages, or no message at all.
9207                      *
9208                      * For forms of authentication which are attempted
9209                      * implicitly, by which I mean without printing
9210                      * anything in the window indicating that we're
9211                      * trying them, we should never print 'Access
9212                      * denied'.
9213                      *
9214                      * If we do print a message saying that we're
9215                      * attempting some kind of authentication, it's OK
9216                      * to print a followup message saying it failed -
9217                      * but the message may sometimes be more specific
9218                      * than simply 'Access denied'.
9219                      *
9220                      * Additionally, if we'd just tried password
9221                      * authentication, we should break out of this
9222                      * whole loop so as to go back to the username
9223                      * prompt (iff we're configured to allow
9224                      * username change attempts).
9225                      */
9226                     if (s->type == AUTH_TYPE_NONE) {
9227                         /* do nothing */
9228                     } else if (s->type == AUTH_TYPE_PUBLICKEY_OFFER_LOUD ||
9229                                s->type == AUTH_TYPE_PUBLICKEY_OFFER_QUIET) {
9230                         if (s->type == AUTH_TYPE_PUBLICKEY_OFFER_LOUD)
9231                             c_write_str(ssh, "Server refused our key\r\n");
9232                         logevent("Server refused our key");
9233                     } else if (s->type == AUTH_TYPE_PUBLICKEY) {
9234                         /* This _shouldn't_ happen except by a
9235                          * protocol bug causing client and server to
9236                          * disagree on what is a correct signature. */
9237                         c_write_str(ssh, "Server refused public-key signature"
9238                                     " despite accepting key!\r\n");
9239                         logevent("Server refused public-key signature"
9240                                  " despite accepting key!");
9241                     } else if (s->type==AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET) {
9242                         /* quiet, so no c_write */
9243                         logevent("Server refused keyboard-interactive authentication");
9244                     } else if (s->type==AUTH_TYPE_GSSAPI) {
9245                         /* always quiet, so no c_write */
9246                         /* also, the code down in the GSSAPI block has
9247                          * already logged this in the Event Log */
9248                     } else if (s->type == AUTH_TYPE_KEYBOARD_INTERACTIVE) {
9249                         logevent("Keyboard-interactive authentication failed");
9250                         c_write_str(ssh, "Access denied\r\n");
9251                     } else {
9252                         assert(s->type == AUTH_TYPE_PASSWORD);
9253                         logevent("Password authentication failed");
9254                         c_write_str(ssh, "Access denied\r\n");
9255
9256                         if (conf_get_int(ssh->conf, CONF_change_username)) {
9257                             /* XXX perhaps we should allow
9258                              * keyboard-interactive to do this too? */
9259                             s->we_are_in = FALSE;
9260                             break;
9261                         }
9262                     }
9263                 } else {
9264                     c_write_str(ssh, "Further authentication required\r\n");
9265                     logevent("Further authentication required");
9266                 }
9267
9268                 s->can_pubkey =
9269                     in_commasep_string("publickey", methods, methlen);
9270                 s->can_passwd =
9271                     in_commasep_string("password", methods, methlen);
9272                 s->can_keyb_inter = conf_get_int(ssh->conf, CONF_try_ki_auth) &&
9273                     in_commasep_string("keyboard-interactive", methods, methlen);
9274 #ifndef NO_GSSAPI
9275                 if (!ssh->gsslibs)
9276                     ssh->gsslibs = ssh_gss_setup(ssh->conf);
9277                 s->can_gssapi = conf_get_int(ssh->conf, CONF_try_gssapi_auth) &&
9278                     in_commasep_string("gssapi-with-mic", methods, methlen) &&
9279                     ssh->gsslibs->nlibraries > 0;
9280 #endif
9281             }
9282
9283             ssh->pkt_actx = SSH2_PKTCTX_NOAUTH;
9284
9285             if (s->can_pubkey && !s->done_agent && s->nkeys) {
9286
9287                 /*
9288                  * Attempt public-key authentication using a key from Pageant.
9289                  */
9290
9291                 ssh->pkt_actx = SSH2_PKTCTX_PUBLICKEY;
9292
9293                 logeventf(ssh, "Trying Pageant key #%d", s->keyi);
9294
9295                 /* Unpack key from agent response */
9296                 s->pklen = toint(GET_32BIT(s->agentp));
9297                 s->agentp += 4;
9298                 s->pkblob = (char *)s->agentp;
9299                 s->agentp += s->pklen;
9300                 s->alglen = toint(GET_32BIT(s->pkblob));
9301                 s->alg = s->pkblob + 4;
9302                 s->commentlen = toint(GET_32BIT(s->agentp));
9303                 s->agentp += 4;
9304                 s->commentp = (char *)s->agentp;
9305                 s->agentp += s->commentlen;
9306                 /* s->agentp now points at next key, if any */
9307
9308                 /* See if server will accept it */
9309                 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
9310                 ssh2_pkt_addstring(s->pktout, ssh->username);
9311                 ssh2_pkt_addstring(s->pktout, "ssh-connection");
9312                                                     /* service requested */
9313                 ssh2_pkt_addstring(s->pktout, "publickey");
9314                                                     /* method */
9315                 ssh2_pkt_addbool(s->pktout, FALSE); /* no signature included */
9316                 ssh2_pkt_addstring_start(s->pktout);
9317                 ssh2_pkt_addstring_data(s->pktout, s->alg, s->alglen);
9318                 ssh2_pkt_addstring_start(s->pktout);
9319                 ssh2_pkt_addstring_data(s->pktout, s->pkblob, s->pklen);
9320                 ssh2_pkt_send(ssh, s->pktout);
9321                 s->type = AUTH_TYPE_PUBLICKEY_OFFER_QUIET;
9322
9323                 crWaitUntilV(pktin);
9324                 if (pktin->type != SSH2_MSG_USERAUTH_PK_OK) {
9325
9326                     /* Offer of key refused. */
9327                     s->gotit = TRUE;
9328
9329                 } else {
9330                     
9331                     void *vret;
9332
9333                     if (flags & FLAG_VERBOSE) {
9334                         c_write_str(ssh, "Authenticating with "
9335                                     "public key \"");
9336                         c_write(ssh, s->commentp, s->commentlen);
9337                         c_write_str(ssh, "\" from agent\r\n");
9338                     }
9339
9340                     /*
9341                      * Server is willing to accept the key.
9342                      * Construct a SIGN_REQUEST.
9343                      */
9344                     s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
9345                     ssh2_pkt_addstring(s->pktout, ssh->username);
9346                     ssh2_pkt_addstring(s->pktout, "ssh-connection");
9347                                                         /* service requested */
9348                     ssh2_pkt_addstring(s->pktout, "publickey");
9349                                                         /* method */
9350                     ssh2_pkt_addbool(s->pktout, TRUE);  /* signature included */
9351                     ssh2_pkt_addstring_start(s->pktout);
9352                     ssh2_pkt_addstring_data(s->pktout, s->alg, s->alglen);
9353                     ssh2_pkt_addstring_start(s->pktout);
9354                     ssh2_pkt_addstring_data(s->pktout, s->pkblob, s->pklen);
9355
9356                     /* Ask agent for signature. */
9357                     s->siglen = s->pktout->length - 5 + 4 +
9358                         ssh->v2_session_id_len;
9359                     if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)
9360                         s->siglen -= 4;
9361                     s->len = 1;       /* message type */
9362                     s->len += 4 + s->pklen;     /* key blob */
9363                     s->len += 4 + s->siglen;    /* data to sign */
9364                     s->len += 4;      /* flags */
9365                     s->agentreq = snewn(4 + s->len, char);
9366                     PUT_32BIT(s->agentreq, s->len);
9367                     s->q = s->agentreq + 4;
9368                     *s->q++ = SSH2_AGENTC_SIGN_REQUEST;
9369                     PUT_32BIT(s->q, s->pklen);
9370                     s->q += 4;
9371                     memcpy(s->q, s->pkblob, s->pklen);
9372                     s->q += s->pklen;
9373                     PUT_32BIT(s->q, s->siglen);
9374                     s->q += 4;
9375                     /* Now the data to be signed... */
9376                     if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) {
9377                         PUT_32BIT(s->q, ssh->v2_session_id_len);
9378                         s->q += 4;
9379                     }
9380                     memcpy(s->q, ssh->v2_session_id,
9381                            ssh->v2_session_id_len);
9382                     s->q += ssh->v2_session_id_len;
9383                     memcpy(s->q, s->pktout->data + 5,
9384                            s->pktout->length - 5);
9385                     s->q += s->pktout->length - 5;
9386                     /* And finally the (zero) flags word. */
9387                     PUT_32BIT(s->q, 0);
9388                     if (!agent_query(s->agentreq, s->len + 4,
9389                                      &vret, &s->retlen,
9390                                      ssh_agent_callback, ssh)) {
9391                         do {
9392                             crReturnV;
9393                             if (pktin) {
9394                                 bombout(("Unexpected data from server"
9395                                          " while waiting for agent"
9396                                          " response"));
9397                                 crStopV;
9398                             }
9399                         } while (pktin || inlen > 0);
9400                         vret = ssh->agent_response;
9401                         s->retlen = ssh->agent_response_len;
9402                     }
9403                     s->ret = vret;
9404                     sfree(s->agentreq);
9405                     if (s->ret) {
9406                         if (s->retlen >= 9 &&
9407                             s->ret[4] == SSH2_AGENT_SIGN_RESPONSE &&
9408                             GET_32BIT(s->ret + 5) <= (unsigned)(s->retlen-9)) {
9409                             logevent("Sending Pageant's response");
9410                             ssh2_add_sigblob(ssh, s->pktout,
9411                                              s->pkblob, s->pklen,
9412                                              s->ret + 9,
9413                                              GET_32BIT(s->ret + 5));
9414                             ssh2_pkt_send(ssh, s->pktout);
9415                             s->type = AUTH_TYPE_PUBLICKEY;
9416                         } else {
9417                             /* FIXME: less drastic response */
9418                             bombout(("Pageant failed to answer challenge"));
9419                             crStopV;
9420                         }
9421                     }
9422                 }
9423
9424                 /* Do we have any keys left to try? */
9425                 if (s->pkblob_in_agent) {
9426                     s->done_agent = TRUE;
9427                     s->tried_pubkey_config = TRUE;
9428                 } else {
9429                     s->keyi++;
9430                     if (s->keyi >= s->nkeys)
9431                         s->done_agent = TRUE;
9432                 }
9433
9434             } else if (s->can_pubkey && s->publickey_blob &&
9435                        s->privatekey_available && !s->tried_pubkey_config) {
9436
9437                 struct ssh2_userkey *key;   /* not live over crReturn */
9438                 char *passphrase;           /* not live over crReturn */
9439
9440                 ssh->pkt_actx = SSH2_PKTCTX_PUBLICKEY;
9441
9442                 s->tried_pubkey_config = TRUE;
9443
9444                 /*
9445                  * Try the public key supplied in the configuration.
9446                  *
9447                  * First, offer the public blob to see if the server is
9448                  * willing to accept it.
9449                  */
9450                 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
9451                 ssh2_pkt_addstring(s->pktout, ssh->username);
9452                 ssh2_pkt_addstring(s->pktout, "ssh-connection");
9453                                                 /* service requested */
9454                 ssh2_pkt_addstring(s->pktout, "publickey");     /* method */
9455                 ssh2_pkt_addbool(s->pktout, FALSE);
9456                                                 /* no signature included */
9457                 ssh2_pkt_addstring(s->pktout, s->publickey_algorithm);
9458                 ssh2_pkt_addstring_start(s->pktout);
9459                 ssh2_pkt_addstring_data(s->pktout,
9460                                         (char *)s->publickey_blob,
9461                                         s->publickey_bloblen);
9462                 ssh2_pkt_send(ssh, s->pktout);
9463                 logevent("Offered public key");
9464
9465                 crWaitUntilV(pktin);
9466                 if (pktin->type != SSH2_MSG_USERAUTH_PK_OK) {
9467                     /* Key refused. Give up. */
9468                     s->gotit = TRUE; /* reconsider message next loop */
9469                     s->type = AUTH_TYPE_PUBLICKEY_OFFER_LOUD;
9470                     continue; /* process this new message */
9471                 }
9472                 logevent("Offer of public key accepted");
9473
9474                 /*
9475                  * Actually attempt a serious authentication using
9476                  * the key.
9477                  */
9478                 if (flags & FLAG_VERBOSE) {
9479                     c_write_str(ssh, "Authenticating with public key \"");
9480                     c_write_str(ssh, s->publickey_comment);
9481                     c_write_str(ssh, "\"\r\n");
9482                 }
9483                 key = NULL;
9484                 while (!key) {
9485                     const char *error;  /* not live over crReturn */
9486                     if (s->privatekey_encrypted) {
9487                         /*
9488                          * Get a passphrase from the user.
9489                          */
9490                         int ret; /* need not be kept over crReturn */
9491                         s->cur_prompt = new_prompts(ssh->frontend);
9492                         s->cur_prompt->to_server = FALSE;
9493                         s->cur_prompt->name = dupstr("SSH key passphrase");
9494                         add_prompt(s->cur_prompt,
9495                                    dupprintf("Passphrase for key \"%.100s\": ",
9496                                              s->publickey_comment),
9497                                    FALSE);
9498                         ret = get_userpass_input(s->cur_prompt, NULL, 0);
9499                         while (ret < 0) {
9500                             ssh->send_ok = 1;
9501                             crWaitUntilV(!pktin);
9502                             ret = get_userpass_input(s->cur_prompt,
9503                                                      in, inlen);
9504                             ssh->send_ok = 0;
9505                         }
9506                         if (!ret) {
9507                             /* Failed to get a passphrase. Terminate. */
9508                             free_prompts(s->cur_prompt);
9509                             ssh_disconnect(ssh, NULL,
9510                                            "Unable to authenticate",
9511                                            SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
9512                                            TRUE);
9513                             crStopV;
9514                         }
9515                         passphrase =
9516                             dupstr(s->cur_prompt->prompts[0]->result);
9517                         free_prompts(s->cur_prompt);
9518                     } else {
9519                         passphrase = NULL; /* no passphrase needed */
9520                     }
9521
9522                     /*
9523                      * Try decrypting the key.
9524                      */
9525                     s->keyfile = conf_get_filename(ssh->conf, CONF_keyfile);
9526                     key = ssh2_load_userkey(s->keyfile, passphrase, &error);
9527                     if (passphrase) {
9528                         /* burn the evidence */
9529                         smemclr(passphrase, strlen(passphrase));
9530                         sfree(passphrase);
9531                     }
9532                     if (key == SSH2_WRONG_PASSPHRASE || key == NULL) {
9533                         if (passphrase &&
9534                             (key == SSH2_WRONG_PASSPHRASE)) {
9535                             c_write_str(ssh, "Wrong passphrase\r\n");
9536                             key = NULL;
9537                             /* and loop again */
9538                         } else {
9539                             c_write_str(ssh, "Unable to load private key (");
9540                             c_write_str(ssh, error);
9541                             c_write_str(ssh, ")\r\n");
9542                             key = NULL;
9543                             break; /* try something else */
9544                         }
9545                     }
9546                 }
9547
9548                 if (key) {
9549                     unsigned char *pkblob, *sigblob, *sigdata;
9550                     int pkblob_len, sigblob_len, sigdata_len;
9551                     int p;
9552
9553                     /*
9554                      * We have loaded the private key and the server
9555                      * has announced that it's willing to accept it.
9556                      * Hallelujah. Generate a signature and send it.
9557                      */
9558                     s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
9559                     ssh2_pkt_addstring(s->pktout, ssh->username);
9560                     ssh2_pkt_addstring(s->pktout, "ssh-connection");
9561                                                     /* service requested */
9562                     ssh2_pkt_addstring(s->pktout, "publickey");
9563                                                     /* method */
9564                     ssh2_pkt_addbool(s->pktout, TRUE);
9565                                                     /* signature follows */
9566                     ssh2_pkt_addstring(s->pktout, key->alg->name);
9567                     pkblob = key->alg->public_blob(key->data,
9568                                                    &pkblob_len);
9569                     ssh2_pkt_addstring_start(s->pktout);
9570                     ssh2_pkt_addstring_data(s->pktout, (char *)pkblob,
9571                                             pkblob_len);
9572
9573                     /*
9574                      * The data to be signed is:
9575                      *
9576                      *   string  session-id
9577                      *
9578                      * followed by everything so far placed in the
9579                      * outgoing packet.
9580                      */
9581                     sigdata_len = s->pktout->length - 5 + 4 +
9582                         ssh->v2_session_id_len;
9583                     if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)
9584                         sigdata_len -= 4;
9585                     sigdata = snewn(sigdata_len, unsigned char);
9586                     p = 0;
9587                     if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) {
9588                         PUT_32BIT(sigdata+p, ssh->v2_session_id_len);
9589                         p += 4;
9590                     }
9591                     memcpy(sigdata+p, ssh->v2_session_id,
9592                            ssh->v2_session_id_len);
9593                     p += ssh->v2_session_id_len;
9594                     memcpy(sigdata+p, s->pktout->data + 5,
9595                            s->pktout->length - 5);
9596                     p += s->pktout->length - 5;
9597                     assert(p == sigdata_len);
9598                     sigblob = key->alg->sign(key->data, (char *)sigdata,
9599                                              sigdata_len, &sigblob_len);
9600                     ssh2_add_sigblob(ssh, s->pktout, pkblob, pkblob_len,
9601                                      sigblob, sigblob_len);
9602                     sfree(pkblob);
9603                     sfree(sigblob);
9604                     sfree(sigdata);
9605
9606                     ssh2_pkt_send(ssh, s->pktout);
9607                     logevent("Sent public key signature");
9608                     s->type = AUTH_TYPE_PUBLICKEY;
9609                     key->alg->freekey(key->data);
9610                     sfree(key->comment);
9611                     sfree(key);
9612                 }
9613
9614 #ifndef NO_GSSAPI
9615             } else if (s->can_gssapi && !s->tried_gssapi) {
9616
9617                 /* GSSAPI Authentication */
9618
9619                 int micoffset, len;
9620                 char *data;
9621                 Ssh_gss_buf mic;
9622                 s->type = AUTH_TYPE_GSSAPI;
9623                 s->tried_gssapi = TRUE;
9624                 s->gotit = TRUE;
9625                 ssh->pkt_actx = SSH2_PKTCTX_GSSAPI;
9626
9627                 /*
9628                  * Pick the highest GSS library on the preference
9629                  * list.
9630                  */
9631                 {
9632                     int i, j;
9633                     s->gsslib = NULL;
9634                     for (i = 0; i < ngsslibs; i++) {
9635                         int want_id = conf_get_int_int(ssh->conf,
9636                                                        CONF_ssh_gsslist, i);
9637                         for (j = 0; j < ssh->gsslibs->nlibraries; j++)
9638                             if (ssh->gsslibs->libraries[j].id == want_id) {
9639                                 s->gsslib = &ssh->gsslibs->libraries[j];
9640                                 goto got_gsslib;   /* double break */
9641                             }
9642                     }
9643                     got_gsslib:
9644                     /*
9645                      * We always expect to have found something in
9646                      * the above loop: we only came here if there
9647                      * was at least one viable GSS library, and the
9648                      * preference list should always mention
9649                      * everything and only change the order.
9650                      */
9651                     assert(s->gsslib);
9652                 }
9653
9654                 if (s->gsslib->gsslogmsg)
9655                     logevent(s->gsslib->gsslogmsg);
9656
9657                 /* Sending USERAUTH_REQUEST with "gssapi-with-mic" method */
9658                 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
9659                 ssh2_pkt_addstring(s->pktout, ssh->username);
9660                 ssh2_pkt_addstring(s->pktout, "ssh-connection");
9661                 ssh2_pkt_addstring(s->pktout, "gssapi-with-mic");
9662                 logevent("Attempting GSSAPI authentication");
9663
9664                 /* add mechanism info */
9665                 s->gsslib->indicate_mech(s->gsslib, &s->gss_buf);
9666
9667                 /* number of GSSAPI mechanisms */
9668                 ssh2_pkt_adduint32(s->pktout,1);
9669
9670                 /* length of OID + 2 */
9671                 ssh2_pkt_adduint32(s->pktout, s->gss_buf.length + 2);
9672                 ssh2_pkt_addbyte(s->pktout, SSH2_GSS_OIDTYPE);
9673
9674                 /* length of OID */
9675                 ssh2_pkt_addbyte(s->pktout, (unsigned char) s->gss_buf.length);
9676
9677                 ssh_pkt_adddata(s->pktout, s->gss_buf.value,
9678                                 s->gss_buf.length);
9679                 ssh2_pkt_send(ssh, s->pktout);
9680                 crWaitUntilV(pktin);
9681                 if (pktin->type != SSH2_MSG_USERAUTH_GSSAPI_RESPONSE) {
9682                     logevent("GSSAPI authentication request refused");
9683                     continue;
9684                 }
9685
9686                 /* check returned packet ... */
9687
9688                 ssh_pkt_getstring(pktin, &data, &len);
9689                 s->gss_rcvtok.value = data;
9690                 s->gss_rcvtok.length = len;
9691                 if (s->gss_rcvtok.length != s->gss_buf.length + 2 ||
9692                     ((char *)s->gss_rcvtok.value)[0] != SSH2_GSS_OIDTYPE ||
9693                     ((char *)s->gss_rcvtok.value)[1] != s->gss_buf.length ||
9694                     memcmp((char *)s->gss_rcvtok.value + 2,
9695                            s->gss_buf.value,s->gss_buf.length) ) {
9696                     logevent("GSSAPI authentication - wrong response from server");
9697                     continue;
9698                 }
9699
9700                 /* now start running */
9701                 s->gss_stat = s->gsslib->import_name(s->gsslib,
9702                                                      ssh->fullhostname,
9703                                                      &s->gss_srv_name);
9704                 if (s->gss_stat != SSH_GSS_OK) {
9705                     if (s->gss_stat == SSH_GSS_BAD_HOST_NAME)
9706                         logevent("GSSAPI import name failed - Bad service name");
9707                     else
9708                         logevent("GSSAPI import name failed");
9709                     continue;
9710                 }
9711
9712                 /* fetch TGT into GSS engine */
9713                 s->gss_stat = s->gsslib->acquire_cred(s->gsslib, &s->gss_ctx);
9714
9715                 if (s->gss_stat != SSH_GSS_OK) {
9716                     logevent("GSSAPI authentication failed to get credentials");
9717                     s->gsslib->release_name(s->gsslib, &s->gss_srv_name);
9718                     continue;
9719                 }
9720
9721                 /* initial tokens are empty */
9722                 SSH_GSS_CLEAR_BUF(&s->gss_rcvtok);
9723                 SSH_GSS_CLEAR_BUF(&s->gss_sndtok);
9724
9725                 /* now enter the loop */
9726                 do {
9727                     s->gss_stat = s->gsslib->init_sec_context
9728                         (s->gsslib,
9729                          &s->gss_ctx,
9730                          s->gss_srv_name,
9731                          conf_get_int(ssh->conf, CONF_gssapifwd),
9732                          &s->gss_rcvtok,
9733                          &s->gss_sndtok);
9734
9735                     if (s->gss_stat!=SSH_GSS_S_COMPLETE &&
9736                         s->gss_stat!=SSH_GSS_S_CONTINUE_NEEDED) {
9737                         logevent("GSSAPI authentication initialisation failed");
9738
9739                         if (s->gsslib->display_status(s->gsslib, s->gss_ctx,
9740                                                       &s->gss_buf) == SSH_GSS_OK) {
9741                             logevent(s->gss_buf.value);
9742                             sfree(s->gss_buf.value);
9743                         }
9744
9745                         break;
9746                     }
9747                     logevent("GSSAPI authentication initialised");
9748
9749                     /* Client and server now exchange tokens until GSSAPI
9750                      * no longer says CONTINUE_NEEDED */
9751
9752                     if (s->gss_sndtok.length != 0) {
9753                         s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);
9754                         ssh_pkt_addstring_start(s->pktout);
9755                         ssh_pkt_addstring_data(s->pktout,s->gss_sndtok.value,s->gss_sndtok.length);
9756                         ssh2_pkt_send(ssh, s->pktout);
9757                         s->gsslib->free_tok(s->gsslib, &s->gss_sndtok);
9758                     }
9759
9760                     if (s->gss_stat == SSH_GSS_S_CONTINUE_NEEDED) {
9761                         crWaitUntilV(pktin);
9762                         if (pktin->type != SSH2_MSG_USERAUTH_GSSAPI_TOKEN) {
9763                             logevent("GSSAPI authentication - bad server response");
9764                             s->gss_stat = SSH_GSS_FAILURE;
9765                             break;
9766                         }
9767                         ssh_pkt_getstring(pktin, &data, &len);
9768                         s->gss_rcvtok.value = data;
9769                         s->gss_rcvtok.length = len;
9770                     }
9771                 } while (s-> gss_stat == SSH_GSS_S_CONTINUE_NEEDED);
9772
9773                 if (s->gss_stat != SSH_GSS_OK) {
9774                     s->gsslib->release_name(s->gsslib, &s->gss_srv_name);
9775                     s->gsslib->release_cred(s->gsslib, &s->gss_ctx);
9776                     continue;
9777                 }
9778                 logevent("GSSAPI authentication loop finished OK");
9779
9780                 /* Now send the MIC */
9781
9782                 s->pktout = ssh2_pkt_init(0);
9783                 micoffset = s->pktout->length;
9784                 ssh_pkt_addstring_start(s->pktout);
9785                 ssh_pkt_addstring_data(s->pktout, (char *)ssh->v2_session_id, ssh->v2_session_id_len);
9786                 ssh_pkt_addbyte(s->pktout, SSH2_MSG_USERAUTH_REQUEST);
9787                 ssh_pkt_addstring(s->pktout, ssh->username);
9788                 ssh_pkt_addstring(s->pktout, "ssh-connection");
9789                 ssh_pkt_addstring(s->pktout, "gssapi-with-mic");
9790
9791                 s->gss_buf.value = (char *)s->pktout->data + micoffset;
9792                 s->gss_buf.length = s->pktout->length - micoffset;
9793
9794                 s->gsslib->get_mic(s->gsslib, s->gss_ctx, &s->gss_buf, &mic);
9795                 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_GSSAPI_MIC);
9796                 ssh_pkt_addstring_start(s->pktout);
9797                 ssh_pkt_addstring_data(s->pktout, mic.value, mic.length);
9798                 ssh2_pkt_send(ssh, s->pktout);
9799                 s->gsslib->free_mic(s->gsslib, &mic);
9800
9801                 s->gotit = FALSE;
9802
9803                 s->gsslib->release_name(s->gsslib, &s->gss_srv_name);
9804                 s->gsslib->release_cred(s->gsslib, &s->gss_ctx);
9805                 continue;
9806 #endif
9807             } else if (s->can_keyb_inter && !s->kbd_inter_refused) {
9808
9809                 /*
9810                  * Keyboard-interactive authentication.
9811                  */
9812
9813                 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
9814
9815                 ssh->pkt_actx = SSH2_PKTCTX_KBDINTER;
9816
9817                 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
9818                 ssh2_pkt_addstring(s->pktout, ssh->username);
9819                 ssh2_pkt_addstring(s->pktout, "ssh-connection");
9820                                                         /* service requested */
9821                 ssh2_pkt_addstring(s->pktout, "keyboard-interactive");
9822                                                         /* method */
9823                 ssh2_pkt_addstring(s->pktout, "");      /* lang */
9824                 ssh2_pkt_addstring(s->pktout, "");      /* submethods */
9825                 ssh2_pkt_send(ssh, s->pktout);
9826                 
9827                 logevent("Attempting keyboard-interactive authentication");
9828
9829                 crWaitUntilV(pktin);
9830                 if (pktin->type != SSH2_MSG_USERAUTH_INFO_REQUEST) {
9831                     /* Server is not willing to do keyboard-interactive
9832                      * at all (or, bizarrely but legally, accepts the
9833                      * user without actually issuing any prompts).
9834                      * Give up on it entirely. */
9835                     s->gotit = TRUE;
9836                     s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET;
9837                     s->kbd_inter_refused = TRUE; /* don't try it again */
9838                     continue;
9839                 }
9840
9841                 /*
9842                  * Loop while the server continues to send INFO_REQUESTs.
9843                  */
9844                 while (pktin->type == SSH2_MSG_USERAUTH_INFO_REQUEST) {
9845
9846                     char *name, *inst, *lang;
9847                     int name_len, inst_len, lang_len;
9848                     int i;
9849
9850                     /*
9851                      * We've got a fresh USERAUTH_INFO_REQUEST.
9852                      * Get the preamble and start building a prompt.
9853                      */
9854                     ssh_pkt_getstring(pktin, &name, &name_len);
9855                     ssh_pkt_getstring(pktin, &inst, &inst_len);
9856                     ssh_pkt_getstring(pktin, &lang, &lang_len);
9857                     s->cur_prompt = new_prompts(ssh->frontend);
9858                     s->cur_prompt->to_server = TRUE;
9859
9860                     /*
9861                      * Get any prompt(s) from the packet.
9862                      */
9863                     s->num_prompts = ssh_pkt_getuint32(pktin);
9864                     for (i = 0; i < s->num_prompts; i++) {
9865                         char *prompt;
9866                         int prompt_len;
9867                         int echo;
9868                         static char noprompt[] =
9869                             "<server failed to send prompt>: ";
9870
9871                         ssh_pkt_getstring(pktin, &prompt, &prompt_len);
9872                         echo = ssh2_pkt_getbool(pktin);
9873                         if (!prompt_len) {
9874                             prompt = noprompt;
9875                             prompt_len = lenof(noprompt)-1;
9876                         }
9877                         add_prompt(s->cur_prompt,
9878                                    dupprintf("%.*s", prompt_len, prompt),
9879                                    echo);
9880                     }
9881
9882                     if (name_len) {
9883                         /* FIXME: better prefix to distinguish from
9884                          * local prompts? */
9885                         s->cur_prompt->name =
9886                             dupprintf("SSH server: %.*s", name_len, name);
9887                         s->cur_prompt->name_reqd = TRUE;
9888                     } else {
9889                         s->cur_prompt->name =
9890                             dupstr("SSH server authentication");
9891                         s->cur_prompt->name_reqd = FALSE;
9892                     }
9893                     /* We add a prefix to try to make it clear that a prompt
9894                      * has come from the server.
9895                      * FIXME: ugly to print "Using..." in prompt _every_
9896                      * time round. Can this be done more subtly? */
9897                     /* Special case: for reasons best known to themselves,
9898                      * some servers send k-i requests with no prompts and
9899                      * nothing to display. Keep quiet in this case. */
9900                     if (s->num_prompts || name_len || inst_len) {
9901                         s->cur_prompt->instruction =
9902                             dupprintf("Using keyboard-interactive authentication.%s%.*s",
9903                                       inst_len ? "\n" : "", inst_len, inst);
9904                         s->cur_prompt->instr_reqd = TRUE;
9905                     } else {
9906                         s->cur_prompt->instr_reqd = FALSE;
9907                     }
9908
9909                     /*
9910                      * Display any instructions, and get the user's
9911                      * response(s).
9912                      */
9913                     {
9914                         int ret; /* not live over crReturn */
9915                         ret = get_userpass_input(s->cur_prompt, NULL, 0);
9916                         while (ret < 0) {
9917                             ssh->send_ok = 1;
9918                             crWaitUntilV(!pktin);
9919                             ret = get_userpass_input(s->cur_prompt, in, inlen);
9920                             ssh->send_ok = 0;
9921                         }
9922                         if (!ret) {
9923                             /*
9924                              * Failed to get responses. Terminate.
9925                              */
9926                             free_prompts(s->cur_prompt);
9927                             ssh_disconnect(ssh, NULL, "Unable to authenticate",
9928                                            SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
9929                                            TRUE);
9930                             crStopV;
9931                         }
9932                     }
9933
9934                     /*
9935                      * Send the response(s) to the server.
9936                      */
9937                     s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_INFO_RESPONSE);
9938                     ssh2_pkt_adduint32(s->pktout, s->num_prompts);
9939                     for (i=0; i < s->num_prompts; i++) {
9940                         ssh2_pkt_addstring(s->pktout,
9941                                            s->cur_prompt->prompts[i]->result);
9942                     }
9943                     ssh2_pkt_send_with_padding(ssh, s->pktout, 256);
9944
9945                     /*
9946                      * Free the prompts structure from this iteration.
9947                      * If there's another, a new one will be allocated
9948                      * when we return to the top of this while loop.
9949                      */
9950                     free_prompts(s->cur_prompt);
9951
9952                     /*
9953                      * Get the next packet in case it's another
9954                      * INFO_REQUEST.
9955                      */
9956                     crWaitUntilV(pktin);
9957
9958                 }
9959
9960                 /*
9961                  * We should have SUCCESS or FAILURE now.
9962                  */
9963                 s->gotit = TRUE;
9964
9965             } else if (s->can_passwd) {
9966
9967                 /*
9968                  * Plain old password authentication.
9969                  */
9970                 int ret; /* not live over crReturn */
9971                 int changereq_first_time; /* not live over crReturn */
9972
9973                 ssh->pkt_actx = SSH2_PKTCTX_PASSWORD;
9974
9975                 s->cur_prompt = new_prompts(ssh->frontend);
9976                 s->cur_prompt->to_server = TRUE;
9977                 s->cur_prompt->name = dupstr("SSH password");
9978                 add_prompt(s->cur_prompt, dupprintf("%s@%s's password: ",
9979                                                     ssh->username,
9980                                                     ssh->savedhost),
9981                            FALSE);
9982
9983                 ret = get_userpass_input(s->cur_prompt, NULL, 0);
9984                 while (ret < 0) {
9985                     ssh->send_ok = 1;
9986                     crWaitUntilV(!pktin);
9987                     ret = get_userpass_input(s->cur_prompt, in, inlen);
9988                     ssh->send_ok = 0;
9989                 }
9990                 if (!ret) {
9991                     /*
9992                      * Failed to get responses. Terminate.
9993                      */
9994                     free_prompts(s->cur_prompt);
9995                     ssh_disconnect(ssh, NULL, "Unable to authenticate",
9996                                    SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
9997                                    TRUE);
9998                     crStopV;
9999                 }
10000                 /*
10001                  * Squirrel away the password. (We may need it later if
10002                  * asked to change it.)
10003                  */
10004                 s->password = dupstr(s->cur_prompt->prompts[0]->result);
10005                 free_prompts(s->cur_prompt);
10006
10007                 /*
10008                  * Send the password packet.
10009                  *
10010                  * We pad out the password packet to 256 bytes to make
10011                  * it harder for an attacker to find the length of the
10012                  * user's password.
10013                  *
10014                  * Anyone using a password longer than 256 bytes
10015                  * probably doesn't have much to worry about from
10016                  * people who find out how long their password is!
10017                  */
10018                 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
10019                 ssh2_pkt_addstring(s->pktout, ssh->username);
10020                 ssh2_pkt_addstring(s->pktout, "ssh-connection");
10021                                                         /* service requested */
10022                 ssh2_pkt_addstring(s->pktout, "password");
10023                 ssh2_pkt_addbool(s->pktout, FALSE);
10024                 ssh2_pkt_addstring(s->pktout, s->password);
10025                 ssh2_pkt_send_with_padding(ssh, s->pktout, 256);
10026                 logevent("Sent password");
10027                 s->type = AUTH_TYPE_PASSWORD;
10028
10029                 /*
10030                  * Wait for next packet, in case it's a password change
10031                  * request.
10032                  */
10033                 crWaitUntilV(pktin);
10034                 changereq_first_time = TRUE;
10035
10036                 while (pktin->type == SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ) {
10037
10038                     /* 
10039                      * We're being asked for a new password
10040                      * (perhaps not for the first time).
10041                      * Loop until the server accepts it.
10042                      */
10043
10044                     int got_new = FALSE; /* not live over crReturn */
10045                     char *prompt;   /* not live over crReturn */
10046                     int prompt_len; /* not live over crReturn */
10047                     
10048                     {
10049                         const char *msg;
10050                         if (changereq_first_time)
10051                             msg = "Server requested password change";
10052                         else
10053                             msg = "Server rejected new password";
10054                         logevent(msg);
10055                         c_write_str(ssh, msg);
10056                         c_write_str(ssh, "\r\n");
10057                     }
10058
10059                     ssh_pkt_getstring(pktin, &prompt, &prompt_len);
10060
10061                     s->cur_prompt = new_prompts(ssh->frontend);
10062                     s->cur_prompt->to_server = TRUE;
10063                     s->cur_prompt->name = dupstr("New SSH password");
10064                     s->cur_prompt->instruction =
10065                         dupprintf("%.*s", prompt_len, prompt);
10066                     s->cur_prompt->instr_reqd = TRUE;
10067                     /*
10068                      * There's no explicit requirement in the protocol
10069                      * for the "old" passwords in the original and
10070                      * password-change messages to be the same, and
10071                      * apparently some Cisco kit supports password change
10072                      * by the user entering a blank password originally
10073                      * and the real password subsequently, so,
10074                      * reluctantly, we prompt for the old password again.
10075                      *
10076                      * (On the other hand, some servers don't even bother
10077                      * to check this field.)
10078                      */
10079                     add_prompt(s->cur_prompt,
10080                                dupstr("Current password (blank for previously entered password): "),
10081                                FALSE);
10082                     add_prompt(s->cur_prompt, dupstr("Enter new password: "),
10083                                FALSE);
10084                     add_prompt(s->cur_prompt, dupstr("Confirm new password: "),
10085                                FALSE);
10086
10087                     /*
10088                      * Loop until the user manages to enter the same
10089                      * password twice.
10090                      */
10091                     while (!got_new) {
10092
10093                         ret = get_userpass_input(s->cur_prompt, NULL, 0);
10094                         while (ret < 0) {
10095                             ssh->send_ok = 1;
10096                             crWaitUntilV(!pktin);
10097                             ret = get_userpass_input(s->cur_prompt, in, inlen);
10098                             ssh->send_ok = 0;
10099                         }
10100                         if (!ret) {
10101                             /*
10102                              * Failed to get responses. Terminate.
10103                              */
10104                             /* burn the evidence */
10105                             free_prompts(s->cur_prompt);
10106                             smemclr(s->password, strlen(s->password));
10107                             sfree(s->password);
10108                             ssh_disconnect(ssh, NULL, "Unable to authenticate",
10109                                            SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
10110                                            TRUE);
10111                             crStopV;
10112                         }
10113
10114                         /*
10115                          * If the user specified a new original password
10116                          * (IYSWIM), overwrite any previously specified
10117                          * one.
10118                          * (A side effect is that the user doesn't have to
10119                          * re-enter it if they louse up the new password.)
10120                          */
10121                         if (s->cur_prompt->prompts[0]->result[0]) {
10122                             smemclr(s->password, strlen(s->password));
10123                                 /* burn the evidence */
10124                             sfree(s->password);
10125                             s->password =
10126                                 dupstr(s->cur_prompt->prompts[0]->result);
10127                         }
10128
10129                         /*
10130                          * Check the two new passwords match.
10131                          */
10132                         got_new = (strcmp(s->cur_prompt->prompts[1]->result,
10133                                           s->cur_prompt->prompts[2]->result)
10134                                    == 0);
10135                         if (!got_new)
10136                             /* They don't. Silly user. */
10137                             c_write_str(ssh, "Passwords do not match\r\n");
10138
10139                     }
10140
10141                     /*
10142                      * Send the new password (along with the old one).
10143                      * (see above for padding rationale)
10144                      */
10145                     s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
10146                     ssh2_pkt_addstring(s->pktout, ssh->username);
10147                     ssh2_pkt_addstring(s->pktout, "ssh-connection");
10148                                                         /* service requested */
10149                     ssh2_pkt_addstring(s->pktout, "password");
10150                     ssh2_pkt_addbool(s->pktout, TRUE);
10151                     ssh2_pkt_addstring(s->pktout, s->password);
10152                     ssh2_pkt_addstring(s->pktout,
10153                                        s->cur_prompt->prompts[1]->result);
10154                     free_prompts(s->cur_prompt);
10155                     ssh2_pkt_send_with_padding(ssh, s->pktout, 256);
10156                     logevent("Sent new password");
10157                     
10158                     /*
10159                      * Now see what the server has to say about it.
10160                      * (If it's CHANGEREQ again, it's not happy with the
10161                      * new password.)
10162                      */
10163                     crWaitUntilV(pktin);
10164                     changereq_first_time = FALSE;
10165
10166                 }
10167
10168                 /*
10169                  * We need to reexamine the current pktin at the top
10170                  * of the loop. Either:
10171                  *  - we weren't asked to change password at all, in
10172                  *    which case it's a SUCCESS or FAILURE with the
10173                  *    usual meaning
10174                  *  - we sent a new password, and the server was
10175                  *    either OK with it (SUCCESS or FAILURE w/partial
10176                  *    success) or unhappy with the _old_ password
10177                  *    (FAILURE w/o partial success)
10178                  * In any of these cases, we go back to the top of
10179                  * the loop and start again.
10180                  */
10181                 s->gotit = TRUE;
10182
10183                 /*
10184                  * We don't need the old password any more, in any
10185                  * case. Burn the evidence.
10186                  */
10187                 smemclr(s->password, strlen(s->password));
10188                 sfree(s->password);
10189
10190             } else {
10191                 char *str = dupprintf("No supported authentication methods available"
10192                                       " (server sent: %.*s)",
10193                                       methlen, methods);
10194
10195                 ssh_disconnect(ssh, str,
10196                                "No supported authentication methods available",
10197                                SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
10198                                FALSE);
10199                 sfree(str);
10200
10201                 crStopV;
10202
10203             }
10204
10205         }
10206     }
10207     ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = NULL;
10208
10209     /* Clear up various bits and pieces from authentication. */
10210     if (s->publickey_blob) {
10211         sfree(s->publickey_algorithm);
10212         sfree(s->publickey_blob);
10213         sfree(s->publickey_comment);
10214     }
10215     if (s->agent_response)
10216         sfree(s->agent_response);
10217
10218     if (s->userauth_success && !ssh->bare_connection) {
10219         /*
10220          * We've just received USERAUTH_SUCCESS, and we haven't sent any
10221          * packets since. Signal the transport layer to consider enacting
10222          * delayed compression.
10223          *
10224          * (Relying on we_are_in is not sufficient, as
10225          * draft-miller-secsh-compression-delayed is quite clear that it
10226          * triggers on USERAUTH_SUCCESS specifically, and we_are_in can
10227          * become set for other reasons.)
10228          */
10229         do_ssh2_transport(ssh, "enabling delayed compression", -2, NULL);
10230     }
10231
10232     ssh->channels = newtree234(ssh_channelcmp);
10233
10234     /*
10235      * Set up handlers for some connection protocol messages, so we
10236      * don't have to handle them repeatedly in this coroutine.
10237      */
10238     ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] =
10239         ssh2_msg_channel_window_adjust;
10240     ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] =
10241         ssh2_msg_global_request;
10242
10243     /*
10244      * Create the main session channel.
10245      */
10246     if (conf_get_int(ssh->conf, CONF_ssh_no_shell)) {
10247         ssh->mainchan = NULL;
10248     } else {
10249         ssh->mainchan = snew(struct ssh_channel);
10250         ssh->mainchan->ssh = ssh;
10251         ssh2_channel_init(ssh->mainchan);
10252
10253         if (*conf_get_str(ssh->conf, CONF_ssh_nc_host)) {
10254             /*
10255              * Just start a direct-tcpip channel and use it as the main
10256              * channel.
10257              */
10258             ssh_send_port_open(ssh->mainchan,
10259                                conf_get_str(ssh->conf, CONF_ssh_nc_host),
10260                                conf_get_int(ssh->conf, CONF_ssh_nc_port),
10261                                "main channel");
10262             ssh->ncmode = TRUE;
10263         } else {
10264             s->pktout = ssh2_chanopen_init(ssh->mainchan, "session");
10265             logevent("Opening session as main channel");
10266             ssh2_pkt_send(ssh, s->pktout);
10267             ssh->ncmode = FALSE;
10268         }
10269         crWaitUntilV(pktin);
10270         if (pktin->type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
10271             bombout(("Server refused to open channel"));
10272             crStopV;
10273             /* FIXME: error data comes back in FAILURE packet */
10274         }
10275         if (ssh_pkt_getuint32(pktin) != ssh->mainchan->localid) {
10276             bombout(("Server's channel confirmation cited wrong channel"));
10277             crStopV;
10278         }
10279         ssh->mainchan->remoteid = ssh_pkt_getuint32(pktin);
10280         ssh->mainchan->halfopen = FALSE;
10281         ssh->mainchan->type = CHAN_MAINSESSION;
10282         ssh->mainchan->v.v2.remwindow = ssh_pkt_getuint32(pktin);
10283         ssh->mainchan->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
10284         add234(ssh->channels, ssh->mainchan);
10285         update_specials_menu(ssh->frontend);
10286         logevent("Opened main channel");
10287     }
10288
10289     /*
10290      * Now we have a channel, make dispatch table entries for
10291      * general channel-based messages.
10292      */
10293     ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] =
10294     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] =
10295         ssh2_msg_channel_data;
10296     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = ssh2_msg_channel_eof;
10297     ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = ssh2_msg_channel_close;
10298     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] =
10299         ssh2_msg_channel_open_confirmation;
10300     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] =
10301         ssh2_msg_channel_open_failure;
10302     ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] =
10303         ssh2_msg_channel_request;
10304     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] =
10305         ssh2_msg_channel_open;
10306     ssh->packet_dispatch[SSH2_MSG_CHANNEL_SUCCESS] = ssh2_msg_channel_response;
10307     ssh->packet_dispatch[SSH2_MSG_CHANNEL_FAILURE] = ssh2_msg_channel_response;
10308
10309     /*
10310      * Now the connection protocol is properly up and running, with
10311      * all those dispatch table entries, so it's safe to let
10312      * downstreams start trying to open extra channels through us.
10313      */
10314     if (ssh->connshare)
10315         share_activate(ssh->connshare, ssh->v_s);
10316
10317     if (ssh->mainchan && ssh_is_simple(ssh)) {
10318         /*
10319          * This message indicates to the server that we promise
10320          * not to try to run any other channel in parallel with
10321          * this one, so it's safe for it to advertise a very large
10322          * window and leave the flow control to TCP.
10323          */
10324         s->pktout = ssh2_chanreq_init(ssh->mainchan,
10325                                       "simple@putty.projects.tartarus.org",
10326                                       NULL, NULL);
10327         ssh2_pkt_send(ssh, s->pktout);
10328     }
10329
10330     /*
10331      * Enable port forwardings.
10332      */
10333     ssh_setup_portfwd(ssh, ssh->conf);
10334
10335     if (ssh->mainchan && !ssh->ncmode) {
10336         /*
10337          * Send the CHANNEL_REQUESTS for the main session channel.
10338          * Each one is handled by its own little asynchronous
10339          * co-routine.
10340          */
10341
10342         /* Potentially enable X11 forwarding. */
10343         if (conf_get_int(ssh->conf, CONF_x11_forward)) {
10344             ssh->x11disp =
10345                 x11_setup_display(conf_get_str(ssh->conf, CONF_x11_display),
10346                                   ssh->conf);
10347             if (!ssh->x11disp) {
10348                 /* FIXME: return an error message from x11_setup_display */
10349                 logevent("X11 forwarding not enabled: unable to"
10350                          " initialise X display");
10351             } else {
10352                 ssh->x11auth = x11_invent_fake_auth
10353                     (ssh->x11authtree, conf_get_int(ssh->conf, CONF_x11_auth));
10354                 ssh->x11auth->disp = ssh->x11disp;
10355
10356                 ssh2_setup_x11(ssh->mainchan, NULL, NULL);
10357             }
10358         }
10359
10360         /* Potentially enable agent forwarding. */
10361         if (ssh_agent_forwarding_permitted(ssh))
10362             ssh2_setup_agent(ssh->mainchan, NULL, NULL);
10363
10364         /* Now allocate a pty for the session. */
10365         if (!conf_get_int(ssh->conf, CONF_nopty))
10366             ssh2_setup_pty(ssh->mainchan, NULL, NULL);
10367
10368         /* Send environment variables. */
10369         ssh2_setup_env(ssh->mainchan, NULL, NULL);
10370
10371         /*
10372          * Start a shell or a remote command. We may have to attempt
10373          * this twice if the config data has provided a second choice
10374          * of command.
10375          */
10376         while (1) {
10377             int subsys;
10378             char *cmd;
10379
10380             if (ssh->fallback_cmd) {
10381                 subsys = conf_get_int(ssh->conf, CONF_ssh_subsys2);
10382                 cmd = conf_get_str(ssh->conf, CONF_remote_cmd2);
10383             } else {
10384                 subsys = conf_get_int(ssh->conf, CONF_ssh_subsys);
10385                 cmd = conf_get_str(ssh->conf, CONF_remote_cmd);
10386             }
10387
10388             if (subsys) {
10389                 s->pktout = ssh2_chanreq_init(ssh->mainchan, "subsystem",
10390                                               ssh2_response_authconn, NULL);
10391                 ssh2_pkt_addstring(s->pktout, cmd);
10392             } else if (*cmd) {
10393                 s->pktout = ssh2_chanreq_init(ssh->mainchan, "exec",
10394                                               ssh2_response_authconn, NULL);
10395                 ssh2_pkt_addstring(s->pktout, cmd);
10396             } else {
10397                 s->pktout = ssh2_chanreq_init(ssh->mainchan, "shell",
10398                                               ssh2_response_authconn, NULL);
10399             }
10400             ssh2_pkt_send(ssh, s->pktout);
10401
10402             crWaitUntilV(pktin);
10403
10404             if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
10405                 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
10406                     bombout(("Unexpected response to shell/command request:"
10407                              " packet type %d", pktin->type));
10408                     crStopV;
10409                 }
10410                 /*
10411                  * We failed to start the command. If this is the
10412                  * fallback command, we really are finished; if it's
10413                  * not, and if the fallback command exists, try falling
10414                  * back to it before complaining.
10415                  */
10416                 if (!ssh->fallback_cmd &&
10417                     *conf_get_str(ssh->conf, CONF_remote_cmd2)) {
10418                     logevent("Primary command failed; attempting fallback");
10419                     ssh->fallback_cmd = TRUE;
10420                     continue;
10421                 }
10422                 bombout(("Server refused to start a shell/command"));
10423                 crStopV;
10424             } else {
10425                 logevent("Started a shell/command");
10426             }
10427             break;
10428         }
10429     } else {
10430         ssh->editing = ssh->echoing = TRUE;
10431     }
10432
10433     ssh->state = SSH_STATE_SESSION;
10434     if (ssh->size_needed)
10435         ssh_size(ssh, ssh->term_width, ssh->term_height);
10436     if (ssh->eof_needed)
10437         ssh_special(ssh, TS_EOF);
10438
10439     /*
10440      * Transfer data!
10441      */
10442     if (ssh->ldisc)
10443         ldisc_echoedit_update(ssh->ldisc);  /* cause ldisc to notice changes */
10444     if (ssh->mainchan)
10445         ssh->send_ok = 1;
10446     while (1) {
10447         crReturnV;
10448         s->try_send = FALSE;
10449         if (pktin) {
10450
10451             /*
10452              * _All_ the connection-layer packets we expect to
10453              * receive are now handled by the dispatch table.
10454              * Anything that reaches here must be bogus.
10455              */
10456
10457             bombout(("Strange packet received: type %d", pktin->type));
10458             crStopV;
10459         } else if (ssh->mainchan) {
10460             /*
10461              * We have spare data. Add it to the channel buffer.
10462              */
10463             ssh2_add_channel_data(ssh->mainchan, (char *)in, inlen);
10464             s->try_send = TRUE;
10465         }
10466         if (s->try_send) {
10467             int i;
10468             struct ssh_channel *c;
10469             /*
10470              * Try to send data on all channels if we can.
10471              */
10472             for (i = 0; NULL != (c = index234(ssh->channels, i)); i++)
10473                 ssh2_try_send_and_unthrottle(ssh, c);
10474         }
10475     }
10476
10477     crFinishV;
10478 }
10479
10480 /*
10481  * Handlers for SSH-2 messages that might arrive at any moment.
10482  */
10483 static void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin)
10484 {
10485     /* log reason code in disconnect message */
10486     char *buf, *msg;
10487     int reason, msglen;
10488
10489     reason = ssh_pkt_getuint32(pktin);
10490     ssh_pkt_getstring(pktin, &msg, &msglen);
10491
10492     if (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) {
10493         buf = dupprintf("Received disconnect message (%s)",
10494                         ssh2_disconnect_reasons[reason]);
10495     } else {
10496         buf = dupprintf("Received disconnect message (unknown"
10497                         " type %d)", reason);
10498     }
10499     logevent(buf);
10500     sfree(buf);
10501     buf = dupprintf("Disconnection message text: %.*s",
10502                     msglen, msg);
10503     logevent(buf);
10504     bombout(("Server sent disconnect message\ntype %d (%s):\n\"%.*s\"",
10505              reason,
10506              (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) ?
10507              ssh2_disconnect_reasons[reason] : "unknown",
10508              msglen, msg));
10509     sfree(buf);
10510 }
10511
10512 static void ssh2_msg_debug(Ssh ssh, struct Packet *pktin)
10513 {
10514     /* log the debug message */
10515     char *msg;
10516     int msglen;
10517
10518     /* XXX maybe we should actually take notice of the return value */
10519     ssh2_pkt_getbool(pktin);
10520     ssh_pkt_getstring(pktin, &msg, &msglen);
10521
10522     logeventf(ssh, "Remote debug message: %.*s", msglen, msg);
10523 }
10524
10525 static void ssh2_msg_transport(Ssh ssh, struct Packet *pktin)
10526 {
10527     do_ssh2_transport(ssh, NULL, 0, pktin);
10528 }
10529
10530 /*
10531  * Called if we receive a packet that isn't allowed by the protocol.
10532  * This only applies to packets whose meaning PuTTY understands.
10533  * Entirely unknown packets are handled below.
10534  */
10535 static void ssh2_msg_unexpected(Ssh ssh, struct Packet *pktin)
10536 {
10537     char *buf = dupprintf("Server protocol violation: unexpected %s packet",
10538                           ssh2_pkt_type(ssh->pkt_kctx, ssh->pkt_actx,
10539                                         pktin->type));
10540     ssh_disconnect(ssh, NULL, buf, SSH2_DISCONNECT_PROTOCOL_ERROR, FALSE);
10541     sfree(buf);
10542 }
10543
10544 static void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin)
10545 {
10546     struct Packet *pktout;
10547     pktout = ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED);
10548     ssh2_pkt_adduint32(pktout, pktin->sequence);
10549     /*
10550      * UNIMPLEMENTED messages MUST appear in the same order as the
10551      * messages they respond to. Hence, never queue them.
10552      */
10553     ssh2_pkt_send_noqueue(ssh, pktout);
10554 }
10555
10556 /*
10557  * Handle the top-level SSH-2 protocol.
10558  */
10559 static void ssh2_protocol_setup(Ssh ssh)
10560 {
10561     int i;
10562
10563     /*
10564      * Most messages cause SSH2_MSG_UNIMPLEMENTED.
10565      */
10566     for (i = 0; i < 256; i++)
10567         ssh->packet_dispatch[i] = ssh2_msg_something_unimplemented;
10568
10569     /*
10570      * Initially, we only accept transport messages (and a few generic
10571      * ones).  do_ssh2_authconn will add more when it starts.
10572      * Messages that are understood but not currently acceptable go to
10573      * ssh2_msg_unexpected.
10574      */
10575     ssh->packet_dispatch[SSH2_MSG_UNIMPLEMENTED] = ssh2_msg_unexpected;
10576     ssh->packet_dispatch[SSH2_MSG_SERVICE_REQUEST] = ssh2_msg_unexpected;
10577     ssh->packet_dispatch[SSH2_MSG_SERVICE_ACCEPT] = ssh2_msg_unexpected;
10578     ssh->packet_dispatch[SSH2_MSG_KEXINIT] = ssh2_msg_transport;
10579     ssh->packet_dispatch[SSH2_MSG_NEWKEYS] = ssh2_msg_transport;
10580     ssh->packet_dispatch[SSH2_MSG_KEXDH_INIT] = ssh2_msg_transport;
10581     ssh->packet_dispatch[SSH2_MSG_KEXDH_REPLY] = ssh2_msg_transport;
10582     /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REQUEST] = ssh2_msg_transport; duplicate case value */
10583     /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_GROUP] = ssh2_msg_transport; duplicate case value */
10584     ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_INIT] = ssh2_msg_transport;
10585     ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REPLY] = ssh2_msg_transport;
10586     ssh->packet_dispatch[SSH2_MSG_USERAUTH_REQUEST] = ssh2_msg_unexpected;
10587     ssh->packet_dispatch[SSH2_MSG_USERAUTH_FAILURE] = ssh2_msg_unexpected;
10588     ssh->packet_dispatch[SSH2_MSG_USERAUTH_SUCCESS] = ssh2_msg_unexpected;
10589     ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = ssh2_msg_unexpected;
10590     ssh->packet_dispatch[SSH2_MSG_USERAUTH_PK_OK] = ssh2_msg_unexpected;
10591     /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ] = ssh2_msg_unexpected; duplicate case value */
10592     /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_REQUEST] = ssh2_msg_unexpected; duplicate case value */
10593     ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_RESPONSE] = ssh2_msg_unexpected;
10594     ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] = ssh2_msg_unexpected;
10595     ssh->packet_dispatch[SSH2_MSG_REQUEST_SUCCESS] = ssh2_msg_unexpected;
10596     ssh->packet_dispatch[SSH2_MSG_REQUEST_FAILURE] = ssh2_msg_unexpected;
10597     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] = ssh2_msg_unexpected;
10598     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] = ssh2_msg_unexpected;
10599     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] = ssh2_msg_unexpected;
10600     ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] = ssh2_msg_unexpected;
10601     ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] = ssh2_msg_unexpected;
10602     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] = ssh2_msg_unexpected;
10603     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = ssh2_msg_unexpected;
10604     ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = ssh2_msg_unexpected;
10605     ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] = ssh2_msg_unexpected;
10606     ssh->packet_dispatch[SSH2_MSG_CHANNEL_SUCCESS] = ssh2_msg_unexpected;
10607     ssh->packet_dispatch[SSH2_MSG_CHANNEL_FAILURE] = ssh2_msg_unexpected;
10608
10609     /*
10610      * These messages have a special handler from the start.
10611      */
10612     ssh->packet_dispatch[SSH2_MSG_DISCONNECT] = ssh2_msg_disconnect;
10613     ssh->packet_dispatch[SSH2_MSG_IGNORE] = ssh_msg_ignore; /* shared with SSH-1 */
10614     ssh->packet_dispatch[SSH2_MSG_DEBUG] = ssh2_msg_debug;
10615 }
10616
10617 static void ssh2_bare_connection_protocol_setup(Ssh ssh)
10618 {
10619     int i;
10620
10621     /*
10622      * Most messages cause SSH2_MSG_UNIMPLEMENTED.
10623      */
10624     for (i = 0; i < 256; i++)
10625         ssh->packet_dispatch[i] = ssh2_msg_something_unimplemented;
10626
10627     /*
10628      * Initially, we set all ssh-connection messages to 'unexpected';
10629      * do_ssh2_authconn will fill things in properly. We also handle a
10630      * couple of messages from the transport protocol which aren't
10631      * related to key exchange (UNIMPLEMENTED, IGNORE, DEBUG,
10632      * DISCONNECT).
10633      */
10634     ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] = ssh2_msg_unexpected;
10635     ssh->packet_dispatch[SSH2_MSG_REQUEST_SUCCESS] = ssh2_msg_unexpected;
10636     ssh->packet_dispatch[SSH2_MSG_REQUEST_FAILURE] = ssh2_msg_unexpected;
10637     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] = ssh2_msg_unexpected;
10638     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] = ssh2_msg_unexpected;
10639     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] = ssh2_msg_unexpected;
10640     ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] = ssh2_msg_unexpected;
10641     ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] = ssh2_msg_unexpected;
10642     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] = ssh2_msg_unexpected;
10643     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = ssh2_msg_unexpected;
10644     ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = ssh2_msg_unexpected;
10645     ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] = ssh2_msg_unexpected;
10646     ssh->packet_dispatch[SSH2_MSG_CHANNEL_SUCCESS] = ssh2_msg_unexpected;
10647     ssh->packet_dispatch[SSH2_MSG_CHANNEL_FAILURE] = ssh2_msg_unexpected;
10648
10649     ssh->packet_dispatch[SSH2_MSG_UNIMPLEMENTED] = ssh2_msg_unexpected;
10650
10651     /*
10652      * These messages have a special handler from the start.
10653      */
10654     ssh->packet_dispatch[SSH2_MSG_DISCONNECT] = ssh2_msg_disconnect;
10655     ssh->packet_dispatch[SSH2_MSG_IGNORE] = ssh_msg_ignore;
10656     ssh->packet_dispatch[SSH2_MSG_DEBUG] = ssh2_msg_debug;
10657 }
10658
10659 static void ssh2_timer(void *ctx, unsigned long now)
10660 {
10661     Ssh ssh = (Ssh)ctx;
10662
10663     if (ssh->state == SSH_STATE_CLOSED)
10664         return;
10665
10666     if (!ssh->kex_in_progress && !ssh->bare_connection &&
10667         conf_get_int(ssh->conf, CONF_ssh_rekey_time) != 0 &&
10668         now == ssh->next_rekey) {
10669         do_ssh2_transport(ssh, "timeout", -1, NULL);
10670     }
10671 }
10672
10673 static void ssh2_protocol(Ssh ssh, const void *vin, int inlen,
10674                           struct Packet *pktin)
10675 {
10676     const unsigned char *in = (const unsigned char *)vin;
10677     if (ssh->state == SSH_STATE_CLOSED)
10678         return;
10679
10680     if (pktin) {
10681         ssh->incoming_data_size += pktin->encrypted_len;
10682         if (!ssh->kex_in_progress &&
10683             ssh->max_data_size != 0 &&
10684             ssh->incoming_data_size > ssh->max_data_size)
10685             do_ssh2_transport(ssh, "too much data received", -1, NULL);
10686     }
10687
10688     if (pktin)
10689         ssh->packet_dispatch[pktin->type](ssh, pktin);
10690     else if (!ssh->protocol_initial_phase_done)
10691         do_ssh2_transport(ssh, in, inlen, pktin);
10692     else
10693         do_ssh2_authconn(ssh, in, inlen, pktin);
10694 }
10695
10696 static void ssh2_bare_connection_protocol(Ssh ssh, const void *vin, int inlen,
10697                                           struct Packet *pktin)
10698 {
10699     const unsigned char *in = (const unsigned char *)vin;
10700     if (ssh->state == SSH_STATE_CLOSED)
10701         return;
10702
10703     if (pktin)
10704         ssh->packet_dispatch[pktin->type](ssh, pktin);
10705     else
10706         do_ssh2_authconn(ssh, in, inlen, pktin);
10707 }
10708
10709 static void ssh_cache_conf_values(Ssh ssh)
10710 {
10711     ssh->logomitdata = conf_get_int(ssh->conf, CONF_logomitdata);
10712 }
10713
10714 /*
10715  * Called to set up the connection.
10716  *
10717  * Returns an error message, or NULL on success.
10718  */
10719 static const char *ssh_init(void *frontend_handle, void **backend_handle,
10720                             Conf *conf,
10721                             const char *host, int port, char **realhost,
10722                             int nodelay, int keepalive)
10723 {
10724     const char *p;
10725     Ssh ssh;
10726
10727     ssh = snew(struct ssh_tag);
10728     ssh->conf = conf_copy(conf);
10729     ssh_cache_conf_values(ssh);
10730     ssh->version = 0;                  /* when not ready yet */
10731     ssh->s = NULL;
10732     ssh->cipher = NULL;
10733     ssh->v1_cipher_ctx = NULL;
10734     ssh->crcda_ctx = NULL;
10735     ssh->cscipher = NULL;
10736     ssh->cs_cipher_ctx = NULL;
10737     ssh->sccipher = NULL;
10738     ssh->sc_cipher_ctx = NULL;
10739     ssh->csmac = NULL;
10740     ssh->cs_mac_ctx = NULL;
10741     ssh->scmac = NULL;
10742     ssh->sc_mac_ctx = NULL;
10743     ssh->cscomp = NULL;
10744     ssh->cs_comp_ctx = NULL;
10745     ssh->sccomp = NULL;
10746     ssh->sc_comp_ctx = NULL;
10747     ssh->kex = NULL;
10748     ssh->kex_ctx = NULL;
10749     ssh->hostkey = NULL;
10750     ssh->hostkey_str = NULL;
10751     ssh->exitcode = -1;
10752     ssh->close_expected = FALSE;
10753     ssh->clean_exit = FALSE;
10754     ssh->state = SSH_STATE_PREPACKET;
10755     ssh->size_needed = FALSE;
10756     ssh->eof_needed = FALSE;
10757     ssh->ldisc = NULL;
10758     ssh->logctx = NULL;
10759     ssh->deferred_send_data = NULL;
10760     ssh->deferred_len = 0;
10761     ssh->deferred_size = 0;
10762     ssh->fallback_cmd = 0;
10763     ssh->pkt_kctx = SSH2_PKTCTX_NOKEX;
10764     ssh->pkt_actx = SSH2_PKTCTX_NOAUTH;
10765     ssh->x11disp = NULL;
10766     ssh->x11auth = NULL;
10767     ssh->x11authtree = newtree234(x11_authcmp);
10768     ssh->v1_compressing = FALSE;
10769     ssh->v2_outgoing_sequence = 0;
10770     ssh->ssh1_rdpkt_crstate = 0;
10771     ssh->ssh2_rdpkt_crstate = 0;
10772     ssh->ssh2_bare_rdpkt_crstate = 0;
10773     ssh->ssh_gotdata_crstate = 0;
10774     ssh->do_ssh1_connection_crstate = 0;
10775     ssh->do_ssh_init_state = NULL;
10776     ssh->do_ssh_connection_init_state = NULL;
10777     ssh->do_ssh1_login_state = NULL;
10778     ssh->do_ssh2_transport_state = NULL;
10779     ssh->do_ssh2_authconn_state = NULL;
10780     ssh->v_c = NULL;
10781     ssh->v_s = NULL;
10782     ssh->mainchan = NULL;
10783     ssh->throttled_all = 0;
10784     ssh->v1_stdout_throttling = 0;
10785     ssh->queue = NULL;
10786     ssh->queuelen = ssh->queuesize = 0;
10787     ssh->queueing = FALSE;
10788     ssh->qhead = ssh->qtail = NULL;
10789     ssh->deferred_rekey_reason = NULL;
10790     bufchain_init(&ssh->queued_incoming_data);
10791     ssh->frozen = FALSE;
10792     ssh->username = NULL;
10793     ssh->sent_console_eof = FALSE;
10794     ssh->got_pty = FALSE;
10795     ssh->bare_connection = FALSE;
10796     ssh->X11_fwd_enabled = FALSE;
10797     ssh->connshare = NULL;
10798     ssh->attempting_connshare = FALSE;
10799
10800     *backend_handle = ssh;
10801
10802 #ifdef MSCRYPTOAPI
10803     if (crypto_startup() == 0)
10804         return "Microsoft high encryption pack not installed!";
10805 #endif
10806
10807     ssh->frontend = frontend_handle;
10808     ssh->term_width = conf_get_int(ssh->conf, CONF_width);
10809     ssh->term_height = conf_get_int(ssh->conf, CONF_height);
10810
10811     ssh->channels = NULL;
10812     ssh->rportfwds = NULL;
10813     ssh->portfwds = NULL;
10814
10815     ssh->send_ok = 0;
10816     ssh->editing = 0;
10817     ssh->echoing = 0;
10818     ssh->conn_throttle_count = 0;
10819     ssh->overall_bufsize = 0;
10820     ssh->fallback_cmd = 0;
10821
10822     ssh->protocol = NULL;
10823
10824     ssh->protocol_initial_phase_done = FALSE;
10825
10826     ssh->pinger = NULL;
10827
10828     ssh->incoming_data_size = ssh->outgoing_data_size =
10829         ssh->deferred_data_size = 0L;
10830     ssh->max_data_size = parse_blocksize(conf_get_str(ssh->conf,
10831                                                       CONF_ssh_rekey_data));
10832     ssh->kex_in_progress = FALSE;
10833
10834 #ifndef NO_GSSAPI
10835     ssh->gsslibs = NULL;
10836 #endif
10837
10838     random_ref(); /* do this now - may be needed by sharing setup code */
10839
10840     p = connect_to_host(ssh, host, port, realhost, nodelay, keepalive);
10841     if (p != NULL) {
10842         random_unref();
10843         return p;
10844     }
10845
10846     return NULL;
10847 }
10848
10849 static void ssh_free(void *handle)
10850 {
10851     Ssh ssh = (Ssh) handle;
10852     struct ssh_channel *c;
10853     struct ssh_rportfwd *pf;
10854     struct X11FakeAuth *auth;
10855
10856     if (ssh->v1_cipher_ctx)
10857         ssh->cipher->free_context(ssh->v1_cipher_ctx);
10858     if (ssh->cs_cipher_ctx)
10859         ssh->cscipher->free_context(ssh->cs_cipher_ctx);
10860     if (ssh->sc_cipher_ctx)
10861         ssh->sccipher->free_context(ssh->sc_cipher_ctx);
10862     if (ssh->cs_mac_ctx)
10863         ssh->csmac->free_context(ssh->cs_mac_ctx);
10864     if (ssh->sc_mac_ctx)
10865         ssh->scmac->free_context(ssh->sc_mac_ctx);
10866     if (ssh->cs_comp_ctx) {
10867         if (ssh->cscomp)
10868             ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
10869         else
10870             zlib_compress_cleanup(ssh->cs_comp_ctx);
10871     }
10872     if (ssh->sc_comp_ctx) {
10873         if (ssh->sccomp)
10874             ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
10875         else
10876             zlib_decompress_cleanup(ssh->sc_comp_ctx);
10877     }
10878     if (ssh->kex_ctx)
10879         dh_cleanup(ssh->kex_ctx);
10880     sfree(ssh->savedhost);
10881
10882     while (ssh->queuelen-- > 0)
10883         ssh_free_packet(ssh->queue[ssh->queuelen]);
10884     sfree(ssh->queue);
10885
10886     while (ssh->qhead) {
10887         struct queued_handler *qh = ssh->qhead;
10888         ssh->qhead = qh->next;
10889         sfree(qh);
10890     }
10891     ssh->qhead = ssh->qtail = NULL;
10892
10893     if (ssh->channels) {
10894         while ((c = delpos234(ssh->channels, 0)) != NULL) {
10895             switch (c->type) {
10896               case CHAN_X11:
10897                 if (c->u.x11.xconn != NULL)
10898                     x11_close(c->u.x11.xconn);
10899                 break;
10900               case CHAN_SOCKDATA:
10901               case CHAN_SOCKDATA_DORMANT:
10902                 if (c->u.pfd.pf != NULL)
10903                     pfd_close(c->u.pfd.pf);
10904                 break;
10905             }
10906             if (ssh->version == 2) {
10907                 struct outstanding_channel_request *ocr, *nocr;
10908                 ocr = c->v.v2.chanreq_head;
10909                 while (ocr) {
10910                     ocr->handler(c, NULL, ocr->ctx);
10911                     nocr = ocr->next;
10912                     sfree(ocr);
10913                     ocr = nocr;
10914                 }
10915                 bufchain_clear(&c->v.v2.outbuffer);
10916             }
10917             sfree(c);
10918         }
10919         freetree234(ssh->channels);
10920         ssh->channels = NULL;
10921     }
10922
10923     if (ssh->connshare)
10924         sharestate_free(ssh->connshare);
10925
10926     if (ssh->rportfwds) {
10927         while ((pf = delpos234(ssh->rportfwds, 0)) != NULL)
10928             free_rportfwd(pf);
10929         freetree234(ssh->rportfwds);
10930         ssh->rportfwds = NULL;
10931     }
10932     sfree(ssh->deferred_send_data);
10933     if (ssh->x11disp)
10934         x11_free_display(ssh->x11disp);
10935     while ((auth = delpos234(ssh->x11authtree, 0)) != NULL)
10936         x11_free_fake_auth(auth);
10937     freetree234(ssh->x11authtree);
10938     sfree(ssh->do_ssh_init_state);
10939     sfree(ssh->do_ssh1_login_state);
10940     sfree(ssh->do_ssh2_transport_state);
10941     sfree(ssh->do_ssh2_authconn_state);
10942     sfree(ssh->v_c);
10943     sfree(ssh->v_s);
10944     sfree(ssh->fullhostname);
10945     sfree(ssh->hostkey_str);
10946     if (ssh->crcda_ctx) {
10947         crcda_free_context(ssh->crcda_ctx);
10948         ssh->crcda_ctx = NULL;
10949     }
10950     if (ssh->s)
10951         ssh_do_close(ssh, TRUE);
10952     expire_timer_context(ssh);
10953     if (ssh->pinger)
10954         pinger_free(ssh->pinger);
10955     bufchain_clear(&ssh->queued_incoming_data);
10956     sfree(ssh->username);
10957     conf_free(ssh->conf);
10958 #ifndef NO_GSSAPI
10959     if (ssh->gsslibs)
10960         ssh_gss_cleanup(ssh->gsslibs);
10961 #endif
10962     sfree(ssh);
10963
10964     random_unref();
10965 }
10966
10967 /*
10968  * Reconfigure the SSH backend.
10969  */
10970 static void ssh_reconfig(void *handle, Conf *conf)
10971 {
10972     Ssh ssh = (Ssh) handle;
10973     const char *rekeying = NULL;
10974     int rekey_mandatory = FALSE;
10975     unsigned long old_max_data_size;
10976     int i, rekey_time;
10977
10978     pinger_reconfig(ssh->pinger, ssh->conf, conf);
10979     if (ssh->portfwds)
10980         ssh_setup_portfwd(ssh, conf);
10981
10982     rekey_time = conf_get_int(conf, CONF_ssh_rekey_time);
10983     if (conf_get_int(ssh->conf, CONF_ssh_rekey_time) != rekey_time &&
10984         rekey_time != 0) {
10985         unsigned long new_next = ssh->last_rekey + rekey_time*60*TICKSPERSEC;
10986         unsigned long now = GETTICKCOUNT();
10987
10988         if (now - ssh->last_rekey > rekey_time*60*TICKSPERSEC) {
10989             rekeying = "timeout shortened";
10990         } else {
10991             ssh->next_rekey = schedule_timer(new_next - now, ssh2_timer, ssh);
10992         }
10993     }
10994
10995     old_max_data_size = ssh->max_data_size;
10996     ssh->max_data_size = parse_blocksize(conf_get_str(ssh->conf,
10997                                                       CONF_ssh_rekey_data));
10998     if (old_max_data_size != ssh->max_data_size &&
10999         ssh->max_data_size != 0) {
11000         if (ssh->outgoing_data_size > ssh->max_data_size ||
11001             ssh->incoming_data_size > ssh->max_data_size)
11002             rekeying = "data limit lowered";
11003     }
11004
11005     if (conf_get_int(ssh->conf, CONF_compression) !=
11006         conf_get_int(conf, CONF_compression)) {
11007         rekeying = "compression setting changed";
11008         rekey_mandatory = TRUE;
11009     }
11010
11011     for (i = 0; i < CIPHER_MAX; i++)
11012         if (conf_get_int_int(ssh->conf, CONF_ssh_cipherlist, i) !=
11013             conf_get_int_int(conf, CONF_ssh_cipherlist, i)) {
11014         rekeying = "cipher settings changed";
11015         rekey_mandatory = TRUE;
11016     }
11017     if (conf_get_int(ssh->conf, CONF_ssh2_des_cbc) !=
11018         conf_get_int(conf, CONF_ssh2_des_cbc)) {
11019         rekeying = "cipher settings changed";
11020         rekey_mandatory = TRUE;
11021     }
11022
11023     conf_free(ssh->conf);
11024     ssh->conf = conf_copy(conf);
11025     ssh_cache_conf_values(ssh);
11026
11027     if (!ssh->bare_connection && rekeying) {
11028         if (!ssh->kex_in_progress) {
11029             do_ssh2_transport(ssh, rekeying, -1, NULL);
11030         } else if (rekey_mandatory) {
11031             ssh->deferred_rekey_reason = rekeying;
11032         }
11033     }
11034 }
11035
11036 /*
11037  * Called to send data down the SSH connection.
11038  */
11039 static int ssh_send(void *handle, const char *buf, int len)
11040 {
11041     Ssh ssh = (Ssh) handle;
11042
11043     if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
11044         return 0;
11045
11046     ssh->protocol(ssh, (const unsigned char *)buf, len, 0);
11047
11048     return ssh_sendbuffer(ssh);
11049 }
11050
11051 /*
11052  * Called to query the current amount of buffered stdin data.
11053  */
11054 static int ssh_sendbuffer(void *handle)
11055 {
11056     Ssh ssh = (Ssh) handle;
11057     int override_value;
11058
11059     if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
11060         return 0;
11061
11062     /*
11063      * If the SSH socket itself has backed up, add the total backup
11064      * size on that to any individual buffer on the stdin channel.
11065      */
11066     override_value = 0;
11067     if (ssh->throttled_all)
11068         override_value = ssh->overall_bufsize;
11069
11070     if (ssh->version == 1) {
11071         return override_value;
11072     } else if (ssh->version == 2) {
11073         if (!ssh->mainchan)
11074             return override_value;
11075         else
11076             return (override_value +
11077                     bufchain_size(&ssh->mainchan->v.v2.outbuffer));
11078     }
11079
11080     return 0;
11081 }
11082
11083 /*
11084  * Called to set the size of the window from SSH's POV.
11085  */
11086 static void ssh_size(void *handle, int width, int height)
11087 {
11088     Ssh ssh = (Ssh) handle;
11089     struct Packet *pktout;
11090
11091     ssh->term_width = width;
11092     ssh->term_height = height;
11093
11094     switch (ssh->state) {
11095       case SSH_STATE_BEFORE_SIZE:
11096       case SSH_STATE_PREPACKET:
11097       case SSH_STATE_CLOSED:
11098         break;                         /* do nothing */
11099       case SSH_STATE_INTERMED:
11100         ssh->size_needed = TRUE;       /* buffer for later */
11101         break;
11102       case SSH_STATE_SESSION:
11103         if (!conf_get_int(ssh->conf, CONF_nopty)) {
11104             if (ssh->version == 1) {
11105                 send_packet(ssh, SSH1_CMSG_WINDOW_SIZE,
11106                             PKT_INT, ssh->term_height,
11107                             PKT_INT, ssh->term_width,
11108                             PKT_INT, 0, PKT_INT, 0, PKT_END);
11109             } else if (ssh->mainchan) {
11110                 pktout = ssh2_chanreq_init(ssh->mainchan, "window-change",
11111                                            NULL, NULL);
11112                 ssh2_pkt_adduint32(pktout, ssh->term_width);
11113                 ssh2_pkt_adduint32(pktout, ssh->term_height);
11114                 ssh2_pkt_adduint32(pktout, 0);
11115                 ssh2_pkt_adduint32(pktout, 0);
11116                 ssh2_pkt_send(ssh, pktout);
11117             }
11118         }
11119         break;
11120     }
11121 }
11122
11123 /*
11124  * Return a list of the special codes that make sense in this
11125  * protocol.
11126  */
11127 static const struct telnet_special *ssh_get_specials(void *handle)
11128 {
11129     static const struct telnet_special ssh1_ignore_special[] = {
11130         {"IGNORE message", TS_NOP}
11131     };
11132     static const struct telnet_special ssh2_ignore_special[] = {
11133         {"IGNORE message", TS_NOP},
11134     };
11135     static const struct telnet_special ssh2_rekey_special[] = {
11136         {"Repeat key exchange", TS_REKEY},
11137     };
11138     static const struct telnet_special ssh2_session_specials[] = {
11139         {NULL, TS_SEP},
11140         {"Break", TS_BRK},
11141         /* These are the signal names defined by RFC 4254.
11142          * They include all the ISO C signals, but are a subset of the POSIX
11143          * required signals. */
11144         {"SIGINT (Interrupt)", TS_SIGINT},
11145         {"SIGTERM (Terminate)", TS_SIGTERM},
11146         {"SIGKILL (Kill)", TS_SIGKILL},
11147         {"SIGQUIT (Quit)", TS_SIGQUIT},
11148         {"SIGHUP (Hangup)", TS_SIGHUP},
11149         {"More signals", TS_SUBMENU},
11150           {"SIGABRT", TS_SIGABRT}, {"SIGALRM", TS_SIGALRM},
11151           {"SIGFPE",  TS_SIGFPE},  {"SIGILL",  TS_SIGILL},
11152           {"SIGPIPE", TS_SIGPIPE}, {"SIGSEGV", TS_SIGSEGV},
11153           {"SIGUSR1", TS_SIGUSR1}, {"SIGUSR2", TS_SIGUSR2},
11154         {NULL, TS_EXITMENU}
11155     };
11156     static const struct telnet_special specials_end[] = {
11157         {NULL, TS_EXITMENU}
11158     };
11159     /* XXX review this length for any changes: */
11160     static struct telnet_special ssh_specials[lenof(ssh2_ignore_special) +
11161                                               lenof(ssh2_rekey_special) +
11162                                               lenof(ssh2_session_specials) +
11163                                               lenof(specials_end)];
11164     Ssh ssh = (Ssh) handle;
11165     int i = 0;
11166 #define ADD_SPECIALS(name) \
11167     do { \
11168         assert((i + lenof(name)) <= lenof(ssh_specials)); \
11169         memcpy(&ssh_specials[i], name, sizeof name); \
11170         i += lenof(name); \
11171     } while(0)
11172
11173     if (ssh->version == 1) {
11174         /* Don't bother offering IGNORE if we've decided the remote
11175          * won't cope with it, since we wouldn't bother sending it if
11176          * asked anyway. */
11177         if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
11178             ADD_SPECIALS(ssh1_ignore_special);
11179     } else if (ssh->version == 2) {
11180         if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH2_IGNORE))
11181             ADD_SPECIALS(ssh2_ignore_special);
11182         if (!(ssh->remote_bugs & BUG_SSH2_REKEY) && !ssh->bare_connection)
11183             ADD_SPECIALS(ssh2_rekey_special);
11184         if (ssh->mainchan)
11185             ADD_SPECIALS(ssh2_session_specials);
11186     } /* else we're not ready yet */
11187
11188     if (i) {
11189         ADD_SPECIALS(specials_end);
11190         return ssh_specials;
11191     } else {
11192         return NULL;
11193     }
11194 #undef ADD_SPECIALS
11195 }
11196
11197 /*
11198  * Send special codes. TS_EOF is useful for `plink', so you
11199  * can send an EOF and collect resulting output (e.g. `plink
11200  * hostname sort').
11201  */
11202 static void ssh_special(void *handle, Telnet_Special code)
11203 {
11204     Ssh ssh = (Ssh) handle;
11205     struct Packet *pktout;
11206
11207     if (code == TS_EOF) {
11208         if (ssh->state != SSH_STATE_SESSION) {
11209             /*
11210              * Buffer the EOF in case we are pre-SESSION, so we can
11211              * send it as soon as we reach SESSION.
11212              */
11213             if (code == TS_EOF)
11214                 ssh->eof_needed = TRUE;
11215             return;
11216         }
11217         if (ssh->version == 1) {
11218             send_packet(ssh, SSH1_CMSG_EOF, PKT_END);
11219         } else if (ssh->mainchan) {
11220             sshfwd_write_eof(ssh->mainchan);
11221             ssh->send_ok = 0;          /* now stop trying to read from stdin */
11222         }
11223         logevent("Sent EOF message");
11224     } else if (code == TS_PING || code == TS_NOP) {
11225         if (ssh->state == SSH_STATE_CLOSED
11226             || ssh->state == SSH_STATE_PREPACKET) return;
11227         if (ssh->version == 1) {
11228             if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
11229                 send_packet(ssh, SSH1_MSG_IGNORE, PKT_STR, "", PKT_END);
11230         } else {
11231             if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH2_IGNORE)) {
11232                 pktout = ssh2_pkt_init(SSH2_MSG_IGNORE);
11233                 ssh2_pkt_addstring_start(pktout);
11234                 ssh2_pkt_send_noqueue(ssh, pktout);
11235             }
11236         }
11237     } else if (code == TS_REKEY) {
11238         if (!ssh->kex_in_progress && !ssh->bare_connection &&
11239             ssh->version == 2) {
11240             do_ssh2_transport(ssh, "at user request", -1, NULL);
11241         }
11242     } else if (code == TS_BRK) {
11243         if (ssh->state == SSH_STATE_CLOSED
11244             || ssh->state == SSH_STATE_PREPACKET) return;
11245         if (ssh->version == 1) {
11246             logevent("Unable to send BREAK signal in SSH-1");
11247         } else if (ssh->mainchan) {
11248             pktout = ssh2_chanreq_init(ssh->mainchan, "break", NULL, NULL);
11249             ssh2_pkt_adduint32(pktout, 0);   /* default break length */
11250             ssh2_pkt_send(ssh, pktout);
11251         }
11252     } else {
11253         /* Is is a POSIX signal? */
11254         const char *signame = NULL;
11255         if (code == TS_SIGABRT) signame = "ABRT";
11256         if (code == TS_SIGALRM) signame = "ALRM";
11257         if (code == TS_SIGFPE)  signame = "FPE";
11258         if (code == TS_SIGHUP)  signame = "HUP";
11259         if (code == TS_SIGILL)  signame = "ILL";
11260         if (code == TS_SIGINT)  signame = "INT";
11261         if (code == TS_SIGKILL) signame = "KILL";
11262         if (code == TS_SIGPIPE) signame = "PIPE";
11263         if (code == TS_SIGQUIT) signame = "QUIT";
11264         if (code == TS_SIGSEGV) signame = "SEGV";
11265         if (code == TS_SIGTERM) signame = "TERM";
11266         if (code == TS_SIGUSR1) signame = "USR1";
11267         if (code == TS_SIGUSR2) signame = "USR2";
11268         /* The SSH-2 protocol does in principle support arbitrary named
11269          * signals, including signame@domain, but we don't support those. */
11270         if (signame) {
11271             /* It's a signal. */
11272             if (ssh->version == 2 && ssh->mainchan) {
11273                 pktout = ssh2_chanreq_init(ssh->mainchan, "signal", NULL, NULL);
11274                 ssh2_pkt_addstring(pktout, signame);
11275                 ssh2_pkt_send(ssh, pktout);
11276                 logeventf(ssh, "Sent signal SIG%s", signame);
11277             }
11278         } else {
11279             /* Never heard of it. Do nothing */
11280         }
11281     }
11282 }
11283
11284 void *new_sock_channel(void *handle, struct PortForwarding *pf)
11285 {
11286     Ssh ssh = (Ssh) handle;
11287     struct ssh_channel *c;
11288     c = snew(struct ssh_channel);
11289
11290     c->ssh = ssh;
11291     ssh2_channel_init(c);
11292     c->halfopen = TRUE;
11293     c->type = CHAN_SOCKDATA_DORMANT;/* identify channel type */
11294     c->u.pfd.pf = pf;
11295     add234(ssh->channels, c);
11296     return c;
11297 }
11298
11299 unsigned ssh_alloc_sharing_channel(Ssh ssh, void *sharing_ctx)
11300 {
11301     struct ssh_channel *c;
11302     c = snew(struct ssh_channel);
11303
11304     c->ssh = ssh;
11305     ssh2_channel_init(c);
11306     c->type = CHAN_SHARING;
11307     c->u.sharing.ctx = sharing_ctx;
11308     add234(ssh->channels, c);
11309     return c->localid;
11310 }
11311
11312 void ssh_delete_sharing_channel(Ssh ssh, unsigned localid)
11313 {
11314     struct ssh_channel *c;
11315
11316     c = find234(ssh->channels, &localid, ssh_channelfind);
11317     if (c)
11318         ssh_channel_destroy(c);
11319 }
11320
11321 void ssh_send_packet_from_downstream(Ssh ssh, unsigned id, int type,
11322                                      const void *data, int datalen,
11323                                      const char *additional_log_text)
11324 {
11325     struct Packet *pkt;
11326
11327     pkt = ssh2_pkt_init(type);
11328     pkt->downstream_id = id;
11329     pkt->additional_log_text = additional_log_text;
11330     ssh2_pkt_adddata(pkt, data, datalen);
11331     ssh2_pkt_send(ssh, pkt);
11332 }
11333
11334 /*
11335  * This is called when stdout/stderr (the entity to which
11336  * from_backend sends data) manages to clear some backlog.
11337  */
11338 static void ssh_unthrottle(void *handle, int bufsize)
11339 {
11340     Ssh ssh = (Ssh) handle;
11341     int buflimit;
11342
11343     if (ssh->version == 1) {
11344         if (ssh->v1_stdout_throttling && bufsize < SSH1_BUFFER_LIMIT) {
11345             ssh->v1_stdout_throttling = 0;
11346             ssh_throttle_conn(ssh, -1);
11347         }
11348     } else {
11349         if (ssh->mainchan) {
11350             ssh2_set_window(ssh->mainchan,
11351                             bufsize < ssh->mainchan->v.v2.locmaxwin ?
11352                             ssh->mainchan->v.v2.locmaxwin - bufsize : 0);
11353             if (ssh_is_simple(ssh))
11354                 buflimit = 0;
11355             else
11356                 buflimit = ssh->mainchan->v.v2.locmaxwin;
11357             if (ssh->mainchan->throttling_conn && bufsize <= buflimit) {
11358                 ssh->mainchan->throttling_conn = 0;
11359                 ssh_throttle_conn(ssh, -1);
11360             }
11361         }
11362     }
11363
11364     /*
11365      * Now process any SSH connection data that was stashed in our
11366      * queue while we were frozen.
11367      */
11368     ssh_process_queued_incoming_data(ssh);
11369 }
11370
11371 void ssh_send_port_open(void *channel, const char *hostname, int port,
11372                         const char *org)
11373 {
11374     struct ssh_channel *c = (struct ssh_channel *)channel;
11375     Ssh ssh = c->ssh;
11376     struct Packet *pktout;
11377
11378     logeventf(ssh, "Opening connection to %s:%d for %s", hostname, port, org);
11379
11380     if (ssh->version == 1) {
11381         send_packet(ssh, SSH1_MSG_PORT_OPEN,
11382                     PKT_INT, c->localid,
11383                     PKT_STR, hostname,
11384                     PKT_INT, port,
11385                     /* PKT_STR, <org:orgport>, */
11386                     PKT_END);
11387     } else {
11388         pktout = ssh2_chanopen_init(c, "direct-tcpip");
11389         {
11390             char *trimmed_host = host_strduptrim(hostname);
11391             ssh2_pkt_addstring(pktout, trimmed_host);
11392             sfree(trimmed_host);
11393         }
11394         ssh2_pkt_adduint32(pktout, port);
11395         /*
11396          * We make up values for the originator data; partly it's
11397          * too much hassle to keep track, and partly I'm not
11398          * convinced the server should be told details like that
11399          * about my local network configuration.
11400          * The "originator IP address" is syntactically a numeric
11401          * IP address, and some servers (e.g., Tectia) get upset
11402          * if it doesn't match this syntax.
11403          */
11404         ssh2_pkt_addstring(pktout, "0.0.0.0");
11405         ssh2_pkt_adduint32(pktout, 0);
11406         ssh2_pkt_send(ssh, pktout);
11407     }
11408 }
11409
11410 static int ssh_connected(void *handle)
11411 {
11412     Ssh ssh = (Ssh) handle;
11413     return ssh->s != NULL;
11414 }
11415
11416 static int ssh_sendok(void *handle)
11417 {
11418     Ssh ssh = (Ssh) handle;
11419     return ssh->send_ok;
11420 }
11421
11422 static int ssh_ldisc(void *handle, int option)
11423 {
11424     Ssh ssh = (Ssh) handle;
11425     if (option == LD_ECHO)
11426         return ssh->echoing;
11427     if (option == LD_EDIT)
11428         return ssh->editing;
11429     return FALSE;
11430 }
11431
11432 static void ssh_provide_ldisc(void *handle, void *ldisc)
11433 {
11434     Ssh ssh = (Ssh) handle;
11435     ssh->ldisc = ldisc;
11436 }
11437
11438 static void ssh_provide_logctx(void *handle, void *logctx)
11439 {
11440     Ssh ssh = (Ssh) handle;
11441     ssh->logctx = logctx;
11442 }
11443
11444 static int ssh_return_exitcode(void *handle)
11445 {
11446     Ssh ssh = (Ssh) handle;
11447     if (ssh->s != NULL)
11448         return -1;
11449     else
11450         return (ssh->exitcode >= 0 ? ssh->exitcode : INT_MAX);
11451 }
11452
11453 /*
11454  * cfg_info for SSH is the protocol running in this session.
11455  * (1 or 2 for the full SSH-1 or SSH-2 protocol; -1 for the bare
11456  * SSH-2 connection protocol, i.e. a downstream; 0 for not-decided-yet.)
11457  */
11458 static int ssh_cfg_info(void *handle)
11459 {
11460     Ssh ssh = (Ssh) handle;
11461     if (ssh->version == 0)
11462         return 0; /* don't know yet */
11463     else if (ssh->bare_connection)
11464         return -1;
11465     else
11466         return ssh->version;
11467 }
11468
11469 /*
11470  * Gross hack: pscp will try to start SFTP but fall back to scp1 if
11471  * that fails. This variable is the means by which scp.c can reach
11472  * into the SSH code and find out which one it got.
11473  */
11474 extern int ssh_fallback_cmd(void *handle)
11475 {
11476     Ssh ssh = (Ssh) handle;
11477     return ssh->fallback_cmd;
11478 }
11479
11480 Backend ssh_backend = {
11481     ssh_init,
11482     ssh_free,
11483     ssh_reconfig,
11484     ssh_send,
11485     ssh_sendbuffer,
11486     ssh_size,
11487     ssh_special,
11488     ssh_get_specials,
11489     ssh_connected,
11490     ssh_return_exitcode,
11491     ssh_sendok,
11492     ssh_ldisc,
11493     ssh_provide_ldisc,
11494     ssh_provide_logctx,
11495     ssh_unthrottle,
11496     ssh_cfg_info,
11497     "ssh",
11498     PROT_SSH,
11499     22
11500 };