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