+ /*
+ * Adjust memory allocation if packet is too big.
+ */
+ if (ssh->pktin.maxlen < st->packetlen + st->maclen) {
+ ssh->pktin.maxlen = st->packetlen + st->maclen;
+ ssh->pktin.data = srealloc(ssh->pktin.data,
+ ssh->pktin.maxlen + APIEXTRA);
+ }
+
+ /*
+ * Read and decrypt the remainder of the packet.
+ */
+ for (st->i = st->cipherblk; st->i < st->packetlen + st->maclen;
+ st->i++) {
+ while ((*datalen) == 0)
+ crReturn(st->packetlen + st->maclen - st->i);
+ ssh->pktin.data[st->i] = *(*data)++;
+ (*datalen)--;
+ }
+ /* Decrypt everything _except_ the MAC. */
+ if (ssh->sccipher)
+ ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
+ ssh->pktin.data + st->cipherblk,
+ st->packetlen - st->cipherblk);
+
+ /*
+ * Check the MAC.
+ */
+ if (ssh->scmac
+ && !ssh->scmac->verify(ssh->sc_mac_ctx, ssh->pktin.data, st->len + 4,
+ st->incoming_sequence)) {
+ bombout((ssh,"Incorrect MAC received on packet"));
+ crReturn(0);
+ }
+ st->incoming_sequence++; /* whether or not we MACed */
+
+ /*
+ * Decompress packet payload.
+ */
+ {
+ unsigned char *newpayload;
+ int newlen;
+ if (ssh->sccomp &&
+ ssh->sccomp->decompress(ssh->sc_comp_ctx,
+ ssh->pktin.data + 5, ssh->pktin.length - 5,
+ &newpayload, &newlen)) {
+ if (ssh->pktin.maxlen < newlen + 5) {
+ ssh->pktin.maxlen = newlen + 5;
+ ssh->pktin.data = srealloc(ssh->pktin.data,
+ ssh->pktin.maxlen + APIEXTRA);
+ }
+ ssh->pktin.length = 5 + newlen;
+ memcpy(ssh->pktin.data + 5, newpayload, newlen);
+ sfree(newpayload);
+ }
+ }
+
+ ssh->pktin.savedpos = 6;
+ ssh->pktin.type = ssh->pktin.data[5];
+
+ if (ssh->logctx)
+ log_packet(ssh->logctx, PKT_INCOMING, ssh->pktin.type,
+ ssh2_pkt_type(ssh->pkt_ctx, ssh->pktin.type),
+ ssh->pktin.data+6, ssh->pktin.length-6);
+
+ switch (ssh->pktin.type) {
+ /*
+ * These packets we must handle instantly.
+ */
+ case SSH2_MSG_DISCONNECT:
+ {
+ /* log reason code in disconnect message */
+ char *buf;
+ int nowlen;
+ int reason = GET_32BIT(ssh->pktin.data + 6);
+ unsigned msglen = GET_32BIT(ssh->pktin.data + 10);
+
+ if (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) {
+ buf = dupprintf("Received disconnect message (%s)",
+ ssh2_disconnect_reasons[reason]);
+ } else {
+ buf = dupprintf("Received disconnect message (unknown"
+ " type %d)", reason);
+ }
+ logevent(buf);
+ sfree(buf);
+ buf = dupprintf("Disconnection message text: %n%.*s",
+ &nowlen, msglen, ssh->pktin.data + 14);
+ logevent(buf);
+ bombout((ssh,"Server sent disconnect message\ntype %d (%s):\n\"%s\"",
+ reason,
+ (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) ?
+ ssh2_disconnect_reasons[reason] : "unknown",
+ buf+nowlen));
+ sfree(buf);
+ crReturn(0);
+ }
+ break;
+ case SSH2_MSG_IGNORE:
+ goto next_packet;
+ case SSH2_MSG_DEBUG:
+ {
+ /* log the debug message */
+ char buf[512];
+ /* int display = ssh->pktin.body[6]; */
+ int stringlen = GET_32BIT(ssh->pktin.data+7);
+ int prefix;
+ strcpy(buf, "Remote debug message: ");
+ prefix = strlen(buf);
+ if (stringlen > (int)(sizeof(buf)-prefix-1))
+ stringlen = sizeof(buf)-prefix-1;
+ memcpy(buf + prefix, ssh->pktin.data + 11, stringlen);
+ buf[prefix + stringlen] = '\0';
+ logevent(buf);
+ }
+ goto next_packet; /* FIXME: print the debug message */
+
+ /*
+ * These packets we need do nothing about here.
+ */
+ case SSH2_MSG_UNIMPLEMENTED:
+ case SSH2_MSG_SERVICE_REQUEST:
+ case SSH2_MSG_SERVICE_ACCEPT:
+ case SSH2_MSG_KEXINIT:
+ case SSH2_MSG_NEWKEYS:
+ case SSH2_MSG_KEXDH_INIT:
+ case SSH2_MSG_KEXDH_REPLY:
+ /* case SSH2_MSG_KEX_DH_GEX_REQUEST: duplicate case value */
+ /* case SSH2_MSG_KEX_DH_GEX_GROUP: duplicate case value */
+ case SSH2_MSG_KEX_DH_GEX_INIT:
+ case SSH2_MSG_KEX_DH_GEX_REPLY:
+ case SSH2_MSG_USERAUTH_REQUEST:
+ case SSH2_MSG_USERAUTH_FAILURE:
+ case SSH2_MSG_USERAUTH_SUCCESS:
+ case SSH2_MSG_USERAUTH_BANNER:
+ case SSH2_MSG_USERAUTH_PK_OK:
+ /* case SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ: duplicate case value */
+ /* case SSH2_MSG_USERAUTH_INFO_REQUEST: duplicate case value */
+ case SSH2_MSG_USERAUTH_INFO_RESPONSE:
+ case SSH2_MSG_GLOBAL_REQUEST:
+ case SSH2_MSG_REQUEST_SUCCESS:
+ case SSH2_MSG_REQUEST_FAILURE:
+ case SSH2_MSG_CHANNEL_OPEN:
+ case SSH2_MSG_CHANNEL_OPEN_CONFIRMATION:
+ case SSH2_MSG_CHANNEL_OPEN_FAILURE:
+ case SSH2_MSG_CHANNEL_WINDOW_ADJUST:
+ case SSH2_MSG_CHANNEL_DATA:
+ case SSH2_MSG_CHANNEL_EXTENDED_DATA:
+ case SSH2_MSG_CHANNEL_EOF:
+ case SSH2_MSG_CHANNEL_CLOSE:
+ case SSH2_MSG_CHANNEL_REQUEST:
+ case SSH2_MSG_CHANNEL_SUCCESS:
+ case SSH2_MSG_CHANNEL_FAILURE:
+ break;
+
+ /*
+ * For anything else we send SSH2_MSG_UNIMPLEMENTED.
+ */
+ default:
+ ssh2_pkt_init(ssh, SSH2_MSG_UNIMPLEMENTED);
+ ssh2_pkt_adduint32(ssh, st->incoming_sequence - 1);
+ ssh2_pkt_send(ssh);
+ break;
+ }
+
+ crFinish(0);
+}
+
+static void ssh1_pktout_size(Ssh ssh, int len)
+{
+ int pad, biglen;
+
+ len += 5; /* type and CRC */
+ pad = 8 - (len % 8);
+ biglen = len + pad;
+
+ ssh->pktout.length = len - 5;
+ if (ssh->pktout.maxlen < biglen) {
+ ssh->pktout.maxlen = biglen;
+#ifdef MSCRYPTOAPI
+ /* Allocate enough buffer space for extra block
+ * for MS CryptEncrypt() */
+ ssh->pktout.data = srealloc(ssh->pktout.data, biglen + 12);
+#else
+ ssh->pktout.data = srealloc(ssh->pktout.data, biglen + 4);
+#endif
+ }
+ ssh->pktout.body = ssh->pktout.data + 4 + pad + 1;
+}
+
+static void s_wrpkt_start(Ssh ssh, int type, int len)
+{
+ ssh1_pktout_size(ssh, len);
+ ssh->pktout.type = type;
+}
+
+static int s_wrpkt_prepare(Ssh ssh)
+{
+ int pad, len, biglen, i;
+ unsigned long crc;
+
+ ssh->pktout.body[-1] = ssh->pktout.type;
+
+ if (ssh->logctx)
+ log_packet(ssh->logctx, PKT_OUTGOING, ssh->pktout.type,
+ ssh1_pkt_type(ssh->pktout.type),
+ ssh->pktout.body, ssh->pktout.length);
+
+ if (ssh->v1_compressing) {
+ unsigned char *compblk;
+ int complen;
+ zlib_compress_block(ssh->cs_comp_ctx,
+ ssh->pktout.body - 1, ssh->pktout.length + 1,
+ &compblk, &complen);
+ ssh1_pktout_size(ssh, complen - 1);
+ memcpy(ssh->pktout.body - 1, compblk, complen);
+ sfree(compblk);
+ }
+
+ len = ssh->pktout.length + 5; /* type and CRC */
+ pad = 8 - (len % 8);
+ biglen = len + pad;
+
+ for (i = 0; i < pad; i++)
+ ssh->pktout.data[i + 4] = random_byte();
+ crc = crc32(ssh->pktout.data + 4, biglen - 4);
+ PUT_32BIT(ssh->pktout.data + biglen, crc);
+ PUT_32BIT(ssh->pktout.data, len);
+
+ if (ssh->cipher)
+ ssh->cipher->encrypt(ssh->v1_cipher_ctx, ssh->pktout.data + 4, biglen);
+
+ return biglen + 4;
+}
+
+static void s_wrpkt(Ssh ssh)
+{
+ int len, backlog;
+ len = s_wrpkt_prepare(ssh);
+ backlog = sk_write(ssh->s, (char *)ssh->pktout.data, len);
+ if (backlog > SSH_MAX_BACKLOG)
+ ssh_throttle_all(ssh, 1, backlog);
+}
+
+static void s_wrpkt_defer(Ssh ssh)
+{
+ int len;
+ len = s_wrpkt_prepare(ssh);
+ if (ssh->deferred_len + len > ssh->deferred_size) {
+ ssh->deferred_size = ssh->deferred_len + len + 128;
+ ssh->deferred_send_data = srealloc(ssh->deferred_send_data,
+ ssh->deferred_size);
+ }
+ memcpy(ssh->deferred_send_data + ssh->deferred_len, ssh->pktout.data, len);
+ ssh->deferred_len += len;
+}
+
+/*
+ * Construct a packet with the specified contents.
+ */
+static void construct_packet(Ssh ssh, int pkttype, va_list ap1, va_list ap2)
+{
+ unsigned char *p, *argp, argchar;
+ unsigned long argint;
+ int pktlen, argtype, arglen;
+ Bignum bn;
+
+ 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;
+ default:
+ assert(0);
+ }
+ }
+
+ s_wrpkt_start(ssh, pkttype, pktlen);
+ p = ssh->pktout.body;
+
+ while ((argtype = va_arg(ap2, int)) != PKT_END) {
+ switch (argtype) {
+ case PKT_INT:
+ argint = va_arg(ap2, int);
+ PUT_32BIT(p, argint);
+ p += 4;
+ break;
+ case PKT_CHAR:
+ argchar = (unsigned char) va_arg(ap2, int);
+ *p = argchar;
+ p++;
+ break;
+ case PKT_DATA:
+ argp = va_arg(ap2, unsigned char *);
+ arglen = va_arg(ap2, int);
+ memcpy(p, argp, arglen);
+ p += arglen;
+ break;
+ case PKT_STR:
+ argp = va_arg(ap2, unsigned char *);
+ arglen = strlen((char *)argp);
+ PUT_32BIT(p, arglen);
+ memcpy(p + 4, argp, arglen);
+ p += 4 + arglen;
+ break;
+ case PKT_BIGNUM:
+ bn = va_arg(ap2, Bignum);
+ p += ssh1_write_bignum(p, bn);
+ break;
+ }
+ }
+}
+
+static void send_packet(Ssh ssh, int pkttype, ...)
+{
+ va_list ap1, ap2;
+ va_start(ap1, pkttype);
+ va_start(ap2, pkttype);
+ construct_packet(ssh, pkttype, ap1, ap2);
+ s_wrpkt(ssh);
+}
+
+static void defer_packet(Ssh ssh, int pkttype, ...)
+{
+ va_list ap1, ap2;
+ va_start(ap1, pkttype);
+ va_start(ap2, pkttype);
+ construct_packet(ssh, pkttype, ap1, ap2);
+ s_wrpkt_defer(ssh);
+}
+
+static int ssh_versioncmp(char *a, char *b)
+{
+ char *ae, *be;
+ unsigned long av, bv;
+
+ av = strtoul(a, &ae, 10);
+ bv = strtoul(b, &be, 10);
+ if (av != bv)
+ return (av < bv ? -1 : +1);
+ if (*ae == '.')
+ ae++;
+ if (*be == '.')
+ be++;
+ av = strtoul(ae, &ae, 10);
+ bv = strtoul(be, &be, 10);
+ if (av != bv)
+ return (av < bv ? -1 : +1);
+ return 0;
+}
+
+/*
+ * Utility routines for putting an SSH-protocol `string' and
+ * `uint32' into a SHA state.
+ */
+#include <stdio.h>
+static void sha_string(SHA_State * s, void *str, int len)
+{
+ unsigned char lenblk[4];
+ PUT_32BIT(lenblk, len);
+ SHA_Bytes(s, lenblk, 4);
+ SHA_Bytes(s, str, len);
+}
+
+static void sha_uint32(SHA_State * s, unsigned i)
+{
+ unsigned char intblk[4];
+ PUT_32BIT(intblk, i);
+ SHA_Bytes(s, intblk, 4);
+}
+
+/*
+ * SSH2 packet construction functions.
+ */
+static void ssh2_pkt_ensure(Ssh ssh, int length)
+{
+ if (ssh->pktout.maxlen < length) {
+ ssh->pktout.maxlen = length + 256;
+ ssh->pktout.data = srealloc(ssh->pktout.data,
+ ssh->pktout.maxlen + APIEXTRA);
+ if (!ssh->pktout.data)
+ fatalbox("Out of memory");
+ }
+}
+static void ssh2_pkt_adddata(Ssh ssh, void *data, int len)
+{
+ ssh->pktout.length += len;
+ ssh2_pkt_ensure(ssh, ssh->pktout.length);
+ memcpy(ssh->pktout.data + ssh->pktout.length - len, data, len);
+}
+static void ssh2_pkt_addbyte(Ssh ssh, unsigned char byte)
+{
+ ssh2_pkt_adddata(ssh, &byte, 1);
+}
+static void ssh2_pkt_init(Ssh ssh, int pkt_type)
+{
+ ssh->pktout.length = 5;
+ ssh2_pkt_addbyte(ssh, (unsigned char) pkt_type);
+}
+static void ssh2_pkt_addbool(Ssh ssh, unsigned char value)
+{
+ ssh2_pkt_adddata(ssh, &value, 1);
+}
+static void ssh2_pkt_adduint32(Ssh ssh, unsigned long value)
+{
+ unsigned char x[4];
+ PUT_32BIT(x, value);
+ ssh2_pkt_adddata(ssh, x, 4);
+}
+static void ssh2_pkt_addstring_start(Ssh ssh)
+{
+ ssh2_pkt_adduint32(ssh, 0);
+ ssh->pktout.savedpos = ssh->pktout.length;
+}
+static void ssh2_pkt_addstring_str(Ssh ssh, char *data)
+{
+ ssh2_pkt_adddata(ssh, data, strlen(data));
+ PUT_32BIT(ssh->pktout.data + ssh->pktout.savedpos - 4,
+ ssh->pktout.length - ssh->pktout.savedpos);
+}
+static void ssh2_pkt_addstring_data(Ssh ssh, char *data, int len)
+{
+ ssh2_pkt_adddata(ssh, data, len);
+ PUT_32BIT(ssh->pktout.data + ssh->pktout.savedpos - 4,
+ ssh->pktout.length - ssh->pktout.savedpos);
+}
+static void ssh2_pkt_addstring(Ssh ssh, char *data)
+{
+ ssh2_pkt_addstring_start(ssh);
+ ssh2_pkt_addstring_str(ssh, data);
+}
+static unsigned char *ssh2_mpint_fmt(Bignum b, int *len)
+{
+ unsigned char *p;
+ int i, n = (bignum_bitcount(b) + 7) / 8;
+ p = smalloc(n + 1);
+ if (!p)
+ fatalbox("out of memory");
+ p[0] = 0;
+ for (i = 1; i <= n; i++)
+ p[i] = bignum_byte(b, n - i);
+ i = 0;
+ while (i <= n && p[i] == 0 && (p[i + 1] & 0x80) == 0)
+ i++;
+ memmove(p, p + i, n + 1 - i);
+ *len = n + 1 - i;
+ return p;
+}
+static void ssh2_pkt_addmp(Ssh ssh, Bignum b)
+{
+ unsigned char *p;
+ int len;
+ p = ssh2_mpint_fmt(b, &len);
+ ssh2_pkt_addstring_start(ssh);
+ ssh2_pkt_addstring_data(ssh, (char *)p, len);
+ sfree(p);
+}
+
+/*
+ * Construct an SSH2 final-form packet: compress it, encrypt it,
+ * put the MAC on it. Final packet, ready to be sent, is stored in
+ * ssh->pktout.data. Total length is returned.
+ */
+static int ssh2_pkt_construct(Ssh ssh)
+{
+ int cipherblk, maclen, padding, i;
+
+ if (ssh->logctx)
+ log_packet(ssh->logctx, PKT_OUTGOING, ssh->pktout.data[5],
+ ssh2_pkt_type(ssh->pkt_ctx, ssh->pktout.data[5]),
+ ssh->pktout.data + 6, ssh->pktout.length - 6);
+
+ /*
+ * Compress packet payload.
+ */
+ {
+ unsigned char *newpayload;
+ int newlen;
+ if (ssh->cscomp &&
+ ssh->cscomp->compress(ssh->cs_comp_ctx, ssh->pktout.data + 5,
+ ssh->pktout.length - 5,
+ &newpayload, &newlen)) {
+ ssh->pktout.length = 5;
+ ssh2_pkt_adddata(ssh, newpayload, newlen);
+ sfree(newpayload);
+ }
+ }
+
+ /*
+ * Add padding. At least four bytes, and must also bring total
+ * length (minus MAC) up to a multiple of the block size.
+ */
+ cipherblk = ssh->cscipher ? ssh->cscipher->blksize : 8; /* block size */
+ cipherblk = cipherblk < 8 ? 8 : cipherblk; /* or 8 if blksize < 8 */
+ padding = 4;
+ padding +=
+ (cipherblk - (ssh->pktout.length + padding) % cipherblk) % cipherblk;
+ maclen = ssh->csmac ? ssh->csmac->len : 0;
+ ssh2_pkt_ensure(ssh, ssh->pktout.length + padding + maclen);
+ ssh->pktout.data[4] = padding;
+ for (i = 0; i < padding; i++)
+ ssh->pktout.data[ssh->pktout.length + i] = random_byte();
+ PUT_32BIT(ssh->pktout.data, ssh->pktout.length + padding - 4);
+ if (ssh->csmac)
+ ssh->csmac->generate(ssh->cs_mac_ctx, ssh->pktout.data,
+ ssh->pktout.length + padding,
+ ssh->v2_outgoing_sequence);
+ ssh->v2_outgoing_sequence++; /* whether or not we MACed */
+
+ if (ssh->cscipher)
+ ssh->cscipher->encrypt(ssh->cs_cipher_ctx,
+ ssh->pktout.data, ssh->pktout.length + padding);
+
+ /* Ready-to-send packet starts at ssh->pktout.data. We return length. */
+ return ssh->pktout.length + padding + maclen;
+}
+
+/*
+ * Construct and send an SSH2 packet immediately.
+ */
+static void ssh2_pkt_send(Ssh ssh)
+{
+ int len;
+ int backlog;
+ len = ssh2_pkt_construct(ssh);
+ backlog = sk_write(ssh->s, (char *)ssh->pktout.data, len);
+ if (backlog > SSH_MAX_BACKLOG)
+ ssh_throttle_all(ssh, 1, backlog);
+}
+
+/*
+ * Construct an SSH2 packet and add it to a deferred data block.
+ * Useful for sending multiple packets in a single sk_write() call,
+ * to prevent a traffic-analysing listener from being able to work
+ * out the length of any particular packet (such as the password
+ * packet).
+ *
+ * Note that because SSH2 sequence-numbers its packets, this can
+ * NOT be used as an m4-style `defer' allowing packets to be
+ * constructed in one order and sent in another.
+ */
+static void ssh2_pkt_defer(Ssh ssh)
+{
+ int len = ssh2_pkt_construct(ssh);
+ if (ssh->deferred_len + len > ssh->deferred_size) {
+ ssh->deferred_size = ssh->deferred_len + len + 128;
+ ssh->deferred_send_data = srealloc(ssh->deferred_send_data,
+ ssh->deferred_size);
+ }
+ memcpy(ssh->deferred_send_data + ssh->deferred_len, ssh->pktout.data, len);
+ ssh->deferred_len += len;
+}
+
+/*
+ * Send the whole deferred data block constructed by
+ * ssh2_pkt_defer() or SSH1's defer_packet().
+ */
+static void ssh_pkt_defersend(Ssh ssh)
+{
+ int backlog;
+ backlog = sk_write(ssh->s, (char *)ssh->deferred_send_data,
+ ssh->deferred_len);
+ ssh->deferred_len = ssh->deferred_size = 0;
+ sfree(ssh->deferred_send_data);
+ ssh->deferred_send_data = NULL;
+ if (backlog > SSH_MAX_BACKLOG)
+ ssh_throttle_all(ssh, 1, backlog);
+}
+
+#if 0
+void bndebug(char *string, Bignum b)
+{
+ unsigned char *p;
+ int i, len;
+ p = ssh2_mpint_fmt(b, &len);
+ debug(("%s", string));
+ for (i = 0; i < len; i++)
+ debug((" %02x", p[i]));
+ debug(("\n"));
+ sfree(p);
+}
+#endif
+
+static void sha_mpint(SHA_State * s, Bignum b)
+{
+ unsigned char *p;
+ int len;
+ p = ssh2_mpint_fmt(b, &len);
+ sha_string(s, p, len);
+ sfree(p);
+}
+
+/*
+ * SSH2 packet decode functions.
+ */
+static unsigned long ssh2_pkt_getuint32(Ssh ssh)
+{
+ unsigned long value;
+ if (ssh->pktin.length - ssh->pktin.savedpos < 4)
+ return 0; /* arrgh, no way to decline (FIXME?) */
+ value = GET_32BIT(ssh->pktin.data + ssh->pktin.savedpos);
+ ssh->pktin.savedpos += 4;
+ return value;
+}
+static int ssh2_pkt_getbool(Ssh ssh)
+{
+ unsigned long value;
+ if (ssh->pktin.length - ssh->pktin.savedpos < 1)
+ return 0; /* arrgh, no way to decline (FIXME?) */
+ value = ssh->pktin.data[ssh->pktin.savedpos] != 0;
+ ssh->pktin.savedpos++;
+ return value;
+}
+static void ssh2_pkt_getstring(Ssh ssh, char **p, int *length)
+{
+ int len;
+ *p = NULL;
+ *length = 0;
+ if (ssh->pktin.length - ssh->pktin.savedpos < 4)
+ return;
+ len = GET_32BIT(ssh->pktin.data + ssh->pktin.savedpos);
+ if (len < 0)
+ return;
+ *length = len;
+ ssh->pktin.savedpos += 4;
+ if (ssh->pktin.length - ssh->pktin.savedpos < *length)
+ return;
+ *p = (char *)(ssh->pktin.data + ssh->pktin.savedpos);
+ ssh->pktin.savedpos += *length;
+}
+static Bignum ssh2_pkt_getmp(Ssh ssh)
+{
+ char *p;
+ int length;
+ Bignum b;
+
+ ssh2_pkt_getstring(ssh, &p, &length);
+ if (!p)
+ return NULL;
+ if (p[0] & 0x80) {
+ bombout((ssh,"internal error: Can't handle negative mpints"));
+ return NULL;
+ }
+ b = bignum_from_bytes((unsigned char *)p, length);
+ return b;
+}
+
+/*
+ * Helper function to add an SSH2 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
+ * BUG_SSH2_RSA_PADDING.
+ */
+static void ssh2_add_sigblob(Ssh ssh, void *pkblob_v, int pkblob_len,
+ void *sigblob_v, int sigblob_len)
+{
+ unsigned char *pkblob = (unsigned char *)pkblob_v;
+ unsigned char *sigblob = (unsigned char *)sigblob_v;
+
+ /* dmemdump(pkblob, pkblob_len); */
+ /* dmemdump(sigblob, sigblob_len); */
+
+ /*
+ * See if this is in fact an ssh-rsa signature and a buggy
+ * server; otherwise we can just do this the easy way.
+ */
+ if ((ssh->remote_bugs & BUG_SSH2_RSA_PADDING) &&
+ (GET_32BIT(pkblob) == 7 && !memcmp(pkblob+4, "ssh-rsa", 7))) {
+ int pos, len, siglen;
+
+ /*
+ * Find the byte length of the modulus.
+ */
+
+ pos = 4+7; /* skip over "ssh-rsa" */
+ pos += 4 + GET_32BIT(pkblob+pos); /* skip over exponent */
+ len = GET_32BIT(pkblob+pos); /* find length of modulus */
+ pos += 4; /* find modulus itself */
+ while (len > 0 && pkblob[pos] == 0)
+ len--, pos++;
+ /* debug(("modulus length is %d\n", len)); */
+
+ /*
+ * Now find the signature integer.
+ */
+ pos = 4+7; /* skip over "ssh-rsa" */
+ siglen = GET_32BIT(sigblob+pos);
+ /* debug(("signature length is %d\n", siglen)); */
+
+ if (len != siglen) {
+ unsigned char newlen[4];
+ ssh2_pkt_addstring_start(ssh);
+ ssh2_pkt_addstring_data(ssh, (char *)sigblob, pos);
+ /* dmemdump(sigblob, pos); */
+ pos += 4; /* point to start of actual sig */
+ PUT_32BIT(newlen, len);
+ ssh2_pkt_addstring_data(ssh, (char *)newlen, 4);
+ /* dmemdump(newlen, 4); */
+ newlen[0] = 0;
+ while (len-- > siglen) {
+ ssh2_pkt_addstring_data(ssh, (char *)newlen, 1);
+ /* dmemdump(newlen, 1); */
+ }
+ ssh2_pkt_addstring_data(ssh, (char *)(sigblob+pos), siglen);
+ /* dmemdump(sigblob+pos, siglen); */
+ return;
+ }
+
+ /* Otherwise fall through and do it the easy way. */
+ }
+
+ ssh2_pkt_addstring_start(ssh);
+ ssh2_pkt_addstring_data(ssh, (char *)sigblob, sigblob_len);
+}
+
+/*
+ * Examine the remote side's version string and compare it against
+ * a list of known buggy implementations.
+ */
+static void ssh_detect_bugs(Ssh ssh, char *vstring)
+{
+ char *imp; /* pointer to implementation part */
+ imp = vstring;
+ imp += strcspn(imp, "-");
+ if (*imp) imp++;
+ imp += strcspn(imp, "-");
+ if (*imp) imp++;
+
+ ssh->remote_bugs = 0;
+
+ if (ssh->cfg.sshbug_ignore1 == FORCE_ON ||
+ (ssh->cfg.sshbug_ignore1 == AUTO &&
+ (!strcmp(imp, "1.2.18") || !strcmp(imp, "1.2.19") ||
+ !strcmp(imp, "1.2.20") || !strcmp(imp, "1.2.21") ||
+ !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25")))) {
+ /*
+ * These versions don't support SSH1_MSG_IGNORE, so we have
+ * to use a different defence against password length
+ * sniffing.
+ */
+ ssh->remote_bugs |= BUG_CHOKES_ON_SSH1_IGNORE;
+ logevent("We believe remote version has SSH1 ignore bug");
+ }
+
+ if (ssh->cfg.sshbug_plainpw1 == FORCE_ON ||
+ (ssh->cfg.sshbug_plainpw1 == AUTO &&
+ (!strcmp(imp, "Cisco-1.25")))) {
+ /*
+ * These versions need a plain password sent; they can't
+ * handle having a null and a random length of data after
+ * the password.
+ */
+ ssh->remote_bugs |= BUG_NEEDS_SSH1_PLAIN_PASSWORD;
+ logevent("We believe remote version needs a plain SSH1 password");
+ }
+
+ if (ssh->cfg.sshbug_rsa1 == FORCE_ON ||
+ (ssh->cfg.sshbug_rsa1 == AUTO &&
+ (!strcmp(imp, "Cisco-1.25")))) {
+ /*
+ * These versions apparently have no clue whatever about
+ * RSA authentication and will panic and die if they see
+ * an AUTH_RSA message.
+ */
+ ssh->remote_bugs |= BUG_CHOKES_ON_RSA;
+ logevent("We believe remote version can't handle RSA authentication");
+ }
+
+ if (ssh->cfg.sshbug_hmac2 == FORCE_ON ||
+ (ssh->cfg.sshbug_hmac2 == AUTO &&
+ (wc_match("2.1.0*", imp) || wc_match("2.0.*", imp) ||
+ wc_match("2.2.0*", imp) || wc_match("2.3.0*", imp) ||
+ wc_match("2.1 *", imp)))) {
+ /*
+ * These versions have the HMAC bug.
+ */
+ ssh->remote_bugs |= BUG_SSH2_HMAC;
+ logevent("We believe remote version has SSH2 HMAC bug");
+ }
+
+ if (ssh->cfg.sshbug_derivekey2 == FORCE_ON ||
+ (ssh->cfg.sshbug_derivekey2 == AUTO &&
+ (wc_match("2.0.0*", imp) || wc_match("2.0.1[01]*", imp) ))) {
+ /*
+ * These versions have the key-derivation bug (failing to
+ * include the literal shared secret in the hashes that
+ * generate the keys).
+ */
+ ssh->remote_bugs |= BUG_SSH2_DERIVEKEY;
+ logevent("We believe remote version has SSH2 key-derivation bug");
+ }
+
+ if (ssh->cfg.sshbug_rsapad2 == FORCE_ON ||
+ (ssh->cfg.sshbug_rsapad2 == AUTO &&
+ (wc_match("OpenSSH_2.[5-9]*", imp) ||
+ wc_match("OpenSSH_3.[0-2]*", imp)))) {
+ /*
+ * These versions have the SSH2 RSA padding bug.
+ */
+ ssh->remote_bugs |= BUG_SSH2_RSA_PADDING;
+ logevent("We believe remote version has SSH2 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
+ * public-key authentication.
+ */
+ ssh->remote_bugs |= BUG_SSH2_PK_SESSIONID;
+ logevent("We believe remote version has SSH2 public-key-session-ID bug");
+ }
+
+ if (ssh->cfg.sshbug_dhgex2 == FORCE_ON) {
+ /*
+ * User specified the SSH2 DH GEX bug.
+ */
+ ssh->remote_bugs |= BUG_SSH2_DH_GEX;
+ logevent("We believe remote version has SSH2 DH group exchange bug");
+ }
+}
+
+static int do_ssh_init(Ssh ssh, unsigned char c)
+{
+ struct do_ssh_init_state {
+ int vslen;
+ char version[10];
+ char *vstring;
+ int vstrsize;
+ int i;
+ int proto1, proto2;
+ };
+ crState(do_ssh_init_state);
+
+ 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 */
+ }
+
+ s->vstrsize = 16;
+ s->vstring = smalloc(s->vstrsize);
+ strcpy(s->vstring, "SSH-");
+ s->vslen = 4;
+ s->i = 0;
+ while (1) {
+ crReturn(1); /* get another char */
+ if (s->vslen >= s->vstrsize - 1) {
+ s->vstrsize += 16;
+ s->vstring = srealloc(s->vstring, s->vstrsize);
+ }
+ s->vstring[s->vslen++] = c;
+ if (s->i >= 0) {
+ if (c == '-') {
+ s->version[s->i] = '\0';
+ s->i = -1;
+ } else if (s->i < sizeof(s->version) - 1)
+ s->version[s->i++] = c;
+ } else if (c == '\012')
+ break;
+ }
+
+ ssh->agentfwd_enabled = FALSE;
+ ssh->rdpkt2_state.incoming_sequence = 0;
+
+ s->vstring[s->vslen] = 0;
+ s->vstring[strcspn(s->vstring, "\r\n")] = '\0';/* remove EOL chars */
+ {
+ char *vlog;
+ vlog = smalloc(20 + s->vslen);
+ sprintf(vlog, "Server version: %s", s->vstring);
+ logevent(vlog);
+ sfree(vlog);
+ }
+ ssh_detect_bugs(ssh, s->vstring);
+
+ /*
+ * Decide which SSH protocol version to support.
+ */
+
+ /* Anything strictly below "2.0" means protocol 1 is supported. */
+ s->proto1 = ssh_versioncmp(s->version, "2.0") < 0;
+ /* Anything greater or equal to "1.99" means protocol 2 is supported. */
+ s->proto2 = ssh_versioncmp(s->version, "1.99") >= 0;
+
+ if (ssh->cfg.sshprot == 0 && !s->proto1) {
+ bombout((ssh,"SSH protocol version 1 required by user but not provided by server"));
+ crReturn(0);
+ }
+ if (ssh->cfg.sshprot == 3 && !s->proto2) {
+ bombout((ssh,"SSH protocol version 2 required by user but not provided by server"));
+ crReturn(0);
+ }
+
+ if (s->proto2 && (ssh->cfg.sshprot >= 2 || !s->proto1)) {
+ /*
+ * Use v2 protocol.
+ */
+ char verstring[80], vlog[100];
+ sprintf(verstring, "SSH-2.0-%s", sshver);
+ SHA_Init(&ssh->exhashbase);
+ /*
+ * Hash our version string and their version string.
+ */
+ sha_string(&ssh->exhashbase, verstring, strlen(verstring));
+ sha_string(&ssh->exhashbase, s->vstring, strcspn(s->vstring, "\r\n"));
+ sprintf(vlog, "We claim version: %s", verstring);
+ logevent(vlog);
+ strcat(verstring, "\012");
+ logevent("Using SSH protocol version 2");
+ sk_write(ssh->s, verstring, strlen(verstring));
+ ssh->protocol = ssh2_protocol;
+ ssh->version = 2;
+ ssh->s_rdpkt = ssh2_rdpkt;
+ } else {
+ /*
+ * Use v1 protocol.
+ */
+ char verstring[80], vlog[100];
+ sprintf(verstring, "SSH-%s-%s",
+ (ssh_versioncmp(s->version, "1.5") <= 0 ? s->version : "1.5"),
+ sshver);
+ sprintf(vlog, "We claim version: %s", verstring);
+ logevent(vlog);
+ strcat(verstring, "\012");
+
+ logevent("Using SSH protocol version 1");
+ sk_write(ssh->s, verstring, strlen(verstring));
+ ssh->protocol = ssh1_protocol;
+ ssh->version = 1;
+ ssh->s_rdpkt = ssh1_rdpkt;
+ }
+ ssh->state = SSH_STATE_BEFORE_SIZE;
+
+ sfree(s->vstring);
+
+ crFinish(0);
+}
+
+static void ssh_gotdata(Ssh ssh, unsigned char *data, int datalen)
+{
+ crBegin(ssh->ssh_gotdata_crstate);
+
+ /*
+ * To begin with, feed the characters one by one to the
+ * protocol initialisation / selection function do_ssh_init().
+ * When that returns 0, we're done with the initial greeting
+ * exchange and can move on to packet discipline.
+ */
+ while (1) {
+ int ret; /* need not be kept across crReturn */
+ if (datalen == 0)
+ crReturnV; /* more data please */
+ ret = do_ssh_init(ssh, *data);
+ data++;
+ datalen--;
+ if (ret == 0)
+ break;
+ }
+
+ /*
+ * We emerge from that loop when the initial negotiation is
+ * over and we have selected an s_rdpkt function. Now pass
+ * everything to s_rdpkt, and then pass the resulting packets
+ * to the proper protocol handler.
+ */
+ if (datalen == 0)
+ crReturnV;
+ while (1) {
+ while (datalen > 0) {
+ if (ssh->s_rdpkt(ssh, &data, &datalen) == 0) {
+ if (ssh->state == SSH_STATE_CLOSED) {
+ return;
+ }
+ ssh->protocol(ssh, NULL, 0, 1);
+ if (ssh->state == SSH_STATE_CLOSED) {
+ return;
+ }
+ }
+ }
+ crReturnV;
+ }
+ crFinishV;
+}
+
+static int ssh_closing(Plug plug, char *error_msg, int error_code,
+ int calling_back)
+{
+ Ssh ssh = (Ssh) plug;
+ ssh->state = SSH_STATE_CLOSED;
+ if (ssh->s) {
+ sk_close(ssh->s);
+ ssh->s = NULL;
+ }
+ if (error_msg) {
+ /* A socket error has occurred. */
+ logevent(error_msg);
+ connection_fatal(ssh->frontend, error_msg);
+ } else {
+ /* Otherwise, the remote side closed the connection normally. */
+ }
+ return 0;
+}
+
+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) {
+ if (ssh->s) {
+ sk_close(ssh->s);
+ ssh->s = NULL;
+ }
+ return 0;
+ }
+ return 1;
+}
+
+static void ssh_sent(Plug plug, int bufsize)
+{
+ Ssh ssh = (Ssh) plug;
+ /*
+ * If the send backlog on the SSH socket itself clears, we
+ * should unthrottle the whole world if it was throttled.
+ */
+ if (bufsize < SSH_MAX_BACKLOG)
+ ssh_throttle_all(ssh, 0, bufsize);
+}
+
+/*
+ * Connect to specified host and port.
+ * Returns an error message, or NULL on success.
+ * Also places the canonical host name into `realhost'. It must be
+ * freed by the caller.
+ */
+static char *connect_to_host(Ssh ssh, char *host, int port,
+ char **realhost, int nodelay)
+{
+ static const struct plug_function_table fn_table = {
+ ssh_closing,
+ ssh_receive,
+ ssh_sent,
+ NULL
+ };
+
+ SockAddr addr;
+ char *err;
+
+ ssh->savedhost = smalloc(1 + strlen(host));
+ if (!ssh->savedhost)
+ fatalbox("Out of memory");
+ strcpy(ssh->savedhost, host);
+
+ if (port < 0)
+ port = 22; /* default ssh port */
+ ssh->savedport = port;
+
+ /*
+ * Try to find host.
+ */
+ logeventf(ssh, "Looking up host \"%s\"", host);
+ addr = name_lookup(host, port, realhost, &ssh->cfg);
+ if ((err = sk_addr_error(addr)) != NULL)
+ return err;
+
+ /*
+ * 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, (Plug) ssh, &ssh->cfg);
+ if ((err = sk_socket_error(ssh->s)) != NULL) {
+ ssh->s = NULL;
+ return err;
+ }
+
+ return NULL;
+}
+
+/*
+ * Throttle or unthrottle the SSH connection.
+ */
+static void ssh1_throttle(Ssh ssh, int adjust)
+{
+ int old_count = ssh->v1_throttle_count;
+ ssh->v1_throttle_count += adjust;
+ assert(ssh->v1_throttle_count >= 0);
+ if (ssh->v1_throttle_count && !old_count) {
+ sk_set_frozen(ssh->s, 1);
+ } else if (!ssh->v1_throttle_count && old_count) {
+ sk_set_frozen(ssh->s, 0);
+ }
+}
+
+/*
+ * Throttle or unthrottle _all_ local data streams (for when sends
+ * on the SSH connection itself back up).
+ */
+static void ssh_throttle_all(Ssh ssh, int enable, int bufsize)
+{
+ int i;
+ struct ssh_channel *c;
+
+ if (enable == ssh->throttled_all)
+ return;
+ ssh->throttled_all = enable;
+ ssh->overall_bufsize = bufsize;
+ if (!ssh->channels)
+ return;
+ for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
+ switch (c->type) {
+ case CHAN_MAINSESSION:
+ /*
+ * This is treated separately, outside the switch.
+ */
+ break;
+ case CHAN_X11:
+ x11_override_throttle(c->u.x11.s, enable);
+ break;
+ case CHAN_AGENT:
+ /* Agent channels require no buffer management. */
+ break;
+ case CHAN_SOCKDATA:
+ pfd_override_throttle(c->u.x11.s, enable);
+ break;
+ }
+ }
+}
+
+/*
+ * Username and password input, abstracted off into routines
+ * reusable in several places - even between SSH1 and SSH2.
+ */
+
+/* Set up a username or password input loop on a given buffer. */
+static void setup_userpass_input(Ssh ssh, char *buffer, int buflen, int echo)
+{
+ ssh->userpass_input_buffer = buffer;
+ ssh->userpass_input_buflen = buflen;
+ ssh->userpass_input_bufpos = 0;
+ ssh->userpass_input_echo = echo;
+}
+
+/*
+ * Process some terminal data in the course of username/password
+ * input. Returns >0 for success (line of input returned in
+ * buffer), <0 for failure (user hit ^C/^D, bomb out and exit), 0
+ * for inconclusive (keep waiting for more input please).
+ */
+static int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
+{
+ char c;
+
+ while (inlen--) {
+ switch (c = *in++) {
+ case 10:
+ case 13:
+ ssh->userpass_input_buffer[ssh->userpass_input_bufpos] = 0;
+ ssh->userpass_input_buffer[ssh->userpass_input_buflen-1] = 0;
+ return +1;
+ break;
+ case 8:
+ case 127:
+ if (ssh->userpass_input_bufpos > 0) {
+ if (ssh->userpass_input_echo)
+ c_write_str(ssh, "\b \b");
+ ssh->userpass_input_bufpos--;
+ }
+ break;
+ case 21:
+ case 27:
+ while (ssh->userpass_input_bufpos > 0) {
+ if (ssh->userpass_input_echo)
+ c_write_str(ssh, "\b \b");
+ ssh->userpass_input_bufpos--;
+ }
+ break;
+ case 3:
+ case 4:
+ return -1;
+ break;
+ default:
+ if (((c >= ' ' && c <= '~') ||
+ ((unsigned char) c >= 160))
+ && ssh->userpass_input_bufpos < ssh->userpass_input_buflen-1) {
+ ssh->userpass_input_buffer[ssh->userpass_input_bufpos++] = c;
+ if (ssh->userpass_input_echo)
+ c_write(ssh, &c, 1);
+ }
+ break;
+ }
+ }
+ return 0;
+}
+
+/*
+ * Handle the key exchange and user authentication phases.
+ */
+static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
+{
+ int i, j;
+ unsigned char cookie[8];
+ struct RSAKey servkey, hostkey;
+ struct MD5Context md5c;
+ struct do_ssh1_login_state {
+ int len;
+ unsigned char *rsabuf, *keystr1, *keystr2;
+ unsigned long supported_ciphers_mask, supported_auths_mask;
+ int tried_publickey, tried_agent;
+ int tis_auth_refused, ccard_auth_refused;
+ unsigned char session_id[16];
+ int cipher_type;
+ char username[100];
+ void *publickey_blob;
+ int publickey_bloblen;
+ char password[100];
+ char prompt[200];
+ int pos;
+ char c;
+ int pwpkt_type;
+ unsigned char request[5], *response, *p;
+ int responselen;
+ int keyi, nkeys;
+ int authed;
+ struct RSAKey key;
+ Bignum challenge;
+ char *commentp;
+ int commentlen;
+ };
+ crState(do_ssh1_login_state);
+
+ crBegin(ssh->do_ssh1_login_crstate);
+
+ if (!ispkt)
+ crWaitUntil(ispkt);
+
+ if (ssh->pktin.type != SSH1_SMSG_PUBLIC_KEY) {
+ bombout((ssh,"Public key packet not received"));
+ crReturn(0);
+ }
+
+ logevent("Received public keys");
+
+ memcpy(cookie, ssh->pktin.body, 8);
+
+ i = makekey(ssh->pktin.body + 8, &servkey, &s->keystr1, 0);
+ j = makekey(ssh->pktin.body + 8 + i, &hostkey, &s->keystr2, 0);
+
+ /*
+ * Log the host key fingerprint.
+ */
+ {
+ char logmsg[80];
+ logevent("Host key fingerprint is:");
+ strcpy(logmsg, " ");
+ hostkey.comment = NULL;
+ rsa_fingerprint(logmsg + strlen(logmsg),
+ sizeof(logmsg) - strlen(logmsg), &hostkey);
+ logevent(logmsg);
+ }
+
+ ssh->v1_remote_protoflags = GET_32BIT(ssh->pktin.body + 8 + i + j);
+ s->supported_ciphers_mask = GET_32BIT(ssh->pktin.body + 12 + i + j);
+ s->supported_auths_mask = GET_32BIT(ssh->pktin.body + 16 + i + j);
+
+ ssh->v1_local_protoflags =
+ ssh->v1_remote_protoflags & SSH1_PROTOFLAGS_SUPPORTED;
+ ssh->v1_local_protoflags |= SSH1_PROTOFLAG_SCREEN_NUMBER;
+
+ MD5Init(&md5c);
+ MD5Update(&md5c, s->keystr2, hostkey.bytes);
+ MD5Update(&md5c, s->keystr1, servkey.bytes);
+ MD5Update(&md5c, ssh->pktin.body, 8);
+ MD5Final(s->session_id, &md5c);
+
+ for (i = 0; i < 32; i++)
+ ssh->session_key[i] = random_byte();
+
+ s->len = (hostkey.bytes > servkey.bytes ? hostkey.bytes : servkey.bytes);
+
+ s->rsabuf = smalloc(s->len);
+ if (!s->rsabuf)
+ fatalbox("Out of memory");
+
+ /*
+ * Verify the host key.
+ */
+ {
+ /*
+ * First format the key into a string.
+ */
+ int len = rsastr_len(&hostkey);
+ char fingerprint[100];
+ char *keystr = smalloc(len);
+ 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);
+ sfree(keystr);
+ }
+
+ for (i = 0; i < 32; i++) {
+ s->rsabuf[i] = ssh->session_key[i];
+ if (i < 16)
+ s->rsabuf[i] ^= s->session_id[i];
+ }
+
+ if (hostkey.bytes > servkey.bytes) {
+ rsaencrypt(s->rsabuf, 32, &servkey);
+ rsaencrypt(s->rsabuf, servkey.bytes, &hostkey);
+ } else {
+ rsaencrypt(s->rsabuf, 32, &hostkey);
+ rsaencrypt(s->rsabuf, hostkey.bytes, &servkey);
+ }
+
+ logevent("Encrypted session key");
+
+ {
+ int cipher_chosen = 0, warn = 0;
+ char *cipher_string = NULL;
+ int i;
+ for (i = 0; !cipher_chosen && i < CIPHER_MAX; i++) {
+ int next_cipher = ssh->cfg.ssh_cipherlist[i];
+ if (next_cipher == CIPHER_WARN) {
+ /* If/when we choose a cipher, warn about it */
+ warn = 1;
+ } else if (next_cipher == CIPHER_AES) {
+ /* XXX Probably don't need to mention this. */
+ logevent("AES not supported in SSH1, skipping");
+ } else {
+ switch (next_cipher) {
+ case CIPHER_3DES: s->cipher_type = SSH_CIPHER_3DES;
+ cipher_string = "3DES"; break;
+ case CIPHER_BLOWFISH: s->cipher_type = SSH_CIPHER_BLOWFISH;
+ cipher_string = "Blowfish"; break;
+ case CIPHER_DES: s->cipher_type = SSH_CIPHER_DES;
+ cipher_string = "single-DES"; break;
+ }
+ if (s->supported_ciphers_mask & (1 << s->cipher_type))
+ cipher_chosen = 1;
+ }
+ }
+ if (!cipher_chosen) {
+ if ((s->supported_ciphers_mask & (1 << SSH_CIPHER_3DES)) == 0)
+ bombout((ssh,"Server violates SSH 1 protocol by not "
+ "supporting 3DES encryption"));
+ else
+ /* shouldn't happen */
+ bombout((ssh,"No supported ciphers found"));
+ crReturn(0);
+ }
+
+ /* Warn about chosen cipher if necessary. */
+ if (warn)
+ askcipher(ssh->frontend, cipher_string, 0);
+ }
+
+ switch (s->cipher_type) {
+ case SSH_CIPHER_3DES:
+ logevent("Using 3DES encryption");
+ break;
+ case SSH_CIPHER_DES:
+ logevent("Using single-DES encryption");
+ break;
+ case SSH_CIPHER_BLOWFISH:
+ logevent("Using Blowfish encryption");
+ break;
+ }
+
+ send_packet(ssh, SSH1_CMSG_SESSION_KEY,
+ PKT_CHAR, s->cipher_type,
+ PKT_DATA, cookie, 8,
+ PKT_CHAR, (s->len * 8) >> 8, PKT_CHAR, (s->len * 8) & 0xFF,
+ PKT_DATA, s->rsabuf, s->len,
+ PKT_INT, ssh->v1_local_protoflags, PKT_END);
+
+ logevent("Trying to enable encryption...");
+
+ sfree(s->rsabuf);
+
+ ssh->cipher = (s->cipher_type == SSH_CIPHER_BLOWFISH ? &ssh_blowfish_ssh1 :
+ s->cipher_type == SSH_CIPHER_DES ? &ssh_des :
+ &ssh_3des);
+ ssh->v1_cipher_ctx = ssh->cipher->make_context();
+ ssh->cipher->sesskey(ssh->v1_cipher_ctx, ssh->session_key);
+ logeventf(ssh, "Initialised %s encryption", ssh->cipher->text_name);
+
+ ssh->crcda_ctx = crcda_make_context();
+ logevent("Installing CRC compensation attack detector");
+
+ crWaitUntil(ispkt);
+
+ if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
+ bombout((ssh,"Encryption not successfully enabled"));
+ crReturn(0);
+ }
+
+ logevent("Successfully started encryption");
+
+ fflush(stdout);
+ {
+ if ((flags & FLAG_INTERACTIVE) && !*ssh->cfg.username) {
+ if (ssh_get_line && !ssh_getline_pw_only) {
+ if (!ssh_get_line("login as: ",
+ s->username, sizeof(s->username), FALSE)) {
+ /*
+ * get_line failed to get a username.
+ * Terminate.
+ */
+ logevent("No username provided. Abandoning session.");
+ ssh->state = SSH_STATE_CLOSED;
+ crReturn(1);
+ }
+ } else {
+ int ret; /* need not be kept over crReturn */
+ c_write_str(ssh, "login as: ");
+ ssh->send_ok = 1;
+
+ setup_userpass_input(ssh, s->username, sizeof(s->username), 1);
+ do {
+ crWaitUntil(!ispkt);
+ ret = process_userpass_input(ssh, in, inlen);
+ } while (ret == 0);
+ if (ret < 0)
+ cleanup_exit(0);
+ c_write_str(ssh, "\r\n");
+ }
+ } else {
+ strncpy(s->username, ssh->cfg.username, sizeof(s->username));
+ s->username[sizeof(s->username)-1] = '\0';
+ }
+
+ send_packet(ssh, SSH1_CMSG_USER, PKT_STR, s->username, PKT_END);
+ {
+ char userlog[22 + sizeof(s->username)];
+ sprintf(userlog, "Sent username \"%s\"", s->username);
+ logevent(userlog);
+ if (flags & FLAG_INTERACTIVE &&
+ (!((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)))) {
+ strcat(userlog, "\r\n");
+ c_write_str(ssh, userlog);
+ }
+ }
+ }
+
+ crWaitUntil(ispkt);
+
+ if ((ssh->remote_bugs & BUG_CHOKES_ON_RSA)) {
+ /* We must not attempt PK auth. Pretend we've already tried it. */
+ s->tried_publickey = s->tried_agent = 1;
+ } else {
+ s->tried_publickey = s->tried_agent = 0;
+ }
+ s->tis_auth_refused = s->ccard_auth_refused = 0;
+ /* Load the public half of ssh->cfg.keyfile so we notice if it's in Pageant */
+ if (!filename_is_null(ssh->cfg.keyfile)) {
+ if (!rsakey_pubblob(&ssh->cfg.keyfile,
+ &s->publickey_blob, &s->publickey_bloblen))
+ s->publickey_blob = NULL;
+ } else
+ s->publickey_blob = NULL;
+
+ while (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ s->pwpkt_type = SSH1_CMSG_AUTH_PASSWORD;
+
+ if (agent_exists() && !s->tried_agent) {
+ /*
+ * Attempt RSA authentication using Pageant.
+ */
+ void *r;
+
+ s->authed = FALSE;
+ s->tried_agent = 1;
+ logevent("Pageant is running. Requesting keys.");
+
+ /* Request the keys held by the agent. */
+ PUT_32BIT(s->request, 1);
+ s->request[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES;
+ agent_query(s->request, 5, &r, &s->responselen);
+ s->response = (unsigned char *) r;
+ if (s->response && s->responselen >= 5 &&
+ s->response[4] == SSH1_AGENT_RSA_IDENTITIES_ANSWER) {
+ 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);
+ }
+ for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) {
+ {
+ char buf[64];
+ sprintf(buf, "Trying Pageant key #%d", s->keyi);
+ logevent(buf);
+ }
+ if (s->publickey_blob &&
+ !memcmp(s->p, s->publickey_blob,
+ s->publickey_bloblen)) {
+ logevent("This key matches configured key file");
+ s->tried_publickey = 1;
+ }
+ s->p += 4;
+ s->p += ssh1_read_bignum(s->p, &s->key.exponent);
+ s->p += ssh1_read_bignum(s->p, &s->key.modulus);
+ s->commentlen = GET_32BIT(s->p);
+ s->p += 4;
+ s->commentp = (char *)s->p;
+ s->p += s->commentlen;
+ send_packet(ssh, SSH1_CMSG_AUTH_RSA,
+ PKT_BIGNUM, s->key.modulus, PKT_END);
+ crWaitUntil(ispkt);
+ if (ssh->pktin.type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
+ logevent("Key refused");
+ continue;
+ }
+ logevent("Received RSA challenge");
+ ssh1_read_bignum(ssh->pktin.body, &s->challenge);
+ {
+ char *agentreq, *q, *ret;
+ void *vret;
+ int len, retlen;
+ len = 1 + 4; /* message type, bit count */
+ len += ssh1_bignum_length(s->key.exponent);
+ len += ssh1_bignum_length(s->key.modulus);
+ len += ssh1_bignum_length(s->challenge);
+ len += 16; /* session id */
+ len += 4; /* response format */
+ agentreq = smalloc(4 + len);
+ PUT_32BIT(agentreq, len);
+ q = agentreq + 4;
+ *q++ = SSH1_AGENTC_RSA_CHALLENGE;
+ PUT_32BIT(q, bignum_bitcount(s->key.modulus));
+ q += 4;
+ q += ssh1_write_bignum(q, s->key.exponent);
+ q += ssh1_write_bignum(q, s->key.modulus);
+ q += ssh1_write_bignum(q, s->challenge);
+ memcpy(q, s->session_id, 16);
+ q += 16;
+ PUT_32BIT(q, 1); /* response format */
+ agent_query(agentreq, len + 4, &vret, &retlen);
+ ret = vret;
+ sfree(agentreq);
+ if (ret) {
+ if (ret[4] == SSH1_AGENT_RSA_RESPONSE) {
+ logevent("Sending Pageant's response");
+ send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
+ PKT_DATA, ret + 5, 16,
+ PKT_END);
+ sfree(ret);
+ crWaitUntil(ispkt);
+ if (ssh->pktin.type == SSH1_SMSG_SUCCESS) {
+ logevent
+ ("Pageant's response accepted");
+ if (flags & FLAG_VERBOSE) {
+ c_write_str(ssh, "Authenticated using"
+ " RSA key \"");
+ c_write(ssh, s->commentp,
+ s->commentlen);
+ c_write_str(ssh, "\" from agent\r\n");
+ }
+ s->authed = TRUE;
+ } else
+ logevent
+ ("Pageant's response not accepted");
+ } else {
+ logevent
+ ("Pageant failed to answer challenge");
+ sfree(ret);
+ }
+ } else {
+ logevent("No reply received from Pageant");
+ }
+ }
+ freebn(s->key.exponent);
+ freebn(s->key.modulus);
+ freebn(s->challenge);
+ if (s->authed)
+ break;
+ }
+ }
+ if (s->authed)
+ break;
+ }
+ if (!filename_is_null(ssh->cfg.keyfile) && !s->tried_publickey)
+ s->pwpkt_type = SSH1_CMSG_AUTH_RSA;
+
+ if (ssh->cfg.try_tis_auth &&
+ (s->supported_auths_mask & (1 << SSH1_AUTH_TIS)) &&
+ !s->tis_auth_refused) {
+ s->pwpkt_type = SSH1_CMSG_AUTH_TIS_RESPONSE;
+ logevent("Requested TIS authentication");
+ send_packet(ssh, SSH1_CMSG_AUTH_TIS, PKT_END);
+ crWaitUntil(ispkt);
+ if (ssh->pktin.type != SSH1_SMSG_AUTH_TIS_CHALLENGE) {
+ logevent("TIS authentication declined");
+ if (flags & FLAG_INTERACTIVE)
+ c_write_str(ssh, "TIS authentication refused.\r\n");
+ s->tis_auth_refused = 1;
+ continue;
+ } else {
+ int challengelen = GET_32BIT(ssh->pktin.body);
+ logevent("Received TIS challenge");
+ if (challengelen > sizeof(s->prompt) - 1)
+ challengelen = sizeof(s->prompt) - 1;/* prevent overrun */
+ memcpy(s->prompt, ssh->pktin.body + 4, challengelen);
+ /* Prompt heuristic comes from OpenSSH */
+ strncpy(s->prompt + challengelen,
+ memchr(s->prompt, '\n', challengelen) ?
+ "": "\r\nResponse: ",
+ (sizeof s->prompt) - challengelen);
+ s->prompt[(sizeof s->prompt) - 1] = '\0';
+ }
+ }
+ if (ssh->cfg.try_tis_auth &&
+ (s->supported_auths_mask & (1 << SSH1_AUTH_CCARD)) &&
+ !s->ccard_auth_refused) {
+ s->pwpkt_type = SSH1_CMSG_AUTH_CCARD_RESPONSE;
+ logevent("Requested CryptoCard authentication");
+ send_packet(ssh, SSH1_CMSG_AUTH_CCARD, PKT_END);
+ crWaitUntil(ispkt);
+ if (ssh->pktin.type != SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
+ logevent("CryptoCard authentication declined");
+ c_write_str(ssh, "CryptoCard authentication refused.\r\n");
+ s->ccard_auth_refused = 1;
+ continue;
+ } else {
+ int challengelen = GET_32BIT(ssh->pktin.body);
+ logevent("Received CryptoCard challenge");
+ if (challengelen > sizeof(s->prompt) - 1)
+ challengelen = sizeof(s->prompt) - 1;/* prevent overrun */
+ memcpy(s->prompt, ssh->pktin.body + 4, challengelen);
+ strncpy(s->prompt + challengelen,
+ memchr(s->prompt, '\n', challengelen) ?
+ "" : "\r\nResponse: ",
+ sizeof(s->prompt) - challengelen);
+ s->prompt[sizeof(s->prompt) - 1] = '\0';
+ }
+ }
+ if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
+ sprintf(s->prompt, "%.90s@%.90s's password: ",
+ s->username, ssh->savedhost);
+ }
+ 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);
+ c_write_str(ssh, "\r\n");
+ s->tried_publickey = 1;
+ continue;
+ }
+ if (!rsakey_encrypted(&ssh->cfg.keyfile, &comment)) {
+ if (flags & FLAG_VERBOSE)
+ c_write_str(ssh, "No passphrase required.\r\n");
+ goto tryauth;
+ }
+ sprintf(s->prompt, "Passphrase for key \"%.100s\": ", comment);
+ sfree(comment);
+ }
+
+ /*
+ * Show password prompt, having first obtained it via a TIS
+ * or CryptoCard exchange if we're doing TIS or CryptoCard
+ * authentication.
+ */
+ if (ssh_get_line) {
+ if (!ssh_get_line(s->prompt, s->password,
+ sizeof(s->password), TRUE)) {
+ /*
+ * get_line failed to get a password (for example
+ * 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->state = SSH_STATE_CLOSED;
+ crReturn(1);
+ }
+ } else {
+ /* Prompt may have come from server. We've munged it a bit, so
+ * we know it to be zero-terminated at least once. */
+ int ret; /* need not be saved over crReturn */
+ c_write_untrusted(ssh, s->prompt, strlen(s->prompt));
+ s->pos = 0;
+
+ setup_userpass_input(ssh, s->password, sizeof(s->password), 0);
+ do {
+ crWaitUntil(!ispkt);
+ ret = process_userpass_input(ssh, in, inlen);
+ } while (ret == 0);
+ if (ret < 0)
+ cleanup_exit(0);
+ c_write_str(ssh, "\r\n");
+ }
+
+ tryauth:
+ if (s->pwpkt_type == SSH1_CMSG_AUTH_RSA) {
+ /*
+ * Try public key authentication with the specified
+ * key file.
+ */
+ s->tried_publickey = 1;
+
+ {
+ int ret = loadrsakey(&ssh->cfg.keyfile, &s->key, s->password);
+ if (ret == 0) {
+ c_write_str(ssh, "Couldn't load private key from ");
+ c_write_str(ssh, filename_to_str(&ssh->cfg.keyfile));
+ c_write_str(ssh, ".\r\n");
+ continue; /* go and try password */
+ }
+ if (ret == -1) {
+ c_write_str(ssh, "Wrong passphrase.\r\n");
+ s->tried_publickey = 0;
+ continue; /* try again */
+ }
+ }
+
+ /*
+ * Send a public key attempt.
+ */
+ send_packet(ssh, SSH1_CMSG_AUTH_RSA,
+ PKT_BIGNUM, s->key.modulus, PKT_END);
+
+ crWaitUntil(ispkt);
+ if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ c_write_str(ssh, "Server refused our public key.\r\n");
+ continue; /* go and try password */
+ }
+ if (ssh->pktin.type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
+ bombout((ssh,"Bizarre response to offer of public key"));
+ crReturn(0);
+ }
+
+ {
+ int i;
+ unsigned char buffer[32];
+ Bignum challenge, response;
+
+ ssh1_read_bignum(ssh->pktin.body, &challenge);
+ response = rsadecrypt(challenge, &s->key);
+ freebn(s->key.private_exponent);/* burn the evidence */
+
+ for (i = 0; i < 32; i++) {
+ buffer[i] = bignum_byte(response, 31 - i);
+ }
+
+ MD5Init(&md5c);
+ MD5Update(&md5c, buffer, 32);
+ MD5Update(&md5c, s->session_id, 16);
+ MD5Final(buffer, &md5c);
+
+ send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
+ PKT_DATA, buffer, 16, PKT_END);
+
+ freebn(challenge);
+ freebn(response);
+ }
+
+ crWaitUntil(ispkt);
+ if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ if (flags & FLAG_VERBOSE)
+ c_write_str(ssh, "Failed to authenticate with"
+ " our public key.\r\n");
+ continue; /* go and try password */
+ } else if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
+ bombout((ssh,"Bizarre response to RSA authentication response"));
+ crReturn(0);
+ }
+
+ break; /* we're through! */
+ } else {
+ if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
+ /*
+ * Defence against traffic analysis: we send a
+ * whole bunch of packets containing strings of
+ * different lengths. One of these strings is the
+ * password, in a SSH1_CMSG_AUTH_PASSWORD packet.
+ * The others are all random data in
+ * SSH1_MSG_IGNORE packets. This way a passive
+ * listener can't tell which is the password, and
+ * hence can't deduce the password length.
+ *
+ * Anybody with a password length greater than 16
+ * bytes is going to have enough entropy in their
+ * password that a listener won't find it _that_
+ * much help to know how long it is. So what we'll
+ * do is:
+ *
+ * - if password length < 16, we send 15 packets
+ * containing string lengths 1 through 15
+ *
+ * - otherwise, we let N be the nearest multiple
+ * of 8 below the password length, and send 8
+ * packets containing string lengths N through
+ * N+7. This won't obscure the order of
+ * magnitude of the password length, but it will
+ * introduce a bit of extra uncertainty.
+ *
+ * A few servers (the old 1.2.18 through 1.2.22)
+ * can't deal with SSH1_MSG_IGNORE. For these
+ * servers, we need an alternative defence. We make
+ * use of the fact that the password is interpreted
+ * as a C string: so we can append a NUL, then some
+ * random data.
+ *
+ * One server (a Cisco one) can deal with neither
+ * SSH1_MSG_IGNORE _nor_ a padded password string.
+ * For this server we are left with no defences
+ * against password length sniffing.
+ */
+ if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE)) {
+ /*
+ * The server can deal with SSH1_MSG_IGNORE, so
+ * we can use the primary defence.
+ */
+ int bottom, top, pwlen, i;
+ char *randomstr;
+
+ pwlen = strlen(s->password);
+ if (pwlen < 16) {
+ bottom = 0; /* zero length passwords are OK! :-) */
+ top = 15;
+ } else {
+ bottom = pwlen & ~7;
+ top = bottom + 7;
+ }
+
+ assert(pwlen >= bottom && pwlen <= top);
+
+ randomstr = smalloc(top + 1);
+
+ for (i = bottom; i <= top; i++) {
+ if (i == pwlen)
+ defer_packet(ssh, s->pwpkt_type,
+ PKT_STR, s->password, PKT_END);
+ else {
+ for (j = 0; j < i; j++) {
+ do {
+ randomstr[j] = random_byte();
+ } while (randomstr[j] == '\0');
+ }
+ randomstr[i] = '\0';
+ defer_packet(ssh, SSH1_MSG_IGNORE,
+ PKT_STR, randomstr, PKT_END);
+ }
+ }
+ logevent("Sending password with camouflage packets");
+ ssh_pkt_defersend(ssh);
+ }
+ else if (!(ssh->remote_bugs & BUG_NEEDS_SSH1_PLAIN_PASSWORD)) {
+ /*
+ * The server can't deal with SSH1_MSG_IGNORE
+ * but can deal with padded passwords, so we
+ * can use the secondary defence.
+ */
+ char string[64];
+ char *ss;
+ int len;
+
+ len = strlen(s->password);
+ if (len < sizeof(string)) {
+ ss = string;
+ strcpy(string, s->password);
+ len++; /* cover the zero byte */
+ while (len < sizeof(string)) {
+ string[len++] = (char) random_byte();
+ }
+ } else {
+ ss = s->password;
+ }
+ logevent("Sending length-padded password");
+ send_packet(ssh, s->pwpkt_type, PKT_INT, len,
+ PKT_DATA, ss, len, PKT_END);
+ } else {
+ /*
+ * The server has _both_
+ * BUG_CHOKES_ON_SSH1_IGNORE and
+ * BUG_NEEDS_SSH1_PLAIN_PASSWORD. There is
+ * therefore nothing we can do.
+ */
+ int len;
+ len = strlen(s->password);
+ logevent("Sending unpadded password");
+ send_packet(ssh, s->pwpkt_type, PKT_INT, len,
+ PKT_DATA, s->password, len, PKT_END);
+ }
+ } else {
+ send_packet(ssh, s->pwpkt_type, PKT_STR, s->password, PKT_END);
+ }
+ }
+ logevent("Sent password");
+ memset(s->password, 0, strlen(s->password));
+ crWaitUntil(ispkt);
+ if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ if (flags & FLAG_VERBOSE)
+ c_write_str(ssh, "Access denied\r\n");
+ logevent("Authentication refused");
+ } else if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
+ bombout((ssh,"Strange packet received, type %d", ssh->pktin.type));
+ crReturn(0);
+ }
+ }
+
+ logevent("Authentication successful");
+
+ crFinish(1);
+}
+
+void sshfwd_close(struct ssh_channel *c)
+{
+ Ssh ssh = c->ssh;
+
+ if (c && !c->closes) {
+ /*
+ * If the channel's remoteid is -1, 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 (ssh->version == 1) {
+ send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE, PKT_INT, c->remoteid,
+ PKT_END);
+ } else {
+ ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_CLOSE);
+ ssh2_pkt_adduint32(ssh, c->remoteid);
+ ssh2_pkt_send(ssh);
+ }
+ }
+ c->closes = 1; /* sent MSG_CLOSE */
+ if (c->type == CHAN_X11) {
+ c->u.x11.s = NULL;
+ logevent("Forwarded X11 connection terminated");
+ } else if (c->type == CHAN_SOCKDATA ||
+ c->type == CHAN_SOCKDATA_DORMANT) {
+ c->u.pfd.s = NULL;
+ logevent("Forwarded port closed");
+ }
+ }
+}
+
+int sshfwd_write(struct ssh_channel *c, char *buf, int len)
+{
+ Ssh ssh = c->ssh;
+
+ if (ssh->version == 1) {
+ send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
+ PKT_INT, c->remoteid,
+ PKT_INT, len, PKT_DATA, buf, len, PKT_END);
+ /*
+ * In SSH1 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
+ * _everything_ will be throttled as a whole.
+ */
+ return 0;
+ } else {
+ ssh2_add_channel_data(c, buf, len);
+ return ssh2_try_send(c);
+ }
+}
+
+void sshfwd_unthrottle(struct ssh_channel *c, int bufsize)
+{
+ Ssh ssh = c->ssh;
+
+ if (ssh->version == 1) {
+ if (c->v.v1.throttling && bufsize < SSH1_BUFFER_LIMIT) {
+ c->v.v1.throttling = 0;
+ ssh1_throttle(ssh, -1);
+ }
+ } else {
+ ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
+ }
+}
+
+static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
+{
+ crBegin(ssh->ssh1_protocol_crstate);
+
+ random_init();
+
+ while (!do_ssh1_login(ssh, in, inlen, ispkt)) {
+ crReturnV;
+ }
+ if (ssh->state == SSH_STATE_CLOSED)
+ crReturnV;
+
+ if (ssh->cfg.agentfwd && agent_exists()) {
+ logevent("Requesting agent forwarding");
+ send_packet(ssh, SSH1_CMSG_AGENT_REQUEST_FORWARDING, PKT_END);
+ do {
+ crReturnV;
+ } while (!ispkt);
+ if (ssh->pktin.type != SSH1_SMSG_SUCCESS
+ && ssh->pktin.type != SSH1_SMSG_FAILURE) {
+ bombout((ssh,"Protocol confusion"));
+ crReturnV;
+ } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ logevent("Agent forwarding refused");
+ } else {
+ logevent("Agent forwarding enabled");
+ ssh->agentfwd_enabled = TRUE;
+ }
+ }
+
+ if (ssh->cfg.x11_forward) {
+ char proto[20], data[64];
+ logevent("Requesting X11 forwarding");
+ 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);
+ if (ssh->v1_local_protoflags & SSH1_PROTOFLAG_SCREEN_NUMBER) {
+ send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
+ PKT_STR, proto, PKT_STR, data,
+ 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);
+ }
+ do {
+ crReturnV;
+ } while (!ispkt);
+ if (ssh->pktin.type != SSH1_SMSG_SUCCESS
+ && ssh->pktin.type != SSH1_SMSG_FAILURE) {
+ bombout((ssh,"Protocol confusion"));
+ crReturnV;
+ } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ logevent("X11 forwarding refused");
+ } else {
+ logevent("X11 forwarding enabled");
+ ssh->X11_fwd_enabled = TRUE;
+ }
+ }
+
+ {
+ char type;
+ int n;
+ int sport,dport,sserv,dserv;
+ char sports[256], dports[256], saddr[256], host[256];
+
+ ssh->rportfwds = newtree234(ssh_rportcmp_ssh1);
+ /* Add port forwardings. */
+ ssh->portfwd_strptr = ssh->cfg.portfwd;
+ while (*ssh->portfwd_strptr) {
+ type = *ssh->portfwd_strptr++;
+ saddr[0] = '\0';
+ n = 0;
+ while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != '\t') {
+ if (*ssh->portfwd_strptr == ':') {
+ /*
+ * We've seen a colon in the middle of the
+ * source port number. This means that
+ * everything we've seen until now is the
+ * source _address_, so we'll move it into
+ * saddr and start sports from the beginning
+ * again.
+ */
+ ssh->portfwd_strptr++;
+ sports[n] = '\0';
+ strcpy(saddr, sports);
+ n = 0;
+ }
+ if (n < 255) sports[n++] = *ssh->portfwd_strptr++;
+ }
+ sports[n] = 0;
+ if (*ssh->portfwd_strptr == '\t')
+ ssh->portfwd_strptr++;
+ n = 0;
+ while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != ':') {
+ if (n < 255) host[n++] = *ssh->portfwd_strptr++;
+ }
+ host[n] = 0;
+ if (*ssh->portfwd_strptr == ':')
+ ssh->portfwd_strptr++;
+ n = 0;
+ while (*ssh->portfwd_strptr) {
+ if (n < 255) dports[n++] = *ssh->portfwd_strptr++;
+ }
+ dports[n] = 0;
+ ssh->portfwd_strptr++;
+ dport = atoi(dports);
+ dserv = 0;
+ if (dport == 0) {
+ dserv = 1;
+ dport = net_service_lookup(dports);
+ if (!dport) {
+ logeventf(ssh, "Service lookup failed for"
+ " destination port \"%s\"", dports);
+ }
+ }
+ sport = atoi(sports);
+ sserv = 0;
+ if (sport == 0) {
+ sserv = 1;
+ sport = net_service_lookup(sports);
+ if (!sport) {
+ logeventf(ssh, "Service lookup failed for source"
+ " port \"%s\"", sports);
+ }
+ }
+ if (sport && dport) {
+ if (type == 'L') {
+ pfd_addforward(host, dport, *saddr ? saddr : NULL,
+ sport, ssh, &ssh->cfg);
+ logeventf(ssh, "Local port %.*s%.*s%.*s%.*s%d%.*s"
+ " forwarding to %s:%.*s%.*s%d%.*s",
+ (int)(*saddr?strlen(saddr):0), *saddr?saddr:NULL,
+ (int)(*saddr?1:0), ":",
+ (int)(sserv ? strlen(sports) : 0), sports,
+ sserv, "(", sport, sserv, ")",
+ host,
+ (int)(dserv ? strlen(dports) : 0), dports,
+ dserv, "(", dport, dserv, ")");
+ } else {
+ struct ssh_rportfwd *pf;
+ pf = smalloc(sizeof(*pf));
+ strcpy(pf->dhost, host);
+ pf->dport = dport;
+ if (saddr) {
+ logeventf(ssh,
+ "SSH1 cannot handle source address spec \"%s:%d\"; ignoring",
+ saddr, sport);
+ }
+ if (add234(ssh->rportfwds, pf) != pf) {
+ logeventf(ssh,
+ "Duplicate remote port forwarding to %s:%d",
+ host, dport);
+ sfree(pf);
+ } else {
+ logeventf(ssh, "Requesting remote port %.*s%.*s%d%.*s"
+ " forward to %s:%.*s%.*s%d%.*s",
+ (int)(sserv ? strlen(sports) : 0), sports,
+ sserv, "(", sport, sserv, ")",
+ host,
+ (int)(dserv ? strlen(dports) : 0), dports,
+ dserv, "(", dport, dserv, ")");
+ send_packet(ssh, SSH1_CMSG_PORT_FORWARD_REQUEST,
+ PKT_INT, sport,
+ PKT_STR, host,
+ PKT_INT, dport,
+ PKT_END);
+ do {
+ crReturnV;
+ } while (!ispkt);
+ if (ssh->pktin.type != SSH1_SMSG_SUCCESS
+ && ssh->pktin.type != SSH1_SMSG_FAILURE) {
+ bombout((ssh,"Protocol confusion"));
+ crReturnV;
+ } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ c_write_str(ssh, "Server refused port"
+ " forwarding\r\n");
+ }
+ logevent("Remote port forwarding enabled");
+ }
+ }
+ }
+ }
+ }
+
+ if (!ssh->cfg.nopty) {
+ 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, PKT_CHAR, 0, PKT_END);
+ ssh->state = SSH_STATE_INTERMED;
+ do {
+ crReturnV;
+ } while (!ispkt);
+ if (ssh->pktin.type != SSH1_SMSG_SUCCESS
+ && ssh->pktin.type != SSH1_SMSG_FAILURE) {
+ bombout((ssh,"Protocol confusion"));
+ crReturnV;
+ } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ c_write_str(ssh, "Server refused to allocate pty\r\n");
+ ssh->editing = ssh->echoing = 1;
+ }
+ logevent("Allocated pty");
+ } else {
+ ssh->editing = ssh->echoing = 1;
+ }
+
+ if (ssh->cfg.compression) {
+ send_packet(ssh, SSH1_CMSG_REQUEST_COMPRESSION, PKT_INT, 6, PKT_END);
+ do {
+ crReturnV;
+ } while (!ispkt);
+ if (ssh->pktin.type != SSH1_SMSG_SUCCESS
+ && ssh->pktin.type != SSH1_SMSG_FAILURE) {
+ bombout((ssh,"Protocol confusion"));
+ crReturnV;
+ } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ c_write_str(ssh, "Server refused to compress\r\n");
+ }
+ logevent("Started compression");
+ ssh->v1_compressing = TRUE;
+ ssh->cs_comp_ctx = zlib_compress_init();
+ logevent("Initialised zlib (RFC1950) compression");
+ ssh->sc_comp_ctx = zlib_decompress_init();
+ logevent("Initialised zlib (RFC1950) decompression");
+ }
+
+ /*
+ * Start the shell or command.
+ *
+ * Special case: if the first-choice command is an SSH2
+ * subsystem (hence not usable here) and the second choice
+ * exists, we fall straight back to that.
+ */
+ {
+ char *cmd = ssh->cfg.remote_cmd_ptr;
+
+ if (ssh->cfg.ssh_subsys && ssh->cfg.remote_cmd_ptr2) {
+ cmd = ssh->cfg.remote_cmd_ptr2;
+ ssh->fallback_cmd = TRUE;
+ }
+ if (*cmd)
+ send_packet(ssh, SSH1_CMSG_EXEC_CMD, PKT_STR, cmd, PKT_END);
+ else
+ send_packet(ssh, SSH1_CMSG_EXEC_SHELL, PKT_END);
+ logevent("Started session");
+ }
+
+ ssh->state = SSH_STATE_SESSION;
+ if (ssh->size_needed)
+ ssh_size(ssh, ssh->term_width, ssh->term_height);
+ if (ssh->eof_needed)
+ ssh_special(ssh, TS_EOF);
+
+ if (ssh->ldisc)
+ ldisc_send(ssh->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
+ ssh->send_ok = 1;
+ ssh->channels = newtree234(ssh_channelcmp);
+ while (1) {
+ crReturnV;
+ if (ispkt) {
+ if (ssh->pktin.type == SSH1_SMSG_STDOUT_DATA ||
+ ssh->pktin.type == SSH1_SMSG_STDERR_DATA) {
+ long len = GET_32BIT(ssh->pktin.body);
+ int bufsize =
+ from_backend(ssh->frontend,
+ ssh->pktin.type == SSH1_SMSG_STDERR_DATA,
+ (char *)(ssh->pktin.body) + 4, len);
+ if (!ssh->v1_stdout_throttling && bufsize > SSH1_BUFFER_LIMIT) {
+ ssh->v1_stdout_throttling = 1;
+ ssh1_throttle(ssh, +1);
+ }
+ } else if (ssh->pktin.type == SSH1_MSG_DISCONNECT) {
+ ssh->state = SSH_STATE_CLOSED;
+ logevent("Received disconnect request");
+ crReturnV;
+ } else if (ssh->pktin.type == SSH1_SMSG_X11_OPEN) {
+ /* Remote side is trying to open a channel to talk to our
+ * X-Server. Give them back a local channel number. */
+ struct ssh_channel *c;
+
+ logevent("Received X11 connect request");
+ /* Refuse if X11 forwarding is disabled. */
+ if (!ssh->X11_fwd_enabled) {
+ send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
+ PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
+ logevent("Rejected X11 connect request");
+ } else {
+ c = smalloc(sizeof(struct ssh_channel));
+ c->ssh = ssh;
+
+ if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
+ ssh->x11auth, NULL, -1, &ssh->cfg) != NULL) {
+ logevent("opening X11 forward connection failed");
+ sfree(c);
+ send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
+ PKT_INT, GET_32BIT(ssh->pktin.body),
+ PKT_END);
+ } else {
+ logevent
+ ("opening X11 forward connection succeeded");
+ c->remoteid = GET_32BIT(ssh->pktin.body);
+ c->localid = alloc_channel_id(ssh);
+ c->closes = 0;
+ c->v.v1.throttling = 0;
+ c->type = CHAN_X11; /* identify channel type */
+ add234(ssh->channels, c);
+ send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
+ PKT_INT, c->remoteid, PKT_INT,
+ c->localid, PKT_END);
+ logevent("Opened X11 forward channel");
+ }
+ }
+ } else if (ssh->pktin.type == SSH1_SMSG_AGENT_OPEN) {
+ /* Remote side is trying to open a channel to talk to our
+ * agent. Give them back a local channel number. */
+ struct ssh_channel *c;
+
+ /* Refuse if agent forwarding is disabled. */
+ if (!ssh->agentfwd_enabled) {
+ send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
+ PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
+ } else {
+ c = smalloc(sizeof(struct ssh_channel));
+ c->ssh = ssh;
+ c->remoteid = GET_32BIT(ssh->pktin.body);
+ c->localid = alloc_channel_id(ssh);
+ c->closes = 0;
+ c->v.v1.throttling = 0;
+ c->type = CHAN_AGENT; /* identify channel type */
+ c->u.a.lensofar = 0;
+ add234(ssh->channels, c);
+ send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
+ PKT_INT, c->remoteid, PKT_INT, c->localid,
+ PKT_END);
+ }
+ } else if (ssh->pktin.type == SSH1_MSG_PORT_OPEN) {
+ /* Remote side is trying to open a channel to talk to a
+ * forwarded port. Give them back a local channel number. */
+ struct ssh_channel *c;
+ struct ssh_rportfwd pf;
+ int hostsize, port;
+ char host[256], buf[1024];
+ char *p, *h, *e;
+ c = smalloc(sizeof(struct ssh_channel));
+ c->ssh = ssh;
+
+ hostsize = GET_32BIT(ssh->pktin.body+4);
+ for (h = host, p = (char *)(ssh->pktin.body+8);
+ hostsize != 0; hostsize--) {
+ if (h+1 < host+sizeof(host))
+ *h++ = *p;
+ p++;
+ }
+ *h = 0;
+ port = GET_32BIT(p);
+
+ strcpy(pf.dhost, host);
+ pf.dport = port;
+
+ if (find234(ssh->rportfwds, &pf, NULL) == NULL) {
+ sprintf(buf, "Rejected remote port open request for %s:%d",
+ host, port);
+ logevent(buf);
+ send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
+ PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
+ } else {
+ sprintf(buf, "Received remote port open request for %s:%d",
+ host, port);
+ logevent(buf);
+ e = pfd_newconnect(&c->u.pfd.s, host, port, c, &ssh->cfg);
+ if (e != NULL) {
+ char buf[256];
+ sprintf(buf, "Port open failed: %s", e);
+ logevent(buf);
+ sfree(c);
+ send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
+ PKT_INT, GET_32BIT(ssh->pktin.body),
+ PKT_END);
+ } else {
+ c->remoteid = GET_32BIT(ssh->pktin.body);
+ c->localid = alloc_channel_id(ssh);
+ c->closes = 0;
+ c->v.v1.throttling = 0;
+ c->type = CHAN_SOCKDATA; /* identify channel type */
+ add234(ssh->channels, c);
+ send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
+ PKT_INT, c->remoteid, PKT_INT,
+ c->localid, PKT_END);
+ logevent("Forwarded port opened successfully");
+ }
+ }
+
+ } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_OPEN_CONFIRMATION) {
+ unsigned int remoteid = GET_32BIT(ssh->pktin.body);
+ unsigned int localid = GET_32BIT(ssh->pktin.body+4);
+ struct ssh_channel *c;
+
+ c = find234(ssh->channels, &remoteid, ssh_channelfind);
+ if (c && c->type == CHAN_SOCKDATA_DORMANT) {
+ c->remoteid = localid;
+ c->type = CHAN_SOCKDATA;
+ c->v.v1.throttling = 0;
+ pfd_confirm(c->u.pfd.s);
+ }
+
+ if (c && c->closes) {
+ /*
+ * We have a pending close on this channel,
+ * which we decided on before the server acked
+ * the channel open. So now we know the
+ * remoteid, we can close it again.
+ */
+ send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE,
+ PKT_INT, c->remoteid, PKT_END);
+ }
+
+ } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_OPEN_FAILURE) {
+ unsigned int remoteid = GET_32BIT(ssh->pktin.body);
+ struct ssh_channel *c;
+
+ c = find234(ssh->channels, &remoteid, ssh_channelfind);
+ if (c && c->type == CHAN_SOCKDATA_DORMANT) {
+ logevent("Forwarded connection refused by server");
+ pfd_close(c->u.pfd.s);
+ del234(ssh->channels, c);
+ sfree(c);
+ }
+
+ } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE ||
+ ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION) {
+ /* Remote side closes a channel. */
+ unsigned i = GET_32BIT(ssh->pktin.body);
+ struct ssh_channel *c;
+ c = find234(ssh->channels, &i, ssh_channelfind);
+ if (c && ((int)c->remoteid) != -1) {
+ int closetype;
+ closetype =
+ (ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE ? 1 : 2);
+
+ if ((c->closes == 0) && (c->type == CHAN_X11)) {
+ logevent("Forwarded X11 connection terminated");
+ assert(c->u.x11.s != NULL);
+ x11_close(c->u.x11.s);
+ c->u.x11.s = NULL;
+ }
+ if ((c->closes == 0) && (c->type == CHAN_SOCKDATA)) {
+ logevent("Forwarded port closed");
+ assert(c->u.pfd.s != NULL);
+ pfd_close(c->u.pfd.s);
+ c->u.pfd.s = NULL;
+ }
+
+ c->closes |= (closetype << 2); /* seen this message */
+ if (!(c->closes & closetype)) {
+ send_packet(ssh, ssh->pktin.type, PKT_INT, c->remoteid,
+ PKT_END);
+ c->closes |= closetype; /* sent it too */
+ }
+
+ if (c->closes == 15) {
+ del234(ssh->channels, c);
+ sfree(c);
+ }
+ } else {
+ bombout((ssh,"Received CHANNEL_CLOSE%s for %s channel %d\n",
+ ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE ? "" :
+ "_CONFIRMATION", c ? "half-open" : "nonexistent",
+ i));
+ }
+ } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_DATA) {
+ /* Data sent down one of our channels. */
+ int i = GET_32BIT(ssh->pktin.body);
+ int len = GET_32BIT(ssh->pktin.body + 4);
+ unsigned char *p = ssh->pktin.body + 8;
+ struct ssh_channel *c;
+ c = find234(ssh->channels, &i, ssh_channelfind);
+ if (c) {
+ int bufsize;
+ switch (c->type) {
+ case CHAN_X11:
+ bufsize = x11_send(c->u.x11.s, (char *)p, len);
+ break;
+ case CHAN_SOCKDATA:
+ bufsize = pfd_send(c->u.pfd.s, (char *)p, len);
+ break;
+ case CHAN_AGENT:
+ /* Data for an agent message. Buffer it. */
+ while (len > 0) {
+ if (c->u.a.lensofar < 4) {
+ int l = min(4 - c->u.a.lensofar, len);
+ memcpy(c->u.a.msglen + c->u.a.lensofar, p,
+ l);
+ p += l;
+ len -= l;
+ c->u.a.lensofar += l;
+ }
+ if (c->u.a.lensofar == 4) {
+ c->u.a.totallen =
+ 4 + GET_32BIT(c->u.a.msglen);
+ c->u.a.message = smalloc(c->u.a.totallen);
+ memcpy(c->u.a.message, c->u.a.msglen, 4);
+ }
+ if (c->u.a.lensofar >= 4 && len > 0) {
+ int l =
+ min(c->u.a.totallen - c->u.a.lensofar,
+ len);
+ memcpy(c->u.a.message + c->u.a.lensofar, p,
+ l);
+ p += l;
+ len -= l;
+ c->u.a.lensofar += l;
+ }
+ if (c->u.a.lensofar == c->u.a.totallen) {
+ void *reply, *sentreply;
+ int replylen;
+ agent_query(c->u.a.message,
+ c->u.a.totallen, &reply,
+ &replylen);
+ if (reply)
+ sentreply = reply;
+ else {
+ /* Fake SSH_AGENT_FAILURE. */
+ sentreply = "\0\0\0\1\5";
+ replylen = 5;
+ }
+ send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
+ PKT_INT, c->remoteid,
+ PKT_INT, replylen,
+ PKT_DATA, sentreply, replylen,
+ PKT_END);
+ if (reply)
+ sfree(reply);
+ sfree(c->u.a.message);
+ c->u.a.lensofar = 0;
+ }
+ }
+ bufsize = 0; /* agent channels never back up */
+ break;
+ }
+ if (!c->v.v1.throttling && bufsize > SSH1_BUFFER_LIMIT) {
+ c->v.v1.throttling = 1;
+ ssh1_throttle(ssh, +1);
+ }
+ }
+ } else if (ssh->pktin.type == SSH1_SMSG_SUCCESS) {
+ /* may be from EXEC_SHELL on some servers */
+ } else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
+ /* may be from EXEC_SHELL on some servers
+ * if no pty is available or in other odd cases. Ignore */
+ } else if (ssh->pktin.type == SSH1_SMSG_EXIT_STATUS) {
+ char buf[100];
+ ssh->exitcode = GET_32BIT(ssh->pktin.body);
+ sprintf(buf, "Server sent command exit status %d",
+ ssh->exitcode);
+ logevent(buf);
+ send_packet(ssh, SSH1_CMSG_EXIT_CONFIRMATION, PKT_END);
+ /*
+ * In case `helpful' firewalls or proxies tack
+ * extra human-readable text on the end of the
+ * session which we might mistake for another
+ * encrypted packet, we close the session once
+ * we've sent EXIT_CONFIRMATION.
+ */
+ ssh->state = SSH_STATE_CLOSED;
+ crReturnV;
+ } else {
+ bombout((ssh,"Strange packet received: type %d", ssh->pktin.type));
+ crReturnV;
+ }
+ } else {
+ while (inlen > 0) {
+ int len = min(inlen, 512);
+ send_packet(ssh, SSH1_CMSG_STDIN_DATA,
+ PKT_INT, len, PKT_DATA, in, len, PKT_END);
+ in += len;
+ inlen -= len;
+ }
+ }
+ }
+
+ crFinishV;
+}
+
+/*
+ * Utility routine for decoding comma-separated strings in KEXINIT.
+ */
+static int in_commasep_string(char *needle, char *haystack, int haylen)
+{
+ int needlen;
+ if (!needle || !haystack) /* protect against null pointers */
+ return 0;
+ needlen = strlen(needle);
+ while (1) {
+ /*
+ * 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 */
+ )