X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/43b5682aa6140913dfd750fe64cc15edb499d2d4..2ccb2fc83a62d8ded4b0287b72384ce22a83000c:/ssh.c diff --git a/ssh.c b/ssh.c index 9517e95f..75610c67 100644 --- a/ssh.c +++ b/ssh.c @@ -166,6 +166,110 @@ static const char *const ssh2_disconnect_reasons[] = { #define BUG_SSH2_REKEY 64 #define BUG_SSH2_PK_SESSIONID 128 +/* + * Codes for terminal modes. + * Most of these are the same in SSH-1 and SSH-2. + * This list is derived from draft-ietf-secsh-connect-25 and + * SSH-1 RFC-1.2.31. + */ +static const struct { + const char* const mode; + int opcode; + enum { TTY_OP_CHAR, TTY_OP_BOOL } type; +} ssh_ttymodes[] = { + /* "V" prefix discarded for special characters relative to SSH specs */ + { "INTR", 1, TTY_OP_CHAR }, + { "QUIT", 2, TTY_OP_CHAR }, + { "ERASE", 3, TTY_OP_CHAR }, + { "KILL", 4, TTY_OP_CHAR }, + { "EOF", 5, TTY_OP_CHAR }, + { "EOL", 6, TTY_OP_CHAR }, + { "EOL2", 7, TTY_OP_CHAR }, + { "START", 8, TTY_OP_CHAR }, + { "STOP", 9, TTY_OP_CHAR }, + { "SUSP", 10, TTY_OP_CHAR }, + { "DSUSP", 11, TTY_OP_CHAR }, + { "REPRINT", 12, TTY_OP_CHAR }, + { "WERASE", 13, TTY_OP_CHAR }, + { "LNEXT", 14, TTY_OP_CHAR }, + { "FLUSH", 15, TTY_OP_CHAR }, + { "SWTCH", 16, TTY_OP_CHAR }, + { "STATUS", 17, TTY_OP_CHAR }, + { "DISCARD", 18, TTY_OP_CHAR }, + { "IGNPAR", 30, TTY_OP_BOOL }, + { "PARMRK", 31, TTY_OP_BOOL }, + { "INPCK", 32, TTY_OP_BOOL }, + { "ISTRIP", 33, TTY_OP_BOOL }, + { "INLCR", 34, TTY_OP_BOOL }, + { "IGNCR", 35, TTY_OP_BOOL }, + { "ICRNL", 36, TTY_OP_BOOL }, + { "IUCLC", 37, TTY_OP_BOOL }, + { "IXON", 38, TTY_OP_BOOL }, + { "IXANY", 39, TTY_OP_BOOL }, + { "IXOFF", 40, TTY_OP_BOOL }, + { "IMAXBEL", 41, TTY_OP_BOOL }, + { "ISIG", 50, TTY_OP_BOOL }, + { "ICANON", 51, TTY_OP_BOOL }, + { "XCASE", 52, TTY_OP_BOOL }, + { "ECHO", 53, TTY_OP_BOOL }, + { "ECHOE", 54, TTY_OP_BOOL }, + { "ECHOK", 55, TTY_OP_BOOL }, + { "ECHONL", 56, TTY_OP_BOOL }, + { "NOFLSH", 57, TTY_OP_BOOL }, + { "TOSTOP", 58, TTY_OP_BOOL }, + { "IEXTEN", 59, TTY_OP_BOOL }, + { "ECHOCTL", 60, TTY_OP_BOOL }, + { "ECHOKE", 61, TTY_OP_BOOL }, + { "PENDIN", 62, TTY_OP_BOOL }, /* XXX is this a real mode? */ + { "OPOST", 70, TTY_OP_BOOL }, + { "OLCUC", 71, TTY_OP_BOOL }, + { "ONLCR", 72, TTY_OP_BOOL }, + { "OCRNL", 73, TTY_OP_BOOL }, + { "ONOCR", 74, TTY_OP_BOOL }, + { "ONLRET", 75, TTY_OP_BOOL }, + { "CS7", 90, TTY_OP_BOOL }, + { "CS8", 91, TTY_OP_BOOL }, + { "PARENB", 92, TTY_OP_BOOL }, + { "PARODD", 93, TTY_OP_BOOL } +}; + +/* Miscellaneous other tty-related constants. */ +#define SSH_TTY_OP_END 0 +/* The opcodes for ISPEED/OSPEED differ between SSH-1 and SSH-2. */ +#define SSH1_TTY_OP_ISPEED 192 +#define SSH1_TTY_OP_OSPEED 193 +#define SSH2_TTY_OP_ISPEED 128 +#define SSH2_TTY_OP_OSPEED 129 + +/* Helper functions for parsing tty-related config. */ +static unsigned int ssh_tty_parse_specchar(char *s) +{ + unsigned int ret; + if (*s) { + char *next = NULL; + ret = ctrlparse(s, &next); + if (!next) ret = s[0]; + } else { + ret = 255; /* special value meaning "don't set" */ + } + return ret; +} +static unsigned int ssh_tty_parse_boolean(char *s) +{ + if (stricmp(s, "yes") == 0 || + stricmp(s, "on") == 0 || + stricmp(s, "true") == 0 || + stricmp(s, "+") == 0) + return 1; /* true */ + else if (stricmp(s, "no") == 0 || + stricmp(s, "off") == 0 || + stricmp(s, "false") == 0 || + stricmp(s, "-") == 0) + return 0; /* false */ + else + return (atoi(s) != 0); +} + #define translate(x) if (type == x) return #x #define translatec(x,ctx) if (type == x && (pkt_ctx & ctx)) return #x static char *ssh1_pkt_type(int type) @@ -256,18 +360,6 @@ static char *ssh2_pkt_type(int pkt_ctx, int type) #undef translate #undef translatec -#define GET_32BIT(cp) \ - (((unsigned long)(unsigned char)(cp)[0] << 24) | \ - ((unsigned long)(unsigned char)(cp)[1] << 16) | \ - ((unsigned long)(unsigned char)(cp)[2] << 8) | \ - ((unsigned long)(unsigned char)(cp)[3])) - -#define PUT_32BIT(cp, value) { \ - (cp)[0] = (unsigned char)((value) >> 24); \ - (cp)[1] = (unsigned char)((value) >> 16); \ - (cp)[2] = (unsigned char)((value) >> 8); \ - (cp)[3] = (unsigned char)(value); } - /* Enumeration values for fields in SSH-1 packets */ enum { PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM, @@ -319,14 +411,19 @@ enum { typedef struct ssh_tag *Ssh; struct Packet; +static struct Packet *ssh1_pkt_init(int pkt_type); static struct Packet *ssh2_pkt_init(int pkt_type); +static void ssh_pkt_ensure(struct Packet *, int length); +static void ssh_pkt_adddata(struct Packet *, void *data, int len); +static void ssh_pkt_addbyte(struct Packet *, unsigned char value); static void ssh2_pkt_addbool(struct Packet *, unsigned char value); -static void ssh2_pkt_adduint32(struct Packet *, unsigned long value); -static void ssh2_pkt_addstring_start(struct Packet *); -static void ssh2_pkt_addstring_str(struct Packet *, char *data); -static void ssh2_pkt_addstring_data(struct Packet *, char *data, int len); -static void ssh2_pkt_addstring(struct Packet *, char *data); +static void ssh_pkt_adduint32(struct Packet *, unsigned long value); +static void ssh_pkt_addstring_start(struct Packet *); +static void ssh_pkt_addstring_str(struct Packet *, char *data); +static void ssh_pkt_addstring_data(struct Packet *, char *data, int len); +static void ssh_pkt_addstring(struct Packet *, char *data); static unsigned char *ssh2_mpint_fmt(Bignum b, int *len); +static void ssh1_pkt_addmp(struct Packet *, Bignum b); static void ssh2_pkt_addmp(struct Packet *, Bignum b); static int ssh2_pkt_construct(Ssh, struct Packet *); static void ssh2_pkt_send(Ssh, struct Packet *); @@ -342,55 +439,33 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, * * - SSH1_BUFFER_LIMIT is the amount of backlog that must build up * on a local data stream before we throttle the whole SSH - * connection (in SSH1 only). Throttling the whole connection is + * connection (in SSH-1 only). Throttling the whole connection is * pretty drastic so we set this high in the hope it won't * happen very often. * * - SSH_MAX_BACKLOG is the amount of backlog that must build up * on the SSH connection itself before we defensively throttle * _all_ local data streams. This is pretty drastic too (though - * thankfully unlikely in SSH2 since the window mechanism should + * thankfully unlikely in SSH-2 since the window mechanism should * ensure that the server never has any need to throttle its end * of the connection), so we set this high as well. * - * - OUR_V2_WINSIZE is the maximum window size we present on SSH2 + * - OUR_V2_WINSIZE is the maximum window size we present on SSH-2 * channels. */ #define SSH1_BUFFER_LIMIT 32768 #define SSH_MAX_BACKLOG 32768 #define OUR_V2_WINSIZE 16384 +#define OUR_V2_MAXPKT 0x4000UL const static struct ssh_signkey *hostkey_algs[] = { &ssh_rsa, &ssh_dss }; -static void *nullmac_make_context(void) -{ - return NULL; -} -static void nullmac_free_context(void *handle) -{ -} -static void nullmac_key(void *handle, unsigned char *key) -{ -} -static void nullmac_generate(void *handle, unsigned char *blk, int len, - unsigned long seq) -{ -} -static int nullmac_verify(void *handle, unsigned char *blk, int len, - unsigned long seq) -{ - return 1; -} -const static struct ssh_mac ssh_mac_none = { - nullmac_make_context, nullmac_free_context, nullmac_key, - nullmac_generate, nullmac_verify, "none", 0 -}; const static struct ssh_mac *macs[] = { - &ssh_sha1, &ssh_md5, &ssh_mac_none + &ssh_hmac_sha1, &ssh_hmac_md5 }; const static struct ssh_mac *buggymacs[] = { - &ssh_sha1_buggy, &ssh_md5, &ssh_mac_none + &ssh_hmac_sha1_buggy, &ssh_hmac_md5 }; static void *ssh_comp_none_init(void) @@ -435,8 +510,10 @@ struct ssh_channel { Ssh ssh; /* pointer back to main context */ unsigned remoteid, localid; int type; + /* True if we opened this channel but server hasn't confirmed. */ + int halfopen; /* - * In SSH1, this value contains four bits: + * In SSH-1, this value contains four bits: * * 1 We have sent SSH1_MSG_CHANNEL_CLOSE. * 2 We have sent SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION. @@ -472,11 +549,11 @@ struct ssh_channel { }; /* - * 2-3-4 tree storing remote->local port forwardings. SSH 1 and SSH - * 2 use this structure in different ways, reflecting SSH 2's + * 2-3-4 tree storing remote->local port forwardings. SSH-1 and SSH-2 + * use this structure in different ways, reflecting SSH-2's * altogether saner approach to port forwarding. * - * In SSH 1, you arrange a remote forwarding by sending the server + * In SSH-1, you arrange a remote forwarding by sending the server * the remote port number, and the local destination host:port. * When a connection comes in, the server sends you back that * host:port pair, and you connect to it. This is a ready-made @@ -488,15 +565,15 @@ struct ssh_channel { * host:port pairs we _are_ trying to forward to, and reject a * connection request from the server if it's not in the list. * - * In SSH 2, each side of the connection minds its own business and + * In SSH-2, each side of the connection minds its own business and * doesn't send unnecessary information to the other. You arrange a * remote forwarding by sending the server just the remote port * number. When a connection comes in, the server tells you which * of its ports was connected to; and _you_ have to remember what * local host:port pair went with that port number. * - * Hence, in SSH 1 this structure is indexed by destination - * host:port pair, whereas in SSH 2 it is indexed by source port. + * Hence, in SSH-1 this structure is indexed by destination + * host:port pair, whereas in SSH-2 it is indexed by source port. */ struct ssh_portfwd; /* forward declaration */ @@ -531,14 +608,15 @@ struct ssh_portfwd { sfree((pf)->sserv), sfree((pf)->dserv)) : (void)0 ), sfree(pf) ) struct Packet { - long length; - int type; - unsigned long sequence; - unsigned char *data; - unsigned char *body; - long savedpos; - long maxlen; - long encrypted_len; /* for SSH2 total-size counting */ + long length; /* length of `data' actually used */ + long forcepad; /* SSH-2: force padding to at least this length */ + int type; /* only used for incoming packets */ + unsigned long sequence; /* SSH-2 incoming sequence number */ + unsigned char *data; /* allocated storage */ + unsigned char *body; /* offset of payload within `data' */ + long savedpos; /* temporary index into `data' (for strings) */ + long maxlen; /* amount of storage allocated for `data' */ + long encrypted_len; /* for SSH-2 total-size counting */ /* * State associated with packet logging @@ -548,9 +626,9 @@ struct Packet { struct logblank_t *blanks; }; -static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, +static void ssh1_protocol(Ssh ssh, void *vin, int inlen, struct Packet *pktin); -static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen, +static void ssh2_protocol(Ssh ssh, void *vin, int inlen, struct Packet *pktin); static void ssh1_protocol_setup(Ssh ssh); static void ssh2_protocol_setup(Ssh ssh); @@ -561,12 +639,12 @@ static void ssh2_add_channel_data(struct ssh_channel *c, char *buf, int len); static void ssh_throttle_all(Ssh ssh, int enable, int bufsize); static void ssh2_set_window(struct ssh_channel *c, unsigned newwin); static int ssh_sendbuffer(void *handle); -static void ssh_do_close(Ssh ssh); +static int ssh_do_close(Ssh ssh, int notify_exit); static unsigned long ssh_pkt_getuint32(struct Packet *pkt); static int ssh2_pkt_getbool(struct Packet *pkt); static void ssh_pkt_getstring(struct Packet *pkt, char **p, int *length); static void ssh2_timer(void *ctx, long now); -static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, +static int do_ssh2_transport(Ssh ssh, void *vin, int inlen, struct Packet *pktin); struct rdpkt1_state_tag { @@ -601,7 +679,8 @@ struct ssh_tag { const struct plug_function_table *fn; /* the above field _must_ be first in the structure */ - SHA_State exhash, exhashbase; + char *v_c, *v_s; + void *exhash; Socket s; @@ -626,7 +705,8 @@ struct ssh_tag { void *cs_comp_ctx, *sc_comp_ctx; const struct ssh_kex *kex; const struct ssh_signkey *hostkey; - unsigned char v2_session_id[20]; + unsigned char v2_session_id[32]; + int v2_session_id_len; void *kex_ctx; char *savedhost; @@ -642,6 +722,8 @@ struct ssh_tag { tree234 *channels; /* indexed by local id */ struct ssh_channel *mainchan; /* primary session channel */ int exitcode; + int close_expected; + int clean_exit; tree234 *rportfwds, *portfwds; @@ -669,6 +751,7 @@ struct ssh_tag { */ int fallback_cmd; + bufchain banner; /* accumulates banners during do_ssh2_authconn */ /* * Used for username and password input. */ @@ -686,7 +769,7 @@ struct ssh_tag { int overall_bufsize; int throttled_all; int v1_stdout_throttling; - int v2_outgoing_sequence; + unsigned long v2_outgoing_sequence; int ssh1_rdpkt_crstate; int ssh2_rdpkt_crstate; @@ -705,10 +788,10 @@ struct ssh_tag { struct rdpkt1_state_tag rdpkt1_state; struct rdpkt2_state_tag rdpkt2_state; - /* ssh1 and ssh2 use this for different things, but both use it */ + /* SSH-1 and SSH-2 use this for different things, but both use it */ int protocol_initial_phase_done; - void (*protocol) (Ssh ssh, unsigned char *in, int inlen, + void (*protocol) (Ssh ssh, void *vin, int inlen, struct Packet *pkt); struct Packet *(*s_rdpkt) (Ssh ssh, unsigned char **data, int *datalen); @@ -721,10 +804,23 @@ struct ssh_tag { Config cfg; /* - * Used to transfer data back from async agent callbacks. + * Used to transfer data back from async callbacks. */ void *agent_response; int agent_response_len; + int user_response; + + /* + * The SSH connection can be set as `frozen', meaning we are + * not currently accepting incoming data from the network. This + * is slightly more serious than setting the _socket_ as + * frozen, because we may already have had data passed to us + * from the network which we need to delay processing until + * after the freeze is lifted, so we also need a bufchain to + * store that data. + */ + int frozen; + bufchain queued_incoming_data; /* * Dispatch table for packet types that we may have to deal @@ -772,7 +868,7 @@ static void logeventf(Ssh ssh, const char *fmt, ...) #define bombout(msg) \ do { \ char *text = dupprintf msg; \ - ssh_do_close(ssh); \ + ssh_do_close(ssh, FALSE); \ logevent(text); \ connection_fatal(ssh->frontend, "%s", text); \ sfree(text); \ @@ -797,6 +893,29 @@ static void end_log_omission(Ssh ssh, struct Packet *pkt) pkt->logmode = PKTLOG_EMIT; } +/* Helper function for common bits of parsing cfg.ttymodes. */ +static void parse_ttymodes(Ssh ssh, char *modes, + void (*do_mode)(void *data, char *mode, char *val), + void *data) +{ + while (*modes) { + char *t = strchr(modes, '\t'); + char *m = snewn(t-modes+1, char); + char *val; + strncpy(m, modes, t-modes); + m[t-modes] = '\0'; + if (*(t+1) == 'A') + val = get_ttymode(ssh->frontend, m); + else + val = dupstr(t+2); + if (val) + do_mode(data, m, val); + sfree(m); + sfree(val); + modes += strlen(modes) + 1; + } +} + static int ssh_channelcmp(void *av, void *bv) { struct ssh_channel *a = (struct ssh_channel *) av; @@ -964,7 +1083,7 @@ static struct Packet *ssh_new_packet(void) { struct Packet *pkt = snew(struct Packet); - pkt->data = NULL; + pkt->body = pkt->data = NULL; pkt->maxlen = 0; pkt->logmode = PKTLOG_EMIT; pkt->nblanks = 0; @@ -1150,7 +1269,8 @@ static struct Packet *ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen) * _Completely_ silly lengths should be stomped on before they * do us any more damage. */ - if (st->len < 0 || st->pad < 0 || st->len + st->pad < 0) { + if (st->len < 0 || st->len > 35000 || st->pad < 4 || + st->len - st->pad < 1 || (st->len + 4) % st->cipherblk != 0) { bombout(("Incoming packet was garbled on decryption")); ssh_free_packet(st->pktin); crStop(NULL); @@ -1264,36 +1384,9 @@ static struct Packet *ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen) crFinish(st->pktin); } -static void ssh1_pktout_size(struct Packet *pkt, int len) +static int s_wrpkt_prepare(Ssh ssh, struct Packet *pkt, int *offset_p) { - int pad, biglen; - - len += 5; /* type and CRC */ - pad = 8 - (len % 8); - biglen = len + pad; - - pkt->length = len - 5; - if (pkt->maxlen < biglen) { - pkt->maxlen = biglen; - pkt->data = sresize(pkt->data, biglen + 4 + APIEXTRA, unsigned char); - } - pkt->body = pkt->data + 4 + pad + 1; -} - -static struct Packet *s_wrpkt_start(int type, int len) -{ - struct Packet *pkt = ssh_new_packet(); - ssh1_pktout_size(pkt, len); - pkt->type = type; - /* Initialise log omission state */ - pkt->nblanks = 0; - pkt->blanks = NULL; - return pkt; -} - -static int s_wrpkt_prepare(Ssh ssh, struct Packet *pkt) -{ - int pad, biglen, i; + int pad, biglen, i, pktoffs; unsigned long crc; #ifdef __SC__ /* @@ -1306,12 +1399,10 @@ static int s_wrpkt_prepare(Ssh ssh, struct Packet *pkt) #endif int len; - pkt->body[-1] = pkt->type; - if (ssh->logctx) - log_packet(ssh->logctx, PKT_OUTGOING, pkt->type, - ssh1_pkt_type(pkt->type), - pkt->body, pkt->length, + log_packet(ssh->logctx, PKT_OUTGOING, pkt->data[12], + ssh1_pkt_type(pkt->data[12]), + pkt->body, pkt->length - (pkt->body - pkt->data), pkt->nblanks, pkt->blanks); sfree(pkt->blanks); pkt->blanks = NULL; pkt->nblanks = 0; @@ -1320,132 +1411,99 @@ static int s_wrpkt_prepare(Ssh ssh, struct Packet *pkt) unsigned char *compblk; int complen; zlib_compress_block(ssh->cs_comp_ctx, - pkt->body - 1, pkt->length + 1, + pkt->data + 12, pkt->length - 12, &compblk, &complen); - ssh1_pktout_size(pkt, complen - 1); - memcpy(pkt->body - 1, compblk, complen); + memcpy(pkt->data + 12, compblk, complen); sfree(compblk); + pkt->length = complen + 12; } - len = pkt->length + 5; /* type and CRC */ + ssh_pkt_ensure(pkt, pkt->length + 4); /* space for CRC */ + pkt->length += 4; + len = pkt->length - 4 - 8; /* len(type+data+CRC) */ pad = 8 - (len % 8); - biglen = len + pad; + pktoffs = 8 - pad; + biglen = len + pad; /* len(padding+type+data+CRC) */ - for (i = 0; i < pad; i++) - pkt->data[i + 4] = random_byte(); - crc = crc32_compute(pkt->data + 4, biglen - 4); - PUT_32BIT(pkt->data + biglen, crc); - PUT_32BIT(pkt->data, len); + for (i = pktoffs; i < 4+8; i++) + pkt->data[i] = random_byte(); + crc = crc32_compute(pkt->data + pktoffs + 4, biglen - 4); /* all ex len */ + PUT_32BIT(pkt->data + pktoffs + 4 + biglen - 4, crc); + PUT_32BIT(pkt->data + pktoffs, len); if (ssh->cipher) - ssh->cipher->encrypt(ssh->v1_cipher_ctx, pkt->data + 4, biglen); + ssh->cipher->encrypt(ssh->v1_cipher_ctx, + pkt->data + pktoffs + 4, biglen); - return biglen + 4; + if (offset_p) *offset_p = pktoffs; + return biglen + 4; /* len(length+padding+type+data+CRC) */ } static void s_wrpkt(Ssh ssh, struct Packet *pkt) { - int len, backlog; - len = s_wrpkt_prepare(ssh, pkt); - backlog = sk_write(ssh->s, (char *)pkt->data, len); + int len, backlog, offset; + len = s_wrpkt_prepare(ssh, pkt, &offset); + backlog = sk_write(ssh->s, (char *)pkt->data + offset, len); if (backlog > SSH_MAX_BACKLOG) ssh_throttle_all(ssh, 1, backlog); + ssh_free_packet(pkt); } static void s_wrpkt_defer(Ssh ssh, struct Packet *pkt) { - int len; - len = s_wrpkt_prepare(ssh, pkt); + int len, offset; + len = s_wrpkt_prepare(ssh, pkt, &offset); if (ssh->deferred_len + len > ssh->deferred_size) { ssh->deferred_size = ssh->deferred_len + len + 128; ssh->deferred_send_data = sresize(ssh->deferred_send_data, ssh->deferred_size, unsigned char); } - memcpy(ssh->deferred_send_data + ssh->deferred_len, pkt->data, len); + memcpy(ssh->deferred_send_data + ssh->deferred_len, + pkt->data + offset, len); ssh->deferred_len += len; + ssh_free_packet(pkt); } /* - * Construct a packet with the specified contents. + * Construct a SSH-1 packet with the specified contents. + * (This all-at-once interface used to be the only one, but now SSH-1 + * packets can also be constructed incrementally.) */ -static struct Packet *construct_packet(Ssh ssh, int pkttype, - va_list ap1, va_list ap2) +static struct Packet *construct_packet(Ssh ssh, int pkttype, va_list ap) { - unsigned char *p, *argp, argchar; - unsigned long argint; - int pktlen, argtype, arglen; + int argtype; Bignum bn; struct Packet *pkt; - pktlen = 0; - while ((argtype = va_arg(ap1, int)) != PKT_END) { - switch (argtype) { - case PKT_INT: - (void) va_arg(ap1, int); - pktlen += 4; - break; - case PKT_CHAR: - (void) va_arg(ap1, int); - pktlen++; - break; - case PKT_DATA: - (void) va_arg(ap1, unsigned char *); - arglen = va_arg(ap1, int); - pktlen += arglen; - break; - case PKT_STR: - argp = va_arg(ap1, unsigned char *); - arglen = strlen((char *)argp); - pktlen += 4 + arglen; - break; - case PKT_BIGNUM: - bn = va_arg(ap1, Bignum); - pktlen += ssh1_bignum_length(bn); - break; - case PKTT_PASSWORD: - case PKTT_DATA: - case PKTT_OTHER: - /* ignore this pass */ - break; - default: - assert(0); - } - } - - pkt = s_wrpkt_start(pkttype, pktlen); - p = pkt->body; + pkt = ssh1_pkt_init(pkttype); - while ((argtype = va_arg(ap2, int)) != PKT_END) { - int offset = p - pkt->body, len = 0; + while ((argtype = va_arg(ap, int)) != PKT_END) { + unsigned char *argp, argchar; + unsigned long argint; + int arglen; switch (argtype) { /* Actual fields in the packet */ case PKT_INT: - argint = va_arg(ap2, int); - PUT_32BIT(p, argint); - len = 4; + argint = va_arg(ap, int); + ssh_pkt_adduint32(pkt, argint); break; case PKT_CHAR: - argchar = (unsigned char) va_arg(ap2, int); - *p = argchar; - len = 1; + argchar = (unsigned char) va_arg(ap, int); + ssh_pkt_addbyte(pkt, argchar); break; case PKT_DATA: - argp = va_arg(ap2, unsigned char *); - arglen = va_arg(ap2, int); - memcpy(p, argp, arglen); - len = arglen; + argp = va_arg(ap, unsigned char *); + arglen = va_arg(ap, int); + ssh_pkt_adddata(pkt, argp, arglen); break; case PKT_STR: - argp = va_arg(ap2, unsigned char *); - arglen = strlen((char *)argp); - PUT_32BIT(p, arglen); - memcpy(p + 4, argp, arglen); - len = arglen + 4; + argp = va_arg(ap, unsigned char *); + ssh_pkt_addstring(pkt, argp); break; case PKT_BIGNUM: - bn = va_arg(ap2, Bignum); - len = ssh1_write_bignum(p, bn); + bn = va_arg(ap, Bignum); + ssh1_pkt_addmp(pkt, bn); break; /* Tokens for modifications to packet logging */ case PKTT_PASSWORD: @@ -1458,16 +1516,6 @@ static struct Packet *construct_packet(Ssh ssh, int pkttype, end_log_omission(ssh, pkt); break; } - p += len; - /* Deal with logfile omission, if required. */ - if (len && (pkt->logmode != PKTLOG_EMIT)) { - pkt->nblanks++; - pkt->blanks = sresize(pkt->blanks, pkt->nblanks, - struct logblank_t); - pkt->blanks[pkt->nblanks-1].offset = offset; - pkt->blanks[pkt->nblanks-1].len = len; - pkt->blanks[pkt->nblanks-1].type = pkt->logmode; - } } return pkt; @@ -1476,27 +1524,21 @@ static struct Packet *construct_packet(Ssh ssh, int pkttype, static void send_packet(Ssh ssh, int pkttype, ...) { struct Packet *pkt; - va_list ap1, ap2; - va_start(ap1, pkttype); - va_start(ap2, pkttype); - pkt = construct_packet(ssh, pkttype, ap1, ap2); - va_end(ap2); - va_end(ap1); + va_list ap; + va_start(ap, pkttype); + pkt = construct_packet(ssh, pkttype, ap); + va_end(ap); s_wrpkt(ssh, pkt); - ssh_free_packet(pkt); } static void defer_packet(Ssh ssh, int pkttype, ...) { struct Packet *pkt; - va_list ap1, ap2; - va_start(ap1, pkttype); - va_start(ap2, pkttype); - pkt = construct_packet(ssh, pkttype, ap1, ap2); - va_end(ap2); - va_end(ap1); + va_list ap; + va_start(ap, pkttype); + pkt = construct_packet(ssh, pkttype, ap); + va_end(ap); s_wrpkt_defer(ssh, pkt); - ssh_free_packet(pkt); } static int ssh_versioncmp(char *a, char *b) @@ -1521,95 +1563,98 @@ static int ssh_versioncmp(char *a, char *b) /* * Utility routines for putting an SSH-protocol `string' and - * `uint32' into a SHA state. + * `uint32' into a hash state. */ -#include -static void sha_string(SHA_State * s, void *str, int len) +static void hash_string(const struct ssh_hash *h, void *s, void *str, int len) { unsigned char lenblk[4]; PUT_32BIT(lenblk, len); - SHA_Bytes(s, lenblk, 4); - SHA_Bytes(s, str, len); + h->bytes(s, lenblk, 4); + h->bytes(s, str, len); } -static void sha_uint32(SHA_State * s, unsigned i) +static void hash_uint32(const struct ssh_hash *h, void *s, unsigned i) { unsigned char intblk[4]; PUT_32BIT(intblk, i); - SHA_Bytes(s, intblk, 4); + h->bytes(s, intblk, 4); } /* - * SSH2 packet construction functions. + * Packet construction functions. Mostly shared between SSH-1 and SSH-2. */ -static void ssh2_pkt_ensure(struct Packet *pkt, int length) +static void ssh_pkt_ensure(struct Packet *pkt, int length) { if (pkt->maxlen < length) { + unsigned char *body = pkt->body; + int offset = body ? pkt->data - body : 0; pkt->maxlen = length + 256; pkt->data = sresize(pkt->data, pkt->maxlen + APIEXTRA, unsigned char); + if (body) pkt->body = pkt->data + offset; } } -static void ssh2_pkt_adddata(struct Packet *pkt, void *data, int len) +static void ssh_pkt_adddata(struct Packet *pkt, void *data, int len) { if (pkt->logmode != PKTLOG_EMIT) { pkt->nblanks++; pkt->blanks = sresize(pkt->blanks, pkt->nblanks, struct logblank_t); - pkt->blanks[pkt->nblanks-1].offset = pkt->length - 6; + assert(pkt->body); + pkt->blanks[pkt->nblanks-1].offset = pkt->length - + (pkt->body - pkt->data); pkt->blanks[pkt->nblanks-1].len = len; pkt->blanks[pkt->nblanks-1].type = pkt->logmode; } pkt->length += len; - ssh2_pkt_ensure(pkt, pkt->length); + ssh_pkt_ensure(pkt, pkt->length); memcpy(pkt->data + pkt->length - len, data, len); } -static void ssh2_pkt_addbyte(struct Packet *pkt, unsigned char byte) +static void ssh_pkt_addbyte(struct Packet *pkt, unsigned char byte) { - ssh2_pkt_adddata(pkt, &byte, 1); -} -static struct Packet *ssh2_pkt_init(int pkt_type) -{ - struct Packet *pkt = ssh_new_packet(); - pkt->length = 5; - ssh2_pkt_addbyte(pkt, (unsigned char) pkt_type); - return pkt; + ssh_pkt_adddata(pkt, &byte, 1); } static void ssh2_pkt_addbool(struct Packet *pkt, unsigned char value) { - ssh2_pkt_adddata(pkt, &value, 1); + ssh_pkt_adddata(pkt, &value, 1); } -static void ssh2_pkt_adduint32(struct Packet *pkt, unsigned long value) +static void ssh_pkt_adduint32(struct Packet *pkt, unsigned long value) { unsigned char x[4]; PUT_32BIT(x, value); - ssh2_pkt_adddata(pkt, x, 4); + ssh_pkt_adddata(pkt, x, 4); } -static void ssh2_pkt_addstring_start(struct Packet *pkt) +static void ssh_pkt_addstring_start(struct Packet *pkt) { - ssh2_pkt_adduint32(pkt, 0); + ssh_pkt_adduint32(pkt, 0); pkt->savedpos = pkt->length; } -static void ssh2_pkt_addstring_str(struct Packet *pkt, char *data) +static void ssh_pkt_addstring_str(struct Packet *pkt, char *data) { - ssh2_pkt_adddata(pkt, data, strlen(data)); + ssh_pkt_adddata(pkt, data, strlen(data)); PUT_32BIT(pkt->data + pkt->savedpos - 4, pkt->length - pkt->savedpos); } -static void ssh2_pkt_addstring_data(struct Packet *pkt, char *data, int len) +static void ssh_pkt_addstring_data(struct Packet *pkt, char *data, int len) { - ssh2_pkt_adddata(pkt, data, len); + ssh_pkt_adddata(pkt, data, len); PUT_32BIT(pkt->data + pkt->savedpos - 4, pkt->length - pkt->savedpos); } -static void ssh2_pkt_addstring(struct Packet *pkt, char *data) +static void ssh_pkt_addstring(struct Packet *pkt, char *data) { - ssh2_pkt_addstring_start(pkt); - ssh2_pkt_addstring_str(pkt, data); + ssh_pkt_addstring_start(pkt); + ssh_pkt_addstring_str(pkt, data); +} +static void ssh1_pkt_addmp(struct Packet *pkt, Bignum b) +{ + int len = ssh1_bignum_length(b); + unsigned char *data = snewn(len, char); + (void) ssh1_write_bignum(data, b); + ssh_pkt_adddata(pkt, data, len); + sfree(data); } static unsigned char *ssh2_mpint_fmt(Bignum b, int *len) { unsigned char *p; int i, n = (bignum_bitcount(b) + 7) / 8; p = snewn(n + 1, unsigned char); - if (!p) - fatalbox("out of memory"); p[0] = 0; for (i = 1; i <= n; i++) p[i] = bignum_byte(b, n - i); @@ -1625,13 +1670,42 @@ static void ssh2_pkt_addmp(struct Packet *pkt, Bignum b) unsigned char *p; int len; p = ssh2_mpint_fmt(b, &len); - ssh2_pkt_addstring_start(pkt); - ssh2_pkt_addstring_data(pkt, (char *)p, len); + ssh_pkt_addstring_start(pkt); + ssh_pkt_addstring_data(pkt, (char *)p, len); sfree(p); } +static struct Packet *ssh1_pkt_init(int pkt_type) +{ + struct Packet *pkt = ssh_new_packet(); + pkt->length = 4 + 8; /* space for length + max padding */ + ssh_pkt_addbyte(pkt, pkt_type); + pkt->body = pkt->data + pkt->length; + return pkt; +} + +/* For legacy code (SSH-1 and -2 packet construction used to be separate) */ +#define ssh2_pkt_ensure(pkt, length) ssh_pkt_ensure(pkt, length) +#define ssh2_pkt_adddata(pkt, data, len) ssh_pkt_adddata(pkt, data, len) +#define ssh2_pkt_addbyte(pkt, byte) ssh_pkt_addbyte(pkt, byte) +#define ssh2_pkt_adduint32(pkt, value) ssh_pkt_adduint32(pkt, value) +#define ssh2_pkt_addstring_start(pkt) ssh_pkt_addstring_start(pkt) +#define ssh2_pkt_addstring_str(pkt, data) ssh_pkt_addstring_str(pkt, data) +#define ssh2_pkt_addstring_data(pkt, data, len) ssh_pkt_addstring_data(pkt, data, len) +#define ssh2_pkt_addstring(pkt, data) ssh_pkt_addstring(pkt, data) + +static struct Packet *ssh2_pkt_init(int pkt_type) +{ + struct Packet *pkt = ssh_new_packet(); + pkt->length = 5; + pkt->forcepad = 0; + ssh_pkt_addbyte(pkt, (unsigned char) pkt_type); + pkt->body = pkt->data + pkt->length; + return pkt; +} + /* - * Construct an SSH2 final-form packet: compress it, encrypt it, + * Construct an SSH-2 final-form packet: compress it, encrypt it, * put the MAC on it. Final packet, ready to be sent, is stored in * pkt->data. Total length is returned. */ @@ -1642,7 +1716,7 @@ static int ssh2_pkt_construct(Ssh ssh, struct Packet *pkt) if (ssh->logctx) log_packet(ssh->logctx, PKT_OUTGOING, pkt->data[5], ssh2_pkt_type(ssh->pkt_ctx, pkt->data[5]), - pkt->data + 6, pkt->length - 6, + pkt->body, pkt->length - (pkt->body - pkt->data), pkt->nblanks, pkt->blanks); sfree(pkt->blanks); pkt->blanks = NULL; pkt->nblanks = 0; @@ -1666,12 +1740,17 @@ static int ssh2_pkt_construct(Ssh ssh, struct Packet *pkt) /* * Add padding. At least four bytes, and must also bring total * length (minus MAC) up to a multiple of the block size. + * If pkt->forcepad is set, make sure the packet is at least that size + * after padding. */ cipherblk = ssh->cscipher ? ssh->cscipher->blksize : 8; /* block size */ cipherblk = cipherblk < 8 ? 8 : cipherblk; /* or 8 if blksize < 8 */ padding = 4; + if (pkt->length + padding < pkt->forcepad) + padding = pkt->forcepad - pkt->length; padding += (cipherblk - (pkt->length + padding) % cipherblk) % cipherblk; + assert(padding <= 255); maclen = ssh->csmac ? ssh->csmac->len : 0; ssh2_pkt_ensure(pkt, pkt->length + padding + maclen); pkt->data[4] = padding; @@ -1721,15 +1800,32 @@ static int ssh2_pkt_construct(Ssh ssh, struct Packet *pkt) * ssh2_pkt_send() or ssh2_pkt_defer() either go straight to one of * these or get queued, and then when the queue is later emptied * the packets are all passed to defer_noqueue(). + * + * When using a CBC-mode cipher, it's necessary to ensure that an + * attacker can't provide data to be encrypted using an IV that they + * know. We ensure this by prefixing each packet that might contain + * user data with an SSH_MSG_IGNORE. This is done using the deferral + * mechanism, so in this case send_noqueue() ends up redirecting to + * defer_noqueue(). If you don't like this inefficiency, don't use + * CBC. */ +static void ssh2_pkt_defer_noqueue(Ssh, struct Packet *, int); +static void ssh_pkt_defersend(Ssh); + /* - * Send an SSH2 packet immediately, without queuing or deferring. + * Send an SSH-2 packet immediately, without queuing or deferring. */ static void ssh2_pkt_send_noqueue(Ssh ssh, struct Packet *pkt) { int len; int backlog; + if (ssh->cscipher != NULL && (ssh->cscipher->flags & SSH_CIPHER_IS_CBC)) { + /* We need to send two packets, so use the deferral mechanism. */ + ssh2_pkt_defer_noqueue(ssh, pkt, FALSE); + ssh_pkt_defersend(ssh); + return; + } len = ssh2_pkt_construct(ssh, pkt); backlog = sk_write(ssh->s, (char *)pkt->data, len); if (backlog > SSH_MAX_BACKLOG) @@ -1745,11 +1841,21 @@ static void ssh2_pkt_send_noqueue(Ssh ssh, struct Packet *pkt) } /* - * Defer an SSH2 packet. + * Defer an SSH-2 packet. */ -static void ssh2_pkt_defer_noqueue(Ssh ssh, struct Packet *pkt) +static void ssh2_pkt_defer_noqueue(Ssh ssh, struct Packet *pkt, int noignore) { - int len = ssh2_pkt_construct(ssh, pkt); + int len; + if (ssh->cscipher != NULL && (ssh->cscipher->flags & SSH_CIPHER_IS_CBC) && + ssh->deferred_len == 0 && !noignore) { + /* + * Interpose an SSH_MSG_IGNORE to ensure that user data don't + * get encrypted with a known IV. + */ + struct Packet *ipkt = ssh2_pkt_init(SSH2_MSG_IGNORE); + ssh2_pkt_defer_noqueue(ssh, ipkt, TRUE); + } + len = ssh2_pkt_construct(ssh, pkt); if (ssh->deferred_len + len > ssh->deferred_size) { ssh->deferred_size = ssh->deferred_len + len + 128; ssh->deferred_send_data = sresize(ssh->deferred_send_data, @@ -1763,7 +1869,7 @@ static void ssh2_pkt_defer_noqueue(Ssh ssh, struct Packet *pkt) } /* - * Queue an SSH2 packet. + * Queue an SSH-2 packet. */ static void ssh2_pkt_queue(Ssh ssh, struct Packet *pkt) { @@ -1789,6 +1895,7 @@ static void ssh2_pkt_send(Ssh ssh, struct Packet *pkt) ssh2_pkt_send_noqueue(ssh, pkt); } +#if 0 /* disused */ /* * Either queue or defer a packet, depending on whether queueing is * set. @@ -1798,12 +1905,13 @@ static void ssh2_pkt_defer(Ssh ssh, struct Packet *pkt) if (ssh->queueing) ssh2_pkt_queue(ssh, pkt); else - ssh2_pkt_defer_noqueue(ssh, pkt); + ssh2_pkt_defer_noqueue(ssh, pkt, FALSE); } +#endif /* * Send the whole deferred data block constructed by - * ssh2_pkt_defer() or SSH1's defer_packet(). + * ssh2_pkt_defer() or SSH-1's defer_packet(). * * The expected use of the defer mechanism is that you call * ssh2_pkt_defer() a few times, then call ssh_pkt_defersend(). If @@ -1834,7 +1942,7 @@ static void ssh_pkt_defersend(Ssh ssh) } /* - * Send all queued SSH2 packets. We send them by means of + * Send all queued SSH-2 packets. We send them by means of * ssh2_pkt_defer_noqueue(), in case they included a pair of * packets that needed to be lumped together. */ @@ -1845,7 +1953,7 @@ static void ssh2_pkt_queuesend(Ssh ssh) assert(!ssh->queueing); for (i = 0; i < ssh->queuelen; i++) - ssh2_pkt_defer_noqueue(ssh, ssh->queue[i]); + ssh2_pkt_defer_noqueue(ssh, ssh->queue[i], FALSE); ssh->queuelen = 0; ssh_pkt_defersend(ssh); @@ -1865,17 +1973,17 @@ void bndebug(char *string, Bignum b) } #endif -static void sha_mpint(SHA_State * s, Bignum b) +static void hash_mpint(const struct ssh_hash *h, void *s, Bignum b) { unsigned char *p; int len; p = ssh2_mpint_fmt(b, &len); - sha_string(s, p, len); + hash_string(h, s, p, len); sfree(p); } /* - * Packet decode functions for both SSH1 and SSH2. + * Packet decode functions for both SSH-1 and SSH-2. */ static unsigned long ssh_pkt_getuint32(struct Packet *pkt) { @@ -1966,7 +2074,7 @@ static Bignum ssh2_pkt_getmp(struct Packet *pkt) } /* - * Helper function to add an SSH2 signature blob to a packet. + * Helper function to add an SSH-2 signature blob to a packet. * Expects to be shown the public key blob as well as the signature * blob. Normally works just like ssh2_pkt_addstring, but will * fiddle with the signature packet if necessary for @@ -2062,7 +2170,7 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring) * sniffing. */ ssh->remote_bugs |= BUG_CHOKES_ON_SSH1_IGNORE; - logevent("We believe remote version has SSH1 ignore bug"); + logevent("We believe remote version has SSH-1 ignore bug"); } if (ssh->cfg.sshbug_plainpw1 == FORCE_ON || @@ -2074,7 +2182,7 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring) * the password. */ ssh->remote_bugs |= BUG_NEEDS_SSH1_PLAIN_PASSWORD; - logevent("We believe remote version needs a plain SSH1 password"); + logevent("We believe remote version needs a plain SSH-1 password"); } if (ssh->cfg.sshbug_rsa1 == FORCE_ON || @@ -2086,7 +2194,7 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring) * an AUTH_RSA message. */ ssh->remote_bugs |= BUG_CHOKES_ON_RSA; - logevent("We believe remote version can't handle RSA authentication"); + logevent("We believe remote version can't handle SSH-1 RSA authentication"); } if (ssh->cfg.sshbug_hmac2 == FORCE_ON || @@ -2099,7 +2207,7 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring) * These versions have the HMAC bug. */ ssh->remote_bugs |= BUG_SSH2_HMAC; - logevent("We believe remote version has SSH2 HMAC bug"); + logevent("We believe remote version has SSH-2 HMAC bug"); } if (ssh->cfg.sshbug_derivekey2 == FORCE_ON || @@ -2112,7 +2220,7 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring) * generate the keys). */ ssh->remote_bugs |= BUG_SSH2_DERIVEKEY; - logevent("We believe remote version has SSH2 key-derivation bug"); + logevent("We believe remote version has SSH-2 key-derivation bug"); } if (ssh->cfg.sshbug_rsapad2 == FORCE_ON || @@ -2120,32 +2228,37 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring) (wc_match("OpenSSH_2.[5-9]*", imp) || wc_match("OpenSSH_3.[0-2]*", imp)))) { /* - * These versions have the SSH2 RSA padding bug. + * These versions have the SSH-2 RSA padding bug. */ ssh->remote_bugs |= BUG_SSH2_RSA_PADDING; - logevent("We believe remote version has SSH2 RSA padding bug"); + logevent("We believe remote version has SSH-2 RSA padding bug"); } if (ssh->cfg.sshbug_pksessid2 == FORCE_ON || (ssh->cfg.sshbug_pksessid2 == AUTO && wc_match("OpenSSH_2.[0-2]*", imp))) { /* - * These versions have the SSH2 session-ID bug in + * These versions have the SSH-2 session-ID bug in * public-key authentication. */ ssh->remote_bugs |= BUG_SSH2_PK_SESSIONID; - logevent("We believe remote version has SSH2 public-key-session-ID bug"); + logevent("We believe remote version has SSH-2 public-key-session-ID bug"); } if (ssh->cfg.sshbug_rekey2 == FORCE_ON || (ssh->cfg.sshbug_rekey2 == AUTO && - (wc_match("Sun_SSH_1.0", imp) || - wc_match("Sun_SSH_1.0.1", imp)))) { + (wc_match("DigiSSH_2.0", imp) || + wc_match("OpenSSH_2.[0-4]*", imp) || + wc_match("OpenSSH_2.5.[0-3]*", imp) || + wc_match("Sun_SSH_1.0", imp) || + wc_match("Sun_SSH_1.0.1", imp) || + /* All versions <= 1.2.6 (they changed their format in 1.2.7) */ + wc_match("WeOnlyDo-*", imp)))) { /* - * These versions have the SSH2 ignore-rekey bug. + * These versions have the SSH-2 rekey bug. */ ssh->remote_bugs |= BUG_SSH2_REKEY; - logevent("We believe remote version has SSH2 ignore-rekey bug"); + logevent("We believe remote version has SSH-2 rekey bug"); } } @@ -2186,23 +2299,20 @@ static int do_ssh_init(Ssh ssh, unsigned char c) crBegin(ssh->do_ssh_init_crstate); - /* Search for the string "SSH-" in the input. */ - s->i = 0; - while (1) { - static const int transS[] = { 1, 2, 2, 1 }; - static const int transH[] = { 0, 0, 3, 0 }; - static const int transminus[] = { 0, 0, 0, -1 }; - if (c == 'S') - s->i = transS[s->i]; - else if (c == 'H') - s->i = transH[s->i]; - else if (c == '-') - s->i = transminus[s->i]; - else - s->i = 0; - if (s->i < 0) - break; - crReturn(1); /* get another character */ + /* Search for a line beginning with the string "SSH-" in the input. */ + for (;;) { + if (c != 'S') goto no; + crReturn(1); + if (c != 'S') goto no; + crReturn(1); + if (c != 'H') goto no; + crReturn(1); + if (c != '-') goto no; + break; + no: + while (c != '\012') + crReturn(1); + crReturn(1); } s->vstrsize = 16; @@ -2232,13 +2342,7 @@ static int do_ssh_init(Ssh ssh, unsigned char c) s->vstring[s->vslen] = 0; s->vstring[strcspn(s->vstring, "\015\012")] = '\0';/* remove EOL chars */ - { - char *vlog; - vlog = snewn(20 + s->vslen, char); - sprintf(vlog, "Server version: %s", s->vstring); - logevent(vlog); - sfree(vlog); - } + logeventf(ssh, "Server version: %s", s->vstring); ssh_detect_bugs(ssh, s->vstring); /* @@ -2282,24 +2386,28 @@ static int do_ssh_init(Ssh ssh, unsigned char c) ssh_fix_verstring(verstring); if (ssh->version == 2) { + size_t len; /* * Hash our version string and their version string. */ - SHA_Init(&ssh->exhashbase); - sha_string(&ssh->exhashbase, verstring, - strcspn(verstring, "\015\012")); - sha_string(&ssh->exhashbase, s->vstring, - strcspn(s->vstring, "\015\012")); - + len = strcspn(verstring, "\015\012"); + ssh->v_c = snewn(len + 1, char); + memcpy(ssh->v_c, verstring, len); + ssh->v_c[len] = 0; + len = strcspn(s->vstring, "\015\012"); + ssh->v_s = snewn(len + 1, char); + memcpy(ssh->v_s, s->vstring, len); + ssh->v_s[len] = 0; + /* - * Initialise SSHv2 protocol. + * Initialise SSH-2 protocol. */ ssh->protocol = ssh2_protocol; ssh2_protocol_setup(ssh); ssh->s_rdpkt = ssh2_rdpkt; } else { /* - * Initialise SSHv1 protocol. + * Initialise SSH-1 protocol. */ ssh->protocol = ssh1_protocol; ssh1_protocol_setup(ssh); @@ -2309,6 +2417,8 @@ static int do_ssh_init(Ssh ssh, unsigned char c) strcspn(verstring, "\015\012"), verstring); sk_write(ssh->s, verstring, strlen(verstring)); sfree(verstring); + if (ssh->version == 2) + do_ssh2_transport(ssh, NULL, -1, NULL); } logeventf(ssh, "Using SSH protocol version %d", ssh->version); @@ -2322,6 +2432,50 @@ static int do_ssh_init(Ssh ssh, unsigned char c) crFinish(0); } +static void ssh_process_incoming_data(Ssh ssh, + unsigned char **data, int *datalen) +{ + struct Packet *pktin = ssh->s_rdpkt(ssh, data, datalen); + if (pktin) { + ssh->protocol(ssh, NULL, 0, pktin); + ssh_free_packet(pktin); + } +} + +static void ssh_queue_incoming_data(Ssh ssh, + unsigned char **data, int *datalen) +{ + bufchain_add(&ssh->queued_incoming_data, *data, *datalen); + *data += *datalen; + *datalen = 0; +} + +static void ssh_process_queued_incoming_data(Ssh ssh) +{ + void *vdata; + unsigned char *data; + int len, origlen; + + while (!ssh->frozen && bufchain_size(&ssh->queued_incoming_data)) { + bufchain_prefix(&ssh->queued_incoming_data, &vdata, &len); + data = vdata; + origlen = len; + + while (!ssh->frozen && len > 0) + ssh_process_incoming_data(ssh, &data, &len); + + if (origlen > len) + bufchain_consume(&ssh->queued_incoming_data, origlen - len); + } +} + +static void ssh_set_frozen(Ssh ssh, int frozen) +{ + if (ssh->s) + sk_set_frozen(ssh->s, frozen); + ssh->frozen = frozen; +} + static void ssh_gotdata(Ssh ssh, unsigned char *data, int datalen) { crBegin(ssh->ssh_gotdata_crstate); @@ -2349,40 +2503,55 @@ static void ssh_gotdata(Ssh ssh, unsigned char *data, int datalen) * everything to s_rdpkt, and then pass the resulting packets * to the proper protocol handler. */ - if (datalen == 0) - crReturnV; + while (1) { - while (datalen > 0) { - struct Packet *pktin = ssh->s_rdpkt(ssh, &data, &datalen); - if (pktin) { - ssh->protocol(ssh, NULL, 0, pktin); - ssh_free_packet(pktin); + while (bufchain_size(&ssh->queued_incoming_data) > 0 || datalen > 0) { + if (ssh->frozen) { + ssh_queue_incoming_data(ssh, &data, &datalen); + /* This uses up all data and cannot cause anything interesting + * to happen; indeed, for anything to happen at all, we must + * return, so break out. */ + break; + } else if (bufchain_size(&ssh->queued_incoming_data) > 0) { + /* This uses up some or all data, and may freeze the + * session. */ + ssh_process_queued_incoming_data(ssh); + } else { + /* This uses up some or all data, and may freeze the + * session. */ + ssh_process_incoming_data(ssh, &data, &datalen); } + /* FIXME this is probably EBW. */ if (ssh->state == SSH_STATE_CLOSED) return; } + /* We're out of data. Go and get some more. */ crReturnV; } crFinishV; } -static void ssh_do_close(Ssh ssh) +static int ssh_do_close(Ssh ssh, int notify_exit) { - int i; + int ret = 0; struct ssh_channel *c; ssh->state = SSH_STATE_CLOSED; + expire_timer_context(ssh); if (ssh->s) { sk_close(ssh->s); ssh->s = NULL; - notify_remote_exit(ssh->frontend); + if (notify_exit) + notify_remote_exit(ssh->frontend); + else + ret = 1; } /* - * Now we must shut down any port and X forwardings going + * Now we must shut down any port- and X-forwarded channels going * through this connection. */ if (ssh->channels) { - for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) { + while (NULL != (c = index234(ssh->channels, 0))) { switch (c->type) { case CHAN_X11: x11_close(c->u.x11.s); @@ -2391,26 +2560,67 @@ static void ssh_do_close(Ssh ssh) pfd_close(c->u.pfd.s); break; } - del234(ssh->channels, c); + del234(ssh->channels, c); /* moving next one to index 0 */ if (ssh->version == 2) bufchain_clear(&c->v.v2.outbuffer); sfree(c); } } + /* + * Go through port-forwardings, and close any associated + * listening sockets. + */ + if (ssh->portfwds) { + struct ssh_portfwd *pf; + while (NULL != (pf = index234(ssh->portfwds, 0))) { + /* Dispose of any listening socket. */ + if (pf->local) + pfd_terminate(pf->local); + del234(ssh->portfwds, pf); /* moving next one to index 0 */ + free_portfwd(pf); + } + } + + return ret; +} + +static void ssh_log(Plug plug, int type, SockAddr addr, int port, + const char *error_msg, int error_code) +{ + Ssh ssh = (Ssh) plug; + char addrbuf[256], *msg; + + sk_getaddr(addr, addrbuf, lenof(addrbuf)); + + if (type == 0) + msg = dupprintf("Connecting to %s port %d", addrbuf, port); + else + msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg); + + logevent(msg); + sfree(msg); } static int ssh_closing(Plug plug, const char *error_msg, int error_code, int calling_back) { Ssh ssh = (Ssh) plug; - ssh_do_close(ssh); - if (error_msg) { - /* A socket error has occurred. */ + int need_notify = ssh_do_close(ssh, FALSE); + + if (!error_msg) { + if (!ssh->close_expected) + error_msg = "Server unexpectedly closed network connection"; + else + error_msg = "Server closed network connection"; + } + + if (need_notify) + notify_remote_exit(ssh->frontend); + + if (error_msg) logevent(error_msg); + if (!ssh->close_expected || !ssh->clean_exit) connection_fatal(ssh->frontend, "%s", error_msg); - } else { - /* Otherwise, the remote side closed the connection normally. */ - } return 0; } @@ -2419,7 +2629,7 @@ static int ssh_receive(Plug plug, int urgent, char *data, int len) Ssh ssh = (Ssh) plug; ssh_gotdata(ssh, (unsigned char *)data, len); if (ssh->state == SSH_STATE_CLOSED) { - ssh_do_close(ssh); + ssh_do_close(ssh, TRUE); return 0; } return 1; @@ -2446,6 +2656,7 @@ static const char *connect_to_host(Ssh ssh, char *host, int port, char **realhost, int nodelay, int keepalive) { static const struct plug_function_table fn_table = { + ssh_log, ssh_closing, ssh_receive, ssh_sent, @@ -2456,8 +2667,6 @@ static const char *connect_to_host(Ssh ssh, char *host, int port, const char *err; ssh->savedhost = snewn(1 + strlen(host), char); - if (!ssh->savedhost) - fatalbox("Out of memory"); strcpy(ssh->savedhost, host); if (port < 0) @@ -2480,11 +2689,6 @@ static const char *connect_to_host(Ssh ssh, char *host, int port, /* * Open socket. */ - { - char addrbuf[100]; - sk_getaddr(addr, addrbuf, 100); - logeventf(ssh, "Connecting to %s port %d", addrbuf, port); - } ssh->fn = &fn_table; ssh->s = new_connection(addr, *realhost, port, 0, 1, nodelay, keepalive, (Plug) ssh, &ssh->cfg); @@ -2506,9 +2710,9 @@ static void ssh1_throttle(Ssh ssh, int adjust) ssh->v1_throttle_count += adjust; assert(ssh->v1_throttle_count >= 0); if (ssh->v1_throttle_count && !old_count) { - sk_set_frozen(ssh->s, 1); + ssh_set_frozen(ssh, 1); } else if (!ssh->v1_throttle_count && old_count) { - sk_set_frozen(ssh->s, 0); + ssh_set_frozen(ssh, 0); } } @@ -2549,7 +2753,7 @@ static void ssh_throttle_all(Ssh ssh, int enable, int bufsize) /* * Username and password input, abstracted off into routines - * reusable in several places - even between SSH1 and SSH2. + * reusable in several places - even between SSH-1 and SSH-2. */ /* Set up a username or password input loop on a given buffer. */ @@ -2632,6 +2836,24 @@ static void ssh_agent_callback(void *sshv, void *reply, int replylen) do_ssh2_authconn(ssh, NULL, -1, NULL); } +static void ssh_dialog_callback(void *sshv, int ret) +{ + Ssh ssh = (Ssh) sshv; + + ssh->user_response = ret; + + if (ssh->version == 1) + do_ssh1_login(ssh, NULL, -1, NULL); + else + do_ssh2_transport(ssh, NULL, -1, NULL); + + /* + * This may have unfrozen the SSH connection, so do a + * queued-data run. + */ + ssh_process_queued_incoming_data(ssh); +} + static void ssh_agentf_callback(void *cv, void *reply, int replylen) { struct ssh_channel *c = (struct ssh_channel *)cv; @@ -2660,6 +2882,39 @@ static void ssh_agentf_callback(void *cv, void *reply, int replylen) } /* + * Client-initiated disconnection. Send a DISCONNECT if `wire_reason' + * non-NULL, otherwise just close the connection. `client_reason' == NULL + * => log `wire_reason'. + */ +static void ssh_disconnect(Ssh ssh, char *client_reason, char *wire_reason, + int code, int clean_exit) +{ + char *error; + if (!client_reason) + client_reason = wire_reason; + if (client_reason) + error = dupprintf("Disconnected: %s", client_reason); + else + error = dupstr("Disconnected"); + if (wire_reason) { + if (ssh->version == 1) { + send_packet(ssh, SSH1_MSG_DISCONNECT, PKT_STR, wire_reason, + PKT_END); + } else if (ssh->version == 2) { + struct Packet *pktout = ssh2_pkt_init(SSH2_MSG_DISCONNECT); + ssh2_pkt_adduint32(pktout, code); + ssh2_pkt_addstring(pktout, wire_reason); + ssh2_pkt_addstring(pktout, "en"); /* language tag */ + ssh2_pkt_send_noqueue(ssh, pktout); + } + } + ssh->close_expected = TRUE; + ssh->clean_exit = clean_exit; + ssh_closing((Plug)ssh, error, 0, 0); + sfree(error); +} + +/* * Handle the key exchange and user authentication phases. */ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, @@ -2693,6 +2948,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, Bignum challenge; char *commentp; int commentlen; + int dlgret; }; crState(do_ssh1_login_state); @@ -2710,14 +2966,14 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, ptr = ssh_pkt_getdata(pktin, 8); if (!ptr) { - bombout(("SSH1 public key packet stopped before random cookie")); + bombout(("SSH-1 public key packet stopped before random cookie")); crStop(0); } memcpy(cookie, ptr, 8); if (!ssh1_pkt_getrsakey(pktin, &servkey, &s->keystr1) || !ssh1_pkt_getrsakey(pktin, &hostkey, &s->keystr2)) { - bombout(("Failed to read SSH1 public keys from public key packet")); + bombout(("Failed to read SSH-1 public keys from public key packet")); crStop(0); } @@ -2756,15 +3012,13 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, */ if (hostkey.bits > hostkey.bytes * 8 || servkey.bits > servkey.bytes * 8) { - bombout(("SSH1 public keys were badly formatted")); + bombout(("SSH-1 public keys were badly formatted")); crStop(0); } s->len = (hostkey.bytes > servkey.bytes ? hostkey.bytes : servkey.bytes); s->rsabuf = snewn(s->len, unsigned char); - if (!s->rsabuf) - fatalbox("Out of memory"); /* * Verify the host key. @@ -2776,14 +3030,33 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int len = rsastr_len(&hostkey); char fingerprint[100]; char *keystr = snewn(len, char); - if (!keystr) - fatalbox("Out of memory"); rsastr_fmt(keystr, &hostkey); rsa_fingerprint(fingerprint, sizeof(fingerprint), &hostkey); - verify_ssh_host_key(ssh->frontend, - ssh->savedhost, ssh->savedport, "rsa", keystr, - fingerprint); + + ssh_set_frozen(ssh, 1); + s->dlgret = verify_ssh_host_key(ssh->frontend, + ssh->savedhost, ssh->savedport, + "rsa", keystr, fingerprint, + ssh_dialog_callback, ssh); sfree(keystr); + if (s->dlgret < 0) { + do { + crReturn(0); + if (pktin) { + bombout(("Unexpected data from server while waiting" + " for user host key response")); + crStop(0); + } + } while (pktin || inlen > 0); + s->dlgret = ssh->user_response; + } + ssh_set_frozen(ssh, 0); + + if (s->dlgret == 0) { + ssh_disconnect(ssh, "User aborted at host key verification", + NULL, 0, TRUE); + crStop(0); + } } for (i = 0; i < 32; i++) { @@ -2802,7 +3075,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, ret = rsaencrypt(s->rsabuf, hostkey.bytes, &servkey); } if (!ret) { - bombout(("SSH1 public key encryptions failed due to bad formatting")); + bombout(("SSH-1 public key encryptions failed due to bad formatting")); crStop(0); } @@ -2819,7 +3092,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, warn = 1; } else if (next_cipher == CIPHER_AES) { /* XXX Probably don't need to mention this. */ - logevent("AES not supported in SSH1, skipping"); + logevent("AES not supported in SSH-1, skipping"); } else { switch (next_cipher) { case CIPHER_3DES: s->cipher_type = SSH_CIPHER_3DES; @@ -2835,7 +3108,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, } if (!cipher_chosen) { if ((s->supported_ciphers_mask & (1 << SSH_CIPHER_3DES)) == 0) - bombout(("Server violates SSH 1 protocol by not " + bombout(("Server violates SSH-1 protocol by not " "supporting 3DES encryption")); else /* shouldn't happen */ @@ -2845,9 +3118,26 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, /* Warn about chosen cipher if necessary. */ if (warn) { - sk_set_frozen(ssh->s, 1); - askalg(ssh->frontend, "cipher", cipher_string); - sk_set_frozen(ssh->s, 0); + ssh_set_frozen(ssh, 1); + s->dlgret = askalg(ssh->frontend, "cipher", cipher_string, + ssh_dialog_callback, ssh); + if (s->dlgret < 0) { + do { + crReturn(0); + if (pktin) { + bombout(("Unexpected data from server while waiting" + " for user response")); + crStop(0); + } + } while (pktin || inlen > 0); + s->dlgret = ssh->user_response; + } + ssh_set_frozen(ssh, 0); + if (s->dlgret == 0) { + ssh_disconnect(ssh, "User aborted at cipher warning", NULL, + 0, TRUE); + crStop(0); + } } } @@ -2919,8 +3209,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, * get_line failed to get a username. * Terminate. */ - logevent("No username provided. Abandoning session."); - ssh_closing((Plug)ssh, NULL, 0, 0); + ssh_disconnect(ssh, "No username provided", NULL, 0, TRUE); crStop(1); } } else { @@ -3007,17 +3296,9 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, s->p = s->response + 5; s->nkeys = GET_32BIT(s->p); s->p += 4; - { - char buf[64]; - sprintf(buf, "Pageant has %d SSH1 keys", s->nkeys); - logevent(buf); - } + logeventf(ssh, "Pageant has %d SSH-1 keys", s->nkeys); for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) { - { - char buf[64]; - sprintf(buf, "Trying Pageant key #%d", s->keyi); - logevent(buf); - } + logeventf(ssh, "Trying Pageant key #%d", s->keyi); if (s->publickey_blob && !memcmp(s->p, s->publickey_blob, s->publickey_bloblen)) { @@ -3175,6 +3456,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, bombout(("TIS challenge packet was badly formed")); crStop(0); } + c_write_str(ssh, "Using TIS authentication.\r\n"); logevent("Received TIS challenge"); if (challengelen > sizeof(s->prompt) - 1) challengelen = sizeof(s->prompt) - 1;/* prevent overrun */ @@ -3208,6 +3490,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, bombout(("CryptoCard challenge packet was badly formed")); crStop(0); } + c_write_str(ssh, "Using CryptoCard authentication.\r\n"); logevent("Received CryptoCard challenge"); if (challengelen > sizeof(s->prompt) - 1) challengelen = sizeof(s->prompt) - 1;/* prevent overrun */ @@ -3226,18 +3509,18 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, if (s->pwpkt_type == SSH1_CMSG_AUTH_RSA) { char *comment = NULL; int type; - char msgbuf[256]; if (flags & FLAG_VERBOSE) c_write_str(ssh, "Trying public key authentication.\r\n"); logeventf(ssh, "Trying public key \"%s\"", filename_to_str(&ssh->cfg.keyfile)); type = key_type(&ssh->cfg.keyfile); if (type != SSH_KEYTYPE_SSH1) { - sprintf(msgbuf, "Key is of wrong type (%s)", - key_type_to_str(type)); - logevent(msgbuf); - c_write_str(ssh, msgbuf); + char *msg = dupprintf("Key is of wrong type (%s)", + key_type_to_str(type)); + logevent(msg); + c_write_str(ssh, msg); c_write_str(ssh, "\r\n"); + sfree(msg); s->tried_publickey = 1; continue; } @@ -3263,12 +3546,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, * because one was supplied on the command line * which has already failed to work). Terminate. */ - send_packet(ssh, SSH1_MSG_DISCONNECT, - PKT_STR, "No more passwords available to try", - PKT_END); - logevent("Unable to authenticate"); - connection_fatal(ssh->frontend, "Unable to authenticate"); - ssh_closing((Plug)ssh, NULL, 0, 0); + ssh_disconnect(ssh, NULL, "Unable to authenticate", 0, FALSE); crStop(1); } } else { @@ -3519,20 +3797,18 @@ void sshfwd_close(struct ssh_channel *c) { Ssh ssh = c->ssh; - if (ssh->state != SSH_STATE_SESSION) { - assert(ssh->state == SSH_STATE_CLOSED); + if (ssh->state == SSH_STATE_CLOSED) return; - } if (c && !c->closes) { /* - * If the channel's remoteid is -1, we have sent + * If halfopen is true, we have sent * CHANNEL_OPEN for this channel, but it hasn't even been * acknowledged by the server. So we must set a close flag * on it now, and then when the server acks the channel * open, we can close it then. */ - if (((int)c->remoteid) != -1) { + if (!c->halfopen) { if (ssh->version == 1) { send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE, PKT_INT, c->remoteid, PKT_END); @@ -3559,10 +3835,8 @@ int sshfwd_write(struct ssh_channel *c, char *buf, int len) { Ssh ssh = c->ssh; - if (ssh->state != SSH_STATE_SESSION) { - assert(ssh->state == SSH_STATE_CLOSED); + if (ssh->state == SSH_STATE_CLOSED) return 0; - } if (ssh->version == 1) { send_packet(ssh, SSH1_MSG_CHANNEL_DATA, @@ -3571,7 +3845,7 @@ int sshfwd_write(struct ssh_channel *c, char *buf, int len) PKT_INT, len, PKT_DATA, buf, len, PKTT_OTHER, PKT_END); /* - * In SSH1 we can return 0 here - implying that forwarded + * In SSH-1 we can return 0 here - implying that forwarded * connections are never individually throttled - because * the only circumstance that can cause throttling will be * the whole SSH connection backing up, in which case @@ -3588,10 +3862,8 @@ void sshfwd_unthrottle(struct ssh_channel *c, int bufsize) { Ssh ssh = c->ssh; - if (ssh->state != SSH_STATE_SESSION) { - assert(ssh->state == SSH_STATE_CLOSED); + if (ssh->state == SSH_STATE_CLOSED) return; - } if (ssh->version == 1) { if (c->v.v1.throttling && bufsize < SSH1_BUFFER_LIMIT) { @@ -3743,13 +4015,13 @@ static void ssh_setup_portfwd(Ssh ssh, const Config *cfg) portfwd_strptr++; sports[n] = '\0'; if (ssh->version == 1 && type == 'R') { - logeventf(ssh, "SSH1 cannot handle remote source address " + logeventf(ssh, "SSH-1 cannot handle remote source address " "spec \"%s\"; ignoring", sports); } else strcpy(saddr, sports); n = 0; } - if (n < 255) sports[n++] = *portfwd_strptr++; + if (n < lenof(sports)-1) sports[n++] = *portfwd_strptr++; } sports[n] = 0; if (type != 'D') { @@ -3757,14 +4029,14 @@ static void ssh_setup_portfwd(Ssh ssh, const Config *cfg) portfwd_strptr++; n = 0; while (*portfwd_strptr && *portfwd_strptr != ':') { - if (n < 255) host[n++] = *portfwd_strptr++; + if (n < lenof(host)-1) host[n++] = *portfwd_strptr++; } host[n] = 0; if (*portfwd_strptr == ':') portfwd_strptr++; n = 0; while (*portfwd_strptr) { - if (n < 255) dports[n++] = *portfwd_strptr++; + if (n < lenof(dports)-1) dports[n++] = *portfwd_strptr++; } dports[n] = 0; portfwd_strptr++; @@ -3780,6 +4052,8 @@ static void ssh_setup_portfwd(Ssh ssh, const Config *cfg) } } else { while (*portfwd_strptr) portfwd_strptr++; + host[0] = 0; + dports[0] = 0; dport = dserv = -1; portfwd_strptr++; /* eat the NUL and move to next one */ } @@ -3862,7 +4136,7 @@ static void ssh_setup_portfwd(Ssh ssh, const Config *cfg) if (ssh->version == 1) { /* * We cannot cancel listening ports on the - * server side in SSH1! There's no message + * server side in SSH-1! There's no message * to support it. Instead, we simply remove * the rportfwd record from the local end * so that any connections the server tries @@ -3875,6 +4149,9 @@ static void ssh_setup_portfwd(Ssh ssh, const Config *cfg) if (epf->saddr) { ssh2_pkt_addstring(pktout, epf->saddr); } else if (ssh->cfg.rport_acceptall) { + /* XXX: ssh->cfg.rport_acceptall may not represent + * what was used to open the original connection, + * since it's reconfigurable. */ ssh2_pkt_addstring(pktout, "0.0.0.0"); } else { ssh2_pkt_addstring(pktout, "127.0.0.1"); @@ -3921,7 +4198,7 @@ static void ssh_setup_portfwd(Ssh ssh, const Config *cfg) if (epf->type == 'L') { const char *err = pfd_addforward(epf->daddr, epf->dport, epf->saddr, epf->sport, - ssh, &ssh->cfg, + ssh, cfg, &epf->local, epf->addressfamily); @@ -3933,7 +4210,7 @@ static void ssh_setup_portfwd(Ssh ssh, const Config *cfg) } else if (epf->type == 'D') { const char *err = pfd_addforward(NULL, -1, epf->saddr, epf->sport, - ssh, &ssh->cfg, + ssh, cfg, &epf->local, epf->addressfamily); @@ -3989,7 +4266,7 @@ static void ssh_setup_portfwd(Ssh ssh, const Config *cfg) ssh2_pkt_addbool(pktout, 1);/* want reply */ if (epf->saddr) { ssh2_pkt_addstring(pktout, epf->saddr); - } else if (ssh->cfg.rport_acceptall) { + } else if (cfg->rport_acceptall) { ssh2_pkt_addstring(pktout, "0.0.0.0"); } else { ssh2_pkt_addstring(pktout, "127.0.0.1"); @@ -4054,6 +4331,7 @@ static void ssh1_smsg_x11_open(Ssh ssh, struct Packet *pktin) logevent ("Opening X11 forward connection succeeded"); c->remoteid = remoteid; + c->halfopen = FALSE; c->localid = alloc_channel_id(ssh); c->closes = 0; c->v.v1.throttling = 0; @@ -4082,6 +4360,7 @@ static void ssh1_smsg_agent_open(Ssh ssh, struct Packet *pktin) c = snew(struct ssh_channel); c->ssh = ssh; c->remoteid = remoteid; + c->halfopen = FALSE; c->localid = alloc_channel_id(ssh); c->closes = 0; c->v.v1.throttling = 0; @@ -4102,7 +4381,7 @@ static void ssh1_msg_port_open(Ssh ssh, struct Packet *pktin) struct ssh_rportfwd pf, *pfp; int remoteid; int hostsize, port; - char *host, buf[1024]; + char *host; const char *e; c = snew(struct ssh_channel); c->ssh = ssh; @@ -4119,26 +4398,23 @@ static void ssh1_msg_port_open(Ssh ssh, struct Packet *pktin) pfp = find234(ssh->rportfwds, &pf, NULL); if (pfp == NULL) { - sprintf(buf, "Rejected remote port open request for %s:%d", - pf.dhost, port); - logevent(buf); + logeventf(ssh, "Rejected remote port open request for %s:%d", + pf.dhost, port); send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE, PKT_INT, remoteid, PKT_END); } else { - sprintf(buf, "Received remote port open request for %s:%d", - pf.dhost, port); - logevent(buf); + logeventf(ssh, "Received remote port open request for %s:%d", + pf.dhost, port); e = pfd_newconnect(&c->u.pfd.s, pf.dhost, port, c, &ssh->cfg, pfp->pfrec->addressfamily); if (e != NULL) { - char buf[256]; - sprintf(buf, "Port open failed: %s", e); - logevent(buf); + logeventf(ssh, "Port open failed: %s", e); sfree(c); send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE, PKT_INT, remoteid, PKT_END); } else { c->remoteid = remoteid; + c->halfopen = FALSE; c->localid = alloc_channel_id(ssh); c->closes = 0; c->v.v1.throttling = 0; @@ -4161,6 +4437,7 @@ static void ssh1_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin) c = find234(ssh->channels, &remoteid, ssh_channelfind); if (c && c->type == CHAN_SOCKDATA_DORMANT) { c->remoteid = localid; + c->halfopen = FALSE; c->type = CHAN_SOCKDATA; c->v.v1.throttling = 0; pfd_confirm(c->u.pfd.s); @@ -4198,7 +4475,7 @@ static void ssh1_msg_channel_close(Ssh ssh, struct Packet *pktin) unsigned i = ssh_pkt_getuint32(pktin); struct ssh_channel *c; c = find234(ssh->channels, &i, ssh_channelfind); - if (c && ((int)c->remoteid) != -1) { + if (c && !c->halfopen) { int closetype; closetype = (pktin->type == SSH1_MSG_CHANNEL_CLOSE ? 1 : 2); @@ -4240,7 +4517,7 @@ static void ssh1_msg_channel_data(Ssh ssh, struct Packet *pktin) /* Data sent down one of our channels. */ int i = ssh_pkt_getuint32(pktin); char *p; - unsigned int len; + int len; struct ssh_channel *c; ssh_pkt_getstring(pktin, &p, &len); @@ -4307,11 +4584,8 @@ static void ssh1_msg_channel_data(Ssh ssh, struct Packet *pktin) static void ssh1_smsg_exit_status(Ssh ssh, struct Packet *pktin) { - char buf[100]; ssh->exitcode = ssh_pkt_getuint32(pktin); - sprintf(buf, "Server sent command exit status %d", - ssh->exitcode); - logevent(buf); + logeventf(ssh, "Server sent command exit status %d", ssh->exitcode); send_packet(ssh, SSH1_CMSG_EXIT_CONFIRMATION, PKT_END); /* * In case `helpful' firewalls or proxies tack @@ -4320,9 +4594,30 @@ static void ssh1_smsg_exit_status(Ssh ssh, struct Packet *pktin) * encrypted packet, we close the session once * we've sent EXIT_CONFIRMATION. */ - ssh_closing((Plug)ssh, NULL, 0, 0); + ssh_disconnect(ssh, NULL, NULL, 0, TRUE); } +/* Helper function to deal with sending tty modes for REQUEST_PTY */ +static void ssh1_send_ttymode(void *data, char *mode, char *val) +{ + struct Packet *pktout = (struct Packet *)data; + int i = 0; + unsigned int arg = 0; + while (strcmp(mode, ssh_ttymodes[i].mode) != 0) i++; + if (i == lenof(ssh_ttymodes)) return; + switch (ssh_ttymodes[i].type) { + case TTY_OP_CHAR: + arg = ssh_tty_parse_specchar(val); + break; + case TTY_OP_BOOL: + arg = ssh_tty_parse_boolean(val); + break; + } + ssh2_pkt_addbyte(pktout, ssh_ttymodes[i].opcode); + ssh2_pkt_addbyte(pktout, arg); +} + + static void do_ssh1_connection(Ssh ssh, unsigned char *in, int inlen, struct Packet *pktin) { @@ -4367,14 +4662,23 @@ static void do_ssh1_connection(Ssh ssh, unsigned char *in, int inlen, ssh->x11auth = x11_invent_auth(proto, sizeof(proto), data, sizeof(data), ssh->cfg.x11_auth); x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display); + /* + * Note that while we blank the X authentication data here, we don't + * take any special action to blank the start of an X11 channel, + * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection + * without having session blanking enabled is likely to leak your + * cookie into the log. + */ if (ssh->v1_local_protoflags & SSH1_PROTOFLAG_SCREEN_NUMBER) { send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING, - PKT_STR, proto, PKT_STR, data, + PKT_STR, proto, + PKTT_PASSWORD, PKT_STR, data, PKTT_OTHER, PKT_INT, x11_get_screen_number(ssh->cfg.x11_display), PKT_END); } else { send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING, - PKT_STR, proto, PKT_STR, data, PKT_END); + PKT_STR, proto, + PKTT_PASSWORD, PKT_STR, data, PKTT_OTHER, PKT_END); } do { crReturnV; @@ -4396,19 +4700,26 @@ static void do_ssh1_connection(Ssh ssh, unsigned char *in, int inlen, ssh->packet_dispatch[SSH1_MSG_PORT_OPEN] = ssh1_msg_port_open; if (!ssh->cfg.nopty) { + struct Packet *pkt; /* Unpick the terminal-speed string. */ /* XXX perhaps we should allow no speeds to be sent. */ ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */ sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed); /* Send the pty request. */ - send_packet(ssh, SSH1_CMSG_REQUEST_PTY, - PKT_STR, ssh->cfg.termtype, - PKT_INT, ssh->term_height, - PKT_INT, ssh->term_width, - PKT_INT, 0, PKT_INT, 0, /* width,height in pixels */ - PKT_CHAR, 192, PKT_INT, ssh->ispeed, /* TTY_OP_ISPEED */ - PKT_CHAR, 193, PKT_INT, ssh->ospeed, /* TTY_OP_OSPEED */ - PKT_CHAR, 0, PKT_END); + pkt = ssh1_pkt_init(SSH1_CMSG_REQUEST_PTY); + ssh_pkt_addstring(pkt, ssh->cfg.termtype); + ssh_pkt_adduint32(pkt, ssh->term_height); + ssh_pkt_adduint32(pkt, ssh->term_width); + ssh_pkt_adduint32(pkt, 0); /* width in pixels */ + ssh_pkt_adduint32(pkt, 0); /* height in pixels */ + parse_ttymodes(ssh, ssh->cfg.ttymodes, + ssh1_send_ttymode, (void *)pkt); + ssh_pkt_addbyte(pkt, SSH1_TTY_OP_ISPEED); + ssh_pkt_adduint32(pkt, ssh->ispeed); + ssh_pkt_addbyte(pkt, SSH1_TTY_OP_OSPEED); + ssh_pkt_adduint32(pkt, ssh->ospeed); + ssh_pkt_addbyte(pkt, SSH_TTY_OP_END); + s_wrpkt(ssh, pkt); ssh->state = SSH_STATE_INTERMED; do { crReturnV; @@ -4450,12 +4761,14 @@ static void do_ssh1_connection(Ssh ssh, unsigned char *in, int inlen, /* * Start the shell or command. * - * Special case: if the first-choice command is an SSH2 + * Special case: if the first-choice command is an SSH-2 * subsystem (hence not usable here) and the second choice * exists, we fall straight back to that. */ { char *cmd = ssh->cfg.remote_cmd_ptr; + + if (!cmd) cmd = ssh->cfg.remote_cmd; if (ssh->cfg.ssh_subsys && ssh->cfg.remote_cmd_ptr2) { cmd = ssh->cfg.remote_cmd_ptr2; @@ -4513,17 +4826,15 @@ static void do_ssh1_connection(Ssh ssh, unsigned char *in, int inlen, } /* - * Handle the top-level SSH2 protocol. + * Handle the top-level SSH-2 protocol. */ static void ssh1_msg_debug(Ssh ssh, struct Packet *pktin) { - char *buf, *msg; + char *msg; int msglen; ssh_pkt_getstring(pktin, &msg, &msglen); - buf = dupprintf("Remote debug message: %.*s", msglen, msg); - logevent(buf); - sfree(buf); + logeventf(ssh, "Remote debug message: %.*s", msglen, msg); } static void ssh1_msg_disconnect(Ssh ssh, struct Packet *pktin) @@ -4536,7 +4847,7 @@ static void ssh1_msg_disconnect(Ssh ssh, struct Packet *pktin) bombout(("Server sent disconnect message:\n\"%.*s\"", msglen, msg)); } -void ssh_msg_ignore(Ssh ssh, struct Packet *pktin) +static void ssh_msg_ignore(Ssh ssh, struct Packet *pktin) { /* Do nothing, because we're ignoring it! Duhh. */ } @@ -4559,9 +4870,10 @@ static void ssh1_protocol_setup(Ssh ssh) ssh->packet_dispatch[SSH1_MSG_DEBUG] = ssh1_msg_debug; } -static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, +static void ssh1_protocol(Ssh ssh, void *vin, int inlen, struct Packet *pktin) { + unsigned char *in=(unsigned char*)vin; if (ssh->state == SSH_STATE_CLOSED) return; @@ -4612,39 +4924,64 @@ static int in_commasep_string(char *needle, char *haystack, int haylen) } /* - * SSH2 key creation method. + * Similar routine for checking whether we have the first string in a list. */ -static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H, - unsigned char *sessid, char chr, +static int first_in_commasep_string(char *needle, char *haystack, int haylen) +{ + int needlen; + if (!needle || !haystack) /* protect against null pointers */ + return 0; + needlen = strlen(needle); + /* + * Is it at the start of the string? + */ + if (haylen >= needlen && /* haystack is long enough */ + !memcmp(needle, haystack, needlen) && /* initial match */ + (haylen == needlen || haystack[needlen] == ',') + /* either , or EOS follows */ + ) + return 1; + return 0; +} + + +/* + * SSH-2 key creation method. + */ +static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H, char chr, unsigned char *keyspace) { - SHA_State s; - /* First 20 bytes. */ - SHA_Init(&s); + const struct ssh_hash *h = ssh->kex->hash; + void *s; + /* First hlen bytes. */ + s = h->init(); if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY)) - sha_mpint(&s, K); - SHA_Bytes(&s, H, 20); - SHA_Bytes(&s, &chr, 1); - SHA_Bytes(&s, sessid, 20); - SHA_Final(&s, keyspace); - /* Next 20 bytes. */ - SHA_Init(&s); + hash_mpint(h, s, K); + h->bytes(s, H, h->hlen); + h->bytes(s, &chr, 1); + h->bytes(s, ssh->v2_session_id, ssh->v2_session_id_len); + h->final(s, keyspace); + /* Next hlen bytes. */ + s = h->init(); if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY)) - sha_mpint(&s, K); - SHA_Bytes(&s, H, 20); - SHA_Bytes(&s, keyspace, 20); - SHA_Final(&s, keyspace + 20); + hash_mpint(h, s, K); + h->bytes(s, H, h->hlen); + h->bytes(s, keyspace, h->hlen); + h->final(s, keyspace + h->hlen); } /* - * Handle the SSH2 transport layer. + * Handle the SSH-2 transport layer. */ -static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, +static int do_ssh2_transport(Ssh ssh, void *vin, int inlen, struct Packet *pktin) { + unsigned char *in = (unsigned char *)vin; struct do_ssh2_transport_state { - int nbits, pbits, warn; + int nbits, pbits, warn_kex, warn_cscipher, warn_sccipher; Bignum p, g, e, f, K; + void *our_kexinit; + int our_kexinitlen; int kex_init_value, kex_reply_value; const struct ssh_mac **maclist; int nmacs; @@ -4657,14 +4994,17 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, char *hostkeydata, *sigdata, *keystr, *fingerprint; int hostkeylen, siglen; void *hkey; /* actual host key */ - unsigned char exchange_hash[20]; + unsigned char exchange_hash[32]; int n_preferred_kex; - const struct ssh_kex *preferred_kex[KEX_MAX]; + const struct ssh_kexes *preferred_kex[KEX_MAX]; int n_preferred_ciphers; const struct ssh2_ciphers *preferred_ciphers[CIPHER_MAX]; const struct ssh_compress *preferred_comp; int got_session_id, activated_authconn; struct Packet *pktout; + int dlgret; + int guessok; + int ignorepkt; }; crState(do_ssh2_transport_state); @@ -4737,6 +5077,9 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, case CIPHER_AES: s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_aes; break; + case CIPHER_ARCFOUR: + s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_arcfour; + break; case CIPHER_WARN: /* Flag for later. Don't bother if it's the last in * the list. */ @@ -4776,12 +5119,14 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, ssh2_pkt_addstring_start(s->pktout); commalist_started = 0; for (i = 0; i < s->n_preferred_kex; i++) { - const struct ssh_kex *k = s->preferred_kex[i]; + const struct ssh_kexes *k = s->preferred_kex[i]; if (!k) continue; /* warning flag */ - if (commalist_started) - ssh2_pkt_addstring_str(s->pktout, ","); - ssh2_pkt_addstring_str(s->pktout, s->preferred_kex[i]->name); - commalist_started = 1; + for (j = 0; j < k->nkexes; j++) { + if (commalist_started) + ssh2_pkt_addstring_str(s->pktout, ","); + ssh2_pkt_addstring_str(s->pktout, k->list[j]->name); + commalist_started = 1; + } } /* List server host key algorithms. */ ssh2_pkt_addstring_start(s->pktout); @@ -4862,22 +5207,21 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, ssh2_pkt_adduint32(s->pktout, 0); } - ssh->exhash = ssh->exhashbase; - sha_string(&ssh->exhash, s->pktout->data + 5, s->pktout->length - 5); + s->our_kexinitlen = s->pktout->length - 5; + s->our_kexinit = snewn(s->our_kexinitlen, unsigned char); + memcpy(s->our_kexinit, s->pktout->data + 5, s->our_kexinitlen); ssh2_pkt_send_noqueue(ssh, s->pktout); if (!pktin) crWaitUntil(pktin); - if (pktin->length > 5) - sha_string(&ssh->exhash, pktin->data + 5, pktin->length - 5); /* * Now examine the other side's KEXINIT to see what we're up * to. */ { - char *str; + char *str, *preferred; int i, j, len; if (pktin->type != SSH2_MSG_KEXINIT) { @@ -4892,31 +5236,39 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, s->scmac_tobe = NULL; s->cscomp_tobe = NULL; s->sccomp_tobe = NULL; + s->warn_kex = s->warn_cscipher = s->warn_sccipher = FALSE; + pktin->savedpos += 16; /* skip garbage cookie */ ssh_pkt_getstring(pktin, &str, &len); /* key exchange algorithms */ - s->warn = 0; + + preferred = NULL; for (i = 0; i < s->n_preferred_kex; i++) { - const struct ssh_kex *k = s->preferred_kex[i]; + const struct ssh_kexes *k = s->preferred_kex[i]; if (!k) { - s->warn = 1; - } else if (in_commasep_string(k->name, str, len)) { - ssh->kex = k; + s->warn_kex = TRUE; + } else { + for (j = 0; j < k->nkexes; j++) { + if (!preferred) preferred = k->list[j]->name; + if (in_commasep_string(k->list[j]->name, str, len)) { + ssh->kex = k->list[j]; + break; + } + } } - if (ssh->kex) { - if (s->warn) { - sk_set_frozen(ssh->s, 1); - askalg(ssh->frontend, "key-exchange algorithm", - ssh->kex->name); - sk_set_frozen(ssh->s, 0); - } + if (ssh->kex) break; - } } if (!ssh->kex) { bombout(("Couldn't agree a key exchange algorithm (available: %s)", str ? str : "(null)")); crStop(0); } + /* + * Note that the server's guess is considered wrong if it doesn't match + * the first algorithm in our list, even if it's still the algorithm + * we end up using. + */ + s->guessok = first_in_commasep_string(preferred, str, len); ssh_pkt_getstring(pktin, &str, &len); /* host key algorithms */ for (i = 0; i < lenof(hostkey_algs); i++) { if (in_commasep_string(hostkey_algs[i]->name, str, len)) { @@ -4924,12 +5276,13 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, break; } } + s->guessok = s->guessok && + first_in_commasep_string(hostkey_algs[0]->name, str, len); ssh_pkt_getstring(pktin, &str, &len); /* client->server cipher */ - s->warn = 0; for (i = 0; i < s->n_preferred_ciphers; i++) { const struct ssh2_ciphers *c = s->preferred_ciphers[i]; if (!c) { - s->warn = 1; + s->warn_cscipher = TRUE; } else { for (j = 0; j < c->nciphers; j++) { if (in_commasep_string(c->list[j]->name, str, len)) { @@ -4938,15 +5291,8 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, } } } - if (s->cscipher_tobe) { - if (s->warn) { - sk_set_frozen(ssh->s, 1); - askalg(ssh->frontend, "client-to-server cipher", - s->cscipher_tobe->name); - sk_set_frozen(ssh->s, 0); - } + if (s->cscipher_tobe) break; - } } if (!s->cscipher_tobe) { bombout(("Couldn't agree a client-to-server cipher (available: %s)", @@ -4955,11 +5301,10 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, } ssh_pkt_getstring(pktin, &str, &len); /* server->client cipher */ - s->warn = 0; for (i = 0; i < s->n_preferred_ciphers; i++) { const struct ssh2_ciphers *c = s->preferred_ciphers[i]; if (!c) { - s->warn = 1; + s->warn_sccipher = TRUE; } else { for (j = 0; j < c->nciphers; j++) { if (in_commasep_string(c->list[j]->name, str, len)) { @@ -4968,15 +5313,8 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, } } } - if (s->sccipher_tobe) { - if (s->warn) { - sk_set_frozen(ssh->s, 1); - askalg(ssh->frontend, "server-to-client cipher", - s->sccipher_tobe->name); - sk_set_frozen(ssh->s, 0); - } + if (s->sccipher_tobe) break; - } } if (!s->sccipher_tobe) { bombout(("Couldn't agree a server-to-client cipher (available: %s)", @@ -5016,6 +5354,96 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, break; } } + ssh_pkt_getstring(pktin, &str, &len); /* client->server language */ + ssh_pkt_getstring(pktin, &str, &len); /* server->client language */ + s->ignorepkt = ssh2_pkt_getbool(pktin) && !s->guessok; + + if (s->warn_kex) { + ssh_set_frozen(ssh, 1); + s->dlgret = askalg(ssh->frontend, "key-exchange algorithm", + ssh->kex->name, + ssh_dialog_callback, ssh); + if (s->dlgret < 0) { + do { + crReturn(0); + if (pktin) { + bombout(("Unexpected data from server while" + " waiting for user response")); + crStop(0); + } + } while (pktin || inlen > 0); + s->dlgret = ssh->user_response; + } + ssh_set_frozen(ssh, 0); + if (s->dlgret == 0) { + ssh_disconnect(ssh, "User aborted at kex warning", NULL, + 0, TRUE); + crStop(0); + } + } + + if (s->warn_cscipher) { + ssh_set_frozen(ssh, 1); + s->dlgret = askalg(ssh->frontend, + "client-to-server cipher", + s->cscipher_tobe->name, + ssh_dialog_callback, ssh); + if (s->dlgret < 0) { + do { + crReturn(0); + if (pktin) { + bombout(("Unexpected data from server while" + " waiting for user response")); + crStop(0); + } + } while (pktin || inlen > 0); + s->dlgret = ssh->user_response; + } + ssh_set_frozen(ssh, 0); + if (s->dlgret == 0) { + ssh_disconnect(ssh, "User aborted at cipher warning", NULL, + 0, TRUE); + crStop(0); + } + } + + if (s->warn_sccipher) { + ssh_set_frozen(ssh, 1); + s->dlgret = askalg(ssh->frontend, + "server-to-client cipher", + s->sccipher_tobe->name, + ssh_dialog_callback, ssh); + if (s->dlgret < 0) { + do { + crReturn(0); + if (pktin) { + bombout(("Unexpected data from server while" + " waiting for user response")); + crStop(0); + } + } while (pktin || inlen > 0); + s->dlgret = ssh->user_response; + } + ssh_set_frozen(ssh, 0); + if (s->dlgret == 0) { + ssh_disconnect(ssh, "User aborted at cipher warning", NULL, + 0, TRUE); + crStop(0); + } + } + + ssh->exhash = ssh->kex->hash->init(); + hash_string(ssh->kex->hash, ssh->exhash, ssh->v_c, strlen(ssh->v_c)); + hash_string(ssh->kex->hash, ssh->exhash, ssh->v_s, strlen(ssh->v_s)); + hash_string(ssh->kex->hash, ssh->exhash, + s->our_kexinit, s->our_kexinitlen); + sfree(s->our_kexinit); + if (pktin->length > 5) + hash_string(ssh->kex->hash, ssh->exhash, + pktin->data + 5, pktin->length - 5); + + if (s->ignorepkt) /* first_kex_packet_follows */ + crWaitUntil(pktin); /* Ignore packet */ } /* @@ -5030,10 +5458,10 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, scbits = s->sccipher_tobe->keylen; s->nbits = (csbits > scbits ? csbits : scbits); } - /* The keys only have 160-bit entropy, since they're based on - * a SHA-1 hash. So cap the key size at 160 bits. */ - if (s->nbits > 160) - s->nbits = 160; + /* The keys only have hlen-bit entropy, since they're based on + * a hash. So cap the key size at hlen bits. */ + if (s->nbits > ssh->kex->hash->hlen * 8) + s->nbits = ssh->kex->hash->hlen * 8; /* * If we're doing Diffie-Hellman group exchange, start by @@ -5078,16 +5506,19 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, /* * Now generate and send e for Diffie-Hellman. */ + set_busy_status(ssh->frontend, BUSY_CPU); /* this can take a while */ s->e = dh_create_e(ssh->kex_ctx, s->nbits * 2); s->pktout = ssh2_pkt_init(s->kex_init_value); ssh2_pkt_addmp(s->pktout, s->e); ssh2_pkt_send_noqueue(ssh, s->pktout); + set_busy_status(ssh->frontend, BUSY_WAITING); /* wait for server */ crWaitUntil(pktin); if (pktin->type != s->kex_reply_value) { bombout(("expected key exchange reply packet from server")); crStop(0); } + set_busy_status(ssh->frontend, BUSY_CPU); /* cogitate */ ssh_pkt_getstring(pktin, &s->hostkeydata, &s->hostkeylen); s->f = ssh2_pkt_getmp(pktin); if (!s->f) { @@ -5098,29 +5529,35 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, s->K = dh_find_K(ssh->kex_ctx, s->f); - sha_string(&ssh->exhash, s->hostkeydata, s->hostkeylen); - if (ssh->kex == &ssh_diffiehellman_gex) { - sha_uint32(&ssh->exhash, s->pbits); - sha_mpint(&ssh->exhash, s->p); - sha_mpint(&ssh->exhash, s->g); + /* We assume everything from now on will be quick, and it might + * involve user interaction. */ + set_busy_status(ssh->frontend, BUSY_NOT); + + hash_string(ssh->kex->hash, ssh->exhash, s->hostkeydata, s->hostkeylen); + if (!ssh->kex->pdata) { + hash_uint32(ssh->kex->hash, ssh->exhash, s->pbits); + hash_mpint(ssh->kex->hash, ssh->exhash, s->p); + hash_mpint(ssh->kex->hash, ssh->exhash, s->g); } - sha_mpint(&ssh->exhash, s->e); - sha_mpint(&ssh->exhash, s->f); - sha_mpint(&ssh->exhash, s->K); - SHA_Final(&ssh->exhash, s->exchange_hash); + hash_mpint(ssh->kex->hash, ssh->exhash, s->e); + hash_mpint(ssh->kex->hash, ssh->exhash, s->f); + hash_mpint(ssh->kex->hash, ssh->exhash, s->K); + assert(ssh->kex->hash->hlen <= sizeof(s->exchange_hash)); + ssh->kex->hash->final(ssh->exhash, s->exchange_hash); dh_cleanup(ssh->kex_ctx); ssh->kex_ctx = NULL; #if 0 debug(("Exchange hash is:\n")); - dmemdump(s->exchange_hash, 20); + dmemdump(s->exchange_hash, ssh->kex->hash->hlen); #endif s->hkey = ssh->hostkey->newkey(s->hostkeydata, s->hostkeylen); if (!s->hkey || !ssh->hostkey->verifysig(s->hkey, s->sigdata, s->siglen, - (char *)s->exchange_hash, 20)) { + (char *)s->exchange_hash, + ssh->kex->hash->hlen)) { bombout(("Server's host key did not match the signature supplied")); crStop(0); } @@ -5131,11 +5568,29 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, */ s->keystr = ssh->hostkey->fmtkey(s->hkey); s->fingerprint = ssh->hostkey->fingerprint(s->hkey); - sk_set_frozen(ssh->s, 1); - verify_ssh_host_key(ssh->frontend, - ssh->savedhost, ssh->savedport, ssh->hostkey->keytype, - s->keystr, s->fingerprint); - sk_set_frozen(ssh->s, 0); + ssh_set_frozen(ssh, 1); + s->dlgret = verify_ssh_host_key(ssh->frontend, + ssh->savedhost, ssh->savedport, + ssh->hostkey->keytype, s->keystr, + s->fingerprint, + ssh_dialog_callback, ssh); + if (s->dlgret < 0) { + do { + crReturn(0); + if (pktin) { + bombout(("Unexpected data from server while waiting" + " for user host key response")); + crStop(0); + } + } while (pktin || inlen > 0); + s->dlgret = ssh->user_response; + } + ssh_set_frozen(ssh, 0); + if (s->dlgret == 0) { + ssh_disconnect(ssh, "User aborted at host key verification", NULL, + 0, TRUE); + crStop(0); + } if (!s->got_session_id) { /* don't bother logging this in rekeys */ logevent("Host key fingerprint is:"); logevent(s->fingerprint); @@ -5150,8 +5605,11 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, * authentication. */ if (!s->got_session_id) { + assert(sizeof(s->exchange_hash) <= sizeof(ssh->v2_session_id)); memcpy(ssh->v2_session_id, s->exchange_hash, sizeof(s->exchange_hash)); + ssh->v2_session_id_len = ssh->kex->hash->hlen; + assert(ssh->v2_session_id_len <= sizeof(ssh->v2_session_id)); s->got_session_id = TRUE; } @@ -5187,11 +5645,11 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, */ { unsigned char keyspace[40]; - ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'C',keyspace); + ssh2_mkkey(ssh,s->K,s->exchange_hash,'C',keyspace); ssh->cscipher->setkey(ssh->cs_cipher_ctx, keyspace); - ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'A',keyspace); + ssh2_mkkey(ssh,s->K,s->exchange_hash,'A',keyspace); ssh->cscipher->setiv(ssh->cs_cipher_ctx, keyspace); - ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'E',keyspace); + ssh2_mkkey(ssh,s->K,s->exchange_hash,'E',keyspace); ssh->csmac->setkey(ssh->cs_mac_ctx, keyspace); } @@ -5245,11 +5703,11 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, */ { unsigned char keyspace[40]; - ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'D',keyspace); + ssh2_mkkey(ssh,s->K,s->exchange_hash,'D',keyspace); ssh->sccipher->setkey(ssh->sc_cipher_ctx, keyspace); - ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'B',keyspace); + ssh2_mkkey(ssh,s->K,s->exchange_hash,'B',keyspace); ssh->sccipher->setiv(ssh->sc_cipher_ctx, keyspace); - ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'F',keyspace); + ssh2_mkkey(ssh,s->K,s->exchange_hash,'F',keyspace); ssh->scmac->setkey(ssh->sc_mac_ctx, keyspace); } logeventf(ssh, "Initialised %.200s server->client encryption", @@ -5265,7 +5723,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, */ freebn(s->f); freebn(s->K); - if (ssh->kex == &ssh_diffiehellman_gex) { + if (!ssh->kex->pdata) { freebn(s->g); freebn(s->p); } @@ -5299,7 +5757,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, * it would only confuse the layer above. */ if (s->activated_authconn) { - crReturn(1); + crReturn(0); } s->activated_authconn = TRUE; @@ -5351,7 +5809,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, } /* - * Add data to an SSH2 channel output buffer. + * Add data to an SSH-2 channel output buffer. */ static void ssh2_add_channel_data(struct ssh_channel *c, char *buf, int len) @@ -5360,7 +5818,7 @@ static void ssh2_add_channel_data(struct ssh_channel *c, char *buf, } /* - * Attempt to send data on an SSH2 channel. + * Attempt to send data on an SSH-2 channel. */ static int ssh2_try_send(struct ssh_channel *c) { @@ -5393,8 +5851,34 @@ static int ssh2_try_send(struct ssh_channel *c) return bufchain_size(&c->v.v2.outbuffer); } +static void ssh2_try_send_and_unthrottle(struct ssh_channel *c) +{ + int bufsize; + if (c->closes) + return; /* don't send on closing channels */ + bufsize = ssh2_try_send(c); + if (bufsize == 0) { + switch (c->type) { + case CHAN_MAINSESSION: + /* stdin need not receive an unthrottle + * notification since it will be polled */ + break; + case CHAN_X11: + x11_unthrottle(c->u.x11.s); + break; + case CHAN_AGENT: + /* agent sockets are request/response and need no + * buffer management */ + break; + case CHAN_SOCKDATA: + pfd_unthrottle(c->u.pfd.s); + break; + } + } +} + /* - * Potentially enlarge the window on an SSH2 channel. + * Potentially enlarge the window on an SSH-2 channel. */ static void ssh2_set_window(struct ssh_channel *c, unsigned newwin) { @@ -5408,7 +5892,14 @@ static void ssh2_set_window(struct ssh_channel *c, unsigned newwin) if (c->closes != 0) return; - if (newwin > c->v.v2.locwindow) { + /* + * Only send a WINDOW_ADJUST if there's significantly more window + * available than the other end thinks there is. This saves us + * sending a WINDOW_ADJUST for every character in a shell session. + * + * "Significant" is arbitrarily defined as half the window size. + */ + if (newwin > c->v.v2.locwindow * 2) { struct Packet *pktout; pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_WINDOW_ADJUST); @@ -5424,14 +5915,16 @@ static void ssh2_msg_channel_window_adjust(Ssh ssh, struct Packet *pktin) unsigned i = ssh_pkt_getuint32(pktin); struct ssh_channel *c; c = find234(ssh->channels, &i, ssh_channelfind); - if (c && !c->closes) + if (c && !c->closes) { c->v.v2.remwindow += ssh_pkt_getuint32(pktin); + ssh2_try_send_and_unthrottle(c); + } } static void ssh2_msg_channel_data(Ssh ssh, struct Packet *pktin) { char *data; - unsigned int length; + int length; unsigned i = ssh_pkt_getuint32(pktin); struct ssh_channel *c; c = find234(ssh->channels, &i, ssh_channelfind); @@ -5539,7 +6032,7 @@ static void ssh2_msg_channel_close(Ssh ssh, struct Packet *pktin) struct Packet *pktout; c = find234(ssh->channels, &i, ssh_channelfind); - if (!c || ((int)c->remoteid) == -1) { + if (!c || c->halfopen) { bombout(("Received CHANNEL_CLOSE for %s channel %d\n", c ? "half-open" : "nonexistent", i)); return; @@ -5579,12 +6072,10 @@ static void ssh2_msg_channel_close(Ssh ssh, struct Packet *pktin) * not running in -N mode.) */ if (!ssh->cfg.ssh_no_shell && count234(ssh->channels) == 0) { - logevent("All channels closed. Disconnecting"); -#if 0 /* * We used to send SSH_MSG_DISCONNECT here, * because I'd believed that _every_ conforming - * SSH2 connection had to end with a disconnect + * SSH-2 connection had to end with a disconnect * being sent by at least one side; apparently * I was wrong and it's perfectly OK to * unceremoniously slam the connection shut @@ -5592,13 +6083,7 @@ static void ssh2_msg_channel_close(Ssh ssh, struct Packet *pktin) * this is more polite than sending a * DISCONNECT. So now we don't. */ - s->pktout = ssh2_pkt_init(SSH2_MSG_DISCONNECT); - ssh2_pkt_adduint32(s->pktout, SSH2_DISCONNECT_BY_APPLICATION); - ssh2_pkt_addstring(s->pktout, "All open channels closed"); - ssh2_pkt_addstring(s->pktout, "en"); /* language tag */ - ssh2_pkt_send_noqueue(ssh, s->pktout); -#endif - ssh_closing((Plug)ssh, NULL, 0, 0); + ssh_disconnect(ssh, "All channels closed", NULL, 0, TRUE); } } @@ -5614,6 +6099,7 @@ static void ssh2_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin) if (c->type != CHAN_SOCKDATA_DORMANT) return; /* dunno why they're confirming this */ c->remoteid = ssh_pkt_getuint32(pktin); + c->halfopen = FALSE; c->type = CHAN_SOCKDATA; c->v.v2.remwindow = ssh_pkt_getuint32(pktin); c->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin); @@ -5645,7 +6131,6 @@ static void ssh2_msg_channel_open_failure(Ssh ssh, struct Packet *pktin) unsigned reason_code; char *reason_string; int reason_length; - char *message; struct ssh_channel *c; c = find234(ssh->channels, &i, ssh_channelfind); if (!c) @@ -5657,11 +6142,8 @@ static void ssh2_msg_channel_open_failure(Ssh ssh, struct Packet *pktin) if (reason_code >= lenof(reasons)) reason_code = 0; /* ensure reasons[reason_code] in range */ ssh_pkt_getstring(pktin, &reason_string, &reason_length); - message = dupprintf("Forwarded connection refused by" - " server: %s [%.*s]", reasons[reason_code], - reason_length, reason_string); - logevent(message); - sfree(message); + logeventf(ssh, "Forwarded connection refused by server: %s [%.*s]", + reasons[reason_code], reason_length, reason_string); pfd_close(c->u.pfd.s); @@ -5688,17 +6170,10 @@ static void ssh2_msg_channel_request(Ssh ssh, struct Packet *pktin) */ c = find234(ssh->channels, &localid, ssh_channelfind); if (!c) { - char buf[80]; - sprintf(buf, "Received channel request for nonexistent" - " channel %d", localid); - logevent(buf); - pktout = ssh2_pkt_init(SSH2_MSG_DISCONNECT); - ssh2_pkt_adduint32(pktout, SSH2_DISCONNECT_BY_APPLICATION); - ssh2_pkt_addstring(pktout, buf); - ssh2_pkt_addstring(pktout, "en"); /* language tag */ - ssh2_pkt_send_noqueue(ssh, pktout); - connection_fatal(ssh->frontend, "%s", buf); - ssh_closing((Plug)ssh, NULL, 0, 0); + char *buf = dupprintf("Received channel request for nonexistent" + " channel %d", localid); + ssh_disconnect(ssh, NULL, buf, SSH2_DISCONNECT_PROTOCOL_ERROR, FALSE); + sfree(buf); return; } @@ -5748,7 +6223,7 @@ static void ssh2_msg_channel_request(Ssh ssh, struct Packet *pktin) if (q >= 0 && q+4 <= len) { \ q = q + 4 + GET_32BIT(p+q); \ if (q >= 0 && q+4 <= len && \ - (q = q + 4 + GET_32BIT(p+q)) && q == len) \ + ((q = q + 4 + GET_32BIT(p+q))!= 0) && q == len) \ result = TRUE; \ } \ } while(0) @@ -5908,7 +6383,7 @@ static void ssh2_msg_channel_open(Ssh ssh, struct Packet *pktin) } } } else if (typelen == 22 && - !memcmp(type, "auth-agent@openssh.com", 3)) { + !memcmp(type, "auth-agent@openssh.com", 22)) { if (!ssh->agentfwd_enabled) error = "Agent forwarding is not enabled"; else { @@ -5920,6 +6395,7 @@ static void ssh2_msg_channel_open(Ssh ssh, struct Packet *pktin) } c->remoteid = remid; + c->halfopen = FALSE; if (error) { pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_FAILURE); ssh2_pkt_adduint32(pktout, c->remoteid); @@ -5941,13 +6417,48 @@ static void ssh2_msg_channel_open(Ssh ssh, struct Packet *pktin) ssh2_pkt_adduint32(pktout, c->remoteid); ssh2_pkt_adduint32(pktout, c->localid); ssh2_pkt_adduint32(pktout, c->v.v2.locwindow); - ssh2_pkt_adduint32(pktout, 0x4000UL); /* our max pkt size */ + ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT); /* our max pkt size */ ssh2_pkt_send(ssh, pktout); } } /* - * Handle the SSH2 userauth and connection layers. + * Buffer banner messages for later display at some convenient point. + */ +static void ssh2_msg_userauth_banner(Ssh ssh, struct Packet *pktin) +{ + /* Arbitrary limit to prevent unbounded inflation of buffer */ + if (bufchain_size(&ssh->banner) <= 131072) { + char *banner = NULL; + int size = 0; + ssh_pkt_getstring(pktin, &banner, &size); + if (banner) + bufchain_add(&ssh->banner, banner, size); + } +} + +/* Helper function to deal with sending tty modes for "pty-req" */ +static void ssh2_send_ttymode(void *data, char *mode, char *val) +{ + struct Packet *pktout = (struct Packet *)data; + int i = 0; + unsigned int arg = 0; + while (strcmp(mode, ssh_ttymodes[i].mode) != 0) i++; + if (i == lenof(ssh_ttymodes)) return; + switch (ssh_ttymodes[i].type) { + case TTY_OP_CHAR: + arg = ssh_tty_parse_specchar(val); + break; + case TTY_OP_BOOL: + arg = ssh_tty_parse_boolean(val); + break; + } + ssh2_pkt_addbyte(pktout, ssh_ttymodes[i].opcode); + ssh2_pkt_adduint32(pktout, arg); +} + +/* + * Handle the SSH-2 userauth and connection layers. */ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, struct Packet *pktin) @@ -5967,6 +6478,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, AUTH_TYPE_KEYBOARD_INTERACTIVE, AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET } type; + int done_service_req; int gotit, need_pw, can_pubkey, can_passwd, can_keyb_inter; int tried_pubkey_config, tried_agent; int kbd_inter_running, kbd_inter_refused; @@ -5994,16 +6506,33 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, crBegin(ssh->do_ssh2_authconn_crstate); - /* - * Request userauth protocol, and await a response to it. - */ - s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST); - ssh2_pkt_addstring(s->pktout, "ssh-userauth"); - ssh2_pkt_send(ssh, s->pktout); - crWaitUntilV(pktin); - if (pktin->type != SSH2_MSG_SERVICE_ACCEPT) { - bombout(("Server refused user authentication protocol")); - crStopV; + s->done_service_req = FALSE; + s->we_are_in = FALSE; + if (!ssh->cfg.ssh_no_userauth) { + /* + * Request userauth protocol, and await a response to it. + */ + s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST); + ssh2_pkt_addstring(s->pktout, "ssh-userauth"); + ssh2_pkt_send(ssh, s->pktout); + crWaitUntilV(pktin); + if (pktin->type == SSH2_MSG_SERVICE_ACCEPT) + s->done_service_req = TRUE; + } + if (!s->done_service_req) { + /* + * Request connection protocol directly, without authentication. + */ + s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST); + ssh2_pkt_addstring(s->pktout, "ssh-connection"); + ssh2_pkt_send(ssh, s->pktout); + crWaitUntilV(pktin); + if (pktin->type == SSH2_MSG_SERVICE_ACCEPT) { + s->we_are_in = TRUE; /* no auth required */ + } else { + bombout(("Server refused service request")); + crStopV; + } } /* @@ -6032,7 +6561,10 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, */ s->username[0] = '\0'; s->got_username = FALSE; - do { + bufchain_init(&ssh->banner); + ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = + ssh2_msg_userauth_banner; + while (!s->we_are_in) { /* * Get a username. */ @@ -6050,8 +6582,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, * get_line failed to get a username. * Terminate. */ - logevent("No username provided. Abandoning session."); - ssh_closing((Plug)ssh, NULL, 0, 0); + ssh_disconnect(ssh, "No username provided", NULL, 0, TRUE); crStopV; } } else { @@ -6131,9 +6662,14 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, */ if (!s->gotit) crWaitUntilV(pktin); - while (pktin->type == SSH2_MSG_USERAUTH_BANNER) { - char *banner; - int size; + /* + * Now is a convenient point to spew any banner material + * that we've accumulated. (This should ensure that when + * we exit the auth loop, we haven't any left to deal + * with.) + */ + { + int size = bufchain_size(&ssh->banner); /* * Don't show the banner if we're operating in * non-verbose non-interactive mode. (It's probably @@ -6142,12 +6678,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, * the banner will screw up processing on the * output of (say) plink.) */ - if (flags & (FLAG_VERBOSE | FLAG_INTERACTIVE)) { - ssh_pkt_getstring(pktin, &banner, &size); - if (banner) - c_write_untrusted(ssh, banner, size); + if (size && (flags & (FLAG_VERBOSE | FLAG_INTERACTIVE))) { + char *banner = snewn(size, char); + bufchain_fetch(&ssh->banner, banner, size); + c_write_untrusted(ssh, banner, size); + sfree(banner); } - crWaitUntilV(pktin); + bufchain_clear(&ssh->banner); } if (pktin->type == SSH2_MSG_USERAUTH_SUCCESS) { logevent("Access granted"); @@ -6293,19 +6830,11 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, s->p = s->response + 5; s->nkeys = GET_32BIT(s->p); s->p += 4; - { - char buf[64]; - sprintf(buf, "Pageant has %d SSH2 keys", s->nkeys); - logevent(buf); - } + logeventf(ssh, "Pageant has %d SSH-2 keys", s->nkeys); for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) { void *vret; - { - char buf[64]; - sprintf(buf, "Trying Pageant key #%d", s->keyi); - logevent(buf); - } + logeventf(ssh, "Trying Pageant key #%d", s->keyi); s->pklen = GET_32BIT(s->p); s->p += 4; if (s->publickey_blob && @@ -6361,7 +6890,8 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, ssh2_pkt_addstring_start(s->pktout); ssh2_pkt_addstring_data(s->pktout, s->pkblob, s->pklen); - s->siglen = s->pktout->length - 5 + 4 + 20; + s->siglen = s->pktout->length - 5 + 4 + + ssh->v2_session_id_len; if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID) s->siglen -= 4; s->len = 1; /* message type */ @@ -6380,11 +6910,12 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, s->q += 4; /* Now the data to be signed... */ if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) { - PUT_32BIT(s->q, 20); + PUT_32BIT(s->q, ssh->v2_session_id_len); s->q += 4; } - memcpy(s->q, ssh->v2_session_id, 20); - s->q += 20; + memcpy(s->q, ssh->v2_session_id, + ssh->v2_session_id_len); + s->q += ssh->v2_session_id_len; memcpy(s->q, s->pktout->data + 5, s->pktout->length - 5); s->q += s->pktout->length - 5; @@ -6520,6 +7051,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, continue; } + c_write_str(ssh, "Using keyboard-interactive authentication.\r\n"); s->kbd_inter_running = TRUE; s->curr_prompt = 0; } @@ -6603,16 +7135,9 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, * command line which has already failed to * work). Terminate. */ - s->pktout = ssh2_pkt_init(SSH2_MSG_DISCONNECT); - ssh2_pkt_adduint32(s->pktout,SSH2_DISCONNECT_BY_APPLICATION); - ssh2_pkt_addstring(s->pktout, "No more passwords available" - " to try"); - ssh2_pkt_addstring(s->pktout, "en"); /* language tag */ - ssh2_pkt_send_noqueue(ssh, s->pktout); - logevent("Unable to authenticate"); - connection_fatal(ssh->frontend, - "Unable to authenticate"); - ssh_closing((Plug)ssh, NULL, 0, 0); + ssh_disconnect(ssh, NULL, "Unable to authenticate", + SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER, + FALSE); crStopV; } } else { @@ -6686,16 +7211,19 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, * followed by everything so far placed in the * outgoing packet. */ - sigdata_len = s->pktout->length - 5 + 4 + 20; + sigdata_len = s->pktout->length - 5 + 4 + + ssh->v2_session_id_len; if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID) sigdata_len -= 4; sigdata = snewn(sigdata_len, unsigned char); p = 0; if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) { - PUT_32BIT(sigdata+p, 20); + PUT_32BIT(sigdata+p, ssh->v2_session_id_len); p += 4; } - memcpy(sigdata+p, ssh->v2_session_id, 20); p += 20; + memcpy(sigdata+p, ssh->v2_session_id, + ssh->v2_session_id_len); + p += ssh->v2_session_id_len; memcpy(sigdata+p, s->pktout->data + 5, s->pktout->length - 5); p += s->pktout->length - 5; @@ -6714,20 +7242,16 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, } } else if (s->method == AUTH_PASSWORD) { /* - * We send the password packet lumped tightly together with - * an SSH_MSG_IGNORE packet. The IGNORE packet contains a - * string long enough to make the total length of the two - * packets constant. This should ensure that a passive - * listener doing traffic analyis can't work out the length - * of the password. + * We pad out the password packet to 256 bytes to make + * it harder for an attacker to find the length of the + * user's password. * - * For this to work, we need an assumption about the - * maximum length of the password packet. I think 256 is - * pretty conservative. Anyone using a password longer than - * that probably doesn't have much to worry about from + * Anyone using a password longer than 256 bytes + * probably doesn't have much to worry about from * people who find out how long their password is! */ s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST); + s->pktout->forcepad = 256; ssh2_pkt_addstring(s->pktout, s->username); ssh2_pkt_addstring(s->pktout, "ssh-connection"); /* service requested */ ssh2_pkt_addstring(s->pktout, "password"); @@ -6736,46 +7260,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, ssh2_pkt_addstring(s->pktout, s->password); memset(s->password, 0, sizeof(s->password)); end_log_omission(ssh, s->pktout); - ssh2_pkt_defer(ssh, s->pktout); - /* - * We'll include a string that's an exact multiple of the - * cipher block size. If the cipher is NULL for some - * reason, we don't do this trick at all because we gain - * nothing by it. - */ - if (ssh->cscipher) { - int stringlen, i; - - stringlen = (256 - ssh->deferred_len); - stringlen += ssh->cscipher->blksize - 1; - stringlen -= (stringlen % ssh->cscipher->blksize); - if (ssh->cscomp) { - /* - * Temporarily disable actual compression, - * so we can guarantee to get this string - * exactly the length we want it. The - * compression-disabling routine should - * return an integer indicating how many - * bytes we should adjust our string length - * by. - */ - stringlen -= - ssh->cscomp->disable_compression(ssh->cs_comp_ctx); - } - s->pktout = ssh2_pkt_init(SSH2_MSG_IGNORE); - ssh2_pkt_addstring_start(s->pktout); - for (i = 0; i < stringlen; i++) { - char c = (char) random_byte(); - ssh2_pkt_addstring_data(s->pktout, &c, 1); - } - ssh2_pkt_defer(ssh, s->pktout); - } - ssh_pkt_defersend(ssh); + ssh2_pkt_send(ssh, s->pktout); logevent("Sent password"); s->type = AUTH_TYPE_PASSWORD; } else if (s->method == AUTH_KEYBOARD_INTERACTIVE) { if (s->curr_prompt == 0) { s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_INFO_RESPONSE); + s->pktout->forcepad = 256; ssh2_pkt_adduint32(s->pktout, s->num_prompts); } if (s->need_pw) { /* only add pw if we just got one! */ @@ -6800,26 +7291,18 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, } s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE; } else { - c_write_str(ssh, "No supported authentication methods" - " left to try!\r\n"); - logevent("No supported authentications offered." - " Disconnecting"); - s->pktout = ssh2_pkt_init(SSH2_MSG_DISCONNECT); - ssh2_pkt_adduint32(s->pktout, SSH2_DISCONNECT_BY_APPLICATION); - ssh2_pkt_addstring(s->pktout, "No supported authentication" - " methods available"); - ssh2_pkt_addstring(s->pktout, "en"); /* language tag */ - ssh2_pkt_send_noqueue(ssh, s->pktout); - ssh_closing((Plug)ssh, NULL, 0, 0); + ssh_disconnect(ssh, NULL, + "No supported authentication methods available", + SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE, + FALSE); crStopV; } } - } while (!s->we_are_in); + } + ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = NULL; /* - * Now we're authenticated for the connection protocol. The - * connection protocol will automatically have started at this - * point; there's no need to send SERVICE_REQUEST. + * Now the connection protocol has started, one way or another. */ ssh->channels = newtree234(ssh_channelcmp); @@ -6845,7 +7328,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, ssh2_pkt_adduint32(s->pktout, ssh->mainchan->localid); ssh->mainchan->v.v2.locwindow = OUR_V2_WINSIZE; ssh2_pkt_adduint32(s->pktout, ssh->mainchan->v.v2.locwindow);/* our window size */ - ssh2_pkt_adduint32(s->pktout, 0x4000UL); /* our max pkt size */ + ssh2_pkt_adduint32(s->pktout, OUR_V2_MAXPKT); /* our max pkt size */ ssh2_pkt_send(ssh, s->pktout); crWaitUntilV(pktin); if (pktin->type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) { @@ -6858,6 +7341,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, crStopV; } ssh->mainchan->remoteid = ssh_pkt_getuint32(pktin); + ssh->mainchan->halfopen = FALSE; ssh->mainchan->type = CHAN_MAINSESSION; ssh->mainchan->closes = 0; ssh->mainchan->v.v2.remwindow = ssh_pkt_getuint32(pktin); @@ -6902,7 +7386,16 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, ssh2_pkt_addbool(s->pktout, 1); /* want reply */ ssh2_pkt_addbool(s->pktout, 0); /* many connections */ ssh2_pkt_addstring(s->pktout, proto); + /* + * Note that while we blank the X authentication data here, we don't + * take any special action to blank the start of an X11 channel, + * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection + * without having session blanking enabled is likely to leak your + * cookie into the log. + */ + dont_log_password(ssh, s->pktout, PKTLOG_BLANK); ssh2_pkt_addstring(s->pktout, data); + end_log_omission(ssh, s->pktout); ssh2_pkt_adduint32(s->pktout, x11_get_screen_number(ssh->cfg.x11_display)); ssh2_pkt_send(ssh, s->pktout); @@ -6971,9 +7464,11 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, ssh2_pkt_adduint32(s->pktout, 0); /* pixel width */ ssh2_pkt_adduint32(s->pktout, 0); /* pixel height */ ssh2_pkt_addstring_start(s->pktout); - ssh2_pkt_addbyte(s->pktout, 128); /* TTY_OP_ISPEED */ + parse_ttymodes(ssh, ssh->cfg.ttymodes, + ssh2_send_ttymode, (void *)s->pktout); + ssh2_pkt_addbyte(s->pktout, SSH2_TTY_OP_ISPEED); ssh2_pkt_adduint32(s->pktout, ssh->ispeed); - ssh2_pkt_addbyte(s->pktout, 129); /* TTY_OP_OSPEED */ + ssh2_pkt_addbyte(s->pktout, SSH2_TTY_OP_OSPEED); ssh2_pkt_adduint32(s->pktout, ssh->ospeed); ssh2_pkt_addstring_data(s->pktout, "\0", 1); /* TTY_OP_END */ ssh2_pkt_send(ssh, s->pktout); @@ -7078,6 +7573,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, } else { subsys = ssh->cfg.ssh_subsys; cmd = ssh->cfg.remote_cmd_ptr; + if (!cmd) cmd = ssh->cfg.remote_cmd; } s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST); @@ -7162,30 +7658,8 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, /* * Try to send data on all channels if we can. */ - for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) { - int bufsize; - if (c->closes) - continue; /* don't send on closing channels */ - bufsize = ssh2_try_send(c); - if (bufsize == 0) { - switch (c->type) { - case CHAN_MAINSESSION: - /* stdin need not receive an unthrottle - * notification since it will be polled */ - break; - case CHAN_X11: - x11_unthrottle(c->u.x11.s); - break; - case CHAN_AGENT: - /* agent sockets are request/response and need no - * buffer management */ - break; - case CHAN_SOCKDATA: - pfd_unthrottle(c->u.pfd.s); - break; - } - } - } + for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) + ssh2_try_send_and_unthrottle(c); } } @@ -7193,9 +7667,9 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, } /* - * Handlers for SSH2 messages that might arrive at any moment. + * Handlers for SSH-2 messages that might arrive at any moment. */ -void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin) +static void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin) { /* log reason code in disconnect message */ char *buf, *msg; @@ -7224,10 +7698,10 @@ void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin) sfree(buf); } -void ssh2_msg_debug(Ssh ssh, struct Packet *pktin) +static void ssh2_msg_debug(Ssh ssh, struct Packet *pktin) { /* log the debug message */ - char *buf, *msg; + char *msg; int msglen; int always_display; @@ -7235,12 +7709,10 @@ void ssh2_msg_debug(Ssh ssh, struct Packet *pktin) always_display = ssh2_pkt_getbool(pktin); ssh_pkt_getstring(pktin, &msg, &msglen); - buf = dupprintf("Remote debug message: %.*s", msglen, msg); - logevent(buf); - sfree(buf); + logeventf(ssh, "Remote debug message: %.*s", msglen, msg); } -void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin) +static void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin) { struct Packet *pktout; pktout = ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED); @@ -7253,7 +7725,7 @@ void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin) } /* - * Handle the top-level SSH2 protocol. + * Handle the top-level SSH-2 protocol. */ static void ssh2_protocol_setup(Ssh ssh) { @@ -7307,7 +7779,7 @@ static void ssh2_protocol_setup(Ssh ssh) * These special message types we install handlers for. */ ssh->packet_dispatch[SSH2_MSG_DISCONNECT] = ssh2_msg_disconnect; - ssh->packet_dispatch[SSH2_MSG_IGNORE] = ssh_msg_ignore; /* shared with ssh1 */ + ssh->packet_dispatch[SSH2_MSG_IGNORE] = ssh_msg_ignore; /* shared with SSH-1 */ ssh->packet_dispatch[SSH2_MSG_DEBUG] = ssh2_msg_debug; } @@ -7315,15 +7787,19 @@ static void ssh2_timer(void *ctx, long now) { Ssh ssh = (Ssh)ctx; + if (ssh->state == SSH_STATE_CLOSED) + return; + if (!ssh->kex_in_progress && ssh->cfg.ssh_rekey_time != 0 && now - ssh->next_rekey >= 0) { do_ssh2_transport(ssh, "timeout", -1, NULL); } } -static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen, +static void ssh2_protocol(Ssh ssh, void *vin, int inlen, struct Packet *pktin) { + unsigned char *in = (unsigned char *)vin; if (ssh->state == SSH_STATE_CLOSED) return; @@ -7391,6 +7867,8 @@ static const char *ssh_init(void *frontend_handle, void **backend_handle, ssh->kex_ctx = NULL; ssh->hostkey = NULL; ssh->exitcode = -1; + ssh->close_expected = FALSE; + ssh->clean_exit = FALSE; ssh->state = SSH_STATE_PREPACKET; ssh->size_needed = FALSE; ssh->eof_needed = FALSE; @@ -7416,6 +7894,8 @@ static const char *ssh_init(void *frontend_handle, void **backend_handle, ssh->do_ssh1_login_state = NULL; ssh->do_ssh2_transport_state = NULL; ssh->do_ssh2_authconn_state = NULL; + ssh->v_c = NULL; + ssh->v_s = NULL; ssh->mainchan = NULL; ssh->throttled_all = 0; ssh->v1_stdout_throttling = 0; @@ -7424,6 +7904,8 @@ static const char *ssh_init(void *frontend_handle, void **backend_handle, ssh->queueing = FALSE; ssh->qhead = ssh->qtail = NULL; ssh->deferred_rekey_reason = NULL; + bufchain_init(&ssh->queued_incoming_data); + ssh->frozen = FALSE; *backend_handle = ssh; @@ -7541,15 +8023,18 @@ static void ssh_free(void *handle) sfree(ssh->do_ssh1_login_state); sfree(ssh->do_ssh2_transport_state); sfree(ssh->do_ssh2_authconn_state); + sfree(ssh->v_c); + sfree(ssh->v_s); if (ssh->crcda_ctx) { crcda_free_context(ssh->crcda_ctx); ssh->crcda_ctx = NULL; } if (ssh->s) - ssh_do_close(ssh); + ssh_do_close(ssh, TRUE); expire_timer_context(ssh); if (ssh->pinger) pinger_free(ssh->pinger); + bufchain_clear(&ssh->queued_incoming_data); sfree(ssh); random_unref(); @@ -7565,7 +8050,8 @@ static void ssh_reconfig(void *handle, Config *cfg) unsigned long old_max_data_size; pinger_reconfig(ssh->pinger, &ssh->cfg, cfg); - ssh_setup_portfwd(ssh, cfg); + if (ssh->portfwds) + ssh_setup_portfwd(ssh, cfg); if (ssh->cfg.ssh_rekey_time != cfg->ssh_rekey_time && cfg->ssh_rekey_time != 0) { @@ -7612,7 +8098,7 @@ static void ssh_reconfig(void *handle, Config *cfg) } /* - * Called to send data down the Telnet connection. + * Called to send data down the SSH connection. */ static int ssh_send(void *handle, char *buf, int len) { @@ -7769,7 +8255,7 @@ static const struct telnet_special *ssh_get_specials(void *handle) } /* - * Send Telnet special codes. TS_EOF is useful for `plink', so you + * Send special codes. TS_EOF is useful for `plink', so you * can send an EOF and collect resulting output (e.g. `plink * hostname sort'). */ @@ -7794,6 +8280,7 @@ static void ssh_special(void *handle, Telnet_Special code) struct Packet *pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_EOF); ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid); ssh2_pkt_send(ssh, pktout); + ssh->send_ok = 0; /* now stop trying to read from stdin */ } logevent("Sent EOF message"); } else if (code == TS_PING || code == TS_NOP) { @@ -7815,7 +8302,7 @@ static void ssh_special(void *handle, Telnet_Special code) if (ssh->state == SSH_STATE_CLOSED || ssh->state == SSH_STATE_PREPACKET) return; if (ssh->version == 1) { - logevent("Unable to send BREAK signal in SSH1"); + logevent("Unable to send BREAK signal in SSH-1"); } else if (ssh->mainchan) { pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST); ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid); @@ -7867,7 +8354,7 @@ void *new_sock_channel(void *handle, Socket s) c->ssh = ssh; if (c) { - c->remoteid = -1; /* to be set when open confirmed */ + c->halfopen = TRUE; c->localid = alloc_channel_id(ssh); c->closes = 0; c->type = CHAN_SOCKDATA_DORMANT;/* identify channel type */ @@ -7917,7 +8404,7 @@ void ssh_send_port_open(void *channel, char *hostname, int port, char *org) ssh2_pkt_adduint32(pktout, c->localid); c->v.v2.locwindow = OUR_V2_WINSIZE; ssh2_pkt_adduint32(pktout, c->v.v2.locwindow);/* our window size */ - ssh2_pkt_adduint32(pktout, 0x4000UL); /* our max pkt size */ + ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT); /* our max pkt size */ ssh2_pkt_addstring(pktout, hostname); ssh2_pkt_adduint32(pktout, port); /*