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