ssh.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdarg.h>
   4 #include <assert.h>
   5
   6 #include "putty.h"
   7 #include "tree234.h"
   8 #include "ssh.h"
   9
  10 #ifndef FALSE
  11 #define FALSE 0
  12 #endif
  13 #ifndef TRUE
  14 #define TRUE 1
  15 #endif
  16
  17 #define SSH1_MSG_DISCONNECT                       1     /* 0x1 */
  18 #define SSH1_SMSG_PUBLIC_KEY                      2     /* 0x2 */
  19 #define SSH1_CMSG_SESSION_KEY                     3     /* 0x3 */
  20 #define SSH1_CMSG_USER                            4     /* 0x4 */
  21 #define SSH1_CMSG_AUTH_RSA                        6     /* 0x6 */
  22 #define SSH1_SMSG_AUTH_RSA_CHALLENGE              7     /* 0x7 */
  23 #define SSH1_CMSG_AUTH_RSA_RESPONSE               8     /* 0x8 */
  24 #define SSH1_CMSG_AUTH_PASSWORD                   9     /* 0x9 */
  25 #define SSH1_CMSG_REQUEST_PTY                     10    /* 0xa */
  26 #define SSH1_CMSG_WINDOW_SIZE                     11    /* 0xb */
  27 #define SSH1_CMSG_EXEC_SHELL                      12    /* 0xc */
  28 #define SSH1_CMSG_EXEC_CMD                        13    /* 0xd */
  29 #define SSH1_SMSG_SUCCESS                         14    /* 0xe */
  30 #define SSH1_SMSG_FAILURE                         15    /* 0xf */
  31 #define SSH1_CMSG_STDIN_DATA                      16    /* 0x10 */
  32 #define SSH1_SMSG_STDOUT_DATA                     17    /* 0x11 */
  33 #define SSH1_SMSG_STDERR_DATA                     18    /* 0x12 */
  34 #define SSH1_CMSG_EOF                             19    /* 0x13 */
  35 #define SSH1_SMSG_EXIT_STATUS                     20    /* 0x14 */
  36 #define SSH1_MSG_CHANNEL_OPEN_CONFIRMATION        21    /* 0x15 */
  37 #define SSH1_MSG_CHANNEL_OPEN_FAILURE             22    /* 0x16 */
  38 #define SSH1_MSG_CHANNEL_DATA                     23    /* 0x17 */
  39 #define SSH1_MSG_CHANNEL_CLOSE                    24    /* 0x18 */
  40 #define SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION       25    /* 0x19 */
  41 #define SSH1_SMSG_X11_OPEN                        27    /* 0x1b */
  42 #define SSH1_CMSG_PORT_FORWARD_REQUEST            28    /* 0x1c */
  43 #define SSH1_MSG_PORT_OPEN                        29    /* 0x1d */
  44 #define SSH1_CMSG_AGENT_REQUEST_FORWARDING        30    /* 0x1e */
  45 #define SSH1_SMSG_AGENT_OPEN                      31    /* 0x1f */
  46 #define SSH1_MSG_IGNORE                           32    /* 0x20 */
  47 #define SSH1_CMSG_EXIT_CONFIRMATION               33    /* 0x21 */
  48 #define SSH1_CMSG_X11_REQUEST_FORWARDING          34    /* 0x22 */
  49 #define SSH1_CMSG_AUTH_RHOSTS_RSA                 35    /* 0x23 */
  50 #define SSH1_MSG_DEBUG                            36    /* 0x24 */
  51 #define SSH1_CMSG_REQUEST_COMPRESSION             37    /* 0x25 */
  52 #define SSH1_CMSG_AUTH_TIS                        39    /* 0x27 */
  53 #define SSH1_SMSG_AUTH_TIS_CHALLENGE              40    /* 0x28 */
  54 #define SSH1_CMSG_AUTH_TIS_RESPONSE               41    /* 0x29 */
  55 #define SSH1_CMSG_AUTH_CCARD                      70    /* 0x46 */
  56 #define SSH1_SMSG_AUTH_CCARD_CHALLENGE            71    /* 0x47 */
  57 #define SSH1_CMSG_AUTH_CCARD_RESPONSE             72    /* 0x48 */
  58
  59 #define SSH1_AUTH_TIS                             5     /* 0x5 */
  60 #define SSH1_AUTH_CCARD                           16    /* 0x10 */
  61
  62 #define SSH1_PROTOFLAG_SCREEN_NUMBER              1     /* 0x1 */
  63 /* Mask for protoflags we will echo back to server if seen */
  64 #define SSH1_PROTOFLAGS_SUPPORTED                 0     /* 0x1 */
  65
  66 #define SSH2_MSG_DISCONNECT                       1     /* 0x1 */
  67 #define SSH2_MSG_IGNORE                           2     /* 0x2 */
  68 #define SSH2_MSG_UNIMPLEMENTED                    3     /* 0x3 */
  69 #define SSH2_MSG_DEBUG                            4     /* 0x4 */
  70 #define SSH2_MSG_SERVICE_REQUEST                  5     /* 0x5 */
  71 #define SSH2_MSG_SERVICE_ACCEPT                   6     /* 0x6 */
  72 #define SSH2_MSG_KEXINIT                          20    /* 0x14 */
  73 #define SSH2_MSG_NEWKEYS                          21    /* 0x15 */
  74 #define SSH2_MSG_KEXDH_INIT                       30    /* 0x1e */
  75 #define SSH2_MSG_KEXDH_REPLY                      31    /* 0x1f */
  76 #define SSH2_MSG_KEX_DH_GEX_REQUEST               30    /* 0x1e */
  77 #define SSH2_MSG_KEX_DH_GEX_GROUP                 31    /* 0x1f */
  78 #define SSH2_MSG_KEX_DH_GEX_INIT                  32    /* 0x20 */
  79 #define SSH2_MSG_KEX_DH_GEX_REPLY                 33    /* 0x21 */
  80 #define SSH2_MSG_USERAUTH_REQUEST                 50    /* 0x32 */
  81 #define SSH2_MSG_USERAUTH_FAILURE                 51    /* 0x33 */
  82 #define SSH2_MSG_USERAUTH_SUCCESS                 52    /* 0x34 */
  83 #define SSH2_MSG_USERAUTH_BANNER                  53    /* 0x35 */
  84 #define SSH2_MSG_USERAUTH_PK_OK                   60    /* 0x3c */
  85 #define SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ        60    /* 0x3c */
  86 #define SSH2_MSG_USERAUTH_INFO_REQUEST            60    /* 0x3c */
  87 #define SSH2_MSG_USERAUTH_INFO_RESPONSE           61    /* 0x3d */
  88 #define SSH2_MSG_GLOBAL_REQUEST                   80    /* 0x50 */
  89 #define SSH2_MSG_REQUEST_SUCCESS                  81    /* 0x51 */
  90 #define SSH2_MSG_REQUEST_FAILURE                  82    /* 0x52 */
  91 #define SSH2_MSG_CHANNEL_OPEN                     90    /* 0x5a */
  92 #define SSH2_MSG_CHANNEL_OPEN_CONFIRMATION        91    /* 0x5b */
  93 #define SSH2_MSG_CHANNEL_OPEN_FAILURE             92    /* 0x5c */
  94 #define SSH2_MSG_CHANNEL_WINDOW_ADJUST            93    /* 0x5d */
  95 #define SSH2_MSG_CHANNEL_DATA                     94    /* 0x5e */
  96 #define SSH2_MSG_CHANNEL_EXTENDED_DATA            95    /* 0x5f */
  97 #define SSH2_MSG_CHANNEL_EOF                      96    /* 0x60 */
  98 #define SSH2_MSG_CHANNEL_CLOSE                    97    /* 0x61 */
  99 #define SSH2_MSG_CHANNEL_REQUEST                  98    /* 0x62 */
 100 #define SSH2_MSG_CHANNEL_SUCCESS                  99    /* 0x63 */
 101 #define SSH2_MSG_CHANNEL_FAILURE                  100   /* 0x64 */
 102
 103 /*
 104  * Packet type contexts, so that ssh2_pkt_type can correctly decode
 105  * the ambiguous type numbers back into the correct type strings.
 106  */
 107 #define SSH2_PKTCTX_DHGROUP1         0x0001
 108 #define SSH2_PKTCTX_DHGEX            0x0002
 109 #define SSH2_PKTCTX_PUBLICKEY        0x0010
 110 #define SSH2_PKTCTX_PASSWORD         0x0020
 111 #define SSH2_PKTCTX_KBDINTER         0x0040
 112 #define SSH2_PKTCTX_AUTH_MASK        0x00F0
 113
 114 #define SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1   /* 0x1 */
 115 #define SSH2_DISCONNECT_PROTOCOL_ERROR            2     /* 0x2 */
 116 #define SSH2_DISCONNECT_KEY_EXCHANGE_FAILED       3     /* 0x3 */
 117 #define SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED 4    /* 0x4 */
 118 #define SSH2_DISCONNECT_MAC_ERROR                 5     /* 0x5 */
 119 #define SSH2_DISCONNECT_COMPRESSION_ERROR         6     /* 0x6 */
 120 #define SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE     7     /* 0x7 */
 121 #define SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8        /* 0x8 */
 122 #define SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE   9     /* 0x9 */
 123 #define SSH2_DISCONNECT_CONNECTION_LOST           10    /* 0xa */
 124 #define SSH2_DISCONNECT_BY_APPLICATION            11    /* 0xb */
 125 #define SSH2_DISCONNECT_TOO_MANY_CONNECTIONS      12    /* 0xc */
 126 #define SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER    13    /* 0xd */
 127 #define SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE 14       /* 0xe */
 128 #define SSH2_DISCONNECT_ILLEGAL_USER_NAME         15    /* 0xf */
 129
 130 static const char *const ssh2_disconnect_reasons[] = {
 131     NULL,
 132     "SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT",
 133     "SSH_DISCONNECT_PROTOCOL_ERROR",
 134     "SSH_DISCONNECT_KEY_EXCHANGE_FAILED",
 135     "SSH_DISCONNECT_HOST_AUTHENTICATION_FAILED",
 136     "SSH_DISCONNECT_MAC_ERROR",
 137     "SSH_DISCONNECT_COMPRESSION_ERROR",
 138     "SSH_DISCONNECT_SERVICE_NOT_AVAILABLE",
 139     "SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED",
 140     "SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE",
 141     "SSH_DISCONNECT_CONNECTION_LOST",
 142     "SSH_DISCONNECT_BY_APPLICATION",
 143     "SSH_DISCONNECT_TOO_MANY_CONNECTIONS",
 144     "SSH_DISCONNECT_AUTH_CANCELLED_BY_USER",
 145     "SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE",
 146     "SSH_DISCONNECT_ILLEGAL_USER_NAME",
 147 };
 148
 149 #define SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED     1     /* 0x1 */
 150 #define SSH2_OPEN_CONNECT_FAILED                  2     /* 0x2 */
 151 #define SSH2_OPEN_UNKNOWN_CHANNEL_TYPE            3     /* 0x3 */
 152 #define SSH2_OPEN_RESOURCE_SHORTAGE               4     /* 0x4 */
 153
 154 #define SSH2_EXTENDED_DATA_STDERR                 1     /* 0x1 */
 155
 156 /*
 157  * Various remote-bug flags.
 158  */
 159 #define BUG_CHOKES_ON_SSH1_IGNORE                 1
 160 #define BUG_SSH2_HMAC                             2
 161 #define BUG_NEEDS_SSH1_PLAIN_PASSWORD             4
 162 #define BUG_CHOKES_ON_RSA                         8
 163 #define BUG_SSH2_RSA_PADDING                     16
 164 #define BUG_SSH2_DERIVEKEY                       32
 165 #define BUG_SSH2_DH_GEX                          64
 166
 167 #define translate(x) if (type == x) return #x
 168 #define translatec(x,ctx) if (type == x && (pkt_ctx & ctx)) return #x
 169 static char *ssh1_pkt_type(int type)
 170 {
 171     translate(SSH1_MSG_DISCONNECT);
 172     translate(SSH1_SMSG_PUBLIC_KEY);
 173     translate(SSH1_CMSG_SESSION_KEY);
 174     translate(SSH1_CMSG_USER);
 175     translate(SSH1_CMSG_AUTH_RSA);
 176     translate(SSH1_SMSG_AUTH_RSA_CHALLENGE);
 177     translate(SSH1_CMSG_AUTH_RSA_RESPONSE);
 178     translate(SSH1_CMSG_AUTH_PASSWORD);
 179     translate(SSH1_CMSG_REQUEST_PTY);
 180     translate(SSH1_CMSG_WINDOW_SIZE);
 181     translate(SSH1_CMSG_EXEC_SHELL);
 182     translate(SSH1_CMSG_EXEC_CMD);
 183     translate(SSH1_SMSG_SUCCESS);
 184     translate(SSH1_SMSG_FAILURE);
 185     translate(SSH1_CMSG_STDIN_DATA);
 186     translate(SSH1_SMSG_STDOUT_DATA);
 187     translate(SSH1_SMSG_STDERR_DATA);
 188     translate(SSH1_CMSG_EOF);
 189     translate(SSH1_SMSG_EXIT_STATUS);
 190     translate(SSH1_MSG_CHANNEL_OPEN_CONFIRMATION);
 191     translate(SSH1_MSG_CHANNEL_OPEN_FAILURE);
 192     translate(SSH1_MSG_CHANNEL_DATA);
 193     translate(SSH1_MSG_CHANNEL_CLOSE);
 194     translate(SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION);
 195     translate(SSH1_SMSG_X11_OPEN);
 196     translate(SSH1_CMSG_PORT_FORWARD_REQUEST);
 197     translate(SSH1_MSG_PORT_OPEN);
 198     translate(SSH1_CMSG_AGENT_REQUEST_FORWARDING);
 199     translate(SSH1_SMSG_AGENT_OPEN);
 200     translate(SSH1_MSG_IGNORE);
 201     translate(SSH1_CMSG_EXIT_CONFIRMATION);
 202     translate(SSH1_CMSG_X11_REQUEST_FORWARDING);
 203     translate(SSH1_CMSG_AUTH_RHOSTS_RSA);
 204     translate(SSH1_MSG_DEBUG);
 205     translate(SSH1_CMSG_REQUEST_COMPRESSION);
 206     translate(SSH1_CMSG_AUTH_TIS);
 207     translate(SSH1_SMSG_AUTH_TIS_CHALLENGE);
 208     translate(SSH1_CMSG_AUTH_TIS_RESPONSE);
 209     translate(SSH1_CMSG_AUTH_CCARD);
 210     translate(SSH1_SMSG_AUTH_CCARD_CHALLENGE);
 211     translate(SSH1_CMSG_AUTH_CCARD_RESPONSE);
 212     return "unknown";
 213 }
 214 static char *ssh2_pkt_type(int pkt_ctx, int type)
 215 {
 216     translate(SSH2_MSG_DISCONNECT);
 217     translate(SSH2_MSG_IGNORE);
 218     translate(SSH2_MSG_UNIMPLEMENTED);
 219     translate(SSH2_MSG_DEBUG);
 220     translate(SSH2_MSG_SERVICE_REQUEST);
 221     translate(SSH2_MSG_SERVICE_ACCEPT);
 222     translate(SSH2_MSG_KEXINIT);
 223     translate(SSH2_MSG_NEWKEYS);
 224     translatec(SSH2_MSG_KEXDH_INIT, SSH2_PKTCTX_DHGROUP1);
 225     translatec(SSH2_MSG_KEXDH_REPLY, SSH2_PKTCTX_DHGROUP1);
 226     translatec(SSH2_MSG_KEX_DH_GEX_REQUEST, SSH2_PKTCTX_DHGEX);
 227     translatec(SSH2_MSG_KEX_DH_GEX_GROUP, SSH2_PKTCTX_DHGEX);
 228     translatec(SSH2_MSG_KEX_DH_GEX_INIT, SSH2_PKTCTX_DHGEX);
 229     translatec(SSH2_MSG_KEX_DH_GEX_REPLY, SSH2_PKTCTX_DHGEX);
 230     translate(SSH2_MSG_USERAUTH_REQUEST);
 231     translate(SSH2_MSG_USERAUTH_FAILURE);
 232     translate(SSH2_MSG_USERAUTH_SUCCESS);
 233     translate(SSH2_MSG_USERAUTH_BANNER);
 234     translatec(SSH2_MSG_USERAUTH_PK_OK, SSH2_PKTCTX_PUBLICKEY);
 235     translatec(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ, SSH2_PKTCTX_PASSWORD);
 236     translatec(SSH2_MSG_USERAUTH_INFO_REQUEST, SSH2_PKTCTX_KBDINTER);
 237     translatec(SSH2_MSG_USERAUTH_INFO_RESPONSE, SSH2_PKTCTX_KBDINTER);
 238     translate(SSH2_MSG_GLOBAL_REQUEST);
 239     translate(SSH2_MSG_REQUEST_SUCCESS);
 240     translate(SSH2_MSG_REQUEST_FAILURE);
 241     translate(SSH2_MSG_CHANNEL_OPEN);
 242     translate(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
 243     translate(SSH2_MSG_CHANNEL_OPEN_FAILURE);
 244     translate(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
 245     translate(SSH2_MSG_CHANNEL_DATA);
 246     translate(SSH2_MSG_CHANNEL_EXTENDED_DATA);
 247     translate(SSH2_MSG_CHANNEL_EOF);
 248     translate(SSH2_MSG_CHANNEL_CLOSE);
 249     translate(SSH2_MSG_CHANNEL_REQUEST);
 250     translate(SSH2_MSG_CHANNEL_SUCCESS);
 251     translate(SSH2_MSG_CHANNEL_FAILURE);
 252     return "unknown";
 253 }
 254 #undef translate
 255 #undef translatec
 256
 257 #define GET_32BIT(cp) \
 258     (((unsigned long)(unsigned char)(cp)[0] << 24) | \
 259     ((unsigned long)(unsigned char)(cp)[1] << 16) | \
 260     ((unsigned long)(unsigned char)(cp)[2] << 8) | \
 261     ((unsigned long)(unsigned char)(cp)[3]))
 262
 263 #define PUT_32BIT(cp, value) { \
 264     (cp)[0] = (unsigned char)((value) >> 24); \
 265     (cp)[1] = (unsigned char)((value) >> 16); \
 266     (cp)[2] = (unsigned char)((value) >> 8); \
 267     (cp)[3] = (unsigned char)(value); }
 268
 269 enum { PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM };
 270
 271 /* Coroutine mechanics for the sillier bits of the code */
 272 #define crBegin(v)      { int *crLine = &v; switch(v) { case 0:;
 273 #define crState(t) \
 274     struct t *s; \
 275     if (!ssh->t) ssh->t = smalloc(sizeof(struct t)); \
 276     s = ssh->t;
 277 #define crFinish(z)     } *crLine = 0; return (z); }
 278 #define crFinishV       } *crLine = 0; return; }
 279 #define crReturn(z)     \
 280         do {\
 281             *crLine =__LINE__; return (z); case __LINE__:;\
 282         } while (0)
 283 #define crReturnV       \
 284         do {\
 285             *crLine=__LINE__; return; case __LINE__:;\
 286         } while (0)
 287 #define crStop(z)       do{ *crLine = 0; return (z); }while(0)
 288 #define crStopV         do{ *crLine = 0; return; }while(0)
 289 #define crWaitUntil(c)  do { crReturn(0); } while (!(c))
 290 #define crWaitUntilV(c) do { crReturnV; } while (!(c))
 291
 292 typedef struct ssh_tag *Ssh;
 293
 294 static void ssh2_pkt_init(Ssh, int pkt_type);
 295 static void ssh2_pkt_addbool(Ssh, unsigned char value);
 296 static void ssh2_pkt_adduint32(Ssh, unsigned long value);
 297 static void ssh2_pkt_addstring_start(Ssh);
 298 static void ssh2_pkt_addstring_str(Ssh, char *data);
 299 static void ssh2_pkt_addstring_data(Ssh, char *data, int len);
 300 static void ssh2_pkt_addstring(Ssh, char *data);
 301 static unsigned char *ssh2_mpint_fmt(Bignum b, int *len);
 302 static void ssh2_pkt_addmp(Ssh, Bignum b);
 303 static int ssh2_pkt_construct(Ssh);
 304 static void ssh2_pkt_send(Ssh);
 305
 306 /*
 307  * Buffer management constants. There are several of these for
 308  * various different purposes:
 309  *
 310  *  - SSH1_BUFFER_LIMIT is the amount of backlog that must build up
 311  *    on a local data stream before we throttle the whole SSH
 312  *    connection (in SSH1 only). Throttling the whole connection is
 313  *    pretty drastic so we set this high in the hope it won't
 314  *    happen very often.
 315  *
 316  *  - SSH_MAX_BACKLOG is the amount of backlog that must build up
 317  *    on the SSH connection itself before we defensively throttle
 318  *    _all_ local data streams. This is pretty drastic too (though
 319  *    thankfully unlikely in SSH2 since the window mechanism should
 320  *    ensure that the server never has any need to throttle its end
 321  *    of the connection), so we set this high as well.
 322  *
 323  *  - OUR_V2_WINSIZE is the maximum window size we present on SSH2
 324  *    channels.
 325  */
 326
 327 #define SSH1_BUFFER_LIMIT 32768
 328 #define SSH_MAX_BACKLOG 32768
 329 #define OUR_V2_WINSIZE 16384
 330
 331 const static struct ssh_kex *kex_algs[] = {
 332     &ssh_diffiehellman_gex,
 333     &ssh_diffiehellman
 334 };
 335
 336 const static struct ssh_signkey *hostkey_algs[] = { &ssh_rsa, &ssh_dss };
 337
 338 static void *nullmac_make_context(void)
 339 {
 340     return NULL;
 341 }
 342 static void nullmac_free_context(void *handle)
 343 {
 344 }
 345 static void nullmac_key(void *handle, unsigned char *key)
 346 {
 347 }
 348 static void nullmac_generate(void *handle, unsigned char *blk, int len,
 349                              unsigned long seq)
 350 {
 351 }
 352 static int nullmac_verify(void *handle, unsigned char *blk, int len,
 353                           unsigned long seq)
 354 {
 355     return 1;
 356 }
 357 const static struct ssh_mac ssh_mac_none = {
 358     nullmac_make_context, nullmac_free_context, nullmac_key,
 359     nullmac_generate, nullmac_verify, "none", 0
 360 };
 361 const static struct ssh_mac *macs[] = {
 362     &ssh_sha1, &ssh_md5, &ssh_mac_none
 363 };
 364 const static struct ssh_mac *buggymacs[] = {
 365     &ssh_sha1_buggy, &ssh_md5, &ssh_mac_none
 366 };
 367
 368 static void *ssh_comp_none_init(void)
 369 {
 370     return NULL;
 371 }
 372 static void ssh_comp_none_cleanup(void *handle)
 373 {
 374 }
 375 static int ssh_comp_none_block(void *handle, unsigned char *block, int len,
 376                                unsigned char **outblock, int *outlen)
 377 {
 378     return 0;
 379 }
 380 static int ssh_comp_none_disable(void *handle)
 381 {
 382     return 0;
 383 }
 384 const static struct ssh_compress ssh_comp_none = {
 385     "none",
 386     ssh_comp_none_init, ssh_comp_none_cleanup, ssh_comp_none_block,
 387     ssh_comp_none_init, ssh_comp_none_cleanup, ssh_comp_none_block,
 388     ssh_comp_none_disable, NULL
 389 };
 390 extern const struct ssh_compress ssh_zlib;
 391 const static struct ssh_compress *compressions[] = {
 392     &ssh_zlib, &ssh_comp_none
 393 };
 394
 395 enum {                                 /* channel types */
 396     CHAN_MAINSESSION,
 397     CHAN_X11,
 398     CHAN_AGENT,
 399     CHAN_SOCKDATA,
 400     CHAN_SOCKDATA_DORMANT              /* one the remote hasn't confirmed */
 401 };
 402
 403 /*
 404  * 2-3-4 tree storing channels.
 405  */
 406 struct ssh_channel {
 407     Ssh ssh;                           /* pointer back to main context */
 408     unsigned remoteid, localid;
 409     int type;
 410     /*
 411      * In SSH1, this value contains four bits:
 412      *
 413      *   1   We have sent SSH1_MSG_CHANNEL_CLOSE.
 414      *   2   We have sent SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
 415      *   4   We have received SSH1_MSG_CHANNEL_CLOSE.
 416      *   8   We have received SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
 417      *
 418      * A channel is completely finished with when all four bits are set.
 419      */
 420     int closes;
 421     union {
 422         struct ssh1_data_channel {
 423             int throttling;
 424         } v1;
 425         struct ssh2_data_channel {
 426             bufchain outbuffer;
 427             unsigned remwindow, remmaxpkt;
 428             unsigned locwindow;
 429         } v2;
 430     } v;
 431     union {
 432         struct ssh_agent_channel {
 433             unsigned char *message;
 434             unsigned char msglen[4];
 435             int lensofar, totallen;
 436         } a;
 437         struct ssh_x11_channel {
 438             Socket s;
 439         } x11;
 440         struct ssh_pfd_channel {
 441             Socket s;
 442         } pfd;
 443     } u;
 444 };
 445
 446 /*
 447  * 2-3-4 tree storing remote->local port forwardings. SSH 1 and SSH
 448  * 2 use this structure in different ways, reflecting SSH 2's
 449  * altogether saner approach to port forwarding.
 450  *
 451  * In SSH 1, you arrange a remote forwarding by sending the server
 452  * the remote port number, and the local destination host:port.
 453  * When a connection comes in, the server sends you back that
 454  * host:port pair, and you connect to it. This is a ready-made
 455  * security hole if you're not on the ball: a malicious server
 456  * could send you back _any_ host:port pair, so if you trustingly
 457  * connect to the address it gives you then you've just opened the
 458  * entire inside of your corporate network just by connecting
 459  * through it to a dodgy SSH server. Hence, we must store a list of
 460  * host:port pairs we _are_ trying to forward to, and reject a
 461  * connection request from the server if it's not in the list.
 462  *
 463  * In SSH 2, each side of the connection minds its own business and
 464  * doesn't send unnecessary information to the other. You arrange a
 465  * remote forwarding by sending the server just the remote port
 466  * number. When a connection comes in, the server tells you which
 467  * of its ports was connected to; and _you_ have to remember what
 468  * local host:port pair went with that port number.
 469  *
 470  * Hence: in SSH 1 this structure stores host:port pairs we intend
 471  * to allow connections to, and is indexed by those host:port
 472  * pairs. In SSH 2 it stores a mapping from source port to
 473  * destination host:port pair, and is indexed by source port.
 474  */
 475 struct ssh_rportfwd {
 476     unsigned sport, dport;
 477     char dhost[256];
 478 };
 479
 480 struct Packet {
 481     long length;
 482     int type;
 483     unsigned char *data;
 484     unsigned char *body;
 485     long savedpos;
 486     long maxlen;
 487 };
 488
 489 static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt);
 490 static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt);
 491 static void ssh_size(void *handle, int width, int height);
 492 static void ssh_special(void *handle, Telnet_Special);
 493 static int ssh2_try_send(struct ssh_channel *c);
 494 static void ssh2_add_channel_data(struct ssh_channel *c, char *buf, int len);
 495 static void ssh_throttle_all(Ssh ssh, int enable, int bufsize);
 496 static void ssh2_set_window(struct ssh_channel *c, unsigned newwin);
 497 static int ssh_sendbuffer(void *handle);
 498
 499 struct rdpkt1_state_tag {
 500     long len, pad, biglen, to_read;
 501     unsigned long realcrc, gotcrc;
 502     unsigned char *p;
 503     int i;
 504     int chunk;
 505 };
 506
 507 struct rdpkt2_state_tag {
 508     long len, pad, payload, packetlen, maclen;
 509     int i;
 510     int cipherblk;
 511     unsigned long incoming_sequence;
 512 };
 513
 514 struct ssh_tag {
 515     const struct plug_function_table *fn;
 516     /* the above field _must_ be first in the structure */
 517
 518     SHA_State exhash, exhashbase;
 519
 520     Socket s;
 521
 522     void *ldisc;
 523     void *logctx;
 524
 525     unsigned char session_key[32];
 526     int v1_compressing;
 527     int v1_remote_protoflags;
 528     int v1_local_protoflags;
 529     int agentfwd_enabled;
 530     int X11_fwd_enabled;
 531     int remote_bugs;
 532     const struct ssh_cipher *cipher;
 533     void *v1_cipher_ctx;
 534     void *crcda_ctx;
 535     const struct ssh2_cipher *cscipher, *sccipher;
 536     void *cs_cipher_ctx, *sc_cipher_ctx;
 537     const struct ssh_mac *csmac, *scmac;
 538     void *cs_mac_ctx, *sc_mac_ctx;
 539     const struct ssh_compress *cscomp, *sccomp;
 540     void *cs_comp_ctx, *sc_comp_ctx;
 541     const struct ssh_kex *kex;
 542     const struct ssh_signkey *hostkey;
 543     unsigned char v2_session_id[20];
 544     void *kex_ctx;
 545
 546     char *savedhost;
 547     int savedport;
 548     int send_ok;
 549     int echoing, editing;
 550
 551     void *frontend;
 552
 553     int term_width, term_height;
 554
 555     tree234 *channels;                 /* indexed by local id */
 556     struct ssh_channel *mainchan;      /* primary session channel */
 557     int exitcode;
 558
 559     tree234 *rportfwds;
 560
 561     enum {
 562         SSH_STATE_PREPACKET,
 563         SSH_STATE_BEFORE_SIZE,
 564         SSH_STATE_INTERMED,
 565         SSH_STATE_SESSION,
 566         SSH_STATE_CLOSED
 567     } state;
 568
 569     int size_needed, eof_needed;
 570
 571     struct Packet pktin;
 572     struct Packet pktout;
 573     unsigned char *deferred_send_data;
 574     int deferred_len, deferred_size;
 575
 576     /*
 577      * Gross hack: pscp will try to start SFTP but fall back to
 578      * scp1 if that fails. This variable is the means by which
 579      * scp.c can reach into the SSH code and find out which one it
 580      * got.
 581      */
 582     int fallback_cmd;
 583
 584     /*
 585      * Used for username and password input.
 586      */
 587     char *userpass_input_buffer;
 588     int userpass_input_buflen;
 589     int userpass_input_bufpos;
 590     int userpass_input_echo;
 591
 592     char *portfwd_strptr;
 593     int pkt_ctx;
 594
 595     void *x11auth;
 596
 597     int version;
 598     int v1_throttle_count;
 599     int overall_bufsize;
 600     int throttled_all;
 601     int v1_stdout_throttling;
 602     int v2_outgoing_sequence;
 603
 604     int ssh1_rdpkt_crstate;
 605     int ssh2_rdpkt_crstate;
 606     int do_ssh_init_crstate;
 607     int ssh_gotdata_crstate;
 608     int ssh1_protocol_crstate;
 609     int do_ssh1_login_crstate;
 610     int do_ssh2_transport_crstate;
 611     int do_ssh2_authconn_crstate;
 612
 613     void *do_ssh_init_state;
 614     void *do_ssh1_login_state;
 615     void *do_ssh2_transport_state;
 616     void *do_ssh2_authconn_state;
 617
 618     struct rdpkt1_state_tag rdpkt1_state;
 619     struct rdpkt2_state_tag rdpkt2_state;
 620
 621     void (*protocol) (Ssh ssh, unsigned char *in, int inlen, int ispkt);
 622     int (*s_rdpkt) (Ssh ssh, unsigned char **data, int *datalen);
 623
 624     /*
 625      * We maintain a full _copy_ of a Config structure here, not
 626      * merely a pointer to it. That way, when we're passed a new
 627      * one for reconfiguration, we can check the differences and
 628      * potentially reconfigure port forwardings etc in mid-session.
 629      */
 630     Config cfg;
 631 };
 632
 633 #define logevent(s) logevent(ssh->frontend, s)
 634
 635 /* logevent, only printf-formatted. */
 636 static void logeventf(Ssh ssh, char *fmt, ...)
 637 {
 638     va_list ap;
 639     char *buf;
 640
 641     va_start(ap, fmt);
 642     buf = dupvprintf(fmt, ap);
 643     va_end(ap);
 644     logevent(buf);
 645     sfree(buf);
 646 }
 647
 648 #define bombout(msg) ( ssh->state = SSH_STATE_CLOSED, \
 649                           (ssh->s ? sk_close(ssh->s), ssh->s = NULL : 0), \
 650                           logeventf msg, connection_fatal msg )
 651
 652 static int ssh_channelcmp(void *av, void *bv)
 653 {
 654     struct ssh_channel *a = (struct ssh_channel *) av;
 655     struct ssh_channel *b = (struct ssh_channel *) bv;
 656     if (a->localid < b->localid)
 657         return -1;
 658     if (a->localid > b->localid)
 659         return +1;
 660     return 0;
 661 }
 662 static int ssh_channelfind(void *av, void *bv)
 663 {
 664     unsigned *a = (unsigned *) av;
 665     struct ssh_channel *b = (struct ssh_channel *) bv;
 666     if (*a < b->localid)
 667         return -1;
 668     if (*a > b->localid)
 669         return +1;
 670     return 0;
 671 }
 672
 673 static int ssh_rportcmp_ssh1(void *av, void *bv)
 674 {
 675     struct ssh_rportfwd *a = (struct ssh_rportfwd *) av;
 676     struct ssh_rportfwd *b = (struct ssh_rportfwd *) bv;
 677     int i;
 678     if ( (i = strcmp(a->dhost, b->dhost)) != 0)
 679         return i < 0 ? -1 : +1;
 680     if (a->dport > b->dport)
 681         return +1;
 682     if (a->dport < b->dport)
 683         return -1;
 684     return 0;
 685 }
 686
 687 static int ssh_rportcmp_ssh2(void *av, void *bv)
 688 {
 689     struct ssh_rportfwd *a = (struct ssh_rportfwd *) av;
 690     struct ssh_rportfwd *b = (struct ssh_rportfwd *) bv;
 691
 692     if (a->sport > b->sport)
 693         return +1;
 694     if (a->sport < b->sport)
 695         return -1;
 696     return 0;
 697 }
 698
 699 static int alloc_channel_id(Ssh ssh)
 700 {
 701     const unsigned CHANNEL_NUMBER_OFFSET = 256;
 702     unsigned low, high, mid;
 703     int tsize;
 704     struct ssh_channel *c;
 705
 706     /*
 707      * First-fit allocation of channel numbers: always pick the
 708      * lowest unused one. To do this, binary-search using the
 709      * counted B-tree to find the largest channel ID which is in a
 710      * contiguous sequence from the beginning. (Precisely
 711      * everything in that sequence must have ID equal to its tree
 712      * index plus CHANNEL_NUMBER_OFFSET.)
 713      */
 714     tsize = count234(ssh->channels);
 715
 716     low = -1;
 717     high = tsize;
 718     while (high - low > 1) {
 719         mid = (high + low) / 2;
 720         c = index234(ssh->channels, mid);
 721         if (c->localid == mid + CHANNEL_NUMBER_OFFSET)
 722             low = mid;                 /* this one is fine */
 723         else
 724             high = mid;                /* this one is past it */
 725     }
 726     /*
 727      * Now low points to either -1, or the tree index of the
 728      * largest ID in the initial sequence.
 729      */
 730     {
 731         unsigned i = low + 1 + CHANNEL_NUMBER_OFFSET;
 732         assert(NULL == find234(ssh->channels, &i, ssh_channelfind));
 733     }
 734     return low + 1 + CHANNEL_NUMBER_OFFSET;
 735 }
 736
 737 static void c_write(Ssh ssh, char *buf, int len)
 738 {
 739     if ((flags & FLAG_STDERR)) {
 740         int i;
 741         for (i = 0; i < len; i++)
 742             if (buf[i] != '\r')
 743                 fputc(buf[i], stderr);
 744         return;
 745     }
 746     from_backend(ssh->frontend, 1, buf, len);
 747 }
 748
 749 static void c_write_untrusted(Ssh ssh, char *buf, int len)
 750 {
 751     int i;
 752     for (i = 0; i < len; i++) {
 753         if (buf[i] == '\n')
 754             c_write(ssh, "\r\n", 2);
 755         else if ((buf[i] & 0x60) || (buf[i] == '\r'))
 756             c_write(ssh, buf + i, 1);
 757     }
 758 }
 759
 760 static void c_write_str(Ssh ssh, char *buf)
 761 {
 762     c_write(ssh, buf, strlen(buf));
 763 }
 764
 765 /*
 766  * Collect incoming data in the incoming packet buffer.
 767  * Decipher and verify the packet when it is completely read.
 768  * Drop SSH1_MSG_DEBUG and SSH1_MSG_IGNORE packets.
 769  * Update the *data and *datalen variables.
 770  * Return the additional nr of bytes needed, or 0 when
 771  * a complete packet is available.
 772  */
 773 static int ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
 774 {
 775     struct rdpkt1_state_tag *st = &ssh->rdpkt1_state;
 776
 777     crBegin(ssh->ssh1_rdpkt_crstate);
 778
 779   next_packet:
 780
 781     ssh->pktin.type = 0;
 782     ssh->pktin.length = 0;
 783
 784     for (st->i = st->len = 0; st->i < 4; st->i++) {
 785         while ((*datalen) == 0)
 786             crReturn(4 - st->i);
 787         st->len = (st->len << 8) + **data;
 788         (*data)++, (*datalen)--;
 789     }
 790
 791     st->pad = 8 - (st->len % 8);
 792     st->biglen = st->len + st->pad;
 793     ssh->pktin.length = st->len - 5;
 794
 795     if (ssh->pktin.maxlen < st->biglen) {
 796         ssh->pktin.maxlen = st->biglen;
 797         ssh->pktin.data = srealloc(ssh->pktin.data, st->biglen + APIEXTRA);
 798     }
 799
 800     st->to_read = st->biglen;
 801     st->p = ssh->pktin.data;
 802     while (st->to_read > 0) {
 803         st->chunk = st->to_read;
 804         while ((*datalen) == 0)
 805             crReturn(st->to_read);
 806         if (st->chunk > (*datalen))
 807             st->chunk = (*datalen);
 808         memcpy(st->p, *data, st->chunk);
 809         *data += st->chunk;
 810         *datalen -= st->chunk;
 811         st->p += st->chunk;
 812         st->to_read -= st->chunk;
 813     }
 814
 815     if (ssh->cipher && detect_attack(ssh->crcda_ctx, ssh->pktin.data,
 816                                      st->biglen, NULL)) {
 817         bombout((ssh,"Network attack (CRC compensation) detected!"));
 818         crReturn(0);
 819     }
 820
 821     if (ssh->cipher)
 822         ssh->cipher->decrypt(ssh->v1_cipher_ctx, ssh->pktin.data, st->biglen);
 823
 824     st->realcrc = crc32(ssh->pktin.data, st->biglen - 4);
 825     st->gotcrc = GET_32BIT(ssh->pktin.data + st->biglen - 4);
 826     if (st->gotcrc != st->realcrc) {
 827         bombout((ssh,"Incorrect CRC received on packet"));
 828         crReturn(0);
 829     }
 830
 831     ssh->pktin.body = ssh->pktin.data + st->pad + 1;
 832
 833     if (ssh->v1_compressing) {
 834         unsigned char *decompblk;
 835         int decomplen;
 836         zlib_decompress_block(ssh->sc_comp_ctx,
 837                               ssh->pktin.body - 1, ssh->pktin.length + 1,
 838                               &decompblk, &decomplen);
 839
 840         if (ssh->pktin.maxlen < st->pad + decomplen) {
 841             ssh->pktin.maxlen = st->pad + decomplen;
 842             ssh->pktin.data = srealloc(ssh->pktin.data,
 843                                        ssh->pktin.maxlen + APIEXTRA);
 844             ssh->pktin.body = ssh->pktin.data + st->pad + 1;
 845         }
 846
 847         memcpy(ssh->pktin.body - 1, decompblk, decomplen);
 848         sfree(decompblk);
 849         ssh->pktin.length = decomplen - 1;
 850     }
 851
 852     ssh->pktin.type = ssh->pktin.body[-1];
 853
 854     if (ssh->logctx)
 855         log_packet(ssh->logctx,
 856                    PKT_INCOMING, ssh->pktin.type,
 857                    ssh1_pkt_type(ssh->pktin.type),
 858                    ssh->pktin.body, ssh->pktin.length);
 859
 860     if (ssh->pktin.type == SSH1_SMSG_STDOUT_DATA ||
 861         ssh->pktin.type == SSH1_SMSG_STDERR_DATA ||
 862         ssh->pktin.type == SSH1_MSG_DEBUG ||
 863         ssh->pktin.type == SSH1_SMSG_AUTH_TIS_CHALLENGE ||
 864         ssh->pktin.type == SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
 865         long stringlen = GET_32BIT(ssh->pktin.body);
 866         if (stringlen + 4 != ssh->pktin.length) {
 867             bombout((ssh,"Received data packet with bogus string length"));
 868             crReturn(0);
 869         }
 870     }
 871
 872     if (ssh->pktin.type == SSH1_MSG_DEBUG) {
 873         /* log debug message */
 874         char buf[512];
 875         int stringlen = GET_32BIT(ssh->pktin.body);
 876         strcpy(buf, "Remote debug message: ");
 877         if (stringlen > 480)
 878             stringlen = 480;
 879         memcpy(buf + 8, ssh->pktin.body + 4, stringlen);
 880         buf[8 + stringlen] = '\0';
 881         logevent(buf);
 882         goto next_packet;
 883     } else if (ssh->pktin.type == SSH1_MSG_IGNORE) {
 884         /* do nothing */
 885         goto next_packet;
 886     }
 887
 888     if (ssh->pktin.type == SSH1_MSG_DISCONNECT) {
 889         /* log reason code in disconnect message */
 890         char buf[256];
 891         unsigned msglen = GET_32BIT(ssh->pktin.body);
 892         unsigned nowlen;
 893         strcpy(buf, "Remote sent disconnect: ");
 894         nowlen = strlen(buf);
 895         if (msglen > sizeof(buf) - nowlen - 1)
 896             msglen = sizeof(buf) - nowlen - 1;
 897         memcpy(buf + nowlen, ssh->pktin.body + 4, msglen);
 898         buf[nowlen + msglen] = '\0';
 899         /* logevent(buf); (this is now done within the bombout macro) */
 900         bombout((ssh,"Server sent disconnect message:\n\"%s\"", buf+nowlen));
 901         crReturn(0);
 902     }
 903
 904     crFinish(0);
 905 }
 906
 907 static int ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
 908 {
 909     struct rdpkt2_state_tag *st = &ssh->rdpkt2_state;
 910
 911     crBegin(ssh->ssh2_rdpkt_crstate);
 912
 913   next_packet:
 914     ssh->pktin.type = 0;
 915     ssh->pktin.length = 0;
 916     if (ssh->sccipher)
 917         st->cipherblk = ssh->sccipher->blksize;
 918     else
 919         st->cipherblk = 8;
 920     if (st->cipherblk < 8)
 921         st->cipherblk = 8;
 922
 923     if (ssh->pktin.maxlen < st->cipherblk) {
 924         ssh->pktin.maxlen = st->cipherblk;
 925         ssh->pktin.data = srealloc(ssh->pktin.data, st->cipherblk + APIEXTRA);
 926     }
 927
 928     /*
 929      * Acquire and decrypt the first block of the packet. This will
 930      * contain the length and padding details.
 931      */
 932     for (st->i = st->len = 0; st->i < st->cipherblk; st->i++) {
 933         while ((*datalen) == 0)
 934             crReturn(st->cipherblk - st->i);
 935         ssh->pktin.data[st->i] = *(*data)++;
 936         (*datalen)--;
 937     }
 938
 939     if (ssh->sccipher)
 940         ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
 941                                ssh->pktin.data, st->cipherblk);
 942
 943     /*
 944      * Now get the length and padding figures.
 945      */
 946     st->len = GET_32BIT(ssh->pktin.data);
 947     st->pad = ssh->pktin.data[4];
 948
 949     /*
 950      * _Completely_ silly lengths should be stomped on before they
 951      * do us any more damage.
 952      */
 953     if (st->len < 0 || st->pad < 0 || st->len + st->pad < 0) {
 954         bombout((ssh,"Incoming packet was garbled on decryption"));
 955         crReturn(0);
 956     }
 957
 958     /*
 959      * This enables us to deduce the payload length.
 960      */
 961     st->payload = st->len - st->pad - 1;
 962
 963     ssh->pktin.length = st->payload + 5;
 964
 965     /*
 966      * So now we can work out the total packet length.
 967      */
 968     st->packetlen = st->len + 4;
 969     st->maclen = ssh->scmac ? ssh->scmac->len : 0;
 970
 971     /*
 972      * Adjust memory allocation if packet is too big.
 973      */
 974     if (ssh->pktin.maxlen < st->packetlen + st->maclen) {
 975         ssh->pktin.maxlen = st->packetlen + st->maclen;
 976         ssh->pktin.data = srealloc(ssh->pktin.data,
 977                                    ssh->pktin.maxlen + APIEXTRA);
 978     }
 979
 980     /*
 981      * Read and decrypt the remainder of the packet.
 982      */
 983     for (st->i = st->cipherblk; st->i < st->packetlen + st->maclen;
 984          st->i++) {
 985         while ((*datalen) == 0)
 986             crReturn(st->packetlen + st->maclen - st->i);
 987         ssh->pktin.data[st->i] = *(*data)++;
 988         (*datalen)--;
 989     }
 990     /* Decrypt everything _except_ the MAC. */
 991     if (ssh->sccipher)
 992         ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
 993                                ssh->pktin.data + st->cipherblk,
 994                                st->packetlen - st->cipherblk);
 995
 996     /*
 997      * Check the MAC.
 998      */
 999     if (ssh->scmac
1000         && !ssh->scmac->verify(ssh->sc_mac_ctx, ssh->pktin.data, st->len + 4,
1001                                st->incoming_sequence)) {
1002         bombout((ssh,"Incorrect MAC received on packet"));
1003         crReturn(0);
1004     }
1005     st->incoming_sequence++;           /* whether or not we MACed */
1006
1007     /*
1008      * Decompress packet payload.
1009      */
1010     {
1011         unsigned char *newpayload;
1012         int newlen;
1013         if (ssh->sccomp &&
1014             ssh->sccomp->decompress(ssh->sc_comp_ctx,
1015                                     ssh->pktin.data + 5, ssh->pktin.length - 5,
1016                                     &newpayload, &newlen)) {
1017             if (ssh->pktin.maxlen < newlen + 5) {
1018                 ssh->pktin.maxlen = newlen + 5;
1019                 ssh->pktin.data = srealloc(ssh->pktin.data,
1020                                            ssh->pktin.maxlen + APIEXTRA);
1021             }
1022             ssh->pktin.length = 5 + newlen;
1023             memcpy(ssh->pktin.data + 5, newpayload, newlen);
1024             sfree(newpayload);
1025         }
1026     }
1027
1028     ssh->pktin.savedpos = 6;
1029     ssh->pktin.type = ssh->pktin.data[5];
1030
1031     if (ssh->logctx)
1032         log_packet(ssh->logctx, PKT_INCOMING, ssh->pktin.type,
1033                    ssh2_pkt_type(ssh->pkt_ctx, ssh->pktin.type),
1034                    ssh->pktin.data+6, ssh->pktin.length-6);
1035
1036     switch (ssh->pktin.type) {
1037         /*
1038          * These packets we must handle instantly.
1039          */
1040       case SSH2_MSG_DISCONNECT:
1041         {
1042             /* log reason code in disconnect message */
1043             char *buf;
1044             int nowlen;
1045             int reason = GET_32BIT(ssh->pktin.data + 6);
1046             unsigned msglen = GET_32BIT(ssh->pktin.data + 10);
1047
1048             if (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) {
1049                 buf = dupprintf("Received disconnect message (%s)",
1050                                 ssh2_disconnect_reasons[reason]);
1051             } else {
1052                 buf = dupprintf("Received disconnect message (unknown"
1053                                 " type %d)", reason);
1054             }
1055             logevent(buf);
1056             sfree(buf);
1057             buf = dupprintf("Disconnection message text: %n%.*s",
1058                             &nowlen, msglen, ssh->pktin.data + 14);
1059             logevent(buf);
1060             bombout((ssh,"Server sent disconnect message\ntype %d (%s):\n\"%s\"",
1061                      reason,
1062                      (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) ?
1063                      ssh2_disconnect_reasons[reason] : "unknown",
1064                      buf+nowlen));
1065             sfree(buf);
1066             crReturn(0);
1067         }
1068         break;
1069       case SSH2_MSG_IGNORE:
1070         goto next_packet;
1071       case SSH2_MSG_DEBUG:
1072         {
1073             /* log the debug message */
1074             char buf[512];
1075             /* int display = ssh->pktin.body[6]; */
1076             int stringlen = GET_32BIT(ssh->pktin.data+7);
1077             int prefix;
1078             strcpy(buf, "Remote debug message: ");
1079             prefix = strlen(buf);
1080             if (stringlen > (int)(sizeof(buf)-prefix-1))
1081                 stringlen = sizeof(buf)-prefix-1;
1082             memcpy(buf + prefix, ssh->pktin.data + 11, stringlen);
1083             buf[prefix + stringlen] = '\0';
1084             logevent(buf);
1085         }
1086         goto next_packet;              /* FIXME: print the debug message */
1087
1088         /*
1089          * These packets we need do nothing about here.
1090          */
1091       case SSH2_MSG_UNIMPLEMENTED:
1092       case SSH2_MSG_SERVICE_REQUEST:
1093       case SSH2_MSG_SERVICE_ACCEPT:
1094       case SSH2_MSG_KEXINIT:
1095       case SSH2_MSG_NEWKEYS:
1096       case SSH2_MSG_KEXDH_INIT:
1097       case SSH2_MSG_KEXDH_REPLY:
1098       /* case SSH2_MSG_KEX_DH_GEX_REQUEST: duplicate case value */
1099       /* case SSH2_MSG_KEX_DH_GEX_GROUP: duplicate case value */
1100       case SSH2_MSG_KEX_DH_GEX_INIT:
1101       case SSH2_MSG_KEX_DH_GEX_REPLY:
1102       case SSH2_MSG_USERAUTH_REQUEST:
1103       case SSH2_MSG_USERAUTH_FAILURE:
1104       case SSH2_MSG_USERAUTH_SUCCESS:
1105       case SSH2_MSG_USERAUTH_BANNER:
1106       case SSH2_MSG_USERAUTH_PK_OK:
1107       /* case SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ: duplicate case value */
1108       /* case SSH2_MSG_USERAUTH_INFO_REQUEST: duplicate case value */
1109       case SSH2_MSG_USERAUTH_INFO_RESPONSE:
1110       case SSH2_MSG_GLOBAL_REQUEST:
1111       case SSH2_MSG_REQUEST_SUCCESS:
1112       case SSH2_MSG_REQUEST_FAILURE:
1113       case SSH2_MSG_CHANNEL_OPEN:
1114       case SSH2_MSG_CHANNEL_OPEN_CONFIRMATION:
1115       case SSH2_MSG_CHANNEL_OPEN_FAILURE:
1116       case SSH2_MSG_CHANNEL_WINDOW_ADJUST:
1117       case SSH2_MSG_CHANNEL_DATA:
1118       case SSH2_MSG_CHANNEL_EXTENDED_DATA:
1119       case SSH2_MSG_CHANNEL_EOF:
1120       case SSH2_MSG_CHANNEL_CLOSE:
1121       case SSH2_MSG_CHANNEL_REQUEST:
1122       case SSH2_MSG_CHANNEL_SUCCESS:
1123       case SSH2_MSG_CHANNEL_FAILURE:
1124         break;
1125
1126         /*
1127          * For anything else we send SSH2_MSG_UNIMPLEMENTED.
1128          */
1129       default:
1130         ssh2_pkt_init(ssh, SSH2_MSG_UNIMPLEMENTED);
1131         ssh2_pkt_adduint32(ssh, st->incoming_sequence - 1);
1132         ssh2_pkt_send(ssh);
1133         break;
1134     }
1135
1136     crFinish(0);
1137 }
1138
1139 static void ssh1_pktout_size(Ssh ssh, int len)
1140 {
1141     int pad, biglen;
1142
1143     len += 5;                          /* type and CRC */
1144     pad = 8 - (len % 8);
1145     biglen = len + pad;
1146
1147     ssh->pktout.length = len - 5;
1148     if (ssh->pktout.maxlen < biglen) {
1149         ssh->pktout.maxlen = biglen;
1150 #ifdef MSCRYPTOAPI
1151         /* Allocate enough buffer space for extra block
1152          * for MS CryptEncrypt() */
1153         ssh->pktout.data = srealloc(ssh->pktout.data, biglen + 12);
1154 #else
1155         ssh->pktout.data = srealloc(ssh->pktout.data, biglen + 4);
1156 #endif
1157     }
1158     ssh->pktout.body = ssh->pktout.data + 4 + pad + 1;
1159 }
1160
1161 static void s_wrpkt_start(Ssh ssh, int type, int len)
1162 {
1163     ssh1_pktout_size(ssh, len);
1164     ssh->pktout.type = type;
1165 }
1166
1167 static int s_wrpkt_prepare(Ssh ssh)
1168 {
1169     int pad, len, biglen, i;
1170     unsigned long crc;
1171
1172     ssh->pktout.body[-1] = ssh->pktout.type;
1173
1174     if (ssh->logctx)
1175         log_packet(ssh->logctx, PKT_OUTGOING, ssh->pktout.type,
1176                    ssh1_pkt_type(ssh->pktout.type),
1177                    ssh->pktout.body, ssh->pktout.length);
1178
1179     if (ssh->v1_compressing) {
1180         unsigned char *compblk;
1181         int complen;
1182         zlib_compress_block(ssh->cs_comp_ctx,
1183                             ssh->pktout.body - 1, ssh->pktout.length + 1,
1184                             &compblk, &complen);
1185         ssh1_pktout_size(ssh, complen - 1);
1186         memcpy(ssh->pktout.body - 1, compblk, complen);
1187         sfree(compblk);
1188     }
1189
1190     len = ssh->pktout.length + 5;              /* type and CRC */
1191     pad = 8 - (len % 8);
1192     biglen = len + pad;
1193
1194     for (i = 0; i < pad; i++)
1195         ssh->pktout.data[i + 4] = random_byte();
1196     crc = crc32(ssh->pktout.data + 4, biglen - 4);
1197     PUT_32BIT(ssh->pktout.data + biglen, crc);
1198     PUT_32BIT(ssh->pktout.data, len);
1199
1200     if (ssh->cipher)
1201         ssh->cipher->encrypt(ssh->v1_cipher_ctx, ssh->pktout.data + 4, biglen);
1202
1203     return biglen + 4;
1204 }
1205
1206 static void s_wrpkt(Ssh ssh)
1207 {
1208     int len, backlog;
1209     len = s_wrpkt_prepare(ssh);
1210     backlog = sk_write(ssh->s, (char *)ssh->pktout.data, len);
1211     if (backlog > SSH_MAX_BACKLOG)
1212         ssh_throttle_all(ssh, 1, backlog);
1213 }
1214
1215 static void s_wrpkt_defer(Ssh ssh)
1216 {
1217     int len;
1218     len = s_wrpkt_prepare(ssh);
1219     if (ssh->deferred_len + len > ssh->deferred_size) {
1220         ssh->deferred_size = ssh->deferred_len + len + 128;
1221         ssh->deferred_send_data = srealloc(ssh->deferred_send_data,
1222                                            ssh->deferred_size);
1223     }
1224     memcpy(ssh->deferred_send_data + ssh->deferred_len, ssh->pktout.data, len);
1225     ssh->deferred_len += len;
1226 }
1227
1228 /*
1229  * Construct a packet with the specified contents.
1230  */
1231 static void construct_packet(Ssh ssh, int pkttype, va_list ap1, va_list ap2)
1232 {
1233     unsigned char *p, *argp, argchar;
1234     unsigned long argint;
1235     int pktlen, argtype, arglen;
1236     Bignum bn;
1237
1238     pktlen = 0;
1239     while ((argtype = va_arg(ap1, int)) != PKT_END) {
1240         switch (argtype) {
1241           case PKT_INT:
1242             (void) va_arg(ap1, int);
1243             pktlen += 4;
1244             break;
1245           case PKT_CHAR:
1246             (void) va_arg(ap1, int);
1247             pktlen++;
1248             break;
1249           case PKT_DATA:
1250             (void) va_arg(ap1, unsigned char *);
1251             arglen = va_arg(ap1, int);
1252             pktlen += arglen;
1253             break;
1254           case PKT_STR:
1255             argp = va_arg(ap1, unsigned char *);
1256             arglen = strlen((char *)argp);
1257             pktlen += 4 + arglen;
1258             break;
1259           case PKT_BIGNUM:
1260             bn = va_arg(ap1, Bignum);
1261             pktlen += ssh1_bignum_length(bn);
1262             break;
1263           default:
1264             assert(0);
1265         }
1266     }
1267
1268     s_wrpkt_start(ssh, pkttype, pktlen);
1269     p = ssh->pktout.body;
1270
1271     while ((argtype = va_arg(ap2, int)) != PKT_END) {
1272         switch (argtype) {
1273           case PKT_INT:
1274             argint = va_arg(ap2, int);
1275             PUT_32BIT(p, argint);
1276             p += 4;
1277             break;
1278           case PKT_CHAR:
1279             argchar = (unsigned char) va_arg(ap2, int);
1280             *p = argchar;
1281             p++;
1282             break;
1283           case PKT_DATA:
1284             argp = va_arg(ap2, unsigned char *);
1285             arglen = va_arg(ap2, int);
1286             memcpy(p, argp, arglen);
1287             p += arglen;
1288             break;
1289           case PKT_STR:
1290             argp = va_arg(ap2, unsigned char *);
1291             arglen = strlen((char *)argp);
1292             PUT_32BIT(p, arglen);
1293             memcpy(p + 4, argp, arglen);
1294             p += 4 + arglen;
1295             break;
1296           case PKT_BIGNUM:
1297             bn = va_arg(ap2, Bignum);
1298             p += ssh1_write_bignum(p, bn);
1299             break;
1300         }
1301     }
1302 }
1303
1304 static void send_packet(Ssh ssh, int pkttype, ...)
1305 {
1306     va_list ap1, ap2;
1307     va_start(ap1, pkttype);
1308     va_start(ap2, pkttype);
1309     construct_packet(ssh, pkttype, ap1, ap2);
1310     s_wrpkt(ssh);
1311 }
1312
1313 static void defer_packet(Ssh ssh, int pkttype, ...)
1314 {
1315     va_list ap1, ap2;
1316     va_start(ap1, pkttype);
1317     va_start(ap2, pkttype);
1318     construct_packet(ssh, pkttype, ap1, ap2);
1319     s_wrpkt_defer(ssh);
1320 }
1321
1322 static int ssh_versioncmp(char *a, char *b)
1323 {
1324     char *ae, *be;
1325     unsigned long av, bv;
1326
1327     av = strtoul(a, &ae, 10);
1328     bv = strtoul(b, &be, 10);
1329     if (av != bv)
1330         return (av < bv ? -1 : +1);
1331     if (*ae == '.')
1332         ae++;
1333     if (*be == '.')
1334         be++;
1335     av = strtoul(ae, &ae, 10);
1336     bv = strtoul(be, &be, 10);
1337     if (av != bv)
1338         return (av < bv ? -1 : +1);
1339     return 0;
1340 }
1341
1342 /*
1343  * Utility routines for putting an SSH-protocol `string' and
1344  * `uint32' into a SHA state.
1345  */
1346 #include <stdio.h>
1347 static void sha_string(SHA_State * s, void *str, int len)
1348 {
1349     unsigned char lenblk[4];
1350     PUT_32BIT(lenblk, len);
1351     SHA_Bytes(s, lenblk, 4);
1352     SHA_Bytes(s, str, len);
1353 }
1354
1355 static void sha_uint32(SHA_State * s, unsigned i)
1356 {
1357     unsigned char intblk[4];
1358     PUT_32BIT(intblk, i);
1359     SHA_Bytes(s, intblk, 4);
1360 }
1361
1362 /*
1363  * SSH2 packet construction functions.
1364  */
1365 static void ssh2_pkt_ensure(Ssh ssh, int length)
1366 {
1367     if (ssh->pktout.maxlen < length) {
1368         ssh->pktout.maxlen = length + 256;
1369         ssh->pktout.data = srealloc(ssh->pktout.data,
1370                                     ssh->pktout.maxlen + APIEXTRA);
1371         if (!ssh->pktout.data)
1372             fatalbox("Out of memory");
1373     }
1374 }
1375 static void ssh2_pkt_adddata(Ssh ssh, void *data, int len)
1376 {
1377     ssh->pktout.length += len;
1378     ssh2_pkt_ensure(ssh, ssh->pktout.length);
1379     memcpy(ssh->pktout.data + ssh->pktout.length - len, data, len);
1380 }
1381 static void ssh2_pkt_addbyte(Ssh ssh, unsigned char byte)
1382 {
1383     ssh2_pkt_adddata(ssh, &byte, 1);
1384 }
1385 static void ssh2_pkt_init(Ssh ssh, int pkt_type)
1386 {
1387     ssh->pktout.length = 5;
1388     ssh2_pkt_addbyte(ssh, (unsigned char) pkt_type);
1389 }
1390 static void ssh2_pkt_addbool(Ssh ssh, unsigned char value)
1391 {
1392     ssh2_pkt_adddata(ssh, &value, 1);
1393 }
1394 static void ssh2_pkt_adduint32(Ssh ssh, unsigned long value)
1395 {
1396     unsigned char x[4];
1397     PUT_32BIT(x, value);
1398     ssh2_pkt_adddata(ssh, x, 4);
1399 }
1400 static void ssh2_pkt_addstring_start(Ssh ssh)
1401 {
1402     ssh2_pkt_adduint32(ssh, 0);
1403     ssh->pktout.savedpos = ssh->pktout.length;
1404 }
1405 static void ssh2_pkt_addstring_str(Ssh ssh, char *data)
1406 {
1407     ssh2_pkt_adddata(ssh, data, strlen(data));
1408     PUT_32BIT(ssh->pktout.data + ssh->pktout.savedpos - 4,
1409               ssh->pktout.length - ssh->pktout.savedpos);
1410 }
1411 static void ssh2_pkt_addstring_data(Ssh ssh, char *data, int len)
1412 {
1413     ssh2_pkt_adddata(ssh, data, len);
1414     PUT_32BIT(ssh->pktout.data + ssh->pktout.savedpos - 4,
1415               ssh->pktout.length - ssh->pktout.savedpos);
1416 }
1417 static void ssh2_pkt_addstring(Ssh ssh, char *data)
1418 {
1419     ssh2_pkt_addstring_start(ssh);
1420     ssh2_pkt_addstring_str(ssh, data);
1421 }
1422 static unsigned char *ssh2_mpint_fmt(Bignum b, int *len)
1423 {
1424     unsigned char *p;
1425     int i, n = (bignum_bitcount(b) + 7) / 8;
1426     p = smalloc(n + 1);
1427     if (!p)
1428         fatalbox("out of memory");
1429     p[0] = 0;
1430     for (i = 1; i <= n; i++)
1431         p[i] = bignum_byte(b, n - i);
1432     i = 0;
1433     while (i <= n && p[i] == 0 && (p[i + 1] & 0x80) == 0)
1434         i++;
1435     memmove(p, p + i, n + 1 - i);
1436     *len = n + 1 - i;
1437     return p;
1438 }
1439 static void ssh2_pkt_addmp(Ssh ssh, Bignum b)
1440 {
1441     unsigned char *p;
1442     int len;
1443     p = ssh2_mpint_fmt(b, &len);
1444     ssh2_pkt_addstring_start(ssh);
1445     ssh2_pkt_addstring_data(ssh, (char *)p, len);
1446     sfree(p);
1447 }
1448
1449 /*
1450  * Construct an SSH2 final-form packet: compress it, encrypt it,
1451  * put the MAC on it. Final packet, ready to be sent, is stored in
1452  * ssh->pktout.data. Total length is returned.
1453  */
1454 static int ssh2_pkt_construct(Ssh ssh)
1455 {
1456     int cipherblk, maclen, padding, i;
1457
1458     if (ssh->logctx)
1459         log_packet(ssh->logctx, PKT_OUTGOING, ssh->pktout.data[5],
1460                    ssh2_pkt_type(ssh->pkt_ctx, ssh->pktout.data[5]),
1461                    ssh->pktout.data + 6, ssh->pktout.length - 6);
1462
1463     /*
1464      * Compress packet payload.
1465      */
1466     {
1467         unsigned char *newpayload;
1468         int newlen;
1469         if (ssh->cscomp &&
1470             ssh->cscomp->compress(ssh->cs_comp_ctx, ssh->pktout.data + 5,
1471                                   ssh->pktout.length - 5,
1472                                   &newpayload, &newlen)) {
1473             ssh->pktout.length = 5;
1474             ssh2_pkt_adddata(ssh, newpayload, newlen);
1475             sfree(newpayload);
1476         }
1477     }
1478
1479     /*
1480      * Add padding. At least four bytes, and must also bring total
1481      * length (minus MAC) up to a multiple of the block size.
1482      */
1483     cipherblk = ssh->cscipher ? ssh->cscipher->blksize : 8;  /* block size */
1484     cipherblk = cipherblk < 8 ? 8 : cipherblk;  /* or 8 if blksize < 8 */
1485     padding = 4;
1486     padding +=
1487         (cipherblk - (ssh->pktout.length + padding) % cipherblk) % cipherblk;
1488     maclen = ssh->csmac ? ssh->csmac->len : 0;
1489     ssh2_pkt_ensure(ssh, ssh->pktout.length + padding + maclen);
1490     ssh->pktout.data[4] = padding;
1491     for (i = 0; i < padding; i++)
1492         ssh->pktout.data[ssh->pktout.length + i] = random_byte();
1493     PUT_32BIT(ssh->pktout.data, ssh->pktout.length + padding - 4);
1494     if (ssh->csmac)
1495         ssh->csmac->generate(ssh->cs_mac_ctx, ssh->pktout.data,
1496                              ssh->pktout.length + padding,
1497                              ssh->v2_outgoing_sequence);
1498     ssh->v2_outgoing_sequence++;       /* whether or not we MACed */
1499
1500     if (ssh->cscipher)
1501         ssh->cscipher->encrypt(ssh->cs_cipher_ctx,
1502                                ssh->pktout.data, ssh->pktout.length + padding);
1503
1504     /* Ready-to-send packet starts at ssh->pktout.data. We return length. */
1505     return ssh->pktout.length + padding + maclen;
1506 }
1507
1508 /*
1509  * Construct and send an SSH2 packet immediately.
1510  */
1511 static void ssh2_pkt_send(Ssh ssh)
1512 {
1513     int len;
1514     int backlog;
1515     len = ssh2_pkt_construct(ssh);
1516     backlog = sk_write(ssh->s, (char *)ssh->pktout.data, len);
1517     if (backlog > SSH_MAX_BACKLOG)
1518         ssh_throttle_all(ssh, 1, backlog);
1519 }
1520
1521 /*
1522  * Construct an SSH2 packet and add it to a deferred data block.
1523  * Useful for sending multiple packets in a single sk_write() call,
1524  * to prevent a traffic-analysing listener from being able to work
1525  * out the length of any particular packet (such as the password
1526  * packet).
1527  *
1528  * Note that because SSH2 sequence-numbers its packets, this can
1529  * NOT be used as an m4-style `defer' allowing packets to be
1530  * constructed in one order and sent in another.
1531  */
1532 static void ssh2_pkt_defer(Ssh ssh)
1533 {
1534     int len = ssh2_pkt_construct(ssh);
1535     if (ssh->deferred_len + len > ssh->deferred_size) {
1536         ssh->deferred_size = ssh->deferred_len + len + 128;
1537         ssh->deferred_send_data = srealloc(ssh->deferred_send_data,
1538                                            ssh->deferred_size);
1539     }
1540     memcpy(ssh->deferred_send_data + ssh->deferred_len, ssh->pktout.data, len);
1541     ssh->deferred_len += len;
1542 }
1543
1544 /*
1545  * Send the whole deferred data block constructed by
1546  * ssh2_pkt_defer() or SSH1's defer_packet().
1547  */
1548 static void ssh_pkt_defersend(Ssh ssh)
1549 {
1550     int backlog;
1551     backlog = sk_write(ssh->s, (char *)ssh->deferred_send_data,
1552                        ssh->deferred_len);
1553     ssh->deferred_len = ssh->deferred_size = 0;
1554     sfree(ssh->deferred_send_data);
1555     ssh->deferred_send_data = NULL;
1556     if (backlog > SSH_MAX_BACKLOG)
1557         ssh_throttle_all(ssh, 1, backlog);
1558 }
1559
1560 #if 0
1561 void bndebug(char *string, Bignum b)
1562 {
1563     unsigned char *p;
1564     int i, len;
1565     p = ssh2_mpint_fmt(b, &len);
1566     debug(("%s", string));
1567     for (i = 0; i < len; i++)
1568         debug((" %02x", p[i]));
1569     debug(("\n"));
1570     sfree(p);
1571 }
1572 #endif
1573
1574 static void sha_mpint(SHA_State * s, Bignum b)
1575 {
1576     unsigned char *p;
1577     int len;
1578     p = ssh2_mpint_fmt(b, &len);
1579     sha_string(s, p, len);
1580     sfree(p);
1581 }
1582
1583 /*
1584  * SSH2 packet decode functions.
1585  */
1586 static unsigned long ssh2_pkt_getuint32(Ssh ssh)
1587 {
1588     unsigned long value;
1589     if (ssh->pktin.length - ssh->pktin.savedpos < 4)
1590         return 0;                      /* arrgh, no way to decline (FIXME?) */
1591     value = GET_32BIT(ssh->pktin.data + ssh->pktin.savedpos);
1592     ssh->pktin.savedpos += 4;
1593     return value;
1594 }
1595 static int ssh2_pkt_getbool(Ssh ssh)
1596 {
1597     unsigned long value;
1598     if (ssh->pktin.length - ssh->pktin.savedpos < 1)
1599         return 0;                      /* arrgh, no way to decline (FIXME?) */
1600     value = ssh->pktin.data[ssh->pktin.savedpos] != 0;
1601     ssh->pktin.savedpos++;
1602     return value;
1603 }
1604 static void ssh2_pkt_getstring(Ssh ssh, char **p, int *length)
1605 {
1606     int len;
1607     *p = NULL;
1608     *length = 0;
1609     if (ssh->pktin.length - ssh->pktin.savedpos < 4)
1610         return;
1611     len = GET_32BIT(ssh->pktin.data + ssh->pktin.savedpos);
1612     if (len < 0)
1613         return;
1614     *length = len;
1615     ssh->pktin.savedpos += 4;
1616     if (ssh->pktin.length - ssh->pktin.savedpos < *length)
1617         return;
1618     *p = (char *)(ssh->pktin.data + ssh->pktin.savedpos);
1619     ssh->pktin.savedpos += *length;
1620 }
1621 static Bignum ssh2_pkt_getmp(Ssh ssh)
1622 {
1623     char *p;
1624     int length;
1625     Bignum b;
1626
1627     ssh2_pkt_getstring(ssh, &p, &length);
1628     if (!p)
1629         return NULL;
1630     if (p[0] & 0x80) {
1631         bombout((ssh,"internal error: Can't handle negative mpints"));
1632         return NULL;
1633     }
1634     b = bignum_from_bytes((unsigned char *)p, length);
1635     return b;
1636 }
1637
1638 /*
1639  * Helper function to add an SSH2 signature blob to a packet.
1640  * Expects to be shown the public key blob as well as the signature
1641  * blob. Normally works just like ssh2_pkt_addstring, but will
1642  * fiddle with the signature packet if necessary for
1643  * BUG_SSH2_RSA_PADDING.
1644  */
1645 static void ssh2_add_sigblob(Ssh ssh, void *pkblob_v, int pkblob_len,
1646                              void *sigblob_v, int sigblob_len)
1647 {
1648     unsigned char *pkblob = (unsigned char *)pkblob_v;
1649     unsigned char *sigblob = (unsigned char *)sigblob_v;
1650
1651     /* dmemdump(pkblob, pkblob_len); */
1652     /* dmemdump(sigblob, sigblob_len); */
1653
1654     /*
1655      * See if this is in fact an ssh-rsa signature and a buggy
1656      * server; otherwise we can just do this the easy way.
1657      */
1658     if ((ssh->remote_bugs & BUG_SSH2_RSA_PADDING) &&
1659         (GET_32BIT(pkblob) == 7 && !memcmp(pkblob+4, "ssh-rsa", 7))) {
1660         int pos, len, siglen;
1661
1662         /*
1663          * Find the byte length of the modulus.
1664          */
1665
1666         pos = 4+7;                     /* skip over "ssh-rsa" */
1667         pos += 4 + GET_32BIT(pkblob+pos);   /* skip over exponent */
1668         len = GET_32BIT(pkblob+pos);   /* find length of modulus */
1669         pos += 4;                      /* find modulus itself */
1670         while (len > 0 && pkblob[pos] == 0)
1671             len--, pos++;
1672         /* debug(("modulus length is %d\n", len)); */
1673
1674         /*
1675          * Now find the signature integer.
1676          */
1677         pos = 4+7;                     /* skip over "ssh-rsa" */
1678         siglen = GET_32BIT(sigblob+pos);
1679         /* debug(("signature length is %d\n", siglen)); */
1680
1681         if (len != siglen) {
1682             unsigned char newlen[4];
1683             ssh2_pkt_addstring_start(ssh);
1684             ssh2_pkt_addstring_data(ssh, (char *)sigblob, pos);
1685             /* dmemdump(sigblob, pos); */
1686             pos += 4;                  /* point to start of actual sig */
1687             PUT_32BIT(newlen, len);
1688             ssh2_pkt_addstring_data(ssh, (char *)newlen, 4);
1689             /* dmemdump(newlen, 4); */
1690             newlen[0] = 0;
1691             while (len-- > siglen) {
1692                 ssh2_pkt_addstring_data(ssh, (char *)newlen, 1);
1693                 /* dmemdump(newlen, 1); */
1694             }
1695             ssh2_pkt_addstring_data(ssh, (char *)(sigblob+pos), siglen);
1696             /* dmemdump(sigblob+pos, siglen); */
1697             return;
1698         }
1699
1700         /* Otherwise fall through and do it the easy way. */
1701     }
1702
1703     ssh2_pkt_addstring_start(ssh);
1704     ssh2_pkt_addstring_data(ssh, (char *)sigblob, sigblob_len);
1705 }
1706
1707 /*
1708  * Examine the remote side's version string and compare it against
1709  * a list of known buggy implementations.
1710  */
1711 static void ssh_detect_bugs(Ssh ssh, char *vstring)
1712 {
1713     char *imp;                         /* pointer to implementation part */
1714     imp = vstring;
1715     imp += strcspn(imp, "-");
1716     if (*imp) imp++;
1717     imp += strcspn(imp, "-");
1718     if (*imp) imp++;
1719
1720     ssh->remote_bugs = 0;
1721
1722     if (ssh->cfg.sshbug_ignore1 == BUG_ON ||
1723         (ssh->cfg.sshbug_ignore1 == BUG_AUTO &&
1724          (!strcmp(imp, "1.2.18") || !strcmp(imp, "1.2.19") ||
1725           !strcmp(imp, "1.2.20") || !strcmp(imp, "1.2.21") ||
1726           !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25")))) {
1727         /*
1728          * These versions don't support SSH1_MSG_IGNORE, so we have
1729          * to use a different defence against password length
1730          * sniffing.
1731          */
1732         ssh->remote_bugs |= BUG_CHOKES_ON_SSH1_IGNORE;
1733         logevent("We believe remote version has SSH1 ignore bug");
1734     }
1735
1736     if (ssh->cfg.sshbug_plainpw1 == BUG_ON ||
1737         (ssh->cfg.sshbug_plainpw1 == BUG_AUTO &&
1738          (!strcmp(imp, "Cisco-1.25")))) {
1739         /*
1740          * These versions need a plain password sent; they can't
1741          * handle having a null and a random length of data after
1742          * the password.
1743          */
1744         ssh->remote_bugs |= BUG_NEEDS_SSH1_PLAIN_PASSWORD;
1745         logevent("We believe remote version needs a plain SSH1 password");
1746     }
1747
1748     if (ssh->cfg.sshbug_rsa1 == BUG_ON ||
1749         (ssh->cfg.sshbug_rsa1 == BUG_AUTO &&
1750          (!strcmp(imp, "Cisco-1.25")))) {
1751         /*
1752          * These versions apparently have no clue whatever about
1753          * RSA authentication and will panic and die if they see
1754          * an AUTH_RSA message.
1755          */
1756         ssh->remote_bugs |= BUG_CHOKES_ON_RSA;
1757         logevent("We believe remote version can't handle RSA authentication");
1758     }
1759
1760     if (ssh->cfg.sshbug_hmac2 == BUG_ON ||
1761         (ssh->cfg.sshbug_hmac2 == BUG_AUTO &&
1762          (wc_match("2.1.0*", imp) || wc_match("2.0.*", imp) ||
1763           wc_match("2.2.0*", imp) || wc_match("2.3.0*", imp) ||
1764           wc_match("2.1 *", imp)))) {
1765         /*
1766          * These versions have the HMAC bug.
1767          */
1768         ssh->remote_bugs |= BUG_SSH2_HMAC;
1769         logevent("We believe remote version has SSH2 HMAC bug");
1770     }
1771
1772     if (ssh->cfg.sshbug_derivekey2 == BUG_ON ||
1773         (ssh->cfg.sshbug_derivekey2 == BUG_AUTO &&
1774          (wc_match("2.0.0*", imp) || wc_match("2.0.1[01]*", imp) ))) {
1775         /*
1776          * These versions have the key-derivation bug (failing to
1777          * include the literal shared secret in the hashes that
1778          * generate the keys).
1779          */
1780         ssh->remote_bugs |= BUG_SSH2_DERIVEKEY;
1781         logevent("We believe remote version has SSH2 key-derivation bug");
1782     }
1783
1784     if (ssh->cfg.sshbug_rsapad2 == BUG_ON ||
1785         (ssh->cfg.sshbug_rsapad2 == BUG_AUTO &&
1786          (wc_match("OpenSSH_2.[5-9]*", imp) ||
1787           wc_match("OpenSSH_3.[0-2]*", imp)))) {
1788         /*
1789          * These versions have the SSH2 RSA padding bug.
1790          */
1791         ssh->remote_bugs |= BUG_SSH2_RSA_PADDING;
1792         logevent("We believe remote version has SSH2 RSA padding bug");
1793     }
1794
1795     if (ssh->cfg.sshbug_dhgex2 == BUG_ON) {
1796         /*
1797          * User specified the SSH2 DH GEX bug.
1798          */
1799         ssh->remote_bugs |= BUG_SSH2_DH_GEX;
1800         logevent("We believe remote version has SSH2 DH group exchange bug");
1801     }
1802 }
1803
1804 static int do_ssh_init(Ssh ssh, unsigned char c)
1805 {
1806     struct do_ssh_init_state {
1807         int vslen;
1808         char version[10];
1809         char *vstring;
1810         int vstrsize;
1811         int i;
1812         int proto1, proto2;
1813     };
1814     crState(do_ssh_init_state);
1815
1816     crBegin(ssh->do_ssh_init_crstate);
1817
1818     /* Search for the string "SSH-" in the input. */
1819     s->i = 0;
1820     while (1) {
1821         static const int transS[] = { 1, 2, 2, 1 };
1822         static const int transH[] = { 0, 0, 3, 0 };
1823         static const int transminus[] = { 0, 0, 0, -1 };
1824         if (c == 'S')
1825             s->i = transS[s->i];
1826         else if (c == 'H')
1827             s->i = transH[s->i];
1828         else if (c == '-')
1829             s->i = transminus[s->i];
1830         else
1831             s->i = 0;
1832         if (s->i < 0)
1833             break;
1834         crReturn(1);                   /* get another character */
1835     }
1836
1837     s->vstrsize = 16;
1838     s->vstring = smalloc(s->vstrsize);
1839     strcpy(s->vstring, "SSH-");
1840     s->vslen = 4;
1841     s->i = 0;
1842     while (1) {
1843         crReturn(1);                   /* get another char */
1844         if (s->vslen >= s->vstrsize - 1) {
1845             s->vstrsize += 16;
1846             s->vstring = srealloc(s->vstring, s->vstrsize);
1847         }
1848         s->vstring[s->vslen++] = c;
1849         if (s->i >= 0) {
1850             if (c == '-') {
1851                 s->version[s->i] = '\0';
1852                 s->i = -1;
1853             } else if (s->i < sizeof(s->version) - 1)
1854                 s->version[s->i++] = c;
1855         } else if (c == '\012')
1856             break;
1857     }
1858
1859     ssh->agentfwd_enabled = FALSE;
1860     ssh->rdpkt2_state.incoming_sequence = 0;
1861
1862     s->vstring[s->vslen] = 0;
1863     s->vstring[strcspn(s->vstring, "\r\n")] = '\0';/* remove EOL chars */
1864     {
1865         char *vlog;
1866         vlog = smalloc(20 + s->vslen);
1867         sprintf(vlog, "Server version: %s", s->vstring);
1868         logevent(vlog);
1869         sfree(vlog);
1870     }
1871     ssh_detect_bugs(ssh, s->vstring);
1872
1873     /*
1874      * Decide which SSH protocol version to support.
1875      */
1876
1877     /* Anything strictly below "2.0" means protocol 1 is supported. */
1878     s->proto1 = ssh_versioncmp(s->version, "2.0") < 0;
1879     /* Anything greater or equal to "1.99" means protocol 2 is supported. */
1880     s->proto2 = ssh_versioncmp(s->version, "1.99") >= 0;
1881
1882     if (ssh->cfg.sshprot == 0 && !s->proto1) {
1883         bombout((ssh,"SSH protocol version 1 required by user but not provided by server"));
1884         crReturn(0);
1885     }
1886     if (ssh->cfg.sshprot == 3 && !s->proto2) {
1887         bombout((ssh,"SSH protocol version 2 required by user but not provided by server"));
1888         crReturn(0);
1889     }
1890
1891     if (s->proto2 && (ssh->cfg.sshprot >= 2 || !s->proto1)) {
1892         /*
1893          * Use v2 protocol.
1894          */
1895         char verstring[80], vlog[100];
1896         sprintf(verstring, "SSH-2.0-%s", sshver);
1897         SHA_Init(&ssh->exhashbase);
1898         /*
1899          * Hash our version string and their version string.
1900          */
1901         sha_string(&ssh->exhashbase, verstring, strlen(verstring));
1902         sha_string(&ssh->exhashbase, s->vstring, strcspn(s->vstring, "\r\n"));
1903         sprintf(vlog, "We claim version: %s", verstring);
1904         logevent(vlog);
1905         strcat(verstring, "\012");
1906         logevent("Using SSH protocol version 2");
1907         sk_write(ssh->s, verstring, strlen(verstring));
1908         ssh->protocol = ssh2_protocol;
1909         ssh->version = 2;
1910         ssh->s_rdpkt = ssh2_rdpkt;
1911     } else {
1912         /*
1913          * Use v1 protocol.
1914          */
1915         char verstring[80], vlog[100];
1916         sprintf(verstring, "SSH-%s-%s",
1917                 (ssh_versioncmp(s->version, "1.5") <= 0 ? s->version : "1.5"),
1918                 sshver);
1919         sprintf(vlog, "We claim version: %s", verstring);
1920         logevent(vlog);
1921         strcat(verstring, "\012");
1922
1923         logevent("Using SSH protocol version 1");
1924         sk_write(ssh->s, verstring, strlen(verstring));
1925         ssh->protocol = ssh1_protocol;
1926         ssh->version = 1;
1927         ssh->s_rdpkt = ssh1_rdpkt;
1928     }
1929     ssh->state = SSH_STATE_BEFORE_SIZE;
1930
1931     sfree(s->vstring);
1932
1933     crFinish(0);
1934 }
1935
1936 static void ssh_gotdata(Ssh ssh, unsigned char *data, int datalen)
1937 {
1938     crBegin(ssh->ssh_gotdata_crstate);
1939
1940     /*
1941      * To begin with, feed the characters one by one to the
1942      * protocol initialisation / selection function do_ssh_init().
1943      * When that returns 0, we're done with the initial greeting
1944      * exchange and can move on to packet discipline.
1945      */
1946     while (1) {
1947         int ret;                       /* need not be kept across crReturn */
1948         if (datalen == 0)
1949             crReturnV;                 /* more data please */
1950         ret = do_ssh_init(ssh, *data);
1951         data++;
1952         datalen--;
1953         if (ret == 0)
1954             break;
1955     }
1956
1957     /*
1958      * We emerge from that loop when the initial negotiation is
1959      * over and we have selected an s_rdpkt function. Now pass
1960      * everything to s_rdpkt, and then pass the resulting packets
1961      * to the proper protocol handler.
1962      */
1963     if (datalen == 0)
1964         crReturnV;
1965     while (1) {
1966         while (datalen > 0) {
1967             if (ssh->s_rdpkt(ssh, &data, &datalen) == 0) {
1968                 if (ssh->state == SSH_STATE_CLOSED) {
1969                     return;
1970                 }
1971                 ssh->protocol(ssh, NULL, 0, 1);
1972                 if (ssh->state == SSH_STATE_CLOSED) {
1973                     return;
1974                 }
1975             }
1976         }
1977         crReturnV;
1978     }
1979     crFinishV;
1980 }
1981
1982 static int ssh_closing(Plug plug, char *error_msg, int error_code,
1983                        int calling_back)
1984 {
1985     Ssh ssh = (Ssh) plug;
1986     ssh->state = SSH_STATE_CLOSED;
1987     if (ssh->s) {
1988         sk_close(ssh->s);
1989         ssh->s = NULL;
1990     }
1991     if (error_msg) {
1992         /* A socket error has occurred. */
1993         logevent(error_msg);
1994         connection_fatal(ssh->frontend, error_msg);
1995     } else {
1996         /* Otherwise, the remote side closed the connection normally. */
1997     }
1998     return 0;
1999 }
2000
2001 static int ssh_receive(Plug plug, int urgent, char *data, int len)
2002 {
2003     Ssh ssh = (Ssh) plug;
2004     ssh_gotdata(ssh, (unsigned char *)data, len);
2005     if (ssh->state == SSH_STATE_CLOSED) {
2006         if (ssh->s) {
2007             sk_close(ssh->s);
2008             ssh->s = NULL;
2009         }
2010         return 0;
2011     }
2012     return 1;
2013 }
2014
2015 static void ssh_sent(Plug plug, int bufsize)
2016 {
2017     Ssh ssh = (Ssh) plug;
2018     /*
2019      * If the send backlog on the SSH socket itself clears, we
2020      * should unthrottle the whole world if it was throttled.
2021      */
2022     if (bufsize < SSH_MAX_BACKLOG)
2023         ssh_throttle_all(ssh, 0, bufsize);
2024 }
2025
2026 /*
2027  * Connect to specified host and port.
2028  * Returns an error message, or NULL on success.
2029  * Also places the canonical host name into `realhost'. It must be
2030  * freed by the caller.
2031  */
2032 static char *connect_to_host(Ssh ssh, char *host, int port,
2033                              char **realhost, int nodelay)
2034 {
2035     static const struct plug_function_table fn_table = {
2036         ssh_closing,
2037         ssh_receive,
2038         ssh_sent,
2039         NULL
2040     };
2041
2042     SockAddr addr;
2043     char *err;
2044
2045     ssh->savedhost = smalloc(1 + strlen(host));
2046     if (!ssh->savedhost)
2047         fatalbox("Out of memory");
2048     strcpy(ssh->savedhost, host);
2049
2050     if (port < 0)
2051         port = 22;                     /* default ssh port */
2052     ssh->savedport = port;
2053
2054     /*
2055      * Try to find host.
2056      */
2057     logeventf(ssh, "Looking up host \"%s\"", host);
2058     addr = name_lookup(host, port, realhost, &ssh->cfg);
2059     if ((err = sk_addr_error(addr)) != NULL)
2060         return err;
2061
2062     /*
2063      * Open socket.
2064      */
2065     {
2066         char addrbuf[100];
2067         sk_getaddr(addr, addrbuf, 100);
2068         logeventf(ssh, "Connecting to %s port %d", addrbuf, port);
2069     }
2070     ssh->fn = &fn_table;
2071     ssh->s = new_connection(addr, *realhost, port,
2072                             0, 1, nodelay, (Plug) ssh, &ssh->cfg);
2073     if ((err = sk_socket_error(ssh->s)) != NULL) {
2074         ssh->s = NULL;
2075         return err;
2076     }
2077
2078     return NULL;
2079 }
2080
2081 /*
2082  * Throttle or unthrottle the SSH connection.
2083  */
2084 static void ssh1_throttle(Ssh ssh, int adjust)
2085 {
2086     int old_count = ssh->v1_throttle_count;
2087     ssh->v1_throttle_count += adjust;
2088     assert(ssh->v1_throttle_count >= 0);
2089     if (ssh->v1_throttle_count && !old_count) {
2090         sk_set_frozen(ssh->s, 1);
2091     } else if (!ssh->v1_throttle_count && old_count) {
2092         sk_set_frozen(ssh->s, 0);
2093     }
2094 }
2095
2096 /*
2097  * Throttle or unthrottle _all_ local data streams (for when sends
2098  * on the SSH connection itself back up).
2099  */
2100 static void ssh_throttle_all(Ssh ssh, int enable, int bufsize)
2101 {
2102     int i;
2103     struct ssh_channel *c;
2104
2105     if (enable == ssh->throttled_all)
2106         return;
2107     ssh->throttled_all = enable;
2108     ssh->overall_bufsize = bufsize;
2109     if (!ssh->channels)
2110         return;
2111     for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
2112         switch (c->type) {
2113           case CHAN_MAINSESSION:
2114             /*
2115              * This is treated separately, outside the switch.
2116              */
2117             break;
2118           case CHAN_X11:
2119             x11_override_throttle(c->u.x11.s, enable);
2120             break;
2121           case CHAN_AGENT:
2122             /* Agent channels require no buffer management. */
2123             break;
2124           case CHAN_SOCKDATA:
2125             pfd_override_throttle(c->u.x11.s, enable);
2126             break;
2127         }
2128     }
2129 }
2130
2131 /*
2132  * Username and password input, abstracted off into routines
2133  * reusable in several places - even between SSH1 and SSH2.
2134  */
2135
2136 /* Set up a username or password input loop on a given buffer. */
2137 static void setup_userpass_input(Ssh ssh, char *buffer, int buflen, int echo)
2138 {
2139     ssh->userpass_input_buffer = buffer;
2140     ssh->userpass_input_buflen = buflen;
2141     ssh->userpass_input_bufpos = 0;
2142     ssh->userpass_input_echo = echo;
2143 }
2144
2145 /*
2146  * Process some terminal data in the course of username/password
2147  * input. Returns >0 for success (line of input returned in
2148  * buffer), <0 for failure (user hit ^C/^D, bomb out and exit), 0
2149  * for inconclusive (keep waiting for more input please).
2150  */
2151 static int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
2152 {
2153     char c;
2154
2155     while (inlen--) {
2156         switch (c = *in++) {
2157           case 10:
2158           case 13:
2159             ssh->userpass_input_buffer[ssh->userpass_input_bufpos] = 0;
2160             ssh->userpass_input_buffer[ssh->userpass_input_buflen-1] = 0;
2161             return +1;
2162             break;
2163           case 8:
2164           case 127:
2165             if (ssh->userpass_input_bufpos > 0) {
2166                 if (ssh->userpass_input_echo)
2167                     c_write_str(ssh, "\b \b");
2168                 ssh->userpass_input_bufpos--;
2169             }
2170             break;
2171           case 21:
2172           case 27:
2173             while (ssh->userpass_input_bufpos > 0) {
2174                 if (ssh->userpass_input_echo)
2175                     c_write_str(ssh, "\b \b");
2176                 ssh->userpass_input_bufpos--;
2177             }
2178             break;
2179           case 3:
2180           case 4:
2181             return -1;
2182             break;
2183           default:
2184             if (((c >= ' ' && c <= '~') ||
2185                  ((unsigned char) c >= 160))
2186                 && ssh->userpass_input_bufpos < ssh->userpass_input_buflen-1) {
2187                 ssh->userpass_input_buffer[ssh->userpass_input_bufpos++] = c;
2188                 if (ssh->userpass_input_echo)
2189                     c_write(ssh, &c, 1);
2190             }
2191             break;
2192         }
2193     }
2194     return 0;
2195 }
2196
2197 /*
2198  * Handle the key exchange and user authentication phases.
2199  */
2200 static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
2201 {
2202     int i, j;
2203     unsigned char cookie[8];
2204     struct RSAKey servkey, hostkey;
2205     struct MD5Context md5c;
2206     struct do_ssh1_login_state {
2207         int len;
2208         unsigned char *rsabuf, *keystr1, *keystr2;
2209         unsigned long supported_ciphers_mask, supported_auths_mask;
2210         int tried_publickey, tried_agent;
2211         int tis_auth_refused, ccard_auth_refused;
2212         unsigned char session_id[16];
2213         int cipher_type;
2214         char username[100];
2215         void *publickey_blob;
2216         int publickey_bloblen;
2217         char password[100];
2218         char prompt[200];
2219         int pos;
2220         char c;
2221         int pwpkt_type;
2222         unsigned char request[5], *response, *p;
2223         int responselen;
2224         int keyi, nkeys;
2225         int authed;
2226         struct RSAKey key;
2227         Bignum challenge;
2228         char *commentp;
2229         int commentlen;
2230     };
2231     crState(do_ssh1_login_state);
2232
2233     crBegin(ssh->do_ssh1_login_crstate);
2234
2235     if (!ispkt)
2236         crWaitUntil(ispkt);
2237
2238     if (ssh->pktin.type != SSH1_SMSG_PUBLIC_KEY) {
2239         bombout((ssh,"Public key packet not received"));
2240         crReturn(0);
2241     }
2242
2243     logevent("Received public keys");
2244
2245     memcpy(cookie, ssh->pktin.body, 8);
2246
2247     i = makekey(ssh->pktin.body + 8, &servkey, &s->keystr1, 0);
2248     j = makekey(ssh->pktin.body + 8 + i, &hostkey, &s->keystr2, 0);
2249
2250     /*
2251      * Log the host key fingerprint.
2252      */
2253     {
2254         char logmsg[80];
2255         logevent("Host key fingerprint is:");
2256         strcpy(logmsg, "      ");
2257         hostkey.comment = NULL;
2258         rsa_fingerprint(logmsg + strlen(logmsg),
2259                         sizeof(logmsg) - strlen(logmsg), &hostkey);
2260         logevent(logmsg);
2261     }
2262
2263     ssh->v1_remote_protoflags = GET_32BIT(ssh->pktin.body + 8 + i + j);
2264     s->supported_ciphers_mask = GET_32BIT(ssh->pktin.body + 12 + i + j);
2265     s->supported_auths_mask = GET_32BIT(ssh->pktin.body + 16 + i + j);
2266
2267     ssh->v1_local_protoflags =
2268         ssh->v1_remote_protoflags & SSH1_PROTOFLAGS_SUPPORTED;
2269     ssh->v1_local_protoflags |= SSH1_PROTOFLAG_SCREEN_NUMBER;
2270
2271     MD5Init(&md5c);
2272     MD5Update(&md5c, s->keystr2, hostkey.bytes);
2273     MD5Update(&md5c, s->keystr1, servkey.bytes);
2274     MD5Update(&md5c, ssh->pktin.body, 8);
2275     MD5Final(s->session_id, &md5c);
2276
2277     for (i = 0; i < 32; i++)
2278         ssh->session_key[i] = random_byte();
2279
2280     s->len = (hostkey.bytes > servkey.bytes ? hostkey.bytes : servkey.bytes);
2281
2282     s->rsabuf = smalloc(s->len);
2283     if (!s->rsabuf)
2284         fatalbox("Out of memory");
2285
2286     /*
2287      * Verify the host key.
2288      */
2289     {
2290         /*
2291          * First format the key into a string.
2292          */
2293         int len = rsastr_len(&hostkey);
2294         char fingerprint[100];
2295         char *keystr = smalloc(len);
2296         if (!keystr)
2297             fatalbox("Out of memory");
2298         rsastr_fmt(keystr, &hostkey);
2299         rsa_fingerprint(fingerprint, sizeof(fingerprint), &hostkey);
2300         verify_ssh_host_key(ssh->frontend,
2301                             ssh->savedhost, ssh->savedport, "rsa", keystr,
2302                             fingerprint);
2303         sfree(keystr);
2304     }
2305
2306     for (i = 0; i < 32; i++) {
2307         s->rsabuf[i] = ssh->session_key[i];
2308         if (i < 16)
2309             s->rsabuf[i] ^= s->session_id[i];
2310     }
2311
2312     if (hostkey.bytes > servkey.bytes) {
2313         rsaencrypt(s->rsabuf, 32, &servkey);
2314         rsaencrypt(s->rsabuf, servkey.bytes, &hostkey);
2315     } else {
2316         rsaencrypt(s->rsabuf, 32, &hostkey);
2317         rsaencrypt(s->rsabuf, hostkey.bytes, &servkey);
2318     }
2319
2320     logevent("Encrypted session key");
2321
2322     {
2323         int cipher_chosen = 0, warn = 0;
2324         char *cipher_string = NULL;
2325         int i;
2326         for (i = 0; !cipher_chosen && i < CIPHER_MAX; i++) {
2327             int next_cipher = ssh->cfg.ssh_cipherlist[i];
2328             if (next_cipher == CIPHER_WARN) {
2329                 /* If/when we choose a cipher, warn about it */
2330                 warn = 1;
2331             } else if (next_cipher == CIPHER_AES) {
2332                 /* XXX Probably don't need to mention this. */
2333                 logevent("AES not supported in SSH1, skipping");
2334             } else {
2335                 switch (next_cipher) {
2336                   case CIPHER_3DES:     s->cipher_type = SSH_CIPHER_3DES;
2337                                         cipher_string = "3DES"; break;
2338                   case CIPHER_BLOWFISH: s->cipher_type = SSH_CIPHER_BLOWFISH;
2339                                         cipher_string = "Blowfish"; break;
2340                   case CIPHER_DES:      s->cipher_type = SSH_CIPHER_DES;
2341                                         cipher_string = "single-DES"; break;
2342                 }
2343                 if (s->supported_ciphers_mask & (1 << s->cipher_type))
2344                     cipher_chosen = 1;
2345             }
2346         }
2347         if (!cipher_chosen) {
2348             if ((s->supported_ciphers_mask & (1 << SSH_CIPHER_3DES)) == 0)
2349                 bombout((ssh,"Server violates SSH 1 protocol by not "
2350                          "supporting 3DES encryption"));
2351             else
2352                 /* shouldn't happen */
2353                 bombout((ssh,"No supported ciphers found"));
2354             crReturn(0);
2355         }
2356
2357         /* Warn about chosen cipher if necessary. */
2358         if (warn)
2359             askcipher(ssh->frontend, cipher_string, 0);
2360     }
2361
2362     switch (s->cipher_type) {
2363       case SSH_CIPHER_3DES:
2364         logevent("Using 3DES encryption");
2365         break;
2366       case SSH_CIPHER_DES:
2367         logevent("Using single-DES encryption");
2368         break;
2369       case SSH_CIPHER_BLOWFISH:
2370         logevent("Using Blowfish encryption");
2371         break;
2372     }
2373
2374     send_packet(ssh, SSH1_CMSG_SESSION_KEY,
2375                 PKT_CHAR, s->cipher_type,
2376                 PKT_DATA, cookie, 8,
2377                 PKT_CHAR, (s->len * 8) >> 8, PKT_CHAR, (s->len * 8) & 0xFF,
2378                 PKT_DATA, s->rsabuf, s->len,
2379                 PKT_INT, ssh->v1_local_protoflags, PKT_END);
2380
2381     logevent("Trying to enable encryption...");
2382
2383     sfree(s->rsabuf);
2384
2385     ssh->cipher = (s->cipher_type == SSH_CIPHER_BLOWFISH ? &ssh_blowfish_ssh1 :
2386                    s->cipher_type == SSH_CIPHER_DES ? &ssh_des :
2387                    &ssh_3des);
2388     ssh->v1_cipher_ctx = ssh->cipher->make_context();
2389     ssh->cipher->sesskey(ssh->v1_cipher_ctx, ssh->session_key);
2390     logeventf(ssh, "Initialised %s encryption", ssh->cipher->text_name);
2391
2392     ssh->crcda_ctx = crcda_make_context();
2393     logevent("Installing CRC compensation attack detector");
2394
2395     crWaitUntil(ispkt);
2396
2397     if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
2398         bombout((ssh,"Encryption not successfully enabled"));
2399         crReturn(0);
2400     }
2401
2402     logevent("Successfully started encryption");
2403
2404     fflush(stdout);
2405     {
2406         if ((flags & FLAG_INTERACTIVE) && !*ssh->cfg.username) {
2407             if (ssh_get_line && !ssh_getline_pw_only) {
2408                 if (!ssh_get_line("login as: ",
2409                                   s->username, sizeof(s->username), FALSE)) {
2410                     /*
2411                      * get_line failed to get a username.
2412                      * Terminate.
2413                      */
2414                     logevent("No username provided. Abandoning session.");
2415                     ssh->state = SSH_STATE_CLOSED;
2416                     crReturn(1);
2417                 }
2418             } else {
2419                 int ret;               /* need not be kept over crReturn */
2420                 c_write_str(ssh, "login as: ");
2421                 ssh->send_ok = 1;
2422
2423                 setup_userpass_input(ssh, s->username, sizeof(s->username), 1);
2424                 do {
2425                     crWaitUntil(!ispkt);
2426                     ret = process_userpass_input(ssh, in, inlen);
2427                 } while (ret == 0);
2428                 if (ret < 0)
2429                     cleanup_exit(0);
2430                 c_write_str(ssh, "\r\n");
2431             }
2432         } else {
2433             strncpy(s->username, ssh->cfg.username, sizeof(s->username));
2434             s->username[sizeof(s->username)-1] = '\0';
2435         }
2436
2437         send_packet(ssh, SSH1_CMSG_USER, PKT_STR, s->username, PKT_END);
2438         {
2439             char userlog[22 + sizeof(s->username)];
2440             sprintf(userlog, "Sent username \"%s\"", s->username);
2441             logevent(userlog);
2442             if (flags & FLAG_INTERACTIVE &&
2443                 (!((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)))) {
2444                 strcat(userlog, "\r\n");
2445                 c_write_str(ssh, userlog);
2446             }
2447         }
2448     }
2449
2450     crWaitUntil(ispkt);
2451
2452     if ((ssh->remote_bugs & BUG_CHOKES_ON_RSA)) {
2453         /* We must not attempt PK auth. Pretend we've already tried it. */
2454         s->tried_publickey = s->tried_agent = 1;
2455     } else {
2456         s->tried_publickey = s->tried_agent = 0;
2457     }
2458     s->tis_auth_refused = s->ccard_auth_refused = 0;
2459     /* Load the public half of ssh->cfg.keyfile so we notice if it's in Pageant */
2460     if (*ssh->cfg.keyfile) {
2461         if (!rsakey_pubblob(ssh->cfg.keyfile,
2462                             &s->publickey_blob, &s->publickey_bloblen))
2463             s->publickey_blob = NULL;
2464     } else
2465         s->publickey_blob = NULL;
2466
2467     while (ssh->pktin.type == SSH1_SMSG_FAILURE) {
2468         s->pwpkt_type = SSH1_CMSG_AUTH_PASSWORD;
2469
2470         if (agent_exists() && !s->tried_agent) {
2471             /*
2472              * Attempt RSA authentication using Pageant.
2473              */
2474             void *r;
2475
2476             s->authed = FALSE;
2477             s->tried_agent = 1;
2478             logevent("Pageant is running. Requesting keys.");
2479
2480             /* Request the keys held by the agent. */
2481             PUT_32BIT(s->request, 1);
2482             s->request[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES;
2483             agent_query(s->request, 5, &r, &s->responselen);
2484             s->response = (unsigned char *) r;
2485             if (s->response && s->responselen >= 5 &&
2486                 s->response[4] == SSH1_AGENT_RSA_IDENTITIES_ANSWER) {
2487                 s->p = s->response + 5;
2488                 s->nkeys = GET_32BIT(s->p);
2489                 s->p += 4;
2490                 {
2491                     char buf[64];
2492                     sprintf(buf, "Pageant has %d SSH1 keys", s->nkeys);
2493                     logevent(buf);
2494                 }
2495                 for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) {
2496                     {
2497                         char buf[64];
2498                         sprintf(buf, "Trying Pageant key #%d", s->keyi);
2499                         logevent(buf);
2500                     }
2501                     if (s->publickey_blob &&
2502                         !memcmp(s->p, s->publickey_blob,
2503                                 s->publickey_bloblen)) {
2504                         logevent("This key matches configured key file");
2505                         s->tried_publickey = 1;
2506                     }
2507                     s->p += 4;
2508                     s->p += ssh1_read_bignum(s->p, &s->key.exponent);
2509                     s->p += ssh1_read_bignum(s->p, &s->key.modulus);
2510                     s->commentlen = GET_32BIT(s->p);
2511                     s->p += 4;
2512                     s->commentp = (char *)s->p;
2513                     s->p += s->commentlen;
2514                     send_packet(ssh, SSH1_CMSG_AUTH_RSA,
2515                                 PKT_BIGNUM, s->key.modulus, PKT_END);
2516                     crWaitUntil(ispkt);
2517                     if (ssh->pktin.type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
2518                         logevent("Key refused");
2519                         continue;
2520                     }
2521                     logevent("Received RSA challenge");
2522                     ssh1_read_bignum(ssh->pktin.body, &s->challenge);
2523                     {
2524                         char *agentreq, *q, *ret;
2525                         void *vret;
2526                         int len, retlen;
2527                         len = 1 + 4;   /* message type, bit count */
2528                         len += ssh1_bignum_length(s->key.exponent);
2529                         len += ssh1_bignum_length(s->key.modulus);
2530                         len += ssh1_bignum_length(s->challenge);
2531                         len += 16;     /* session id */
2532                         len += 4;      /* response format */
2533                         agentreq = smalloc(4 + len);
2534                         PUT_32BIT(agentreq, len);
2535                         q = agentreq + 4;
2536                         *q++ = SSH1_AGENTC_RSA_CHALLENGE;
2537                         PUT_32BIT(q, bignum_bitcount(s->key.modulus));
2538                         q += 4;
2539                         q += ssh1_write_bignum(q, s->key.exponent);
2540                         q += ssh1_write_bignum(q, s->key.modulus);
2541                         q += ssh1_write_bignum(q, s->challenge);
2542                         memcpy(q, s->session_id, 16);
2543                         q += 16;
2544                         PUT_32BIT(q, 1);        /* response format */
2545                         agent_query(agentreq, len + 4, &vret, &retlen);
2546                         ret = vret;
2547                         sfree(agentreq);
2548                         if (ret) {
2549                             if (ret[4] == SSH1_AGENT_RSA_RESPONSE) {
2550                                 logevent("Sending Pageant's response");
2551                                 send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
2552                                             PKT_DATA, ret + 5, 16,
2553                                             PKT_END);
2554                                 sfree(ret);
2555                                 crWaitUntil(ispkt);
2556                                 if (ssh->pktin.type == SSH1_SMSG_SUCCESS) {
2557                                     logevent
2558                                         ("Pageant's response accepted");
2559                                     if (flags & FLAG_VERBOSE) {
2560                                         c_write_str(ssh, "Authenticated using"
2561                                                     " RSA key \"");
2562                                         c_write(ssh, s->commentp,
2563                                                 s->commentlen);
2564                                         c_write_str(ssh, "\" from agent\r\n");
2565                                     }
2566                                     s->authed = TRUE;
2567                                 } else
2568                                     logevent
2569                                         ("Pageant's response not accepted");
2570                             } else {
2571                                 logevent
2572                                     ("Pageant failed to answer challenge");
2573                                 sfree(ret);
2574                             }
2575                         } else {
2576                             logevent("No reply received from Pageant");
2577                         }
2578                     }
2579                     freebn(s->key.exponent);
2580                     freebn(s->key.modulus);
2581                     freebn(s->challenge);
2582                     if (s->authed)
2583                         break;
2584                 }
2585             }
2586             if (s->authed)
2587                 break;
2588         }
2589         if (*ssh->cfg.keyfile && !s->tried_publickey)
2590             s->pwpkt_type = SSH1_CMSG_AUTH_RSA;
2591
2592         if (ssh->cfg.try_tis_auth &&
2593             (s->supported_auths_mask & (1 << SSH1_AUTH_TIS)) &&
2594             !s->tis_auth_refused) {
2595             s->pwpkt_type = SSH1_CMSG_AUTH_TIS_RESPONSE;
2596             logevent("Requested TIS authentication");
2597             send_packet(ssh, SSH1_CMSG_AUTH_TIS, PKT_END);
2598             crWaitUntil(ispkt);
2599             if (ssh->pktin.type != SSH1_SMSG_AUTH_TIS_CHALLENGE) {
2600                 logevent("TIS authentication declined");
2601                 if (flags & FLAG_INTERACTIVE)
2602                     c_write_str(ssh, "TIS authentication refused.\r\n");
2603                 s->tis_auth_refused = 1;
2604                 continue;
2605             } else {
2606                 int challengelen = GET_32BIT(ssh->pktin.body);
2607                 logevent("Received TIS challenge");
2608                 if (challengelen > sizeof(s->prompt) - 1)
2609                     challengelen = sizeof(s->prompt) - 1;/* prevent overrun */
2610                 memcpy(s->prompt, ssh->pktin.body + 4, challengelen);
2611                 /* Prompt heuristic comes from OpenSSH */
2612                 strncpy(s->prompt + challengelen,
2613                         memchr(s->prompt, '\n', challengelen) ?
2614                         "": "\r\nResponse: ",
2615                         (sizeof s->prompt) - challengelen);
2616                 s->prompt[(sizeof s->prompt) - 1] = '\0';
2617             }
2618         }
2619         if (ssh->cfg.try_tis_auth &&
2620             (s->supported_auths_mask & (1 << SSH1_AUTH_CCARD)) &&
2621             !s->ccard_auth_refused) {
2622             s->pwpkt_type = SSH1_CMSG_AUTH_CCARD_RESPONSE;
2623             logevent("Requested CryptoCard authentication");
2624             send_packet(ssh, SSH1_CMSG_AUTH_CCARD, PKT_END);
2625             crWaitUntil(ispkt);
2626             if (ssh->pktin.type != SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
2627                 logevent("CryptoCard authentication declined");
2628                 c_write_str(ssh, "CryptoCard authentication refused.\r\n");
2629                 s->ccard_auth_refused = 1;
2630                 continue;
2631             } else {
2632                 int challengelen = GET_32BIT(ssh->pktin.body);
2633                 logevent("Received CryptoCard challenge");
2634                 if (challengelen > sizeof(s->prompt) - 1)
2635                     challengelen = sizeof(s->prompt) - 1;/* prevent overrun */
2636                 memcpy(s->prompt, ssh->pktin.body + 4, challengelen);
2637                 strncpy(s->prompt + challengelen,
2638                         memchr(s->prompt, '\n', challengelen) ?
2639                         "" : "\r\nResponse: ",
2640                         sizeof(s->prompt) - challengelen);
2641                 s->prompt[sizeof(s->prompt) - 1] = '\0';
2642             }
2643         }
2644         if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
2645             sprintf(s->prompt, "%.90s@%.90s's password: ",
2646                     s->username, ssh->savedhost);
2647         }
2648         if (s->pwpkt_type == SSH1_CMSG_AUTH_RSA) {
2649             char *comment = NULL;
2650             int type;
2651             char msgbuf[256];
2652             if (flags & FLAG_VERBOSE)
2653                 c_write_str(ssh, "Trying public key authentication.\r\n");
2654             logeventf(ssh, "Trying public key \"%s\"", ssh->cfg.keyfile);
2655             type = key_type(ssh->cfg.keyfile);
2656             if (type != SSH_KEYTYPE_SSH1) {
2657                 sprintf(msgbuf, "Key is of wrong type (%s)",
2658                         key_type_to_str(type));
2659                 logevent(msgbuf);
2660                 c_write_str(ssh, msgbuf);
2661                 c_write_str(ssh, "\r\n");
2662                 s->tried_publickey = 1;
2663                 continue;
2664             }
2665             if (!rsakey_encrypted(ssh->cfg.keyfile, &comment)) {
2666                 if (flags & FLAG_VERBOSE)
2667                     c_write_str(ssh, "No passphrase required.\r\n");
2668                 goto tryauth;
2669             }
2670             sprintf(s->prompt, "Passphrase for key \"%.100s\": ", comment);
2671             sfree(comment);
2672         }
2673
2674         /*
2675          * Show password prompt, having first obtained it via a TIS
2676          * or CryptoCard exchange if we're doing TIS or CryptoCard
2677          * authentication.
2678          */
2679         if (ssh_get_line) {
2680             if (!ssh_get_line(s->prompt, s->password,
2681                               sizeof(s->password), TRUE)) {
2682                 /*
2683                  * get_line failed to get a password (for example
2684                  * because one was supplied on the command line
2685                  * which has already failed to work). Terminate.
2686                  */
2687                 send_packet(ssh, SSH1_MSG_DISCONNECT,
2688                             PKT_STR, "No more passwords available to try",
2689                             PKT_END);
2690                 logevent("Unable to authenticate");
2691                 connection_fatal(ssh->frontend, "Unable to authenticate");
2692                 ssh->state = SSH_STATE_CLOSED;
2693                 crReturn(1);
2694             }
2695         } else {
2696             /* Prompt may have come from server. We've munged it a bit, so
2697              * we know it to be zero-terminated at least once. */
2698             int ret;                   /* need not be saved over crReturn */
2699             c_write_untrusted(ssh, s->prompt, strlen(s->prompt));
2700             s->pos = 0;
2701
2702             setup_userpass_input(ssh, s->password, sizeof(s->password), 0);
2703             do {
2704                 crWaitUntil(!ispkt);
2705                 ret = process_userpass_input(ssh, in, inlen);
2706             } while (ret == 0);
2707             if (ret < 0)
2708                 cleanup_exit(0);
2709             c_write_str(ssh, "\r\n");
2710         }
2711
2712       tryauth:
2713         if (s->pwpkt_type == SSH1_CMSG_AUTH_RSA) {
2714             /*
2715              * Try public key authentication with the specified
2716              * key file.
2717              */
2718             s->tried_publickey = 1;
2719
2720             {
2721                 int ret = loadrsakey(ssh->cfg.keyfile, &s->key, s->password);
2722                 if (ret == 0) {
2723                     c_write_str(ssh, "Couldn't load private key from ");
2724                     c_write_str(ssh, ssh->cfg.keyfile);
2725                     c_write_str(ssh, ".\r\n");
2726                     continue;          /* go and try password */
2727                 }
2728                 if (ret == -1) {
2729                     c_write_str(ssh, "Wrong passphrase.\r\n");
2730                     s->tried_publickey = 0;
2731                     continue;          /* try again */
2732                 }
2733             }
2734
2735             /*
2736              * Send a public key attempt.
2737              */
2738             send_packet(ssh, SSH1_CMSG_AUTH_RSA,
2739                         PKT_BIGNUM, s->key.modulus, PKT_END);
2740
2741             crWaitUntil(ispkt);
2742             if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
2743                 c_write_str(ssh, "Server refused our public key.\r\n");
2744                 continue;              /* go and try password */
2745             }
2746             if (ssh->pktin.type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
2747                 bombout((ssh,"Bizarre response to offer of public key"));
2748                 crReturn(0);
2749             }
2750
2751             {
2752                 int i;
2753                 unsigned char buffer[32];
2754                 Bignum challenge, response;
2755
2756                 ssh1_read_bignum(ssh->pktin.body, &challenge);
2757                 response = rsadecrypt(challenge, &s->key);
2758                 freebn(s->key.private_exponent);/* burn the evidence */
2759
2760                 for (i = 0; i < 32; i++) {
2761                     buffer[i] = bignum_byte(response, 31 - i);
2762                 }
2763
2764                 MD5Init(&md5c);
2765                 MD5Update(&md5c, buffer, 32);
2766                 MD5Update(&md5c, s->session_id, 16);
2767                 MD5Final(buffer, &md5c);
2768
2769                 send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
2770                             PKT_DATA, buffer, 16, PKT_END);
2771
2772                 freebn(challenge);
2773                 freebn(response);
2774             }
2775
2776             crWaitUntil(ispkt);
2777             if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
2778                 if (flags & FLAG_VERBOSE)
2779                     c_write_str(ssh, "Failed to authenticate with"
2780                                 " our public key.\r\n");
2781                 continue;              /* go and try password */
2782             } else if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
2783                 bombout((ssh,"Bizarre response to RSA authentication response"));
2784                 crReturn(0);
2785             }
2786
2787             break;                     /* we're through! */
2788         } else {
2789             if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
2790                 /*
2791                  * Defence against traffic analysis: we send a
2792                  * whole bunch of packets containing strings of
2793                  * different lengths. One of these strings is the
2794                  * password, in a SSH1_CMSG_AUTH_PASSWORD packet.
2795                  * The others are all random data in
2796                  * SSH1_MSG_IGNORE packets. This way a passive
2797                  * listener can't tell which is the password, and
2798                  * hence can't deduce the password length.
2799                  *
2800                  * Anybody with a password length greater than 16
2801                  * bytes is going to have enough entropy in their
2802                  * password that a listener won't find it _that_
2803                  * much help to know how long it is. So what we'll
2804                  * do is:
2805                  *
2806                  *  - if password length < 16, we send 15 packets
2807                  *    containing string lengths 1 through 15
2808                  *
2809                  *  - otherwise, we let N be the nearest multiple
2810                  *    of 8 below the password length, and send 8
2811                  *    packets containing string lengths N through
2812                  *    N+7. This won't obscure the order of
2813                  *    magnitude of the password length, but it will
2814                  *    introduce a bit of extra uncertainty.
2815                  *
2816                  * A few servers (the old 1.2.18 through 1.2.22)
2817                  * can't deal with SSH1_MSG_IGNORE. For these
2818                  * servers, we need an alternative defence. We make
2819                  * use of the fact that the password is interpreted
2820                  * as a C string: so we can append a NUL, then some
2821                  * random data.
2822                  *
2823                  * One server (a Cisco one) can deal with neither
2824                  * SSH1_MSG_IGNORE _nor_ a padded password string.
2825                  * For this server we are left with no defences
2826                  * against password length sniffing.
2827                  */
2828                 if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE)) {
2829                     /*
2830                      * The server can deal with SSH1_MSG_IGNORE, so
2831                      * we can use the primary defence.
2832                      */
2833                     int bottom, top, pwlen, i;
2834                     char *randomstr;
2835
2836                     pwlen = strlen(s->password);
2837                     if (pwlen < 16) {
2838                         bottom = 0;    /* zero length passwords are OK! :-) */
2839                         top = 15;
2840                     } else {
2841                         bottom = pwlen & ~7;
2842                         top = bottom + 7;
2843                     }
2844
2845                     assert(pwlen >= bottom && pwlen <= top);
2846
2847                     randomstr = smalloc(top + 1);
2848
2849                     for (i = bottom; i <= top; i++) {
2850                         if (i == pwlen)
2851                             defer_packet(ssh, s->pwpkt_type,
2852                                          PKT_STR, s->password, PKT_END);
2853                         else {
2854                             for (j = 0; j < i; j++) {
2855                                 do {
2856                                     randomstr[j] = random_byte();
2857                                 } while (randomstr[j] == '\0');
2858                             }
2859                             randomstr[i] = '\0';
2860                             defer_packet(ssh, SSH1_MSG_IGNORE,
2861                                          PKT_STR, randomstr, PKT_END);
2862                         }
2863                     }
2864                     logevent("Sending password with camouflage packets");
2865                     ssh_pkt_defersend(ssh);
2866                 }
2867                 else if (!(ssh->remote_bugs & BUG_NEEDS_SSH1_PLAIN_PASSWORD)) {
2868                     /*
2869                      * The server can't deal with SSH1_MSG_IGNORE
2870                      * but can deal with padded passwords, so we
2871                      * can use the secondary defence.
2872                      */
2873                     char string[64];
2874                     char *ss;
2875                     int len;
2876
2877                     len = strlen(s->password);
2878                     if (len < sizeof(string)) {
2879                         ss = string;
2880                         strcpy(string, s->password);
2881                         len++;         /* cover the zero byte */
2882                         while (len < sizeof(string)) {
2883                             string[len++] = (char) random_byte();
2884                         }
2885                     } else {
2886                         ss = s->password;
2887                     }
2888                     logevent("Sending length-padded password");
2889                     send_packet(ssh, s->pwpkt_type, PKT_INT, len,
2890                                 PKT_DATA, ss, len, PKT_END);
2891                 } else {
2892                     /*
2893                      * The server has _both_
2894                      * BUG_CHOKES_ON_SSH1_IGNORE and
2895                      * BUG_NEEDS_SSH1_PLAIN_PASSWORD. There is
2896                      * therefore nothing we can do.
2897                      */
2898                     int len;
2899                     len = strlen(s->password);
2900                     logevent("Sending unpadded password");
2901                     send_packet(ssh, s->pwpkt_type, PKT_INT, len,
2902                                 PKT_DATA, s->password, len, PKT_END);
2903                 }
2904             } else {
2905                 send_packet(ssh, s->pwpkt_type, PKT_STR, s->password, PKT_END);
2906             }
2907         }
2908         logevent("Sent password");
2909         memset(s->password, 0, strlen(s->password));
2910         crWaitUntil(ispkt);
2911         if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
2912             if (flags & FLAG_VERBOSE)
2913                 c_write_str(ssh, "Access denied\r\n");
2914             logevent("Authentication refused");
2915         } else if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
2916             bombout((ssh,"Strange packet received, type %d", ssh->pktin.type));
2917             crReturn(0);
2918         }
2919     }
2920
2921     logevent("Authentication successful");
2922
2923     crFinish(1);
2924 }
2925
2926 void sshfwd_close(struct ssh_channel *c)
2927 {
2928     Ssh ssh = c->ssh;
2929
2930     if (c && !c->closes) {
2931         /*
2932          * If the channel's remoteid is -1, we have sent
2933          * CHANNEL_OPEN for this channel, but it hasn't even been
2934          * acknowledged by the server. So we must set a close flag
2935          * on it now, and then when the server acks the channel
2936          * open, we can close it then.
2937          */
2938         if (((int)c->remoteid) != -1) {
2939             if (ssh->version == 1) {
2940                 send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE, PKT_INT, c->remoteid,
2941                             PKT_END);
2942             } else {
2943                 ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_CLOSE);
2944                 ssh2_pkt_adduint32(ssh, c->remoteid);
2945                 ssh2_pkt_send(ssh);
2946             }
2947         }
2948         c->closes = 1;                 /* sent MSG_CLOSE */
2949         if (c->type == CHAN_X11) {
2950             c->u.x11.s = NULL;
2951             logevent("Forwarded X11 connection terminated");
2952         } else if (c->type == CHAN_SOCKDATA ||
2953                    c->type == CHAN_SOCKDATA_DORMANT) {
2954             c->u.pfd.s = NULL;
2955             logevent("Forwarded port closed");
2956         }
2957     }
2958 }
2959
2960 int sshfwd_write(struct ssh_channel *c, char *buf, int len)
2961 {
2962     Ssh ssh = c->ssh;
2963
2964     if (ssh->version == 1) {
2965         send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
2966                     PKT_INT, c->remoteid,
2967                     PKT_INT, len, PKT_DATA, buf, len, PKT_END);
2968         /*
2969          * In SSH1 we can return 0 here - implying that forwarded
2970          * connections are never individually throttled - because
2971          * the only circumstance that can cause throttling will be
2972          * the whole SSH connection backing up, in which case
2973          * _everything_ will be throttled as a whole.
2974          */
2975         return 0;
2976     } else {
2977         ssh2_add_channel_data(c, buf, len);
2978         return ssh2_try_send(c);
2979     }
2980 }
2981
2982 void sshfwd_unthrottle(struct ssh_channel *c, int bufsize)
2983 {
2984     Ssh ssh = c->ssh;
2985
2986     if (ssh->version == 1) {
2987         if (c->v.v1.throttling && bufsize < SSH1_BUFFER_LIMIT) {
2988             c->v.v1.throttling = 0;
2989             ssh1_throttle(ssh, -1);
2990         }
2991     } else {
2992         ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
2993     }
2994 }
2995
2996 static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
2997 {
2998     crBegin(ssh->ssh1_protocol_crstate);
2999
3000     random_init();
3001
3002     while (!do_ssh1_login(ssh, in, inlen, ispkt)) {
3003         crReturnV;
3004     }
3005     if (ssh->state == SSH_STATE_CLOSED)
3006         crReturnV;
3007
3008     if (ssh->cfg.agentfwd && agent_exists()) {
3009         logevent("Requesting agent forwarding");
3010         send_packet(ssh, SSH1_CMSG_AGENT_REQUEST_FORWARDING, PKT_END);
3011         do {
3012             crReturnV;
3013         } while (!ispkt);
3014         if (ssh->pktin.type != SSH1_SMSG_SUCCESS
3015             && ssh->pktin.type != SSH1_SMSG_FAILURE) {
3016             bombout((ssh,"Protocol confusion"));
3017             crReturnV;
3018         } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
3019             logevent("Agent forwarding refused");
3020         } else {
3021             logevent("Agent forwarding enabled");
3022             ssh->agentfwd_enabled = TRUE;
3023         }
3024     }
3025
3026     if (ssh->cfg.x11_forward) {
3027         char proto[20], data[64];
3028         logevent("Requesting X11 forwarding");
3029         ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
3030                                        data, sizeof(data), ssh->cfg.x11_auth);
3031         x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display);
3032         if (ssh->v1_local_protoflags & SSH1_PROTOFLAG_SCREEN_NUMBER) {
3033             send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
3034                         PKT_STR, proto, PKT_STR, data,
3035                         PKT_INT, x11_get_screen_number(ssh->cfg.x11_display),
3036                         PKT_END);
3037         } else {
3038             send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
3039                         PKT_STR, proto, PKT_STR, data, PKT_END);
3040         }
3041         do {
3042             crReturnV;
3043         } while (!ispkt);
3044         if (ssh->pktin.type != SSH1_SMSG_SUCCESS
3045             && ssh->pktin.type != SSH1_SMSG_FAILURE) {
3046             bombout((ssh,"Protocol confusion"));
3047             crReturnV;
3048         } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
3049             logevent("X11 forwarding refused");
3050         } else {
3051             logevent("X11 forwarding enabled");
3052             ssh->X11_fwd_enabled = TRUE;
3053         }
3054     }
3055
3056     {
3057         char type;
3058         int n;
3059         int sport,dport,sserv,dserv;
3060         char sports[256], dports[256], saddr[256], host[256];
3061
3062         ssh->rportfwds = newtree234(ssh_rportcmp_ssh1);
3063         /* Add port forwardings. */
3064         ssh->portfwd_strptr = ssh->cfg.portfwd;
3065         while (*ssh->portfwd_strptr) {
3066             type = *ssh->portfwd_strptr++;
3067             saddr[0] = '\0';
3068             n = 0;
3069             while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != '\t') {
3070                 if (*ssh->portfwd_strptr == ':') {
3071                     /*
3072                      * We've seen a colon in the middle of the
3073                      * source port number. This means that
3074                      * everything we've seen until now is the
3075                      * source _address_, so we'll move it into
3076                      * saddr and start sports from the beginning
3077                      * again.
3078                      */
3079                     ssh->portfwd_strptr++;
3080                     sports[n] = '\0';
3081                     strcpy(saddr, sports);
3082                     n = 0;
3083                 }
3084                 if (n < 255) sports[n++] = *ssh->portfwd_strptr++;
3085             }
3086             sports[n] = 0;
3087             if (*ssh->portfwd_strptr == '\t')
3088                 ssh->portfwd_strptr++;
3089             n = 0;
3090             while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != ':') {
3091                 if (n < 255) host[n++] = *ssh->portfwd_strptr++;
3092             }
3093             host[n] = 0;
3094             if (*ssh->portfwd_strptr == ':')
3095                 ssh->portfwd_strptr++;
3096             n = 0;
3097             while (*ssh->portfwd_strptr) {
3098                 if (n < 255) dports[n++] = *ssh->portfwd_strptr++;
3099             }
3100             dports[n] = 0;
3101             ssh->portfwd_strptr++;
3102             dport = atoi(dports);
3103             dserv = 0;
3104             if (dport == 0) {
3105                 dserv = 1;
3106                 dport = net_service_lookup(dports);
3107                 if (!dport) {
3108                     logeventf(ssh, "Service lookup failed for"
3109                               " destination port \"%s\"", dports);
3110                 }
3111             }
3112             sport = atoi(sports);
3113             sserv = 0;
3114             if (sport == 0) {
3115                 sserv = 1;
3116                 sport = net_service_lookup(sports);
3117                 if (!sport) {
3118                     logeventf(ssh, "Service lookup failed for source"
3119                               " port \"%s\"", sports);
3120                 }
3121             }
3122             if (sport && dport) {
3123                 if (type == 'L') {
3124                     pfd_addforward(host, dport, *saddr ? saddr : NULL,
3125                                    sport, ssh, &ssh->cfg);
3126                     logeventf(ssh, "Local port %.*s%.*s%.*s%.*s%d%.*s"
3127                               " forwarding to %s:%.*s%.*s%d%.*s",
3128                               (int)(*saddr?strlen(saddr):0), *saddr?saddr:NULL,
3129                               (int)(*saddr?1:0), ":",
3130                               (int)(sserv ? strlen(sports) : 0), sports,
3131                               sserv, "(", sport, sserv, ")",
3132                               host,
3133                               (int)(dserv ? strlen(dports) : 0), dports,
3134                               dserv, "(", dport, dserv, ")");
3135                 } else {
3136                     struct ssh_rportfwd *pf;
3137                     pf = smalloc(sizeof(*pf));
3138                     strcpy(pf->dhost, host);
3139                     pf->dport = dport;
3140                     if (saddr) {
3141                         logeventf(ssh,
3142                                   "SSH1 cannot handle source address spec \"%s:%d\"; ignoring",
3143                                   saddr, sport);
3144                     }
3145                     if (add234(ssh->rportfwds, pf) != pf) {
3146                         logeventf(ssh,
3147                                   "Duplicate remote port forwarding to %s:%d",
3148                                   host, dport);
3149                         sfree(pf);
3150                     } else {
3151                         logeventf(ssh, "Requesting remote port %.*s%.*s%d%.*s"
3152                                   " forward to %s:%.*s%.*s%d%.*s",
3153                                   (int)(sserv ? strlen(sports) : 0), sports,
3154                                   sserv, "(", sport, sserv, ")",
3155                                   host,
3156                                   (int)(dserv ? strlen(dports) : 0), dports,
3157                                   dserv, "(", dport, dserv, ")");
3158                         send_packet(ssh, SSH1_CMSG_PORT_FORWARD_REQUEST,
3159                                     PKT_INT, sport,
3160                                     PKT_STR, host,
3161                                     PKT_INT, dport,
3162                                     PKT_END);
3163                         do {
3164                             crReturnV;
3165                         } while (!ispkt);
3166                         if (ssh->pktin.type != SSH1_SMSG_SUCCESS
3167                             && ssh->pktin.type != SSH1_SMSG_FAILURE) {
3168                             bombout((ssh,"Protocol confusion"));
3169                             crReturnV;
3170                         } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
3171                             c_write_str(ssh, "Server refused port"
3172                                         " forwarding\r\n");
3173                         }
3174                         logevent("Remote port forwarding enabled");
3175                     }
3176                 }
3177             }
3178         }
3179     }
3180
3181     if (!ssh->cfg.nopty) {
3182         send_packet(ssh, SSH1_CMSG_REQUEST_PTY,
3183                     PKT_STR, ssh->cfg.termtype,
3184                     PKT_INT, ssh->term_height,
3185                     PKT_INT, ssh->term_width,
3186                     PKT_INT, 0, PKT_INT, 0, PKT_CHAR, 0, PKT_END);
3187         ssh->state = SSH_STATE_INTERMED;
3188         do {
3189             crReturnV;
3190         } while (!ispkt);
3191         if (ssh->pktin.type != SSH1_SMSG_SUCCESS
3192             && ssh->pktin.type != SSH1_SMSG_FAILURE) {
3193             bombout((ssh,"Protocol confusion"));
3194             crReturnV;
3195         } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
3196             c_write_str(ssh, "Server refused to allocate pty\r\n");
3197             ssh->editing = ssh->echoing = 1;
3198         }
3199         logevent("Allocated pty");
3200     } else {
3201         ssh->editing = ssh->echoing = 1;
3202     }
3203
3204     if (ssh->cfg.compression) {
3205         send_packet(ssh, SSH1_CMSG_REQUEST_COMPRESSION, PKT_INT, 6, PKT_END);
3206         do {
3207             crReturnV;
3208         } while (!ispkt);
3209         if (ssh->pktin.type != SSH1_SMSG_SUCCESS
3210             && ssh->pktin.type != SSH1_SMSG_FAILURE) {
3211             bombout((ssh,"Protocol confusion"));
3212             crReturnV;
3213         } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
3214             c_write_str(ssh, "Server refused to compress\r\n");
3215         }
3216         logevent("Started compression");
3217         ssh->v1_compressing = TRUE;
3218         ssh->cs_comp_ctx = zlib_compress_init();
3219         logevent("Initialised zlib (RFC1950) compression");
3220         ssh->sc_comp_ctx = zlib_decompress_init();
3221         logevent("Initialised zlib (RFC1950) decompression");
3222     }
3223
3224     /*
3225      * Start the shell or command.
3226      *
3227      * Special case: if the first-choice command is an SSH2
3228      * subsystem (hence not usable here) and the second choice
3229      * exists, we fall straight back to that.
3230      */
3231     {
3232         char *cmd = ssh->cfg.remote_cmd_ptr;
3233
3234         if (ssh->cfg.ssh_subsys && ssh->cfg.remote_cmd_ptr2) {
3235             cmd = ssh->cfg.remote_cmd_ptr2;
3236             ssh->fallback_cmd = TRUE;
3237         }
3238         if (*cmd)
3239             send_packet(ssh, SSH1_CMSG_EXEC_CMD, PKT_STR, cmd, PKT_END);
3240         else
3241             send_packet(ssh, SSH1_CMSG_EXEC_SHELL, PKT_END);
3242         logevent("Started session");
3243     }
3244
3245     ssh->state = SSH_STATE_SESSION;
3246     if (ssh->size_needed)
3247         ssh_size(ssh, ssh->term_width, ssh->term_height);
3248     if (ssh->eof_needed)
3249         ssh_special(ssh, TS_EOF);
3250
3251     if (ssh->ldisc)
3252         ldisc_send(ssh->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
3253     ssh->send_ok = 1;
3254     ssh->channels = newtree234(ssh_channelcmp);
3255     while (1) {
3256         crReturnV;
3257         if (ispkt) {
3258             if (ssh->pktin.type == SSH1_SMSG_STDOUT_DATA ||
3259                 ssh->pktin.type == SSH1_SMSG_STDERR_DATA) {
3260                 long len = GET_32BIT(ssh->pktin.body);
3261                 int bufsize =
3262                     from_backend(ssh->frontend,
3263                                  ssh->pktin.type == SSH1_SMSG_STDERR_DATA,
3264                                  (char *)(ssh->pktin.body) + 4, len);
3265                 if (!ssh->v1_stdout_throttling && bufsize > SSH1_BUFFER_LIMIT) {
3266                     ssh->v1_stdout_throttling = 1;
3267                     ssh1_throttle(ssh, +1);
3268                 }
3269             } else if (ssh->pktin.type == SSH1_MSG_DISCONNECT) {
3270                 ssh->state = SSH_STATE_CLOSED;
3271                 logevent("Received disconnect request");
3272                 crReturnV;
3273             } else if (ssh->pktin.type == SSH1_SMSG_X11_OPEN) {
3274                 /* Remote side is trying to open a channel to talk to our
3275                  * X-Server. Give them back a local channel number. */
3276                 struct ssh_channel *c;
3277
3278                 logevent("Received X11 connect request");
3279                 /* Refuse if X11 forwarding is disabled. */
3280                 if (!ssh->X11_fwd_enabled) {
3281                     send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
3282                                 PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
3283                     logevent("Rejected X11 connect request");
3284                 } else {
3285                     c = smalloc(sizeof(struct ssh_channel));
3286                     c->ssh = ssh;
3287
3288                     if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
3289                                  ssh->x11auth, NULL, -1, &ssh->cfg) != NULL) {
3290                         logevent("opening X11 forward connection failed");
3291                         sfree(c);
3292                         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
3293                                     PKT_INT, GET_32BIT(ssh->pktin.body),
3294                                     PKT_END);
3295                     } else {
3296                         logevent
3297                             ("opening X11 forward connection succeeded");
3298                         c->remoteid = GET_32BIT(ssh->pktin.body);
3299                         c->localid = alloc_channel_id(ssh);
3300                         c->closes = 0;
3301                         c->v.v1.throttling = 0;
3302                         c->type = CHAN_X11;     /* identify channel type */
3303                         add234(ssh->channels, c);
3304                         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
3305                                     PKT_INT, c->remoteid, PKT_INT,
3306                                     c->localid, PKT_END);
3307                         logevent("Opened X11 forward channel");
3308                     }
3309                 }
3310             } else if (ssh->pktin.type == SSH1_SMSG_AGENT_OPEN) {
3311                 /* Remote side is trying to open a channel to talk to our
3312                  * agent. Give them back a local channel number. */
3313                 struct ssh_channel *c;
3314
3315                 /* Refuse if agent forwarding is disabled. */
3316                 if (!ssh->agentfwd_enabled) {
3317                     send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
3318                                 PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
3319                 } else {
3320                     c = smalloc(sizeof(struct ssh_channel));
3321                     c->ssh = ssh;
3322                     c->remoteid = GET_32BIT(ssh->pktin.body);
3323                     c->localid = alloc_channel_id(ssh);
3324                     c->closes = 0;
3325                     c->v.v1.throttling = 0;
3326                     c->type = CHAN_AGENT;       /* identify channel type */
3327                     c->u.a.lensofar = 0;
3328                     add234(ssh->channels, c);
3329                     send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
3330                                 PKT_INT, c->remoteid, PKT_INT, c->localid,
3331                                 PKT_END);
3332                 }
3333             } else if (ssh->pktin.type == SSH1_MSG_PORT_OPEN) {
3334                 /* Remote side is trying to open a channel to talk to a
3335                  * forwarded port. Give them back a local channel number. */
3336                 struct ssh_channel *c;
3337                 struct ssh_rportfwd pf;
3338                 int hostsize, port;
3339                 char host[256], buf[1024];
3340                 char *p, *h, *e;
3341                 c = smalloc(sizeof(struct ssh_channel));
3342                 c->ssh = ssh;
3343
3344                 hostsize = GET_32BIT(ssh->pktin.body+4);
3345                 for (h = host, p = (char *)(ssh->pktin.body+8);
3346                      hostsize != 0; hostsize--) {
3347                     if (h+1 < host+sizeof(host))
3348                         *h++ = *p;
3349                     p++;
3350                 }
3351                 *h = 0;
3352                 port = GET_32BIT(p);
3353
3354                 strcpy(pf.dhost, host);
3355                 pf.dport = port;
3356
3357                 if (find234(ssh->rportfwds, &pf, NULL) == NULL) {
3358                     sprintf(buf, "Rejected remote port open request for %s:%d",
3359                             host, port);
3360                     logevent(buf);
3361                     send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
3362                                 PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
3363                 } else {
3364                     sprintf(buf, "Received remote port open request for %s:%d",
3365                             host, port);
3366                     logevent(buf);
3367                     e = pfd_newconnect(&c->u.pfd.s, host, port, c, &ssh->cfg);
3368                     if (e != NULL) {
3369                         char buf[256];
3370                         sprintf(buf, "Port open failed: %s", e);
3371                         logevent(buf);
3372                         sfree(c);
3373                         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
3374                                     PKT_INT, GET_32BIT(ssh->pktin.body),
3375                                     PKT_END);
3376                     } else {
3377                         c->remoteid = GET_32BIT(ssh->pktin.body);
3378                         c->localid = alloc_channel_id(ssh);
3379                         c->closes = 0;
3380                         c->v.v1.throttling = 0;
3381                         c->type = CHAN_SOCKDATA;        /* identify channel type */
3382                         add234(ssh->channels, c);
3383                         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
3384                                     PKT_INT, c->remoteid, PKT_INT,
3385                                     c->localid, PKT_END);
3386                         logevent("Forwarded port opened successfully");
3387                     }
3388                 }
3389
3390             } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_OPEN_CONFIRMATION) {
3391                 unsigned int remoteid = GET_32BIT(ssh->pktin.body);
3392                 unsigned int localid = GET_32BIT(ssh->pktin.body+4);
3393                 struct ssh_channel *c;
3394
3395                 c = find234(ssh->channels, &remoteid, ssh_channelfind);
3396                 if (c && c->type == CHAN_SOCKDATA_DORMANT) {
3397                     c->remoteid = localid;
3398                     c->type = CHAN_SOCKDATA;
3399                     c->v.v1.throttling = 0;
3400                     pfd_confirm(c->u.pfd.s);
3401                 }
3402
3403                 if (c && c->closes) {
3404                     /*
3405                      * We have a pending close on this channel,
3406                      * which we decided on before the server acked
3407                      * the channel open. So now we know the
3408                      * remoteid, we can close it again.
3409                      */
3410                     send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE,
3411                                 PKT_INT, c->remoteid, PKT_END);
3412                 }
3413
3414             } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_OPEN_FAILURE) {
3415                 unsigned int remoteid = GET_32BIT(ssh->pktin.body);
3416                 struct ssh_channel *c;
3417
3418                 c = find234(ssh->channels, &remoteid, ssh_channelfind);
3419                 if (c && c->type == CHAN_SOCKDATA_DORMANT) {
3420                     logevent("Forwarded connection refused by server");
3421                     pfd_close(c->u.pfd.s);
3422                     del234(ssh->channels, c);
3423                     sfree(c);
3424                 }
3425
3426             } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE ||
3427                        ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION) {
3428                 /* Remote side closes a channel. */
3429                 unsigned i = GET_32BIT(ssh->pktin.body);
3430                 struct ssh_channel *c;
3431                 c = find234(ssh->channels, &i, ssh_channelfind);
3432                 if (c && ((int)c->remoteid) != -1) {
3433                     int closetype;
3434                     closetype =
3435                         (ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE ? 1 : 2);
3436
3437                     if ((c->closes == 0) && (c->type == CHAN_X11)) {
3438                         logevent("Forwarded X11 connection terminated");
3439                         assert(c->u.x11.s != NULL);
3440                         x11_close(c->u.x11.s);
3441                         c->u.x11.s = NULL;
3442                     }
3443                     if ((c->closes == 0) && (c->type == CHAN_SOCKDATA)) {
3444                         logevent("Forwarded port closed");
3445                         assert(c->u.pfd.s != NULL);
3446                         pfd_close(c->u.pfd.s);
3447                         c->u.pfd.s = NULL;
3448                     }
3449
3450                     c->closes |= (closetype << 2);   /* seen this message */
3451                     if (!(c->closes & closetype)) {
3452                         send_packet(ssh, ssh->pktin.type, PKT_INT, c->remoteid,
3453                                     PKT_END);
3454                         c->closes |= closetype;      /* sent it too */
3455                     }
3456
3457                     if (c->closes == 15) {
3458                         del234(ssh->channels, c);
3459                         sfree(c);
3460                     }
3461                 } else {
3462                     bombout((ssh,"Received CHANNEL_CLOSE%s for %s channel %d\n",
3463                              ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE ? "" :
3464                              "_CONFIRMATION", c ? "half-open" : "nonexistent",
3465                              i));
3466                 }
3467             } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_DATA) {
3468                 /* Data sent down one of our channels. */
3469                 int i = GET_32BIT(ssh->pktin.body);
3470                 int len = GET_32BIT(ssh->pktin.body + 4);
3471                 unsigned char *p = ssh->pktin.body + 8;
3472                 struct ssh_channel *c;
3473                 c = find234(ssh->channels, &i, ssh_channelfind);
3474                 if (c) {
3475                     int bufsize;
3476                     switch (c->type) {
3477                       case CHAN_X11:
3478                         bufsize = x11_send(c->u.x11.s, (char *)p, len);
3479                         break;
3480                       case CHAN_SOCKDATA:
3481                         bufsize = pfd_send(c->u.pfd.s, (char *)p, len);
3482                         break;
3483                       case CHAN_AGENT:
3484                         /* Data for an agent message. Buffer it. */
3485                         while (len > 0) {
3486                             if (c->u.a.lensofar < 4) {
3487                                 int l = min(4 - c->u.a.lensofar, len);
3488                                 memcpy(c->u.a.msglen + c->u.a.lensofar, p,
3489                                        l);
3490                                 p += l;
3491                                 len -= l;
3492                                 c->u.a.lensofar += l;
3493                             }
3494                             if (c->u.a.lensofar == 4) {
3495                                 c->u.a.totallen =
3496                                     4 + GET_32BIT(c->u.a.msglen);
3497                                 c->u.a.message = smalloc(c->u.a.totallen);
3498                                 memcpy(c->u.a.message, c->u.a.msglen, 4);
3499                             }
3500                             if (c->u.a.lensofar >= 4 && len > 0) {
3501                                 int l =
3502                                     min(c->u.a.totallen - c->u.a.lensofar,
3503                                         len);
3504                                 memcpy(c->u.a.message + c->u.a.lensofar, p,
3505                                        l);
3506                                 p += l;
3507                                 len -= l;
3508                                 c->u.a.lensofar += l;
3509                             }
3510                             if (c->u.a.lensofar == c->u.a.totallen) {
3511                                 void *reply, *sentreply;
3512                                 int replylen;
3513                                 agent_query(c->u.a.message,
3514                                             c->u.a.totallen, &reply,
3515                                             &replylen);
3516                                 if (reply)
3517                                     sentreply = reply;
3518                                 else {
3519                                     /* Fake SSH_AGENT_FAILURE. */
3520                                     sentreply = "\0\0\0\1\5";
3521                                     replylen = 5;
3522                                 }
3523                                 send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
3524                                             PKT_INT, c->remoteid,
3525                                             PKT_INT, replylen,
3526                                             PKT_DATA, sentreply, replylen,
3527                                             PKT_END);
3528                                 if (reply)
3529                                     sfree(reply);
3530                                 sfree(c->u.a.message);
3531                                 c->u.a.lensofar = 0;
3532                             }
3533                         }
3534                         bufsize = 0;   /* agent channels never back up */
3535                         break;
3536                     }
3537                     if (!c->v.v1.throttling && bufsize > SSH1_BUFFER_LIMIT) {
3538                         c->v.v1.throttling = 1;
3539                         ssh1_throttle(ssh, +1);
3540                     }
3541                 }
3542             } else if (ssh->pktin.type == SSH1_SMSG_SUCCESS) {
3543                 /* may be from EXEC_SHELL on some servers */
3544             } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
3545                 /* may be from EXEC_SHELL on some servers
3546                  * if no pty is available or in other odd cases. Ignore */
3547             } else if (ssh->pktin.type == SSH1_SMSG_EXIT_STATUS) {
3548                 char buf[100];
3549                 ssh->exitcode = GET_32BIT(ssh->pktin.body);
3550                 sprintf(buf, "Server sent command exit status %d",
3551                         ssh->exitcode);
3552                 logevent(buf);
3553                 send_packet(ssh, SSH1_CMSG_EXIT_CONFIRMATION, PKT_END);
3554                 /*
3555                  * In case `helpful' firewalls or proxies tack
3556                  * extra human-readable text on the end of the
3557                  * session which we might mistake for another
3558                  * encrypted packet, we close the session once
3559                  * we've sent EXIT_CONFIRMATION.
3560                  */
3561                 ssh->state = SSH_STATE_CLOSED;
3562                 crReturnV;
3563             } else {
3564                 bombout((ssh,"Strange packet received: type %d", ssh->pktin.type));
3565                 crReturnV;
3566             }
3567         } else {
3568             while (inlen > 0) {
3569                 int len = min(inlen, 512);
3570                 send_packet(ssh, SSH1_CMSG_STDIN_DATA,
3571                             PKT_INT, len, PKT_DATA, in, len, PKT_END);
3572                 in += len;
3573                 inlen -= len;
3574             }
3575         }
3576     }
3577
3578     crFinishV;
3579 }
3580
3581 /*
3582  * Utility routine for decoding comma-separated strings in KEXINIT.
3583  */
3584 static int in_commasep_string(char *needle, char *haystack, int haylen)
3585 {
3586     int needlen;
3587     if (!needle || !haystack)          /* protect against null pointers */
3588         return 0;
3589     needlen = strlen(needle);
3590     while (1) {
3591         /*
3592          * Is it at the start of the string?
3593          */
3594         if (haylen >= needlen &&       /* haystack is long enough */
3595             !memcmp(needle, haystack, needlen) &&       /* initial match */
3596             (haylen == needlen || haystack[needlen] == ',')
3597             /* either , or EOS follows */
3598             )
3599             return 1;
3600         /*
3601          * If not, search for the next comma and resume after that.
3602          * If no comma found, terminate.
3603          */
3604         while (haylen > 0 && *haystack != ',')
3605             haylen--, haystack++;
3606         if (haylen == 0)
3607             return 0;
3608         haylen--, haystack++;          /* skip over comma itself */
3609     }
3610 }
3611
3612 /*
3613  * SSH2 key creation method.
3614  */
3615 static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H,
3616                        unsigned char *sessid, char chr,
3617                        unsigned char *keyspace)
3618 {
3619     SHA_State s;
3620     /* First 20 bytes. */
3621     SHA_Init(&s);
3622     if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY))
3623         sha_mpint(&s, K);
3624     SHA_Bytes(&s, H, 20);
3625     SHA_Bytes(&s, &chr, 1);
3626     SHA_Bytes(&s, sessid, 20);
3627     SHA_Final(&s, keyspace);
3628     /* Next 20 bytes. */
3629     SHA_Init(&s);
3630     if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY))
3631         sha_mpint(&s, K);
3632     SHA_Bytes(&s, H, 20);
3633     SHA_Bytes(&s, keyspace, 20);
3634     SHA_Final(&s, keyspace + 20);
3635 }
3636
3637 /*
3638  * Handle the SSH2 transport layer.
3639  */
3640 static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
3641 {
3642     struct do_ssh2_transport_state {
3643         int nbits, pbits, warn;
3644         Bignum p, g, e, f, K;
3645         int kex_init_value, kex_reply_value;
3646         const struct ssh_mac **maclist;
3647         int nmacs;
3648         const struct ssh2_cipher *cscipher_tobe;
3649         const struct ssh2_cipher *sccipher_tobe;
3650         const struct ssh_mac *csmac_tobe;
3651         const struct ssh_mac *scmac_tobe;
3652         const struct ssh_compress *cscomp_tobe;
3653         const struct ssh_compress *sccomp_tobe;
3654         char *hostkeydata, *sigdata, *keystr, *fingerprint;
3655         int hostkeylen, siglen;
3656         void *hkey;                    /* actual host key */
3657         unsigned char exchange_hash[20];
3658         int n_preferred_ciphers;
3659         const struct ssh2_ciphers *preferred_ciphers[CIPHER_MAX];
3660         const struct ssh_compress *preferred_comp;
3661         int first_kex;
3662     };
3663     crState(do_ssh2_transport_state);
3664
3665     crBegin(ssh->do_ssh2_transport_crstate);
3666
3667     s->cscipher_tobe = s->sccipher_tobe = NULL;
3668     s->csmac_tobe = s->scmac_tobe = NULL;
3669     s->cscomp_tobe = s->sccomp_tobe = NULL;
3670
3671     random_init();
3672     s->first_kex = 1;
3673
3674     {
3675         int i;
3676         /*
3677          * Set up the preferred ciphers. (NULL => warn below here)
3678          */
3679         s->n_preferred_ciphers = 0;
3680         for (i = 0; i < CIPHER_MAX; i++) {
3681             switch (ssh->cfg.ssh_cipherlist[i]) {
3682               case CIPHER_BLOWFISH:
3683                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_blowfish;
3684                 break;
3685               case CIPHER_DES:
3686                 if (ssh->cfg.ssh2_des_cbc) {
3687                     s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_des;
3688                 }
3689                 break;
3690               case CIPHER_3DES:
3691                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_3des;
3692                 break;
3693               case CIPHER_AES:
3694                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_aes;
3695                 break;
3696               case CIPHER_WARN:
3697                 /* Flag for later. Don't bother if it's the last in
3698                  * the list. */
3699                 if (i < CIPHER_MAX - 1) {
3700                     s->preferred_ciphers[s->n_preferred_ciphers++] = NULL;
3701                 }
3702                 break;
3703             }
3704         }
3705     }
3706
3707     /*
3708      * Set up preferred compression.
3709      */
3710     if (ssh->cfg.compression)
3711         s->preferred_comp = &ssh_zlib;
3712     else
3713         s->preferred_comp = &ssh_comp_none;
3714
3715     /*
3716      * Be prepared to work around the buggy MAC problem.
3717      */
3718     if (ssh->remote_bugs & BUG_SSH2_HMAC)
3719         s->maclist = buggymacs, s->nmacs = lenof(buggymacs);
3720     else
3721         s->maclist = macs, s->nmacs = lenof(macs);
3722
3723   begin_key_exchange:
3724     {
3725         int i, j, cipherstr_started;
3726
3727         /*
3728          * Construct and send our key exchange packet.
3729          */
3730         ssh2_pkt_init(ssh, SSH2_MSG_KEXINIT);
3731         for (i = 0; i < 16; i++)
3732             ssh2_pkt_addbyte(ssh, (unsigned char) random_byte());
3733         /* List key exchange algorithms. */
3734         ssh2_pkt_addstring_start(ssh);
3735         for (i = 0; i < lenof(kex_algs); i++) {
3736             if (kex_algs[i] == &ssh_diffiehellman_gex &&
3737                 (ssh->remote_bugs & BUG_SSH2_DH_GEX))
3738                 continue;
3739             ssh2_pkt_addstring_str(ssh, kex_algs[i]->name);
3740             if (i < lenof(kex_algs) - 1)
3741                 ssh2_pkt_addstring_str(ssh, ",");
3742         }
3743         /* List server host key algorithms. */
3744         ssh2_pkt_addstring_start(ssh);
3745         for (i = 0; i < lenof(hostkey_algs); i++) {
3746             ssh2_pkt_addstring_str(ssh, hostkey_algs[i]->name);
3747             if (i < lenof(hostkey_algs) - 1)
3748                 ssh2_pkt_addstring_str(ssh, ",");
3749         }
3750         /* List client->server encryption algorithms. */
3751         ssh2_pkt_addstring_start(ssh);
3752         cipherstr_started = 0;
3753         for (i = 0; i < s->n_preferred_ciphers; i++) {
3754             const struct ssh2_ciphers *c = s->preferred_ciphers[i];
3755             if (!c) continue;          /* warning flag */
3756             for (j = 0; j < c->nciphers; j++) {
3757                 if (cipherstr_started)
3758                     ssh2_pkt_addstring_str(ssh, ",");
3759                 ssh2_pkt_addstring_str(ssh, c->list[j]->name);
3760                 cipherstr_started = 1;
3761             }
3762         }
3763         /* List server->client encryption algorithms. */
3764         ssh2_pkt_addstring_start(ssh);
3765         cipherstr_started = 0;
3766         for (i = 0; i < s->n_preferred_ciphers; i++) {
3767             const struct ssh2_ciphers *c = s->preferred_ciphers[i];
3768             if (!c) continue; /* warning flag */
3769             for (j = 0; j < c->nciphers; j++) {
3770                 if (cipherstr_started)
3771                     ssh2_pkt_addstring_str(ssh, ",");
3772                 ssh2_pkt_addstring_str(ssh, c->list[j]->name);
3773                 cipherstr_started = 1;
3774             }
3775         }
3776         /* List client->server MAC algorithms. */
3777         ssh2_pkt_addstring_start(ssh);
3778         for (i = 0; i < s->nmacs; i++) {
3779             ssh2_pkt_addstring_str(ssh, s->maclist[i]->name);
3780             if (i < s->nmacs - 1)
3781                 ssh2_pkt_addstring_str(ssh, ",");
3782         }
3783         /* List server->client MAC algorithms. */
3784         ssh2_pkt_addstring_start(ssh);
3785         for (i = 0; i < s->nmacs; i++) {
3786             ssh2_pkt_addstring_str(ssh, s->maclist[i]->name);
3787             if (i < s->nmacs - 1)
3788                 ssh2_pkt_addstring_str(ssh, ",");
3789         }
3790         /* List client->server compression algorithms. */
3791         ssh2_pkt_addstring_start(ssh);
3792         for (i = 0; i < lenof(compressions) + 1; i++) {
3793             const struct ssh_compress *c =
3794                 i == 0 ? s->preferred_comp : compressions[i - 1];
3795             ssh2_pkt_addstring_str(ssh, c->name);
3796             if (i < lenof(compressions))
3797                 ssh2_pkt_addstring_str(ssh, ",");
3798         }
3799         /* List server->client compression algorithms. */
3800         ssh2_pkt_addstring_start(ssh);
3801         for (i = 0; i < lenof(compressions) + 1; i++) {
3802             const struct ssh_compress *c =
3803                 i == 0 ? s->preferred_comp : compressions[i - 1];
3804             ssh2_pkt_addstring_str(ssh, c->name);
3805             if (i < lenof(compressions))
3806                 ssh2_pkt_addstring_str(ssh, ",");
3807         }
3808         /* List client->server languages. Empty list. */
3809         ssh2_pkt_addstring_start(ssh);
3810         /* List server->client languages. Empty list. */
3811         ssh2_pkt_addstring_start(ssh);
3812         /* First KEX packet does _not_ follow, because we're not that brave. */
3813         ssh2_pkt_addbool(ssh, FALSE);
3814         /* Reserved. */
3815         ssh2_pkt_adduint32(ssh, 0);
3816     }
3817
3818     ssh->exhash = ssh->exhashbase;
3819     sha_string(&ssh->exhash, ssh->pktout.data + 5, ssh->pktout.length - 5);
3820
3821     ssh2_pkt_send(ssh);
3822
3823     if (!ispkt)
3824         crWaitUntil(ispkt);
3825     if (ssh->pktin.length > 5)
3826         sha_string(&ssh->exhash, ssh->pktin.data + 5, ssh->pktin.length - 5);
3827
3828     /*
3829      * Now examine the other side's KEXINIT to see what we're up
3830      * to.
3831      */
3832     {
3833         char *str;
3834         int i, j, len;
3835
3836         if (ssh->pktin.type != SSH2_MSG_KEXINIT) {
3837             bombout((ssh,"expected key exchange packet from server"));
3838             crReturn(0);
3839         }
3840         ssh->kex = NULL;
3841         ssh->hostkey = NULL;
3842         s->cscipher_tobe = NULL;
3843         s->sccipher_tobe = NULL;
3844         s->csmac_tobe = NULL;
3845         s->scmac_tobe = NULL;
3846         s->cscomp_tobe = NULL;
3847         s->sccomp_tobe = NULL;
3848         ssh->pktin.savedpos += 16;              /* skip garbage cookie */
3849         ssh2_pkt_getstring(ssh, &str, &len);    /* key exchange algorithms */
3850         for (i = 0; i < lenof(kex_algs); i++) {
3851             if (kex_algs[i] == &ssh_diffiehellman_gex &&
3852                 (ssh->remote_bugs & BUG_SSH2_DH_GEX))
3853                 continue;
3854             if (in_commasep_string(kex_algs[i]->name, str, len)) {
3855                 ssh->kex = kex_algs[i];
3856                 break;
3857             }
3858         }
3859         ssh2_pkt_getstring(ssh, &str, &len);    /* host key algorithms */
3860         for (i = 0; i < lenof(hostkey_algs); i++) {
3861             if (in_commasep_string(hostkey_algs[i]->name, str, len)) {
3862                 ssh->hostkey = hostkey_algs[i];
3863                 break;
3864             }
3865         }
3866         ssh2_pkt_getstring(ssh, &str, &len);    /* client->server cipher */
3867         s->warn = 0;
3868         for (i = 0; i < s->n_preferred_ciphers; i++) {
3869             const struct ssh2_ciphers *c = s->preferred_ciphers[i];
3870             if (!c) {
3871                 s->warn = 1;
3872             } else {
3873                 for (j = 0; j < c->nciphers; j++) {
3874                     if (in_commasep_string(c->list[j]->name, str, len)) {
3875                         s->cscipher_tobe = c->list[j];
3876                         break;
3877                     }
3878                 }
3879             }
3880             if (s->cscipher_tobe) {
3881                 if (s->warn)
3882                     askcipher(ssh->frontend, s->cscipher_tobe->name, 1);
3883                 break;
3884             }
3885         }
3886         if (!s->cscipher_tobe) {
3887             bombout((ssh,"Couldn't agree a client-to-server cipher (available: %s)",
3888                      str ? str : "(null)"));
3889             crReturn(0);
3890         }
3891
3892         ssh2_pkt_getstring(ssh, &str, &len);    /* server->client cipher */
3893         s->warn = 0;
3894         for (i = 0; i < s->n_preferred_ciphers; i++) {
3895             const struct ssh2_ciphers *c = s->preferred_ciphers[i];
3896             if (!c) {
3897                 s->warn = 1;
3898             } else {
3899                 for (j = 0; j < c->nciphers; j++) {
3900                     if (in_commasep_string(c->list[j]->name, str, len)) {
3901                         s->sccipher_tobe = c->list[j];
3902                         break;
3903                     }
3904                 }
3905             }
3906             if (s->sccipher_tobe) {
3907                 if (s->warn)
3908                     askcipher(ssh->frontend, s->sccipher_tobe->name, 2);
3909                 break;
3910             }
3911         }
3912         if (!s->sccipher_tobe) {
3913             bombout((ssh,"Couldn't agree a server-to-client cipher (available: %s)",
3914                      str ? str : "(null)"));
3915             crReturn(0);
3916         }
3917
3918         ssh2_pkt_getstring(ssh, &str, &len);    /* client->server mac */
3919         for (i = 0; i < s->nmacs; i++) {
3920             if (in_commasep_string(s->maclist[i]->name, str, len)) {
3921                 s->csmac_tobe = s->maclist[i];
3922                 break;
3923             }
3924         }
3925         ssh2_pkt_getstring(ssh, &str, &len);    /* server->client mac */
3926         for (i = 0; i < s->nmacs; i++) {
3927             if (in_commasep_string(s->maclist[i]->name, str, len)) {
3928                 s->scmac_tobe = s->maclist[i];
3929                 break;
3930             }
3931         }
3932         ssh2_pkt_getstring(ssh, &str, &len);  /* client->server compression */
3933         for (i = 0; i < lenof(compressions) + 1; i++) {
3934             const struct ssh_compress *c =
3935                 i == 0 ? s->preferred_comp : compressions[i - 1];
3936             if (in_commasep_string(c->name, str, len)) {
3937                 s->cscomp_tobe = c;
3938                 break;
3939             }
3940         }
3941         ssh2_pkt_getstring(ssh, &str, &len);  /* server->client compression */
3942         for (i = 0; i < lenof(compressions) + 1; i++) {
3943             const struct ssh_compress *c =
3944                 i == 0 ? s->preferred_comp : compressions[i - 1];
3945             if (in_commasep_string(c->name, str, len)) {
3946                 s->sccomp_tobe = c;
3947                 break;
3948             }
3949         }
3950     }
3951
3952     /*
3953      * Work out the number of bits of key we will need from the key
3954      * exchange. We start with the maximum key length of either
3955      * cipher...
3956      */
3957     {
3958         int csbits, scbits;
3959
3960         csbits = s->cscipher_tobe->keylen;
3961         scbits = s->sccipher_tobe->keylen;
3962         s->nbits = (csbits > scbits ? csbits : scbits);
3963     }
3964     /* The keys only have 160-bit entropy, since they're based on
3965      * a SHA-1 hash. So cap the key size at 160 bits. */
3966     if (s->nbits > 160)
3967         s->nbits = 160;
3968
3969     /*
3970      * If we're doing Diffie-Hellman group exchange, start by
3971      * requesting a group.
3972      */
3973     if (ssh->kex == &ssh_diffiehellman_gex) {
3974         logevent("Doing Diffie-Hellman group exchange");
3975         ssh->pkt_ctx |= SSH2_PKTCTX_DHGEX;
3976         /*
3977          * Work out how big a DH group we will need to allow that
3978          * much data.
3979          */
3980         s->pbits = 512 << ((s->nbits - 1) / 64);
3981         ssh2_pkt_init(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST);
3982         ssh2_pkt_adduint32(ssh, s->pbits);
3983         ssh2_pkt_send(ssh);
3984
3985         crWaitUntil(ispkt);
3986         if (ssh->pktin.type != SSH2_MSG_KEX_DH_GEX_GROUP) {
3987             bombout((ssh,"expected key exchange group packet from server"));
3988             crReturn(0);
3989         }
3990         s->p = ssh2_pkt_getmp(ssh);
3991         s->g = ssh2_pkt_getmp(ssh);
3992         ssh->kex_ctx = dh_setup_group(s->p, s->g);
3993         s->kex_init_value = SSH2_MSG_KEX_DH_GEX_INIT;
3994         s->kex_reply_value = SSH2_MSG_KEX_DH_GEX_REPLY;
3995     } else {
3996         ssh->pkt_ctx |= SSH2_PKTCTX_DHGROUP1;
3997         ssh->kex_ctx = dh_setup_group1();
3998         s->kex_init_value = SSH2_MSG_KEXDH_INIT;
3999         s->kex_reply_value = SSH2_MSG_KEXDH_REPLY;
4000     }
4001
4002     logevent("Doing Diffie-Hellman key exchange");
4003     /*
4004      * Now generate and send e for Diffie-Hellman.
4005      */
4006     s->e = dh_create_e(ssh->kex_ctx, s->nbits * 2);
4007     ssh2_pkt_init(ssh, s->kex_init_value);
4008     ssh2_pkt_addmp(ssh, s->e);
4009     ssh2_pkt_send(ssh);
4010
4011     crWaitUntil(ispkt);
4012     if (ssh->pktin.type != s->kex_reply_value) {
4013         bombout((ssh,"expected key exchange reply packet from server"));
4014         crReturn(0);
4015     }
4016     ssh2_pkt_getstring(ssh, &s->hostkeydata, &s->hostkeylen);
4017     s->f = ssh2_pkt_getmp(ssh);
4018     ssh2_pkt_getstring(ssh, &s->sigdata, &s->siglen);
4019
4020     s->K = dh_find_K(ssh->kex_ctx, s->f);
4021
4022     sha_string(&ssh->exhash, s->hostkeydata, s->hostkeylen);
4023     if (ssh->kex == &ssh_diffiehellman_gex) {
4024         sha_uint32(&ssh->exhash, s->pbits);
4025         sha_mpint(&ssh->exhash, s->p);
4026         sha_mpint(&ssh->exhash, s->g);
4027     }
4028     sha_mpint(&ssh->exhash, s->e);
4029     sha_mpint(&ssh->exhash, s->f);
4030     sha_mpint(&ssh->exhash, s->K);
4031     SHA_Final(&ssh->exhash, s->exchange_hash);
4032
4033     dh_cleanup(ssh->kex_ctx);
4034     ssh->kex_ctx = NULL;
4035
4036 #if 0
4037     debug(("Exchange hash is:\n"));
4038     dmemdump(s->exchange_hash, 20);
4039 #endif
4040
4041     s->hkey = ssh->hostkey->newkey(s->hostkeydata, s->hostkeylen);
4042     if (!s->hkey ||
4043         !ssh->hostkey->verifysig(s->hkey, s->sigdata, s->siglen,
4044                                  (char *)s->exchange_hash, 20)) {
4045         bombout((ssh,"Server's host key did not match the signature supplied"));
4046         crReturn(0);
4047     }
4048
4049     /*
4050      * Authenticate remote host: verify host key. (We've already
4051      * checked the signature of the exchange hash.)
4052      */
4053     s->keystr = ssh->hostkey->fmtkey(s->hkey);
4054     s->fingerprint = ssh->hostkey->fingerprint(s->hkey);
4055     verify_ssh_host_key(ssh->frontend,
4056                         ssh->savedhost, ssh->savedport, ssh->hostkey->keytype,
4057                         s->keystr, s->fingerprint);
4058     if (s->first_kex) {                /* don't bother logging this in rekeys */
4059         logevent("Host key fingerprint is:");
4060         logevent(s->fingerprint);
4061     }
4062     sfree(s->fingerprint);
4063     sfree(s->keystr);
4064     ssh->hostkey->freekey(s->hkey);
4065
4066     /*
4067      * Send SSH2_MSG_NEWKEYS.
4068      */
4069     ssh2_pkt_init(ssh, SSH2_MSG_NEWKEYS);
4070     ssh2_pkt_send(ssh);
4071
4072     /*
4073      * Expect SSH2_MSG_NEWKEYS from server.
4074      */
4075     crWaitUntil(ispkt);
4076     if (ssh->pktin.type != SSH2_MSG_NEWKEYS) {
4077         bombout((ssh,"expected new-keys packet from server"));
4078         crReturn(0);
4079     }
4080
4081     /*
4082      * Create and initialise session keys.
4083      */
4084     if (ssh->cs_cipher_ctx)
4085         ssh->cscipher->free_context(ssh->cs_cipher_ctx);
4086     ssh->cscipher = s->cscipher_tobe;
4087     ssh->cs_cipher_ctx = ssh->cscipher->make_context();
4088
4089     if (ssh->sc_cipher_ctx)
4090         ssh->sccipher->free_context(ssh->sc_cipher_ctx);
4091     ssh->sccipher = s->sccipher_tobe;
4092     ssh->sc_cipher_ctx = ssh->sccipher->make_context();
4093
4094     if (ssh->cs_mac_ctx)
4095         ssh->csmac->free_context(ssh->cs_mac_ctx);
4096     ssh->csmac = s->csmac_tobe;
4097     ssh->cs_mac_ctx = ssh->csmac->make_context();
4098
4099     if (ssh->sc_mac_ctx)
4100         ssh->scmac->free_context(ssh->sc_mac_ctx);
4101     ssh->scmac = s->scmac_tobe;
4102     ssh->sc_mac_ctx = ssh->scmac->make_context();
4103
4104     if (ssh->cs_comp_ctx)
4105         ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
4106     ssh->cscomp = s->cscomp_tobe;
4107     ssh->cs_comp_ctx = ssh->cscomp->compress_init();
4108
4109     if (ssh->sc_comp_ctx)
4110         ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
4111     ssh->sccomp = s->sccomp_tobe;
4112     ssh->sc_comp_ctx = ssh->sccomp->decompress_init();
4113
4114     /*
4115      * Set IVs after keys. Here we use the exchange hash from the
4116      * _first_ key exchange.
4117      */
4118     {
4119         unsigned char keyspace[40];
4120         if (s->first_kex)
4121             memcpy(ssh->v2_session_id, s->exchange_hash,
4122                    sizeof(s->exchange_hash));
4123         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'C',keyspace);
4124         ssh->cscipher->setkey(ssh->cs_cipher_ctx, keyspace);
4125         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'D',keyspace);
4126         ssh->sccipher->setkey(ssh->sc_cipher_ctx, keyspace);
4127         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'A',keyspace);
4128         ssh->cscipher->setiv(ssh->cs_cipher_ctx, keyspace);
4129         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'B',keyspace);
4130         ssh->sccipher->setiv(ssh->sc_cipher_ctx, keyspace);
4131         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'E',keyspace);
4132         ssh->csmac->setkey(ssh->cs_mac_ctx, keyspace);
4133         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'F',keyspace);
4134         ssh->scmac->setkey(ssh->sc_mac_ctx, keyspace);
4135     }
4136     logeventf(ssh, "Initialised %.200s client->server encryption",
4137               ssh->cscipher->text_name);
4138     logeventf(ssh, "Initialised %.200s server->client encryption",
4139               ssh->sccipher->text_name);
4140     if (ssh->cscomp->text_name)
4141         logeventf(ssh, "Initialised %s compression",
4142                   ssh->cscomp->text_name);
4143     if (ssh->sccomp->text_name)
4144         logeventf(ssh, "Initialised %s decompression",
4145                   ssh->sccomp->text_name);
4146
4147     /*
4148      * If this is the first key exchange phase, we must pass the
4149      * SSH2_MSG_NEWKEYS packet to the next layer, not because it
4150      * wants to see it but because it will need time to initialise
4151      * itself before it sees an actual packet. In subsequent key
4152      * exchange phases, we don't pass SSH2_MSG_NEWKEYS on, because
4153      * it would only confuse the layer above.
4154      */
4155     if (!s->first_kex) {
4156         crReturn(0);
4157     }
4158     s->first_kex = 0;
4159
4160     /*
4161      * Now we're encrypting. Begin returning 1 to the protocol main
4162      * function so that other things can run on top of the
4163      * transport. If we ever see a KEXINIT, we must go back to the
4164      * start.
4165      */
4166     while (!(ispkt && ssh->pktin.type == SSH2_MSG_KEXINIT)) {
4167         crReturn(1);
4168     }
4169     logevent("Server initiated key re-exchange");
4170     goto begin_key_exchange;
4171
4172     crFinish(1);
4173 }
4174
4175 /*
4176  * Add data to an SSH2 channel output buffer.
4177  */
4178 static void ssh2_add_channel_data(struct ssh_channel *c, char *buf,
4179                                   int len)
4180 {
4181     bufchain_add(&c->v.v2.outbuffer, buf, len);
4182 }
4183
4184 /*
4185  * Attempt to send data on an SSH2 channel.
4186  */
4187 static int ssh2_try_send(struct ssh_channel *c)
4188 {
4189     Ssh ssh = c->ssh;
4190
4191     while (c->v.v2.remwindow > 0 && bufchain_size(&c->v.v2.outbuffer) > 0) {
4192         int len;
4193         void *data;
4194         bufchain_prefix(&c->v.v2.outbuffer, &data, &len);
4195         if ((unsigned)len > c->v.v2.remwindow)
4196             len = c->v.v2.remwindow;
4197         if ((unsigned)len > c->v.v2.remmaxpkt)
4198             len = c->v.v2.remmaxpkt;
4199         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_DATA);
4200         ssh2_pkt_adduint32(ssh, c->remoteid);
4201         ssh2_pkt_addstring_start(ssh);
4202         ssh2_pkt_addstring_data(ssh, data, len);
4203         ssh2_pkt_send(ssh);
4204         bufchain_consume(&c->v.v2.outbuffer, len);
4205         c->v.v2.remwindow -= len;
4206     }
4207
4208     /*
4209      * After having sent as much data as we can, return the amount
4210      * still buffered.
4211      */
4212     return bufchain_size(&c->v.v2.outbuffer);
4213 }
4214
4215 /*
4216  * Potentially enlarge the window on an SSH2 channel.
4217  */
4218 static void ssh2_set_window(struct ssh_channel *c, unsigned newwin)
4219 {
4220     Ssh ssh = c->ssh;
4221
4222     /*
4223      * Never send WINDOW_ADJUST for a channel that the remote side
4224      * already thinks it's closed; there's no point, since it won't
4225      * be sending any more data anyway.
4226      */
4227     if (c->closes != 0)
4228         return;
4229
4230     if (newwin > c->v.v2.locwindow) {
4231         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_WINDOW_ADJUST);
4232         ssh2_pkt_adduint32(ssh, c->remoteid);
4233         ssh2_pkt_adduint32(ssh, newwin - c->v.v2.locwindow);
4234         ssh2_pkt_send(ssh);
4235         c->v.v2.locwindow = newwin;
4236     }
4237 }
4238
4239 /*
4240  * Handle the SSH2 userauth and connection layers.
4241  */
4242 static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
4243 {
4244     struct do_ssh2_authconn_state {
4245         enum {
4246             AUTH_INVALID, AUTH_PUBLICKEY_AGENT, AUTH_PUBLICKEY_FILE,
4247                 AUTH_PASSWORD,
4248                 AUTH_KEYBOARD_INTERACTIVE
4249         } method;
4250         enum {
4251             AUTH_TYPE_NONE,
4252                 AUTH_TYPE_PUBLICKEY,
4253                 AUTH_TYPE_PUBLICKEY_OFFER_LOUD,
4254                 AUTH_TYPE_PUBLICKEY_OFFER_QUIET,
4255                 AUTH_TYPE_PASSWORD,
4256                 AUTH_TYPE_KEYBOARD_INTERACTIVE,
4257                 AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
4258         } type;
4259         int gotit, need_pw, can_pubkey, can_passwd, can_keyb_inter;
4260         int tried_pubkey_config, tried_agent, tried_keyb_inter;
4261         int kbd_inter_running;
4262         int we_are_in;
4263         int num_prompts, curr_prompt, echo;
4264         char username[100];
4265         int got_username;
4266         char pwprompt[200];
4267         char password[100];
4268         void *publickey_blob;
4269         int publickey_bloblen;
4270         unsigned char request[5], *response, *p;
4271         int responselen;
4272         int keyi, nkeys;
4273         int authed;
4274         char *pkblob, *alg, *commentp;
4275         int pklen, alglen, commentlen;
4276         int siglen, retlen, len;
4277         char *q, *agentreq, *ret;
4278         int try_send;
4279     };
4280     crState(do_ssh2_authconn_state);
4281
4282     crBegin(ssh->do_ssh2_authconn_crstate);
4283
4284     /*
4285      * Request userauth protocol, and await a response to it.
4286      */
4287     ssh2_pkt_init(ssh, SSH2_MSG_SERVICE_REQUEST);
4288     ssh2_pkt_addstring(ssh, "ssh-userauth");
4289     ssh2_pkt_send(ssh);
4290     crWaitUntilV(ispkt);
4291     if (ssh->pktin.type != SSH2_MSG_SERVICE_ACCEPT) {
4292         bombout((ssh,"Server refused user authentication protocol"));
4293         crReturnV;
4294     }
4295
4296     /*
4297      * We repeat this whole loop, including the username prompt,
4298      * until we manage a successful authentication. If the user
4299      * types the wrong _password_, they can be sent back to the
4300      * beginning to try another username, if this is configured on.
4301      * (If they specify a username in the config, they are never
4302      * asked, even if they do give a wrong password.)
4303      *
4304      * I think this best serves the needs of
4305      *
4306      *  - the people who have no configuration, no keys, and just
4307      *    want to try repeated (username,password) pairs until they
4308      *    type both correctly
4309      *
4310      *  - people who have keys and configuration but occasionally
4311      *    need to fall back to passwords
4312      *
4313      *  - people with a key held in Pageant, who might not have
4314      *    logged in to a particular machine before; so they want to
4315      *    type a username, and then _either_ their key will be
4316      *    accepted, _or_ they will type a password. If they mistype
4317      *    the username they will want to be able to get back and
4318      *    retype it!
4319      */
4320     s->username[0] = '\0';
4321     s->got_username = FALSE;
4322     do {
4323         /*
4324          * Get a username.
4325          */
4326         if (s->got_username && !ssh->cfg.change_username) {
4327             /*
4328              * We got a username last time round this loop, and
4329              * with change_username turned off we don't try to get
4330              * it again.
4331              */
4332         } else if ((flags & FLAG_INTERACTIVE) && !*ssh->cfg.username) {
4333             if (ssh_get_line && !ssh_getline_pw_only) {
4334                 if (!ssh_get_line("login as: ",
4335                                   s->username, sizeof(s->username), FALSE)) {
4336                     /*
4337                      * get_line failed to get a username.
4338                      * Terminate.
4339                      */
4340                     logevent("No username provided. Abandoning session.");
4341                     ssh->state = SSH_STATE_CLOSED;
4342                     crReturnV;
4343                 }
4344             } else {
4345                 int ret;               /* need not be saved across crReturn */
4346                 c_write_str(ssh, "login as: ");
4347                 ssh->send_ok = 1;
4348                 setup_userpass_input(ssh, s->username, sizeof(s->username), 1);
4349                 do {
4350                     crWaitUntilV(!ispkt);
4351                     ret = process_userpass_input(ssh, in, inlen);
4352                 } while (ret == 0);
4353                 if (ret < 0)
4354                     cleanup_exit(0);
4355                 c_write_str(ssh, "\r\n");
4356             }
4357             s->username[strcspn(s->username, "\n\r")] = '\0';
4358         } else {
4359             char *stuff;
4360             strncpy(s->username, ssh->cfg.username, sizeof(s->username));
4361             s->username[sizeof(s->username)-1] = '\0';
4362             if ((flags & FLAG_VERBOSE) || (flags & FLAG_INTERACTIVE)) {
4363                 stuff = dupprintf("Using username \"%s\".\r\n", s->username);
4364                 c_write_str(ssh, stuff);
4365                 sfree(stuff);
4366             }
4367         }
4368         s->got_username = TRUE;
4369
4370         /*
4371          * Send an authentication request using method "none": (a)
4372          * just in case it succeeds, and (b) so that we know what
4373          * authentication methods we can usefully try next.
4374          */
4375         ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
4376
4377         ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
4378         ssh2_pkt_addstring(ssh, s->username);
4379         ssh2_pkt_addstring(ssh, "ssh-connection");/* service requested */
4380         ssh2_pkt_addstring(ssh, "none");    /* method */
4381         ssh2_pkt_send(ssh);
4382         s->type = AUTH_TYPE_NONE;
4383         s->gotit = FALSE;
4384         s->we_are_in = FALSE;
4385
4386         s->tried_pubkey_config = FALSE;
4387         s->tried_agent = FALSE;
4388         s->tried_keyb_inter = FALSE;
4389         s->kbd_inter_running = FALSE;
4390         /* Load the pub half of ssh->cfg.keyfile so we notice if it's in Pageant */
4391         if (*ssh->cfg.keyfile) {
4392             int keytype;
4393             logeventf(ssh, "Reading private key file \"%.150s\"", ssh->cfg.keyfile);
4394             keytype = key_type(ssh->cfg.keyfile);
4395             if (keytype == SSH_KEYTYPE_SSH2) {
4396                 s->publickey_blob =
4397                     ssh2_userkey_loadpub(ssh->cfg.keyfile, NULL,
4398                                          &s->publickey_bloblen);
4399             } else {
4400                 char *msgbuf;
4401                 logeventf(ssh, "Unable to use this key file (%s)",
4402                           key_type_to_str(keytype));
4403                 msgbuf = dupprintf("Unable to use key file \"%.150s\""
4404                                    " (%s)\r\n", ssh->cfg.keyfile,
4405                                    key_type_to_str(keytype));
4406                 c_write_str(ssh, msgbuf);
4407                 sfree(msgbuf);
4408                 s->publickey_blob = NULL;
4409             }
4410         } else
4411             s->publickey_blob = NULL;
4412
4413         while (1) {
4414             /*
4415              * Wait for the result of the last authentication request.
4416              */
4417             if (!s->gotit)
4418                 crWaitUntilV(ispkt);
4419             while (ssh->pktin.type == SSH2_MSG_USERAUTH_BANNER) {
4420                 char *banner;
4421                 int size;
4422                 /*
4423                  * Don't show the banner if we're operating in
4424                  * non-verbose non-interactive mode. (It's probably
4425                  * a script, which means nobody will read the
4426                  * banner _anyway_, and moreover the printing of
4427                  * the banner will screw up processing on the
4428                  * output of (say) plink.)
4429                  */
4430                 if (flags & (FLAG_VERBOSE | FLAG_INTERACTIVE)) {
4431                     ssh2_pkt_getstring(ssh, &banner, &size);
4432                     if (banner)
4433                         c_write_untrusted(ssh, banner, size);
4434                 }
4435                 crWaitUntilV(ispkt);
4436             }
4437             if (ssh->pktin.type == SSH2_MSG_USERAUTH_SUCCESS) {
4438                 logevent("Access granted");
4439                 s->we_are_in = TRUE;
4440                 break;
4441             }
4442
4443             if (s->kbd_inter_running &&
4444                 ssh->pktin.type == SSH2_MSG_USERAUTH_INFO_REQUEST) {
4445                 /*
4446                  * This is either a further set-of-prompts packet
4447                  * in keyboard-interactive authentication, or it's
4448                  * the same one and we came back here with `gotit'
4449                  * set. In the former case, we must reset the
4450                  * curr_prompt variable.
4451                  */
4452                 if (!s->gotit)
4453                     s->curr_prompt = 0;
4454             } else if (ssh->pktin.type != SSH2_MSG_USERAUTH_FAILURE) {
4455                 bombout((ssh,"Strange packet received during authentication: type %d",
4456                          ssh->pktin.type));
4457                 crReturnV;
4458             }
4459
4460             s->gotit = FALSE;
4461
4462             /*
4463              * OK, we're now sitting on a USERAUTH_FAILURE message, so
4464              * we can look at the string in it and know what we can
4465              * helpfully try next.
4466              */
4467             if (ssh->pktin.type == SSH2_MSG_USERAUTH_FAILURE) {
4468                 char *methods;
4469                 int methlen;
4470                 ssh2_pkt_getstring(ssh, &methods, &methlen);
4471                 s->kbd_inter_running = FALSE;
4472                 if (!ssh2_pkt_getbool(ssh)) {
4473                     /*
4474                      * We have received an unequivocal Access
4475                      * Denied. This can translate to a variety of
4476                      * messages:
4477                      *
4478                      *  - if we'd just tried "none" authentication,
4479                      *    it's not worth printing anything at all
4480                      *
4481                      *  - if we'd just tried a public key _offer_,
4482                      *    the message should be "Server refused our
4483                      *    key" (or no message at all if the key
4484                      *    came from Pageant)
4485                      *
4486                      *  - if we'd just tried anything else, the
4487                      *    message really should be "Access denied".
4488                      *
4489                      * Additionally, if we'd just tried password
4490                      * authentication, we should break out of this
4491                      * whole loop so as to go back to the username
4492                      * prompt.
4493                      */
4494                     if (s->type == AUTH_TYPE_NONE) {
4495                         /* do nothing */
4496                     } else if (s->type == AUTH_TYPE_PUBLICKEY_OFFER_LOUD ||
4497                                s->type == AUTH_TYPE_PUBLICKEY_OFFER_QUIET) {
4498                         if (s->type == AUTH_TYPE_PUBLICKEY_OFFER_LOUD)
4499                             c_write_str(ssh, "Server refused our key\r\n");
4500                         logevent("Server refused public key");
4501                     } else if (s->type==AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET) {
4502                         /* server declined keyboard-interactive; ignore */
4503                     } else {
4504                         c_write_str(ssh, "Access denied\r\n");
4505                         logevent("Access denied");
4506                         if (s->type == AUTH_TYPE_PASSWORD) {
4507                             s->we_are_in = FALSE;
4508                             break;
4509                         }
4510                     }
4511                 } else {
4512                     c_write_str(ssh, "Further authentication required\r\n");
4513                     logevent("Further authentication required");
4514                 }
4515
4516                 s->can_pubkey =
4517                     in_commasep_string("publickey", methods, methlen);
4518                 s->can_passwd =
4519                     in_commasep_string("password", methods, methlen);
4520                 s->can_keyb_inter = ssh->cfg.try_ki_auth &&
4521                     in_commasep_string("keyboard-interactive", methods, methlen);
4522             }
4523
4524             s->method = 0;
4525             ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
4526
4527             /*
4528              * Most password/passphrase prompts will be
4529              * non-echoing, so we set this to 0 by default.
4530              * Exception is that some keyboard-interactive prompts
4531              * can be echoing, in which case we'll set this to 1.
4532              */
4533             s->echo = 0;
4534
4535             if (!s->method && s->can_pubkey &&
4536                 agent_exists() && !s->tried_agent) {
4537                 /*
4538                  * Attempt public-key authentication using Pageant.
4539                  */
4540                 void *r;
4541                 s->authed = FALSE;
4542
4543                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
4544                 ssh->pkt_ctx |= SSH2_PKTCTX_PUBLICKEY;
4545
4546                 s->tried_agent = TRUE;
4547
4548                 logevent("Pageant is running. Requesting keys.");
4549
4550                 /* Request the keys held by the agent. */
4551                 PUT_32BIT(s->request, 1);
4552                 s->request[4] = SSH2_AGENTC_REQUEST_IDENTITIES;
4553                 agent_query(s->request, 5, &r, &s->responselen);
4554                 s->response = (unsigned char *) r;
4555                 if (s->response && s->responselen >= 5 &&
4556                     s->response[4] == SSH2_AGENT_IDENTITIES_ANSWER) {
4557                     s->p = s->response + 5;
4558                     s->nkeys = GET_32BIT(s->p);
4559                     s->p += 4;
4560                     {
4561                         char buf[64];
4562                         sprintf(buf, "Pageant has %d SSH2 keys", s->nkeys);
4563                         logevent(buf);
4564                     }
4565                     for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) {
4566                         void *vret;
4567
4568                         {
4569                             char buf[64];
4570                             sprintf(buf, "Trying Pageant key #%d", s->keyi);
4571                             logevent(buf);
4572                         }
4573                         s->pklen = GET_32BIT(s->p);
4574                         s->p += 4;
4575                         if (s->publickey_blob &&
4576                             s->pklen == s->publickey_bloblen &&
4577                             !memcmp(s->p, s->publickey_blob,
4578                                     s->publickey_bloblen)) {
4579                             logevent("This key matches configured key file");
4580                             s->tried_pubkey_config = 1;
4581                         }
4582                         s->pkblob = (char *)s->p;
4583                         s->p += s->pklen;
4584                         s->alglen = GET_32BIT(s->pkblob);
4585                         s->alg = s->pkblob + 4;
4586                         s->commentlen = GET_32BIT(s->p);
4587                         s->p += 4;
4588                         s->commentp = (char *)s->p;
4589                         s->p += s->commentlen;
4590                         ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
4591                         ssh2_pkt_addstring(ssh, s->username);
4592                         ssh2_pkt_addstring(ssh, "ssh-connection");      /* service requested */
4593                         ssh2_pkt_addstring(ssh, "publickey");   /* method */
4594                         ssh2_pkt_addbool(ssh, FALSE);   /* no signature included */
4595                         ssh2_pkt_addstring_start(ssh);
4596                         ssh2_pkt_addstring_data(ssh, s->alg, s->alglen);
4597                         ssh2_pkt_addstring_start(ssh);
4598                         ssh2_pkt_addstring_data(ssh, s->pkblob, s->pklen);
4599                         ssh2_pkt_send(ssh);
4600
4601                         crWaitUntilV(ispkt);
4602                         if (ssh->pktin.type != SSH2_MSG_USERAUTH_PK_OK) {
4603                             logevent("Key refused");
4604                             continue;
4605                         }
4606
4607                         if (flags & FLAG_VERBOSE) {
4608                             c_write_str(ssh, "Authenticating with "
4609                                         "public key \"");
4610                             c_write(ssh, s->commentp, s->commentlen);
4611                             c_write_str(ssh, "\" from agent\r\n");
4612                         }
4613
4614                         /*
4615                          * Server is willing to accept the key.
4616                          * Construct a SIGN_REQUEST.
4617                          */
4618                         ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
4619                         ssh2_pkt_addstring(ssh, s->username);
4620                         ssh2_pkt_addstring(ssh, "ssh-connection");      /* service requested */
4621                         ssh2_pkt_addstring(ssh, "publickey");   /* method */
4622                         ssh2_pkt_addbool(ssh, TRUE);
4623                         ssh2_pkt_addstring_start(ssh);
4624                         ssh2_pkt_addstring_data(ssh, s->alg, s->alglen);
4625                         ssh2_pkt_addstring_start(ssh);
4626                         ssh2_pkt_addstring_data(ssh, s->pkblob, s->pklen);
4627
4628                         s->siglen = ssh->pktout.length - 5 + 4 + 20;
4629                         s->len = 1;       /* message type */
4630                         s->len += 4 + s->pklen; /* key blob */
4631                         s->len += 4 + s->siglen;        /* data to sign */
4632                         s->len += 4;      /* flags */
4633                         s->agentreq = smalloc(4 + s->len);
4634                         PUT_32BIT(s->agentreq, s->len);
4635                         s->q = s->agentreq + 4;
4636                         *s->q++ = SSH2_AGENTC_SIGN_REQUEST;
4637                         PUT_32BIT(s->q, s->pklen);
4638                         s->q += 4;
4639                         memcpy(s->q, s->pkblob, s->pklen);
4640                         s->q += s->pklen;
4641                         PUT_32BIT(s->q, s->siglen);
4642                         s->q += 4;
4643                         /* Now the data to be signed... */
4644                         PUT_32BIT(s->q, 20);
4645                         s->q += 4;
4646                         memcpy(s->q, ssh->v2_session_id, 20);
4647                         s->q += 20;
4648                         memcpy(s->q, ssh->pktout.data + 5,
4649                                ssh->pktout.length - 5);
4650                         s->q += ssh->pktout.length - 5;
4651                         /* And finally the (zero) flags word. */
4652                         PUT_32BIT(s->q, 0);
4653                         agent_query(s->agentreq, s->len + 4, &vret, &s->retlen);
4654                         s->ret = vret;
4655                         sfree(s->agentreq);
4656                         if (s->ret) {
4657                             if (s->ret[4] == SSH2_AGENT_SIGN_RESPONSE) {
4658                                 logevent("Sending Pageant's response");
4659                                 ssh2_add_sigblob(ssh, s->pkblob, s->pklen,
4660                                                  s->ret + 9,
4661                                                  GET_32BIT(s->ret + 5));
4662                                 ssh2_pkt_send(ssh);
4663                                 s->authed = TRUE;
4664                                 break;
4665                             } else {
4666                                 logevent
4667                                     ("Pageant failed to answer challenge");
4668                                 sfree(s->ret);
4669                             }
4670                         }
4671                     }
4672                     if (s->authed)
4673                         continue;
4674                 }
4675             }
4676
4677             if (!s->method && s->can_pubkey && s->publickey_blob
4678                 && !s->tried_pubkey_config) {
4679                 unsigned char *pub_blob;
4680                 char *algorithm, *comment;
4681                 int pub_blob_len;
4682
4683                 s->tried_pubkey_config = TRUE;
4684
4685                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
4686                 ssh->pkt_ctx |= SSH2_PKTCTX_PUBLICKEY;
4687
4688                 /*
4689                  * Try the public key supplied in the configuration.
4690                  *
4691                  * First, offer the public blob to see if the server is
4692                  * willing to accept it.
4693                  */
4694                 pub_blob =
4695                     (unsigned char *)ssh2_userkey_loadpub(ssh->cfg.keyfile,
4696                                                           &algorithm,
4697                                                           &pub_blob_len);
4698                 if (pub_blob) {
4699                     ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
4700                     ssh2_pkt_addstring(ssh, s->username);
4701                     ssh2_pkt_addstring(ssh, "ssh-connection");  /* service requested */
4702                     ssh2_pkt_addstring(ssh, "publickey");       /* method */
4703                     ssh2_pkt_addbool(ssh, FALSE);       /* no signature included */
4704                     ssh2_pkt_addstring(ssh, algorithm);
4705                     ssh2_pkt_addstring_start(ssh);
4706                     ssh2_pkt_addstring_data(ssh, (char *)pub_blob,
4707                                             pub_blob_len);
4708                     ssh2_pkt_send(ssh);
4709                     logevent("Offered public key");     /* FIXME */
4710
4711                     crWaitUntilV(ispkt);
4712                     if (ssh->pktin.type != SSH2_MSG_USERAUTH_PK_OK) {
4713                         s->gotit = TRUE;
4714                         s->type = AUTH_TYPE_PUBLICKEY_OFFER_LOUD;
4715                         continue;      /* key refused; give up on it */
4716                     }
4717
4718                     logevent("Offer of public key accepted");
4719                     /*
4720                      * Actually attempt a serious authentication using
4721                      * the key.
4722                      */
4723                     if (ssh2_userkey_encrypted(ssh->cfg.keyfile, &comment)) {
4724                         sprintf(s->pwprompt,
4725                                 "Passphrase for key \"%.100s\": ",
4726                                 comment);
4727                         s->need_pw = TRUE;
4728                     } else {
4729                         s->need_pw = FALSE;
4730                     }
4731                     c_write_str(ssh, "Authenticating with public key \"");
4732                     c_write_str(ssh, comment);
4733                     c_write_str(ssh, "\"\r\n");
4734                     s->method = AUTH_PUBLICKEY_FILE;
4735                 }
4736             }
4737
4738             if (!s->method && s->can_keyb_inter && !s->tried_keyb_inter) {
4739                 s->method = AUTH_KEYBOARD_INTERACTIVE;
4740                 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
4741                 s->tried_keyb_inter = TRUE;
4742
4743                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
4744                 ssh->pkt_ctx |= SSH2_PKTCTX_KBDINTER;
4745
4746                 ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
4747                 ssh2_pkt_addstring(ssh, s->username);
4748                 ssh2_pkt_addstring(ssh, "ssh-connection");      /* service requested */
4749                 ssh2_pkt_addstring(ssh, "keyboard-interactive");        /* method */
4750                 ssh2_pkt_addstring(ssh, ""); /* lang */
4751                 ssh2_pkt_addstring(ssh, "");
4752                 ssh2_pkt_send(ssh);
4753
4754                 crWaitUntilV(ispkt);
4755                 if (ssh->pktin.type != SSH2_MSG_USERAUTH_INFO_REQUEST) {
4756                     if (ssh->pktin.type == SSH2_MSG_USERAUTH_FAILURE)
4757                         s->gotit = TRUE;
4758                     logevent("Keyboard-interactive authentication refused");
4759                     s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET;
4760                     continue;
4761                 }
4762
4763                 s->kbd_inter_running = TRUE;
4764                 s->curr_prompt = 0;
4765             }
4766
4767             if (s->kbd_inter_running) {
4768                 s->method = AUTH_KEYBOARD_INTERACTIVE;
4769                 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
4770                 s->tried_keyb_inter = TRUE;
4771
4772                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
4773                 ssh->pkt_ctx |= SSH2_PKTCTX_KBDINTER;
4774
4775                 if (s->curr_prompt == 0) {
4776                     /*
4777                      * We've got a fresh USERAUTH_INFO_REQUEST.
4778                      * Display header data, and start going through
4779                      * the prompts.
4780                      */
4781                     char *name, *inst, *lang;
4782                     int name_len, inst_len, lang_len;
4783
4784                     ssh2_pkt_getstring(ssh, &name, &name_len);
4785                     ssh2_pkt_getstring(ssh, &inst, &inst_len);
4786                     ssh2_pkt_getstring(ssh, &lang, &lang_len);
4787                     if (name_len > 0) {
4788                         c_write_untrusted(ssh, name, name_len);
4789                         c_write_str(ssh, "\r\n");
4790                     }
4791                     if (inst_len > 0) {
4792                         c_write_untrusted(ssh, inst, inst_len);
4793                         c_write_str(ssh, "\r\n");
4794                     }
4795                     s->num_prompts = ssh2_pkt_getuint32(ssh);
4796                 }
4797
4798                 /*
4799                  * If there are prompts remaining in the packet,
4800                  * display one and get a response.
4801                  */
4802                 if (s->curr_prompt < s->num_prompts) {
4803                     char *prompt;
4804                     int prompt_len;
4805
4806                     ssh2_pkt_getstring(ssh, &prompt, &prompt_len);
4807                     if (prompt_len > 0) {
4808                         strncpy(s->pwprompt, prompt, sizeof(s->pwprompt));
4809                         s->pwprompt[prompt_len < sizeof(s->pwprompt) ?
4810                                     prompt_len : sizeof(s->pwprompt)-1] = '\0';
4811                     } else {
4812                         strcpy(s->pwprompt,
4813                                "<server failed to send prompt>: ");
4814                     }
4815                     s->echo = ssh2_pkt_getbool(ssh);
4816                     s->need_pw = TRUE;
4817                 } else
4818                     s->need_pw = FALSE;
4819             }
4820
4821             if (!s->method && s->can_passwd) {
4822                 s->method = AUTH_PASSWORD;
4823                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
4824                 ssh->pkt_ctx |= SSH2_PKTCTX_PASSWORD;
4825                 sprintf(s->pwprompt, "%.90s@%.90s's password: ", s->username,
4826                         ssh->savedhost);
4827                 s->need_pw = TRUE;
4828             }
4829
4830             if (s->need_pw) {
4831                 if (ssh_get_line) {
4832                     if (!ssh_get_line(s->pwprompt, s->password,
4833                                       sizeof(s->password), TRUE)) {
4834                         /*
4835                          * get_line failed to get a password (for
4836                          * example because one was supplied on the
4837                          * command line which has already failed to
4838                          * work). Terminate.
4839                          */
4840                         ssh2_pkt_init(ssh, SSH2_MSG_DISCONNECT);
4841                         ssh2_pkt_adduint32(ssh,SSH2_DISCONNECT_BY_APPLICATION);
4842                         ssh2_pkt_addstring(ssh, "No more passwords available"
4843                                            " to try");
4844                         ssh2_pkt_addstring(ssh, "en");  /* language tag */
4845                         ssh2_pkt_send(ssh);
4846                         logevent("Unable to authenticate");
4847                         connection_fatal(ssh->frontend,
4848                                          "Unable to authenticate");
4849                         ssh->state = SSH_STATE_CLOSED;
4850                         crReturnV;
4851                     }
4852                 } else {
4853                     int ret;           /* need not be saved across crReturn */
4854                     c_write_untrusted(ssh, s->pwprompt, strlen(s->pwprompt));
4855                     ssh->send_ok = 1;
4856
4857                     setup_userpass_input(ssh, s->password,
4858                                          sizeof(s->password), s->echo);
4859                     do {
4860                         crWaitUntilV(!ispkt);
4861                         ret = process_userpass_input(ssh, in, inlen);
4862                     } while (ret == 0);
4863                     if (ret < 0)
4864                         cleanup_exit(0);
4865                     c_write_str(ssh, "\r\n");
4866                 }
4867             }
4868
4869             if (s->method == AUTH_PUBLICKEY_FILE) {
4870                 /*
4871                  * We have our passphrase. Now try the actual authentication.
4872                  */
4873                 struct ssh2_userkey *key;
4874
4875                 key = ssh2_load_userkey(ssh->cfg.keyfile, s->password);
4876                 if (key == SSH2_WRONG_PASSPHRASE || key == NULL) {
4877                     if (key == SSH2_WRONG_PASSPHRASE) {
4878                         c_write_str(ssh, "Wrong passphrase\r\n");
4879                         s->tried_pubkey_config = FALSE;
4880                     } else {
4881                         c_write_str(ssh, "Unable to load private key\r\n");
4882                         s->tried_pubkey_config = TRUE;
4883                     }
4884                     /* Send a spurious AUTH_NONE to return to the top. */
4885                     ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
4886                     ssh2_pkt_addstring(ssh, s->username);
4887                     ssh2_pkt_addstring(ssh, "ssh-connection");  /* service requested */
4888                     ssh2_pkt_addstring(ssh, "none");    /* method */
4889                     ssh2_pkt_send(ssh);
4890                     s->type = AUTH_TYPE_NONE;
4891                 } else {
4892                     unsigned char *pkblob, *sigblob, *sigdata;
4893                     int pkblob_len, sigblob_len, sigdata_len;
4894
4895                     /*
4896                      * We have loaded the private key and the server
4897                      * has announced that it's willing to accept it.
4898                      * Hallelujah. Generate a signature and send it.
4899                      */
4900                     ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
4901                     ssh2_pkt_addstring(ssh, s->username);
4902                     ssh2_pkt_addstring(ssh, "ssh-connection");  /* service requested */
4903                     ssh2_pkt_addstring(ssh, "publickey");       /* method */
4904                     ssh2_pkt_addbool(ssh, TRUE);
4905                     ssh2_pkt_addstring(ssh, key->alg->name);
4906                     pkblob = key->alg->public_blob(key->data, &pkblob_len);
4907                     ssh2_pkt_addstring_start(ssh);
4908                     ssh2_pkt_addstring_data(ssh, (char *)pkblob, pkblob_len);
4909
4910                     /*
4911                      * The data to be signed is:
4912                      *
4913                      *   string  session-id
4914                      *
4915                      * followed by everything so far placed in the
4916                      * outgoing packet.
4917                      */
4918                     sigdata_len = ssh->pktout.length - 5 + 4 + 20;
4919                     sigdata = smalloc(sigdata_len);
4920                     PUT_32BIT(sigdata, 20);
4921                     memcpy(sigdata + 4, ssh->v2_session_id, 20);
4922                     memcpy(sigdata + 24, ssh->pktout.data + 5,
4923                            ssh->pktout.length - 5);
4924                     sigblob = key->alg->sign(key->data, (char *)sigdata,
4925                                              sigdata_len, &sigblob_len);
4926                     ssh2_add_sigblob(ssh, pkblob, pkblob_len,
4927                                      sigblob, sigblob_len);
4928                     sfree(pkblob);
4929                     sfree(sigblob);
4930                     sfree(sigdata);
4931
4932                     ssh2_pkt_send(ssh);
4933                     s->type = AUTH_TYPE_PUBLICKEY;
4934                 }
4935             } else if (s->method == AUTH_PASSWORD) {
4936                 /*
4937                  * We send the password packet lumped tightly together with
4938                  * an SSH_MSG_IGNORE packet. The IGNORE packet contains a
4939                  * string long enough to make the total length of the two
4940                  * packets constant. This should ensure that a passive
4941                  * listener doing traffic analyis can't work out the length
4942                  * of the password.
4943                  *
4944                  * For this to work, we need an assumption about the
4945                  * maximum length of the password packet. I think 256 is
4946                  * pretty conservative. Anyone using a password longer than
4947                  * that probably doesn't have much to worry about from
4948                  * people who find out how long their password is!
4949                  */
4950                 ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
4951                 ssh2_pkt_addstring(ssh, s->username);
4952                 ssh2_pkt_addstring(ssh, "ssh-connection");      /* service requested */
4953                 ssh2_pkt_addstring(ssh, "password");
4954                 ssh2_pkt_addbool(ssh, FALSE);
4955                 ssh2_pkt_addstring(ssh, s->password);
4956                 memset(s->password, 0, sizeof(s->password));
4957                 ssh2_pkt_defer(ssh);
4958                 /*
4959                  * We'll include a string that's an exact multiple of the
4960                  * cipher block size. If the cipher is NULL for some
4961                  * reason, we don't do this trick at all because we gain
4962                  * nothing by it.
4963                  */
4964                 if (ssh->cscipher) {
4965                     int stringlen, i;
4966
4967                     stringlen = (256 - ssh->deferred_len);
4968                     stringlen += ssh->cscipher->blksize - 1;
4969                     stringlen -= (stringlen % ssh->cscipher->blksize);
4970                     if (ssh->cscomp) {
4971                         /*
4972                          * Temporarily disable actual compression,
4973                          * so we can guarantee to get this string
4974                          * exactly the length we want it. The
4975                          * compression-disabling routine should
4976                          * return an integer indicating how many
4977                          * bytes we should adjust our string length
4978                          * by.
4979                          */
4980                         stringlen -=
4981                             ssh->cscomp->disable_compression(ssh->cs_comp_ctx);
4982                     }
4983                     ssh2_pkt_init(ssh, SSH2_MSG_IGNORE);
4984                     ssh2_pkt_addstring_start(ssh);
4985                     for (i = 0; i < stringlen; i++) {
4986                         char c = (char) random_byte();
4987                         ssh2_pkt_addstring_data(ssh, &c, 1);
4988                     }
4989                     ssh2_pkt_defer(ssh);
4990                 }
4991                 ssh_pkt_defersend(ssh);
4992                 logevent("Sent password");
4993                 s->type = AUTH_TYPE_PASSWORD;
4994             } else if (s->method == AUTH_KEYBOARD_INTERACTIVE) {
4995                 if (s->curr_prompt == 0) {
4996                     ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE);
4997                     ssh2_pkt_adduint32(ssh, s->num_prompts);
4998                 }
4999                 if (s->need_pw) {      /* only add pw if we just got one! */
5000                     ssh2_pkt_addstring(ssh, s->password);
5001                     memset(s->password, 0, sizeof(s->password));
5002                     s->curr_prompt++;
5003                 }
5004                 if (s->curr_prompt >= s->num_prompts) {
5005                     ssh2_pkt_send(ssh);
5006                 } else {
5007                     /*
5008                      * If there are prompts remaining, we set
5009                      * `gotit' so that we won't attempt to get
5010                      * another packet. Then we go back round the
5011                      * loop and will end up retrieving another
5012                      * prompt out of the existing packet. Funky or
5013                      * what?
5014                      */
5015                     s->gotit = TRUE;
5016                 }
5017                 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
5018             } else {
5019                 c_write_str(ssh, "No supported authentication methods"
5020                             " left to try!\r\n");
5021                 logevent("No supported authentications offered."
5022                          " Disconnecting");
5023                 ssh2_pkt_init(ssh, SSH2_MSG_DISCONNECT);
5024                 ssh2_pkt_adduint32(ssh, SSH2_DISCONNECT_BY_APPLICATION);
5025                 ssh2_pkt_addstring(ssh, "No supported authentication"
5026                                    " methods available");
5027                 ssh2_pkt_addstring(ssh, "en");  /* language tag */
5028                 ssh2_pkt_send(ssh);
5029                 ssh->state = SSH_STATE_CLOSED;
5030                 crReturnV;
5031             }
5032         }
5033     } while (!s->we_are_in);
5034
5035     /*
5036      * Now we're authenticated for the connection protocol. The
5037      * connection protocol will automatically have started at this
5038      * point; there's no need to send SERVICE_REQUEST.
5039      */
5040
5041     /*
5042      * So now create a channel with a session in it.
5043      */
5044     ssh->channels = newtree234(ssh_channelcmp);
5045     ssh->mainchan = smalloc(sizeof(struct ssh_channel));
5046     ssh->mainchan->ssh = ssh;
5047     ssh->mainchan->localid = alloc_channel_id(ssh);
5048     ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_OPEN);
5049     ssh2_pkt_addstring(ssh, "session");
5050     ssh2_pkt_adduint32(ssh, ssh->mainchan->localid);
5051     ssh->mainchan->v.v2.locwindow = OUR_V2_WINSIZE;
5052     ssh2_pkt_adduint32(ssh, ssh->mainchan->v.v2.locwindow);/* our window size */
5053     ssh2_pkt_adduint32(ssh, 0x4000UL);      /* our max pkt size */
5054     ssh2_pkt_send(ssh);
5055     crWaitUntilV(ispkt);
5056     if (ssh->pktin.type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
5057         bombout((ssh,"Server refused to open a session"));
5058         crReturnV;
5059         /* FIXME: error data comes back in FAILURE packet */
5060     }
5061     if (ssh2_pkt_getuint32(ssh) != ssh->mainchan->localid) {
5062         bombout((ssh,"Server's channel confirmation cited wrong channel"));
5063         crReturnV;
5064     }
5065     ssh->mainchan->remoteid = ssh2_pkt_getuint32(ssh);
5066     ssh->mainchan->type = CHAN_MAINSESSION;
5067     ssh->mainchan->closes = 0;
5068     ssh->mainchan->v.v2.remwindow = ssh2_pkt_getuint32(ssh);
5069     ssh->mainchan->v.v2.remmaxpkt = ssh2_pkt_getuint32(ssh);
5070     bufchain_init(&ssh->mainchan->v.v2.outbuffer);
5071     add234(ssh->channels, ssh->mainchan);
5072     logevent("Opened channel for session");
5073
5074     /*
5075      * Potentially enable X11 forwarding.
5076      */
5077     if (ssh->cfg.x11_forward) {
5078         char proto[20], data[64];
5079         logevent("Requesting X11 forwarding");
5080         ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
5081                                        data, sizeof(data), ssh->cfg.x11_auth);
5082         x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display);
5083         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
5084         ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);
5085         ssh2_pkt_addstring(ssh, "x11-req");
5086         ssh2_pkt_addbool(ssh, 1);              /* want reply */
5087         ssh2_pkt_addbool(ssh, 0);              /* many connections */
5088         ssh2_pkt_addstring(ssh, proto);
5089         ssh2_pkt_addstring(ssh, data);
5090         ssh2_pkt_adduint32(ssh, x11_get_screen_number(ssh->cfg.x11_display));
5091         ssh2_pkt_send(ssh);
5092
5093         do {
5094             crWaitUntilV(ispkt);
5095             if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
5096                 unsigned i = ssh2_pkt_getuint32(ssh);
5097                 struct ssh_channel *c;
5098                 c = find234(ssh->channels, &i, ssh_channelfind);
5099                 if (!c)
5100                     continue;          /* nonexistent channel */
5101                 c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
5102             }
5103         } while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
5104
5105         if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
5106             if (ssh->pktin.type != SSH2_MSG_CHANNEL_FAILURE) {
5107                 bombout((ssh,"Unexpected response to X11 forwarding request:"
5108                          " packet type %d", ssh->pktin.type));
5109                 crReturnV;
5110             }
5111             logevent("X11 forwarding refused");
5112         } else {
5113             logevent("X11 forwarding enabled");
5114             ssh->X11_fwd_enabled = TRUE;
5115         }
5116     }
5117
5118     /*
5119      * Enable port forwardings.
5120      */
5121     {
5122         char type;
5123         int n;
5124         int sport,dport,sserv,dserv;
5125         char sports[256], dports[256], saddr[256], host[256];
5126
5127         ssh->rportfwds = newtree234(ssh_rportcmp_ssh2);
5128         /* Add port forwardings. */
5129         ssh->portfwd_strptr = ssh->cfg.portfwd;
5130         while (*ssh->portfwd_strptr) {
5131             type = *ssh->portfwd_strptr++;
5132             saddr[0] = '\0';
5133             n = 0;
5134             while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != '\t') {
5135                 if (*ssh->portfwd_strptr == ':') {
5136                     /*
5137                      * We've seen a colon in the middle of the
5138                      * source port number. This means that
5139                      * everything we've seen until now is the
5140                      * source _address_, so we'll move it into
5141                      * saddr and start sports from the beginning
5142                      * again.
5143                      */
5144                     ssh->portfwd_strptr++;
5145                     sports[n] = '\0';
5146                     strcpy(saddr, sports);
5147                     n = 0;
5148                 }
5149                 if (n < 255) sports[n++] = *ssh->portfwd_strptr++;
5150             }
5151             sports[n] = 0;
5152             if (*ssh->portfwd_strptr == '\t')
5153                 ssh->portfwd_strptr++;
5154             n = 0;
5155             while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != ':') {
5156                 if (n < 255) host[n++] = *ssh->portfwd_strptr++;
5157             }
5158             host[n] = 0;
5159             if (*ssh->portfwd_strptr == ':')
5160                 ssh->portfwd_strptr++;
5161             n = 0;
5162             while (*ssh->portfwd_strptr) {
5163                 if (n < 255) dports[n++] = *ssh->portfwd_strptr++;
5164             }
5165             dports[n] = 0;
5166             ssh->portfwd_strptr++;
5167             dport = atoi(dports);
5168             dserv = 0;
5169             if (dport == 0) {
5170                 dserv = 1;
5171                 dport = net_service_lookup(dports);
5172                 if (!dport) {
5173                     logeventf(ssh, "Service lookup failed for destination"
5174                               " port \"%s\"", dports);
5175                 }
5176             }
5177             sport = atoi(sports);
5178             sserv = 0;
5179             if (sport == 0) {
5180                 sserv = 1;
5181                 sport = net_service_lookup(sports);
5182                 if (!sport) {
5183                     logeventf(ssh, "Service lookup failed for source"
5184                               " port \"%s\"", sports);
5185                 }
5186             }
5187             if (sport && dport) {
5188                 if (type == 'L') {
5189                     pfd_addforward(host, dport, *saddr ? saddr : NULL,
5190                                    sport, ssh, &ssh->cfg);
5191                     logeventf(ssh, "Local port %.*s%.*s%.*s%.*s%d%.*s"
5192                               " forwarding to %s:%.*s%.*s%d%.*s",
5193                               (int)(*saddr?strlen(saddr):0), *saddr?saddr:NULL,
5194                               (int)(*saddr?1:0), ":",
5195                               (int)(sserv ? strlen(sports) : 0), sports,
5196                               sserv, "(", sport, sserv, ")",
5197                               host,
5198                               (int)(dserv ? strlen(dports) : 0), dports,
5199                               dserv, "(", dport, dserv, ")");
5200                 } else {
5201                     struct ssh_rportfwd *pf;
5202                     pf = smalloc(sizeof(*pf));
5203                     strcpy(pf->dhost, host);
5204                     pf->dport = dport;
5205                     pf->sport = sport;
5206                     if (add234(ssh->rportfwds, pf) != pf) {
5207                         logeventf(ssh, "Duplicate remote port forwarding"
5208                                   " to %s:%d", host, dport);
5209                         sfree(pf);
5210                     } else {
5211                         logeventf(ssh, "Requesting remote port "
5212                                   "%.*s%.*s%.*s%.*s%d%.*s"
5213                                   " forward to %s:%.*s%.*s%d%.*s",
5214                                   (int)(*saddr?strlen(saddr):0),
5215                                   *saddr?saddr:NULL,
5216                                   (int)(*saddr?1:0), ":",
5217                                   (int)(sserv ? strlen(sports) : 0), sports,
5218                                   sserv, "(", sport, sserv, ")",
5219                                   host,
5220                                   (int)(dserv ? strlen(dports) : 0), dports,
5221                                   dserv, "(", dport, dserv, ")");
5222                         ssh2_pkt_init(ssh, SSH2_MSG_GLOBAL_REQUEST);
5223                         ssh2_pkt_addstring(ssh, "tcpip-forward");
5224                         ssh2_pkt_addbool(ssh, 1);/* want reply */
5225                         if (*saddr)
5226                             ssh2_pkt_addstring(ssh, saddr);
5227                         if (ssh->cfg.rport_acceptall)
5228                             ssh2_pkt_addstring(ssh, "0.0.0.0");
5229                         else
5230                             ssh2_pkt_addstring(ssh, "127.0.0.1");
5231                         ssh2_pkt_adduint32(ssh, sport);
5232                         ssh2_pkt_send(ssh);
5233
5234                         do {
5235                             crWaitUntilV(ispkt);
5236                             if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
5237                                 unsigned i = ssh2_pkt_getuint32(ssh);
5238                                 struct ssh_channel *c;
5239                                 c = find234(ssh->channels, &i, ssh_channelfind);
5240                                 if (!c)
5241                                     continue;/* nonexistent channel */
5242                                 c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
5243                             }
5244                         } while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
5245
5246                         if (ssh->pktin.type != SSH2_MSG_REQUEST_SUCCESS) {
5247                             if (ssh->pktin.type != SSH2_MSG_REQUEST_FAILURE) {
5248                                 bombout((ssh,"Unexpected response to port "
5249                                          "forwarding request: packet type %d",
5250                                          ssh->pktin.type));
5251                                 crReturnV;
5252                             }
5253                             logevent("Server refused this port forwarding");
5254                         } else {
5255                             logevent("Remote port forwarding enabled");
5256                         }
5257                     }
5258                 }
5259             }
5260         }
5261     }
5262
5263     /*
5264      * Potentially enable agent forwarding.
5265      */
5266     if (ssh->cfg.agentfwd && agent_exists()) {
5267         logevent("Requesting OpenSSH-style agent forwarding");
5268         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
5269         ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);
5270         ssh2_pkt_addstring(ssh, "auth-agent-req@openssh.com");
5271         ssh2_pkt_addbool(ssh, 1);              /* want reply */
5272         ssh2_pkt_send(ssh);
5273
5274         do {
5275             crWaitUntilV(ispkt);
5276             if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
5277                 unsigned i = ssh2_pkt_getuint32(ssh);
5278                 struct ssh_channel *c;
5279                 c = find234(ssh->channels, &i, ssh_channelfind);
5280                 if (!c)
5281                     continue;          /* nonexistent channel */
5282                 c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
5283             }
5284         } while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
5285
5286         if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
5287             if (ssh->pktin.type != SSH2_MSG_CHANNEL_FAILURE) {
5288                 bombout((ssh,"Unexpected response to agent forwarding request:"
5289                          " packet type %d", ssh->pktin.type));
5290                 crReturnV;
5291             }
5292             logevent("Agent forwarding refused");
5293         } else {
5294             logevent("Agent forwarding enabled");
5295             ssh->agentfwd_enabled = TRUE;
5296         }
5297     }
5298
5299     /*
5300      * Now allocate a pty for the session.
5301      */
5302     if (!ssh->cfg.nopty) {
5303         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
5304         ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);       /* recipient channel */
5305         ssh2_pkt_addstring(ssh, "pty-req");
5306         ssh2_pkt_addbool(ssh, 1);              /* want reply */
5307         ssh2_pkt_addstring(ssh, ssh->cfg.termtype);
5308         ssh2_pkt_adduint32(ssh, ssh->term_width);
5309         ssh2_pkt_adduint32(ssh, ssh->term_height);
5310         ssh2_pkt_adduint32(ssh, 0);            /* pixel width */
5311         ssh2_pkt_adduint32(ssh, 0);            /* pixel height */
5312         ssh2_pkt_addstring_start(ssh);
5313         ssh2_pkt_addstring_data(ssh, "\0", 1);  /* TTY_OP_END, no special options */
5314         ssh2_pkt_send(ssh);
5315         ssh->state = SSH_STATE_INTERMED;
5316
5317         do {
5318             crWaitUntilV(ispkt);
5319             if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
5320                 unsigned i = ssh2_pkt_getuint32(ssh);
5321                 struct ssh_channel *c;
5322                 c = find234(ssh->channels, &i, ssh_channelfind);
5323                 if (!c)
5324                     continue;          /* nonexistent channel */
5325                 c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
5326             }
5327         } while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
5328
5329         if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
5330             if (ssh->pktin.type != SSH2_MSG_CHANNEL_FAILURE) {
5331                 bombout((ssh,"Unexpected response to pty request:"
5332                          " packet type %d", ssh->pktin.type));
5333                 crReturnV;
5334             }
5335             c_write_str(ssh, "Server refused to allocate pty\r\n");
5336             ssh->editing = ssh->echoing = 1;
5337         } else {
5338             logevent("Allocated pty");
5339         }
5340     } else {
5341         ssh->editing = ssh->echoing = 1;
5342     }
5343
5344     /*
5345      * Start a shell or a remote command. We may have to attempt
5346      * this twice if the config data has provided a second choice
5347      * of command.
5348      */
5349     while (1) {
5350         int subsys;
5351         char *cmd;
5352
5353         if (ssh->fallback_cmd) {
5354             subsys = ssh->cfg.ssh_subsys2;
5355             cmd = ssh->cfg.remote_cmd_ptr2;
5356         } else {
5357             subsys = ssh->cfg.ssh_subsys;
5358             cmd = ssh->cfg.remote_cmd_ptr;
5359         }
5360
5361         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
5362         ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);       /* recipient channel */
5363         if (subsys) {
5364             ssh2_pkt_addstring(ssh, "subsystem");
5365             ssh2_pkt_addbool(ssh, 1);          /* want reply */
5366             ssh2_pkt_addstring(ssh, cmd);
5367         } else if (*cmd) {
5368             ssh2_pkt_addstring(ssh, "exec");
5369             ssh2_pkt_addbool(ssh, 1);          /* want reply */
5370             ssh2_pkt_addstring(ssh, cmd);
5371         } else {
5372             ssh2_pkt_addstring(ssh, "shell");
5373             ssh2_pkt_addbool(ssh, 1);          /* want reply */
5374         }
5375         ssh2_pkt_send(ssh);
5376         do {
5377             crWaitUntilV(ispkt);
5378             if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
5379                 unsigned i = ssh2_pkt_getuint32(ssh);
5380                 struct ssh_channel *c;
5381                 c = find234(ssh->channels, &i, ssh_channelfind);
5382                 if (!c)
5383                     continue;          /* nonexistent channel */
5384                 c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
5385             }
5386         } while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
5387         if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
5388             if (ssh->pktin.type != SSH2_MSG_CHANNEL_FAILURE) {
5389                 bombout((ssh,"Unexpected response to shell/command request:"
5390                          " packet type %d", ssh->pktin.type));
5391                 crReturnV;
5392             }
5393             /*
5394              * We failed to start the command. If this is the
5395              * fallback command, we really are finished; if it's
5396              * not, and if the fallback command exists, try falling
5397              * back to it before complaining.
5398              */
5399             if (!ssh->fallback_cmd && ssh->cfg.remote_cmd_ptr2 != NULL) {
5400                 logevent("Primary command failed; attempting fallback");
5401                 ssh->fallback_cmd = TRUE;
5402                 continue;
5403             }
5404             bombout((ssh,"Server refused to start a shell/command"));
5405             crReturnV;
5406         } else {
5407             logevent("Started a shell/command");
5408         }
5409         break;
5410     }
5411
5412     ssh->state = SSH_STATE_SESSION;
5413     if (ssh->size_needed)
5414         ssh_size(ssh, ssh->term_width, ssh->term_height);
5415     if (ssh->eof_needed)
5416         ssh_special(ssh, TS_EOF);
5417
5418     /*
5419      * Transfer data!
5420      */
5421     if (ssh->ldisc)
5422         ldisc_send(ssh->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
5423     ssh->send_ok = 1;
5424     while (1) {
5425         crReturnV;
5426         s->try_send = FALSE;
5427         if (ispkt) {
5428             if (ssh->pktin.type == SSH2_MSG_CHANNEL_DATA ||
5429                 ssh->pktin.type == SSH2_MSG_CHANNEL_EXTENDED_DATA) {
5430                 char *data;
5431                 int length;
5432                 unsigned i = ssh2_pkt_getuint32(ssh);
5433                 struct ssh_channel *c;
5434                 c = find234(ssh->channels, &i, ssh_channelfind);
5435                 if (!c)
5436                     continue;          /* nonexistent channel */
5437                 if (ssh->pktin.type == SSH2_MSG_CHANNEL_EXTENDED_DATA &&
5438                     ssh2_pkt_getuint32(ssh) != SSH2_EXTENDED_DATA_STDERR)
5439                     continue;          /* extended but not stderr */
5440                 ssh2_pkt_getstring(ssh, &data, &length);
5441                 if (data) {
5442                     int bufsize;
5443                     c->v.v2.locwindow -= length;
5444                     switch (c->type) {
5445                       case CHAN_MAINSESSION:
5446                         bufsize =
5447                             from_backend(ssh->frontend, ssh->pktin.type ==
5448                                          SSH2_MSG_CHANNEL_EXTENDED_DATA,
5449                                          data, length);
5450                         break;
5451                       case CHAN_X11:
5452                         bufsize = x11_send(c->u.x11.s, data, length);
5453                         break;
5454                       case CHAN_SOCKDATA:
5455                         bufsize = pfd_send(c->u.pfd.s, data, length);
5456                         break;
5457                       case CHAN_AGENT:
5458                         while (length > 0) {
5459                             if (c->u.a.lensofar < 4) {
5460                                 int l = min(4 - c->u.a.lensofar, length);
5461                                 memcpy(c->u.a.msglen + c->u.a.lensofar,
5462                                        data, l);
5463                                 data += l;
5464                                 length -= l;
5465                                 c->u.a.lensofar += l;
5466                             }
5467                             if (c->u.a.lensofar == 4) {
5468                                 c->u.a.totallen =
5469                                     4 + GET_32BIT(c->u.a.msglen);
5470                                 c->u.a.message = smalloc(c->u.a.totallen);
5471                                 memcpy(c->u.a.message, c->u.a.msglen, 4);
5472                             }
5473                             if (c->u.a.lensofar >= 4 && length > 0) {
5474                                 int l =
5475                                     min(c->u.a.totallen - c->u.a.lensofar,
5476                                         length);
5477                                 memcpy(c->u.a.message + c->u.a.lensofar,
5478                                        data, l);
5479                                 data += l;
5480                                 length -= l;
5481                                 c->u.a.lensofar += l;
5482                             }
5483                             if (c->u.a.lensofar == c->u.a.totallen) {
5484                                 void *reply, *sentreply;
5485                                 int replylen;
5486                                 agent_query(c->u.a.message,
5487                                             c->u.a.totallen, &reply,
5488                                             &replylen);
5489                                 if (reply)
5490                                     sentreply = reply;
5491                                 else {
5492                                     /* Fake SSH_AGENT_FAILURE. */
5493                                     sentreply = "\0\0\0\1\5";
5494                                     replylen = 5;
5495                                 }
5496                                 ssh2_add_channel_data(c, sentreply, replylen);
5497                                 s->try_send = TRUE;
5498                                 if (reply)
5499                                     sfree(reply);
5500                                 sfree(c->u.a.message);
5501                                 c->u.a.lensofar = 0;
5502                             }
5503                         }
5504                         bufsize = 0;
5505                         break;
5506                     }
5507                     /*
5508                      * If we are not buffering too much data,
5509                      * enlarge the window again at the remote side.
5510                      */
5511                     if (bufsize < OUR_V2_WINSIZE)
5512                         ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
5513                 }
5514             } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_EOF) {
5515                 unsigned i = ssh2_pkt_getuint32(ssh);
5516                 struct ssh_channel *c;
5517
5518                 c = find234(ssh->channels, &i, ssh_channelfind);
5519                 if (!c)
5520                     continue;          /* nonexistent channel */
5521
5522                 if (c->type == CHAN_X11) {
5523                     /*
5524                      * Remote EOF on an X11 channel means we should
5525                      * wrap up and close the channel ourselves.
5526                      */
5527                     x11_close(c->u.x11.s);
5528                     sshfwd_close(c);
5529                 } else if (c->type == CHAN_AGENT) {
5530                     sshfwd_close(c);
5531                 } else if (c->type == CHAN_SOCKDATA) {
5532                     pfd_close(c->u.pfd.s);
5533                     sshfwd_close(c);
5534                 }
5535             } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_CLOSE) {
5536                 unsigned i = ssh2_pkt_getuint32(ssh);
5537                 struct ssh_channel *c;
5538
5539                 c = find234(ssh->channels, &i, ssh_channelfind);
5540                 if (!c || ((int)c->remoteid) == -1) {
5541                     bombout((ssh,"Received CHANNEL_CLOSE for %s channel %d\n",
5542                              c ? "half-open" : "nonexistent", i));
5543                 }
5544                 /* Do pre-close processing on the channel. */
5545                 switch (c->type) {
5546                   case CHAN_MAINSESSION:
5547                     break;             /* nothing to see here, move along */
5548                   case CHAN_X11:
5549                     if (c->u.x11.s != NULL)
5550                         x11_close(c->u.x11.s);
5551                     sshfwd_close(c);
5552                     break;
5553                   case CHAN_AGENT:
5554                     sshfwd_close(c);
5555                     break;
5556                   case CHAN_SOCKDATA:
5557                     if (c->u.pfd.s != NULL)
5558                         pfd_close(c->u.pfd.s);
5559                     sshfwd_close(c);
5560                     break;
5561                 }
5562                 if (c->closes == 0) {
5563                     ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_CLOSE);
5564                     ssh2_pkt_adduint32(ssh, c->remoteid);
5565                     ssh2_pkt_send(ssh);
5566                 }
5567                 del234(ssh->channels, c);
5568                 bufchain_clear(&c->v.v2.outbuffer);
5569                 sfree(c);
5570
5571                 /*
5572                  * See if that was the last channel left open.
5573                  */
5574                 if (count234(ssh->channels) == 0) {
5575 #if 0
5576                     /*
5577                      * We used to send SSH_MSG_DISCONNECT here,
5578                      * because I'd believed that _every_ conforming
5579                      * SSH2 connection had to end with a disconnect
5580                      * being sent by at least one side; apparently
5581                      * I was wrong and it's perfectly OK to
5582                      * unceremoniously slam the connection shut
5583                      * when you're done, and indeed OpenSSH feels
5584                      * this is more polite than sending a
5585                      * DISCONNECT. So now we don't.
5586                      */
5587                     logevent("All channels closed. Disconnecting");
5588                     ssh2_pkt_init(ssh, SSH2_MSG_DISCONNECT);
5589                     ssh2_pkt_adduint32(ssh, SSH2_DISCONNECT_BY_APPLICATION);
5590                     ssh2_pkt_addstring(ssh, "All open channels closed");
5591                     ssh2_pkt_addstring(ssh, "en");      /* language tag */
5592                     ssh2_pkt_send(ssh);
5593 #endif
5594                     ssh->state = SSH_STATE_CLOSED;
5595                     crReturnV;
5596                 }
5597                 continue;              /* remote sends close; ignore (FIXME) */
5598             } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
5599                 unsigned i = ssh2_pkt_getuint32(ssh);
5600                 struct ssh_channel *c;
5601                 c = find234(ssh->channels, &i, ssh_channelfind);
5602                 if (!c || c->closes)
5603                     continue;          /* nonexistent or closing channel */
5604                 c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
5605                 s->try_send = TRUE;
5606             } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
5607                 unsigned i = ssh2_pkt_getuint32(ssh);
5608                 struct ssh_channel *c;
5609                 c = find234(ssh->channels, &i, ssh_channelfind);
5610                 if (!c)
5611                     continue;          /* nonexistent channel */
5612                 if (c->type != CHAN_SOCKDATA_DORMANT)
5613                     continue;          /* dunno why they're confirming this */
5614                 c->remoteid = ssh2_pkt_getuint32(ssh);
5615                 c->type = CHAN_SOCKDATA;
5616                 c->v.v2.remwindow = ssh2_pkt_getuint32(ssh);
5617                 c->v.v2.remmaxpkt = ssh2_pkt_getuint32(ssh);
5618                 if (c->u.pfd.s)
5619                     pfd_confirm(c->u.pfd.s);
5620                 if (c->closes) {
5621                     /*
5622                      * We have a pending close on this channel,
5623                      * which we decided on before the server acked
5624                      * the channel open. So now we know the
5625                      * remoteid, we can close it again.
5626                      */
5627                     ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_CLOSE);
5628                     ssh2_pkt_adduint32(ssh, c->remoteid);
5629                     ssh2_pkt_send(ssh);
5630                 }
5631             } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN_FAILURE) {
5632                 unsigned i = ssh2_pkt_getuint32(ssh);
5633                 struct ssh_channel *c;
5634                 c = find234(ssh->channels, &i, ssh_channelfind);
5635                 if (!c)
5636                     continue;          /* nonexistent channel */
5637                 if (c->type != CHAN_SOCKDATA_DORMANT)
5638                     continue;          /* dunno why they're failing this */
5639
5640                 logevent("Forwarded connection refused by server");
5641
5642                 pfd_close(c->u.pfd.s);
5643
5644                 del234(ssh->channels, c);
5645                 sfree(c);
5646             } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_REQUEST) {
5647                 unsigned localid;
5648                 char *type;
5649                 int typelen, want_reply;
5650                 struct ssh_channel *c;
5651
5652                 localid = ssh2_pkt_getuint32(ssh);
5653                 ssh2_pkt_getstring(ssh, &type, &typelen);
5654                 want_reply = ssh2_pkt_getbool(ssh);
5655
5656                 /*
5657                  * First, check that the channel exists. Otherwise,
5658                  * we can instantly disconnect with a rude message.
5659                  */
5660                 c = find234(ssh->channels, &localid, ssh_channelfind);
5661                 if (!c) {
5662                     char buf[80];
5663                     sprintf(buf, "Received channel request for nonexistent"
5664                             " channel %d", localid);
5665                     logevent(buf);
5666                     ssh2_pkt_init(ssh, SSH2_MSG_DISCONNECT);
5667                     ssh2_pkt_adduint32(ssh, SSH2_DISCONNECT_BY_APPLICATION);
5668                     ssh2_pkt_addstring(ssh, buf);
5669                     ssh2_pkt_addstring(ssh, "en");      /* language tag */
5670                     ssh2_pkt_send(ssh);
5671                     connection_fatal("%s", buf);
5672                     ssh->state = SSH_STATE_CLOSED;
5673                     crReturnV;
5674                 }
5675
5676                 /*
5677                  * Having got the channel number, we now look at
5678                  * the request type string to see if it's something
5679                  * we recognise.
5680                  */
5681                 if (typelen == 11 && !memcmp(type, "exit-status", 11) &&
5682                     c == ssh->mainchan) {
5683                     /* We recognise "exit-status" on the primary channel. */
5684                     char buf[100];
5685                     ssh->exitcode = ssh2_pkt_getuint32(ssh);
5686                     sprintf(buf, "Server sent command exit status %d",
5687                             ssh->exitcode);
5688                     logevent(buf);
5689                     if (want_reply) {
5690                         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_SUCCESS);
5691                         ssh2_pkt_adduint32(ssh, c->remoteid);
5692                         ssh2_pkt_send(ssh);
5693                     }
5694                 } else {
5695                     /*
5696                      * This is a channel request we don't know
5697                      * about, so we now either ignore the request
5698                      * or respond with CHANNEL_FAILURE, depending
5699                      * on want_reply.
5700                      */
5701                     if (want_reply) {
5702                         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_FAILURE);
5703                         ssh2_pkt_adduint32(ssh, c->remoteid);
5704                         ssh2_pkt_send(ssh);
5705                     }
5706                 }
5707             } else if (ssh->pktin.type == SSH2_MSG_GLOBAL_REQUEST) {
5708                 char *type;
5709                 int typelen, want_reply;
5710
5711                 ssh2_pkt_getstring(ssh, &type, &typelen);
5712                 want_reply = ssh2_pkt_getbool(ssh);
5713
5714                 /*
5715                  * We currently don't support any global requests
5716                  * at all, so we either ignore the request or
5717                  * respond with REQUEST_FAILURE, depending on
5718                  * want_reply.
5719                  */
5720                 if (want_reply) {
5721                     ssh2_pkt_init(ssh, SSH2_MSG_REQUEST_FAILURE);
5722                     ssh2_pkt_send(ssh);
5723                 }
5724             } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN) {
5725                 char *type;
5726                 int typelen;
5727                 char *peeraddr;
5728                 int peeraddrlen;
5729                 int port;
5730                 char *error = NULL;
5731                 struct ssh_channel *c;
5732                 unsigned remid, winsize, pktsize;
5733                 ssh2_pkt_getstring(ssh, &type, &typelen);
5734                 c = smalloc(sizeof(struct ssh_channel));
5735                 c->ssh = ssh;
5736
5737                 remid = ssh2_pkt_getuint32(ssh);
5738                 winsize = ssh2_pkt_getuint32(ssh);
5739                 pktsize = ssh2_pkt_getuint32(ssh);
5740                 ssh2_pkt_getstring(ssh, &peeraddr, &peeraddrlen);
5741                 port = ssh2_pkt_getuint32(ssh);
5742
5743                 if (typelen == 3 && !memcmp(type, "x11", 3)) {
5744                     char *addrstr = smalloc(peeraddrlen+1);
5745                     memcpy(addrstr, peeraddr, peeraddrlen);
5746                     peeraddr[peeraddrlen] = '\0';
5747
5748                     if (!ssh->X11_fwd_enabled)
5749                         error = "X11 forwarding is not enabled";
5750                     else if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
5751                                       ssh->x11auth, addrstr, port,
5752                                       &ssh->cfg) != NULL) {
5753                         error = "Unable to open an X11 connection";
5754                     } else {
5755                         c->type = CHAN_X11;
5756                     }
5757
5758                     sfree(addrstr);
5759                 } else if (typelen == 15 &&
5760                            !memcmp(type, "forwarded-tcpip", 15)) {
5761                     struct ssh_rportfwd pf, *realpf;
5762                     char *dummy;
5763                     int dummylen;
5764                     ssh2_pkt_getstring(ssh, &dummy, &dummylen);/* skip address */
5765                     pf.sport = ssh2_pkt_getuint32(ssh);
5766                     realpf = find234(ssh->rportfwds, &pf, NULL);
5767                     if (realpf == NULL) {
5768                         error = "Remote port is not recognised";
5769                     } else {
5770                         char *e = pfd_newconnect(&c->u.pfd.s, realpf->dhost,
5771                                                  realpf->dport, c, &ssh->cfg);
5772                         logeventf(ssh, "Received remote port open request"
5773                                   " for %s:%d", realpf->dhost, realpf->dport);
5774                         if (e != NULL) {
5775                             logeventf(ssh, "Port open failed: %s", e);
5776                             error = "Port open failed";
5777                         } else {
5778                             logevent("Forwarded port opened successfully");
5779                             c->type = CHAN_SOCKDATA;
5780                         }
5781                     }
5782                 } else if (typelen == 22 &&
5783                            !memcmp(type, "auth-agent@openssh.com", 3)) {
5784                     if (!ssh->agentfwd_enabled)
5785                         error = "Agent forwarding is not enabled";
5786                     else {
5787                         c->type = CHAN_AGENT;   /* identify channel type */
5788                         c->u.a.lensofar = 0;
5789                     }
5790                 } else {
5791                     error = "Unsupported channel type requested";
5792                 }
5793
5794                 c->remoteid = remid;
5795                 if (error) {
5796                     ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE);
5797                     ssh2_pkt_adduint32(ssh, c->remoteid);
5798                     ssh2_pkt_adduint32(ssh, SSH2_OPEN_CONNECT_FAILED);
5799                     ssh2_pkt_addstring(ssh, error);
5800                     ssh2_pkt_addstring(ssh, "en");      /* language tag */
5801                     ssh2_pkt_send(ssh);
5802                     sfree(c);
5803                 } else {
5804                     c->localid = alloc_channel_id(ssh);
5805                     c->closes = 0;
5806                     c->v.v2.locwindow = OUR_V2_WINSIZE;
5807                     c->v.v2.remwindow = winsize;
5808                     c->v.v2.remmaxpkt = pktsize;
5809                     bufchain_init(&c->v.v2.outbuffer);
5810                     add234(ssh->channels, c);
5811                     ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
5812                     ssh2_pkt_adduint32(ssh, c->remoteid);
5813                     ssh2_pkt_adduint32(ssh, c->localid);
5814                     ssh2_pkt_adduint32(ssh, c->v.v2.locwindow);
5815                     ssh2_pkt_adduint32(ssh, 0x4000UL);  /* our max pkt size */
5816                     ssh2_pkt_send(ssh);
5817                 }
5818             } else {
5819                 bombout((ssh,"Strange packet received: type %d", ssh->pktin.type));
5820                 crReturnV;
5821             }
5822         } else {
5823             /*
5824              * We have spare data. Add it to the channel buffer.
5825              */
5826             ssh2_add_channel_data(ssh->mainchan, (char *)in, inlen);
5827             s->try_send = TRUE;
5828         }
5829         if (s->try_send) {
5830             int i;
5831             struct ssh_channel *c;
5832             /*
5833              * Try to send data on all channels if we can.
5834              */
5835             for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
5836                 int bufsize;
5837                 if (c->closes)
5838                     continue;          /* don't send on closing channels */
5839                 bufsize = ssh2_try_send(c);
5840                 if (bufsize == 0) {
5841                     switch (c->type) {
5842                       case CHAN_MAINSESSION:
5843                         /* stdin need not receive an unthrottle
5844                          * notification since it will be polled */
5845                         break;
5846                       case CHAN_X11:
5847                         x11_unthrottle(c->u.x11.s);
5848                         break;
5849                       case CHAN_AGENT:
5850                         /* agent sockets are request/response and need no
5851                          * buffer management */
5852                         break;
5853                       case CHAN_SOCKDATA:
5854                         pfd_unthrottle(c->u.pfd.s);
5855                         break;
5856                     }
5857                 }
5858             }
5859         }
5860     }
5861
5862     crFinishV;
5863 }
5864
5865 /*
5866  * Handle the top-level SSH2 protocol.
5867  */
5868 static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
5869 {
5870     if (do_ssh2_transport(ssh, in, inlen, ispkt) == 0)
5871         return;
5872     do_ssh2_authconn(ssh, in, inlen, ispkt);
5873 }
5874
5875 /*
5876  * Called to set up the connection.
5877  *
5878  * Returns an error message, or NULL on success.
5879  */
5880 static char *ssh_init(void *frontend_handle, void **backend_handle,
5881                       Config *cfg,
5882                       char *host, int port, char **realhost, int nodelay)
5883 {
5884     char *p;
5885     Ssh ssh;
5886
5887     ssh = smalloc(sizeof(*ssh));
5888     ssh->cfg = *cfg;                   /* STRUCTURE COPY */
5889     ssh->s = NULL;
5890     ssh->cipher = NULL;
5891     ssh->v1_cipher_ctx = NULL;
5892     ssh->crcda_ctx = NULL;
5893     ssh->cscipher = NULL;
5894     ssh->cs_cipher_ctx = NULL;
5895     ssh->sccipher = NULL;
5896     ssh->sc_cipher_ctx = NULL;
5897     ssh->csmac = NULL;
5898     ssh->cs_mac_ctx = NULL;
5899     ssh->scmac = NULL;
5900     ssh->sc_mac_ctx = NULL;
5901     ssh->cscomp = NULL;
5902     ssh->cs_comp_ctx = NULL;
5903     ssh->sccomp = NULL;
5904     ssh->sc_comp_ctx = NULL;
5905     ssh->kex = NULL;
5906     ssh->hostkey = NULL;
5907     ssh->exitcode = -1;
5908     ssh->state = SSH_STATE_PREPACKET;
5909     ssh->size_needed = FALSE;
5910     ssh->eof_needed = FALSE;
5911     ssh->ldisc = NULL;
5912     ssh->logctx = NULL;
5913     {
5914         static const struct Packet empty = { 0, 0, NULL, NULL, 0 };
5915         ssh->pktin = ssh->pktout = empty;
5916     }
5917     ssh->deferred_send_data = NULL;
5918     ssh->deferred_len = 0;
5919     ssh->deferred_size = 0;
5920     ssh->fallback_cmd = 0;
5921     ssh->pkt_ctx = 0;
5922     ssh->x11auth = NULL;
5923     ssh->v1_compressing = FALSE;
5924     ssh->v2_outgoing_sequence = 0;
5925     ssh->ssh1_rdpkt_crstate = 0;
5926     ssh->ssh2_rdpkt_crstate = 0;
5927     ssh->do_ssh_init_crstate = 0;
5928     ssh->ssh_gotdata_crstate = 0;
5929     ssh->ssh1_protocol_crstate = 0;
5930     ssh->do_ssh1_login_crstate = 0;
5931     ssh->do_ssh2_transport_crstate = 0;
5932     ssh->do_ssh2_authconn_crstate = 0;
5933     ssh->do_ssh_init_state = NULL;
5934     ssh->do_ssh1_login_state = NULL;
5935     ssh->do_ssh2_transport_state = NULL;
5936     ssh->do_ssh2_authconn_state = NULL;
5937     ssh->mainchan = NULL;
5938     ssh->throttled_all = 0;
5939     ssh->v1_stdout_throttling = 0;
5940
5941     *backend_handle = ssh;
5942
5943 #ifdef MSCRYPTOAPI
5944     if (crypto_startup() == 0)
5945         return "Microsoft high encryption pack not installed!";
5946 #endif
5947
5948     ssh->frontend = frontend_handle;
5949     ssh->term_width = ssh->cfg.width;
5950     ssh->term_height = ssh->cfg.height;
5951
5952     ssh->channels = NULL;
5953     ssh->rportfwds = NULL;
5954
5955     ssh->send_ok = 0;
5956     ssh->editing = 0;
5957     ssh->echoing = 0;
5958     ssh->v1_throttle_count = 0;
5959     ssh->overall_bufsize = 0;
5960     ssh->fallback_cmd = 0;
5961
5962     ssh->protocol = NULL;
5963
5964     p = connect_to_host(ssh, host, port, realhost, nodelay);
5965     if (p != NULL)
5966         return p;
5967
5968     return NULL;
5969 }
5970
5971 static void ssh_free(void *handle)
5972 {
5973     Ssh ssh = (Ssh) handle;
5974     struct ssh_channel *c;
5975     struct ssh_rportfwd *pf;
5976
5977     if (ssh->v1_cipher_ctx)
5978         ssh->cipher->free_context(ssh->v1_cipher_ctx);
5979     if (ssh->cs_cipher_ctx)
5980         ssh->cscipher->free_context(ssh->cs_cipher_ctx);
5981     if (ssh->sc_cipher_ctx)
5982         ssh->sccipher->free_context(ssh->sc_cipher_ctx);
5983     if (ssh->cs_mac_ctx)
5984         ssh->csmac->free_context(ssh->cs_mac_ctx);
5985     if (ssh->sc_mac_ctx)
5986         ssh->scmac->free_context(ssh->sc_mac_ctx);
5987     if (ssh->cs_comp_ctx)
5988         ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
5989     if (ssh->sc_comp_ctx)
5990         ssh->sccomp->compress_cleanup(ssh->sc_comp_ctx);
5991     if (ssh->kex_ctx)
5992         dh_cleanup(ssh->kex_ctx);
5993     sfree(ssh->savedhost);
5994
5995     if (ssh->channels) {
5996         while ((c = delpos234(ssh->channels, 0)) != NULL) {
5997             switch (c->type) {
5998               case CHAN_X11:
5999                 if (c->u.x11.s != NULL)
6000                     x11_close(c->u.x11.s);
6001                 break;
6002               case CHAN_SOCKDATA:
6003                 if (c->u.pfd.s != NULL)
6004                     pfd_close(c->u.pfd.s);
6005                 break;
6006             }
6007             sfree(c);
6008         }
6009         freetree234(ssh->channels);
6010     }
6011
6012     if (ssh->rportfwds) {
6013         while ((pf = delpos234(ssh->rportfwds, 0)) != NULL)
6014             sfree(pf);
6015         freetree234(ssh->rportfwds);
6016     }
6017     sfree(ssh->deferred_send_data);
6018     if (ssh->x11auth)
6019         x11_free_auth(ssh->x11auth);
6020     sfree(ssh->do_ssh_init_state);
6021     sfree(ssh->do_ssh1_login_state);
6022     sfree(ssh->do_ssh2_transport_state);
6023     sfree(ssh->do_ssh2_authconn_state);
6024
6025     if (ssh->s)
6026         sk_close(ssh->s);
6027     sfree(ssh);
6028 }
6029
6030 /*
6031  * Reconfigure the SSH backend.
6032  *
6033  * Currently, this function does nothing very useful. In future,
6034  * however, we could do some handy things with it. For example, we
6035  * could make the port forwarding configurer active in the Change
6036  * Settings box, and this routine could close down existing
6037  * forwardings and open up new ones in response to changes.
6038  */
6039 static void ssh_reconfig(void *handle, Config *cfg)
6040 {
6041     Ssh ssh = (Ssh) handle;
6042     ssh->cfg = *cfg;                   /* STRUCTURE COPY */
6043 }
6044
6045 /*
6046  * Called to send data down the Telnet connection.
6047  */
6048 static int ssh_send(void *handle, char *buf, int len)
6049 {
6050     Ssh ssh = (Ssh) handle;
6051
6052     if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
6053         return 0;
6054
6055     ssh->protocol(ssh, (unsigned char *)buf, len, 0);
6056
6057     return ssh_sendbuffer(ssh);
6058 }
6059
6060 /*
6061  * Called to query the current amount of buffered stdin data.
6062  */
6063 static int ssh_sendbuffer(void *handle)
6064 {
6065     Ssh ssh = (Ssh) handle;
6066     int override_value;
6067
6068     if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
6069         return 0;
6070
6071     /*
6072      * If the SSH socket itself has backed up, add the total backup
6073      * size on that to any individual buffer on the stdin channel.
6074      */
6075     override_value = 0;
6076     if (ssh->throttled_all)
6077         override_value = ssh->overall_bufsize;
6078
6079     if (ssh->version == 1) {
6080         return override_value;
6081     } else if (ssh->version == 2) {
6082         if (!ssh->mainchan || ssh->mainchan->closes > 0)
6083             return override_value;
6084         else
6085             return (override_value +
6086                     bufchain_size(&ssh->mainchan->v.v2.outbuffer));
6087     }
6088
6089     return 0;
6090 }
6091
6092 /*
6093  * Called to set the size of the window from SSH's POV.
6094  */
6095 static void ssh_size(void *handle, int width, int height)
6096 {
6097     Ssh ssh = (Ssh) handle;
6098
6099     ssh->term_width = width;
6100     ssh->term_height = height;
6101
6102     switch (ssh->state) {
6103       case SSH_STATE_BEFORE_SIZE:
6104       case SSH_STATE_PREPACKET:
6105       case SSH_STATE_CLOSED:
6106         break;                         /* do nothing */
6107       case SSH_STATE_INTERMED:
6108         ssh->size_needed = TRUE;       /* buffer for later */
6109         break;
6110       case SSH_STATE_SESSION:
6111         if (!ssh->cfg.nopty) {
6112             if (ssh->version == 1) {
6113                 send_packet(ssh, SSH1_CMSG_WINDOW_SIZE,
6114                             PKT_INT, ssh->term_height,
6115                             PKT_INT, ssh->term_width,
6116                             PKT_INT, 0, PKT_INT, 0, PKT_END);
6117             } else {
6118                 ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
6119                 ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);
6120                 ssh2_pkt_addstring(ssh, "window-change");
6121                 ssh2_pkt_addbool(ssh, 0);
6122                 ssh2_pkt_adduint32(ssh, ssh->term_width);
6123                 ssh2_pkt_adduint32(ssh, ssh->term_height);
6124                 ssh2_pkt_adduint32(ssh, 0);
6125                 ssh2_pkt_adduint32(ssh, 0);
6126                 ssh2_pkt_send(ssh);
6127             }
6128         }
6129         break;
6130     }
6131 }
6132
6133 /*
6134  * Send Telnet special codes. TS_EOF is useful for `plink', so you
6135  * can send an EOF and collect resulting output (e.g. `plink
6136  * hostname sort').
6137  */
6138 static void ssh_special(void *handle, Telnet_Special code)
6139 {
6140     Ssh ssh = (Ssh) handle;
6141
6142     if (code == TS_EOF) {
6143         if (ssh->state != SSH_STATE_SESSION) {
6144             /*
6145              * Buffer the EOF in case we are pre-SESSION, so we can
6146              * send it as soon as we reach SESSION.
6147              */
6148             if (code == TS_EOF)
6149                 ssh->eof_needed = TRUE;
6150             return;
6151         }
6152         if (ssh->version == 1) {
6153             send_packet(ssh, SSH1_CMSG_EOF, PKT_END);
6154         } else {
6155             ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_EOF);
6156             ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);
6157             ssh2_pkt_send(ssh);
6158         }
6159         logevent("Sent EOF message");
6160     } else if (code == TS_PING) {
6161         if (ssh->state == SSH_STATE_CLOSED
6162             || ssh->state == SSH_STATE_PREPACKET) return;
6163         if (ssh->version == 1) {
6164             if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
6165                 send_packet(ssh, SSH1_MSG_IGNORE, PKT_STR, "", PKT_END);
6166         } else {
6167             ssh2_pkt_init(ssh, SSH2_MSG_IGNORE);
6168             ssh2_pkt_addstring_start(ssh);
6169             ssh2_pkt_send(ssh);
6170         }
6171     } else {
6172         /* do nothing */
6173     }
6174 }
6175
6176 void *new_sock_channel(void *handle, Socket s)
6177 {
6178     Ssh ssh = (Ssh) handle;
6179     struct ssh_channel *c;
6180     c = smalloc(sizeof(struct ssh_channel));
6181     c->ssh = ssh;
6182
6183     if (c) {
6184         c->remoteid = -1;              /* to be set when open confirmed */
6185         c->localid = alloc_channel_id(ssh);
6186         c->closes = 0;
6187         c->type = CHAN_SOCKDATA_DORMANT;/* identify channel type */
6188         c->u.pfd.s = s;
6189         bufchain_init(&c->v.v2.outbuffer);
6190         add234(ssh->channels, c);
6191     }
6192     return c;
6193 }
6194
6195 /*
6196  * This is called when stdout/stderr (the entity to which
6197  * from_backend sends data) manages to clear some backlog.
6198  */
6199 static void ssh_unthrottle(void *handle, int bufsize)
6200 {
6201     Ssh ssh = (Ssh) handle;
6202     if (ssh->version == 1) {
6203         if (ssh->v1_stdout_throttling && bufsize < SSH1_BUFFER_LIMIT) {
6204             ssh->v1_stdout_throttling = 0;
6205             ssh1_throttle(ssh, -1);
6206         }
6207     } else {
6208         if (ssh->mainchan && ssh->mainchan->closes == 0)
6209             ssh2_set_window(ssh->mainchan, OUR_V2_WINSIZE - bufsize);
6210     }
6211 }
6212
6213 void ssh_send_port_open(void *channel, char *hostname, int port, char *org)
6214 {
6215     struct ssh_channel *c = (struct ssh_channel *)channel;
6216     Ssh ssh = c->ssh;
6217
6218     logeventf(ssh, "Opening forwarded connection to %s:%d", hostname, port);
6219
6220     if (ssh->version == 1) {
6221         send_packet(ssh, SSH1_MSG_PORT_OPEN,
6222                     PKT_INT, c->localid,
6223                     PKT_STR, hostname,
6224                     PKT_INT, port,
6225                     //PKT_STR, <org:orgport>,
6226                     PKT_END);
6227     } else {
6228         ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_OPEN);
6229         ssh2_pkt_addstring(ssh, "direct-tcpip");
6230         ssh2_pkt_adduint32(ssh, c->localid);
6231         c->v.v2.locwindow = OUR_V2_WINSIZE;
6232         ssh2_pkt_adduint32(ssh, c->v.v2.locwindow);/* our window size */
6233         ssh2_pkt_adduint32(ssh, 0x4000UL);      /* our max pkt size */
6234         ssh2_pkt_addstring(ssh, hostname);
6235         ssh2_pkt_adduint32(ssh, port);
6236         /*
6237          * We make up values for the originator data; partly it's
6238          * too much hassle to keep track, and partly I'm not
6239          * convinced the server should be told details like that
6240          * about my local network configuration.
6241          */
6242         ssh2_pkt_addstring(ssh, "client-side-connection");
6243         ssh2_pkt_adduint32(ssh, 0);
6244         ssh2_pkt_send(ssh);
6245     }
6246 }
6247
6248
6249 static Socket ssh_socket(void *handle)
6250 {
6251     Ssh ssh = (Ssh) handle;
6252     return ssh->s;
6253 }
6254
6255 static int ssh_sendok(void *handle)
6256 {
6257     Ssh ssh = (Ssh) handle;
6258     return ssh->send_ok;
6259 }
6260
6261 static int ssh_ldisc(void *handle, int option)
6262 {
6263     Ssh ssh = (Ssh) handle;
6264     if (option == LD_ECHO)
6265         return ssh->echoing;
6266     if (option == LD_EDIT)
6267         return ssh->editing;
6268     return FALSE;
6269 }
6270
6271 static void ssh_provide_ldisc(void *handle, void *ldisc)
6272 {
6273     Ssh ssh = (Ssh) handle;
6274     ssh->ldisc = ldisc;
6275 }
6276
6277 static void ssh_provide_logctx(void *handle, void *logctx)
6278 {
6279     Ssh ssh = (Ssh) handle;
6280     ssh->logctx = logctx;
6281 }
6282
6283 static int ssh_return_exitcode(void *handle)
6284 {
6285     Ssh ssh = (Ssh) handle;
6286     return ssh->exitcode;
6287 }
6288
6289 /*
6290  * Gross hack: pscp will try to start SFTP but fall back to scp1 if
6291  * that fails. This variable is the means by which scp.c can reach
6292  * into the SSH code and find out which one it got.
6293  */
6294 extern int ssh_fallback_cmd(void *handle)
6295 {
6296     Ssh ssh = (Ssh) handle;
6297     return ssh->fallback_cmd;
6298 }
6299
6300 Backend ssh_backend = {
6301     ssh_init,
6302     ssh_free,
6303     ssh_reconfig,
6304     ssh_send,
6305     ssh_sendbuffer,
6306     ssh_size,
6307     ssh_special,
6308     ssh_socket,
6309     ssh_return_exitcode,
6310     ssh_sendok,
6311     ssh_ldisc,
6312     ssh_provide_ldisc,
6313     ssh_provide_logctx,
6314     ssh_unthrottle,
6315     22
6316 };