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_DHGROUP          0x0001
 108 #define SSH2_PKTCTX_DHGEX            0x0002
 109 #define SSH2_PKTCTX_KEX_MASK         0x000F
 110 #define SSH2_PKTCTX_PUBLICKEY        0x0010
 111 #define SSH2_PKTCTX_PASSWORD         0x0020
 112 #define SSH2_PKTCTX_KBDINTER         0x0040
 113 #define SSH2_PKTCTX_AUTH_MASK        0x00F0
 114
 115 #define SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1   /* 0x1 */
 116 #define SSH2_DISCONNECT_PROTOCOL_ERROR            2     /* 0x2 */
 117 #define SSH2_DISCONNECT_KEY_EXCHANGE_FAILED       3     /* 0x3 */
 118 #define SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED 4    /* 0x4 */
 119 #define SSH2_DISCONNECT_MAC_ERROR                 5     /* 0x5 */
 120 #define SSH2_DISCONNECT_COMPRESSION_ERROR         6     /* 0x6 */
 121 #define SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE     7     /* 0x7 */
 122 #define SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8        /* 0x8 */
 123 #define SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE   9     /* 0x9 */
 124 #define SSH2_DISCONNECT_CONNECTION_LOST           10    /* 0xa */
 125 #define SSH2_DISCONNECT_BY_APPLICATION            11    /* 0xb */
 126 #define SSH2_DISCONNECT_TOO_MANY_CONNECTIONS      12    /* 0xc */
 127 #define SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER    13    /* 0xd */
 128 #define SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE 14       /* 0xe */
 129 #define SSH2_DISCONNECT_ILLEGAL_USER_NAME         15    /* 0xf */
 130
 131 static const char *const ssh2_disconnect_reasons[] = {
 132     NULL,
 133     "SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT",
 134     "SSH_DISCONNECT_PROTOCOL_ERROR",
 135     "SSH_DISCONNECT_KEY_EXCHANGE_FAILED",
 136     "SSH_DISCONNECT_HOST_AUTHENTICATION_FAILED",
 137     "SSH_DISCONNECT_MAC_ERROR",
 138     "SSH_DISCONNECT_COMPRESSION_ERROR",
 139     "SSH_DISCONNECT_SERVICE_NOT_AVAILABLE",
 140     "SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED",
 141     "SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE",
 142     "SSH_DISCONNECT_CONNECTION_LOST",
 143     "SSH_DISCONNECT_BY_APPLICATION",
 144     "SSH_DISCONNECT_TOO_MANY_CONNECTIONS",
 145     "SSH_DISCONNECT_AUTH_CANCELLED_BY_USER",
 146     "SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE",
 147     "SSH_DISCONNECT_ILLEGAL_USER_NAME",
 148 };
 149
 150 #define SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED     1     /* 0x1 */
 151 #define SSH2_OPEN_CONNECT_FAILED                  2     /* 0x2 */
 152 #define SSH2_OPEN_UNKNOWN_CHANNEL_TYPE            3     /* 0x3 */
 153 #define SSH2_OPEN_RESOURCE_SHORTAGE               4     /* 0x4 */
 154
 155 #define SSH2_EXTENDED_DATA_STDERR                 1     /* 0x1 */
 156
 157 /*
 158  * Various remote-bug flags.
 159  */
 160 #define BUG_CHOKES_ON_SSH1_IGNORE                 1
 161 #define BUG_SSH2_HMAC                             2
 162 #define BUG_NEEDS_SSH1_PLAIN_PASSWORD             4
 163 #define BUG_CHOKES_ON_RSA                         8
 164 #define BUG_SSH2_RSA_PADDING                     16
 165 #define BUG_SSH2_DERIVEKEY                       32
 166 #define BUG_SSH2_REKEY                           64
 167 #define BUG_SSH2_PK_SESSIONID                   128
 168
 169 /*
 170  * Codes for terminal modes.
 171  * Most of these are the same in SSH-1 and SSH-2.
 172  * This list is derived from draft-ietf-secsh-connect-25 and
 173  * SSH-1 RFC-1.2.31.
 174  */
 175 static const struct {
 176     const char* const mode;
 177     int opcode;
 178     enum { TTY_OP_CHAR, TTY_OP_BOOL } type;
 179 } ssh_ttymodes[] = {
 180     /* "V" prefix discarded for special characters relative to SSH specs */
 181     { "INTR",         1, TTY_OP_CHAR },
 182     { "QUIT",         2, TTY_OP_CHAR },
 183     { "ERASE",        3, TTY_OP_CHAR },
 184     { "KILL",         4, TTY_OP_CHAR },
 185     { "EOF",          5, TTY_OP_CHAR },
 186     { "EOL",          6, TTY_OP_CHAR },
 187     { "EOL2",         7, TTY_OP_CHAR },
 188     { "START",        8, TTY_OP_CHAR },
 189     { "STOP",         9, TTY_OP_CHAR },
 190     { "SUSP",        10, TTY_OP_CHAR },
 191     { "DSUSP",       11, TTY_OP_CHAR },
 192     { "REPRINT",     12, TTY_OP_CHAR },
 193     { "WERASE",      13, TTY_OP_CHAR },
 194     { "LNEXT",       14, TTY_OP_CHAR },
 195     { "FLUSH",       15, TTY_OP_CHAR },
 196     { "SWTCH",       16, TTY_OP_CHAR },
 197     { "STATUS",      17, TTY_OP_CHAR },
 198     { "DISCARD",     18, TTY_OP_CHAR },
 199     { "IGNPAR",      30, TTY_OP_BOOL },
 200     { "PARMRK",      31, TTY_OP_BOOL },
 201     { "INPCK",       32, TTY_OP_BOOL },
 202     { "ISTRIP",      33, TTY_OP_BOOL },
 203     { "INLCR",       34, TTY_OP_BOOL },
 204     { "IGNCR",       35, TTY_OP_BOOL },
 205     { "ICRNL",       36, TTY_OP_BOOL },
 206     { "IUCLC",       37, TTY_OP_BOOL },
 207     { "IXON",        38, TTY_OP_BOOL },
 208     { "IXANY",       39, TTY_OP_BOOL },
 209     { "IXOFF",       40, TTY_OP_BOOL },
 210     { "IMAXBEL",     41, TTY_OP_BOOL },
 211     { "ISIG",        50, TTY_OP_BOOL },
 212     { "ICANON",      51, TTY_OP_BOOL },
 213     { "XCASE",       52, TTY_OP_BOOL },
 214     { "ECHO",        53, TTY_OP_BOOL },
 215     { "ECHOE",       54, TTY_OP_BOOL },
 216     { "ECHOK",       55, TTY_OP_BOOL },
 217     { "ECHONL",      56, TTY_OP_BOOL },
 218     { "NOFLSH",      57, TTY_OP_BOOL },
 219     { "TOSTOP",      58, TTY_OP_BOOL },
 220     { "IEXTEN",      59, TTY_OP_BOOL },
 221     { "ECHOCTL",     60, TTY_OP_BOOL },
 222     { "ECHOKE",      61, TTY_OP_BOOL },
 223     { "PENDIN",      62, TTY_OP_BOOL }, /* XXX is this a real mode? */
 224     { "OPOST",       70, TTY_OP_BOOL },
 225     { "OLCUC",       71, TTY_OP_BOOL },
 226     { "ONLCR",       72, TTY_OP_BOOL },
 227     { "OCRNL",       73, TTY_OP_BOOL },
 228     { "ONOCR",       74, TTY_OP_BOOL },
 229     { "ONLRET",      75, TTY_OP_BOOL },
 230     { "CS7",         90, TTY_OP_BOOL },
 231     { "CS8",         91, TTY_OP_BOOL },
 232     { "PARENB",      92, TTY_OP_BOOL },
 233     { "PARODD",      93, TTY_OP_BOOL }
 234 };
 235
 236 /* Miscellaneous other tty-related constants. */
 237 #define SSH_TTY_OP_END            0
 238 /* The opcodes for ISPEED/OSPEED differ between SSH-1 and SSH-2. */
 239 #define SSH1_TTY_OP_ISPEED      192
 240 #define SSH1_TTY_OP_OSPEED      193
 241 #define SSH2_TTY_OP_ISPEED      128
 242 #define SSH2_TTY_OP_OSPEED      129
 243
 244 /* Helper functions for parsing tty-related config. */
 245 static unsigned int ssh_tty_parse_specchar(char *s)
 246 {
 247     unsigned int ret;
 248     if (*s) {
 249         char *next = NULL;
 250         ret = ctrlparse(s, &next);
 251         if (!next) ret = s[0];
 252     } else {
 253         ret = 255; /* special value meaning "don't set" */
 254     }
 255     return ret;
 256 }
 257 static unsigned int ssh_tty_parse_boolean(char *s)
 258 {
 259     if (stricmp(s, "yes") == 0 ||
 260         stricmp(s, "on") == 0 ||
 261         stricmp(s, "true") == 0 ||
 262         stricmp(s, "+") == 0)
 263         return 1; /* true */
 264     else if (stricmp(s, "no") == 0 ||
 265              stricmp(s, "off") == 0 ||
 266              stricmp(s, "false") == 0 ||
 267              stricmp(s, "-") == 0)
 268         return 0; /* false */
 269     else
 270         return (atoi(s) != 0);
 271 }
 272
 273 #define translate(x) if (type == x) return #x
 274 #define translatec(x,ctx) if (type == x && (pkt_ctx & ctx)) return #x
 275 static char *ssh1_pkt_type(int type)
 276 {
 277     translate(SSH1_MSG_DISCONNECT);
 278     translate(SSH1_SMSG_PUBLIC_KEY);
 279     translate(SSH1_CMSG_SESSION_KEY);
 280     translate(SSH1_CMSG_USER);
 281     translate(SSH1_CMSG_AUTH_RSA);
 282     translate(SSH1_SMSG_AUTH_RSA_CHALLENGE);
 283     translate(SSH1_CMSG_AUTH_RSA_RESPONSE);
 284     translate(SSH1_CMSG_AUTH_PASSWORD);
 285     translate(SSH1_CMSG_REQUEST_PTY);
 286     translate(SSH1_CMSG_WINDOW_SIZE);
 287     translate(SSH1_CMSG_EXEC_SHELL);
 288     translate(SSH1_CMSG_EXEC_CMD);
 289     translate(SSH1_SMSG_SUCCESS);
 290     translate(SSH1_SMSG_FAILURE);
 291     translate(SSH1_CMSG_STDIN_DATA);
 292     translate(SSH1_SMSG_STDOUT_DATA);
 293     translate(SSH1_SMSG_STDERR_DATA);
 294     translate(SSH1_CMSG_EOF);
 295     translate(SSH1_SMSG_EXIT_STATUS);
 296     translate(SSH1_MSG_CHANNEL_OPEN_CONFIRMATION);
 297     translate(SSH1_MSG_CHANNEL_OPEN_FAILURE);
 298     translate(SSH1_MSG_CHANNEL_DATA);
 299     translate(SSH1_MSG_CHANNEL_CLOSE);
 300     translate(SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION);
 301     translate(SSH1_SMSG_X11_OPEN);
 302     translate(SSH1_CMSG_PORT_FORWARD_REQUEST);
 303     translate(SSH1_MSG_PORT_OPEN);
 304     translate(SSH1_CMSG_AGENT_REQUEST_FORWARDING);
 305     translate(SSH1_SMSG_AGENT_OPEN);
 306     translate(SSH1_MSG_IGNORE);
 307     translate(SSH1_CMSG_EXIT_CONFIRMATION);
 308     translate(SSH1_CMSG_X11_REQUEST_FORWARDING);
 309     translate(SSH1_CMSG_AUTH_RHOSTS_RSA);
 310     translate(SSH1_MSG_DEBUG);
 311     translate(SSH1_CMSG_REQUEST_COMPRESSION);
 312     translate(SSH1_CMSG_AUTH_TIS);
 313     translate(SSH1_SMSG_AUTH_TIS_CHALLENGE);
 314     translate(SSH1_CMSG_AUTH_TIS_RESPONSE);
 315     translate(SSH1_CMSG_AUTH_CCARD);
 316     translate(SSH1_SMSG_AUTH_CCARD_CHALLENGE);
 317     translate(SSH1_CMSG_AUTH_CCARD_RESPONSE);
 318     return "unknown";
 319 }
 320 static char *ssh2_pkt_type(int pkt_ctx, int type)
 321 {
 322     translate(SSH2_MSG_DISCONNECT);
 323     translate(SSH2_MSG_IGNORE);
 324     translate(SSH2_MSG_UNIMPLEMENTED);
 325     translate(SSH2_MSG_DEBUG);
 326     translate(SSH2_MSG_SERVICE_REQUEST);
 327     translate(SSH2_MSG_SERVICE_ACCEPT);
 328     translate(SSH2_MSG_KEXINIT);
 329     translate(SSH2_MSG_NEWKEYS);
 330     translatec(SSH2_MSG_KEXDH_INIT, SSH2_PKTCTX_DHGROUP);
 331     translatec(SSH2_MSG_KEXDH_REPLY, SSH2_PKTCTX_DHGROUP);
 332     translatec(SSH2_MSG_KEX_DH_GEX_REQUEST, SSH2_PKTCTX_DHGEX);
 333     translatec(SSH2_MSG_KEX_DH_GEX_GROUP, SSH2_PKTCTX_DHGEX);
 334     translatec(SSH2_MSG_KEX_DH_GEX_INIT, SSH2_PKTCTX_DHGEX);
 335     translatec(SSH2_MSG_KEX_DH_GEX_REPLY, SSH2_PKTCTX_DHGEX);
 336     translate(SSH2_MSG_USERAUTH_REQUEST);
 337     translate(SSH2_MSG_USERAUTH_FAILURE);
 338     translate(SSH2_MSG_USERAUTH_SUCCESS);
 339     translate(SSH2_MSG_USERAUTH_BANNER);
 340     translatec(SSH2_MSG_USERAUTH_PK_OK, SSH2_PKTCTX_PUBLICKEY);
 341     translatec(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ, SSH2_PKTCTX_PASSWORD);
 342     translatec(SSH2_MSG_USERAUTH_INFO_REQUEST, SSH2_PKTCTX_KBDINTER);
 343     translatec(SSH2_MSG_USERAUTH_INFO_RESPONSE, SSH2_PKTCTX_KBDINTER);
 344     translate(SSH2_MSG_GLOBAL_REQUEST);
 345     translate(SSH2_MSG_REQUEST_SUCCESS);
 346     translate(SSH2_MSG_REQUEST_FAILURE);
 347     translate(SSH2_MSG_CHANNEL_OPEN);
 348     translate(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
 349     translate(SSH2_MSG_CHANNEL_OPEN_FAILURE);
 350     translate(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
 351     translate(SSH2_MSG_CHANNEL_DATA);
 352     translate(SSH2_MSG_CHANNEL_EXTENDED_DATA);
 353     translate(SSH2_MSG_CHANNEL_EOF);
 354     translate(SSH2_MSG_CHANNEL_CLOSE);
 355     translate(SSH2_MSG_CHANNEL_REQUEST);
 356     translate(SSH2_MSG_CHANNEL_SUCCESS);
 357     translate(SSH2_MSG_CHANNEL_FAILURE);
 358     return "unknown";
 359 }
 360 #undef translate
 361 #undef translatec
 362
 363 /* Enumeration values for fields in SSH-1 packets */
 364 enum {
 365     PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM,
 366     /* These values are for communicating relevant semantics of
 367      * fields to the packet logging code. */
 368     PKTT_OTHER, PKTT_PASSWORD, PKTT_DATA
 369 };
 370
 371 /*
 372  * Coroutine mechanics for the sillier bits of the code. If these
 373  * macros look impenetrable to you, you might find it helpful to
 374  * read
 375  *
 376  *   http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
 377  *
 378  * which explains the theory behind these macros.
 379  *
 380  * In particular, if you are getting `case expression not constant'
 381  * errors when building with MS Visual Studio, this is because MS's
 382  * Edit and Continue debugging feature causes their compiler to
 383  * violate ANSI C. To disable Edit and Continue debugging:
 384  *
 385  *  - right-click ssh.c in the FileView
 386  *  - click Settings
 387  *  - select the C/C++ tab and the General category
 388  *  - under `Debug info:', select anything _other_ than `Program
 389  *    Database for Edit and Continue'.
 390  */
 391 #define crBegin(v)      { int *crLine = &v; switch(v) { case 0:;
 392 #define crState(t) \
 393     struct t *s; \
 394     if (!ssh->t) ssh->t = snew(struct t); \
 395     s = ssh->t;
 396 #define crFinish(z)     } *crLine = 0; return (z); }
 397 #define crFinishV       } *crLine = 0; return; }
 398 #define crReturn(z)     \
 399         do {\
 400             *crLine =__LINE__; return (z); case __LINE__:;\
 401         } while (0)
 402 #define crReturnV       \
 403         do {\
 404             *crLine=__LINE__; return; case __LINE__:;\
 405         } while (0)
 406 #define crStop(z)       do{ *crLine = 0; return (z); }while(0)
 407 #define crStopV         do{ *crLine = 0; return; }while(0)
 408 #define crWaitUntil(c)  do { crReturn(0); } while (!(c))
 409 #define crWaitUntilV(c) do { crReturnV; } while (!(c))
 410
 411 typedef struct ssh_tag *Ssh;
 412 struct Packet;
 413
 414 static struct Packet *ssh1_pkt_init(int pkt_type);
 415 static struct Packet *ssh2_pkt_init(int pkt_type);
 416 static void ssh_pkt_ensure(struct Packet *, int length);
 417 static void ssh_pkt_adddata(struct Packet *, void *data, int len);
 418 static void ssh_pkt_addbyte(struct Packet *, unsigned char value);
 419 static void ssh2_pkt_addbool(struct Packet *, unsigned char value);
 420 static void ssh_pkt_adduint32(struct Packet *, unsigned long value);
 421 static void ssh_pkt_addstring_start(struct Packet *);
 422 static void ssh_pkt_addstring_str(struct Packet *, char *data);
 423 static void ssh_pkt_addstring_data(struct Packet *, char *data, int len);
 424 static void ssh_pkt_addstring(struct Packet *, char *data);
 425 static unsigned char *ssh2_mpint_fmt(Bignum b, int *len);
 426 static void ssh1_pkt_addmp(struct Packet *, Bignum b);
 427 static void ssh2_pkt_addmp(struct Packet *, Bignum b);
 428 static int ssh2_pkt_construct(Ssh, struct Packet *);
 429 static void ssh2_pkt_send(Ssh, struct Packet *);
 430 static void ssh2_pkt_send_noqueue(Ssh, struct Packet *);
 431 static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen,
 432                          struct Packet *pktin);
 433 static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
 434                              struct Packet *pktin);
 435
 436 /*
 437  * Buffer management constants. There are several of these for
 438  * various different purposes:
 439  *
 440  *  - SSH1_BUFFER_LIMIT is the amount of backlog that must build up
 441  *    on a local data stream before we throttle the whole SSH
 442  *    connection (in SSH-1 only). Throttling the whole connection is
 443  *    pretty drastic so we set this high in the hope it won't
 444  *    happen very often.
 445  *
 446  *  - SSH_MAX_BACKLOG is the amount of backlog that must build up
 447  *    on the SSH connection itself before we defensively throttle
 448  *    _all_ local data streams. This is pretty drastic too (though
 449  *    thankfully unlikely in SSH-2 since the window mechanism should
 450  *    ensure that the server never has any need to throttle its end
 451  *    of the connection), so we set this high as well.
 452  *
 453  *  - OUR_V2_WINSIZE is the maximum window size we present on SSH-2
 454  *    channels.
 455  */
 456
 457 #define SSH1_BUFFER_LIMIT 32768
 458 #define SSH_MAX_BACKLOG 32768
 459 #define OUR_V2_WINSIZE 16384
 460 #define OUR_V2_MAXPKT 0x4000UL
 461
 462 const static struct ssh_signkey *hostkey_algs[] = { &ssh_rsa, &ssh_dss };
 463
 464 const static struct ssh_mac *macs[] = {
 465     &ssh_sha1, &ssh_md5
 466 };
 467 const static struct ssh_mac *buggymacs[] = {
 468     &ssh_sha1_buggy, &ssh_md5
 469 };
 470
 471 static void *ssh_comp_none_init(void)
 472 {
 473     return NULL;
 474 }
 475 static void ssh_comp_none_cleanup(void *handle)
 476 {
 477 }
 478 static int ssh_comp_none_block(void *handle, unsigned char *block, int len,
 479                                unsigned char **outblock, int *outlen)
 480 {
 481     return 0;
 482 }
 483 static int ssh_comp_none_disable(void *handle)
 484 {
 485     return 0;
 486 }
 487 const static struct ssh_compress ssh_comp_none = {
 488     "none",
 489     ssh_comp_none_init, ssh_comp_none_cleanup, ssh_comp_none_block,
 490     ssh_comp_none_init, ssh_comp_none_cleanup, ssh_comp_none_block,
 491     ssh_comp_none_disable, NULL
 492 };
 493 extern const struct ssh_compress ssh_zlib;
 494 const static struct ssh_compress *compressions[] = {
 495     &ssh_zlib, &ssh_comp_none
 496 };
 497
 498 enum {                                 /* channel types */
 499     CHAN_MAINSESSION,
 500     CHAN_X11,
 501     CHAN_AGENT,
 502     CHAN_SOCKDATA,
 503     CHAN_SOCKDATA_DORMANT              /* one the remote hasn't confirmed */
 504 };
 505
 506 /*
 507  * 2-3-4 tree storing channels.
 508  */
 509 struct ssh_channel {
 510     Ssh ssh;                           /* pointer back to main context */
 511     unsigned remoteid, localid;
 512     int type;
 513     /* True if we opened this channel but server hasn't confirmed. */
 514     int halfopen;
 515     /*
 516      * In SSH-1, this value contains four bits:
 517      *
 518      *   1   We have sent SSH1_MSG_CHANNEL_CLOSE.
 519      *   2   We have sent SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
 520      *   4   We have received SSH1_MSG_CHANNEL_CLOSE.
 521      *   8   We have received SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
 522      *
 523      * A channel is completely finished with when all four bits are set.
 524      */
 525     int closes;
 526     union {
 527         struct ssh1_data_channel {
 528             int throttling;
 529         } v1;
 530         struct ssh2_data_channel {
 531             bufchain outbuffer;
 532             unsigned remwindow, remmaxpkt;
 533             unsigned locwindow;
 534         } v2;
 535     } v;
 536     union {
 537         struct ssh_agent_channel {
 538             unsigned char *message;
 539             unsigned char msglen[4];
 540             unsigned lensofar, totallen;
 541         } a;
 542         struct ssh_x11_channel {
 543             Socket s;
 544         } x11;
 545         struct ssh_pfd_channel {
 546             Socket s;
 547         } pfd;
 548     } u;
 549 };
 550
 551 /*
 552  * 2-3-4 tree storing remote->local port forwardings. SSH-1 and SSH-2
 553  * use this structure in different ways, reflecting SSH-2's
 554  * altogether saner approach to port forwarding.
 555  *
 556  * In SSH-1, you arrange a remote forwarding by sending the server
 557  * the remote port number, and the local destination host:port.
 558  * When a connection comes in, the server sends you back that
 559  * host:port pair, and you connect to it. This is a ready-made
 560  * security hole if you're not on the ball: a malicious server
 561  * could send you back _any_ host:port pair, so if you trustingly
 562  * connect to the address it gives you then you've just opened the
 563  * entire inside of your corporate network just by connecting
 564  * through it to a dodgy SSH server. Hence, we must store a list of
 565  * host:port pairs we _are_ trying to forward to, and reject a
 566  * connection request from the server if it's not in the list.
 567  *
 568  * In SSH-2, each side of the connection minds its own business and
 569  * doesn't send unnecessary information to the other. You arrange a
 570  * remote forwarding by sending the server just the remote port
 571  * number. When a connection comes in, the server tells you which
 572  * of its ports was connected to; and _you_ have to remember what
 573  * local host:port pair went with that port number.
 574  *
 575  * Hence, in SSH-1 this structure is indexed by destination
 576  * host:port pair, whereas in SSH-2 it is indexed by source port.
 577  */
 578 struct ssh_portfwd; /* forward declaration */
 579
 580 struct ssh_rportfwd {
 581     unsigned sport, dport;
 582     char dhost[256];
 583     char *sportdesc;
 584     struct ssh_portfwd *pfrec;
 585 };
 586 #define free_rportfwd(pf) ( \
 587     ((pf) ? (sfree((pf)->sportdesc)) : (void)0 ), sfree(pf) )
 588
 589 /*
 590  * Separately to the rportfwd tree (which is for looking up port
 591  * open requests from the server), a tree of _these_ structures is
 592  * used to keep track of all the currently open port forwardings,
 593  * so that we can reconfigure in mid-session if the user requests
 594  * it.
 595  */
 596 struct ssh_portfwd {
 597     enum { DESTROY, KEEP, CREATE } status;
 598     int type;
 599     unsigned sport, dport;
 600     char *saddr, *daddr;
 601     char *sserv, *dserv;
 602     struct ssh_rportfwd *remote;
 603     int addressfamily;
 604     void *local;
 605 };
 606 #define free_portfwd(pf) ( \
 607     ((pf) ? (sfree((pf)->saddr), sfree((pf)->daddr), \
 608              sfree((pf)->sserv), sfree((pf)->dserv)) : (void)0 ), sfree(pf) )
 609
 610 struct Packet {
 611     long length;            /* length of `data' actually used */
 612     long forcepad;          /* SSH-2: force padding to at least this length */
 613     int type;               /* only used for incoming packets */
 614     unsigned long sequence; /* SSH-2 incoming sequence number */
 615     unsigned char *data;    /* allocated storage */
 616     unsigned char *body;    /* offset of payload within `data' */
 617     long savedpos;          /* temporary index into `data' (for strings) */
 618     long maxlen;            /* amount of storage allocated for `data' */
 619     long encrypted_len;     /* for SSH-2 total-size counting */
 620
 621     /*
 622      * State associated with packet logging
 623      */
 624     int logmode;
 625     int nblanks;
 626     struct logblank_t *blanks;
 627 };
 628
 629 static void ssh1_protocol(Ssh ssh, void *vin, int inlen,
 630                           struct Packet *pktin);
 631 static void ssh2_protocol(Ssh ssh, void *vin, int inlen,
 632                           struct Packet *pktin);
 633 static void ssh1_protocol_setup(Ssh ssh);
 634 static void ssh2_protocol_setup(Ssh ssh);
 635 static void ssh_size(void *handle, int width, int height);
 636 static void ssh_special(void *handle, Telnet_Special);
 637 static int ssh2_try_send(struct ssh_channel *c);
 638 static void ssh2_add_channel_data(struct ssh_channel *c, char *buf, int len);
 639 static void ssh_throttle_all(Ssh ssh, int enable, int bufsize);
 640 static void ssh2_set_window(struct ssh_channel *c, unsigned newwin);
 641 static int ssh_sendbuffer(void *handle);
 642 static int ssh_do_close(Ssh ssh, int notify_exit);
 643 static unsigned long ssh_pkt_getuint32(struct Packet *pkt);
 644 static int ssh2_pkt_getbool(struct Packet *pkt);
 645 static void ssh_pkt_getstring(struct Packet *pkt, char **p, int *length);
 646 static void ssh2_timer(void *ctx, long now);
 647 static int do_ssh2_transport(Ssh ssh, void *vin, int inlen,
 648                              struct Packet *pktin);
 649
 650 struct rdpkt1_state_tag {
 651     long len, pad, biglen, to_read;
 652     unsigned long realcrc, gotcrc;
 653     unsigned char *p;
 654     int i;
 655     int chunk;
 656     struct Packet *pktin;
 657 };
 658
 659 struct rdpkt2_state_tag {
 660     long len, pad, payload, packetlen, maclen;
 661     int i;
 662     int cipherblk;
 663     unsigned long incoming_sequence;
 664     struct Packet *pktin;
 665 };
 666
 667 typedef void (*handler_fn_t)(Ssh ssh, struct Packet *pktin);
 668 typedef void (*chandler_fn_t)(Ssh ssh, struct Packet *pktin, void *ctx);
 669
 670 struct queued_handler;
 671 struct queued_handler {
 672     int msg1, msg2;
 673     chandler_fn_t handler;
 674     void *ctx;
 675     struct queued_handler *next;
 676 };
 677
 678 struct ssh_tag {
 679     const struct plug_function_table *fn;
 680     /* the above field _must_ be first in the structure */
 681
 682     char *v_c, *v_s;
 683     SHA_State exhash;
 684
 685     Socket s;
 686
 687     void *ldisc;
 688     void *logctx;
 689
 690     unsigned char session_key[32];
 691     int v1_compressing;
 692     int v1_remote_protoflags;
 693     int v1_local_protoflags;
 694     int agentfwd_enabled;
 695     int X11_fwd_enabled;
 696     int remote_bugs;
 697     const struct ssh_cipher *cipher;
 698     void *v1_cipher_ctx;
 699     void *crcda_ctx;
 700     const struct ssh2_cipher *cscipher, *sccipher;
 701     void *cs_cipher_ctx, *sc_cipher_ctx;
 702     const struct ssh_mac *csmac, *scmac;
 703     void *cs_mac_ctx, *sc_mac_ctx;
 704     const struct ssh_compress *cscomp, *sccomp;
 705     void *cs_comp_ctx, *sc_comp_ctx;
 706     const struct ssh_kex *kex;
 707     const struct ssh_signkey *hostkey;
 708     unsigned char v2_session_id[20];
 709     void *kex_ctx;
 710
 711     char *savedhost;
 712     int savedport;
 713     int send_ok;
 714     int echoing, editing;
 715
 716     void *frontend;
 717
 718     int ospeed, ispeed;                /* temporaries */
 719     int term_width, term_height;
 720
 721     tree234 *channels;                 /* indexed by local id */
 722     struct ssh_channel *mainchan;      /* primary session channel */
 723     int exitcode;
 724     int close_expected;
 725     int clean_exit;
 726
 727     tree234 *rportfwds, *portfwds;
 728
 729     enum {
 730         SSH_STATE_PREPACKET,
 731         SSH_STATE_BEFORE_SIZE,
 732         SSH_STATE_INTERMED,
 733         SSH_STATE_SESSION,
 734         SSH_STATE_CLOSED
 735     } state;
 736
 737     int size_needed, eof_needed;
 738
 739     struct Packet **queue;
 740     int queuelen, queuesize;
 741     int queueing;
 742     unsigned char *deferred_send_data;
 743     int deferred_len, deferred_size;
 744
 745     /*
 746      * Gross hack: pscp will try to start SFTP but fall back to
 747      * scp1 if that fails. This variable is the means by which
 748      * scp.c can reach into the SSH code and find out which one it
 749      * got.
 750      */
 751     int fallback_cmd;
 752
 753     bufchain banner;    /* accumulates banners during do_ssh2_authconn */
 754     /*
 755      * Used for username and password input.
 756      */
 757     char *userpass_input_buffer;
 758     int userpass_input_buflen;
 759     int userpass_input_bufpos;
 760     int userpass_input_echo;
 761
 762     int pkt_ctx;
 763
 764     void *x11auth;
 765
 766     int version;
 767     int v1_throttle_count;
 768     int overall_bufsize;
 769     int throttled_all;
 770     int v1_stdout_throttling;
 771     unsigned long v2_outgoing_sequence;
 772
 773     int ssh1_rdpkt_crstate;
 774     int ssh2_rdpkt_crstate;
 775     int do_ssh_init_crstate;
 776     int ssh_gotdata_crstate;
 777     int do_ssh1_login_crstate;
 778     int do_ssh1_connection_crstate;
 779     int do_ssh2_transport_crstate;
 780     int do_ssh2_authconn_crstate;
 781
 782     void *do_ssh_init_state;
 783     void *do_ssh1_login_state;
 784     void *do_ssh2_transport_state;
 785     void *do_ssh2_authconn_state;
 786
 787     struct rdpkt1_state_tag rdpkt1_state;
 788     struct rdpkt2_state_tag rdpkt2_state;
 789
 790     /* SSH-1 and SSH-2 use this for different things, but both use it */
 791     int protocol_initial_phase_done;
 792
 793     void (*protocol) (Ssh ssh, void *vin, int inlen,
 794                       struct Packet *pkt);
 795     struct Packet *(*s_rdpkt) (Ssh ssh, unsigned char **data, int *datalen);
 796
 797     /*
 798      * We maintain a full _copy_ of a Config structure here, not
 799      * merely a pointer to it. That way, when we're passed a new
 800      * one for reconfiguration, we can check the differences and
 801      * potentially reconfigure port forwardings etc in mid-session.
 802      */
 803     Config cfg;
 804
 805     /*
 806      * Used to transfer data back from async callbacks.
 807      */
 808     void *agent_response;
 809     int agent_response_len;
 810     int user_response;
 811
 812     /*
 813      * The SSH connection can be set as `frozen', meaning we are
 814      * not currently accepting incoming data from the network. This
 815      * is slightly more serious than setting the _socket_ as
 816      * frozen, because we may already have had data passed to us
 817      * from the network which we need to delay processing until
 818      * after the freeze is lifted, so we also need a bufchain to
 819      * store that data.
 820      */
 821     int frozen;
 822     bufchain queued_incoming_data;
 823
 824     /*
 825      * Dispatch table for packet types that we may have to deal
 826      * with at any time.
 827      */
 828     handler_fn_t packet_dispatch[256];
 829
 830     /*
 831      * Queues of one-off handler functions for success/failure
 832      * indications from a request.
 833      */
 834     struct queued_handler *qhead, *qtail;
 835
 836     /*
 837      * This module deals with sending keepalives.
 838      */
 839     Pinger pinger;
 840
 841     /*
 842      * Track incoming and outgoing data sizes and time, for
 843      * size-based rekeys.
 844      */
 845     unsigned long incoming_data_size, outgoing_data_size, deferred_data_size;
 846     unsigned long max_data_size;
 847     int kex_in_progress;
 848     long next_rekey, last_rekey;
 849     char *deferred_rekey_reason;    /* points to STATIC string; don't free */
 850 };
 851
 852 #define logevent(s) logevent(ssh->frontend, s)
 853
 854 /* logevent, only printf-formatted. */
 855 static void logeventf(Ssh ssh, const char *fmt, ...)
 856 {
 857     va_list ap;
 858     char *buf;
 859
 860     va_start(ap, fmt);
 861     buf = dupvprintf(fmt, ap);
 862     va_end(ap);
 863     logevent(buf);
 864     sfree(buf);
 865 }
 866
 867 #define bombout(msg) \
 868     do { \
 869         char *text = dupprintf msg; \
 870         ssh_do_close(ssh, FALSE); \
 871         logevent(text); \
 872         connection_fatal(ssh->frontend, "%s", text); \
 873         sfree(text); \
 874     } while (0)
 875
 876 /* Functions to leave bits out of the SSH packet log file. */
 877
 878 static void dont_log_password(Ssh ssh, struct Packet *pkt, int blanktype)
 879 {
 880     if (ssh->cfg.logomitpass)
 881         pkt->logmode = blanktype;
 882 }
 883
 884 static void dont_log_data(Ssh ssh, struct Packet *pkt, int blanktype)
 885 {
 886     if (ssh->cfg.logomitdata)
 887         pkt->logmode = blanktype;
 888 }
 889
 890 static void end_log_omission(Ssh ssh, struct Packet *pkt)
 891 {
 892     pkt->logmode = PKTLOG_EMIT;
 893 }
 894
 895 /* Helper function for common bits of parsing cfg.ttymodes. */
 896 static void parse_ttymodes(Ssh ssh, char *modes,
 897                            void (*do_mode)(void *data, char *mode, char *val),
 898                            void *data)
 899 {
 900     while (*modes) {
 901         char *t = strchr(modes, '\t');
 902         char *m = snewn(t-modes+1, char);
 903         char *val;
 904         strncpy(m, modes, t-modes);
 905         m[t-modes] = '\0';
 906         if (*(t+1) == 'A')
 907             val = get_ttymode(ssh->frontend, m);
 908         else
 909             val = dupstr(t+2);
 910         if (val)
 911             do_mode(data, m, val);
 912         sfree(m);
 913         sfree(val);
 914         modes += strlen(modes) + 1;
 915     }
 916 }
 917
 918 static int ssh_channelcmp(void *av, void *bv)
 919 {
 920     struct ssh_channel *a = (struct ssh_channel *) av;
 921     struct ssh_channel *b = (struct ssh_channel *) bv;
 922     if (a->localid < b->localid)
 923         return -1;
 924     if (a->localid > b->localid)
 925         return +1;
 926     return 0;
 927 }
 928 static int ssh_channelfind(void *av, void *bv)
 929 {
 930     unsigned *a = (unsigned *) av;
 931     struct ssh_channel *b = (struct ssh_channel *) bv;
 932     if (*a < b->localid)
 933         return -1;
 934     if (*a > b->localid)
 935         return +1;
 936     return 0;
 937 }
 938
 939 static int ssh_rportcmp_ssh1(void *av, void *bv)
 940 {
 941     struct ssh_rportfwd *a = (struct ssh_rportfwd *) av;
 942     struct ssh_rportfwd *b = (struct ssh_rportfwd *) bv;
 943     int i;
 944     if ( (i = strcmp(a->dhost, b->dhost)) != 0)
 945         return i < 0 ? -1 : +1;
 946     if (a->dport > b->dport)
 947         return +1;
 948     if (a->dport < b->dport)
 949         return -1;
 950     return 0;
 951 }
 952
 953 static int ssh_rportcmp_ssh2(void *av, void *bv)
 954 {
 955     struct ssh_rportfwd *a = (struct ssh_rportfwd *) av;
 956     struct ssh_rportfwd *b = (struct ssh_rportfwd *) bv;
 957
 958     if (a->sport > b->sport)
 959         return +1;
 960     if (a->sport < b->sport)
 961         return -1;
 962     return 0;
 963 }
 964
 965 /*
 966  * Special form of strcmp which can cope with NULL inputs. NULL is
 967  * defined to sort before even the empty string.
 968  */
 969 static int nullstrcmp(const char *a, const char *b)
 970 {
 971     if (a == NULL && b == NULL)
 972         return 0;
 973     if (a == NULL)
 974         return -1;
 975     if (b == NULL)
 976         return +1;
 977     return strcmp(a, b);
 978 }
 979
 980 static int ssh_portcmp(void *av, void *bv)
 981 {
 982     struct ssh_portfwd *a = (struct ssh_portfwd *) av;
 983     struct ssh_portfwd *b = (struct ssh_portfwd *) bv;
 984     int i;
 985     if (a->type > b->type)
 986         return +1;
 987     if (a->type < b->type)
 988         return -1;
 989     if (a->addressfamily > b->addressfamily)
 990         return +1;
 991     if (a->addressfamily < b->addressfamily)
 992         return -1;
 993     if ( (i = nullstrcmp(a->saddr, b->saddr)) != 0)
 994         return i < 0 ? -1 : +1;
 995     if (a->sport > b->sport)
 996         return +1;
 997     if (a->sport < b->sport)
 998         return -1;
 999     if (a->type != 'D') {
1000         if ( (i = nullstrcmp(a->daddr, b->daddr)) != 0)
1001             return i < 0 ? -1 : +1;
1002         if (a->dport > b->dport)
1003             return +1;
1004         if (a->dport < b->dport)
1005             return -1;
1006     }
1007     return 0;
1008 }
1009
1010 static int alloc_channel_id(Ssh ssh)
1011 {
1012     const unsigned CHANNEL_NUMBER_OFFSET = 256;
1013     unsigned low, high, mid;
1014     int tsize;
1015     struct ssh_channel *c;
1016
1017     /*
1018      * First-fit allocation of channel numbers: always pick the
1019      * lowest unused one. To do this, binary-search using the
1020      * counted B-tree to find the largest channel ID which is in a
1021      * contiguous sequence from the beginning. (Precisely
1022      * everything in that sequence must have ID equal to its tree
1023      * index plus CHANNEL_NUMBER_OFFSET.)
1024      */
1025     tsize = count234(ssh->channels);
1026
1027     low = -1;
1028     high = tsize;
1029     while (high - low > 1) {
1030         mid = (high + low) / 2;
1031         c = index234(ssh->channels, mid);
1032         if (c->localid == mid + CHANNEL_NUMBER_OFFSET)
1033             low = mid;                 /* this one is fine */
1034         else
1035             high = mid;                /* this one is past it */
1036     }
1037     /*
1038      * Now low points to either -1, or the tree index of the
1039      * largest ID in the initial sequence.
1040      */
1041     {
1042         unsigned i = low + 1 + CHANNEL_NUMBER_OFFSET;
1043         assert(NULL == find234(ssh->channels, &i, ssh_channelfind));
1044     }
1045     return low + 1 + CHANNEL_NUMBER_OFFSET;
1046 }
1047
1048 static void c_write(Ssh ssh, const char *buf, int len)
1049 {
1050     if ((flags & FLAG_STDERR)) {
1051         int i;
1052         for (i = 0; i < len; i++)
1053             if (buf[i] != '\r')
1054                 fputc(buf[i], stderr);
1055         return;
1056     }
1057     from_backend(ssh->frontend, 1, buf, len);
1058 }
1059
1060 static void c_write_untrusted(Ssh ssh, const char *buf, int len)
1061 {
1062     int i;
1063     for (i = 0; i < len; i++) {
1064         if (buf[i] == '\n')
1065             c_write(ssh, "\r\n", 2);
1066         else if ((buf[i] & 0x60) || (buf[i] == '\r'))
1067             c_write(ssh, buf + i, 1);
1068     }
1069 }
1070
1071 static void c_write_str(Ssh ssh, const char *buf)
1072 {
1073     c_write(ssh, buf, strlen(buf));
1074 }
1075
1076 static void ssh_free_packet(struct Packet *pkt)
1077 {
1078     sfree(pkt->data);
1079     sfree(pkt);
1080 }
1081 static struct Packet *ssh_new_packet(void)
1082 {
1083     struct Packet *pkt = snew(struct Packet);
1084
1085     pkt->body = pkt->data = NULL;
1086     pkt->maxlen = 0;
1087     pkt->logmode = PKTLOG_EMIT;
1088     pkt->nblanks = 0;
1089     pkt->blanks = NULL;
1090
1091     return pkt;
1092 }
1093
1094 /*
1095  * Collect incoming data in the incoming packet buffer.
1096  * Decipher and verify the packet when it is completely read.
1097  * Drop SSH1_MSG_DEBUG and SSH1_MSG_IGNORE packets.
1098  * Update the *data and *datalen variables.
1099  * Return a Packet structure when a packet is completed.
1100  */
1101 static struct Packet *ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
1102 {
1103     struct rdpkt1_state_tag *st = &ssh->rdpkt1_state;
1104
1105     crBegin(ssh->ssh1_rdpkt_crstate);
1106
1107     st->pktin = ssh_new_packet();
1108
1109     st->pktin->type = 0;
1110     st->pktin->length = 0;
1111
1112     for (st->i = st->len = 0; st->i < 4; st->i++) {
1113         while ((*datalen) == 0)
1114             crReturn(NULL);
1115         st->len = (st->len << 8) + **data;
1116         (*data)++, (*datalen)--;
1117     }
1118
1119     st->pad = 8 - (st->len % 8);
1120     st->biglen = st->len + st->pad;
1121     st->pktin->length = st->len - 5;
1122
1123     if (st->biglen < 0) {
1124         bombout(("Extremely large packet length from server suggests"
1125                  " data stream corruption"));
1126         ssh_free_packet(st->pktin);
1127         crStop(NULL);
1128     }
1129
1130     st->pktin->maxlen = st->biglen;
1131     st->pktin->data = snewn(st->biglen + APIEXTRA, unsigned char);
1132
1133     st->to_read = st->biglen;
1134     st->p = st->pktin->data;
1135     while (st->to_read > 0) {
1136         st->chunk = st->to_read;
1137         while ((*datalen) == 0)
1138             crReturn(NULL);
1139         if (st->chunk > (*datalen))
1140             st->chunk = (*datalen);
1141         memcpy(st->p, *data, st->chunk);
1142         *data += st->chunk;
1143         *datalen -= st->chunk;
1144         st->p += st->chunk;
1145         st->to_read -= st->chunk;
1146     }
1147
1148     if (ssh->cipher && detect_attack(ssh->crcda_ctx, st->pktin->data,
1149                                      st->biglen, NULL)) {
1150         bombout(("Network attack (CRC compensation) detected!"));
1151         ssh_free_packet(st->pktin);
1152         crStop(NULL);
1153     }
1154
1155     if (ssh->cipher)
1156         ssh->cipher->decrypt(ssh->v1_cipher_ctx, st->pktin->data, st->biglen);
1157
1158     st->realcrc = crc32_compute(st->pktin->data, st->biglen - 4);
1159     st->gotcrc = GET_32BIT(st->pktin->data + st->biglen - 4);
1160     if (st->gotcrc != st->realcrc) {
1161         bombout(("Incorrect CRC received on packet"));
1162         ssh_free_packet(st->pktin);
1163         crStop(NULL);
1164     }
1165
1166     st->pktin->body = st->pktin->data + st->pad + 1;
1167     st->pktin->savedpos = 0;
1168
1169     if (ssh->v1_compressing) {
1170         unsigned char *decompblk;
1171         int decomplen;
1172         if (!zlib_decompress_block(ssh->sc_comp_ctx,
1173                                    st->pktin->body - 1, st->pktin->length + 1,
1174                                    &decompblk, &decomplen)) {
1175             bombout(("Zlib decompression encountered invalid data"));
1176             ssh_free_packet(st->pktin);
1177             crStop(NULL);
1178         }
1179
1180         if (st->pktin->maxlen < st->pad + decomplen) {
1181             st->pktin->maxlen = st->pad + decomplen;
1182             st->pktin->data = sresize(st->pktin->data,
1183                                       st->pktin->maxlen + APIEXTRA,
1184                                       unsigned char);
1185             st->pktin->body = st->pktin->data + st->pad + 1;
1186         }
1187
1188         memcpy(st->pktin->body - 1, decompblk, decomplen);
1189         sfree(decompblk);
1190         st->pktin->length = decomplen - 1;
1191     }
1192
1193     st->pktin->type = st->pktin->body[-1];
1194
1195     /*
1196      * Log incoming packet, possibly omitting sensitive fields.
1197      */
1198     if (ssh->logctx) {
1199         int nblanks = 0;
1200         struct logblank_t blank;
1201         if (ssh->cfg.logomitdata) {
1202             int do_blank = FALSE, blank_prefix = 0;
1203             /* "Session data" packets - omit the data field */
1204             if ((st->pktin->type == SSH1_SMSG_STDOUT_DATA) ||
1205                 (st->pktin->type == SSH1_SMSG_STDERR_DATA)) {
1206                 do_blank = TRUE; blank_prefix = 0;
1207             } else if (st->pktin->type == SSH1_MSG_CHANNEL_DATA) {
1208                 do_blank = TRUE; blank_prefix = 4;
1209             }
1210             if (do_blank) {
1211                 blank.offset = blank_prefix;
1212                 blank.len = st->pktin->length;
1213                 blank.type = PKTLOG_OMIT;
1214                 nblanks = 1;
1215             }
1216         }
1217         log_packet(ssh->logctx,
1218                    PKT_INCOMING, st->pktin->type,
1219                    ssh1_pkt_type(st->pktin->type),
1220                    st->pktin->body, st->pktin->length,
1221                    nblanks, &blank);
1222     }
1223
1224     crFinish(st->pktin);
1225 }
1226
1227 static struct Packet *ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
1228 {
1229     struct rdpkt2_state_tag *st = &ssh->rdpkt2_state;
1230
1231     crBegin(ssh->ssh2_rdpkt_crstate);
1232
1233     st->pktin = ssh_new_packet();
1234
1235     st->pktin->type = 0;
1236     st->pktin->length = 0;
1237     if (ssh->sccipher)
1238         st->cipherblk = ssh->sccipher->blksize;
1239     else
1240         st->cipherblk = 8;
1241     if (st->cipherblk < 8)
1242         st->cipherblk = 8;
1243
1244     st->pktin->data = snewn(st->cipherblk + APIEXTRA, unsigned char);
1245
1246     /*
1247      * Acquire and decrypt the first block of the packet. This will
1248      * contain the length and padding details.
1249      */
1250     for (st->i = st->len = 0; st->i < st->cipherblk; st->i++) {
1251         while ((*datalen) == 0)
1252             crReturn(NULL);
1253         st->pktin->data[st->i] = *(*data)++;
1254         (*datalen)--;
1255     }
1256
1257     if (ssh->sccipher)
1258         ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
1259                                st->pktin->data, st->cipherblk);
1260
1261     /*
1262      * Now get the length and padding figures.
1263      */
1264     st->len = GET_32BIT(st->pktin->data);
1265     st->pad = st->pktin->data[4];
1266
1267     /*
1268      * _Completely_ silly lengths should be stomped on before they
1269      * do us any more damage.
1270      */
1271     if (st->len < 0 || st->len > 35000 || st->pad < 4 ||
1272         st->len - st->pad < 1 || (st->len + 4) % st->cipherblk != 0) {
1273         bombout(("Incoming packet was garbled on decryption"));
1274         ssh_free_packet(st->pktin);
1275         crStop(NULL);
1276     }
1277
1278     /*
1279      * This enables us to deduce the payload length.
1280      */
1281     st->payload = st->len - st->pad - 1;
1282
1283     st->pktin->length = st->payload + 5;
1284
1285     /*
1286      * So now we can work out the total packet length.
1287      */
1288     st->packetlen = st->len + 4;
1289     st->maclen = ssh->scmac ? ssh->scmac->len : 0;
1290
1291     /*
1292      * Allocate memory for the rest of the packet.
1293      */
1294     st->pktin->maxlen = st->packetlen + st->maclen;
1295     st->pktin->data = sresize(st->pktin->data,
1296                               st->pktin->maxlen + APIEXTRA,
1297                               unsigned char);
1298
1299     /*
1300      * Read and decrypt the remainder of the packet.
1301      */
1302     for (st->i = st->cipherblk; st->i < st->packetlen + st->maclen;
1303          st->i++) {
1304         while ((*datalen) == 0)
1305             crReturn(NULL);
1306         st->pktin->data[st->i] = *(*data)++;
1307         (*datalen)--;
1308     }
1309     /* Decrypt everything _except_ the MAC. */
1310     if (ssh->sccipher)
1311         ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
1312                                st->pktin->data + st->cipherblk,
1313                                st->packetlen - st->cipherblk);
1314
1315     st->pktin->encrypted_len = st->packetlen;
1316
1317     /*
1318      * Check the MAC.
1319      */
1320     if (ssh->scmac
1321         && !ssh->scmac->verify(ssh->sc_mac_ctx, st->pktin->data, st->len + 4,
1322                                st->incoming_sequence)) {
1323         bombout(("Incorrect MAC received on packet"));
1324         ssh_free_packet(st->pktin);
1325         crStop(NULL);
1326     }
1327
1328     st->pktin->sequence = st->incoming_sequence++;
1329
1330     /*
1331      * Decompress packet payload.
1332      */
1333     {
1334         unsigned char *newpayload;
1335         int newlen;
1336         if (ssh->sccomp &&
1337             ssh->sccomp->decompress(ssh->sc_comp_ctx,
1338                                     st->pktin->data + 5, st->pktin->length - 5,
1339                                     &newpayload, &newlen)) {
1340             if (st->pktin->maxlen < newlen + 5) {
1341                 st->pktin->maxlen = newlen + 5;
1342                 st->pktin->data = sresize(st->pktin->data,
1343                                           st->pktin->maxlen + APIEXTRA,
1344                                           unsigned char);
1345             }
1346             st->pktin->length = 5 + newlen;
1347             memcpy(st->pktin->data + 5, newpayload, newlen);
1348             sfree(newpayload);
1349         }
1350     }
1351
1352     st->pktin->savedpos = 6;
1353     st->pktin->body = st->pktin->data;
1354     st->pktin->type = st->pktin->data[5];
1355
1356     /*
1357      * Log incoming packet, possibly omitting sensitive fields.
1358      */
1359     if (ssh->logctx) {
1360         int nblanks = 0;
1361         struct logblank_t blank;
1362         if (ssh->cfg.logomitdata) {
1363             int do_blank = FALSE, blank_prefix = 0;
1364             /* "Session data" packets - omit the data field */
1365             if (st->pktin->type == SSH2_MSG_CHANNEL_DATA) {
1366                 do_blank = TRUE; blank_prefix = 4;
1367             } else if (st->pktin->type == SSH2_MSG_CHANNEL_EXTENDED_DATA) {
1368                 do_blank = TRUE; blank_prefix = 8;
1369             }
1370             if (do_blank) {
1371                 blank.offset = blank_prefix;
1372                 blank.len = (st->pktin->length-6) - blank_prefix;
1373                 blank.type = PKTLOG_OMIT;
1374                 nblanks = 1;
1375             }
1376         }
1377         log_packet(ssh->logctx, PKT_INCOMING, st->pktin->type,
1378                    ssh2_pkt_type(ssh->pkt_ctx, st->pktin->type),
1379                    st->pktin->data+6, st->pktin->length-6,
1380                    nblanks, &blank);
1381     }
1382
1383     crFinish(st->pktin);
1384 }
1385
1386 static int s_wrpkt_prepare(Ssh ssh, struct Packet *pkt, int *offset_p)
1387 {
1388     int pad, biglen, i, pktoffs;
1389     unsigned long crc;
1390 #ifdef __SC__
1391     /*
1392      * XXX various versions of SC (including 8.8.4) screw up the
1393      * register allocation in this function and use the same register
1394      * (D6) for len and as a temporary, with predictable results.  The
1395      * following sledgehammer prevents this.
1396      */
1397     volatile
1398 #endif
1399     int len;
1400
1401     if (ssh->logctx)
1402         log_packet(ssh->logctx, PKT_OUTGOING, pkt->data[12],
1403                    ssh1_pkt_type(pkt->data[12]),
1404                    pkt->body, pkt->length - (pkt->body - pkt->data),
1405                    pkt->nblanks, pkt->blanks);
1406     sfree(pkt->blanks); pkt->blanks = NULL;
1407     pkt->nblanks = 0;
1408
1409     if (ssh->v1_compressing) {
1410         unsigned char *compblk;
1411         int complen;
1412         zlib_compress_block(ssh->cs_comp_ctx,
1413                             pkt->data + 12, pkt->length - 12,
1414                             &compblk, &complen);
1415         memcpy(pkt->data + 12, compblk, complen);
1416         sfree(compblk);
1417         pkt->length = complen + 12;
1418     }
1419
1420     ssh_pkt_ensure(pkt, pkt->length + 4); /* space for CRC */
1421     pkt->length += 4;
1422     len = pkt->length - 4 - 8;  /* len(type+data+CRC) */
1423     pad = 8 - (len % 8);
1424     pktoffs = 8 - pad;
1425     biglen = len + pad;         /* len(padding+type+data+CRC) */
1426
1427     for (i = pktoffs; i < 4+8; i++)
1428         pkt->data[i] = random_byte();
1429     crc = crc32_compute(pkt->data + pktoffs + 4, biglen - 4); /* all ex len */
1430     PUT_32BIT(pkt->data + pktoffs + 4 + biglen - 4, crc);
1431     PUT_32BIT(pkt->data + pktoffs, len);
1432
1433     if (ssh->cipher)
1434         ssh->cipher->encrypt(ssh->v1_cipher_ctx,
1435                              pkt->data + pktoffs + 4, biglen);
1436
1437     if (offset_p) *offset_p = pktoffs;
1438     return biglen + 4;          /* len(length+padding+type+data+CRC) */
1439 }
1440
1441 static void s_wrpkt(Ssh ssh, struct Packet *pkt)
1442 {
1443     int len, backlog, offset;
1444     len = s_wrpkt_prepare(ssh, pkt, &offset);
1445     backlog = sk_write(ssh->s, (char *)pkt->data + offset, len);
1446     if (backlog > SSH_MAX_BACKLOG)
1447         ssh_throttle_all(ssh, 1, backlog);
1448     ssh_free_packet(pkt);
1449 }
1450
1451 static void s_wrpkt_defer(Ssh ssh, struct Packet *pkt)
1452 {
1453     int len, offset;
1454     len = s_wrpkt_prepare(ssh, pkt, &offset);
1455     if (ssh->deferred_len + len > ssh->deferred_size) {
1456         ssh->deferred_size = ssh->deferred_len + len + 128;
1457         ssh->deferred_send_data = sresize(ssh->deferred_send_data,
1458                                           ssh->deferred_size,
1459                                           unsigned char);
1460     }
1461     memcpy(ssh->deferred_send_data + ssh->deferred_len,
1462            pkt->data + offset, len);
1463     ssh->deferred_len += len;
1464     ssh_free_packet(pkt);
1465 }
1466
1467 /*
1468  * Construct a SSH-1 packet with the specified contents.
1469  * (This all-at-once interface used to be the only one, but now SSH-1
1470  * packets can also be constructed incrementally.)
1471  */
1472 static struct Packet *construct_packet(Ssh ssh, int pkttype, va_list ap)
1473 {
1474     int argtype;
1475     Bignum bn;
1476     struct Packet *pkt;
1477
1478     pkt = ssh1_pkt_init(pkttype);
1479
1480     while ((argtype = va_arg(ap, int)) != PKT_END) {
1481         unsigned char *argp, argchar;
1482         unsigned long argint;
1483         int arglen;
1484         switch (argtype) {
1485           /* Actual fields in the packet */
1486           case PKT_INT:
1487             argint = va_arg(ap, int);
1488             ssh_pkt_adduint32(pkt, argint);
1489             break;
1490           case PKT_CHAR:
1491             argchar = (unsigned char) va_arg(ap, int);
1492             ssh_pkt_addbyte(pkt, argchar);
1493             break;
1494           case PKT_DATA:
1495             argp = va_arg(ap, unsigned char *);
1496             arglen = va_arg(ap, int);
1497             ssh_pkt_adddata(pkt, argp, arglen);
1498             break;
1499           case PKT_STR:
1500             argp = va_arg(ap, unsigned char *);
1501             ssh_pkt_addstring(pkt, argp);
1502             break;
1503           case PKT_BIGNUM:
1504             bn = va_arg(ap, Bignum);
1505             ssh1_pkt_addmp(pkt, bn);
1506             break;
1507           /* Tokens for modifications to packet logging */
1508           case PKTT_PASSWORD:
1509             dont_log_password(ssh, pkt, PKTLOG_BLANK);
1510             break;
1511           case PKTT_DATA:
1512             dont_log_data(ssh, pkt, PKTLOG_OMIT);
1513             break;
1514           case PKTT_OTHER:
1515             end_log_omission(ssh, pkt);
1516             break;
1517         }
1518     }
1519
1520     return pkt;
1521 }
1522
1523 static void send_packet(Ssh ssh, int pkttype, ...)
1524 {
1525     struct Packet *pkt;
1526     va_list ap;
1527     va_start(ap, pkttype);
1528     pkt = construct_packet(ssh, pkttype, ap);
1529     va_end(ap);
1530     s_wrpkt(ssh, pkt);
1531 }
1532
1533 static void defer_packet(Ssh ssh, int pkttype, ...)
1534 {
1535     struct Packet *pkt;
1536     va_list ap;
1537     va_start(ap, pkttype);
1538     pkt = construct_packet(ssh, pkttype, ap);
1539     va_end(ap);
1540     s_wrpkt_defer(ssh, pkt);
1541 }
1542
1543 static int ssh_versioncmp(char *a, char *b)
1544 {
1545     char *ae, *be;
1546     unsigned long av, bv;
1547
1548     av = strtoul(a, &ae, 10);
1549     bv = strtoul(b, &be, 10);
1550     if (av != bv)
1551         return (av < bv ? -1 : +1);
1552     if (*ae == '.')
1553         ae++;
1554     if (*be == '.')
1555         be++;
1556     av = strtoul(ae, &ae, 10);
1557     bv = strtoul(be, &be, 10);
1558     if (av != bv)
1559         return (av < bv ? -1 : +1);
1560     return 0;
1561 }
1562
1563 /*
1564  * Utility routines for putting an SSH-protocol `string' and
1565  * `uint32' into a SHA state.
1566  */
1567 static void sha_string(SHA_State * s, void *str, int len)
1568 {
1569     unsigned char lenblk[4];
1570     PUT_32BIT(lenblk, len);
1571     SHA_Bytes(s, lenblk, 4);
1572     SHA_Bytes(s, str, len);
1573 }
1574
1575 static void sha_uint32(SHA_State * s, unsigned i)
1576 {
1577     unsigned char intblk[4];
1578     PUT_32BIT(intblk, i);
1579     SHA_Bytes(s, intblk, 4);
1580 }
1581
1582 /*
1583  * Packet construction functions. Mostly shared between SSH-1 and SSH-2.
1584  */
1585 static void ssh_pkt_ensure(struct Packet *pkt, int length)
1586 {
1587     if (pkt->maxlen < length) {
1588         unsigned char *body = pkt->body;
1589         int offset = body ? pkt->data - body : 0;
1590         pkt->maxlen = length + 256;
1591         pkt->data = sresize(pkt->data, pkt->maxlen + APIEXTRA, unsigned char);
1592         if (body) pkt->body = pkt->data + offset;
1593     }
1594 }
1595 static void ssh_pkt_adddata(struct Packet *pkt, void *data, int len)
1596 {
1597     if (pkt->logmode != PKTLOG_EMIT) {
1598         pkt->nblanks++;
1599         pkt->blanks = sresize(pkt->blanks, pkt->nblanks, struct logblank_t);
1600         assert(pkt->body);
1601         pkt->blanks[pkt->nblanks-1].offset = pkt->length -
1602                                              (pkt->body - pkt->data);
1603         pkt->blanks[pkt->nblanks-1].len = len;
1604         pkt->blanks[pkt->nblanks-1].type = pkt->logmode;
1605     }
1606     pkt->length += len;
1607     ssh_pkt_ensure(pkt, pkt->length);
1608     memcpy(pkt->data + pkt->length - len, data, len);
1609 }
1610 static void ssh_pkt_addbyte(struct Packet *pkt, unsigned char byte)
1611 {
1612     ssh_pkt_adddata(pkt, &byte, 1);
1613 }
1614 static void ssh2_pkt_addbool(struct Packet *pkt, unsigned char value)
1615 {
1616     ssh_pkt_adddata(pkt, &value, 1);
1617 }
1618 static void ssh_pkt_adduint32(struct Packet *pkt, unsigned long value)
1619 {
1620     unsigned char x[4];
1621     PUT_32BIT(x, value);
1622     ssh_pkt_adddata(pkt, x, 4);
1623 }
1624 static void ssh_pkt_addstring_start(struct Packet *pkt)
1625 {
1626     ssh_pkt_adduint32(pkt, 0);
1627     pkt->savedpos = pkt->length;
1628 }
1629 static void ssh_pkt_addstring_str(struct Packet *pkt, char *data)
1630 {
1631     ssh_pkt_adddata(pkt, data, strlen(data));
1632     PUT_32BIT(pkt->data + pkt->savedpos - 4, pkt->length - pkt->savedpos);
1633 }
1634 static void ssh_pkt_addstring_data(struct Packet *pkt, char *data, int len)
1635 {
1636     ssh_pkt_adddata(pkt, data, len);
1637     PUT_32BIT(pkt->data + pkt->savedpos - 4, pkt->length - pkt->savedpos);
1638 }
1639 static void ssh_pkt_addstring(struct Packet *pkt, char *data)
1640 {
1641     ssh_pkt_addstring_start(pkt);
1642     ssh_pkt_addstring_str(pkt, data);
1643 }
1644 static void ssh1_pkt_addmp(struct Packet *pkt, Bignum b)
1645 {
1646     int len = ssh1_bignum_length(b);
1647     unsigned char *data = snewn(len, char);
1648     (void) ssh1_write_bignum(data, b);
1649     ssh_pkt_adddata(pkt, data, len);
1650     sfree(data);
1651 }
1652 static unsigned char *ssh2_mpint_fmt(Bignum b, int *len)
1653 {
1654     unsigned char *p;
1655     int i, n = (bignum_bitcount(b) + 7) / 8;
1656     p = snewn(n + 1, unsigned char);
1657     p[0] = 0;
1658     for (i = 1; i <= n; i++)
1659         p[i] = bignum_byte(b, n - i);
1660     i = 0;
1661     while (i <= n && p[i] == 0 && (p[i + 1] & 0x80) == 0)
1662         i++;
1663     memmove(p, p + i, n + 1 - i);
1664     *len = n + 1 - i;
1665     return p;
1666 }
1667 static void ssh2_pkt_addmp(struct Packet *pkt, Bignum b)
1668 {
1669     unsigned char *p;
1670     int len;
1671     p = ssh2_mpint_fmt(b, &len);
1672     ssh_pkt_addstring_start(pkt);
1673     ssh_pkt_addstring_data(pkt, (char *)p, len);
1674     sfree(p);
1675 }
1676
1677 static struct Packet *ssh1_pkt_init(int pkt_type)
1678 {
1679     struct Packet *pkt = ssh_new_packet();
1680     pkt->length = 4 + 8;            /* space for length + max padding */
1681     ssh_pkt_addbyte(pkt, pkt_type);
1682     pkt->body = pkt->data + pkt->length;
1683     return pkt;
1684 }
1685
1686 /* For legacy code (SSH-1 and -2 packet construction used to be separate) */
1687 #define ssh2_pkt_ensure(pkt, length) ssh_pkt_ensure(pkt, length)
1688 #define ssh2_pkt_adddata(pkt, data, len) ssh_pkt_adddata(pkt, data, len)
1689 #define ssh2_pkt_addbyte(pkt, byte) ssh_pkt_addbyte(pkt, byte)
1690 #define ssh2_pkt_adduint32(pkt, value) ssh_pkt_adduint32(pkt, value)
1691 #define ssh2_pkt_addstring_start(pkt) ssh_pkt_addstring_start(pkt)
1692 #define ssh2_pkt_addstring_str(pkt, data) ssh_pkt_addstring_str(pkt, data)
1693 #define ssh2_pkt_addstring_data(pkt, data, len) ssh_pkt_addstring_data(pkt, data, len)
1694 #define ssh2_pkt_addstring(pkt, data) ssh_pkt_addstring(pkt, data)
1695
1696 static struct Packet *ssh2_pkt_init(int pkt_type)
1697 {
1698     struct Packet *pkt = ssh_new_packet();
1699     pkt->length = 5;
1700     pkt->forcepad = 0;
1701     ssh_pkt_addbyte(pkt, (unsigned char) pkt_type);
1702     pkt->body = pkt->data + pkt->length;
1703     return pkt;
1704 }
1705
1706 /*
1707  * Construct an SSH-2 final-form packet: compress it, encrypt it,
1708  * put the MAC on it. Final packet, ready to be sent, is stored in
1709  * pkt->data. Total length is returned.
1710  */
1711 static int ssh2_pkt_construct(Ssh ssh, struct Packet *pkt)
1712 {
1713     int cipherblk, maclen, padding, i;
1714
1715     if (ssh->logctx)
1716         log_packet(ssh->logctx, PKT_OUTGOING, pkt->data[5],
1717                    ssh2_pkt_type(ssh->pkt_ctx, pkt->data[5]),
1718                    pkt->body, pkt->length - (pkt->body - pkt->data),
1719                    pkt->nblanks, pkt->blanks);
1720     sfree(pkt->blanks); pkt->blanks = NULL;
1721     pkt->nblanks = 0;
1722
1723     /*
1724      * Compress packet payload.
1725      */
1726     {
1727         unsigned char *newpayload;
1728         int newlen;
1729         if (ssh->cscomp &&
1730             ssh->cscomp->compress(ssh->cs_comp_ctx, pkt->data + 5,
1731                                   pkt->length - 5,
1732                                   &newpayload, &newlen)) {
1733             pkt->length = 5;
1734             ssh2_pkt_adddata(pkt, newpayload, newlen);
1735             sfree(newpayload);
1736         }
1737     }
1738
1739     /*
1740      * Add padding. At least four bytes, and must also bring total
1741      * length (minus MAC) up to a multiple of the block size.
1742      * If pkt->forcepad is set, make sure the packet is at least that size
1743      * after padding.
1744      */
1745     cipherblk = ssh->cscipher ? ssh->cscipher->blksize : 8;  /* block size */
1746     cipherblk = cipherblk < 8 ? 8 : cipherblk;  /* or 8 if blksize < 8 */
1747     padding = 4;
1748     if (pkt->length + padding < pkt->forcepad)
1749         padding = pkt->forcepad - pkt->length;
1750     padding +=
1751         (cipherblk - (pkt->length + padding) % cipherblk) % cipherblk;
1752     assert(padding <= 255);
1753     maclen = ssh->csmac ? ssh->csmac->len : 0;
1754     ssh2_pkt_ensure(pkt, pkt->length + padding + maclen);
1755     pkt->data[4] = padding;
1756     for (i = 0; i < padding; i++)
1757         pkt->data[pkt->length + i] = random_byte();
1758     PUT_32BIT(pkt->data, pkt->length + padding - 4);
1759     if (ssh->csmac)
1760         ssh->csmac->generate(ssh->cs_mac_ctx, pkt->data,
1761                              pkt->length + padding,
1762                              ssh->v2_outgoing_sequence);
1763     ssh->v2_outgoing_sequence++;       /* whether or not we MACed */
1764
1765     if (ssh->cscipher)
1766         ssh->cscipher->encrypt(ssh->cs_cipher_ctx,
1767                                pkt->data, pkt->length + padding);
1768
1769     pkt->encrypted_len = pkt->length + padding;
1770
1771     /* Ready-to-send packet starts at pkt->data. We return length. */
1772     return pkt->length + padding + maclen;
1773 }
1774
1775 /*
1776  * Routines called from the main SSH code to send packets. There
1777  * are quite a few of these, because we have two separate
1778  * mechanisms for delaying the sending of packets:
1779  *
1780  *  - In order to send an IGNORE message and a password message in
1781  *    a single fixed-length blob, we require the ability to
1782  *    concatenate the encrypted forms of those two packets _into_ a
1783  *    single blob and then pass it to our <network.h> transport
1784  *    layer in one go. Hence, there's a deferment mechanism which
1785  *    works after packet encryption.
1786  *
1787  *  - In order to avoid sending any connection-layer messages
1788  *    during repeat key exchange, we have to queue up any such
1789  *    outgoing messages _before_ they are encrypted (and in
1790  *    particular before they're allocated sequence numbers), and
1791  *    then send them once we've finished.
1792  *
1793  * I call these mechanisms `defer' and `queue' respectively, so as
1794  * to distinguish them reasonably easily.
1795  *
1796  * The functions send_noqueue() and defer_noqueue() free the packet
1797  * structure they are passed. Every outgoing packet goes through
1798  * precisely one of these functions in its life; packets passed to
1799  * ssh2_pkt_send() or ssh2_pkt_defer() either go straight to one of
1800  * these or get queued, and then when the queue is later emptied
1801  * the packets are all passed to defer_noqueue().
1802  *
1803  * When using a CBC-mode cipher, it's necessary to ensure that an
1804  * attacker can't provide data to be encrypted using an IV that they
1805  * know.  We ensure this by prefixing each packet that might contain
1806  * user data with an SSH_MSG_IGNORE.  This is done using the deferral
1807  * mechanism, so in this case send_noqueue() ends up redirecting to
1808  * defer_noqueue().  If you don't like this inefficiency, don't use
1809  * CBC.
1810  */
1811
1812 static void ssh2_pkt_defer_noqueue(Ssh, struct Packet *, int);
1813 static void ssh_pkt_defersend(Ssh);
1814
1815 /*
1816  * Send an SSH-2 packet immediately, without queuing or deferring.
1817  */
1818 static void ssh2_pkt_send_noqueue(Ssh ssh, struct Packet *pkt)
1819 {
1820     int len;
1821     int backlog;
1822     if (ssh->cscipher != NULL && (ssh->cscipher->flags & SSH_CIPHER_IS_CBC)) {
1823         /* We need to send two packets, so use the deferral mechanism. */
1824         ssh2_pkt_defer_noqueue(ssh, pkt, FALSE);
1825         ssh_pkt_defersend(ssh);
1826         return;
1827     }
1828     len = ssh2_pkt_construct(ssh, pkt);
1829     backlog = sk_write(ssh->s, (char *)pkt->data, len);
1830     if (backlog > SSH_MAX_BACKLOG)
1831         ssh_throttle_all(ssh, 1, backlog);
1832
1833     ssh->outgoing_data_size += pkt->encrypted_len;
1834     if (!ssh->kex_in_progress &&
1835         ssh->max_data_size != 0 &&
1836         ssh->outgoing_data_size > ssh->max_data_size)
1837         do_ssh2_transport(ssh, "too much data sent", -1, NULL);
1838
1839     ssh_free_packet(pkt);
1840 }
1841
1842 /*
1843  * Defer an SSH-2 packet.
1844  */
1845 static void ssh2_pkt_defer_noqueue(Ssh ssh, struct Packet *pkt, int noignore)
1846 {
1847     int len;
1848     if (ssh->cscipher != NULL && (ssh->cscipher->flags & SSH_CIPHER_IS_CBC) &&
1849         ssh->deferred_len == 0 && !noignore) {
1850         /*
1851          * Interpose an SSH_MSG_IGNORE to ensure that user data don't
1852          * get encrypted with a known IV.
1853          */
1854         struct Packet *ipkt = ssh2_pkt_init(SSH2_MSG_IGNORE);
1855         ssh2_pkt_defer_noqueue(ssh, ipkt, TRUE);
1856     }
1857     len = ssh2_pkt_construct(ssh, pkt);
1858     if (ssh->deferred_len + len > ssh->deferred_size) {
1859         ssh->deferred_size = ssh->deferred_len + len + 128;
1860         ssh->deferred_send_data = sresize(ssh->deferred_send_data,
1861                                           ssh->deferred_size,
1862                                           unsigned char);
1863     }
1864     memcpy(ssh->deferred_send_data + ssh->deferred_len, pkt->data, len);
1865     ssh->deferred_len += len;
1866     ssh->deferred_data_size += pkt->encrypted_len;
1867     ssh_free_packet(pkt);
1868 }
1869
1870 /*
1871  * Queue an SSH-2 packet.
1872  */
1873 static void ssh2_pkt_queue(Ssh ssh, struct Packet *pkt)
1874 {
1875     assert(ssh->queueing);
1876
1877     if (ssh->queuelen >= ssh->queuesize) {
1878         ssh->queuesize = ssh->queuelen + 32;
1879         ssh->queue = sresize(ssh->queue, ssh->queuesize, struct Packet *);
1880     }
1881
1882     ssh->queue[ssh->queuelen++] = pkt;
1883 }
1884
1885 /*
1886  * Either queue or send a packet, depending on whether queueing is
1887  * set.
1888  */
1889 static void ssh2_pkt_send(Ssh ssh, struct Packet *pkt)
1890 {
1891     if (ssh->queueing)
1892         ssh2_pkt_queue(ssh, pkt);
1893     else
1894         ssh2_pkt_send_noqueue(ssh, pkt);
1895 }
1896
1897 #if 0 /* disused */
1898 /*
1899  * Either queue or defer a packet, depending on whether queueing is
1900  * set.
1901  */
1902 static void ssh2_pkt_defer(Ssh ssh, struct Packet *pkt)
1903 {
1904     if (ssh->queueing)
1905         ssh2_pkt_queue(ssh, pkt);
1906     else
1907         ssh2_pkt_defer_noqueue(ssh, pkt, FALSE);
1908 }
1909 #endif
1910
1911 /*
1912  * Send the whole deferred data block constructed by
1913  * ssh2_pkt_defer() or SSH-1's defer_packet().
1914  *
1915  * The expected use of the defer mechanism is that you call
1916  * ssh2_pkt_defer() a few times, then call ssh_pkt_defersend(). If
1917  * not currently queueing, this simply sets up deferred_send_data
1918  * and then sends it. If we _are_ currently queueing, the calls to
1919  * ssh2_pkt_defer() put the deferred packets on to the queue
1920  * instead, and therefore ssh_pkt_defersend() has no deferred data
1921  * to send. Hence, there's no need to make it conditional on
1922  * ssh->queueing.
1923  */
1924 static void ssh_pkt_defersend(Ssh ssh)
1925 {
1926     int backlog;
1927     backlog = sk_write(ssh->s, (char *)ssh->deferred_send_data,
1928                        ssh->deferred_len);
1929     ssh->deferred_len = ssh->deferred_size = 0;
1930     sfree(ssh->deferred_send_data);
1931     ssh->deferred_send_data = NULL;
1932     if (backlog > SSH_MAX_BACKLOG)
1933         ssh_throttle_all(ssh, 1, backlog);
1934
1935     ssh->outgoing_data_size += ssh->deferred_data_size;
1936     if (!ssh->kex_in_progress &&
1937         ssh->max_data_size != 0 &&
1938         ssh->outgoing_data_size > ssh->max_data_size)
1939         do_ssh2_transport(ssh, "too much data sent", -1, NULL);
1940     ssh->deferred_data_size = 0;
1941 }
1942
1943 /*
1944  * Send all queued SSH-2 packets. We send them by means of
1945  * ssh2_pkt_defer_noqueue(), in case they included a pair of
1946  * packets that needed to be lumped together.
1947  */
1948 static void ssh2_pkt_queuesend(Ssh ssh)
1949 {
1950     int i;
1951
1952     assert(!ssh->queueing);
1953
1954     for (i = 0; i < ssh->queuelen; i++)
1955         ssh2_pkt_defer_noqueue(ssh, ssh->queue[i], FALSE);
1956     ssh->queuelen = 0;
1957
1958     ssh_pkt_defersend(ssh);
1959 }
1960
1961 #if 0
1962 void bndebug(char *string, Bignum b)
1963 {
1964     unsigned char *p;
1965     int i, len;
1966     p = ssh2_mpint_fmt(b, &len);
1967     debug(("%s", string));
1968     for (i = 0; i < len; i++)
1969         debug((" %02x", p[i]));
1970     debug(("\n"));
1971     sfree(p);
1972 }
1973 #endif
1974
1975 static void sha_mpint(SHA_State * s, Bignum b)
1976 {
1977     unsigned char *p;
1978     int len;
1979     p = ssh2_mpint_fmt(b, &len);
1980     sha_string(s, p, len);
1981     sfree(p);
1982 }
1983
1984 /*
1985  * Packet decode functions for both SSH-1 and SSH-2.
1986  */
1987 static unsigned long ssh_pkt_getuint32(struct Packet *pkt)
1988 {
1989     unsigned long value;
1990     if (pkt->length - pkt->savedpos < 4)
1991         return 0;                      /* arrgh, no way to decline (FIXME?) */
1992     value = GET_32BIT(pkt->body + pkt->savedpos);
1993     pkt->savedpos += 4;
1994     return value;
1995 }
1996 static int ssh2_pkt_getbool(struct Packet *pkt)
1997 {
1998     unsigned long value;
1999     if (pkt->length - pkt->savedpos < 1)
2000         return 0;                      /* arrgh, no way to decline (FIXME?) */
2001     value = pkt->body[pkt->savedpos] != 0;
2002     pkt->savedpos++;
2003     return value;
2004 }
2005 static void ssh_pkt_getstring(struct Packet *pkt, char **p, int *length)
2006 {
2007     int len;
2008     *p = NULL;
2009     *length = 0;
2010     if (pkt->length - pkt->savedpos < 4)
2011         return;
2012     len = GET_32BIT(pkt->body + pkt->savedpos);
2013     if (len < 0)
2014         return;
2015     *length = len;
2016     pkt->savedpos += 4;
2017     if (pkt->length - pkt->savedpos < *length)
2018         return;
2019     *p = (char *)(pkt->body + pkt->savedpos);
2020     pkt->savedpos += *length;
2021 }
2022 static void *ssh_pkt_getdata(struct Packet *pkt, int length)
2023 {
2024     if (pkt->length - pkt->savedpos < length)
2025         return NULL;
2026     pkt->savedpos += length;
2027     return pkt->body + (pkt->savedpos - length);
2028 }
2029 static int ssh1_pkt_getrsakey(struct Packet *pkt, struct RSAKey *key,
2030                               unsigned char **keystr)
2031 {
2032     int j;
2033
2034     j = makekey(pkt->body + pkt->savedpos,
2035                 pkt->length - pkt->savedpos,
2036                 key, keystr, 0);
2037
2038     if (j < 0)
2039         return FALSE;
2040
2041     pkt->savedpos += j;
2042     assert(pkt->savedpos < pkt->length);
2043
2044     return TRUE;
2045 }
2046 static Bignum ssh1_pkt_getmp(struct Packet *pkt)
2047 {
2048     int j;
2049     Bignum b;
2050
2051     j = ssh1_read_bignum(pkt->body + pkt->savedpos,
2052                          pkt->length - pkt->savedpos, &b);
2053
2054     if (j < 0)
2055         return NULL;
2056
2057     pkt->savedpos += j;
2058     return b;
2059 }
2060 static Bignum ssh2_pkt_getmp(struct Packet *pkt)
2061 {
2062     char *p;
2063     int length;
2064     Bignum b;
2065
2066     ssh_pkt_getstring(pkt, &p, &length);
2067     if (!p)
2068         return NULL;
2069     if (p[0] & 0x80)
2070         return NULL;
2071     b = bignum_from_bytes((unsigned char *)p, length);
2072     return b;
2073 }
2074
2075 /*
2076  * Helper function to add an SSH-2 signature blob to a packet.
2077  * Expects to be shown the public key blob as well as the signature
2078  * blob. Normally works just like ssh2_pkt_addstring, but will
2079  * fiddle with the signature packet if necessary for
2080  * BUG_SSH2_RSA_PADDING.
2081  */
2082 static void ssh2_add_sigblob(Ssh ssh, struct Packet *pkt,
2083                              void *pkblob_v, int pkblob_len,
2084                              void *sigblob_v, int sigblob_len)
2085 {
2086     unsigned char *pkblob = (unsigned char *)pkblob_v;
2087     unsigned char *sigblob = (unsigned char *)sigblob_v;
2088
2089     /* dmemdump(pkblob, pkblob_len); */
2090     /* dmemdump(sigblob, sigblob_len); */
2091
2092     /*
2093      * See if this is in fact an ssh-rsa signature and a buggy
2094      * server; otherwise we can just do this the easy way.
2095      */
2096     if ((ssh->remote_bugs & BUG_SSH2_RSA_PADDING) &&
2097         (GET_32BIT(pkblob) == 7 && !memcmp(pkblob+4, "ssh-rsa", 7))) {
2098         int pos, len, siglen;
2099
2100         /*
2101          * Find the byte length of the modulus.
2102          */
2103
2104         pos = 4+7;                     /* skip over "ssh-rsa" */
2105         pos += 4 + GET_32BIT(pkblob+pos);   /* skip over exponent */
2106         len = GET_32BIT(pkblob+pos);   /* find length of modulus */
2107         pos += 4;                      /* find modulus itself */
2108         while (len > 0 && pkblob[pos] == 0)
2109             len--, pos++;
2110         /* debug(("modulus length is %d\n", len)); */
2111
2112         /*
2113          * Now find the signature integer.
2114          */
2115         pos = 4+7;                     /* skip over "ssh-rsa" */
2116         siglen = GET_32BIT(sigblob+pos);
2117         /* debug(("signature length is %d\n", siglen)); */
2118
2119         if (len != siglen) {
2120             unsigned char newlen[4];
2121             ssh2_pkt_addstring_start(pkt);
2122             ssh2_pkt_addstring_data(pkt, (char *)sigblob, pos);
2123             /* dmemdump(sigblob, pos); */
2124             pos += 4;                  /* point to start of actual sig */
2125             PUT_32BIT(newlen, len);
2126             ssh2_pkt_addstring_data(pkt, (char *)newlen, 4);
2127             /* dmemdump(newlen, 4); */
2128             newlen[0] = 0;
2129             while (len-- > siglen) {
2130                 ssh2_pkt_addstring_data(pkt, (char *)newlen, 1);
2131                 /* dmemdump(newlen, 1); */
2132             }
2133             ssh2_pkt_addstring_data(pkt, (char *)(sigblob+pos), siglen);
2134             /* dmemdump(sigblob+pos, siglen); */
2135             return;
2136         }
2137
2138         /* Otherwise fall through and do it the easy way. */
2139     }
2140
2141     ssh2_pkt_addstring_start(pkt);
2142     ssh2_pkt_addstring_data(pkt, (char *)sigblob, sigblob_len);
2143 }
2144
2145 /*
2146  * Examine the remote side's version string and compare it against
2147  * a list of known buggy implementations.
2148  */
2149 static void ssh_detect_bugs(Ssh ssh, char *vstring)
2150 {
2151     char *imp;                         /* pointer to implementation part */
2152     imp = vstring;
2153     imp += strcspn(imp, "-");
2154     if (*imp) imp++;
2155     imp += strcspn(imp, "-");
2156     if (*imp) imp++;
2157
2158     ssh->remote_bugs = 0;
2159
2160     if (ssh->cfg.sshbug_ignore1 == FORCE_ON ||
2161         (ssh->cfg.sshbug_ignore1 == AUTO &&
2162          (!strcmp(imp, "1.2.18") || !strcmp(imp, "1.2.19") ||
2163           !strcmp(imp, "1.2.20") || !strcmp(imp, "1.2.21") ||
2164           !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25") ||
2165           !strcmp(imp, "OSU_1.4alpha3") || !strcmp(imp, "OSU_1.5alpha4")))) {
2166         /*
2167          * These versions don't support SSH1_MSG_IGNORE, so we have
2168          * to use a different defence against password length
2169          * sniffing.
2170          */
2171         ssh->remote_bugs |= BUG_CHOKES_ON_SSH1_IGNORE;
2172         logevent("We believe remote version has SSH-1 ignore bug");
2173     }
2174
2175     if (ssh->cfg.sshbug_plainpw1 == FORCE_ON ||
2176         (ssh->cfg.sshbug_plainpw1 == AUTO &&
2177          (!strcmp(imp, "Cisco-1.25") || !strcmp(imp, "OSU_1.4alpha3")))) {
2178         /*
2179          * These versions need a plain password sent; they can't
2180          * handle having a null and a random length of data after
2181          * the password.
2182          */
2183         ssh->remote_bugs |= BUG_NEEDS_SSH1_PLAIN_PASSWORD;
2184         logevent("We believe remote version needs a plain SSH-1 password");
2185     }
2186
2187     if (ssh->cfg.sshbug_rsa1 == FORCE_ON ||
2188         (ssh->cfg.sshbug_rsa1 == AUTO &&
2189          (!strcmp(imp, "Cisco-1.25")))) {
2190         /*
2191          * These versions apparently have no clue whatever about
2192          * RSA authentication and will panic and die if they see
2193          * an AUTH_RSA message.
2194          */
2195         ssh->remote_bugs |= BUG_CHOKES_ON_RSA;
2196         logevent("We believe remote version can't handle SSH-1 RSA authentication");
2197     }
2198
2199     if (ssh->cfg.sshbug_hmac2 == FORCE_ON ||
2200         (ssh->cfg.sshbug_hmac2 == AUTO &&
2201          !wc_match("* VShell", imp) &&
2202          (wc_match("2.1.0*", imp) || wc_match("2.0.*", imp) ||
2203           wc_match("2.2.0*", imp) || wc_match("2.3.0*", imp) ||
2204           wc_match("2.1 *", imp)))) {
2205         /*
2206          * These versions have the HMAC bug.
2207          */
2208         ssh->remote_bugs |= BUG_SSH2_HMAC;
2209         logevent("We believe remote version has SSH-2 HMAC bug");
2210     }
2211
2212     if (ssh->cfg.sshbug_derivekey2 == FORCE_ON ||
2213         (ssh->cfg.sshbug_derivekey2 == AUTO &&
2214          !wc_match("* VShell", imp) &&
2215          (wc_match("2.0.0*", imp) || wc_match("2.0.10*", imp) ))) {
2216         /*
2217          * These versions have the key-derivation bug (failing to
2218          * include the literal shared secret in the hashes that
2219          * generate the keys).
2220          */
2221         ssh->remote_bugs |= BUG_SSH2_DERIVEKEY;
2222         logevent("We believe remote version has SSH-2 key-derivation bug");
2223     }
2224
2225     if (ssh->cfg.sshbug_rsapad2 == FORCE_ON ||
2226         (ssh->cfg.sshbug_rsapad2 == AUTO &&
2227          (wc_match("OpenSSH_2.[5-9]*", imp) ||
2228           wc_match("OpenSSH_3.[0-2]*", imp)))) {
2229         /*
2230          * These versions have the SSH-2 RSA padding bug.
2231          */
2232         ssh->remote_bugs |= BUG_SSH2_RSA_PADDING;
2233         logevent("We believe remote version has SSH-2 RSA padding bug");
2234     }
2235
2236     if (ssh->cfg.sshbug_pksessid2 == FORCE_ON ||
2237         (ssh->cfg.sshbug_pksessid2 == AUTO &&
2238          wc_match("OpenSSH_2.[0-2]*", imp))) {
2239         /*
2240          * These versions have the SSH-2 session-ID bug in
2241          * public-key authentication.
2242          */
2243         ssh->remote_bugs |= BUG_SSH2_PK_SESSIONID;
2244         logevent("We believe remote version has SSH-2 public-key-session-ID bug");
2245     }
2246
2247     if (ssh->cfg.sshbug_rekey2 == FORCE_ON ||
2248         (ssh->cfg.sshbug_rekey2 == AUTO &&
2249          (wc_match("DigiSSH_2.0", imp) ||
2250           wc_match("OpenSSH_2.[0-4]*", imp) ||
2251           wc_match("OpenSSH_2.5.[0-3]*", imp) ||
2252           wc_match("Sun_SSH_1.0", imp) ||
2253           wc_match("Sun_SSH_1.0.1", imp) ||
2254           /* All versions <= 1.2.6 (they changed their format in 1.2.7) */
2255           wc_match("WeOnlyDo-*", imp)))) {
2256         /*
2257          * These versions have the SSH-2 rekey bug.
2258          */
2259         ssh->remote_bugs |= BUG_SSH2_REKEY;
2260         logevent("We believe remote version has SSH-2 rekey bug");
2261     }
2262 }
2263
2264 /*
2265  * The `software version' part of an SSH version string is required
2266  * to contain no spaces or minus signs.
2267  */
2268 static void ssh_fix_verstring(char *str)
2269 {
2270     /* Eat "SSH-<protoversion>-". */
2271     assert(*str == 'S'); str++;
2272     assert(*str == 'S'); str++;
2273     assert(*str == 'H'); str++;
2274     assert(*str == '-'); str++;
2275     while (*str && *str != '-') str++;
2276     assert(*str == '-'); str++;
2277
2278     /* Convert minus signs and spaces in the remaining string into
2279      * underscores. */
2280     while (*str) {
2281         if (*str == '-' || *str == ' ')
2282             *str = '_';
2283         str++;
2284     }
2285 }
2286
2287 static int do_ssh_init(Ssh ssh, unsigned char c)
2288 {
2289     struct do_ssh_init_state {
2290         int vslen;
2291         char version[10];
2292         char *vstring;
2293         int vstrsize;
2294         int i;
2295         int proto1, proto2;
2296     };
2297     crState(do_ssh_init_state);
2298
2299     crBegin(ssh->do_ssh_init_crstate);
2300
2301     /* Search for a line beginning with the string "SSH-" in the input. */
2302     for (;;) {
2303         if (c != 'S') goto no;
2304         crReturn(1);
2305         if (c != 'S') goto no;
2306         crReturn(1);
2307         if (c != 'H') goto no;
2308         crReturn(1);
2309         if (c != '-') goto no;
2310         break;
2311       no:
2312         while (c != '\012')
2313             crReturn(1);
2314         crReturn(1);
2315     }
2316
2317     s->vstrsize = 16;
2318     s->vstring = snewn(s->vstrsize, char);
2319     strcpy(s->vstring, "SSH-");
2320     s->vslen = 4;
2321     s->i = 0;
2322     while (1) {
2323         crReturn(1);                   /* get another char */
2324         if (s->vslen >= s->vstrsize - 1) {
2325             s->vstrsize += 16;
2326             s->vstring = sresize(s->vstring, s->vstrsize, char);
2327         }
2328         s->vstring[s->vslen++] = c;
2329         if (s->i >= 0) {
2330             if (c == '-') {
2331                 s->version[s->i] = '\0';
2332                 s->i = -1;
2333             } else if (s->i < sizeof(s->version) - 1)
2334                 s->version[s->i++] = c;
2335         } else if (c == '\012')
2336             break;
2337     }
2338
2339     ssh->agentfwd_enabled = FALSE;
2340     ssh->rdpkt2_state.incoming_sequence = 0;
2341
2342     s->vstring[s->vslen] = 0;
2343     s->vstring[strcspn(s->vstring, "\015\012")] = '\0';/* remove EOL chars */
2344     logeventf(ssh, "Server version: %s", s->vstring);
2345     ssh_detect_bugs(ssh, s->vstring);
2346
2347     /*
2348      * Decide which SSH protocol version to support.
2349      */
2350
2351     /* Anything strictly below "2.0" means protocol 1 is supported. */
2352     s->proto1 = ssh_versioncmp(s->version, "2.0") < 0;
2353     /* Anything greater or equal to "1.99" means protocol 2 is supported. */
2354     s->proto2 = ssh_versioncmp(s->version, "1.99") >= 0;
2355
2356     if (ssh->cfg.sshprot == 0 && !s->proto1) {
2357         bombout(("SSH protocol version 1 required by user but not provided by server"));
2358         crStop(0);
2359     }
2360     if (ssh->cfg.sshprot == 3 && !s->proto2) {
2361         bombout(("SSH protocol version 2 required by user but not provided by server"));
2362         crStop(0);
2363     }
2364
2365     {
2366         char *verstring;
2367
2368         if (s->proto2 && (ssh->cfg.sshprot >= 2 || !s->proto1)) {
2369             /*
2370              * Construct a v2 version string.
2371              */
2372             verstring = dupprintf("SSH-2.0-%s\015\012", sshver);
2373             ssh->version = 2;
2374         } else {
2375             /*
2376              * Construct a v1 version string.
2377              */
2378             verstring = dupprintf("SSH-%s-%s\012",
2379                                   (ssh_versioncmp(s->version, "1.5") <= 0 ?
2380                                    s->version : "1.5"),
2381                                   sshver);
2382             ssh->version = 1;
2383         }
2384
2385         ssh_fix_verstring(verstring);
2386
2387         if (ssh->version == 2) {
2388             size_t len;
2389             /*
2390              * Hash our version string and their version string.
2391              */
2392             len = strcspn(verstring, "\015\012");
2393             ssh->v_c = snewn(len + 1, char);
2394             memcpy(ssh->v_c, verstring, len);
2395             ssh->v_c[len] = 0;
2396             len = strcspn(s->vstring, "\015\012");
2397             ssh->v_s = snewn(len + 1, char);
2398             memcpy(ssh->v_s, s->vstring, len);
2399             ssh->v_s[len] = 0;
2400
2401             /*
2402              * Initialise SSH-2 protocol.
2403              */
2404             ssh->protocol = ssh2_protocol;
2405             ssh2_protocol_setup(ssh);
2406             ssh->s_rdpkt = ssh2_rdpkt;
2407         } else {
2408             /*
2409              * Initialise SSH-1 protocol.
2410              */
2411             ssh->protocol = ssh1_protocol;
2412             ssh1_protocol_setup(ssh);
2413             ssh->s_rdpkt = ssh1_rdpkt;
2414         }
2415         logeventf(ssh, "We claim version: %.*s",
2416                   strcspn(verstring, "\015\012"), verstring);
2417         sk_write(ssh->s, verstring, strlen(verstring));
2418         sfree(verstring);
2419         if (ssh->version == 2)
2420             do_ssh2_transport(ssh, NULL, -1, NULL);
2421     }
2422
2423     logeventf(ssh, "Using SSH protocol version %d", ssh->version);
2424
2425     update_specials_menu(ssh->frontend);
2426     ssh->state = SSH_STATE_BEFORE_SIZE;
2427     ssh->pinger = pinger_new(&ssh->cfg, &ssh_backend, ssh);
2428
2429     sfree(s->vstring);
2430
2431     crFinish(0);
2432 }
2433
2434 static void ssh_process_incoming_data(Ssh ssh,
2435                                       unsigned char **data, int *datalen)
2436 {
2437     struct Packet *pktin = ssh->s_rdpkt(ssh, data, datalen);
2438     if (pktin) {
2439         ssh->protocol(ssh, NULL, 0, pktin);
2440         ssh_free_packet(pktin);
2441     }
2442 }
2443
2444 static void ssh_queue_incoming_data(Ssh ssh,
2445                                     unsigned char **data, int *datalen)
2446 {
2447     bufchain_add(&ssh->queued_incoming_data, *data, *datalen);
2448     *data += *datalen;
2449     *datalen = 0;
2450 }
2451
2452 static void ssh_process_queued_incoming_data(Ssh ssh)
2453 {
2454     void *vdata;
2455     unsigned char *data;
2456     int len, origlen;
2457
2458     while (!ssh->frozen && bufchain_size(&ssh->queued_incoming_data)) {
2459         bufchain_prefix(&ssh->queued_incoming_data, &vdata, &len);
2460         data = vdata;
2461         origlen = len;
2462
2463         while (!ssh->frozen && len > 0)
2464             ssh_process_incoming_data(ssh, &data, &len);
2465
2466         if (origlen > len)
2467             bufchain_consume(&ssh->queued_incoming_data, origlen - len);
2468     }
2469 }
2470
2471 static void ssh_set_frozen(Ssh ssh, int frozen)
2472 {
2473     if (ssh->s)
2474         sk_set_frozen(ssh->s, frozen);
2475     ssh->frozen = frozen;
2476 }
2477
2478 static void ssh_gotdata(Ssh ssh, unsigned char *data, int datalen)
2479 {
2480     crBegin(ssh->ssh_gotdata_crstate);
2481
2482     /*
2483      * To begin with, feed the characters one by one to the
2484      * protocol initialisation / selection function do_ssh_init().
2485      * When that returns 0, we're done with the initial greeting
2486      * exchange and can move on to packet discipline.
2487      */
2488     while (1) {
2489         int ret;                       /* need not be kept across crReturn */
2490         if (datalen == 0)
2491             crReturnV;                 /* more data please */
2492         ret = do_ssh_init(ssh, *data);
2493         data++;
2494         datalen--;
2495         if (ret == 0)
2496             break;
2497     }
2498
2499     /*
2500      * We emerge from that loop when the initial negotiation is
2501      * over and we have selected an s_rdpkt function. Now pass
2502      * everything to s_rdpkt, and then pass the resulting packets
2503      * to the proper protocol handler.
2504      */
2505
2506     while (1) {
2507         while (bufchain_size(&ssh->queued_incoming_data) > 0 || datalen > 0) {
2508             if (ssh->frozen) {
2509                 ssh_queue_incoming_data(ssh, &data, &datalen);
2510                 /* This uses up all data and cannot cause anything interesting
2511                  * to happen; indeed, for anything to happen at all, we must
2512                  * return, so break out. */
2513                 break;
2514             } else if (bufchain_size(&ssh->queued_incoming_data) > 0) {
2515                 /* This uses up some or all data, and may freeze the
2516                  * session. */
2517                 ssh_process_queued_incoming_data(ssh);
2518             } else {
2519                 /* This uses up some or all data, and may freeze the
2520                  * session. */
2521                 ssh_process_incoming_data(ssh, &data, &datalen);
2522             }
2523             /* FIXME this is probably EBW. */
2524             if (ssh->state == SSH_STATE_CLOSED)
2525                 return;
2526         }
2527         /* We're out of data. Go and get some more. */
2528         crReturnV;
2529     }
2530     crFinishV;
2531 }
2532
2533 static int ssh_do_close(Ssh ssh, int notify_exit)
2534 {
2535     int ret = 0;
2536     struct ssh_channel *c;
2537
2538     ssh->state = SSH_STATE_CLOSED;
2539     expire_timer_context(ssh);
2540     if (ssh->s) {
2541         sk_close(ssh->s);
2542         ssh->s = NULL;
2543         if (notify_exit)
2544             notify_remote_exit(ssh->frontend);
2545         else
2546             ret = 1;
2547     }
2548     /*
2549      * Now we must shut down any port- and X-forwarded channels going
2550      * through this connection.
2551      */
2552     if (ssh->channels) {
2553         while (NULL != (c = index234(ssh->channels, 0))) {
2554             switch (c->type) {
2555               case CHAN_X11:
2556                 x11_close(c->u.x11.s);
2557                 break;
2558               case CHAN_SOCKDATA:
2559                 pfd_close(c->u.pfd.s);
2560                 break;
2561             }
2562             del234(ssh->channels, c); /* moving next one to index 0 */
2563             if (ssh->version == 2)
2564                 bufchain_clear(&c->v.v2.outbuffer);
2565             sfree(c);
2566         }
2567     }
2568     /*
2569      * Go through port-forwardings, and close any associated
2570      * listening sockets.
2571      */
2572     if (ssh->portfwds) {
2573         struct ssh_portfwd *pf;
2574         while (NULL != (pf = index234(ssh->portfwds, 0))) {
2575             /* Dispose of any listening socket. */
2576             if (pf->local)
2577                 pfd_terminate(pf->local);
2578             del234(ssh->portfwds, pf); /* moving next one to index 0 */
2579             free_portfwd(pf);
2580         }
2581     }
2582
2583     return ret;
2584 }
2585
2586 static void ssh_log(Plug plug, int type, SockAddr addr, int port,
2587                     const char *error_msg, int error_code)
2588 {
2589     Ssh ssh = (Ssh) plug;
2590     char addrbuf[256], *msg;
2591
2592     sk_getaddr(addr, addrbuf, lenof(addrbuf));
2593
2594     if (type == 0)
2595         msg = dupprintf("Connecting to %s port %d", addrbuf, port);
2596     else
2597         msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg);
2598
2599     logevent(msg);
2600     sfree(msg);
2601 }
2602
2603 static int ssh_closing(Plug plug, const char *error_msg, int error_code,
2604                        int calling_back)
2605 {
2606     Ssh ssh = (Ssh) plug;
2607     int need_notify = ssh_do_close(ssh, FALSE);
2608
2609     if (!error_msg) {
2610         if (!ssh->close_expected)
2611             error_msg = "Server unexpectedly closed network connection";
2612         else
2613             error_msg = "Server closed network connection";
2614     }
2615
2616     if (need_notify)
2617         notify_remote_exit(ssh->frontend);
2618
2619     if (error_msg)
2620         logevent(error_msg);
2621     if (!ssh->close_expected || !ssh->clean_exit)
2622         connection_fatal(ssh->frontend, "%s", error_msg);
2623     return 0;
2624 }
2625
2626 static int ssh_receive(Plug plug, int urgent, char *data, int len)
2627 {
2628     Ssh ssh = (Ssh) plug;
2629     ssh_gotdata(ssh, (unsigned char *)data, len);
2630     if (ssh->state == SSH_STATE_CLOSED) {
2631         ssh_do_close(ssh, TRUE);
2632         return 0;
2633     }
2634     return 1;
2635 }
2636
2637 static void ssh_sent(Plug plug, int bufsize)
2638 {
2639     Ssh ssh = (Ssh) plug;
2640     /*
2641      * If the send backlog on the SSH socket itself clears, we
2642      * should unthrottle the whole world if it was throttled.
2643      */
2644     if (bufsize < SSH_MAX_BACKLOG)
2645         ssh_throttle_all(ssh, 0, bufsize);
2646 }
2647
2648 /*
2649  * Connect to specified host and port.
2650  * Returns an error message, or NULL on success.
2651  * Also places the canonical host name into `realhost'. It must be
2652  * freed by the caller.
2653  */
2654 static const char *connect_to_host(Ssh ssh, char *host, int port,
2655                                    char **realhost, int nodelay, int keepalive)
2656 {
2657     static const struct plug_function_table fn_table = {
2658         ssh_log,
2659         ssh_closing,
2660         ssh_receive,
2661         ssh_sent,
2662         NULL
2663     };
2664
2665     SockAddr addr;
2666     const char *err;
2667
2668     ssh->savedhost = snewn(1 + strlen(host), char);
2669     strcpy(ssh->savedhost, host);
2670
2671     if (port < 0)
2672         port = 22;                     /* default ssh port */
2673     ssh->savedport = port;
2674
2675     /*
2676      * Try to find host.
2677      */
2678     logeventf(ssh, "Looking up host \"%s\"%s", host,
2679               (ssh->cfg.addressfamily == ADDRTYPE_IPV4 ? " (IPv4)" :
2680                (ssh->cfg.addressfamily == ADDRTYPE_IPV6 ? " (IPv6)" : "")));
2681     addr = name_lookup(host, port, realhost, &ssh->cfg,
2682                        ssh->cfg.addressfamily);
2683     if ((err = sk_addr_error(addr)) != NULL) {
2684         sk_addr_free(addr);
2685         return err;
2686     }
2687
2688     /*
2689      * Open socket.
2690      */
2691     ssh->fn = &fn_table;
2692     ssh->s = new_connection(addr, *realhost, port,
2693                             0, 1, nodelay, keepalive, (Plug) ssh, &ssh->cfg);
2694     if ((err = sk_socket_error(ssh->s)) != NULL) {
2695         ssh->s = NULL;
2696         notify_remote_exit(ssh->frontend);
2697         return err;
2698     }
2699
2700     return NULL;
2701 }
2702
2703 /*
2704  * Throttle or unthrottle the SSH connection.
2705  */
2706 static void ssh1_throttle(Ssh ssh, int adjust)
2707 {
2708     int old_count = ssh->v1_throttle_count;
2709     ssh->v1_throttle_count += adjust;
2710     assert(ssh->v1_throttle_count >= 0);
2711     if (ssh->v1_throttle_count && !old_count) {
2712         ssh_set_frozen(ssh, 1);
2713     } else if (!ssh->v1_throttle_count && old_count) {
2714         ssh_set_frozen(ssh, 0);
2715     }
2716 }
2717
2718 /*
2719  * Throttle or unthrottle _all_ local data streams (for when sends
2720  * on the SSH connection itself back up).
2721  */
2722 static void ssh_throttle_all(Ssh ssh, int enable, int bufsize)
2723 {
2724     int i;
2725     struct ssh_channel *c;
2726
2727     if (enable == ssh->throttled_all)
2728         return;
2729     ssh->throttled_all = enable;
2730     ssh->overall_bufsize = bufsize;
2731     if (!ssh->channels)
2732         return;
2733     for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
2734         switch (c->type) {
2735           case CHAN_MAINSESSION:
2736             /*
2737              * This is treated separately, outside the switch.
2738              */
2739             break;
2740           case CHAN_X11:
2741             x11_override_throttle(c->u.x11.s, enable);
2742             break;
2743           case CHAN_AGENT:
2744             /* Agent channels require no buffer management. */
2745             break;
2746           case CHAN_SOCKDATA:
2747             pfd_override_throttle(c->u.pfd.s, enable);
2748             break;
2749         }
2750     }
2751 }
2752
2753 /*
2754  * Username and password input, abstracted off into routines
2755  * reusable in several places - even between SSH-1 and SSH-2.
2756  */
2757
2758 /* Set up a username or password input loop on a given buffer. */
2759 static void setup_userpass_input(Ssh ssh, char *buffer, int buflen, int echo)
2760 {
2761     ssh->userpass_input_buffer = buffer;
2762     ssh->userpass_input_buflen = buflen;
2763     ssh->userpass_input_bufpos = 0;
2764     ssh->userpass_input_echo = echo;
2765 }
2766
2767 /*
2768  * Process some terminal data in the course of username/password
2769  * input. Returns >0 for success (line of input returned in
2770  * buffer), <0 for failure (user hit ^C/^D, bomb out and exit), 0
2771  * for inconclusive (keep waiting for more input please).
2772  */
2773 static int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
2774 {
2775     char c;
2776
2777     while (inlen--) {
2778         switch (c = *in++) {
2779           case 10:
2780           case 13:
2781             ssh->userpass_input_buffer[ssh->userpass_input_bufpos] = 0;
2782             ssh->userpass_input_buffer[ssh->userpass_input_buflen-1] = 0;
2783             return +1;
2784             break;
2785           case 8:
2786           case 127:
2787             if (ssh->userpass_input_bufpos > 0) {
2788                 if (ssh->userpass_input_echo)
2789                     c_write_str(ssh, "\b \b");
2790                 ssh->userpass_input_bufpos--;
2791             }
2792             break;
2793           case 21:
2794           case 27:
2795             while (ssh->userpass_input_bufpos > 0) {
2796                 if (ssh->userpass_input_echo)
2797                     c_write_str(ssh, "\b \b");
2798                 ssh->userpass_input_bufpos--;
2799             }
2800             break;
2801           case 3:
2802           case 4:
2803             return -1;
2804             break;
2805           default:
2806             /*
2807              * This simplistic check for printability is disabled
2808              * when we're doing password input, because some people
2809              * have control characters in their passwords.o
2810              */
2811             if ((!ssh->userpass_input_echo ||
2812                  (c >= ' ' && c <= '~') ||
2813                  ((unsigned char) c >= 160))
2814                 && ssh->userpass_input_bufpos < ssh->userpass_input_buflen-1) {
2815                 ssh->userpass_input_buffer[ssh->userpass_input_bufpos++] = c;
2816                 if (ssh->userpass_input_echo)
2817                     c_write(ssh, &c, 1);
2818             }
2819             break;
2820         }
2821     }
2822     return 0;
2823 }
2824
2825 static void ssh_agent_callback(void *sshv, void *reply, int replylen)
2826 {
2827     Ssh ssh = (Ssh) sshv;
2828
2829     ssh->agent_response = reply;
2830     ssh->agent_response_len = replylen;
2831
2832     if (ssh->version == 1)
2833         do_ssh1_login(ssh, NULL, -1, NULL);
2834     else
2835         do_ssh2_authconn(ssh, NULL, -1, NULL);
2836 }
2837
2838 static void ssh_dialog_callback(void *sshv, int ret)
2839 {
2840     Ssh ssh = (Ssh) sshv;
2841
2842     ssh->user_response = ret;
2843
2844     if (ssh->version == 1)
2845         do_ssh1_login(ssh, NULL, -1, NULL);
2846     else
2847         do_ssh2_transport(ssh, NULL, -1, NULL);
2848
2849     /*
2850      * This may have unfrozen the SSH connection, so do a
2851      * queued-data run.
2852      */
2853     ssh_process_queued_incoming_data(ssh);
2854 }
2855
2856 static void ssh_agentf_callback(void *cv, void *reply, int replylen)
2857 {
2858     struct ssh_channel *c = (struct ssh_channel *)cv;
2859     Ssh ssh = c->ssh;
2860     void *sentreply = reply;
2861
2862     if (!sentreply) {
2863         /* Fake SSH_AGENT_FAILURE. */
2864         sentreply = "\0\0\0\1\5";
2865         replylen = 5;
2866     }
2867     if (ssh->version == 2) {
2868         ssh2_add_channel_data(c, sentreply, replylen);
2869         ssh2_try_send(c);
2870     } else {
2871         send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
2872                     PKT_INT, c->remoteid,
2873                     PKTT_DATA,
2874                     PKT_INT, replylen,
2875                     PKT_DATA, sentreply, replylen,
2876                     PKTT_OTHER,
2877                     PKT_END);
2878     }
2879     if (reply)
2880         sfree(reply);
2881 }
2882
2883 /*
2884  * Client-initiated disconnection. Send a DISCONNECT if `wire_reason'
2885  * non-NULL, otherwise just close the connection. `client_reason' == NULL
2886  * => log `wire_reason'.
2887  */
2888 static void ssh_disconnect(Ssh ssh, char *client_reason, char *wire_reason,
2889                            int code, int clean_exit)
2890 {
2891     char *error;
2892     if (!client_reason)
2893         client_reason = wire_reason;
2894     if (client_reason)
2895         error = dupprintf("Disconnected: %s", client_reason);
2896     else
2897         error = dupstr("Disconnected");
2898     if (wire_reason) {
2899         if (ssh->version == 1) {
2900             send_packet(ssh, SSH1_MSG_DISCONNECT, PKT_STR, wire_reason,
2901                         PKT_END);
2902         } else if (ssh->version == 2) {
2903             struct Packet *pktout = ssh2_pkt_init(SSH2_MSG_DISCONNECT);
2904             ssh2_pkt_adduint32(pktout, code);
2905             ssh2_pkt_addstring(pktout, wire_reason);
2906             ssh2_pkt_addstring(pktout, "en");   /* language tag */
2907             ssh2_pkt_send_noqueue(ssh, pktout);
2908         }
2909     }
2910     ssh->close_expected = TRUE;
2911     ssh->clean_exit = clean_exit;
2912     ssh_closing((Plug)ssh, error, 0, 0);
2913     sfree(error);
2914 }
2915
2916 /*
2917  * Handle the key exchange and user authentication phases.
2918  */
2919 static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen,
2920                          struct Packet *pktin)
2921 {
2922     int i, j, ret;
2923     unsigned char cookie[8], *ptr;
2924     struct RSAKey servkey, hostkey;
2925     struct MD5Context md5c;
2926     struct do_ssh1_login_state {
2927         int len;
2928         unsigned char *rsabuf, *keystr1, *keystr2;
2929         unsigned long supported_ciphers_mask, supported_auths_mask;
2930         int tried_publickey, tried_agent;
2931         int tis_auth_refused, ccard_auth_refused;
2932         unsigned char session_id[16];
2933         int cipher_type;
2934         char username[100];
2935         void *publickey_blob;
2936         int publickey_bloblen;
2937         char password[100];
2938         char prompt[200];
2939         int pos;
2940         char c;
2941         int pwpkt_type;
2942         unsigned char request[5], *response, *p;
2943         int responselen;
2944         int keyi, nkeys;
2945         int authed;
2946         struct RSAKey key;
2947         Bignum challenge;
2948         char *commentp;
2949         int commentlen;
2950         int dlgret;
2951     };
2952     crState(do_ssh1_login_state);
2953
2954     crBegin(ssh->do_ssh1_login_crstate);
2955
2956     if (!pktin)
2957         crWaitUntil(pktin);
2958
2959     if (pktin->type != SSH1_SMSG_PUBLIC_KEY) {
2960         bombout(("Public key packet not received"));
2961         crStop(0);
2962     }
2963
2964     logevent("Received public keys");
2965
2966     ptr = ssh_pkt_getdata(pktin, 8);
2967     if (!ptr) {
2968         bombout(("SSH-1 public key packet stopped before random cookie"));
2969         crStop(0);
2970     }
2971     memcpy(cookie, ptr, 8);
2972
2973     if (!ssh1_pkt_getrsakey(pktin, &servkey, &s->keystr1) ||
2974         !ssh1_pkt_getrsakey(pktin, &hostkey, &s->keystr2)) {
2975         bombout(("Failed to read SSH-1 public keys from public key packet"));
2976         crStop(0);
2977     }
2978
2979     /*
2980      * Log the host key fingerprint.
2981      */
2982     {
2983         char logmsg[80];
2984         logevent("Host key fingerprint is:");
2985         strcpy(logmsg, "      ");
2986         hostkey.comment = NULL;
2987         rsa_fingerprint(logmsg + strlen(logmsg),
2988                         sizeof(logmsg) - strlen(logmsg), &hostkey);
2989         logevent(logmsg);
2990     }
2991
2992     ssh->v1_remote_protoflags = ssh_pkt_getuint32(pktin);
2993     s->supported_ciphers_mask = ssh_pkt_getuint32(pktin);
2994     s->supported_auths_mask = ssh_pkt_getuint32(pktin);
2995
2996     ssh->v1_local_protoflags =
2997         ssh->v1_remote_protoflags & SSH1_PROTOFLAGS_SUPPORTED;
2998     ssh->v1_local_protoflags |= SSH1_PROTOFLAG_SCREEN_NUMBER;
2999
3000     MD5Init(&md5c);
3001     MD5Update(&md5c, s->keystr2, hostkey.bytes);
3002     MD5Update(&md5c, s->keystr1, servkey.bytes);
3003     MD5Update(&md5c, cookie, 8);
3004     MD5Final(s->session_id, &md5c);
3005
3006     for (i = 0; i < 32; i++)
3007         ssh->session_key[i] = random_byte();
3008
3009     /*
3010      * Verify that the `bits' and `bytes' parameters match.
3011      */
3012     if (hostkey.bits > hostkey.bytes * 8 ||
3013         servkey.bits > servkey.bytes * 8) {
3014         bombout(("SSH-1 public keys were badly formatted"));
3015         crStop(0);
3016     }
3017
3018     s->len = (hostkey.bytes > servkey.bytes ? hostkey.bytes : servkey.bytes);
3019
3020     s->rsabuf = snewn(s->len, unsigned char);
3021
3022     /*
3023      * Verify the host key.
3024      */
3025     {
3026         /*
3027          * First format the key into a string.
3028          */
3029         int len = rsastr_len(&hostkey);
3030         char fingerprint[100];
3031         char *keystr = snewn(len, char);
3032         rsastr_fmt(keystr, &hostkey);
3033         rsa_fingerprint(fingerprint, sizeof(fingerprint), &hostkey);
3034
3035         ssh_set_frozen(ssh, 1);
3036         s->dlgret = verify_ssh_host_key(ssh->frontend,
3037                                         ssh->savedhost, ssh->savedport,
3038                                         "rsa", keystr, fingerprint,
3039                                         ssh_dialog_callback, ssh);
3040         sfree(keystr);
3041         if (s->dlgret < 0) {
3042             do {
3043                 crReturn(0);
3044                 if (pktin) {
3045                     bombout(("Unexpected data from server while waiting"
3046                              " for user host key response"));
3047                     crStop(0);
3048                 }
3049             } while (pktin || inlen > 0);
3050             s->dlgret = ssh->user_response;
3051         }
3052         ssh_set_frozen(ssh, 0);
3053
3054         if (s->dlgret == 0) {
3055             ssh_disconnect(ssh, "User aborted at host key verification",
3056                            NULL, 0, TRUE);
3057             crStop(0);
3058         }
3059     }
3060
3061     for (i = 0; i < 32; i++) {
3062         s->rsabuf[i] = ssh->session_key[i];
3063         if (i < 16)
3064             s->rsabuf[i] ^= s->session_id[i];
3065     }
3066
3067     if (hostkey.bytes > servkey.bytes) {
3068         ret = rsaencrypt(s->rsabuf, 32, &servkey);
3069         if (ret)
3070             ret = rsaencrypt(s->rsabuf, servkey.bytes, &hostkey);
3071     } else {
3072         ret = rsaencrypt(s->rsabuf, 32, &hostkey);
3073         if (ret)
3074             ret = rsaencrypt(s->rsabuf, hostkey.bytes, &servkey);
3075     }
3076     if (!ret) {
3077         bombout(("SSH-1 public key encryptions failed due to bad formatting"));
3078         crStop(0);
3079     }
3080
3081     logevent("Encrypted session key");
3082
3083     {
3084         int cipher_chosen = 0, warn = 0;
3085         char *cipher_string = NULL;
3086         int i;
3087         for (i = 0; !cipher_chosen && i < CIPHER_MAX; i++) {
3088             int next_cipher = ssh->cfg.ssh_cipherlist[i];
3089             if (next_cipher == CIPHER_WARN) {
3090                 /* If/when we choose a cipher, warn about it */
3091                 warn = 1;
3092             } else if (next_cipher == CIPHER_AES) {
3093                 /* XXX Probably don't need to mention this. */
3094                 logevent("AES not supported in SSH-1, skipping");
3095             } else {
3096                 switch (next_cipher) {
3097                   case CIPHER_3DES:     s->cipher_type = SSH_CIPHER_3DES;
3098                                         cipher_string = "3DES"; break;
3099                   case CIPHER_BLOWFISH: s->cipher_type = SSH_CIPHER_BLOWFISH;
3100                                         cipher_string = "Blowfish"; break;
3101                   case CIPHER_DES:      s->cipher_type = SSH_CIPHER_DES;
3102                                         cipher_string = "single-DES"; break;
3103                 }
3104                 if (s->supported_ciphers_mask & (1 << s->cipher_type))
3105                     cipher_chosen = 1;
3106             }
3107         }
3108         if (!cipher_chosen) {
3109             if ((s->supported_ciphers_mask & (1 << SSH_CIPHER_3DES)) == 0)
3110                 bombout(("Server violates SSH-1 protocol by not "
3111                          "supporting 3DES encryption"));
3112             else
3113                 /* shouldn't happen */
3114                 bombout(("No supported ciphers found"));
3115             crStop(0);
3116         }
3117
3118         /* Warn about chosen cipher if necessary. */
3119         if (warn) {
3120             ssh_set_frozen(ssh, 1);
3121             s->dlgret = askalg(ssh->frontend, "cipher", cipher_string,
3122                                ssh_dialog_callback, ssh);
3123             if (s->dlgret < 0) {
3124                 do {
3125                     crReturn(0);
3126                     if (pktin) {
3127                         bombout(("Unexpected data from server while waiting"
3128                                  " for user response"));
3129                         crStop(0);
3130                     }
3131                 } while (pktin || inlen > 0);
3132                 s->dlgret = ssh->user_response;
3133             }
3134             ssh_set_frozen(ssh, 0);
3135             if (s->dlgret == 0) {
3136                 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
3137                                0, TRUE);
3138                 crStop(0);
3139             }
3140         }
3141     }
3142
3143     switch (s->cipher_type) {
3144       case SSH_CIPHER_3DES:
3145         logevent("Using 3DES encryption");
3146         break;
3147       case SSH_CIPHER_DES:
3148         logevent("Using single-DES encryption");
3149         break;
3150       case SSH_CIPHER_BLOWFISH:
3151         logevent("Using Blowfish encryption");
3152         break;
3153     }
3154
3155     send_packet(ssh, SSH1_CMSG_SESSION_KEY,
3156                 PKT_CHAR, s->cipher_type,
3157                 PKT_DATA, cookie, 8,
3158                 PKT_CHAR, (s->len * 8) >> 8, PKT_CHAR, (s->len * 8) & 0xFF,
3159                 PKT_DATA, s->rsabuf, s->len,
3160                 PKT_INT, ssh->v1_local_protoflags, PKT_END);
3161
3162     logevent("Trying to enable encryption...");
3163
3164     sfree(s->rsabuf);
3165
3166     ssh->cipher = (s->cipher_type == SSH_CIPHER_BLOWFISH ? &ssh_blowfish_ssh1 :
3167                    s->cipher_type == SSH_CIPHER_DES ? &ssh_des :
3168                    &ssh_3des);
3169     ssh->v1_cipher_ctx = ssh->cipher->make_context();
3170     ssh->cipher->sesskey(ssh->v1_cipher_ctx, ssh->session_key);
3171     logeventf(ssh, "Initialised %s encryption", ssh->cipher->text_name);
3172
3173     ssh->crcda_ctx = crcda_make_context();
3174     logevent("Installing CRC compensation attack detector");
3175
3176     if (servkey.modulus) {
3177         sfree(servkey.modulus);
3178         servkey.modulus = NULL;
3179     }
3180     if (servkey.exponent) {
3181         sfree(servkey.exponent);
3182         servkey.exponent = NULL;
3183     }
3184     if (hostkey.modulus) {
3185         sfree(hostkey.modulus);
3186         hostkey.modulus = NULL;
3187     }
3188     if (hostkey.exponent) {
3189         sfree(hostkey.exponent);
3190         hostkey.exponent = NULL;
3191     }
3192     crWaitUntil(pktin);
3193
3194     if (pktin->type != SSH1_SMSG_SUCCESS) {
3195         bombout(("Encryption not successfully enabled"));
3196         crStop(0);
3197     }
3198
3199     logevent("Successfully started encryption");
3200
3201     fflush(stdout);
3202     {
3203         if (!*ssh->cfg.username) {
3204             if (ssh_get_line && !ssh_getline_pw_only) {
3205                 if (!ssh_get_line("login as: ",
3206                                   s->username, sizeof(s->username), FALSE)) {
3207                     /*
3208                      * get_line failed to get a username.
3209                      * Terminate.
3210                      */
3211                     ssh_disconnect(ssh, "No username provided", NULL, 0, TRUE);
3212                     crStop(1);
3213                 }
3214             } else {
3215                 int ret;               /* need not be kept over crReturn */
3216                 c_write_str(ssh, "login as: ");
3217                 ssh->send_ok = 1;
3218
3219                 setup_userpass_input(ssh, s->username, sizeof(s->username), 1);
3220                 do {
3221                     crWaitUntil(!pktin);
3222                     ret = process_userpass_input(ssh, in, inlen);
3223                 } while (ret == 0);
3224                 if (ret < 0)
3225                     cleanup_exit(0);
3226                 c_write_str(ssh, "\r\n");
3227             }
3228         } else {
3229             strncpy(s->username, ssh->cfg.username, sizeof(s->username));
3230             s->username[sizeof(s->username)-1] = '\0';
3231         }
3232
3233         send_packet(ssh, SSH1_CMSG_USER, PKT_STR, s->username, PKT_END);
3234         {
3235             char userlog[22 + sizeof(s->username)];
3236             sprintf(userlog, "Sent username \"%s\"", s->username);
3237             logevent(userlog);
3238             if (flags & FLAG_INTERACTIVE &&
3239                 (!((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)))) {
3240                 strcat(userlog, "\r\n");
3241                 c_write_str(ssh, userlog);
3242             }
3243         }
3244     }
3245
3246     crWaitUntil(pktin);
3247
3248     if ((ssh->remote_bugs & BUG_CHOKES_ON_RSA)) {
3249         /* We must not attempt PK auth. Pretend we've already tried it. */
3250         s->tried_publickey = s->tried_agent = 1;
3251     } else {
3252         s->tried_publickey = s->tried_agent = 0;
3253     }
3254     s->tis_auth_refused = s->ccard_auth_refused = 0;
3255     /* Load the public half of ssh->cfg.keyfile so we notice if it's in Pageant */
3256     if (!filename_is_null(ssh->cfg.keyfile)) {
3257         if (!rsakey_pubblob(&ssh->cfg.keyfile,
3258                             &s->publickey_blob, &s->publickey_bloblen, NULL))
3259             s->publickey_blob = NULL;
3260     } else
3261         s->publickey_blob = NULL;
3262
3263     while (pktin->type == SSH1_SMSG_FAILURE) {
3264         s->pwpkt_type = SSH1_CMSG_AUTH_PASSWORD;
3265
3266         if (agent_exists() && !s->tried_agent) {
3267             /*
3268              * Attempt RSA authentication using Pageant.
3269              */
3270             void *r;
3271
3272             s->authed = FALSE;
3273             s->tried_agent = 1;
3274             logevent("Pageant is running. Requesting keys.");
3275
3276             /* Request the keys held by the agent. */
3277             PUT_32BIT(s->request, 1);
3278             s->request[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES;
3279             if (!agent_query(s->request, 5, &r, &s->responselen,
3280                              ssh_agent_callback, ssh)) {
3281                 do {
3282                     crReturn(0);
3283                     if (pktin) {
3284                         bombout(("Unexpected data from server while waiting"
3285                                  " for agent response"));
3286                         crStop(0);
3287                     }
3288                 } while (pktin || inlen > 0);
3289                 r = ssh->agent_response;
3290                 s->responselen = ssh->agent_response_len;
3291             }
3292             s->response = (unsigned char *) r;
3293             if (s->response && s->responselen >= 5 &&
3294                 s->response[4] == SSH1_AGENT_RSA_IDENTITIES_ANSWER) {
3295                 s->p = s->response + 5;
3296                 s->nkeys = GET_32BIT(s->p);
3297                 s->p += 4;
3298                 logeventf(ssh, "Pageant has %d SSH-1 keys", s->nkeys);
3299                 for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) {
3300                     logeventf(ssh, "Trying Pageant key #%d", s->keyi);
3301                     if (s->publickey_blob &&
3302                         !memcmp(s->p, s->publickey_blob,
3303                                 s->publickey_bloblen)) {
3304                         logevent("This key matches configured key file");
3305                         s->tried_publickey = 1;
3306                     }
3307                     s->p += 4;
3308                     {
3309                         int n, ok = FALSE;
3310                         do {           /* do while (0) to make breaking easy */
3311                             n = ssh1_read_bignum
3312                                 (s->p, s->responselen-(s->p-s->response),
3313                                  &s->key.exponent);
3314                             if (n < 0)
3315                                 break;
3316                             s->p += n;
3317                             n = ssh1_read_bignum
3318                                 (s->p, s->responselen-(s->p-s->response),
3319                                  &s->key.modulus);
3320                             if (n < 0)
3321                             break;
3322                             s->p += n;
3323                             if (s->responselen - (s->p-s->response) < 4)
3324                                 break;
3325                             s->commentlen = GET_32BIT(s->p);
3326                             s->p += 4;
3327                             if (s->responselen - (s->p-s->response) <
3328                                 s->commentlen)
3329                                 break;
3330                             s->commentp = (char *)s->p;
3331                             s->p += s->commentlen;
3332                             ok = TRUE;
3333                         } while (0);
3334                         if (!ok) {
3335                             logevent("Pageant key list packet was truncated");
3336                             break;
3337                         }
3338                     }
3339                     send_packet(ssh, SSH1_CMSG_AUTH_RSA,
3340                                 PKT_BIGNUM, s->key.modulus, PKT_END);
3341                     crWaitUntil(pktin);
3342                     if (pktin->type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
3343                         logevent("Key refused");
3344                         continue;
3345                     }
3346                     logevent("Received RSA challenge");
3347                     if ((s->challenge = ssh1_pkt_getmp(pktin)) == NULL) {
3348                         bombout(("Server's RSA challenge was badly formatted"));
3349                         crStop(0);
3350                     }
3351
3352                     {
3353                         char *agentreq, *q, *ret;
3354                         void *vret;
3355                         int len, retlen;
3356                         len = 1 + 4;   /* message type, bit count */
3357                         len += ssh1_bignum_length(s->key.exponent);
3358                         len += ssh1_bignum_length(s->key.modulus);
3359                         len += ssh1_bignum_length(s->challenge);
3360                         len += 16;     /* session id */
3361                         len += 4;      /* response format */
3362                         agentreq = snewn(4 + len, char);
3363                         PUT_32BIT(agentreq, len);
3364                         q = agentreq + 4;
3365                         *q++ = SSH1_AGENTC_RSA_CHALLENGE;
3366                         PUT_32BIT(q, bignum_bitcount(s->key.modulus));
3367                         q += 4;
3368                         q += ssh1_write_bignum(q, s->key.exponent);
3369                         q += ssh1_write_bignum(q, s->key.modulus);
3370                         q += ssh1_write_bignum(q, s->challenge);
3371                         memcpy(q, s->session_id, 16);
3372                         q += 16;
3373                         PUT_32BIT(q, 1);        /* response format */
3374                         if (!agent_query(agentreq, len + 4, &vret, &retlen,
3375                                          ssh_agent_callback, ssh)) {
3376                             sfree(agentreq);
3377                             do {
3378                                 crReturn(0);
3379                                 if (pktin) {
3380                                     bombout(("Unexpected data from server"
3381                                              " while waiting for agent"
3382                                              " response"));
3383                                     crStop(0);
3384                                 }
3385                             } while (pktin || inlen > 0);
3386                             vret = ssh->agent_response;
3387                             retlen = ssh->agent_response_len;
3388                         } else
3389                             sfree(agentreq);
3390                         ret = vret;
3391                         if (ret) {
3392                             if (ret[4] == SSH1_AGENT_RSA_RESPONSE) {
3393                                 logevent("Sending Pageant's response");
3394                                 send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
3395                                             PKT_DATA, ret + 5, 16,
3396                                             PKT_END);
3397                                 sfree(ret);
3398                                 crWaitUntil(pktin);
3399                                 if (pktin->type == SSH1_SMSG_SUCCESS) {
3400                                     logevent
3401                                         ("Pageant's response accepted");
3402                                     if (flags & FLAG_VERBOSE) {
3403                                         c_write_str(ssh, "Authenticated using"
3404                                                     " RSA key \"");
3405                                         c_write(ssh, s->commentp,
3406                                                 s->commentlen);
3407                                         c_write_str(ssh, "\" from agent\r\n");
3408                                     }
3409                                     s->authed = TRUE;
3410                                 } else
3411                                     logevent
3412                                         ("Pageant's response not accepted");
3413                             } else {
3414                                 logevent
3415                                     ("Pageant failed to answer challenge");
3416                                 sfree(ret);
3417                             }
3418                         } else {
3419                             logevent("No reply received from Pageant");
3420                         }
3421                     }
3422                     freebn(s->key.exponent);
3423                     freebn(s->key.modulus);
3424                     freebn(s->challenge);
3425                     if (s->authed)
3426                         break;
3427                 }
3428                 sfree(s->response);
3429             }
3430             if (s->authed)
3431                 break;
3432         }
3433         if (!filename_is_null(ssh->cfg.keyfile) && !s->tried_publickey)
3434             s->pwpkt_type = SSH1_CMSG_AUTH_RSA;
3435
3436         if (ssh->cfg.try_tis_auth &&
3437             (s->supported_auths_mask & (1 << SSH1_AUTH_TIS)) &&
3438             !s->tis_auth_refused) {
3439             s->pwpkt_type = SSH1_CMSG_AUTH_TIS_RESPONSE;
3440             logevent("Requested TIS authentication");
3441             send_packet(ssh, SSH1_CMSG_AUTH_TIS, PKT_END);
3442             crWaitUntil(pktin);
3443             if (pktin->type != SSH1_SMSG_AUTH_TIS_CHALLENGE) {
3444                 logevent("TIS authentication declined");
3445                 if (flags & FLAG_INTERACTIVE)
3446                     c_write_str(ssh, "TIS authentication refused.\r\n");
3447                 s->tis_auth_refused = 1;
3448                 continue;
3449             } else {
3450                 char *challenge;
3451                 int challengelen;
3452
3453                 ssh_pkt_getstring(pktin, &challenge, &challengelen);
3454                 if (!challenge) {
3455                     bombout(("TIS challenge packet was badly formed"));
3456                     crStop(0);
3457                 }
3458                 c_write_str(ssh, "Using TIS authentication.\r\n");
3459                 logevent("Received TIS challenge");
3460                 if (challengelen > sizeof(s->prompt) - 1)
3461                     challengelen = sizeof(s->prompt) - 1;/* prevent overrun */
3462                 memcpy(s->prompt, challenge, challengelen);
3463                 /* Prompt heuristic comes from OpenSSH */
3464                 strncpy(s->prompt + challengelen,
3465                         memchr(s->prompt, '\n', challengelen) ?
3466                         "": "\r\nResponse: ",
3467                         (sizeof s->prompt) - challengelen);
3468                 s->prompt[(sizeof s->prompt) - 1] = '\0';
3469             }
3470         }
3471         if (ssh->cfg.try_tis_auth &&
3472             (s->supported_auths_mask & (1 << SSH1_AUTH_CCARD)) &&
3473             !s->ccard_auth_refused) {
3474             s->pwpkt_type = SSH1_CMSG_AUTH_CCARD_RESPONSE;
3475             logevent("Requested CryptoCard authentication");
3476             send_packet(ssh, SSH1_CMSG_AUTH_CCARD, PKT_END);
3477             crWaitUntil(pktin);
3478             if (pktin->type != SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
3479                 logevent("CryptoCard authentication declined");
3480                 c_write_str(ssh, "CryptoCard authentication refused.\r\n");
3481                 s->ccard_auth_refused = 1;
3482                 continue;
3483             } else {
3484                 char *challenge;
3485                 int challengelen;
3486
3487                 ssh_pkt_getstring(pktin, &challenge, &challengelen);
3488                 if (!challenge) {
3489                     bombout(("CryptoCard challenge packet was badly formed"));
3490                     crStop(0);
3491                 }
3492                 c_write_str(ssh, "Using CryptoCard authentication.\r\n");
3493                 logevent("Received CryptoCard challenge");
3494                 if (challengelen > sizeof(s->prompt) - 1)
3495                     challengelen = sizeof(s->prompt) - 1;/* prevent overrun */
3496                 memcpy(s->prompt, challenge, challengelen);
3497                 strncpy(s->prompt + challengelen,
3498                         memchr(s->prompt, '\n', challengelen) ?
3499                         "" : "\r\nResponse: ",
3500                         sizeof(s->prompt) - challengelen);
3501                 s->prompt[sizeof(s->prompt) - 1] = '\0';
3502             }
3503         }
3504         if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
3505             sprintf(s->prompt, "%.90s@%.90s's password: ",
3506                     s->username, ssh->savedhost);
3507         }
3508         if (s->pwpkt_type == SSH1_CMSG_AUTH_RSA) {
3509             char *comment = NULL;
3510             int type;
3511             if (flags & FLAG_VERBOSE)
3512                 c_write_str(ssh, "Trying public key authentication.\r\n");
3513             logeventf(ssh, "Trying public key \"%s\"",
3514                       filename_to_str(&ssh->cfg.keyfile));
3515             type = key_type(&ssh->cfg.keyfile);
3516             if (type != SSH_KEYTYPE_SSH1) {
3517                 char *msg = dupprintf("Key is of wrong type (%s)",
3518                                       key_type_to_str(type));
3519                 logevent(msg);
3520                 c_write_str(ssh, msg);
3521                 c_write_str(ssh, "\r\n");
3522                 sfree(msg);
3523                 s->tried_publickey = 1;
3524                 continue;
3525             }
3526             if (!rsakey_encrypted(&ssh->cfg.keyfile, &comment)) {
3527                 if (flags & FLAG_VERBOSE)
3528                     c_write_str(ssh, "No passphrase required.\r\n");
3529                 goto tryauth;
3530             }
3531             sprintf(s->prompt, "Passphrase for key \"%.100s\": ", comment);
3532             sfree(comment);
3533         }
3534
3535         /*
3536          * Show password prompt, having first obtained it via a TIS
3537          * or CryptoCard exchange if we're doing TIS or CryptoCard
3538          * authentication.
3539          */
3540         if (ssh_get_line) {
3541             if (!ssh_get_line(s->prompt, s->password,
3542                               sizeof(s->password), TRUE)) {
3543                 /*
3544                  * get_line failed to get a password (for example
3545                  * because one was supplied on the command line
3546                  * which has already failed to work). Terminate.
3547                  */
3548                 ssh_disconnect(ssh, NULL, "Unable to authenticate", 0, FALSE);
3549                 crStop(1);
3550             }
3551         } else {
3552             /* Prompt may have come from server. We've munged it a bit, so
3553              * we know it to be zero-terminated at least once. */
3554             int ret;                   /* need not be saved over crReturn */
3555             c_write_untrusted(ssh, s->prompt, strlen(s->prompt));
3556             s->pos = 0;
3557
3558             setup_userpass_input(ssh, s->password, sizeof(s->password), 0);
3559             do {
3560                 crWaitUntil(!pktin);
3561                 ret = process_userpass_input(ssh, in, inlen);
3562             } while (ret == 0);
3563             if (ret < 0)
3564                 cleanup_exit(0);
3565             c_write_str(ssh, "\r\n");
3566         }
3567
3568       tryauth:
3569         if (s->pwpkt_type == SSH1_CMSG_AUTH_RSA) {
3570             /*
3571              * Try public key authentication with the specified
3572              * key file.
3573              */
3574             s->tried_publickey = 1;
3575
3576             {
3577                 const char *error = NULL;
3578                 int ret = loadrsakey(&ssh->cfg.keyfile, &s->key, s->password,
3579                                      &error);
3580                 if (ret == 0) {
3581                     c_write_str(ssh, "Couldn't load private key from ");
3582                     c_write_str(ssh, filename_to_str(&ssh->cfg.keyfile));
3583                     c_write_str(ssh, " (");
3584                     c_write_str(ssh, error);
3585                     c_write_str(ssh, ").\r\n");
3586                     continue;          /* go and try password */
3587                 }
3588                 if (ret == -1) {
3589                     c_write_str(ssh, "Wrong passphrase.\r\n");
3590                     s->tried_publickey = 0;
3591                     continue;          /* try again */
3592                 }
3593             }
3594
3595             /*
3596              * Send a public key attempt.
3597              */
3598             send_packet(ssh, SSH1_CMSG_AUTH_RSA,
3599                         PKT_BIGNUM, s->key.modulus, PKT_END);
3600
3601             crWaitUntil(pktin);
3602             if (pktin->type == SSH1_SMSG_FAILURE) {
3603                 c_write_str(ssh, "Server refused our public key.\r\n");
3604                 continue;              /* go and try password */
3605             }
3606             if (pktin->type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
3607                 bombout(("Bizarre response to offer of public key"));
3608                 crStop(0);
3609             }
3610
3611             {
3612                 int i;
3613                 unsigned char buffer[32];
3614                 Bignum challenge, response;
3615
3616                 if ((challenge = ssh1_pkt_getmp(pktin)) == NULL) {
3617                     bombout(("Server's RSA challenge was badly formatted"));
3618                     crStop(0);
3619                 }
3620                 response = rsadecrypt(challenge, &s->key);
3621                 freebn(s->key.private_exponent);/* burn the evidence */
3622
3623                 for (i = 0; i < 32; i++) {
3624                     buffer[i] = bignum_byte(response, 31 - i);
3625                 }
3626
3627                 MD5Init(&md5c);
3628                 MD5Update(&md5c, buffer, 32);
3629                 MD5Update(&md5c, s->session_id, 16);
3630                 MD5Final(buffer, &md5c);
3631
3632                 send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
3633                             PKT_DATA, buffer, 16, PKT_END);
3634
3635                 freebn(challenge);
3636                 freebn(response);
3637             }
3638
3639             crWaitUntil(pktin);
3640             if (pktin->type == SSH1_SMSG_FAILURE) {
3641                 if (flags & FLAG_VERBOSE)
3642                     c_write_str(ssh, "Failed to authenticate with"
3643                                 " our public key.\r\n");
3644                 continue;              /* go and try password */
3645             } else if (pktin->type != SSH1_SMSG_SUCCESS) {
3646                 bombout(("Bizarre response to RSA authentication response"));
3647                 crStop(0);
3648             }
3649
3650             break;                     /* we're through! */
3651         } else {
3652             if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
3653                 /*
3654                  * Defence against traffic analysis: we send a
3655                  * whole bunch of packets containing strings of
3656                  * different lengths. One of these strings is the
3657                  * password, in a SSH1_CMSG_AUTH_PASSWORD packet.
3658                  * The others are all random data in
3659                  * SSH1_MSG_IGNORE packets. This way a passive
3660                  * listener can't tell which is the password, and
3661                  * hence can't deduce the password length.
3662                  *
3663                  * Anybody with a password length greater than 16
3664                  * bytes is going to have enough entropy in their
3665                  * password that a listener won't find it _that_
3666                  * much help to know how long it is. So what we'll
3667                  * do is:
3668                  *
3669                  *  - if password length < 16, we send 15 packets
3670                  *    containing string lengths 1 through 15
3671                  *
3672                  *  - otherwise, we let N be the nearest multiple
3673                  *    of 8 below the password length, and send 8
3674                  *    packets containing string lengths N through
3675                  *    N+7. This won't obscure the order of
3676                  *    magnitude of the password length, but it will
3677                  *    introduce a bit of extra uncertainty.
3678                  *
3679                  * A few servers (the old 1.2.18 through 1.2.22)
3680                  * can't deal with SSH1_MSG_IGNORE. For these
3681                  * servers, we need an alternative defence. We make
3682                  * use of the fact that the password is interpreted
3683                  * as a C string: so we can append a NUL, then some
3684                  * random data.
3685                  *
3686                  * One server (a Cisco one) can deal with neither
3687                  * SSH1_MSG_IGNORE _nor_ a padded password string.
3688                  * For this server we are left with no defences
3689                  * against password length sniffing.
3690                  */
3691                 if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE)) {
3692                     /*
3693                      * The server can deal with SSH1_MSG_IGNORE, so
3694                      * we can use the primary defence.
3695                      */
3696                     int bottom, top, pwlen, i;
3697                     char *randomstr;
3698
3699                     pwlen = strlen(s->password);
3700                     if (pwlen < 16) {
3701                         bottom = 0;    /* zero length passwords are OK! :-) */
3702                         top = 15;
3703                     } else {
3704                         bottom = pwlen & ~7;
3705                         top = bottom + 7;
3706                     }
3707
3708                     assert(pwlen >= bottom && pwlen <= top);
3709
3710                     randomstr = snewn(top + 1, char);
3711
3712                     for (i = bottom; i <= top; i++) {
3713                         if (i == pwlen) {
3714                             defer_packet(ssh, s->pwpkt_type,
3715                                          PKTT_PASSWORD, PKT_STR, s->password,
3716                                          PKTT_OTHER, PKT_END);
3717                         } else {
3718                             for (j = 0; j < i; j++) {
3719                                 do {
3720                                     randomstr[j] = random_byte();
3721                                 } while (randomstr[j] == '\0');
3722                             }
3723                             randomstr[i] = '\0';
3724                             defer_packet(ssh, SSH1_MSG_IGNORE,
3725                                          PKT_STR, randomstr, PKT_END);
3726                         }
3727                     }
3728                     logevent("Sending password with camouflage packets");
3729                     ssh_pkt_defersend(ssh);
3730                     sfree(randomstr);
3731                 }
3732                 else if (!(ssh->remote_bugs & BUG_NEEDS_SSH1_PLAIN_PASSWORD)) {
3733                     /*
3734                      * The server can't deal with SSH1_MSG_IGNORE
3735                      * but can deal with padded passwords, so we
3736                      * can use the secondary defence.
3737                      */
3738                     char string[64];
3739                     char *ss;
3740                     int len;
3741
3742                     len = strlen(s->password);
3743                     if (len < sizeof(string)) {
3744                         ss = string;
3745                         strcpy(string, s->password);
3746                         len++;         /* cover the zero byte */
3747                         while (len < sizeof(string)) {
3748                             string[len++] = (char) random_byte();
3749                         }
3750                     } else {
3751                         ss = s->password;
3752                     }
3753                     logevent("Sending length-padded password");
3754                     send_packet(ssh, s->pwpkt_type, PKTT_PASSWORD,
3755                                 PKT_INT, len, PKT_DATA, ss, len,
3756                                 PKTT_OTHER, PKT_END);
3757                 } else {
3758                     /*
3759                      * The server has _both_
3760                      * BUG_CHOKES_ON_SSH1_IGNORE and
3761                      * BUG_NEEDS_SSH1_PLAIN_PASSWORD. There is
3762                      * therefore nothing we can do.
3763                      */
3764                     int len;
3765                     len = strlen(s->password);
3766                     logevent("Sending unpadded password");
3767                     send_packet(ssh, s->pwpkt_type,
3768                                 PKTT_PASSWORD, PKT_INT, len,
3769                                 PKT_DATA, s->password, len,
3770                                 PKTT_OTHER, PKT_END);
3771                 }
3772             } else {
3773                 send_packet(ssh, s->pwpkt_type, PKTT_PASSWORD,
3774                             PKT_STR, s->password, PKTT_OTHER, PKT_END);
3775             }
3776         }
3777         logevent("Sent password");
3778         memset(s->password, 0, strlen(s->password));
3779         crWaitUntil(pktin);
3780         if (pktin->type == SSH1_SMSG_FAILURE) {
3781             if (flags & FLAG_VERBOSE)
3782                 c_write_str(ssh, "Access denied\r\n");
3783             logevent("Authentication refused");
3784         } else if (pktin->type != SSH1_SMSG_SUCCESS) {
3785             bombout(("Strange packet received, type %d", pktin->type));
3786             crStop(0);
3787         }
3788     }
3789
3790     logevent("Authentication successful");
3791
3792     crFinish(1);
3793 }
3794
3795 void sshfwd_close(struct ssh_channel *c)
3796 {
3797     Ssh ssh = c->ssh;
3798
3799     if (ssh->state == SSH_STATE_CLOSED)
3800         return;
3801
3802     if (c && !c->closes) {
3803         /*
3804          * If halfopen is true, we have sent
3805          * CHANNEL_OPEN for this channel, but it hasn't even been
3806          * acknowledged by the server. So we must set a close flag
3807          * on it now, and then when the server acks the channel
3808          * open, we can close it then.
3809          */
3810         if (!c->halfopen) {
3811             if (ssh->version == 1) {
3812                 send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE, PKT_INT, c->remoteid,
3813                             PKT_END);
3814             } else {
3815                 struct Packet *pktout;
3816                 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE);
3817                 ssh2_pkt_adduint32(pktout, c->remoteid);
3818                 ssh2_pkt_send(ssh, pktout);
3819             }
3820         }
3821         c->closes = 1;                 /* sent MSG_CLOSE */
3822         if (c->type == CHAN_X11) {
3823             c->u.x11.s = NULL;
3824             logevent("Forwarded X11 connection terminated");
3825         } else if (c->type == CHAN_SOCKDATA ||
3826                    c->type == CHAN_SOCKDATA_DORMANT) {
3827             c->u.pfd.s = NULL;
3828             logevent("Forwarded port closed");
3829         }
3830     }
3831 }
3832
3833 int sshfwd_write(struct ssh_channel *c, char *buf, int len)
3834 {
3835     Ssh ssh = c->ssh;
3836
3837     if (ssh->state == SSH_STATE_CLOSED)
3838         return 0;
3839
3840     if (ssh->version == 1) {
3841         send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
3842                     PKT_INT, c->remoteid,
3843                     PKTT_DATA,
3844                     PKT_INT, len, PKT_DATA, buf, len,
3845                     PKTT_OTHER, PKT_END);
3846         /*
3847          * In SSH-1 we can return 0 here - implying that forwarded
3848          * connections are never individually throttled - because
3849          * the only circumstance that can cause throttling will be
3850          * the whole SSH connection backing up, in which case
3851          * _everything_ will be throttled as a whole.
3852          */
3853         return 0;
3854     } else {
3855         ssh2_add_channel_data(c, buf, len);
3856         return ssh2_try_send(c);
3857     }
3858 }
3859
3860 void sshfwd_unthrottle(struct ssh_channel *c, int bufsize)
3861 {
3862     Ssh ssh = c->ssh;
3863
3864     if (ssh->state == SSH_STATE_CLOSED)
3865         return;
3866
3867     if (ssh->version == 1) {
3868         if (c->v.v1.throttling && bufsize < SSH1_BUFFER_LIMIT) {
3869             c->v.v1.throttling = 0;
3870             ssh1_throttle(ssh, -1);
3871         }
3872     } else {
3873         ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
3874     }
3875 }
3876
3877 static void ssh_queueing_handler(Ssh ssh, struct Packet *pktin)
3878 {
3879     struct queued_handler *qh = ssh->qhead;
3880
3881     assert(qh != NULL);
3882
3883     assert(pktin->type == qh->msg1 || pktin->type == qh->msg2);
3884
3885     if (qh->msg1 > 0) {
3886         assert(ssh->packet_dispatch[qh->msg1] == ssh_queueing_handler);
3887         ssh->packet_dispatch[qh->msg1] = NULL;
3888     }
3889     if (qh->msg2 > 0) {
3890         assert(ssh->packet_dispatch[qh->msg2] == ssh_queueing_handler);
3891         ssh->packet_dispatch[qh->msg2] = NULL;
3892     }
3893
3894     if (qh->next) {
3895         ssh->qhead = qh->next;
3896
3897         if (ssh->qhead->msg1 > 0) {
3898             assert(ssh->packet_dispatch[ssh->qhead->msg1] == NULL);
3899             ssh->packet_dispatch[ssh->qhead->msg1] = ssh_queueing_handler;
3900         }
3901         if (ssh->qhead->msg2 > 0) {
3902             assert(ssh->packet_dispatch[ssh->qhead->msg2] == NULL);
3903             ssh->packet_dispatch[ssh->qhead->msg2] = ssh_queueing_handler;
3904         }
3905     } else {
3906         ssh->qhead = ssh->qtail = NULL;
3907         ssh->packet_dispatch[pktin->type] = NULL;
3908     }
3909
3910     qh->handler(ssh, pktin, qh->ctx);
3911
3912     sfree(qh);
3913 }
3914
3915 static void ssh_queue_handler(Ssh ssh, int msg1, int msg2,
3916                               chandler_fn_t handler, void *ctx)
3917 {
3918     struct queued_handler *qh;
3919
3920     qh = snew(struct queued_handler);
3921     qh->msg1 = msg1;
3922     qh->msg2 = msg2;
3923     qh->handler = handler;
3924     qh->ctx = ctx;
3925     qh->next = NULL;
3926
3927     if (ssh->qtail == NULL) {
3928         ssh->qhead = qh;
3929
3930         if (qh->msg1 > 0) {
3931             assert(ssh->packet_dispatch[qh->msg1] == NULL);
3932             ssh->packet_dispatch[qh->msg1] = ssh_queueing_handler;
3933         }
3934         if (qh->msg2 > 0) {
3935             assert(ssh->packet_dispatch[qh->msg2] == NULL);
3936             ssh->packet_dispatch[qh->msg2] = ssh_queueing_handler;
3937         }
3938     } else {
3939         ssh->qtail->next = qh;
3940     }
3941     ssh->qtail = qh;
3942 }
3943
3944 static void ssh_rportfwd_succfail(Ssh ssh, struct Packet *pktin, void *ctx)
3945 {
3946     struct ssh_rportfwd *rpf, *pf = (struct ssh_rportfwd *)ctx;
3947
3948     if (pktin->type == (ssh->version == 1 ? SSH1_SMSG_SUCCESS :
3949                         SSH2_MSG_REQUEST_SUCCESS)) {
3950         logeventf(ssh, "Remote port forwarding from %s enabled",
3951                   pf->sportdesc);
3952     } else {
3953         logeventf(ssh, "Remote port forwarding from %s refused",
3954                   pf->sportdesc);
3955
3956         rpf = del234(ssh->rportfwds, pf);
3957         assert(rpf == pf);
3958         free_rportfwd(pf);
3959     }
3960 }
3961
3962 static void ssh_setup_portfwd(Ssh ssh, const Config *cfg)
3963 {
3964     const char *portfwd_strptr = cfg->portfwd;
3965     struct ssh_portfwd *epf;
3966     int i;
3967
3968     if (!ssh->portfwds) {
3969         ssh->portfwds = newtree234(ssh_portcmp);
3970     } else {
3971         /*
3972          * Go through the existing port forwardings and tag them
3973          * with status==DESTROY. Any that we want to keep will be
3974          * re-enabled (status==KEEP) as we go through the
3975          * configuration and find out which bits are the same as
3976          * they were before.
3977          */
3978         struct ssh_portfwd *epf;
3979         int i;
3980         for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
3981             epf->status = DESTROY;
3982     }
3983
3984     while (*portfwd_strptr) {
3985         char address_family, type;
3986         int sport,dport,sserv,dserv;
3987         char sports[256], dports[256], saddr[256], host[256];
3988         int n;
3989
3990         address_family = 'A';
3991         type = 'L';
3992         if (*portfwd_strptr == 'A' ||
3993             *portfwd_strptr == '4' ||
3994             *portfwd_strptr == '6')
3995             address_family = *portfwd_strptr++;
3996         if (*portfwd_strptr == 'L' ||
3997             *portfwd_strptr == 'R' ||
3998             *portfwd_strptr == 'D')
3999             type = *portfwd_strptr++;
4000
4001         saddr[0] = '\0';
4002
4003         n = 0;
4004         while (*portfwd_strptr && *portfwd_strptr != '\t') {
4005             if (*portfwd_strptr == ':') {
4006                 /*
4007                  * We've seen a colon in the middle of the
4008                  * source port number. This means that
4009                  * everything we've seen until now is the
4010                  * source _address_, so we'll move it into
4011                  * saddr and start sports from the beginning
4012                  * again.
4013                  */
4014                 portfwd_strptr++;
4015                 sports[n] = '\0';
4016                 if (ssh->version == 1 && type == 'R') {
4017                     logeventf(ssh, "SSH-1 cannot handle remote source address "
4018                               "spec \"%s\"; ignoring", sports);
4019                 } else
4020                     strcpy(saddr, sports);
4021                 n = 0;
4022             }
4023             if (n < lenof(sports)-1) sports[n++] = *portfwd_strptr++;
4024         }
4025         sports[n] = 0;
4026         if (type != 'D') {
4027             if (*portfwd_strptr == '\t')
4028                 portfwd_strptr++;
4029             n = 0;
4030             while (*portfwd_strptr && *portfwd_strptr != ':') {
4031                 if (n < lenof(host)-1) host[n++] = *portfwd_strptr++;
4032             }
4033             host[n] = 0;
4034             if (*portfwd_strptr == ':')
4035                 portfwd_strptr++;
4036             n = 0;
4037             while (*portfwd_strptr) {
4038                 if (n < lenof(dports)-1) dports[n++] = *portfwd_strptr++;
4039             }
4040             dports[n] = 0;
4041             portfwd_strptr++;
4042             dport = atoi(dports);
4043             dserv = 0;
4044             if (dport == 0) {
4045                 dserv = 1;
4046                 dport = net_service_lookup(dports);
4047                 if (!dport) {
4048                     logeventf(ssh, "Service lookup failed for destination"
4049                               " port \"%s\"", dports);
4050                 }
4051             }
4052         } else {
4053             while (*portfwd_strptr) portfwd_strptr++;
4054             host[0] = 0;
4055             dports[0] = 0;
4056             dport = dserv = -1;
4057             portfwd_strptr++;          /* eat the NUL and move to next one */
4058         }
4059         sport = atoi(sports);
4060         sserv = 0;
4061         if (sport == 0) {
4062             sserv = 1;
4063             sport = net_service_lookup(sports);
4064             if (!sport) {
4065                 logeventf(ssh, "Service lookup failed for source"
4066                           " port \"%s\"", sports);
4067             }
4068         }
4069         if (sport && dport) {
4070             /* Set up a description of the source port. */
4071             struct ssh_portfwd *pfrec, *epfrec;
4072
4073             pfrec = snew(struct ssh_portfwd);
4074             pfrec->type = type;
4075             pfrec->saddr = *saddr ? dupstr(saddr) : NULL;
4076             pfrec->sserv = sserv ? dupstr(sports) : NULL;
4077             pfrec->sport = sport;
4078             pfrec->daddr = *host ? dupstr(host) : NULL;
4079             pfrec->dserv = dserv ? dupstr(dports) : NULL;
4080             pfrec->dport = dport;
4081             pfrec->local = NULL;
4082             pfrec->remote = NULL;
4083             pfrec->addressfamily = (address_family == '4' ? ADDRTYPE_IPV4 :
4084                                     address_family == '6' ? ADDRTYPE_IPV6 :
4085                                     ADDRTYPE_UNSPEC);
4086
4087             epfrec = add234(ssh->portfwds, pfrec);
4088             if (epfrec != pfrec) {
4089                 /*
4090                  * We already have a port forwarding with precisely
4091                  * these parameters. Hence, no need to do anything;
4092                  * simply tag the existing one as KEEP.
4093                  */
4094                 epfrec->status = KEEP;
4095                 free_portfwd(pfrec);
4096             } else {
4097                 pfrec->status = CREATE;
4098             }
4099         }
4100     }
4101
4102     /*
4103      * Now go through and destroy any port forwardings which were
4104      * not re-enabled.
4105      */
4106     for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
4107         if (epf->status == DESTROY) {
4108             char *message;
4109
4110             message = dupprintf("%s port forwarding from %s%s%d",
4111                                 epf->type == 'L' ? "local" :
4112                                 epf->type == 'R' ? "remote" : "dynamic",
4113                                 epf->saddr ? epf->saddr : "",
4114                                 epf->saddr ? ":" : "",
4115                                 epf->sport);
4116
4117             if (epf->type != 'D') {
4118                 char *msg2 = dupprintf("%s to %s:%d", message,
4119                                        epf->daddr, epf->dport);
4120                 sfree(message);
4121                 message = msg2;
4122             }
4123
4124             logeventf(ssh, "Cancelling %s", message);
4125             sfree(message);
4126
4127             if (epf->remote) {
4128                 struct ssh_rportfwd *rpf = epf->remote;
4129                 struct Packet *pktout;
4130
4131                 /*
4132                  * Cancel the port forwarding at the server
4133                  * end.
4134                  */
4135                 if (ssh->version == 1) {
4136                     /*
4137                      * We cannot cancel listening ports on the
4138                      * server side in SSH-1! There's no message
4139                      * to support it. Instead, we simply remove
4140                      * the rportfwd record from the local end
4141                      * so that any connections the server tries
4142                      * to make on it are rejected.
4143                      */
4144                 } else {
4145                     pktout = ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST);
4146                     ssh2_pkt_addstring(pktout, "cancel-tcpip-forward");
4147                     ssh2_pkt_addbool(pktout, 0);/* _don't_ want reply */
4148                     if (epf->saddr) {
4149                         ssh2_pkt_addstring(pktout, epf->saddr);
4150                     } else if (ssh->cfg.rport_acceptall) {
4151                         /* XXX: ssh->cfg.rport_acceptall may not represent
4152                          * what was used to open the original connection,
4153                          * since it's reconfigurable. */
4154                         ssh2_pkt_addstring(pktout, "0.0.0.0");
4155                     } else {
4156                         ssh2_pkt_addstring(pktout, "127.0.0.1");
4157                     }
4158                     ssh2_pkt_adduint32(pktout, epf->sport);
4159                     ssh2_pkt_send(ssh, pktout);
4160                 }
4161
4162                 del234(ssh->rportfwds, rpf);
4163                 free_rportfwd(rpf);
4164             } else if (epf->local) {
4165                 pfd_terminate(epf->local);
4166             }
4167
4168             delpos234(ssh->portfwds, i);
4169             free_portfwd(epf);
4170             i--;                       /* so we don't skip one in the list */
4171         }
4172
4173     /*
4174      * And finally, set up any new port forwardings (status==CREATE).
4175      */
4176     for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
4177         if (epf->status == CREATE) {
4178             char *sportdesc, *dportdesc;
4179             sportdesc = dupprintf("%s%s%s%s%d%s",
4180                                   epf->saddr ? epf->saddr : "",
4181                                   epf->saddr ? ":" : "",
4182                                   epf->sserv ? epf->sserv : "",
4183                                   epf->sserv ? "(" : "",
4184                                   epf->sport,
4185                                   epf->sserv ? ")" : "");
4186             if (epf->type == 'D') {
4187                 dportdesc = NULL;
4188             } else {
4189                 dportdesc = dupprintf("%s:%s%s%d%s",
4190                                       epf->daddr,
4191                                       epf->dserv ? epf->dserv : "",
4192                                       epf->dserv ? "(" : "",
4193                                       epf->dport,
4194                                       epf->dserv ? ")" : "");
4195             }
4196
4197             if (epf->type == 'L') {
4198                 const char *err = pfd_addforward(epf->daddr, epf->dport,
4199                                                  epf->saddr, epf->sport,
4200                                                  ssh, cfg,
4201                                                  &epf->local,
4202                                                  epf->addressfamily);
4203
4204                 logeventf(ssh, "Local %sport %s forwarding to %s%s%s",
4205                           epf->addressfamily == ADDRTYPE_IPV4 ? "IPv4 " :
4206                           epf->addressfamily == ADDRTYPE_IPV6 ? "IPv6 " : "",
4207                           sportdesc, dportdesc,
4208                           err ? " failed: " : "", err ? err : "");
4209             } else if (epf->type == 'D') {
4210                 const char *err = pfd_addforward(NULL, -1,
4211                                                  epf->saddr, epf->sport,
4212                                                  ssh, cfg,
4213                                                  &epf->local,
4214                                                  epf->addressfamily);
4215
4216                 logeventf(ssh, "Local %sport %s SOCKS dynamic forwarding%s%s",
4217                           epf->addressfamily == ADDRTYPE_IPV4 ? "IPv4 " :
4218                           epf->addressfamily == ADDRTYPE_IPV6 ? "IPv6 " : "",
4219                           sportdesc,
4220                           err ? " failed: " : "", err ? err : "");
4221             } else {
4222                 struct ssh_rportfwd *pf;
4223
4224                 /*
4225                  * Ensure the remote port forwardings tree exists.
4226                  */
4227                 if (!ssh->rportfwds) {
4228                     if (ssh->version == 1)
4229                         ssh->rportfwds = newtree234(ssh_rportcmp_ssh1);
4230                     else
4231                         ssh->rportfwds = newtree234(ssh_rportcmp_ssh2);
4232                 }
4233
4234                 pf = snew(struct ssh_rportfwd);
4235                 strncpy(pf->dhost, epf->daddr, lenof(pf->dhost)-1);
4236                 pf->dhost[lenof(pf->dhost)-1] = '\0';
4237                 pf->dport = epf->dport;
4238                 pf->sport = epf->sport;
4239                 if (add234(ssh->rportfwds, pf) != pf) {
4240                     logeventf(ssh, "Duplicate remote port forwarding to %s:%d",
4241                               epf->daddr, epf->dport);
4242                     sfree(pf);
4243                 } else {
4244                     logeventf(ssh, "Requesting remote port %s"
4245                               " forward to %s", sportdesc, dportdesc);
4246
4247                     pf->sportdesc = sportdesc;
4248                     sportdesc = NULL;
4249                     epf->remote = pf;
4250                     pf->pfrec = epf;
4251
4252                     if (ssh->version == 1) {
4253                         send_packet(ssh, SSH1_CMSG_PORT_FORWARD_REQUEST,
4254                                     PKT_INT, epf->sport,
4255                                     PKT_STR, epf->daddr,
4256                                     PKT_INT, epf->dport,
4257                                     PKT_END);
4258                         ssh_queue_handler(ssh, SSH1_SMSG_SUCCESS,
4259                                           SSH1_SMSG_FAILURE,
4260                                           ssh_rportfwd_succfail, pf);
4261                     } else {
4262                         struct Packet *pktout;
4263                         pktout = ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST);
4264                         ssh2_pkt_addstring(pktout, "tcpip-forward");
4265                         ssh2_pkt_addbool(pktout, 1);/* want reply */
4266                         if (epf->saddr) {
4267                             ssh2_pkt_addstring(pktout, epf->saddr);
4268                         } else if (cfg->rport_acceptall) {
4269                             ssh2_pkt_addstring(pktout, "0.0.0.0");
4270                         } else {
4271                             ssh2_pkt_addstring(pktout, "127.0.0.1");
4272                         }
4273                         ssh2_pkt_adduint32(pktout, epf->sport);
4274                         ssh2_pkt_send(ssh, pktout);
4275
4276                         ssh_queue_handler(ssh, SSH2_MSG_REQUEST_SUCCESS,
4277                                           SSH2_MSG_REQUEST_FAILURE,
4278                                           ssh_rportfwd_succfail, pf);
4279                     }
4280                 }
4281             }
4282             sfree(sportdesc);
4283             sfree(dportdesc);
4284         }
4285 }
4286
4287 static void ssh1_smsg_stdout_stderr_data(Ssh ssh, struct Packet *pktin)
4288 {
4289     char *string;
4290     int stringlen, bufsize;
4291
4292     ssh_pkt_getstring(pktin, &string, &stringlen);
4293     if (string == NULL) {
4294         bombout(("Incoming terminal data packet was badly formed"));
4295         return;
4296     }
4297
4298     bufsize = from_backend(ssh->frontend, pktin->type == SSH1_SMSG_STDERR_DATA,
4299                            string, stringlen);
4300     if (!ssh->v1_stdout_throttling && bufsize > SSH1_BUFFER_LIMIT) {
4301         ssh->v1_stdout_throttling = 1;
4302         ssh1_throttle(ssh, +1);
4303     }
4304 }
4305
4306 static void ssh1_smsg_x11_open(Ssh ssh, struct Packet *pktin)
4307 {
4308     /* Remote side is trying to open a channel to talk to our
4309      * X-Server. Give them back a local channel number. */
4310     struct ssh_channel *c;
4311     int remoteid = ssh_pkt_getuint32(pktin);
4312
4313     logevent("Received X11 connect request");
4314     /* Refuse if X11 forwarding is disabled. */
4315     if (!ssh->X11_fwd_enabled) {
4316         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4317                     PKT_INT, remoteid, PKT_END);
4318         logevent("Rejected X11 connect request");
4319     } else {
4320         c = snew(struct ssh_channel);
4321         c->ssh = ssh;
4322
4323         if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
4324                      ssh->x11auth, NULL, -1, &ssh->cfg) != NULL) {
4325             logevent("Opening X11 forward connection failed");
4326             sfree(c);
4327             send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4328                         PKT_INT, remoteid, PKT_END);
4329         } else {
4330             logevent
4331                 ("Opening X11 forward connection succeeded");
4332             c->remoteid = remoteid;
4333             c->halfopen = FALSE;
4334             c->localid = alloc_channel_id(ssh);
4335             c->closes = 0;
4336             c->v.v1.throttling = 0;
4337             c->type = CHAN_X11; /* identify channel type */
4338             add234(ssh->channels, c);
4339             send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
4340                         PKT_INT, c->remoteid, PKT_INT,
4341                         c->localid, PKT_END);
4342             logevent("Opened X11 forward channel");
4343         }
4344     }
4345 }
4346
4347 static void ssh1_smsg_agent_open(Ssh ssh, struct Packet *pktin)
4348 {
4349     /* Remote side is trying to open a channel to talk to our
4350      * agent. Give them back a local channel number. */
4351     struct ssh_channel *c;
4352     int remoteid = ssh_pkt_getuint32(pktin);
4353
4354     /* Refuse if agent forwarding is disabled. */
4355     if (!ssh->agentfwd_enabled) {
4356         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4357                     PKT_INT, remoteid, PKT_END);
4358     } else {
4359         c = snew(struct ssh_channel);
4360         c->ssh = ssh;
4361         c->remoteid = remoteid;
4362         c->halfopen = FALSE;
4363         c->localid = alloc_channel_id(ssh);
4364         c->closes = 0;
4365         c->v.v1.throttling = 0;
4366         c->type = CHAN_AGENT;   /* identify channel type */
4367         c->u.a.lensofar = 0;
4368         add234(ssh->channels, c);
4369         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
4370                     PKT_INT, c->remoteid, PKT_INT, c->localid,
4371                     PKT_END);
4372     }
4373 }
4374
4375 static void ssh1_msg_port_open(Ssh ssh, struct Packet *pktin)
4376 {
4377     /* Remote side is trying to open a channel to talk to a
4378      * forwarded port. Give them back a local channel number. */
4379     struct ssh_channel *c;
4380     struct ssh_rportfwd pf, *pfp;
4381     int remoteid;
4382     int hostsize, port;
4383     char *host;
4384     const char *e;
4385     c = snew(struct ssh_channel);
4386     c->ssh = ssh;
4387
4388     remoteid = ssh_pkt_getuint32(pktin);
4389     ssh_pkt_getstring(pktin, &host, &hostsize);
4390     port = ssh_pkt_getuint32(pktin);
4391
4392     if (hostsize >= lenof(pf.dhost))
4393         hostsize = lenof(pf.dhost)-1;
4394     memcpy(pf.dhost, host, hostsize);
4395     pf.dhost[hostsize] = '\0';
4396     pf.dport = port;
4397     pfp = find234(ssh->rportfwds, &pf, NULL);
4398
4399     if (pfp == NULL) {
4400         logeventf(ssh, "Rejected remote port open request for %s:%d",
4401                   pf.dhost, port);
4402         send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4403                     PKT_INT, remoteid, PKT_END);
4404     } else {
4405         logeventf(ssh, "Received remote port open request for %s:%d",
4406                   pf.dhost, port);
4407         e = pfd_newconnect(&c->u.pfd.s, pf.dhost, port,
4408                            c, &ssh->cfg, pfp->pfrec->addressfamily);
4409         if (e != NULL) {
4410             logeventf(ssh, "Port open failed: %s", e);
4411             sfree(c);
4412             send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4413                         PKT_INT, remoteid, PKT_END);
4414         } else {
4415             c->remoteid = remoteid;
4416             c->halfopen = FALSE;
4417             c->localid = alloc_channel_id(ssh);
4418             c->closes = 0;
4419             c->v.v1.throttling = 0;
4420             c->type = CHAN_SOCKDATA;    /* identify channel type */
4421             add234(ssh->channels, c);
4422             send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
4423                         PKT_INT, c->remoteid, PKT_INT,
4424                         c->localid, PKT_END);
4425             logevent("Forwarded port opened successfully");
4426         }
4427     }
4428 }
4429
4430 static void ssh1_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin)
4431 {
4432     unsigned int remoteid = ssh_pkt_getuint32(pktin);
4433     unsigned int localid = ssh_pkt_getuint32(pktin);
4434     struct ssh_channel *c;
4435
4436     c = find234(ssh->channels, &remoteid, ssh_channelfind);
4437     if (c && c->type == CHAN_SOCKDATA_DORMANT) {
4438         c->remoteid = localid;
4439         c->halfopen = FALSE;
4440         c->type = CHAN_SOCKDATA;
4441         c->v.v1.throttling = 0;
4442         pfd_confirm(c->u.pfd.s);
4443     }
4444
4445     if (c && c->closes) {
4446         /*
4447          * We have a pending close on this channel,
4448          * which we decided on before the server acked
4449          * the channel open. So now we know the
4450          * remoteid, we can close it again.
4451          */
4452         send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE,
4453                     PKT_INT, c->remoteid, PKT_END);
4454     }
4455 }
4456
4457 static void ssh1_msg_channel_open_failure(Ssh ssh, struct Packet *pktin)
4458 {
4459     unsigned int remoteid = ssh_pkt_getuint32(pktin);
4460     struct ssh_channel *c;
4461
4462     c = find234(ssh->channels, &remoteid, ssh_channelfind);
4463     if (c && c->type == CHAN_SOCKDATA_DORMANT) {
4464         logevent("Forwarded connection refused by server");
4465         pfd_close(c->u.pfd.s);
4466         del234(ssh->channels, c);
4467         sfree(c);
4468     }
4469 }
4470
4471 static void ssh1_msg_channel_close(Ssh ssh, struct Packet *pktin)
4472 {
4473     /* Remote side closes a channel. */
4474     unsigned i = ssh_pkt_getuint32(pktin);
4475     struct ssh_channel *c;
4476     c = find234(ssh->channels, &i, ssh_channelfind);
4477     if (c && !c->halfopen) {
4478         int closetype;
4479         closetype =
4480             (pktin->type == SSH1_MSG_CHANNEL_CLOSE ? 1 : 2);
4481
4482         if ((c->closes == 0) && (c->type == CHAN_X11)) {
4483             logevent("Forwarded X11 connection terminated");
4484             assert(c->u.x11.s != NULL);
4485             x11_close(c->u.x11.s);
4486             c->u.x11.s = NULL;
4487         }
4488         if ((c->closes == 0) && (c->type == CHAN_SOCKDATA)) {
4489             logevent("Forwarded port closed");
4490             assert(c->u.pfd.s != NULL);
4491             pfd_close(c->u.pfd.s);
4492             c->u.pfd.s = NULL;
4493         }
4494
4495         c->closes |= (closetype << 2);   /* seen this message */
4496         if (!(c->closes & closetype)) {
4497             send_packet(ssh, pktin->type, PKT_INT, c->remoteid,
4498                         PKT_END);
4499             c->closes |= closetype;      /* sent it too */
4500         }
4501
4502         if (c->closes == 15) {
4503             del234(ssh->channels, c);
4504             sfree(c);
4505         }
4506     } else {
4507         bombout(("Received CHANNEL_CLOSE%s for %s channel %d\n",
4508                  pktin->type == SSH1_MSG_CHANNEL_CLOSE ? "" :
4509                  "_CONFIRMATION", c ? "half-open" : "nonexistent",
4510                  i));
4511     }
4512 }
4513
4514 static void ssh1_msg_channel_data(Ssh ssh, struct Packet *pktin)
4515 {
4516     /* Data sent down one of our channels. */
4517     int i = ssh_pkt_getuint32(pktin);
4518     char *p;
4519     int len;
4520     struct ssh_channel *c;
4521
4522     ssh_pkt_getstring(pktin, &p, &len);
4523
4524     c = find234(ssh->channels, &i, ssh_channelfind);
4525     if (c) {
4526         int bufsize = 0;
4527         switch (c->type) {
4528           case CHAN_X11:
4529             bufsize = x11_send(c->u.x11.s, p, len);
4530             break;
4531           case CHAN_SOCKDATA:
4532             bufsize = pfd_send(c->u.pfd.s, p, len);
4533             break;
4534           case CHAN_AGENT:
4535             /* Data for an agent message. Buffer it. */
4536             while (len > 0) {
4537                 if (c->u.a.lensofar < 4) {
4538                     unsigned int l = min(4 - c->u.a.lensofar, len);
4539                     memcpy(c->u.a.msglen + c->u.a.lensofar, p,
4540                            l);
4541                     p += l;
4542                     len -= l;
4543                     c->u.a.lensofar += l;
4544                 }
4545                 if (c->u.a.lensofar == 4) {
4546                     c->u.a.totallen =
4547                         4 + GET_32BIT(c->u.a.msglen);
4548                     c->u.a.message = snewn(c->u.a.totallen,
4549                                            unsigned char);
4550                     memcpy(c->u.a.message, c->u.a.msglen, 4);
4551                 }
4552                 if (c->u.a.lensofar >= 4 && len > 0) {
4553                     unsigned int l =
4554                         min(c->u.a.totallen - c->u.a.lensofar,
4555                             len);
4556                     memcpy(c->u.a.message + c->u.a.lensofar, p,
4557                            l);
4558                     p += l;
4559                     len -= l;
4560                     c->u.a.lensofar += l;
4561                 }
4562                 if (c->u.a.lensofar == c->u.a.totallen) {
4563                     void *reply;
4564                     int replylen;
4565                     if (agent_query(c->u.a.message,
4566                                     c->u.a.totallen,
4567                                     &reply, &replylen,
4568                                     ssh_agentf_callback, c))
4569                         ssh_agentf_callback(c, reply, replylen);
4570                     sfree(c->u.a.message);
4571                     c->u.a.lensofar = 0;
4572                 }
4573             }
4574             bufsize = 0;   /* agent channels never back up */
4575             break;
4576         }
4577         if (!c->v.v1.throttling && bufsize > SSH1_BUFFER_LIMIT) {
4578             c->v.v1.throttling = 1;
4579             ssh1_throttle(ssh, +1);
4580         }
4581     }
4582 }
4583
4584 static void ssh1_smsg_exit_status(Ssh ssh, struct Packet *pktin)
4585 {
4586     ssh->exitcode = ssh_pkt_getuint32(pktin);
4587     logeventf(ssh, "Server sent command exit status %d", ssh->exitcode);
4588     send_packet(ssh, SSH1_CMSG_EXIT_CONFIRMATION, PKT_END);
4589     /*
4590      * In case `helpful' firewalls or proxies tack
4591      * extra human-readable text on the end of the
4592      * session which we might mistake for another
4593      * encrypted packet, we close the session once
4594      * we've sent EXIT_CONFIRMATION.
4595      */
4596     ssh_disconnect(ssh, NULL, NULL, 0, TRUE);
4597 }
4598
4599 /* Helper function to deal with sending tty modes for REQUEST_PTY */
4600 static void ssh1_send_ttymode(void *data, char *mode, char *val)
4601 {
4602     struct Packet *pktout = (struct Packet *)data;
4603     int i = 0;
4604     unsigned int arg = 0;
4605     while (strcmp(mode, ssh_ttymodes[i].mode) != 0) i++;
4606     if (i == lenof(ssh_ttymodes)) return;
4607     switch (ssh_ttymodes[i].type) {
4608       case TTY_OP_CHAR:
4609         arg = ssh_tty_parse_specchar(val);
4610         break;
4611       case TTY_OP_BOOL:
4612         arg = ssh_tty_parse_boolean(val);
4613         break;
4614     }
4615     ssh2_pkt_addbyte(pktout, ssh_ttymodes[i].opcode);
4616     ssh2_pkt_addbyte(pktout, arg);
4617 }
4618
4619
4620 static void do_ssh1_connection(Ssh ssh, unsigned char *in, int inlen,
4621                                struct Packet *pktin)
4622 {
4623     crBegin(ssh->do_ssh1_connection_crstate);
4624
4625     ssh->packet_dispatch[SSH1_SMSG_STDOUT_DATA] =
4626         ssh->packet_dispatch[SSH1_SMSG_STDERR_DATA] =
4627         ssh1_smsg_stdout_stderr_data;
4628
4629     ssh->packet_dispatch[SSH1_MSG_CHANNEL_OPEN_CONFIRMATION] =
4630         ssh1_msg_channel_open_confirmation;
4631     ssh->packet_dispatch[SSH1_MSG_CHANNEL_OPEN_FAILURE] =
4632         ssh1_msg_channel_open_failure;
4633     ssh->packet_dispatch[SSH1_MSG_CHANNEL_CLOSE] =
4634         ssh->packet_dispatch[SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION] =
4635         ssh1_msg_channel_close;
4636     ssh->packet_dispatch[SSH1_MSG_CHANNEL_DATA] = ssh1_msg_channel_data;
4637     ssh->packet_dispatch[SSH1_SMSG_EXIT_STATUS] = ssh1_smsg_exit_status;
4638
4639     if (ssh->cfg.agentfwd && agent_exists()) {
4640         logevent("Requesting agent forwarding");
4641         send_packet(ssh, SSH1_CMSG_AGENT_REQUEST_FORWARDING, PKT_END);
4642         do {
4643             crReturnV;
4644         } while (!pktin);
4645         if (pktin->type != SSH1_SMSG_SUCCESS
4646             && pktin->type != SSH1_SMSG_FAILURE) {
4647             bombout(("Protocol confusion"));
4648             crStopV;
4649         } else if (pktin->type == SSH1_SMSG_FAILURE) {
4650             logevent("Agent forwarding refused");
4651         } else {
4652             logevent("Agent forwarding enabled");
4653             ssh->agentfwd_enabled = TRUE;
4654             ssh->packet_dispatch[SSH1_SMSG_AGENT_OPEN] = ssh1_smsg_agent_open;
4655         }
4656     }
4657
4658     if (ssh->cfg.x11_forward) {
4659         char proto[20], data[64];
4660         logevent("Requesting X11 forwarding");
4661         ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
4662                                        data, sizeof(data), ssh->cfg.x11_auth);
4663         x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display);
4664         /*
4665          * Note that while we blank the X authentication data here, we don't
4666          * take any special action to blank the start of an X11 channel,
4667          * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
4668          * without having session blanking enabled is likely to leak your
4669          * cookie into the log.
4670          */
4671         if (ssh->v1_local_protoflags & SSH1_PROTOFLAG_SCREEN_NUMBER) {
4672             send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
4673                         PKT_STR, proto,
4674                         PKTT_PASSWORD, PKT_STR, data, PKTT_OTHER,
4675                         PKT_INT, x11_get_screen_number(ssh->cfg.x11_display),
4676                         PKT_END);
4677         } else {
4678             send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
4679                         PKT_STR, proto,
4680                         PKTT_PASSWORD, PKT_STR, data, PKTT_OTHER, PKT_END);
4681         }
4682         do {
4683             crReturnV;
4684         } while (!pktin);
4685         if (pktin->type != SSH1_SMSG_SUCCESS
4686             && pktin->type != SSH1_SMSG_FAILURE) {
4687             bombout(("Protocol confusion"));
4688             crStopV;
4689         } else if (pktin->type == SSH1_SMSG_FAILURE) {
4690             logevent("X11 forwarding refused");
4691         } else {
4692             logevent("X11 forwarding enabled");
4693             ssh->X11_fwd_enabled = TRUE;
4694             ssh->packet_dispatch[SSH1_SMSG_X11_OPEN] = ssh1_smsg_x11_open;
4695         }
4696     }
4697
4698     ssh_setup_portfwd(ssh, &ssh->cfg);
4699     ssh->packet_dispatch[SSH1_MSG_PORT_OPEN] = ssh1_msg_port_open;
4700
4701     if (!ssh->cfg.nopty) {
4702         struct Packet *pkt;
4703         /* Unpick the terminal-speed string. */
4704         /* XXX perhaps we should allow no speeds to be sent. */
4705         ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
4706         sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
4707         /* Send the pty request. */
4708         pkt = ssh1_pkt_init(SSH1_CMSG_REQUEST_PTY);
4709         ssh_pkt_addstring(pkt, ssh->cfg.termtype);
4710         ssh_pkt_adduint32(pkt, ssh->term_height);
4711         ssh_pkt_adduint32(pkt, ssh->term_width);
4712         ssh_pkt_adduint32(pkt, 0); /* width in pixels */
4713         ssh_pkt_adduint32(pkt, 0); /* height in pixels */
4714         parse_ttymodes(ssh, ssh->cfg.ttymodes,
4715                        ssh1_send_ttymode, (void *)pkt);
4716         ssh_pkt_addbyte(pkt, SSH1_TTY_OP_ISPEED);
4717         ssh_pkt_adduint32(pkt, ssh->ispeed);
4718         ssh_pkt_addbyte(pkt, SSH1_TTY_OP_OSPEED);
4719         ssh_pkt_adduint32(pkt, ssh->ospeed);
4720         ssh_pkt_addbyte(pkt, SSH_TTY_OP_END);
4721         s_wrpkt(ssh, pkt);
4722         ssh->state = SSH_STATE_INTERMED;
4723         do {
4724             crReturnV;
4725         } while (!pktin);
4726         if (pktin->type != SSH1_SMSG_SUCCESS
4727             && pktin->type != SSH1_SMSG_FAILURE) {
4728             bombout(("Protocol confusion"));
4729             crStopV;
4730         } else if (pktin->type == SSH1_SMSG_FAILURE) {
4731             c_write_str(ssh, "Server refused to allocate pty\r\n");
4732             ssh->editing = ssh->echoing = 1;
4733         }
4734         logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
4735                   ssh->ospeed, ssh->ispeed);
4736     } else {
4737         ssh->editing = ssh->echoing = 1;
4738     }
4739
4740     if (ssh->cfg.compression) {
4741         send_packet(ssh, SSH1_CMSG_REQUEST_COMPRESSION, PKT_INT, 6, PKT_END);
4742         do {
4743             crReturnV;
4744         } while (!pktin);
4745         if (pktin->type != SSH1_SMSG_SUCCESS
4746             && pktin->type != SSH1_SMSG_FAILURE) {
4747             bombout(("Protocol confusion"));
4748             crStopV;
4749         } else if (pktin->type == SSH1_SMSG_FAILURE) {
4750             c_write_str(ssh, "Server refused to compress\r\n");
4751         }
4752         logevent("Started compression");
4753         ssh->v1_compressing = TRUE;
4754         ssh->cs_comp_ctx = zlib_compress_init();
4755         logevent("Initialised zlib (RFC1950) compression");
4756         ssh->sc_comp_ctx = zlib_decompress_init();
4757         logevent("Initialised zlib (RFC1950) decompression");
4758     }
4759
4760     /*
4761      * Start the shell or command.
4762      *
4763      * Special case: if the first-choice command is an SSH-2
4764      * subsystem (hence not usable here) and the second choice
4765      * exists, we fall straight back to that.
4766      */
4767     {
4768         char *cmd = ssh->cfg.remote_cmd_ptr;
4769
4770         if (!cmd) cmd = ssh->cfg.remote_cmd;
4771
4772         if (ssh->cfg.ssh_subsys && ssh->cfg.remote_cmd_ptr2) {
4773             cmd = ssh->cfg.remote_cmd_ptr2;
4774             ssh->fallback_cmd = TRUE;
4775         }
4776         if (*cmd)
4777             send_packet(ssh, SSH1_CMSG_EXEC_CMD, PKT_STR, cmd, PKT_END);
4778         else
4779             send_packet(ssh, SSH1_CMSG_EXEC_SHELL, PKT_END);
4780         logevent("Started session");
4781     }
4782
4783     ssh->state = SSH_STATE_SESSION;
4784     if (ssh->size_needed)
4785         ssh_size(ssh, ssh->term_width, ssh->term_height);
4786     if (ssh->eof_needed)
4787         ssh_special(ssh, TS_EOF);
4788
4789     if (ssh->ldisc)
4790         ldisc_send(ssh->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
4791     ssh->send_ok = 1;
4792     ssh->channels = newtree234(ssh_channelcmp);
4793     while (1) {
4794
4795         /*
4796          * By this point, most incoming packets are already being
4797          * handled by the dispatch table, and we need only pay
4798          * attention to the unusual ones.
4799          */
4800
4801         crReturnV;
4802         if (pktin) {
4803             if (pktin->type == SSH1_SMSG_SUCCESS) {
4804                 /* may be from EXEC_SHELL on some servers */
4805             } else if (pktin->type == SSH1_SMSG_FAILURE) {
4806                 /* may be from EXEC_SHELL on some servers
4807                  * if no pty is available or in other odd cases. Ignore */
4808             } else {
4809                 bombout(("Strange packet received: type %d", pktin->type));
4810                 crStopV;
4811             }
4812         } else {
4813             while (inlen > 0) {
4814                 int len = min(inlen, 512);
4815                 send_packet(ssh, SSH1_CMSG_STDIN_DATA, PKTT_DATA,
4816                             PKT_INT, len, PKT_DATA, in, len,
4817                             PKTT_OTHER, PKT_END);
4818                 in += len;
4819                 inlen -= len;
4820             }
4821         }
4822     }
4823
4824     crFinishV;
4825 }
4826
4827 /*
4828  * Handle the top-level SSH-2 protocol.
4829  */
4830 static void ssh1_msg_debug(Ssh ssh, struct Packet *pktin)
4831 {
4832     char *msg;
4833     int msglen;
4834
4835     ssh_pkt_getstring(pktin, &msg, &msglen);
4836     logeventf(ssh, "Remote debug message: %.*s", msglen, msg);
4837 }
4838
4839 static void ssh1_msg_disconnect(Ssh ssh, struct Packet *pktin)
4840 {
4841     /* log reason code in disconnect message */
4842     char *msg;
4843     int msglen;
4844
4845     ssh_pkt_getstring(pktin, &msg, &msglen);
4846     bombout(("Server sent disconnect message:\n\"%.*s\"", msglen, msg));
4847 }
4848
4849 static void ssh_msg_ignore(Ssh ssh, struct Packet *pktin)
4850 {
4851     /* Do nothing, because we're ignoring it! Duhh. */
4852 }
4853
4854 static void ssh1_protocol_setup(Ssh ssh)
4855 {
4856     int i;
4857
4858     /*
4859      * Most messages are handled by the coroutines.
4860      */
4861     for (i = 0; i < 256; i++)
4862         ssh->packet_dispatch[i] = NULL;
4863
4864     /*
4865      * These special message types we install handlers for.
4866      */
4867     ssh->packet_dispatch[SSH1_MSG_DISCONNECT] = ssh1_msg_disconnect;
4868     ssh->packet_dispatch[SSH1_MSG_IGNORE] = ssh_msg_ignore;
4869     ssh->packet_dispatch[SSH1_MSG_DEBUG] = ssh1_msg_debug;
4870 }
4871
4872 static void ssh1_protocol(Ssh ssh, void *vin, int inlen,
4873                           struct Packet *pktin)
4874 {
4875     unsigned char *in=(unsigned char*)vin;
4876     if (ssh->state == SSH_STATE_CLOSED)
4877         return;
4878
4879     if (pktin && ssh->packet_dispatch[pktin->type]) {
4880         ssh->packet_dispatch[pktin->type](ssh, pktin);
4881         return;
4882     }
4883
4884     if (!ssh->protocol_initial_phase_done) {
4885         if (do_ssh1_login(ssh, in, inlen, pktin))
4886             ssh->protocol_initial_phase_done = TRUE;
4887         else
4888             return;
4889     }
4890
4891     do_ssh1_connection(ssh, in, inlen, pktin);
4892 }
4893
4894 /*
4895  * Utility routine for decoding comma-separated strings in KEXINIT.
4896  */
4897 static int in_commasep_string(char *needle, char *haystack, int haylen)
4898 {
4899     int needlen;
4900     if (!needle || !haystack)          /* protect against null pointers */
4901         return 0;
4902     needlen = strlen(needle);
4903     while (1) {
4904         /*
4905          * Is it at the start of the string?
4906          */
4907         if (haylen >= needlen &&       /* haystack is long enough */
4908             !memcmp(needle, haystack, needlen) &&       /* initial match */
4909             (haylen == needlen || haystack[needlen] == ',')
4910             /* either , or EOS follows */
4911             )
4912             return 1;
4913         /*
4914          * If not, search for the next comma and resume after that.
4915          * If no comma found, terminate.
4916          */
4917         while (haylen > 0 && *haystack != ',')
4918             haylen--, haystack++;
4919         if (haylen == 0)
4920             return 0;
4921         haylen--, haystack++;          /* skip over comma itself */
4922     }
4923 }
4924
4925 /*
4926  * Similar routine for checking whether we have the first string in a list.
4927  */
4928 static int first_in_commasep_string(char *needle, char *haystack, int haylen)
4929 {
4930     int needlen;
4931     if (!needle || !haystack)          /* protect against null pointers */
4932         return 0;
4933     needlen = strlen(needle);
4934     /*
4935      * Is it at the start of the string?
4936      */
4937     if (haylen >= needlen &&       /* haystack is long enough */
4938         !memcmp(needle, haystack, needlen) &&   /* initial match */
4939         (haylen == needlen || haystack[needlen] == ',')
4940         /* either , or EOS follows */
4941         )
4942         return 1;
4943     return 0;
4944 }
4945
4946
4947 /*
4948  * SSH-2 key creation method.
4949  */
4950 static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H,
4951                        unsigned char *sessid, char chr,
4952                        unsigned char *keyspace)
4953 {
4954     SHA_State s;
4955     /* First 20 bytes. */
4956     SHA_Init(&s);
4957     if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY))
4958         sha_mpint(&s, K);
4959     SHA_Bytes(&s, H, 20);
4960     SHA_Bytes(&s, &chr, 1);
4961     SHA_Bytes(&s, sessid, 20);
4962     SHA_Final(&s, keyspace);
4963     /* Next 20 bytes. */
4964     SHA_Init(&s);
4965     if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY))
4966         sha_mpint(&s, K);
4967     SHA_Bytes(&s, H, 20);
4968     SHA_Bytes(&s, keyspace, 20);
4969     SHA_Final(&s, keyspace + 20);
4970 }
4971
4972 /*
4973  * Handle the SSH-2 transport layer.
4974  */
4975 static int do_ssh2_transport(Ssh ssh, void *vin, int inlen,
4976                              struct Packet *pktin)
4977 {
4978     unsigned char *in = (unsigned char *)vin;
4979     struct do_ssh2_transport_state {
4980         int nbits, pbits, warn_kex, warn_cscipher, warn_sccipher;
4981         Bignum p, g, e, f, K;
4982         void *our_kexinit;
4983         int our_kexinitlen;
4984         int kex_init_value, kex_reply_value;
4985         const struct ssh_mac **maclist;
4986         int nmacs;
4987         const struct ssh2_cipher *cscipher_tobe;
4988         const struct ssh2_cipher *sccipher_tobe;
4989         const struct ssh_mac *csmac_tobe;
4990         const struct ssh_mac *scmac_tobe;
4991         const struct ssh_compress *cscomp_tobe;
4992         const struct ssh_compress *sccomp_tobe;
4993         char *hostkeydata, *sigdata, *keystr, *fingerprint;
4994         int hostkeylen, siglen;
4995         void *hkey;                    /* actual host key */
4996         unsigned char exchange_hash[20];
4997         int n_preferred_kex;
4998         const struct ssh_kex *preferred_kex[KEX_MAX];
4999         int n_preferred_ciphers;
5000         const struct ssh2_ciphers *preferred_ciphers[CIPHER_MAX];
5001         const struct ssh_compress *preferred_comp;
5002         int got_session_id, activated_authconn;
5003         struct Packet *pktout;
5004         int dlgret;
5005         int guessok;
5006         int ignorepkt;
5007     };
5008     crState(do_ssh2_transport_state);
5009
5010     crBegin(ssh->do_ssh2_transport_crstate);
5011
5012     s->cscipher_tobe = s->sccipher_tobe = NULL;
5013     s->csmac_tobe = s->scmac_tobe = NULL;
5014     s->cscomp_tobe = s->sccomp_tobe = NULL;
5015
5016     s->got_session_id = s->activated_authconn = FALSE;
5017
5018     /*
5019      * Be prepared to work around the buggy MAC problem.
5020      */
5021     if (ssh->remote_bugs & BUG_SSH2_HMAC)
5022         s->maclist = buggymacs, s->nmacs = lenof(buggymacs);
5023     else
5024         s->maclist = macs, s->nmacs = lenof(macs);
5025
5026   begin_key_exchange:
5027     ssh->pkt_ctx &= ~SSH2_PKTCTX_KEX_MASK;
5028     {
5029         int i, j, commalist_started;
5030
5031         /*
5032          * Set up the preferred key exchange. (NULL => warn below here)
5033          */
5034         s->n_preferred_kex = 0;
5035         for (i = 0; i < KEX_MAX; i++) {
5036             switch (ssh->cfg.ssh_kexlist[i]) {
5037               case KEX_DHGEX:
5038                 s->preferred_kex[s->n_preferred_kex++] =
5039                     &ssh_diffiehellman_gex;
5040                 break;
5041               case KEX_DHGROUP14:
5042                 s->preferred_kex[s->n_preferred_kex++] =
5043                     &ssh_diffiehellman_group14;
5044                 break;
5045               case KEX_DHGROUP1:
5046                 s->preferred_kex[s->n_preferred_kex++] =
5047                     &ssh_diffiehellman_group1;
5048                 break;
5049               case CIPHER_WARN:
5050                 /* Flag for later. Don't bother if it's the last in
5051                  * the list. */
5052                 if (i < KEX_MAX - 1) {
5053                     s->preferred_kex[s->n_preferred_kex++] = NULL;
5054                 }
5055                 break;
5056             }
5057         }
5058
5059         /*
5060          * Set up the preferred ciphers. (NULL => warn below here)
5061          */
5062         s->n_preferred_ciphers = 0;
5063         for (i = 0; i < CIPHER_MAX; i++) {
5064             switch (ssh->cfg.ssh_cipherlist[i]) {
5065               case CIPHER_BLOWFISH:
5066                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_blowfish;
5067                 break;
5068               case CIPHER_DES:
5069                 if (ssh->cfg.ssh2_des_cbc) {
5070                     s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_des;
5071                 }
5072                 break;
5073               case CIPHER_3DES:
5074                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_3des;
5075                 break;
5076               case CIPHER_AES:
5077                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_aes;
5078                 break;
5079               case CIPHER_ARCFOUR:
5080                 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_arcfour;
5081                 break;
5082               case CIPHER_WARN:
5083                 /* Flag for later. Don't bother if it's the last in
5084                  * the list. */
5085                 if (i < CIPHER_MAX - 1) {
5086                     s->preferred_ciphers[s->n_preferred_ciphers++] = NULL;
5087                 }
5088                 break;
5089             }
5090         }
5091
5092         /*
5093          * Set up preferred compression.
5094          */
5095         if (ssh->cfg.compression)
5096             s->preferred_comp = &ssh_zlib;
5097         else
5098             s->preferred_comp = &ssh_comp_none;
5099
5100         /*
5101          * Enable queueing of outgoing auth- or connection-layer
5102          * packets while we are in the middle of a key exchange.
5103          */
5104         ssh->queueing = TRUE;
5105
5106         /*
5107          * Flag that KEX is in progress.
5108          */
5109         ssh->kex_in_progress = TRUE;
5110
5111         /*
5112          * Construct and send our key exchange packet.
5113          */
5114         s->pktout = ssh2_pkt_init(SSH2_MSG_KEXINIT);
5115         for (i = 0; i < 16; i++)
5116             ssh2_pkt_addbyte(s->pktout, (unsigned char) random_byte());
5117         /* List key exchange algorithms. */
5118         ssh2_pkt_addstring_start(s->pktout);
5119         commalist_started = 0;
5120         for (i = 0; i < s->n_preferred_kex; i++) {
5121             const struct ssh_kex *k = s->preferred_kex[i];
5122             if (!k) continue;          /* warning flag */
5123             if (commalist_started)
5124                 ssh2_pkt_addstring_str(s->pktout, ",");
5125             ssh2_pkt_addstring_str(s->pktout, s->preferred_kex[i]->name);
5126             commalist_started = 1;
5127         }
5128         /* List server host key algorithms. */
5129         ssh2_pkt_addstring_start(s->pktout);
5130         for (i = 0; i < lenof(hostkey_algs); i++) {
5131             ssh2_pkt_addstring_str(s->pktout, hostkey_algs[i]->name);
5132             if (i < lenof(hostkey_algs) - 1)
5133                 ssh2_pkt_addstring_str(s->pktout, ",");
5134         }
5135         /* List client->server encryption algorithms. */
5136         ssh2_pkt_addstring_start(s->pktout);
5137         commalist_started = 0;
5138         for (i = 0; i < s->n_preferred_ciphers; i++) {
5139             const struct ssh2_ciphers *c = s->preferred_ciphers[i];
5140             if (!c) continue;          /* warning flag */
5141             for (j = 0; j < c->nciphers; j++) {
5142                 if (commalist_started)
5143                     ssh2_pkt_addstring_str(s->pktout, ",");
5144                 ssh2_pkt_addstring_str(s->pktout, c->list[j]->name);
5145                 commalist_started = 1;
5146             }
5147         }
5148         /* List server->client encryption algorithms. */
5149         ssh2_pkt_addstring_start(s->pktout);
5150         commalist_started = 0;
5151         for (i = 0; i < s->n_preferred_ciphers; i++) {
5152             const struct ssh2_ciphers *c = s->preferred_ciphers[i];
5153             if (!c) continue; /* warning flag */
5154             for (j = 0; j < c->nciphers; j++) {
5155                 if (commalist_started)
5156                     ssh2_pkt_addstring_str(s->pktout, ",");
5157                 ssh2_pkt_addstring_str(s->pktout, c->list[j]->name);
5158                 commalist_started = 1;
5159             }
5160         }
5161         /* List client->server MAC algorithms. */
5162         ssh2_pkt_addstring_start(s->pktout);
5163         for (i = 0; i < s->nmacs; i++) {
5164             ssh2_pkt_addstring_str(s->pktout, s->maclist[i]->name);
5165             if (i < s->nmacs - 1)
5166                 ssh2_pkt_addstring_str(s->pktout, ",");
5167         }
5168         /* List server->client MAC algorithms. */
5169         ssh2_pkt_addstring_start(s->pktout);
5170         for (i = 0; i < s->nmacs; i++) {
5171             ssh2_pkt_addstring_str(s->pktout, s->maclist[i]->name);
5172             if (i < s->nmacs - 1)
5173                 ssh2_pkt_addstring_str(s->pktout, ",");
5174         }
5175         /* List client->server compression algorithms. */
5176         ssh2_pkt_addstring_start(s->pktout);
5177         assert(lenof(compressions) > 1);
5178         ssh2_pkt_addstring_str(s->pktout, s->preferred_comp->name);
5179         for (i = 0; i < lenof(compressions); i++) {
5180             const struct ssh_compress *c = compressions[i];
5181             if (c != s->preferred_comp) {
5182                 ssh2_pkt_addstring_str(s->pktout, ",");
5183                 ssh2_pkt_addstring_str(s->pktout, c->name);
5184             }
5185         }
5186         /* List server->client compression algorithms. */
5187         ssh2_pkt_addstring_start(s->pktout);
5188         assert(lenof(compressions) > 1);
5189         ssh2_pkt_addstring_str(s->pktout, s->preferred_comp->name);
5190         for (i = 0; i < lenof(compressions); i++) {
5191             const struct ssh_compress *c = compressions[i];
5192             if (c != s->preferred_comp) {
5193                 ssh2_pkt_addstring_str(s->pktout, ",");
5194                 ssh2_pkt_addstring_str(s->pktout, c->name);
5195             }
5196         }
5197         /* List client->server languages. Empty list. */
5198         ssh2_pkt_addstring_start(s->pktout);
5199         /* List server->client languages. Empty list. */
5200         ssh2_pkt_addstring_start(s->pktout);
5201         /* First KEX packet does _not_ follow, because we're not that brave. */
5202         ssh2_pkt_addbool(s->pktout, FALSE);
5203         /* Reserved. */
5204         ssh2_pkt_adduint32(s->pktout, 0);
5205     }
5206
5207     s->our_kexinitlen = s->pktout->length - 5;
5208     s->our_kexinit = snewn(s->our_kexinitlen, unsigned char);
5209     memcpy(s->our_kexinit, s->pktout->data + 5, s->our_kexinitlen);
5210
5211     ssh2_pkt_send_noqueue(ssh, s->pktout);
5212
5213     if (!pktin)
5214         crWaitUntil(pktin);
5215
5216     /*
5217      * Now examine the other side's KEXINIT to see what we're up
5218      * to.
5219      */
5220     {
5221         char *str, *preferred;
5222         int i, j, len;
5223
5224         if (pktin->type != SSH2_MSG_KEXINIT) {
5225             bombout(("expected key exchange packet from server"));
5226             crStop(0);
5227         }
5228         ssh->kex = NULL;
5229         ssh->hostkey = NULL;
5230         s->cscipher_tobe = NULL;
5231         s->sccipher_tobe = NULL;
5232         s->csmac_tobe = NULL;
5233         s->scmac_tobe = NULL;
5234         s->cscomp_tobe = NULL;
5235         s->sccomp_tobe = NULL;
5236         s->warn_kex = s->warn_cscipher = s->warn_sccipher = FALSE;
5237
5238         pktin->savedpos += 16;          /* skip garbage cookie */
5239         ssh_pkt_getstring(pktin, &str, &len);    /* key exchange algorithms */
5240
5241         preferred = NULL;
5242         for (i = 0; i < s->n_preferred_kex; i++) {
5243             const struct ssh_kex *k = s->preferred_kex[i];
5244             if (!k) {
5245                 s->warn_kex = TRUE;
5246             } else {
5247                 if (!preferred) preferred = k->name;
5248                 if (in_commasep_string(k->name, str, len))
5249                     ssh->kex = k;
5250             }
5251             if (ssh->kex)
5252                 break;
5253         }
5254         if (!ssh->kex) {
5255             bombout(("Couldn't agree a key exchange algorithm (available: %s)",
5256                      str ? str : "(null)"));
5257             crStop(0);
5258         }
5259         /*
5260          * Note that the server's guess is considered wrong if it doesn't match
5261          * the first algorithm in our list, even if it's still the algorithm
5262          * we end up using.
5263          */
5264         s->guessok = first_in_commasep_string(preferred, str, len);
5265         ssh_pkt_getstring(pktin, &str, &len);    /* host key algorithms */
5266         for (i = 0; i < lenof(hostkey_algs); i++) {
5267             if (in_commasep_string(hostkey_algs[i]->name, str, len)) {
5268                 ssh->hostkey = hostkey_algs[i];
5269                 break;
5270             }
5271         }
5272         s->guessok = s->guessok &&
5273             first_in_commasep_string(hostkey_algs[0]->name, str, len);
5274         ssh_pkt_getstring(pktin, &str, &len);    /* client->server cipher */
5275         for (i = 0; i < s->n_preferred_ciphers; i++) {
5276             const struct ssh2_ciphers *c = s->preferred_ciphers[i];
5277             if (!c) {
5278                 s->warn_cscipher = TRUE;
5279             } else {
5280                 for (j = 0; j < c->nciphers; j++) {
5281                     if (in_commasep_string(c->list[j]->name, str, len)) {
5282                         s->cscipher_tobe = c->list[j];
5283                         break;
5284                     }
5285                 }
5286             }
5287             if (s->cscipher_tobe)
5288                 break;
5289         }
5290         if (!s->cscipher_tobe) {
5291             bombout(("Couldn't agree a client-to-server cipher (available: %s)",
5292                      str ? str : "(null)"));
5293             crStop(0);
5294         }
5295
5296         ssh_pkt_getstring(pktin, &str, &len);    /* server->client cipher */
5297         for (i = 0; i < s->n_preferred_ciphers; i++) {
5298             const struct ssh2_ciphers *c = s->preferred_ciphers[i];
5299             if (!c) {
5300                 s->warn_sccipher = TRUE;
5301             } else {
5302                 for (j = 0; j < c->nciphers; j++) {
5303                     if (in_commasep_string(c->list[j]->name, str, len)) {
5304                         s->sccipher_tobe = c->list[j];
5305                         break;
5306                     }
5307                 }
5308             }
5309             if (s->sccipher_tobe)
5310                 break;
5311         }
5312         if (!s->sccipher_tobe) {
5313             bombout(("Couldn't agree a server-to-client cipher (available: %s)",
5314                      str ? str : "(null)"));
5315             crStop(0);
5316         }
5317
5318         ssh_pkt_getstring(pktin, &str, &len);    /* client->server mac */
5319         for (i = 0; i < s->nmacs; i++) {
5320             if (in_commasep_string(s->maclist[i]->name, str, len)) {
5321                 s->csmac_tobe = s->maclist[i];
5322                 break;
5323             }
5324         }
5325         ssh_pkt_getstring(pktin, &str, &len);    /* server->client mac */
5326         for (i = 0; i < s->nmacs; i++) {
5327             if (in_commasep_string(s->maclist[i]->name, str, len)) {
5328                 s->scmac_tobe = s->maclist[i];
5329                 break;
5330             }
5331         }
5332         ssh_pkt_getstring(pktin, &str, &len);  /* client->server compression */
5333         for (i = 0; i < lenof(compressions) + 1; i++) {
5334             const struct ssh_compress *c =
5335                 i == 0 ? s->preferred_comp : compressions[i - 1];
5336             if (in_commasep_string(c->name, str, len)) {
5337                 s->cscomp_tobe = c;
5338                 break;
5339             }
5340         }
5341         ssh_pkt_getstring(pktin, &str, &len);  /* server->client compression */
5342         for (i = 0; i < lenof(compressions) + 1; i++) {
5343             const struct ssh_compress *c =
5344                 i == 0 ? s->preferred_comp : compressions[i - 1];
5345             if (in_commasep_string(c->name, str, len)) {
5346                 s->sccomp_tobe = c;
5347                 break;
5348             }
5349         }
5350         ssh_pkt_getstring(pktin, &str, &len);  /* client->server language */
5351         ssh_pkt_getstring(pktin, &str, &len);  /* server->client language */
5352         s->ignorepkt = ssh2_pkt_getbool(pktin) && !s->guessok;
5353
5354         if (s->warn_kex) {
5355             ssh_set_frozen(ssh, 1);
5356             s->dlgret = askalg(ssh->frontend, "key-exchange algorithm",
5357                                ssh->kex->name,
5358                                ssh_dialog_callback, ssh);
5359             if (s->dlgret < 0) {
5360                 do {
5361                     crReturn(0);
5362                     if (pktin) {
5363                         bombout(("Unexpected data from server while"
5364                                  " waiting for user response"));
5365                         crStop(0);
5366                     }
5367                 } while (pktin || inlen > 0);
5368                 s->dlgret = ssh->user_response;
5369             }
5370             ssh_set_frozen(ssh, 0);
5371             if (s->dlgret == 0) {
5372                 ssh_disconnect(ssh, "User aborted at kex warning", NULL,
5373                                0, TRUE);
5374                 crStop(0);
5375             }
5376         }
5377
5378         if (s->warn_cscipher) {
5379             ssh_set_frozen(ssh, 1);
5380             s->dlgret = askalg(ssh->frontend,
5381                                "client-to-server cipher",
5382                                s->cscipher_tobe->name,
5383                                ssh_dialog_callback, ssh);
5384             if (s->dlgret < 0) {
5385                 do {
5386                     crReturn(0);
5387                     if (pktin) {
5388                         bombout(("Unexpected data from server while"
5389                                  " waiting for user response"));
5390                         crStop(0);
5391                     }
5392                 } while (pktin || inlen > 0);
5393                 s->dlgret = ssh->user_response;
5394             }
5395             ssh_set_frozen(ssh, 0);
5396             if (s->dlgret == 0) {
5397                 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
5398                                0, TRUE);
5399                 crStop(0);
5400             }
5401         }
5402
5403         if (s->warn_sccipher) {
5404             ssh_set_frozen(ssh, 1);
5405             s->dlgret = askalg(ssh->frontend,
5406                                "server-to-client cipher",
5407                                s->sccipher_tobe->name,
5408                                ssh_dialog_callback, ssh);
5409             if (s->dlgret < 0) {
5410                 do {
5411                     crReturn(0);
5412                     if (pktin) {
5413                         bombout(("Unexpected data from server while"
5414                                  " waiting for user response"));
5415                         crStop(0);
5416                     }
5417                 } while (pktin || inlen > 0);
5418                 s->dlgret = ssh->user_response;
5419             }
5420             ssh_set_frozen(ssh, 0);
5421             if (s->dlgret == 0) {
5422                 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
5423                                0, TRUE);
5424                 crStop(0);
5425             }
5426         }
5427
5428         SHA_Init(&ssh->exhash);
5429         sha_string(&ssh->exhash, ssh->v_c, strlen(ssh->v_c));
5430         sha_string(&ssh->exhash, ssh->v_s, strlen(ssh->v_s));
5431         sha_string(&ssh->exhash, s->our_kexinit, s->our_kexinitlen);
5432         sfree(s->our_kexinit);
5433         if (pktin->length > 5)
5434             sha_string(&ssh->exhash, pktin->data + 5, pktin->length - 5);
5435
5436
5437         if (s->ignorepkt) /* first_kex_packet_follows */
5438             crWaitUntil(pktin);                /* Ignore packet */
5439     }
5440
5441     /*
5442      * Work out the number of bits of key we will need from the key
5443      * exchange. We start with the maximum key length of either
5444      * cipher...
5445      */
5446     {
5447         int csbits, scbits;
5448
5449         csbits = s->cscipher_tobe->keylen;
5450         scbits = s->sccipher_tobe->keylen;
5451         s->nbits = (csbits > scbits ? csbits : scbits);
5452     }
5453     /* The keys only have 160-bit entropy, since they're based on
5454      * a SHA-1 hash. So cap the key size at 160 bits. */
5455     if (s->nbits > 160)
5456         s->nbits = 160;
5457
5458     /*
5459      * If we're doing Diffie-Hellman group exchange, start by
5460      * requesting a group.
5461      */
5462     if (!ssh->kex->pdata) {
5463         logevent("Doing Diffie-Hellman group exchange");
5464         ssh->pkt_ctx |= SSH2_PKTCTX_DHGEX;
5465         /*
5466          * Work out how big a DH group we will need to allow that
5467          * much data.
5468          */
5469         s->pbits = 512 << ((s->nbits - 1) / 64);
5470         s->pktout = ssh2_pkt_init(SSH2_MSG_KEX_DH_GEX_REQUEST);
5471         ssh2_pkt_adduint32(s->pktout, s->pbits);
5472         ssh2_pkt_send_noqueue(ssh, s->pktout);
5473
5474         crWaitUntil(pktin);
5475         if (pktin->type != SSH2_MSG_KEX_DH_GEX_GROUP) {
5476             bombout(("expected key exchange group packet from server"));
5477             crStop(0);
5478         }
5479         s->p = ssh2_pkt_getmp(pktin);
5480         s->g = ssh2_pkt_getmp(pktin);
5481         if (!s->p || !s->g) {
5482             bombout(("unable to read mp-ints from incoming group packet"));
5483             crStop(0);
5484         }
5485         ssh->kex_ctx = dh_setup_gex(s->p, s->g);
5486         s->kex_init_value = SSH2_MSG_KEX_DH_GEX_INIT;
5487         s->kex_reply_value = SSH2_MSG_KEX_DH_GEX_REPLY;
5488     } else {
5489         ssh->pkt_ctx |= SSH2_PKTCTX_DHGROUP;
5490         ssh->kex_ctx = dh_setup_group(ssh->kex);
5491         s->kex_init_value = SSH2_MSG_KEXDH_INIT;
5492         s->kex_reply_value = SSH2_MSG_KEXDH_REPLY;
5493         logeventf(ssh, "Using Diffie-Hellman with standard group \"%s\"",
5494                   ssh->kex->groupname);
5495     }
5496
5497     logevent("Doing Diffie-Hellman key exchange");
5498     /*
5499      * Now generate and send e for Diffie-Hellman.
5500      */
5501     set_busy_status(ssh->frontend, BUSY_CPU); /* this can take a while */
5502     s->e = dh_create_e(ssh->kex_ctx, s->nbits * 2);
5503     s->pktout = ssh2_pkt_init(s->kex_init_value);
5504     ssh2_pkt_addmp(s->pktout, s->e);
5505     ssh2_pkt_send_noqueue(ssh, s->pktout);
5506
5507     set_busy_status(ssh->frontend, BUSY_WAITING); /* wait for server */
5508     crWaitUntil(pktin);
5509     if (pktin->type != s->kex_reply_value) {
5510         bombout(("expected key exchange reply packet from server"));
5511         crStop(0);
5512     }
5513     set_busy_status(ssh->frontend, BUSY_CPU); /* cogitate */
5514     ssh_pkt_getstring(pktin, &s->hostkeydata, &s->hostkeylen);
5515     s->f = ssh2_pkt_getmp(pktin);
5516     if (!s->f) {
5517         bombout(("unable to parse key exchange reply packet"));
5518         crStop(0);
5519     }
5520     ssh_pkt_getstring(pktin, &s->sigdata, &s->siglen);
5521
5522     s->K = dh_find_K(ssh->kex_ctx, s->f);
5523
5524     /* We assume everything from now on will be quick, and it might
5525      * involve user interaction. */
5526     set_busy_status(ssh->frontend, BUSY_NOT);
5527
5528     sha_string(&ssh->exhash, s->hostkeydata, s->hostkeylen);
5529     if (ssh->kex == &ssh_diffiehellman_gex) {
5530         sha_uint32(&ssh->exhash, s->pbits);
5531         sha_mpint(&ssh->exhash, s->p);
5532         sha_mpint(&ssh->exhash, s->g);
5533     }
5534     sha_mpint(&ssh->exhash, s->e);
5535     sha_mpint(&ssh->exhash, s->f);
5536     sha_mpint(&ssh->exhash, s->K);
5537     SHA_Final(&ssh->exhash, s->exchange_hash);
5538
5539     dh_cleanup(ssh->kex_ctx);
5540     ssh->kex_ctx = NULL;
5541
5542 #if 0
5543     debug(("Exchange hash is:\n"));
5544     dmemdump(s->exchange_hash, 20);
5545 #endif
5546
5547     s->hkey = ssh->hostkey->newkey(s->hostkeydata, s->hostkeylen);
5548     if (!s->hkey ||
5549         !ssh->hostkey->verifysig(s->hkey, s->sigdata, s->siglen,
5550                                  (char *)s->exchange_hash, 20)) {
5551         bombout(("Server's host key did not match the signature supplied"));
5552         crStop(0);
5553     }
5554
5555     /*
5556      * Authenticate remote host: verify host key. (We've already
5557      * checked the signature of the exchange hash.)
5558      */
5559     s->keystr = ssh->hostkey->fmtkey(s->hkey);
5560     s->fingerprint = ssh->hostkey->fingerprint(s->hkey);
5561     ssh_set_frozen(ssh, 1);
5562     s->dlgret = verify_ssh_host_key(ssh->frontend,
5563                                     ssh->savedhost, ssh->savedport,
5564                                     ssh->hostkey->keytype, s->keystr,
5565                                     s->fingerprint,
5566                                     ssh_dialog_callback, ssh);
5567     if (s->dlgret < 0) {
5568         do {
5569             crReturn(0);
5570             if (pktin) {
5571                 bombout(("Unexpected data from server while waiting"
5572                          " for user host key response"));
5573                     crStop(0);
5574             }
5575         } while (pktin || inlen > 0);
5576         s->dlgret = ssh->user_response;
5577     }
5578     ssh_set_frozen(ssh, 0);
5579     if (s->dlgret == 0) {
5580         ssh_disconnect(ssh, "User aborted at host key verification", NULL,
5581                        0, TRUE);
5582         crStop(0);
5583     }
5584     if (!s->got_session_id) {     /* don't bother logging this in rekeys */
5585         logevent("Host key fingerprint is:");
5586         logevent(s->fingerprint);
5587     }
5588     sfree(s->fingerprint);
5589     sfree(s->keystr);
5590     ssh->hostkey->freekey(s->hkey);
5591
5592     /*
5593      * The exchange hash from the very first key exchange is also
5594      * the session id, used in session key construction and
5595      * authentication.
5596      */
5597     if (!s->got_session_id) {
5598         memcpy(ssh->v2_session_id, s->exchange_hash,
5599                sizeof(s->exchange_hash));
5600         s->got_session_id = TRUE;
5601     }
5602
5603     /*
5604      * Send SSH2_MSG_NEWKEYS.
5605      */
5606     s->pktout = ssh2_pkt_init(SSH2_MSG_NEWKEYS);
5607     ssh2_pkt_send_noqueue(ssh, s->pktout);
5608     ssh->outgoing_data_size = 0;       /* start counting from here */
5609
5610     /*
5611      * We've sent client NEWKEYS, so create and initialise
5612      * client-to-server session keys.
5613      */
5614     if (ssh->cs_cipher_ctx)
5615         ssh->cscipher->free_context(ssh->cs_cipher_ctx);
5616     ssh->cscipher = s->cscipher_tobe;
5617     ssh->cs_cipher_ctx = ssh->cscipher->make_context();
5618
5619     if (ssh->cs_mac_ctx)
5620         ssh->csmac->free_context(ssh->cs_mac_ctx);
5621     ssh->csmac = s->csmac_tobe;
5622     ssh->cs_mac_ctx = ssh->csmac->make_context();
5623
5624     if (ssh->cs_comp_ctx)
5625         ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
5626     ssh->cscomp = s->cscomp_tobe;
5627     ssh->cs_comp_ctx = ssh->cscomp->compress_init();
5628
5629     /*
5630      * Set IVs on client-to-server keys. Here we use the exchange
5631      * hash from the _first_ key exchange.
5632      */
5633     {
5634         unsigned char keyspace[40];
5635         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'C',keyspace);
5636         ssh->cscipher->setkey(ssh->cs_cipher_ctx, keyspace);
5637         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'A',keyspace);
5638         ssh->cscipher->setiv(ssh->cs_cipher_ctx, keyspace);
5639         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'E',keyspace);
5640         ssh->csmac->setkey(ssh->cs_mac_ctx, keyspace);
5641     }
5642
5643     logeventf(ssh, "Initialised %.200s client->server encryption",
5644               ssh->cscipher->text_name);
5645     logeventf(ssh, "Initialised %.200s client->server MAC algorithm",
5646               ssh->csmac->text_name);
5647     if (ssh->cscomp->text_name)
5648         logeventf(ssh, "Initialised %s compression",
5649                   ssh->cscomp->text_name);
5650
5651     /*
5652      * Now our end of the key exchange is complete, we can send all
5653      * our queued higher-layer packets.
5654      */
5655     ssh->queueing = FALSE;
5656     ssh2_pkt_queuesend(ssh);
5657
5658     /*
5659      * Expect SSH2_MSG_NEWKEYS from server.
5660      */
5661     crWaitUntil(pktin);
5662     if (pktin->type != SSH2_MSG_NEWKEYS) {
5663         bombout(("expected new-keys packet from server"));
5664         crStop(0);
5665     }
5666     ssh->incoming_data_size = 0;       /* start counting from here */
5667
5668     /*
5669      * We've seen server NEWKEYS, so create and initialise
5670      * server-to-client session keys.
5671      */
5672     if (ssh->sc_cipher_ctx)
5673         ssh->sccipher->free_context(ssh->sc_cipher_ctx);
5674     ssh->sccipher = s->sccipher_tobe;
5675     ssh->sc_cipher_ctx = ssh->sccipher->make_context();
5676
5677     if (ssh->sc_mac_ctx)
5678         ssh->scmac->free_context(ssh->sc_mac_ctx);
5679     ssh->scmac = s->scmac_tobe;
5680     ssh->sc_mac_ctx = ssh->scmac->make_context();
5681
5682     if (ssh->sc_comp_ctx)
5683         ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
5684     ssh->sccomp = s->sccomp_tobe;
5685     ssh->sc_comp_ctx = ssh->sccomp->decompress_init();
5686
5687     /*
5688      * Set IVs on server-to-client keys. Here we use the exchange
5689      * hash from the _first_ key exchange.
5690      */
5691     {
5692         unsigned char keyspace[40];
5693         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'D',keyspace);
5694         ssh->sccipher->setkey(ssh->sc_cipher_ctx, keyspace);
5695         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'B',keyspace);
5696         ssh->sccipher->setiv(ssh->sc_cipher_ctx, keyspace);
5697         ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'F',keyspace);
5698         ssh->scmac->setkey(ssh->sc_mac_ctx, keyspace);
5699     }
5700     logeventf(ssh, "Initialised %.200s server->client encryption",
5701               ssh->sccipher->text_name);
5702     logeventf(ssh, "Initialised %.200s server->client MAC algorithm",
5703               ssh->scmac->text_name);
5704     if (ssh->sccomp->text_name)
5705         logeventf(ssh, "Initialised %s decompression",
5706                   ssh->sccomp->text_name);
5707
5708     /*
5709      * Free key exchange data.
5710      */
5711     freebn(s->f);
5712     freebn(s->K);
5713     if (ssh->kex == &ssh_diffiehellman_gex) {
5714         freebn(s->g);
5715         freebn(s->p);
5716     }
5717
5718     /*
5719      * Key exchange is over. Loop straight back round if we have a
5720      * deferred rekey reason.
5721      */
5722     if (ssh->deferred_rekey_reason) {
5723         logevent(ssh->deferred_rekey_reason);
5724         pktin = NULL;
5725         ssh->deferred_rekey_reason = NULL;
5726         goto begin_key_exchange;
5727     }
5728
5729     /*
5730      * Otherwise, schedule a timer for our next rekey.
5731      */
5732     ssh->kex_in_progress = FALSE;
5733     ssh->last_rekey = GETTICKCOUNT();
5734     if (ssh->cfg.ssh_rekey_time != 0)
5735         ssh->next_rekey = schedule_timer(ssh->cfg.ssh_rekey_time*60*TICKSPERSEC,
5736                                          ssh2_timer, ssh);
5737
5738     /*
5739      * If this is the first key exchange phase, we must pass the
5740      * SSH2_MSG_NEWKEYS packet to the next layer, not because it
5741      * wants to see it but because it will need time to initialise
5742      * itself before it sees an actual packet. In subsequent key
5743      * exchange phases, we don't pass SSH2_MSG_NEWKEYS on, because
5744      * it would only confuse the layer above.
5745      */
5746     if (s->activated_authconn) {
5747         crReturn(0);
5748     }
5749     s->activated_authconn = TRUE;
5750
5751     /*
5752      * Now we're encrypting. Begin returning 1 to the protocol main
5753      * function so that other things can run on top of the
5754      * transport. If we ever see a KEXINIT, we must go back to the
5755      * start.
5756      *
5757      * We _also_ go back to the start if we see pktin==NULL and
5758      * inlen==-1, because this is a special signal meaning
5759      * `initiate client-driven rekey', and `in' contains a message
5760      * giving the reason for the rekey.
5761      */
5762     while (!((pktin && pktin->type == SSH2_MSG_KEXINIT) ||
5763              (!pktin && inlen == -1))) {
5764         wait_for_rekey:
5765         crReturn(1);
5766     }
5767     if (pktin) {
5768         logevent("Server initiated key re-exchange");
5769     } else {
5770         /*
5771          * Special case: if the server bug is set that doesn't
5772          * allow rekeying, we give a different log message and
5773          * continue waiting. (If such a server _initiates_ a rekey,
5774          * we process it anyway!)
5775          */
5776         if ((ssh->remote_bugs & BUG_SSH2_REKEY)) {
5777             logeventf(ssh, "Server bug prevents key re-exchange (%s)",
5778                       (char *)in);
5779             /* Reset the counters, so that at least this message doesn't
5780              * hit the event log _too_ often. */
5781             ssh->outgoing_data_size = 0;
5782             ssh->incoming_data_size = 0;
5783             if (ssh->cfg.ssh_rekey_time != 0) {
5784                 ssh->next_rekey =
5785                     schedule_timer(ssh->cfg.ssh_rekey_time*60*TICKSPERSEC,
5786                                    ssh2_timer, ssh);
5787             }
5788             goto wait_for_rekey;       /* this is utterly horrid */
5789         } else {
5790             logeventf(ssh, "Initiating key re-exchange (%s)", (char *)in);
5791         }
5792     }
5793     goto begin_key_exchange;
5794
5795     crFinish(1);
5796 }
5797
5798 /*
5799  * Add data to an SSH-2 channel output buffer.
5800  */
5801 static void ssh2_add_channel_data(struct ssh_channel *c, char *buf,
5802                                   int len)
5803 {
5804     bufchain_add(&c->v.v2.outbuffer, buf, len);
5805 }
5806
5807 /*
5808  * Attempt to send data on an SSH-2 channel.
5809  */
5810 static int ssh2_try_send(struct ssh_channel *c)
5811 {
5812     Ssh ssh = c->ssh;
5813     struct Packet *pktout;
5814
5815     while (c->v.v2.remwindow > 0 && bufchain_size(&c->v.v2.outbuffer) > 0) {
5816         int len;
5817         void *data;
5818         bufchain_prefix(&c->v.v2.outbuffer, &data, &len);
5819         if ((unsigned)len > c->v.v2.remwindow)
5820             len = c->v.v2.remwindow;
5821         if ((unsigned)len > c->v.v2.remmaxpkt)
5822             len = c->v.v2.remmaxpkt;
5823         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_DATA);
5824         ssh2_pkt_adduint32(pktout, c->remoteid);
5825         dont_log_data(ssh, pktout, PKTLOG_OMIT);
5826         ssh2_pkt_addstring_start(pktout);
5827         ssh2_pkt_addstring_data(pktout, data, len);
5828         end_log_omission(ssh, pktout);
5829         ssh2_pkt_send(ssh, pktout);
5830         bufchain_consume(&c->v.v2.outbuffer, len);
5831         c->v.v2.remwindow -= len;
5832     }
5833
5834     /*
5835      * After having sent as much data as we can, return the amount
5836      * still buffered.
5837      */
5838     return bufchain_size(&c->v.v2.outbuffer);
5839 }
5840
5841 static void ssh2_try_send_and_unthrottle(struct ssh_channel *c)
5842 {
5843     int bufsize;
5844     if (c->closes)
5845         return;                        /* don't send on closing channels */
5846     bufsize = ssh2_try_send(c);
5847     if (bufsize == 0) {
5848         switch (c->type) {
5849           case CHAN_MAINSESSION:
5850             /* stdin need not receive an unthrottle
5851              * notification since it will be polled */
5852             break;
5853           case CHAN_X11:
5854             x11_unthrottle(c->u.x11.s);
5855             break;
5856           case CHAN_AGENT:
5857             /* agent sockets are request/response and need no
5858              * buffer management */
5859             break;
5860           case CHAN_SOCKDATA:
5861             pfd_unthrottle(c->u.pfd.s);
5862             break;
5863         }
5864     }
5865 }
5866
5867 /*
5868  * Potentially enlarge the window on an SSH-2 channel.
5869  */
5870 static void ssh2_set_window(struct ssh_channel *c, unsigned newwin)
5871 {
5872     Ssh ssh = c->ssh;
5873
5874     /*
5875      * Never send WINDOW_ADJUST for a channel that the remote side
5876      * already thinks it's closed; there's no point, since it won't
5877      * be sending any more data anyway.
5878      */
5879     if (c->closes != 0)
5880         return;
5881
5882     /*
5883      * Only send a WINDOW_ADJUST if there's significantly more window
5884      * available than the other end thinks there is.  This saves us
5885      * sending a WINDOW_ADJUST for every character in a shell session.
5886      *
5887      * "Significant" is arbitrarily defined as half the window size.
5888      */
5889     if (newwin > c->v.v2.locwindow * 2) {
5890         struct Packet *pktout;
5891
5892         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
5893         ssh2_pkt_adduint32(pktout, c->remoteid);
5894         ssh2_pkt_adduint32(pktout, newwin - c->v.v2.locwindow);
5895         ssh2_pkt_send(ssh, pktout);
5896         c->v.v2.locwindow = newwin;
5897     }
5898 }
5899
5900 static void ssh2_msg_channel_window_adjust(Ssh ssh, struct Packet *pktin)
5901 {
5902     unsigned i = ssh_pkt_getuint32(pktin);
5903     struct ssh_channel *c;
5904     c = find234(ssh->channels, &i, ssh_channelfind);
5905     if (c && !c->closes) {
5906         c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
5907         ssh2_try_send_and_unthrottle(c);
5908     }
5909 }
5910
5911 static void ssh2_msg_channel_data(Ssh ssh, struct Packet *pktin)
5912 {
5913     char *data;
5914     int length;
5915     unsigned i = ssh_pkt_getuint32(pktin);
5916     struct ssh_channel *c;
5917     c = find234(ssh->channels, &i, ssh_channelfind);
5918     if (!c)
5919         return;                        /* nonexistent channel */
5920     if (pktin->type == SSH2_MSG_CHANNEL_EXTENDED_DATA &&
5921         ssh_pkt_getuint32(pktin) != SSH2_EXTENDED_DATA_STDERR)
5922         return;                        /* extended but not stderr */
5923     ssh_pkt_getstring(pktin, &data, &length);
5924     if (data) {
5925         int bufsize = 0;
5926         c->v.v2.locwindow -= length;
5927         switch (c->type) {
5928           case CHAN_MAINSESSION:
5929             bufsize =
5930                 from_backend(ssh->frontend, pktin->type ==
5931                              SSH2_MSG_CHANNEL_EXTENDED_DATA,
5932                              data, length);
5933             break;
5934           case CHAN_X11:
5935             bufsize = x11_send(c->u.x11.s, data, length);
5936             break;
5937           case CHAN_SOCKDATA:
5938             bufsize = pfd_send(c->u.pfd.s, data, length);
5939             break;
5940           case CHAN_AGENT:
5941             while (length > 0) {
5942                 if (c->u.a.lensofar < 4) {
5943                     unsigned int l = min(4 - c->u.a.lensofar, length);
5944                     memcpy(c->u.a.msglen + c->u.a.lensofar,
5945                            data, l);
5946                     data += l;
5947                     length -= l;
5948                     c->u.a.lensofar += l;
5949                 }
5950                 if (c->u.a.lensofar == 4) {
5951                     c->u.a.totallen =
5952                         4 + GET_32BIT(c->u.a.msglen);
5953                     c->u.a.message = snewn(c->u.a.totallen,
5954                                            unsigned char);
5955                     memcpy(c->u.a.message, c->u.a.msglen, 4);
5956                 }
5957                 if (c->u.a.lensofar >= 4 && length > 0) {
5958                     unsigned int l =
5959                         min(c->u.a.totallen - c->u.a.lensofar,
5960                             length);
5961                     memcpy(c->u.a.message + c->u.a.lensofar,
5962                            data, l);
5963                     data += l;
5964                     length -= l;
5965                     c->u.a.lensofar += l;
5966                 }
5967                 if (c->u.a.lensofar == c->u.a.totallen) {
5968                     void *reply;
5969                     int replylen;
5970                     if (agent_query(c->u.a.message,
5971                                     c->u.a.totallen,
5972                                     &reply, &replylen,
5973                                     ssh_agentf_callback, c))
5974                         ssh_agentf_callback(c, reply, replylen);
5975                     sfree(c->u.a.message);
5976                     c->u.a.lensofar = 0;
5977                 }
5978             }
5979             bufsize = 0;
5980             break;
5981         }
5982         /*
5983          * If we are not buffering too much data,
5984          * enlarge the window again at the remote side.
5985          */
5986         if (bufsize < OUR_V2_WINSIZE)
5987             ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
5988     }
5989 }
5990
5991 static void ssh2_msg_channel_eof(Ssh ssh, struct Packet *pktin)
5992 {
5993     unsigned i = ssh_pkt_getuint32(pktin);
5994     struct ssh_channel *c;
5995
5996     c = find234(ssh->channels, &i, ssh_channelfind);
5997     if (!c)
5998         return;                        /* nonexistent channel */
5999
6000     if (c->type == CHAN_X11) {
6001         /*
6002          * Remote EOF on an X11 channel means we should
6003          * wrap up and close the channel ourselves.
6004          */
6005         x11_close(c->u.x11.s);
6006         sshfwd_close(c);
6007     } else if (c->type == CHAN_AGENT) {
6008         sshfwd_close(c);
6009     } else if (c->type == CHAN_SOCKDATA) {
6010         pfd_close(c->u.pfd.s);
6011         sshfwd_close(c);
6012     }
6013 }
6014
6015 static void ssh2_msg_channel_close(Ssh ssh, struct Packet *pktin)
6016 {
6017     unsigned i = ssh_pkt_getuint32(pktin);
6018     struct ssh_channel *c;
6019     struct Packet *pktout;
6020
6021     c = find234(ssh->channels, &i, ssh_channelfind);
6022     if (!c || c->halfopen) {
6023         bombout(("Received CHANNEL_CLOSE for %s channel %d\n",
6024                  c ? "half-open" : "nonexistent", i));
6025         return;
6026     }
6027     /* Do pre-close processing on the channel. */
6028     switch (c->type) {
6029       case CHAN_MAINSESSION:
6030         ssh->mainchan = NULL;
6031         update_specials_menu(ssh->frontend);
6032         break;
6033       case CHAN_X11:
6034         if (c->u.x11.s != NULL)
6035             x11_close(c->u.x11.s);
6036         sshfwd_close(c);
6037         break;
6038       case CHAN_AGENT:
6039         sshfwd_close(c);
6040         break;
6041       case CHAN_SOCKDATA:
6042         if (c->u.pfd.s != NULL)
6043             pfd_close(c->u.pfd.s);
6044         sshfwd_close(c);
6045         break;
6046     }
6047     if (c->closes == 0) {
6048         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE);
6049         ssh2_pkt_adduint32(pktout, c->remoteid);
6050         ssh2_pkt_send(ssh, pktout);
6051     }
6052     del234(ssh->channels, c);
6053     bufchain_clear(&c->v.v2.outbuffer);
6054     sfree(c);
6055
6056     /*
6057      * See if that was the last channel left open.
6058      * (This is only our termination condition if we're
6059      * not running in -N mode.)
6060      */
6061     if (!ssh->cfg.ssh_no_shell && count234(ssh->channels) == 0) {
6062         /*
6063          * We used to send SSH_MSG_DISCONNECT here,
6064          * because I'd believed that _every_ conforming
6065          * SSH-2 connection had to end with a disconnect
6066          * being sent by at least one side; apparently
6067          * I was wrong and it's perfectly OK to
6068          * unceremoniously slam the connection shut
6069          * when you're done, and indeed OpenSSH feels
6070          * this is more polite than sending a
6071          * DISCONNECT. So now we don't.
6072          */
6073         ssh_disconnect(ssh, "All channels closed", NULL, 0, TRUE);
6074     }
6075 }
6076
6077 static void ssh2_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin)
6078 {
6079     unsigned i = ssh_pkt_getuint32(pktin);
6080     struct ssh_channel *c;
6081     struct Packet *pktout;
6082
6083     c = find234(ssh->channels, &i, ssh_channelfind);
6084     if (!c)
6085         return;                        /* nonexistent channel */
6086     if (c->type != CHAN_SOCKDATA_DORMANT)
6087         return;                        /* dunno why they're confirming this */
6088     c->remoteid = ssh_pkt_getuint32(pktin);
6089     c->halfopen = FALSE;
6090     c->type = CHAN_SOCKDATA;
6091     c->v.v2.remwindow = ssh_pkt_getuint32(pktin);
6092     c->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
6093     if (c->u.pfd.s)
6094         pfd_confirm(c->u.pfd.s);
6095     if (c->closes) {
6096         /*
6097          * We have a pending close on this channel,
6098          * which we decided on before the server acked
6099          * the channel open. So now we know the
6100          * remoteid, we can close it again.
6101          */
6102         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE);
6103         ssh2_pkt_adduint32(pktout, c->remoteid);
6104         ssh2_pkt_send(ssh, pktout);
6105     }
6106 }
6107
6108 static void ssh2_msg_channel_open_failure(Ssh ssh, struct Packet *pktin)
6109 {
6110     static const char *const reasons[] = {
6111         "<unknown reason code>",
6112             "Administratively prohibited",
6113             "Connect failed",
6114             "Unknown channel type",
6115             "Resource shortage",
6116     };
6117     unsigned i = ssh_pkt_getuint32(pktin);
6118     unsigned reason_code;
6119     char *reason_string;
6120     int reason_length;
6121     struct ssh_channel *c;
6122     c = find234(ssh->channels, &i, ssh_channelfind);
6123     if (!c)
6124         return;                        /* nonexistent channel */
6125     if (c->type != CHAN_SOCKDATA_DORMANT)
6126         return;                        /* dunno why they're failing this */
6127
6128     reason_code = ssh_pkt_getuint32(pktin);
6129     if (reason_code >= lenof(reasons))
6130         reason_code = 0; /* ensure reasons[reason_code] in range */
6131     ssh_pkt_getstring(pktin, &reason_string, &reason_length);
6132     logeventf(ssh, "Forwarded connection refused by server: %s [%.*s]",
6133               reasons[reason_code], reason_length, reason_string);
6134
6135     pfd_close(c->u.pfd.s);
6136
6137     del234(ssh->channels, c);
6138     sfree(c);
6139 }
6140
6141 static void ssh2_msg_channel_request(Ssh ssh, struct Packet *pktin)
6142 {
6143     unsigned localid;
6144     char *type;
6145     int typelen, want_reply;
6146     int reply = SSH2_MSG_CHANNEL_FAILURE; /* default */
6147     struct ssh_channel *c;
6148     struct Packet *pktout;
6149
6150     localid = ssh_pkt_getuint32(pktin);
6151     ssh_pkt_getstring(pktin, &type, &typelen);
6152     want_reply = ssh2_pkt_getbool(pktin);
6153
6154     /*
6155      * First, check that the channel exists. Otherwise,
6156      * we can instantly disconnect with a rude message.
6157      */
6158     c = find234(ssh->channels, &localid, ssh_channelfind);
6159     if (!c) {
6160         char *buf = dupprintf("Received channel request for nonexistent"
6161                               " channel %d", localid);
6162         ssh_disconnect(ssh, NULL, buf, SSH2_DISCONNECT_PROTOCOL_ERROR, FALSE);
6163         sfree(buf);
6164         return;
6165     }
6166
6167     /*
6168      * Having got the channel number, we now look at
6169      * the request type string to see if it's something
6170      * we recognise.
6171      */
6172     if (c == ssh->mainchan) {
6173         /*
6174          * We recognise "exit-status" and "exit-signal" on
6175          * the primary channel.
6176          */
6177         if (typelen == 11 &&
6178             !memcmp(type, "exit-status", 11)) {
6179
6180             ssh->exitcode = ssh_pkt_getuint32(pktin);
6181             logeventf(ssh, "Server sent command exit status %d",
6182                       ssh->exitcode);
6183             reply = SSH2_MSG_CHANNEL_SUCCESS;
6184
6185         } else if (typelen == 11 &&
6186                    !memcmp(type, "exit-signal", 11)) {
6187
6188             int is_plausible = TRUE, is_int = FALSE;
6189             char *fmt_sig = "", *fmt_msg = "";
6190             char *msg;
6191             int msglen = 0, core = FALSE;
6192             /* ICK: older versions of OpenSSH (e.g. 3.4p1)
6193              * provide an `int' for the signal, despite its
6194              * having been a `string' in the drafts since at
6195              * least 2001. (Fixed in session.c 1.147.) Try to
6196              * infer which we can safely parse it as. */
6197             {
6198                 unsigned char *p = pktin->body +
6199                     pktin->savedpos;
6200                 long len = pktin->length - pktin->savedpos;
6201                 unsigned long num = GET_32BIT(p); /* what is it? */
6202                 /* If it's 0, it hardly matters; assume string */
6203                 if (num == 0) {
6204                     is_int = FALSE;
6205                 } else {
6206                     int maybe_int = FALSE, maybe_str = FALSE;
6207 #define CHECK_HYPOTHESIS(offset, result) \
6208     do { \
6209         long q = offset; \
6210         if (q >= 0 && q+4 <= len) { \
6211             q = q + 4 + GET_32BIT(p+q); \
6212             if (q >= 0 && q+4 <= len && \
6213                     ((q = q + 4 + GET_32BIT(p+q))!= 0) && q == len) \
6214                 result = TRUE; \
6215         } \
6216     } while(0)
6217                     CHECK_HYPOTHESIS(4+1, maybe_int);
6218                     CHECK_HYPOTHESIS(4+num+1, maybe_str);
6219 #undef CHECK_HYPOTHESIS
6220                     if (maybe_int && !maybe_str)
6221                         is_int = TRUE;
6222                     else if (!maybe_int && maybe_str)
6223                         is_int = FALSE;
6224                     else
6225                         /* Crikey. Either or neither. Panic. */
6226                         is_plausible = FALSE;
6227                 }
6228             }
6229             if (is_plausible) {
6230                 if (is_int) {
6231                     /* Old non-standard OpenSSH. */
6232                     int signum = ssh_pkt_getuint32(pktin);
6233                     fmt_sig = dupprintf(" %d", signum);
6234                 } else {
6235                     /* As per the drafts. */
6236                     char *sig;
6237                     int siglen;
6238                     ssh_pkt_getstring(pktin, &sig, &siglen);
6239                     /* Signal name isn't supposed to be blank, but
6240                      * let's cope gracefully if it is. */
6241                     if (siglen) {
6242                         fmt_sig = dupprintf(" \"%.*s\"",
6243                                             siglen, sig);
6244                     }
6245                 }
6246                 core = ssh2_pkt_getbool(pktin);
6247                 ssh_pkt_getstring(pktin, &msg, &msglen);
6248                 if (msglen) {
6249                     fmt_msg = dupprintf(" (\"%.*s\")", msglen, msg);
6250                 }
6251                 /* ignore lang tag */
6252             } /* else don't attempt to parse */
6253             logeventf(ssh, "Server exited on signal%s%s%s",
6254                       fmt_sig, core ? " (core dumped)" : "",
6255                       fmt_msg);
6256             if (*fmt_sig) sfree(fmt_sig);
6257             if (*fmt_msg) sfree(fmt_msg);
6258             reply = SSH2_MSG_CHANNEL_SUCCESS;
6259
6260         }
6261     } else {
6262         /*
6263          * This is a channel request we don't know
6264          * about, so we now either ignore the request
6265          * or respond with CHANNEL_FAILURE, depending
6266          * on want_reply.
6267          */
6268         reply = SSH2_MSG_CHANNEL_FAILURE;
6269     }
6270     if (want_reply) {
6271         pktout = ssh2_pkt_init(reply);
6272         ssh2_pkt_adduint32(pktout, c->remoteid);
6273         ssh2_pkt_send(ssh, pktout);
6274     }
6275 }
6276
6277 static void ssh2_msg_global_request(Ssh ssh, struct Packet *pktin)
6278 {
6279     char *type;
6280     int typelen, want_reply;
6281     struct Packet *pktout;
6282
6283     ssh_pkt_getstring(pktin, &type, &typelen);
6284     want_reply = ssh2_pkt_getbool(pktin);
6285
6286     /*
6287      * We currently don't support any global requests
6288      * at all, so we either ignore the request or
6289      * respond with REQUEST_FAILURE, depending on
6290      * want_reply.
6291      */
6292     if (want_reply) {
6293         pktout = ssh2_pkt_init(SSH2_MSG_REQUEST_FAILURE);
6294         ssh2_pkt_send(ssh, pktout);
6295     }
6296 }
6297
6298 static void ssh2_msg_channel_open(Ssh ssh, struct Packet *pktin)
6299 {
6300     char *type;
6301     int typelen;
6302     char *peeraddr;
6303     int peeraddrlen;
6304     int peerport;
6305     char *error = NULL;
6306     struct ssh_channel *c;
6307     unsigned remid, winsize, pktsize;
6308     struct Packet *pktout;
6309
6310     ssh_pkt_getstring(pktin, &type, &typelen);
6311     c = snew(struct ssh_channel);
6312     c->ssh = ssh;
6313
6314     remid = ssh_pkt_getuint32(pktin);
6315     winsize = ssh_pkt_getuint32(pktin);
6316     pktsize = ssh_pkt_getuint32(pktin);
6317
6318     if (typelen == 3 && !memcmp(type, "x11", 3)) {
6319         char *addrstr;
6320
6321         ssh_pkt_getstring(pktin, &peeraddr, &peeraddrlen);
6322         addrstr = snewn(peeraddrlen+1, char);
6323         memcpy(addrstr, peeraddr, peeraddrlen);
6324         addrstr[peeraddrlen] = '\0';
6325         peerport = ssh_pkt_getuint32(pktin);
6326
6327         logeventf(ssh, "Received X11 connect request from %s:%d",
6328                   addrstr, peerport);
6329
6330         if (!ssh->X11_fwd_enabled)
6331             error = "X11 forwarding is not enabled";
6332         else if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
6333                           ssh->x11auth, addrstr, peerport,
6334                           &ssh->cfg) != NULL) {
6335             error = "Unable to open an X11 connection";
6336         } else {
6337             logevent("Opening X11 forward connection succeeded");
6338             c->type = CHAN_X11;
6339         }
6340
6341         sfree(addrstr);
6342     } else if (typelen == 15 &&
6343                !memcmp(type, "forwarded-tcpip", 15)) {
6344         struct ssh_rportfwd pf, *realpf;
6345         char *dummy;
6346         int dummylen;
6347         ssh_pkt_getstring(pktin, &dummy, &dummylen);/* skip address */
6348         pf.sport = ssh_pkt_getuint32(pktin);
6349         ssh_pkt_getstring(pktin, &peeraddr, &peeraddrlen);
6350         peerport = ssh_pkt_getuint32(pktin);
6351         realpf = find234(ssh->rportfwds, &pf, NULL);
6352         logeventf(ssh, "Received remote port %d open request "
6353                   "from %s:%d", pf.sport, peeraddr, peerport);
6354         if (realpf == NULL) {
6355             error = "Remote port is not recognised";
6356         } else {
6357             const char *e = pfd_newconnect(&c->u.pfd.s,
6358                                            realpf->dhost,
6359                                            realpf->dport, c,
6360                                            &ssh->cfg,
6361                                            realpf->pfrec->addressfamily);
6362             logeventf(ssh, "Attempting to forward remote port to "
6363                       "%s:%d", realpf->dhost, realpf->dport);
6364             if (e != NULL) {
6365                 logeventf(ssh, "Port open failed: %s", e);
6366                 error = "Port open failed";
6367             } else {
6368                 logevent("Forwarded port opened successfully");
6369                 c->type = CHAN_SOCKDATA;
6370             }
6371         }
6372     } else if (typelen == 22 &&
6373                !memcmp(type, "auth-agent@openssh.com", 22)) {
6374         if (!ssh->agentfwd_enabled)
6375             error = "Agent forwarding is not enabled";
6376         else {
6377             c->type = CHAN_AGENT;       /* identify channel type */
6378             c->u.a.lensofar = 0;
6379         }
6380     } else {
6381         error = "Unsupported channel type requested";
6382     }
6383
6384     c->remoteid = remid;
6385     c->halfopen = FALSE;
6386     if (error) {
6387         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_FAILURE);
6388         ssh2_pkt_adduint32(pktout, c->remoteid);
6389         ssh2_pkt_adduint32(pktout, SSH2_OPEN_CONNECT_FAILED);
6390         ssh2_pkt_addstring(pktout, error);
6391         ssh2_pkt_addstring(pktout, "en");       /* language tag */
6392         ssh2_pkt_send(ssh, pktout);
6393         logeventf(ssh, "Rejected channel open: %s", error);
6394         sfree(c);
6395     } else {
6396         c->localid = alloc_channel_id(ssh);
6397         c->closes = 0;
6398         c->v.v2.locwindow = OUR_V2_WINSIZE;
6399         c->v.v2.remwindow = winsize;
6400         c->v.v2.remmaxpkt = pktsize;
6401         bufchain_init(&c->v.v2.outbuffer);
6402         add234(ssh->channels, c);
6403         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
6404         ssh2_pkt_adduint32(pktout, c->remoteid);
6405         ssh2_pkt_adduint32(pktout, c->localid);
6406         ssh2_pkt_adduint32(pktout, c->v.v2.locwindow);
6407         ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT);      /* our max pkt size */
6408         ssh2_pkt_send(ssh, pktout);
6409     }
6410 }
6411
6412 /*
6413  * Buffer banner messages for later display at some convenient point.
6414  */
6415 static void ssh2_msg_userauth_banner(Ssh ssh, struct Packet *pktin)
6416 {
6417     /* Arbitrary limit to prevent unbounded inflation of buffer */
6418     if (bufchain_size(&ssh->banner) <= 131072) {
6419         char *banner = NULL;
6420         int size = 0;
6421         ssh_pkt_getstring(pktin, &banner, &size);
6422         if (banner)
6423             bufchain_add(&ssh->banner, banner, size);
6424     }
6425 }
6426
6427 /* Helper function to deal with sending tty modes for "pty-req" */
6428 static void ssh2_send_ttymode(void *data, char *mode, char *val)
6429 {
6430     struct Packet *pktout = (struct Packet *)data;
6431     int i = 0;
6432     unsigned int arg = 0;
6433     while (strcmp(mode, ssh_ttymodes[i].mode) != 0) i++;
6434     if (i == lenof(ssh_ttymodes)) return;
6435     switch (ssh_ttymodes[i].type) {
6436       case TTY_OP_CHAR:
6437         arg = ssh_tty_parse_specchar(val);
6438         break;
6439       case TTY_OP_BOOL:
6440         arg = ssh_tty_parse_boolean(val);
6441         break;
6442     }
6443     ssh2_pkt_addbyte(pktout, ssh_ttymodes[i].opcode);
6444     ssh2_pkt_adduint32(pktout, arg);
6445 }
6446
6447 /*
6448  * Handle the SSH-2 userauth and connection layers.
6449  */
6450 static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
6451                              struct Packet *pktin)
6452 {
6453     struct do_ssh2_authconn_state {
6454         enum {
6455             AUTH_INVALID, AUTH_PUBLICKEY_AGENT, AUTH_PUBLICKEY_FILE,
6456                 AUTH_PASSWORD,
6457                 AUTH_KEYBOARD_INTERACTIVE
6458         } method;
6459         enum {
6460             AUTH_TYPE_NONE,
6461                 AUTH_TYPE_PUBLICKEY,
6462                 AUTH_TYPE_PUBLICKEY_OFFER_LOUD,
6463                 AUTH_TYPE_PUBLICKEY_OFFER_QUIET,
6464                 AUTH_TYPE_PASSWORD,
6465                 AUTH_TYPE_KEYBOARD_INTERACTIVE,
6466                 AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
6467         } type;
6468         int done_service_req;
6469         int gotit, need_pw, can_pubkey, can_passwd, can_keyb_inter;
6470         int tried_pubkey_config, tried_agent;
6471         int kbd_inter_running, kbd_inter_refused;
6472         int we_are_in;
6473         int num_prompts, curr_prompt, echo;
6474         char username[100];
6475         int got_username;
6476         char pwprompt[512];
6477         char password[100];
6478         void *publickey_blob;
6479         int publickey_bloblen;
6480         unsigned char request[5], *response, *p;
6481         int responselen;
6482         int keyi, nkeys;
6483         int authed;
6484         char *pkblob, *alg, *commentp;
6485         int pklen, alglen, commentlen;
6486         int siglen, retlen, len;
6487         char *q, *agentreq, *ret;
6488         int try_send;
6489         int num_env, env_left, env_ok;
6490         struct Packet *pktout;
6491     };
6492     crState(do_ssh2_authconn_state);
6493
6494     crBegin(ssh->do_ssh2_authconn_crstate);
6495
6496     s->done_service_req = FALSE;
6497     s->we_are_in = FALSE;
6498     if (!ssh->cfg.ssh_no_userauth) {
6499         /*
6500          * Request userauth protocol, and await a response to it.
6501          */
6502         s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST);
6503         ssh2_pkt_addstring(s->pktout, "ssh-userauth");
6504         ssh2_pkt_send(ssh, s->pktout);
6505         crWaitUntilV(pktin);
6506         if (pktin->type == SSH2_MSG_SERVICE_ACCEPT)
6507             s->done_service_req = TRUE;
6508     }
6509     if (!s->done_service_req) {
6510         /*
6511          * Request connection protocol directly, without authentication.
6512          */
6513         s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST);
6514         ssh2_pkt_addstring(s->pktout, "ssh-connection");
6515         ssh2_pkt_send(ssh, s->pktout);
6516         crWaitUntilV(pktin);
6517         if (pktin->type == SSH2_MSG_SERVICE_ACCEPT) {
6518             s->we_are_in = TRUE; /* no auth required */
6519         } else {
6520             bombout(("Server refused service request"));
6521             crStopV;
6522         }
6523     }
6524
6525     /*
6526      * We repeat this whole loop, including the username prompt,
6527      * until we manage a successful authentication. If the user
6528      * types the wrong _password_, they can be sent back to the
6529      * beginning to try another username, if this is configured on.
6530      * (If they specify a username in the config, they are never
6531      * asked, even if they do give a wrong password.)
6532      *
6533      * I think this best serves the needs of
6534      *
6535      *  - the people who have no configuration, no keys, and just
6536      *    want to try repeated (username,password) pairs until they
6537      *    type both correctly
6538      *
6539      *  - people who have keys and configuration but occasionally
6540      *    need to fall back to passwords
6541      *
6542      *  - people with a key held in Pageant, who might not have
6543      *    logged in to a particular machine before; so they want to
6544      *    type a username, and then _either_ their key will be
6545      *    accepted, _or_ they will type a password. If they mistype
6546      *    the username they will want to be able to get back and
6547      *    retype it!
6548      */
6549     s->username[0] = '\0';
6550     s->got_username = FALSE;
6551     bufchain_init(&ssh->banner);
6552     ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] =
6553         ssh2_msg_userauth_banner;
6554     while (!s->we_are_in) {
6555         /*
6556          * Get a username.
6557          */
6558         if (s->got_username && !ssh->cfg.change_username) {
6559             /*
6560              * We got a username last time round this loop, and
6561              * with change_username turned off we don't try to get
6562              * it again.
6563              */
6564         } else if (!*ssh->cfg.username) {
6565             if (ssh_get_line && !ssh_getline_pw_only) {
6566                 if (!ssh_get_line("login as: ",
6567                                   s->username, sizeof(s->username), FALSE)) {
6568                     /*
6569                      * get_line failed to get a username.
6570                      * Terminate.
6571                      */
6572                     ssh_disconnect(ssh, "No username provided", NULL, 0, TRUE);
6573                     crStopV;
6574                 }
6575             } else {
6576                 int ret;               /* need not be saved across crReturn */
6577                 c_write_str(ssh, "login as: ");
6578                 ssh->send_ok = 1;
6579                 setup_userpass_input(ssh, s->username, sizeof(s->username), 1);
6580                 do {
6581                     crWaitUntilV(!pktin);
6582                     ret = process_userpass_input(ssh, in, inlen);
6583                 } while (ret == 0);
6584                 if (ret < 0)
6585                     cleanup_exit(0);
6586                 c_write_str(ssh, "\r\n");
6587             }
6588             s->username[strcspn(s->username, "\n\r")] = '\0';
6589         } else {
6590             char *stuff;
6591             strncpy(s->username, ssh->cfg.username, sizeof(s->username));
6592             s->username[sizeof(s->username)-1] = '\0';
6593             if ((flags & FLAG_VERBOSE) || (flags & FLAG_INTERACTIVE)) {
6594                 stuff = dupprintf("Using username \"%s\".\r\n", s->username);
6595                 c_write_str(ssh, stuff);
6596                 sfree(stuff);
6597             }
6598         }
6599         s->got_username = TRUE;
6600
6601         /*
6602          * Send an authentication request using method "none": (a)
6603          * just in case it succeeds, and (b) so that we know what
6604          * authentication methods we can usefully try next.
6605          */
6606         ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
6607
6608         s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
6609         ssh2_pkt_addstring(s->pktout, s->username);
6610         ssh2_pkt_addstring(s->pktout, "ssh-connection");/* service requested */
6611         ssh2_pkt_addstring(s->pktout, "none");    /* method */
6612         ssh2_pkt_send(ssh, s->pktout);
6613         s->type = AUTH_TYPE_NONE;
6614         s->gotit = FALSE;
6615         s->we_are_in = FALSE;
6616
6617         s->tried_pubkey_config = FALSE;
6618         s->tried_agent = FALSE;
6619         s->kbd_inter_running = FALSE;
6620         s->kbd_inter_refused = FALSE;
6621         /* Load the pub half of ssh->cfg.keyfile so we notice if it's in Pageant */
6622         if (!filename_is_null(ssh->cfg.keyfile)) {
6623             int keytype;
6624             logeventf(ssh, "Reading private key file \"%.150s\"",
6625                       filename_to_str(&ssh->cfg.keyfile));
6626             keytype = key_type(&ssh->cfg.keyfile);
6627             if (keytype == SSH_KEYTYPE_SSH2) {
6628                 s->publickey_blob =
6629                     ssh2_userkey_loadpub(&ssh->cfg.keyfile, NULL,
6630                                          &s->publickey_bloblen, NULL);
6631             } else {
6632                 char *msgbuf;
6633                 logeventf(ssh, "Unable to use this key file (%s)",
6634                           key_type_to_str(keytype));
6635                 msgbuf = dupprintf("Unable to use key file \"%.150s\""
6636                                    " (%s)\r\n",
6637                                    filename_to_str(&ssh->cfg.keyfile),
6638                                    key_type_to_str(keytype));
6639                 c_write_str(ssh, msgbuf);
6640                 sfree(msgbuf);
6641                 s->publickey_blob = NULL;
6642             }
6643         } else
6644             s->publickey_blob = NULL;
6645
6646         while (1) {
6647             /*
6648              * Wait for the result of the last authentication request.
6649              */
6650             if (!s->gotit)
6651                 crWaitUntilV(pktin);
6652             /*
6653              * Now is a convenient point to spew any banner material
6654              * that we've accumulated. (This should ensure that when
6655              * we exit the auth loop, we haven't any left to deal
6656              * with.)
6657              */
6658             {
6659                 int size = bufchain_size(&ssh->banner);
6660                 /*
6661                  * Don't show the banner if we're operating in
6662                  * non-verbose non-interactive mode. (It's probably
6663                  * a script, which means nobody will read the
6664                  * banner _anyway_, and moreover the printing of
6665                  * the banner will screw up processing on the
6666                  * output of (say) plink.)
6667                  */
6668                 if (size && (flags & (FLAG_VERBOSE | FLAG_INTERACTIVE))) {
6669                     char *banner = snewn(size, char);
6670                     bufchain_fetch(&ssh->banner, banner, size);
6671                     c_write_untrusted(ssh, banner, size);
6672                     sfree(banner);
6673                 }
6674                 bufchain_clear(&ssh->banner);
6675             }
6676             if (pktin->type == SSH2_MSG_USERAUTH_SUCCESS) {
6677                 logevent("Access granted");
6678                 s->we_are_in = TRUE;
6679                 break;
6680             }
6681
6682             if (s->kbd_inter_running &&
6683                 pktin->type == SSH2_MSG_USERAUTH_INFO_REQUEST) {
6684                 /*
6685                  * This is either a further set-of-prompts packet
6686                  * in keyboard-interactive authentication, or it's
6687                  * the same one and we came back here with `gotit'
6688                  * set. In the former case, we must reset the
6689                  * curr_prompt variable.
6690                  */
6691                 if (!s->gotit)
6692                     s->curr_prompt = 0;
6693             } else if (pktin->type == SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ) {
6694                 /* FIXME: perhaps we should support this? */
6695                 bombout(("PASSWD_CHANGEREQ not yet supported"));
6696                 crStopV;
6697             } else if (pktin->type != SSH2_MSG_USERAUTH_FAILURE) {
6698                 bombout(("Strange packet received during authentication: type %d",
6699                          pktin->type));
6700                 crStopV;
6701             }
6702
6703             s->gotit = FALSE;
6704
6705             /*
6706              * OK, we're now sitting on a USERAUTH_FAILURE message, so
6707              * we can look at the string in it and know what we can
6708              * helpfully try next.
6709              */
6710             if (pktin->type == SSH2_MSG_USERAUTH_FAILURE) {
6711                 char *methods;
6712                 int methlen;
6713                 ssh_pkt_getstring(pktin, &methods, &methlen);
6714                 s->kbd_inter_running = FALSE;
6715                 if (!ssh2_pkt_getbool(pktin)) {
6716                     /*
6717                      * We have received an unequivocal Access
6718                      * Denied. This can translate to a variety of
6719                      * messages:
6720                      *
6721                      *  - if we'd just tried "none" authentication,
6722                      *    it's not worth printing anything at all
6723                      *
6724                      *  - if we'd just tried a public key _offer_,
6725                      *    the message should be "Server refused our
6726                      *    key" (or no message at all if the key
6727                      *    came from Pageant)
6728                      *
6729                      *  - if we'd just tried anything else, the
6730                      *    message really should be "Access denied".
6731                      *
6732                      * Additionally, if we'd just tried password
6733                      * authentication, we should break out of this
6734                      * whole loop so as to go back to the username
6735                      * prompt (iff we're configured to allow
6736                      * username change attempts).
6737                      */
6738                     if (s->type == AUTH_TYPE_NONE) {
6739                         /* do nothing */
6740                     } else if (s->type == AUTH_TYPE_PUBLICKEY_OFFER_LOUD ||
6741                                s->type == AUTH_TYPE_PUBLICKEY_OFFER_QUIET) {
6742                         if (s->type == AUTH_TYPE_PUBLICKEY_OFFER_LOUD)
6743                             c_write_str(ssh, "Server refused our key\r\n");
6744                         logevent("Server refused public key");
6745                     } else if (s->type==AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET) {
6746                         /* server declined keyboard-interactive; ignore */
6747                     } else {
6748                         c_write_str(ssh, "Access denied\r\n");
6749                         logevent("Access denied");
6750                         if (s->type == AUTH_TYPE_PASSWORD &&
6751                             ssh->cfg.change_username) {
6752                             /* XXX perhaps we should allow
6753                              * keyboard-interactive to do this too? */
6754                             s->we_are_in = FALSE;
6755                             break;
6756                         }
6757                     }
6758                 } else {
6759                     c_write_str(ssh, "Further authentication required\r\n");
6760                     logevent("Further authentication required");
6761                 }
6762
6763                 s->can_pubkey =
6764                     in_commasep_string("publickey", methods, methlen);
6765                 s->can_passwd =
6766                     in_commasep_string("password", methods, methlen);
6767                 s->can_keyb_inter = ssh->cfg.try_ki_auth &&
6768                     in_commasep_string("keyboard-interactive", methods, methlen);
6769             }
6770
6771             s->method = 0;
6772             ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
6773             s->need_pw = FALSE;
6774
6775             /*
6776              * Most password/passphrase prompts will be
6777              * non-echoing, so we set this to 0 by default.
6778              * Exception is that some keyboard-interactive prompts
6779              * can be echoing, in which case we'll set this to 1.
6780              */
6781             s->echo = 0;
6782
6783             if (!s->method && s->can_pubkey &&
6784                 agent_exists() && !s->tried_agent) {
6785                 /*
6786                  * Attempt public-key authentication using Pageant.
6787                  */
6788                 void *r;
6789                 s->authed = FALSE;
6790
6791                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
6792                 ssh->pkt_ctx |= SSH2_PKTCTX_PUBLICKEY;
6793
6794                 s->tried_agent = TRUE;
6795
6796                 logevent("Pageant is running. Requesting keys.");
6797
6798                 /* Request the keys held by the agent. */
6799                 PUT_32BIT(s->request, 1);
6800                 s->request[4] = SSH2_AGENTC_REQUEST_IDENTITIES;
6801                 if (!agent_query(s->request, 5, &r, &s->responselen,
6802                                  ssh_agent_callback, ssh)) {
6803                     do {
6804                         crReturnV;
6805                         if (pktin) {
6806                             bombout(("Unexpected data from server while"
6807                                      " waiting for agent response"));
6808                             crStopV;
6809                         }
6810                     } while (pktin || inlen > 0);
6811                     r = ssh->agent_response;
6812                     s->responselen = ssh->agent_response_len;
6813                 }
6814                 s->response = (unsigned char *) r;
6815                 if (s->response && s->responselen >= 5 &&
6816                     s->response[4] == SSH2_AGENT_IDENTITIES_ANSWER) {
6817                     s->p = s->response + 5;
6818                     s->nkeys = GET_32BIT(s->p);
6819                     s->p += 4;
6820                     logeventf(ssh, "Pageant has %d SSH-2 keys", s->nkeys);
6821                     for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) {
6822                         void *vret;
6823
6824                         logeventf(ssh, "Trying Pageant key #%d", s->keyi);
6825                         s->pklen = GET_32BIT(s->p);
6826                         s->p += 4;
6827                         if (s->publickey_blob &&
6828                             s->pklen == s->publickey_bloblen &&
6829                             !memcmp(s->p, s->publickey_blob,
6830                                     s->publickey_bloblen)) {
6831                             logevent("This key matches configured key file");
6832                             s->tried_pubkey_config = 1;
6833                         }
6834                         s->pkblob = (char *)s->p;
6835                         s->p += s->pklen;
6836                         s->alglen = GET_32BIT(s->pkblob);
6837                         s->alg = s->pkblob + 4;
6838                         s->commentlen = GET_32BIT(s->p);
6839                         s->p += 4;
6840                         s->commentp = (char *)s->p;
6841                         s->p += s->commentlen;
6842                         s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
6843                         ssh2_pkt_addstring(s->pktout, s->username);
6844                         ssh2_pkt_addstring(s->pktout, "ssh-connection");        /* service requested */
6845                         ssh2_pkt_addstring(s->pktout, "publickey");     /* method */
6846                         ssh2_pkt_addbool(s->pktout, FALSE);     /* no signature included */
6847                         ssh2_pkt_addstring_start(s->pktout);
6848                         ssh2_pkt_addstring_data(s->pktout, s->alg, s->alglen);
6849                         ssh2_pkt_addstring_start(s->pktout);
6850                         ssh2_pkt_addstring_data(s->pktout, s->pkblob, s->pklen);
6851                         ssh2_pkt_send(ssh, s->pktout);
6852
6853                         crWaitUntilV(pktin);
6854                         if (pktin->type != SSH2_MSG_USERAUTH_PK_OK) {
6855                             logevent("Key refused");
6856                             continue;
6857                         }
6858
6859                         if (flags & FLAG_VERBOSE) {
6860                             c_write_str(ssh, "Authenticating with "
6861                                         "public key \"");
6862                             c_write(ssh, s->commentp, s->commentlen);
6863                             c_write_str(ssh, "\" from agent\r\n");
6864                         }
6865
6866                         /*
6867                          * Server is willing to accept the key.
6868                          * Construct a SIGN_REQUEST.
6869                          */
6870                         s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
6871                         ssh2_pkt_addstring(s->pktout, s->username);
6872                         ssh2_pkt_addstring(s->pktout, "ssh-connection");        /* service requested */
6873                         ssh2_pkt_addstring(s->pktout, "publickey");     /* method */
6874                         ssh2_pkt_addbool(s->pktout, TRUE);
6875                         ssh2_pkt_addstring_start(s->pktout);
6876                         ssh2_pkt_addstring_data(s->pktout, s->alg, s->alglen);
6877                         ssh2_pkt_addstring_start(s->pktout);
6878                         ssh2_pkt_addstring_data(s->pktout, s->pkblob, s->pklen);
6879
6880                         s->siglen = s->pktout->length - 5 + 4 + 20;
6881                         if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)
6882                             s->siglen -= 4;
6883                         s->len = 1;       /* message type */
6884                         s->len += 4 + s->pklen; /* key blob */
6885                         s->len += 4 + s->siglen;        /* data to sign */
6886                         s->len += 4;      /* flags */
6887                         s->agentreq = snewn(4 + s->len, char);
6888                         PUT_32BIT(s->agentreq, s->len);
6889                         s->q = s->agentreq + 4;
6890                         *s->q++ = SSH2_AGENTC_SIGN_REQUEST;
6891                         PUT_32BIT(s->q, s->pklen);
6892                         s->q += 4;
6893                         memcpy(s->q, s->pkblob, s->pklen);
6894                         s->q += s->pklen;
6895                         PUT_32BIT(s->q, s->siglen);
6896                         s->q += 4;
6897                         /* Now the data to be signed... */
6898                         if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) {
6899                             PUT_32BIT(s->q, 20);
6900                             s->q += 4;
6901                         }
6902                         memcpy(s->q, ssh->v2_session_id, 20);
6903                         s->q += 20;
6904                         memcpy(s->q, s->pktout->data + 5,
6905                                s->pktout->length - 5);
6906                         s->q += s->pktout->length - 5;
6907                         /* And finally the (zero) flags word. */
6908                         PUT_32BIT(s->q, 0);
6909                         if (!agent_query(s->agentreq, s->len + 4,
6910                                          &vret, &s->retlen,
6911                                          ssh_agent_callback, ssh)) {
6912                             do {
6913                                 crReturnV;
6914                                 if (pktin) {
6915                                     bombout(("Unexpected data from server"
6916                                              " while waiting for agent"
6917                                              " response"));
6918                                     crStopV;
6919                                 }
6920                             } while (pktin || inlen > 0);
6921                             vret = ssh->agent_response;
6922                             s->retlen = ssh->agent_response_len;
6923                         }
6924                         s->ret = vret;
6925                         sfree(s->agentreq);
6926                         if (s->ret) {
6927                             if (s->ret[4] == SSH2_AGENT_SIGN_RESPONSE) {
6928                                 logevent("Sending Pageant's response");
6929                                 ssh2_add_sigblob(ssh, s->pktout,
6930                                                  s->pkblob, s->pklen,
6931                                                  s->ret + 9,
6932                                                  GET_32BIT(s->ret + 5));
6933                                 ssh2_pkt_send(ssh, s->pktout);
6934                                 s->authed = TRUE;
6935                                 break;
6936                             } else {
6937                                 logevent
6938                                     ("Pageant failed to answer challenge");
6939                                 sfree(s->ret);
6940                             }
6941                         }
6942                     }
6943                     if (s->authed)
6944                         continue;
6945                 }
6946                 sfree(s->response);
6947             }
6948
6949             if (!s->method && s->can_pubkey && s->publickey_blob
6950                 && !s->tried_pubkey_config) {
6951                 unsigned char *pub_blob;
6952                 char *algorithm, *comment;
6953                 int pub_blob_len;
6954
6955                 s->tried_pubkey_config = TRUE;
6956
6957                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
6958                 ssh->pkt_ctx |= SSH2_PKTCTX_PUBLICKEY;
6959
6960                 /*
6961                  * Try the public key supplied in the configuration.
6962                  *
6963                  * First, offer the public blob to see if the server is
6964                  * willing to accept it.
6965                  */
6966                 pub_blob =
6967                     (unsigned char *)ssh2_userkey_loadpub(&ssh->cfg.keyfile,
6968                                                           &algorithm,
6969                                                           &pub_blob_len,
6970                                                           NULL);
6971                 if (pub_blob) {
6972                     s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
6973                     ssh2_pkt_addstring(s->pktout, s->username);
6974                     ssh2_pkt_addstring(s->pktout, "ssh-connection");    /* service requested */
6975                     ssh2_pkt_addstring(s->pktout, "publickey"); /* method */
6976                     ssh2_pkt_addbool(s->pktout, FALSE); /* no signature included */
6977                     ssh2_pkt_addstring(s->pktout, algorithm);
6978                     ssh2_pkt_addstring_start(s->pktout);
6979                     ssh2_pkt_addstring_data(s->pktout, (char *)pub_blob,
6980                                             pub_blob_len);
6981                     ssh2_pkt_send(ssh, s->pktout);
6982                     logevent("Offered public key");
6983
6984                     crWaitUntilV(pktin);
6985                     if (pktin->type != SSH2_MSG_USERAUTH_PK_OK) {
6986                         s->gotit = TRUE;
6987                         s->type = AUTH_TYPE_PUBLICKEY_OFFER_LOUD;
6988                         continue;      /* key refused; give up on it */
6989                     }
6990
6991                     logevent("Offer of public key accepted");
6992                     /*
6993                      * Actually attempt a serious authentication using
6994                      * the key.
6995                      */
6996                     if (ssh2_userkey_encrypted(&ssh->cfg.keyfile, &comment)) {
6997                         sprintf(s->pwprompt,
6998                                 "Passphrase for key \"%.100s\": ",
6999                                 comment);
7000                         s->need_pw = TRUE;
7001                     } else {
7002                         s->need_pw = FALSE;
7003                     }
7004                     if (flags & FLAG_VERBOSE) {
7005                         c_write_str(ssh, "Authenticating with public key \"");
7006                         c_write_str(ssh, comment);
7007                         c_write_str(ssh, "\"\r\n");
7008                     }
7009                     s->method = AUTH_PUBLICKEY_FILE;
7010                 }
7011             }
7012
7013             if (!s->method && s->can_keyb_inter && !s->kbd_inter_refused &&
7014                 !s->kbd_inter_running) {
7015                 s->method = AUTH_KEYBOARD_INTERACTIVE;
7016                 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
7017
7018                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
7019                 ssh->pkt_ctx |= SSH2_PKTCTX_KBDINTER;
7020
7021                 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
7022                 ssh2_pkt_addstring(s->pktout, s->username);
7023                 ssh2_pkt_addstring(s->pktout, "ssh-connection");        /* service requested */
7024                 ssh2_pkt_addstring(s->pktout, "keyboard-interactive");  /* method */
7025                 ssh2_pkt_addstring(s->pktout, ""); /* lang */
7026                 ssh2_pkt_addstring(s->pktout, "");
7027                 ssh2_pkt_send(ssh, s->pktout);
7028
7029                 crWaitUntilV(pktin);
7030                 if (pktin->type != SSH2_MSG_USERAUTH_INFO_REQUEST) {
7031                     if (pktin->type == SSH2_MSG_USERAUTH_FAILURE)
7032                         s->gotit = TRUE;
7033                     logevent("Keyboard-interactive authentication refused");
7034                     s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET;
7035                     s->kbd_inter_refused = TRUE; /* don't try it again */
7036                     continue;
7037                 }
7038
7039                 c_write_str(ssh, "Using keyboard-interactive authentication.\r\n");
7040                 s->kbd_inter_running = TRUE;
7041                 s->curr_prompt = 0;
7042             }
7043
7044             if (s->kbd_inter_running) {
7045                 s->method = AUTH_KEYBOARD_INTERACTIVE;
7046                 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
7047
7048                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
7049                 ssh->pkt_ctx |= SSH2_PKTCTX_KBDINTER;
7050
7051                 if (s->curr_prompt == 0) {
7052                     /*
7053                      * We've got a fresh USERAUTH_INFO_REQUEST.
7054                      * Display header data, and start going through
7055                      * the prompts.
7056                      */
7057                     char *name, *inst, *lang;
7058                     int name_len, inst_len, lang_len;
7059
7060                     ssh_pkt_getstring(pktin, &name, &name_len);
7061                     ssh_pkt_getstring(pktin, &inst, &inst_len);
7062                     ssh_pkt_getstring(pktin, &lang, &lang_len);
7063                     if (name_len > 0) {
7064                         c_write_untrusted(ssh, name, name_len);
7065                         c_write_str(ssh, "\r\n");
7066                     }
7067                     if (inst_len > 0) {
7068                         c_write_untrusted(ssh, inst, inst_len);
7069                         c_write_str(ssh, "\r\n");
7070                     }
7071                     s->num_prompts = ssh_pkt_getuint32(pktin);
7072                 }
7073
7074                 /*
7075                  * If there are prompts remaining in the packet,
7076                  * display one and get a response.
7077                  */
7078                 if (s->curr_prompt < s->num_prompts) {
7079                     char *prompt;
7080                     int prompt_len;
7081
7082                     ssh_pkt_getstring(pktin, &prompt, &prompt_len);
7083                     if (prompt_len > 0) {
7084                         static const char trunc[] = "<prompt truncated>: ";
7085                         static const int prlen = sizeof(s->pwprompt) -
7086                                                  lenof(trunc);
7087                         if (prompt_len > prlen) {
7088                             memcpy(s->pwprompt, prompt, prlen);
7089                             strcpy(s->pwprompt + prlen, trunc);
7090                         } else {
7091                             memcpy(s->pwprompt, prompt, prompt_len);
7092                             s->pwprompt[prompt_len] = '\0';
7093                         }
7094                     } else {
7095                         strcpy(s->pwprompt,
7096                                "<server failed to send prompt>: ");
7097                     }
7098                     s->echo = ssh2_pkt_getbool(pktin);
7099                     s->need_pw = TRUE;
7100                 } else
7101                     s->need_pw = FALSE;
7102             }
7103
7104             if (!s->method && s->can_passwd) {
7105                 s->method = AUTH_PASSWORD;
7106                 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
7107                 ssh->pkt_ctx |= SSH2_PKTCTX_PASSWORD;
7108                 sprintf(s->pwprompt, "%.90s@%.90s's password: ", s->username,
7109                         ssh->savedhost);
7110                 s->need_pw = TRUE;
7111             }
7112
7113             if (s->need_pw) {
7114                 if (ssh_get_line) {
7115                     if (!ssh_get_line(s->pwprompt, s->password,
7116                                       sizeof(s->password), TRUE)) {
7117                         /*
7118                          * get_line failed to get a password (for
7119                          * example because one was supplied on the
7120                          * command line which has already failed to
7121                          * work). Terminate.
7122                          */
7123                         ssh_disconnect(ssh, NULL, "Unable to authenticate",
7124                                        SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
7125                                        FALSE);
7126                         crStopV;
7127                     }
7128                 } else {
7129                     int ret;           /* need not be saved across crReturn */
7130                     c_write_untrusted(ssh, s->pwprompt, strlen(s->pwprompt));
7131                     ssh->send_ok = 1;
7132
7133                     setup_userpass_input(ssh, s->password,
7134                                          sizeof(s->password), s->echo);
7135                     do {
7136                         crWaitUntilV(!pktin);
7137                         ret = process_userpass_input(ssh, in, inlen);
7138                     } while (ret == 0);
7139                     if (ret < 0)
7140                         cleanup_exit(0);
7141                     c_write_str(ssh, "\r\n");
7142                 }
7143             }
7144
7145             if (s->method == AUTH_PUBLICKEY_FILE) {
7146                 /*
7147                  * We have our passphrase. Now try the actual authentication.
7148                  */
7149                 struct ssh2_userkey *key;
7150                 const char *error = NULL;
7151
7152                 key = ssh2_load_userkey(&ssh->cfg.keyfile, s->password,
7153                                         &error);
7154                 if (key == SSH2_WRONG_PASSPHRASE || key == NULL) {
7155                     if (key == SSH2_WRONG_PASSPHRASE) {
7156                         c_write_str(ssh, "Wrong passphrase\r\n");
7157                         s->tried_pubkey_config = FALSE;
7158                     } else {
7159                         c_write_str(ssh, "Unable to load private key (");
7160                         c_write_str(ssh, error);
7161                         c_write_str(ssh, ")\r\n");
7162                         s->tried_pubkey_config = TRUE;
7163                     }
7164                     /* Send a spurious AUTH_NONE to return to the top. */
7165                     s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
7166                     ssh2_pkt_addstring(s->pktout, s->username);
7167                     ssh2_pkt_addstring(s->pktout, "ssh-connection");    /* service requested */
7168                     ssh2_pkt_addstring(s->pktout, "none");      /* method */
7169                     ssh2_pkt_send(ssh, s->pktout);
7170                     s->type = AUTH_TYPE_NONE;
7171                 } else {
7172                     unsigned char *pkblob, *sigblob, *sigdata;
7173                     int pkblob_len, sigblob_len, sigdata_len;
7174                     int p;
7175
7176                     /*
7177                      * We have loaded the private key and the server
7178                      * has announced that it's willing to accept it.
7179                      * Hallelujah. Generate a signature and send it.
7180                      */
7181                     s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
7182                     ssh2_pkt_addstring(s->pktout, s->username);
7183                     ssh2_pkt_addstring(s->pktout, "ssh-connection");    /* service requested */
7184                     ssh2_pkt_addstring(s->pktout, "publickey"); /* method */
7185                     ssh2_pkt_addbool(s->pktout, TRUE);
7186                     ssh2_pkt_addstring(s->pktout, key->alg->name);
7187                     pkblob = key->alg->public_blob(key->data, &pkblob_len);
7188                     ssh2_pkt_addstring_start(s->pktout);
7189                     ssh2_pkt_addstring_data(s->pktout, (char *)pkblob, pkblob_len);
7190
7191                     /*
7192                      * The data to be signed is:
7193                      *
7194                      *   string  session-id
7195                      *
7196                      * followed by everything so far placed in the
7197                      * outgoing packet.
7198                      */
7199                     sigdata_len = s->pktout->length - 5 + 4 + 20;
7200                     if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)
7201                         sigdata_len -= 4;
7202                     sigdata = snewn(sigdata_len, unsigned char);
7203                     p = 0;
7204                     if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) {
7205                         PUT_32BIT(sigdata+p, 20);
7206                         p += 4;
7207                     }
7208                     memcpy(sigdata+p, ssh->v2_session_id, 20); p += 20;
7209                     memcpy(sigdata+p, s->pktout->data + 5,
7210                            s->pktout->length - 5);
7211                     p += s->pktout->length - 5;
7212                     assert(p == sigdata_len);
7213                     sigblob = key->alg->sign(key->data, (char *)sigdata,
7214                                              sigdata_len, &sigblob_len);
7215                     ssh2_add_sigblob(ssh, s->pktout, pkblob, pkblob_len,
7216                                      sigblob, sigblob_len);
7217                     sfree(pkblob);
7218                     sfree(sigblob);
7219                     sfree(sigdata);
7220
7221                     ssh2_pkt_send(ssh, s->pktout);
7222                     s->type = AUTH_TYPE_PUBLICKEY;
7223                     key->alg->freekey(key->data);
7224                 }
7225             } else if (s->method == AUTH_PASSWORD) {
7226                 /*
7227                  * We pad out the password packet to 256 bytes to make
7228                  * it harder for an attacker to find the length of the
7229                  * user's password.
7230                  *
7231                  * Anyone using a password longer than 256 bytes
7232                  * probably doesn't have much to worry about from
7233                  * people who find out how long their password is!
7234                  */
7235                 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
7236                 s->pktout->forcepad = 256;
7237                 ssh2_pkt_addstring(s->pktout, s->username);
7238                 ssh2_pkt_addstring(s->pktout, "ssh-connection");        /* service requested */
7239                 ssh2_pkt_addstring(s->pktout, "password");
7240                 ssh2_pkt_addbool(s->pktout, FALSE);
7241                 dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
7242                 ssh2_pkt_addstring(s->pktout, s->password);
7243                 memset(s->password, 0, sizeof(s->password));
7244                 end_log_omission(ssh, s->pktout);
7245                 ssh2_pkt_send(ssh, s->pktout);
7246                 logevent("Sent password");
7247                 s->type = AUTH_TYPE_PASSWORD;
7248             } else if (s->method == AUTH_KEYBOARD_INTERACTIVE) {
7249                 if (s->curr_prompt == 0) {
7250                     s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_INFO_RESPONSE);
7251                     s->pktout->forcepad = 256;
7252                     ssh2_pkt_adduint32(s->pktout, s->num_prompts);
7253                 }
7254                 if (s->need_pw) {      /* only add pw if we just got one! */
7255                     dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
7256                     ssh2_pkt_addstring(s->pktout, s->password);
7257                     memset(s->password, 0, sizeof(s->password));
7258                     end_log_omission(ssh, s->pktout);
7259                     s->curr_prompt++;
7260                 }
7261                 if (s->curr_prompt >= s->num_prompts) {
7262                     ssh2_pkt_send(ssh, s->pktout);
7263                 } else {
7264                     /*
7265                      * If there are prompts remaining, we set
7266                      * `gotit' so that we won't attempt to get
7267                      * another packet. Then we go back round the
7268                      * loop and will end up retrieving another
7269                      * prompt out of the existing packet. Funky or
7270                      * what?
7271                      */
7272                     s->gotit = TRUE;
7273                 }
7274                 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
7275             } else {
7276                 ssh_disconnect(ssh, NULL,
7277                                "No supported authentication methods available",
7278                                SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
7279                                FALSE);
7280                 crStopV;
7281             }
7282         }
7283     }
7284     ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = NULL;
7285
7286     /*
7287      * Now the connection protocol has started, one way or another.
7288      */
7289
7290     ssh->channels = newtree234(ssh_channelcmp);
7291
7292     /*
7293      * Set up handlers for some connection protocol messages, so we
7294      * don't have to handle them repeatedly in this coroutine.
7295      */
7296     ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] =
7297         ssh2_msg_channel_window_adjust;
7298     ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] =
7299         ssh2_msg_global_request;
7300
7301     /*
7302      * Create the main session channel.
7303      */
7304     if (!ssh->cfg.ssh_no_shell) {
7305         ssh->mainchan = snew(struct ssh_channel);
7306         ssh->mainchan->ssh = ssh;
7307         ssh->mainchan->localid = alloc_channel_id(ssh);
7308         s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
7309         ssh2_pkt_addstring(s->pktout, "session");
7310         ssh2_pkt_adduint32(s->pktout, ssh->mainchan->localid);
7311         ssh->mainchan->v.v2.locwindow = OUR_V2_WINSIZE;
7312         ssh2_pkt_adduint32(s->pktout, ssh->mainchan->v.v2.locwindow);/* our window size */
7313         ssh2_pkt_adduint32(s->pktout, OUR_V2_MAXPKT);    /* our max pkt size */
7314         ssh2_pkt_send(ssh, s->pktout);
7315         crWaitUntilV(pktin);
7316         if (pktin->type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
7317             bombout(("Server refused to open a session"));
7318             crStopV;
7319             /* FIXME: error data comes back in FAILURE packet */
7320         }
7321         if (ssh_pkt_getuint32(pktin) != ssh->mainchan->localid) {
7322             bombout(("Server's channel confirmation cited wrong channel"));
7323             crStopV;
7324         }
7325         ssh->mainchan->remoteid = ssh_pkt_getuint32(pktin);
7326         ssh->mainchan->halfopen = FALSE;
7327         ssh->mainchan->type = CHAN_MAINSESSION;
7328         ssh->mainchan->closes = 0;
7329         ssh->mainchan->v.v2.remwindow = ssh_pkt_getuint32(pktin);
7330         ssh->mainchan->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
7331         bufchain_init(&ssh->mainchan->v.v2.outbuffer);
7332         add234(ssh->channels, ssh->mainchan);
7333         update_specials_menu(ssh->frontend);
7334         logevent("Opened channel for session");
7335     } else
7336         ssh->mainchan = NULL;
7337
7338     /*
7339      * Now we have a channel, make dispatch table entries for
7340      * general channel-based messages.
7341      */
7342     ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] =
7343     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] =
7344         ssh2_msg_channel_data;
7345     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = ssh2_msg_channel_eof;
7346     ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = ssh2_msg_channel_close;
7347     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] =
7348         ssh2_msg_channel_open_confirmation;
7349     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] =
7350         ssh2_msg_channel_open_failure;
7351     ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] =
7352         ssh2_msg_channel_request;
7353     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] =
7354         ssh2_msg_channel_open;
7355
7356     /*
7357      * Potentially enable X11 forwarding.
7358      */
7359     if (ssh->mainchan && ssh->cfg.x11_forward) {
7360         char proto[20], data[64];
7361         logevent("Requesting X11 forwarding");
7362         ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
7363                                        data, sizeof(data), ssh->cfg.x11_auth);
7364         x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display);
7365         s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7366         ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
7367         ssh2_pkt_addstring(s->pktout, "x11-req");
7368         ssh2_pkt_addbool(s->pktout, 1);        /* want reply */
7369         ssh2_pkt_addbool(s->pktout, 0);        /* many connections */
7370         ssh2_pkt_addstring(s->pktout, proto);
7371         /*
7372          * Note that while we blank the X authentication data here, we don't
7373          * take any special action to blank the start of an X11 channel,
7374          * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
7375          * without having session blanking enabled is likely to leak your
7376          * cookie into the log.
7377          */
7378         dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
7379         ssh2_pkt_addstring(s->pktout, data);
7380         end_log_omission(ssh, s->pktout);
7381         ssh2_pkt_adduint32(s->pktout, x11_get_screen_number(ssh->cfg.x11_display));
7382         ssh2_pkt_send(ssh, s->pktout);
7383
7384         crWaitUntilV(pktin);
7385
7386         if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7387             if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
7388                 bombout(("Unexpected response to X11 forwarding request:"
7389                          " packet type %d", pktin->type));
7390                 crStopV;
7391             }
7392             logevent("X11 forwarding refused");
7393         } else {
7394             logevent("X11 forwarding enabled");
7395             ssh->X11_fwd_enabled = TRUE;
7396         }
7397     }
7398
7399     /*
7400      * Enable port forwardings.
7401      */
7402     ssh_setup_portfwd(ssh, &ssh->cfg);
7403
7404     /*
7405      * Potentially enable agent forwarding.
7406      */
7407     if (ssh->mainchan && ssh->cfg.agentfwd && agent_exists()) {
7408         logevent("Requesting OpenSSH-style agent forwarding");
7409         s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7410         ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
7411         ssh2_pkt_addstring(s->pktout, "auth-agent-req@openssh.com");
7412         ssh2_pkt_addbool(s->pktout, 1);        /* want reply */
7413         ssh2_pkt_send(ssh, s->pktout);
7414
7415         crWaitUntilV(pktin);
7416
7417         if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7418             if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
7419                 bombout(("Unexpected response to agent forwarding request:"
7420                          " packet type %d", pktin->type));
7421                 crStopV;
7422             }
7423             logevent("Agent forwarding refused");
7424         } else {
7425             logevent("Agent forwarding enabled");
7426             ssh->agentfwd_enabled = TRUE;
7427         }
7428     }
7429
7430     /*
7431      * Now allocate a pty for the session.
7432      */
7433     if (ssh->mainchan && !ssh->cfg.nopty) {
7434         /* Unpick the terminal-speed string. */
7435         /* XXX perhaps we should allow no speeds to be sent. */
7436         ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
7437         sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
7438         /* Build the pty request. */
7439         s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7440         ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid); /* recipient channel */
7441         ssh2_pkt_addstring(s->pktout, "pty-req");
7442         ssh2_pkt_addbool(s->pktout, 1);        /* want reply */
7443         ssh2_pkt_addstring(s->pktout, ssh->cfg.termtype);
7444         ssh2_pkt_adduint32(s->pktout, ssh->term_width);
7445         ssh2_pkt_adduint32(s->pktout, ssh->term_height);
7446         ssh2_pkt_adduint32(s->pktout, 0);              /* pixel width */
7447         ssh2_pkt_adduint32(s->pktout, 0);              /* pixel height */
7448         ssh2_pkt_addstring_start(s->pktout);
7449         parse_ttymodes(ssh, ssh->cfg.ttymodes,
7450                        ssh2_send_ttymode, (void *)s->pktout);
7451         ssh2_pkt_addbyte(s->pktout, SSH2_TTY_OP_ISPEED);
7452         ssh2_pkt_adduint32(s->pktout, ssh->ispeed);
7453         ssh2_pkt_addbyte(s->pktout, SSH2_TTY_OP_OSPEED);
7454         ssh2_pkt_adduint32(s->pktout, ssh->ospeed);
7455         ssh2_pkt_addstring_data(s->pktout, "\0", 1); /* TTY_OP_END */
7456         ssh2_pkt_send(ssh, s->pktout);
7457         ssh->state = SSH_STATE_INTERMED;
7458
7459         crWaitUntilV(pktin);
7460
7461         if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7462             if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
7463                 bombout(("Unexpected response to pty request:"
7464                          " packet type %d", pktin->type));
7465                 crStopV;
7466             }
7467             c_write_str(ssh, "Server refused to allocate pty\r\n");
7468             ssh->editing = ssh->echoing = 1;
7469         } else {
7470             logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
7471                       ssh->ospeed, ssh->ispeed);
7472         }
7473     } else {
7474         ssh->editing = ssh->echoing = 1;
7475     }
7476
7477     /*
7478      * Send environment variables.
7479      *
7480      * Simplest thing here is to send all the requests at once, and
7481      * then wait for a whole bunch of successes or failures.
7482      */
7483     if (ssh->mainchan && *ssh->cfg.environmt) {
7484         char *e = ssh->cfg.environmt;
7485         char *var, *varend, *val;
7486
7487         s->num_env = 0;
7488
7489         while (*e) {
7490             var = e;
7491             while (*e && *e != '\t') e++;
7492             varend = e;
7493             if (*e == '\t') e++;
7494             val = e;
7495             while (*e) e++;
7496             e++;
7497
7498             s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7499             ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
7500             ssh2_pkt_addstring(s->pktout, "env");
7501             ssh2_pkt_addbool(s->pktout, 1);            /* want reply */
7502             ssh2_pkt_addstring_start(s->pktout);
7503             ssh2_pkt_addstring_data(s->pktout, var, varend-var);
7504             ssh2_pkt_addstring(s->pktout, val);
7505             ssh2_pkt_send(ssh, s->pktout);
7506
7507             s->num_env++;
7508         }
7509
7510         logeventf(ssh, "Sent %d environment variables", s->num_env);
7511
7512         s->env_ok = 0;
7513         s->env_left = s->num_env;
7514
7515         while (s->env_left > 0) {
7516             crWaitUntilV(pktin);
7517
7518             if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7519                 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
7520                     bombout(("Unexpected response to environment request:"
7521                              " packet type %d", pktin->type));
7522                     crStopV;
7523                 }
7524             } else {
7525                 s->env_ok++;
7526             }
7527
7528             s->env_left--;
7529         }
7530
7531         if (s->env_ok == s->num_env) {
7532             logevent("All environment variables successfully set");
7533         } else if (s->env_ok == 0) {
7534             logevent("All environment variables refused");
7535             c_write_str(ssh, "Server refused to set environment variables\r\n");
7536         } else {
7537             logeventf(ssh, "%d environment variables refused",
7538                       s->num_env - s->env_ok);
7539             c_write_str(ssh, "Server refused to set all environment variables\r\n");
7540         }
7541     }
7542
7543     /*
7544      * Start a shell or a remote command. We may have to attempt
7545      * this twice if the config data has provided a second choice
7546      * of command.
7547      */
7548     if (ssh->mainchan) while (1) {
7549         int subsys;
7550         char *cmd;
7551
7552         if (ssh->fallback_cmd) {
7553             subsys = ssh->cfg.ssh_subsys2;
7554             cmd = ssh->cfg.remote_cmd_ptr2;
7555         } else {
7556             subsys = ssh->cfg.ssh_subsys;
7557             cmd = ssh->cfg.remote_cmd_ptr;
7558             if (!cmd) cmd = ssh->cfg.remote_cmd;
7559         }
7560
7561         s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7562         ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid); /* recipient channel */
7563         if (subsys) {
7564             ssh2_pkt_addstring(s->pktout, "subsystem");
7565             ssh2_pkt_addbool(s->pktout, 1);            /* want reply */
7566             ssh2_pkt_addstring(s->pktout, cmd);
7567         } else if (*cmd) {
7568             ssh2_pkt_addstring(s->pktout, "exec");
7569             ssh2_pkt_addbool(s->pktout, 1);            /* want reply */
7570             ssh2_pkt_addstring(s->pktout, cmd);
7571         } else {
7572             ssh2_pkt_addstring(s->pktout, "shell");
7573             ssh2_pkt_addbool(s->pktout, 1);            /* want reply */
7574         }
7575         ssh2_pkt_send(ssh, s->pktout);
7576
7577         crWaitUntilV(pktin);
7578
7579         if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7580             if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
7581                 bombout(("Unexpected response to shell/command request:"
7582                          " packet type %d", pktin->type));
7583                 crStopV;
7584             }
7585             /*
7586              * We failed to start the command. If this is the
7587              * fallback command, we really are finished; if it's
7588              * not, and if the fallback command exists, try falling
7589              * back to it before complaining.
7590              */
7591             if (!ssh->fallback_cmd && ssh->cfg.remote_cmd_ptr2 != NULL) {
7592                 logevent("Primary command failed; attempting fallback");
7593                 ssh->fallback_cmd = TRUE;
7594                 continue;
7595             }
7596             bombout(("Server refused to start a shell/command"));
7597             crStopV;
7598         } else {
7599             logevent("Started a shell/command");
7600         }
7601         break;
7602     }
7603
7604     ssh->state = SSH_STATE_SESSION;
7605     if (ssh->size_needed)
7606         ssh_size(ssh, ssh->term_width, ssh->term_height);
7607     if (ssh->eof_needed)
7608         ssh_special(ssh, TS_EOF);
7609
7610     /*
7611      * Transfer data!
7612      */
7613     if (ssh->ldisc)
7614         ldisc_send(ssh->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
7615     if (ssh->mainchan)
7616         ssh->send_ok = 1;
7617     while (1) {
7618         crReturnV;
7619         s->try_send = FALSE;
7620         if (pktin) {
7621
7622             /*
7623              * _All_ the connection-layer packets we expect to
7624              * receive are now handled by the dispatch table.
7625              * Anything that reaches here must be bogus.
7626              */
7627
7628             bombout(("Strange packet received: type %d", pktin->type));
7629             crStopV;
7630         } else if (ssh->mainchan) {
7631             /*
7632              * We have spare data. Add it to the channel buffer.
7633              */
7634             ssh2_add_channel_data(ssh->mainchan, (char *)in, inlen);
7635             s->try_send = TRUE;
7636         }
7637         if (s->try_send) {
7638             int i;
7639             struct ssh_channel *c;
7640             /*
7641              * Try to send data on all channels if we can.
7642              */
7643             for (i = 0; NULL != (c = index234(ssh->channels, i)); i++)
7644                 ssh2_try_send_and_unthrottle(c);
7645         }
7646     }
7647
7648     crFinishV;
7649 }
7650
7651 /*
7652  * Handlers for SSH-2 messages that might arrive at any moment.
7653  */
7654 static void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin)
7655 {
7656     /* log reason code in disconnect message */
7657     char *buf, *msg;
7658     int nowlen, reason, msglen;
7659
7660     reason = ssh_pkt_getuint32(pktin);
7661     ssh_pkt_getstring(pktin, &msg, &msglen);
7662
7663     if (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) {
7664         buf = dupprintf("Received disconnect message (%s)",
7665                         ssh2_disconnect_reasons[reason]);
7666     } else {
7667         buf = dupprintf("Received disconnect message (unknown"
7668                         " type %d)", reason);
7669     }
7670     logevent(buf);
7671     sfree(buf);
7672     buf = dupprintf("Disconnection message text: %n%.*s",
7673                     &nowlen, msglen, msg);
7674     logevent(buf);
7675     bombout(("Server sent disconnect message\ntype %d (%s):\n\"%s\"",
7676              reason,
7677              (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) ?
7678              ssh2_disconnect_reasons[reason] : "unknown",
7679              buf+nowlen));
7680     sfree(buf);
7681 }
7682
7683 static void ssh2_msg_debug(Ssh ssh, struct Packet *pktin)
7684 {
7685     /* log the debug message */
7686     char *msg;
7687     int msglen;
7688     int always_display;
7689
7690     /* XXX maybe we should actually take notice of this */
7691     always_display = ssh2_pkt_getbool(pktin);
7692     ssh_pkt_getstring(pktin, &msg, &msglen);
7693
7694     logeventf(ssh, "Remote debug message: %.*s", msglen, msg);
7695 }
7696
7697 static void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin)
7698 {
7699     struct Packet *pktout;
7700     pktout = ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED);
7701     ssh2_pkt_adduint32(pktout, pktin->sequence);
7702     /*
7703      * UNIMPLEMENTED messages MUST appear in the same order as the
7704      * messages they respond to. Hence, never queue them.
7705      */
7706     ssh2_pkt_send_noqueue(ssh, pktout);
7707 }
7708
7709 /*
7710  * Handle the top-level SSH-2 protocol.
7711  */
7712 static void ssh2_protocol_setup(Ssh ssh)
7713 {
7714     int i;
7715
7716     /*
7717      * Most messages cause SSH2_MSG_UNIMPLEMENTED.
7718      */
7719     for (i = 0; i < 256; i++)
7720         ssh->packet_dispatch[i] = ssh2_msg_something_unimplemented;
7721
7722     /*
7723      * Any message we actually understand, we set to NULL so that
7724      * the coroutines will get it.
7725      */
7726     ssh->packet_dispatch[SSH2_MSG_UNIMPLEMENTED] = NULL;
7727     ssh->packet_dispatch[SSH2_MSG_SERVICE_REQUEST] = NULL;
7728     ssh->packet_dispatch[SSH2_MSG_SERVICE_ACCEPT] = NULL;
7729     ssh->packet_dispatch[SSH2_MSG_KEXINIT] = NULL;
7730     ssh->packet_dispatch[SSH2_MSG_NEWKEYS] = NULL;
7731     ssh->packet_dispatch[SSH2_MSG_KEXDH_INIT] = NULL;
7732     ssh->packet_dispatch[SSH2_MSG_KEXDH_REPLY] = NULL;
7733     /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REQUEST] = NULL; duplicate case value */
7734     /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_GROUP] = NULL; duplicate case value */
7735     ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_INIT] = NULL;
7736     ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REPLY] = NULL;
7737     ssh->packet_dispatch[SSH2_MSG_USERAUTH_REQUEST] = NULL;
7738     ssh->packet_dispatch[SSH2_MSG_USERAUTH_FAILURE] = NULL;
7739     ssh->packet_dispatch[SSH2_MSG_USERAUTH_SUCCESS] = NULL;
7740     ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = NULL;
7741     ssh->packet_dispatch[SSH2_MSG_USERAUTH_PK_OK] = NULL;
7742     /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ] = NULL; duplicate case value */
7743     /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_REQUEST] = NULL; duplicate case value */
7744     ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_RESPONSE] = NULL;
7745     ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] = NULL;
7746     ssh->packet_dispatch[SSH2_MSG_REQUEST_SUCCESS] = NULL;
7747     ssh->packet_dispatch[SSH2_MSG_REQUEST_FAILURE] = NULL;
7748     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] = NULL;
7749     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] = NULL;
7750     ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] = NULL;
7751     ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] = NULL;
7752     ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] = NULL;
7753     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] = NULL;
7754     ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = NULL;
7755     ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = NULL;
7756     ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] = NULL;
7757     ssh->packet_dispatch[SSH2_MSG_CHANNEL_SUCCESS] = NULL;
7758     ssh->packet_dispatch[SSH2_MSG_CHANNEL_FAILURE] = NULL;
7759
7760     /*
7761      * These special message types we install handlers for.
7762      */
7763     ssh->packet_dispatch[SSH2_MSG_DISCONNECT] = ssh2_msg_disconnect;
7764     ssh->packet_dispatch[SSH2_MSG_IGNORE] = ssh_msg_ignore; /* shared with SSH-1 */
7765     ssh->packet_dispatch[SSH2_MSG_DEBUG] = ssh2_msg_debug;
7766 }
7767
7768 static void ssh2_timer(void *ctx, long now)
7769 {
7770     Ssh ssh = (Ssh)ctx;
7771
7772     if (ssh->state == SSH_STATE_CLOSED)
7773         return;
7774
7775     if (!ssh->kex_in_progress && ssh->cfg.ssh_rekey_time != 0 &&
7776         now - ssh->next_rekey >= 0) {
7777         do_ssh2_transport(ssh, "timeout", -1, NULL);
7778     }
7779 }
7780
7781 static void ssh2_protocol(Ssh ssh, void *vin, int inlen,
7782                           struct Packet *pktin)
7783 {
7784     unsigned char *in = (unsigned char *)vin;
7785     if (ssh->state == SSH_STATE_CLOSED)
7786         return;
7787
7788     if (pktin) {
7789         ssh->incoming_data_size += pktin->encrypted_len;
7790         if (!ssh->kex_in_progress &&
7791             ssh->max_data_size != 0 &&
7792             ssh->incoming_data_size > ssh->max_data_size)
7793             do_ssh2_transport(ssh, "too much data received", -1, NULL);
7794     }
7795
7796     if (pktin && ssh->packet_dispatch[pktin->type]) {
7797         ssh->packet_dispatch[pktin->type](ssh, pktin);
7798         return;
7799     }
7800
7801     if (!ssh->protocol_initial_phase_done ||
7802         (pktin && pktin->type >= 20 && pktin->type < 50)) {
7803         if (do_ssh2_transport(ssh, in, inlen, pktin) &&
7804             !ssh->protocol_initial_phase_done) {
7805             ssh->protocol_initial_phase_done = TRUE;
7806             /*
7807              * Allow authconn to initialise itself.
7808              */
7809             do_ssh2_authconn(ssh, NULL, 0, NULL);
7810         }
7811     } else {
7812         do_ssh2_authconn(ssh, in, inlen, pktin);
7813     }
7814 }
7815
7816 /*
7817  * Called to set up the connection.
7818  *
7819  * Returns an error message, or NULL on success.
7820  */
7821 static const char *ssh_init(void *frontend_handle, void **backend_handle,
7822                             Config *cfg,
7823                             char *host, int port, char **realhost, int nodelay,
7824                             int keepalive)
7825 {
7826     const char *p;
7827     Ssh ssh;
7828
7829     ssh = snew(struct ssh_tag);
7830     ssh->cfg = *cfg;                   /* STRUCTURE COPY */
7831     ssh->version = 0;                  /* when not ready yet */
7832     ssh->s = NULL;
7833     ssh->cipher = NULL;
7834     ssh->v1_cipher_ctx = NULL;
7835     ssh->crcda_ctx = NULL;
7836     ssh->cscipher = NULL;
7837     ssh->cs_cipher_ctx = NULL;
7838     ssh->sccipher = NULL;
7839     ssh->sc_cipher_ctx = NULL;
7840     ssh->csmac = NULL;
7841     ssh->cs_mac_ctx = NULL;
7842     ssh->scmac = NULL;
7843     ssh->sc_mac_ctx = NULL;
7844     ssh->cscomp = NULL;
7845     ssh->cs_comp_ctx = NULL;
7846     ssh->sccomp = NULL;
7847     ssh->sc_comp_ctx = NULL;
7848     ssh->kex = NULL;
7849     ssh->kex_ctx = NULL;
7850     ssh->hostkey = NULL;
7851     ssh->exitcode = -1;
7852     ssh->close_expected = FALSE;
7853     ssh->clean_exit = FALSE;
7854     ssh->state = SSH_STATE_PREPACKET;
7855     ssh->size_needed = FALSE;
7856     ssh->eof_needed = FALSE;
7857     ssh->ldisc = NULL;
7858     ssh->logctx = NULL;
7859     ssh->deferred_send_data = NULL;
7860     ssh->deferred_len = 0;
7861     ssh->deferred_size = 0;
7862     ssh->fallback_cmd = 0;
7863     ssh->pkt_ctx = 0;
7864     ssh->x11auth = NULL;
7865     ssh->v1_compressing = FALSE;
7866     ssh->v2_outgoing_sequence = 0;
7867     ssh->ssh1_rdpkt_crstate = 0;
7868     ssh->ssh2_rdpkt_crstate = 0;
7869     ssh->do_ssh_init_crstate = 0;
7870     ssh->ssh_gotdata_crstate = 0;
7871     ssh->do_ssh1_connection_crstate = 0;
7872     ssh->do_ssh1_login_crstate = 0;
7873     ssh->do_ssh2_transport_crstate = 0;
7874     ssh->do_ssh2_authconn_crstate = 0;
7875     ssh->do_ssh_init_state = NULL;
7876     ssh->do_ssh1_login_state = NULL;
7877     ssh->do_ssh2_transport_state = NULL;
7878     ssh->do_ssh2_authconn_state = NULL;
7879     ssh->v_c = NULL;
7880     ssh->v_s = NULL;
7881     ssh->mainchan = NULL;
7882     ssh->throttled_all = 0;
7883     ssh->v1_stdout_throttling = 0;
7884     ssh->queue = NULL;
7885     ssh->queuelen = ssh->queuesize = 0;
7886     ssh->queueing = FALSE;
7887     ssh->qhead = ssh->qtail = NULL;
7888     ssh->deferred_rekey_reason = NULL;
7889     bufchain_init(&ssh->queued_incoming_data);
7890     ssh->frozen = FALSE;
7891
7892     *backend_handle = ssh;
7893
7894 #ifdef MSCRYPTOAPI
7895     if (crypto_startup() == 0)
7896         return "Microsoft high encryption pack not installed!";
7897 #endif
7898
7899     ssh->frontend = frontend_handle;
7900     ssh->term_width = ssh->cfg.width;
7901     ssh->term_height = ssh->cfg.height;
7902
7903     ssh->channels = NULL;
7904     ssh->rportfwds = NULL;
7905     ssh->portfwds = NULL;
7906
7907     ssh->send_ok = 0;
7908     ssh->editing = 0;
7909     ssh->echoing = 0;
7910     ssh->v1_throttle_count = 0;
7911     ssh->overall_bufsize = 0;
7912     ssh->fallback_cmd = 0;
7913
7914     ssh->protocol = NULL;
7915
7916     ssh->protocol_initial_phase_done = FALSE;
7917
7918     ssh->pinger = NULL;
7919
7920     ssh->incoming_data_size = ssh->outgoing_data_size =
7921         ssh->deferred_data_size = 0L;
7922     ssh->max_data_size = parse_blocksize(ssh->cfg.ssh_rekey_data);
7923     ssh->kex_in_progress = FALSE;
7924
7925     p = connect_to_host(ssh, host, port, realhost, nodelay, keepalive);
7926     if (p != NULL)
7927         return p;
7928
7929     random_ref();
7930
7931     return NULL;
7932 }
7933
7934 static void ssh_free(void *handle)
7935 {
7936     Ssh ssh = (Ssh) handle;
7937     struct ssh_channel *c;
7938     struct ssh_rportfwd *pf;
7939
7940     if (ssh->v1_cipher_ctx)
7941         ssh->cipher->free_context(ssh->v1_cipher_ctx);
7942     if (ssh->cs_cipher_ctx)
7943         ssh->cscipher->free_context(ssh->cs_cipher_ctx);
7944     if (ssh->sc_cipher_ctx)
7945         ssh->sccipher->free_context(ssh->sc_cipher_ctx);
7946     if (ssh->cs_mac_ctx)
7947         ssh->csmac->free_context(ssh->cs_mac_ctx);
7948     if (ssh->sc_mac_ctx)
7949         ssh->scmac->free_context(ssh->sc_mac_ctx);
7950     if (ssh->cs_comp_ctx) {
7951         if (ssh->cscomp)
7952             ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
7953         else
7954             zlib_compress_cleanup(ssh->cs_comp_ctx);
7955     }
7956     if (ssh->sc_comp_ctx) {
7957         if (ssh->sccomp)
7958             ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
7959         else
7960             zlib_decompress_cleanup(ssh->sc_comp_ctx);
7961     }
7962     if (ssh->kex_ctx)
7963         dh_cleanup(ssh->kex_ctx);
7964     sfree(ssh->savedhost);
7965
7966     while (ssh->queuelen-- > 0)
7967         ssh_free_packet(ssh->queue[ssh->queuelen]);
7968     sfree(ssh->queue);
7969
7970     while (ssh->qhead) {
7971         struct queued_handler *qh = ssh->qhead;
7972         ssh->qhead = qh->next;
7973         sfree(ssh->qhead);
7974     }
7975     ssh->qhead = ssh->qtail = NULL;
7976
7977     if (ssh->channels) {
7978         while ((c = delpos234(ssh->channels, 0)) != NULL) {
7979             switch (c->type) {
7980               case CHAN_X11:
7981                 if (c->u.x11.s != NULL)
7982                     x11_close(c->u.x11.s);
7983                 break;
7984               case CHAN_SOCKDATA:
7985                 if (c->u.pfd.s != NULL)
7986                     pfd_close(c->u.pfd.s);
7987                 break;
7988             }
7989             sfree(c);
7990         }
7991         freetree234(ssh->channels);
7992         ssh->channels = NULL;
7993     }
7994
7995     if (ssh->rportfwds) {
7996         while ((pf = delpos234(ssh->rportfwds, 0)) != NULL)
7997             sfree(pf);
7998         freetree234(ssh->rportfwds);
7999         ssh->rportfwds = NULL;
8000     }
8001     sfree(ssh->deferred_send_data);
8002     if (ssh->x11auth)
8003         x11_free_auth(ssh->x11auth);
8004     sfree(ssh->do_ssh_init_state);
8005     sfree(ssh->do_ssh1_login_state);
8006     sfree(ssh->do_ssh2_transport_state);
8007     sfree(ssh->do_ssh2_authconn_state);
8008     sfree(ssh->v_c);
8009     sfree(ssh->v_s);
8010     if (ssh->crcda_ctx) {
8011         crcda_free_context(ssh->crcda_ctx);
8012         ssh->crcda_ctx = NULL;
8013     }
8014     if (ssh->s)
8015         ssh_do_close(ssh, TRUE);
8016     expire_timer_context(ssh);
8017     if (ssh->pinger)
8018         pinger_free(ssh->pinger);
8019     bufchain_clear(&ssh->queued_incoming_data);
8020     sfree(ssh);
8021
8022     random_unref();
8023 }
8024
8025 /*
8026  * Reconfigure the SSH backend.
8027  */
8028 static void ssh_reconfig(void *handle, Config *cfg)
8029 {
8030     Ssh ssh = (Ssh) handle;
8031     char *rekeying = NULL, rekey_mandatory = FALSE;
8032     unsigned long old_max_data_size;
8033
8034     pinger_reconfig(ssh->pinger, &ssh->cfg, cfg);
8035     if (ssh->portfwds)
8036         ssh_setup_portfwd(ssh, cfg);
8037
8038     if (ssh->cfg.ssh_rekey_time != cfg->ssh_rekey_time &&
8039         cfg->ssh_rekey_time != 0) {
8040         long new_next = ssh->last_rekey + cfg->ssh_rekey_time*60*TICKSPERSEC;
8041         long now = GETTICKCOUNT();
8042
8043         if (new_next - now < 0) {
8044             rekeying = "timeout shortened";
8045         } else {
8046             ssh->next_rekey = schedule_timer(new_next - now, ssh2_timer, ssh);
8047         }
8048     }
8049
8050     old_max_data_size = ssh->max_data_size;
8051     ssh->max_data_size = parse_blocksize(cfg->ssh_rekey_data);
8052     if (old_max_data_size != ssh->max_data_size &&
8053         ssh->max_data_size != 0) {
8054         if (ssh->outgoing_data_size > ssh->max_data_size ||
8055             ssh->incoming_data_size > ssh->max_data_size)
8056             rekeying = "data limit lowered";
8057     }
8058
8059     if (ssh->cfg.compression != cfg->compression) {
8060         rekeying = "compression setting changed";
8061         rekey_mandatory = TRUE;
8062     }
8063
8064     if (ssh->cfg.ssh2_des_cbc != cfg->ssh2_des_cbc ||
8065         memcmp(ssh->cfg.ssh_cipherlist, cfg->ssh_cipherlist,
8066                sizeof(ssh->cfg.ssh_cipherlist))) {
8067         rekeying = "cipher settings changed";
8068         rekey_mandatory = TRUE;
8069     }
8070
8071     ssh->cfg = *cfg;                   /* STRUCTURE COPY */
8072
8073     if (rekeying) {
8074         if (!ssh->kex_in_progress) {
8075             do_ssh2_transport(ssh, rekeying, -1, NULL);
8076         } else if (rekey_mandatory) {
8077             ssh->deferred_rekey_reason = rekeying;
8078         }
8079     }
8080 }
8081
8082 /*
8083  * Called to send data down the SSH connection.
8084  */
8085 static int ssh_send(void *handle, char *buf, int len)
8086 {
8087     Ssh ssh = (Ssh) handle;
8088
8089     if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
8090         return 0;
8091
8092     ssh->protocol(ssh, (unsigned char *)buf, len, 0);
8093
8094     return ssh_sendbuffer(ssh);
8095 }
8096
8097 /*
8098  * Called to query the current amount of buffered stdin data.
8099  */
8100 static int ssh_sendbuffer(void *handle)
8101 {
8102     Ssh ssh = (Ssh) handle;
8103     int override_value;
8104
8105     if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
8106         return 0;
8107
8108     /*
8109      * If the SSH socket itself has backed up, add the total backup
8110      * size on that to any individual buffer on the stdin channel.
8111      */
8112     override_value = 0;
8113     if (ssh->throttled_all)
8114         override_value = ssh->overall_bufsize;
8115
8116     if (ssh->version == 1) {
8117         return override_value;
8118     } else if (ssh->version == 2) {
8119         if (!ssh->mainchan || ssh->mainchan->closes > 0)
8120             return override_value;
8121         else
8122             return (override_value +
8123                     bufchain_size(&ssh->mainchan->v.v2.outbuffer));
8124     }
8125
8126     return 0;
8127 }
8128
8129 /*
8130  * Called to set the size of the window from SSH's POV.
8131  */
8132 static void ssh_size(void *handle, int width, int height)
8133 {
8134     Ssh ssh = (Ssh) handle;
8135     struct Packet *pktout;
8136
8137     ssh->term_width = width;
8138     ssh->term_height = height;
8139
8140     switch (ssh->state) {
8141       case SSH_STATE_BEFORE_SIZE:
8142       case SSH_STATE_PREPACKET:
8143       case SSH_STATE_CLOSED:
8144         break;                         /* do nothing */
8145       case SSH_STATE_INTERMED:
8146         ssh->size_needed = TRUE;       /* buffer for later */
8147         break;
8148       case SSH_STATE_SESSION:
8149         if (!ssh->cfg.nopty) {
8150             if (ssh->version == 1) {
8151                 send_packet(ssh, SSH1_CMSG_WINDOW_SIZE,
8152                             PKT_INT, ssh->term_height,
8153                             PKT_INT, ssh->term_width,
8154                             PKT_INT, 0, PKT_INT, 0, PKT_END);
8155             } else if (ssh->mainchan) {
8156                 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8157                 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
8158                 ssh2_pkt_addstring(pktout, "window-change");
8159                 ssh2_pkt_addbool(pktout, 0);
8160                 ssh2_pkt_adduint32(pktout, ssh->term_width);
8161                 ssh2_pkt_adduint32(pktout, ssh->term_height);
8162                 ssh2_pkt_adduint32(pktout, 0);
8163                 ssh2_pkt_adduint32(pktout, 0);
8164                 ssh2_pkt_send(ssh, pktout);
8165             }
8166         }
8167         break;
8168     }
8169 }
8170
8171 /*
8172  * Return a list of the special codes that make sense in this
8173  * protocol.
8174  */
8175 static const struct telnet_special *ssh_get_specials(void *handle)
8176 {
8177     static const struct telnet_special ssh1_ignore_special[] = {
8178         {"IGNORE message", TS_NOP}
8179     };
8180     static const struct telnet_special ssh2_transport_specials[] = {
8181         {"IGNORE message", TS_NOP},
8182         {"Repeat key exchange", TS_REKEY},
8183     };
8184     static const struct telnet_special ssh2_session_specials[] = {
8185         {NULL, TS_SEP},
8186         {"Break", TS_BRK},
8187         /* These are the signal names defined by draft-ietf-secsh-connect-23.
8188          * They include all the ISO C signals, but are a subset of the POSIX
8189          * required signals. */
8190         {"SIGINT (Interrupt)", TS_SIGINT},
8191         {"SIGTERM (Terminate)", TS_SIGTERM},
8192         {"SIGKILL (Kill)", TS_SIGKILL},
8193         {"SIGQUIT (Quit)", TS_SIGQUIT},
8194         {"SIGHUP (Hangup)", TS_SIGHUP},
8195         {"More signals", TS_SUBMENU},
8196           {"SIGABRT", TS_SIGABRT}, {"SIGALRM", TS_SIGALRM},
8197           {"SIGFPE",  TS_SIGFPE},  {"SIGILL",  TS_SIGILL},
8198           {"SIGPIPE", TS_SIGPIPE}, {"SIGSEGV", TS_SIGSEGV},
8199           {"SIGUSR1", TS_SIGUSR1}, {"SIGUSR2", TS_SIGUSR2},
8200         {NULL, TS_EXITMENU}
8201     };
8202     static const struct telnet_special specials_end[] = {
8203         {NULL, TS_EXITMENU}
8204     };
8205     /* XXX review this length for any changes: */
8206     static struct telnet_special ssh_specials[lenof(ssh2_transport_specials) +
8207                                               lenof(ssh2_session_specials) +
8208                                               lenof(specials_end)];
8209     Ssh ssh = (Ssh) handle;
8210     int i = 0;
8211 #define ADD_SPECIALS(name) \
8212     do { \
8213         assert((i + lenof(name)) <= lenof(ssh_specials)); \
8214         memcpy(&ssh_specials[i], name, sizeof name); \
8215         i += lenof(name); \
8216     } while(0)
8217
8218     if (ssh->version == 1) {
8219         /* Don't bother offering IGNORE if we've decided the remote
8220          * won't cope with it, since we wouldn't bother sending it if
8221          * asked anyway. */
8222         if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
8223             ADD_SPECIALS(ssh1_ignore_special);
8224     } else if (ssh->version == 2) {
8225         ADD_SPECIALS(ssh2_transport_specials);
8226         if (ssh->mainchan)
8227             ADD_SPECIALS(ssh2_session_specials);
8228     } /* else we're not ready yet */
8229
8230     if (i) {
8231         ADD_SPECIALS(specials_end);
8232         return ssh_specials;
8233     } else {
8234         return NULL;
8235     }
8236 #undef ADD_SPECIALS
8237 }
8238
8239 /*
8240  * Send special codes. TS_EOF is useful for `plink', so you
8241  * can send an EOF and collect resulting output (e.g. `plink
8242  * hostname sort').
8243  */
8244 static void ssh_special(void *handle, Telnet_Special code)
8245 {
8246     Ssh ssh = (Ssh) handle;
8247     struct Packet *pktout;
8248
8249     if (code == TS_EOF) {
8250         if (ssh->state != SSH_STATE_SESSION) {
8251             /*
8252              * Buffer the EOF in case we are pre-SESSION, so we can
8253              * send it as soon as we reach SESSION.
8254              */
8255             if (code == TS_EOF)
8256                 ssh->eof_needed = TRUE;
8257             return;
8258         }
8259         if (ssh->version == 1) {
8260             send_packet(ssh, SSH1_CMSG_EOF, PKT_END);
8261         } else if (ssh->mainchan) {
8262             struct Packet *pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_EOF);
8263             ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
8264             ssh2_pkt_send(ssh, pktout);
8265             ssh->send_ok = 0;          /* now stop trying to read from stdin */
8266         }
8267         logevent("Sent EOF message");
8268     } else if (code == TS_PING || code == TS_NOP) {
8269         if (ssh->state == SSH_STATE_CLOSED
8270             || ssh->state == SSH_STATE_PREPACKET) return;
8271         if (ssh->version == 1) {
8272             if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
8273                 send_packet(ssh, SSH1_MSG_IGNORE, PKT_STR, "", PKT_END);
8274         } else {
8275             pktout = ssh2_pkt_init(SSH2_MSG_IGNORE);
8276             ssh2_pkt_addstring_start(pktout);
8277             ssh2_pkt_send_noqueue(ssh, pktout);
8278         }
8279     } else if (code == TS_REKEY) {
8280         if (!ssh->kex_in_progress && ssh->version == 2) {
8281             do_ssh2_transport(ssh, "at user request", -1, NULL);
8282         }
8283     } else if (code == TS_BRK) {
8284         if (ssh->state == SSH_STATE_CLOSED
8285             || ssh->state == SSH_STATE_PREPACKET) return;
8286         if (ssh->version == 1) {
8287             logevent("Unable to send BREAK signal in SSH-1");
8288         } else if (ssh->mainchan) {
8289             pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8290             ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
8291             ssh2_pkt_addstring(pktout, "break");
8292             ssh2_pkt_addbool(pktout, 0);
8293             ssh2_pkt_adduint32(pktout, 0);   /* default break length */
8294             ssh2_pkt_send(ssh, pktout);
8295         }
8296     } else {
8297         /* Is is a POSIX signal? */
8298         char *signame = NULL;
8299         if (code == TS_SIGABRT) signame = "ABRT";
8300         if (code == TS_SIGALRM) signame = "ALRM";
8301         if (code == TS_SIGFPE)  signame = "FPE";
8302         if (code == TS_SIGHUP)  signame = "HUP";
8303         if (code == TS_SIGILL)  signame = "ILL";
8304         if (code == TS_SIGINT)  signame = "INT";
8305         if (code == TS_SIGKILL) signame = "KILL";
8306         if (code == TS_SIGPIPE) signame = "PIPE";
8307         if (code == TS_SIGQUIT) signame = "QUIT";
8308         if (code == TS_SIGSEGV) signame = "SEGV";
8309         if (code == TS_SIGTERM) signame = "TERM";
8310         if (code == TS_SIGUSR1) signame = "USR1";
8311         if (code == TS_SIGUSR2) signame = "USR2";
8312         /* The SSH-2 protocol does in principle support arbitrary named
8313          * signals, including signame@domain, but we don't support those. */
8314         if (signame) {
8315             /* It's a signal. */
8316             if (ssh->version == 2 && ssh->mainchan) {
8317                 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8318                 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
8319                 ssh2_pkt_addstring(pktout, "signal");
8320                 ssh2_pkt_addbool(pktout, 0);
8321                 ssh2_pkt_addstring(pktout, signame);
8322                 ssh2_pkt_send(ssh, pktout);
8323                 logeventf(ssh, "Sent signal SIG%s", signame);
8324             }
8325         } else {
8326             /* Never heard of it. Do nothing */
8327         }
8328     }
8329 }
8330
8331 void *new_sock_channel(void *handle, Socket s)
8332 {
8333     Ssh ssh = (Ssh) handle;
8334     struct ssh_channel *c;
8335     c = snew(struct ssh_channel);
8336     c->ssh = ssh;
8337
8338     if (c) {
8339         c->halfopen = TRUE;
8340         c->localid = alloc_channel_id(ssh);
8341         c->closes = 0;
8342         c->type = CHAN_SOCKDATA_DORMANT;/* identify channel type */
8343         c->u.pfd.s = s;
8344         bufchain_init(&c->v.v2.outbuffer);
8345         add234(ssh->channels, c);
8346     }
8347     return c;
8348 }
8349
8350 /*
8351  * This is called when stdout/stderr (the entity to which
8352  * from_backend sends data) manages to clear some backlog.
8353  */
8354 static void ssh_unthrottle(void *handle, int bufsize)
8355 {
8356     Ssh ssh = (Ssh) handle;
8357     if (ssh->version == 1) {
8358         if (ssh->v1_stdout_throttling && bufsize < SSH1_BUFFER_LIMIT) {
8359             ssh->v1_stdout_throttling = 0;
8360             ssh1_throttle(ssh, -1);
8361         }
8362     } else {
8363         if (ssh->mainchan && ssh->mainchan->closes == 0)
8364             ssh2_set_window(ssh->mainchan, OUR_V2_WINSIZE - bufsize);
8365     }
8366 }
8367
8368 void ssh_send_port_open(void *channel, char *hostname, int port, char *org)
8369 {
8370     struct ssh_channel *c = (struct ssh_channel *)channel;
8371     Ssh ssh = c->ssh;
8372     struct Packet *pktout;
8373
8374     logeventf(ssh, "Opening forwarded connection to %s:%d", hostname, port);
8375
8376     if (ssh->version == 1) {
8377         send_packet(ssh, SSH1_MSG_PORT_OPEN,
8378                     PKT_INT, c->localid,
8379                     PKT_STR, hostname,
8380                     PKT_INT, port,
8381                     /* PKT_STR, <org:orgport>, */
8382                     PKT_END);
8383     } else {
8384         pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
8385         ssh2_pkt_addstring(pktout, "direct-tcpip");
8386         ssh2_pkt_adduint32(pktout, c->localid);
8387         c->v.v2.locwindow = OUR_V2_WINSIZE;
8388         ssh2_pkt_adduint32(pktout, c->v.v2.locwindow);/* our window size */
8389         ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT);      /* our max pkt size */
8390         ssh2_pkt_addstring(pktout, hostname);
8391         ssh2_pkt_adduint32(pktout, port);
8392         /*
8393          * We make up values for the originator data; partly it's
8394          * too much hassle to keep track, and partly I'm not
8395          * convinced the server should be told details like that
8396          * about my local network configuration.
8397          */
8398         ssh2_pkt_addstring(pktout, "client-side-connection");
8399         ssh2_pkt_adduint32(pktout, 0);
8400         ssh2_pkt_send(ssh, pktout);
8401     }
8402 }
8403
8404 static Socket ssh_socket(void *handle)
8405 {
8406     Ssh ssh = (Ssh) handle;
8407     return ssh->s;
8408 }
8409
8410 static int ssh_sendok(void *handle)
8411 {
8412     Ssh ssh = (Ssh) handle;
8413     return ssh->send_ok;
8414 }
8415
8416 static int ssh_ldisc(void *handle, int option)
8417 {
8418     Ssh ssh = (Ssh) handle;
8419     if (option == LD_ECHO)
8420         return ssh->echoing;
8421     if (option == LD_EDIT)
8422         return ssh->editing;
8423     return FALSE;
8424 }
8425
8426 static void ssh_provide_ldisc(void *handle, void *ldisc)
8427 {
8428     Ssh ssh = (Ssh) handle;
8429     ssh->ldisc = ldisc;
8430 }
8431
8432 static void ssh_provide_logctx(void *handle, void *logctx)
8433 {
8434     Ssh ssh = (Ssh) handle;
8435     ssh->logctx = logctx;
8436 }
8437
8438 static int ssh_return_exitcode(void *handle)
8439 {
8440     Ssh ssh = (Ssh) handle;
8441     if (ssh->s != NULL)
8442         return -1;
8443     else
8444         return (ssh->exitcode >= 0 ? ssh->exitcode : 0);
8445 }
8446
8447 /*
8448  * cfg_info for SSH is the currently running version of the
8449  * protocol. (1 for 1; 2 for 2; 0 for not-decided-yet.)
8450  */
8451 static int ssh_cfg_info(void *handle)
8452 {
8453     Ssh ssh = (Ssh) handle;
8454     return ssh->version;
8455 }
8456
8457 /*
8458  * Gross hack: pscp will try to start SFTP but fall back to scp1 if
8459  * that fails. This variable is the means by which scp.c can reach
8460  * into the SSH code and find out which one it got.
8461  */
8462 extern int ssh_fallback_cmd(void *handle)
8463 {
8464     Ssh ssh = (Ssh) handle;
8465     return ssh->fallback_cmd;
8466 }
8467
8468 Backend ssh_backend = {
8469     ssh_init,
8470     ssh_free,
8471     ssh_reconfig,
8472     ssh_send,
8473     ssh_sendbuffer,
8474     ssh_size,
8475     ssh_special,
8476     ssh_get_specials,
8477     ssh_socket,
8478     ssh_return_exitcode,
8479     ssh_sendok,
8480     ssh_ldisc,
8481     ssh_provide_ldisc,
8482     ssh_provide_logctx,
8483     ssh_unthrottle,
8484     ssh_cfg_info,
8485     22
8486 };