X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/729e54b41014557a58caa06e25a51150c78b11d3..fe50e8140a2dbb3ba357a0ab777f34e07d568c23:/ssh.c

diff --git a/ssh.c b/ssh.c
index 15fd3c41..c065f2f8 100644
--- a/ssh.c
+++ b/ssh.c
@@ -25,7 +25,7 @@
                       if ((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)) \
                       fprintf(stderr, "%s\n", s); }
 
-#define bombout(msg) ( ssh_state == SSH_STATE_CLOSED, closesocket(s), \
+#define bombout(msg) ( ssh_state = SSH_STATE_CLOSED, closesocket(s), \
                        s = INVALID_SOCKET, connection_fatal msg )
 
 #define SSH1_MSG_DISCONNECT                       1    /* 0x1 */
@@ -167,7 +167,7 @@ const static struct ssh_kex *kex_algs[] = { &ssh_diffiehellman };
 extern const struct ssh_hostkey ssh_dss;
 const static struct ssh_hostkey *hostkey_algs[] = { &ssh_dss };
 
-extern const struct ssh_mac ssh_sha1;
+extern const struct ssh_mac ssh_md5, ssh_sha1, ssh_sha1_buggy;
 
 static void nullmac_key(unsigned char *key) { }
 static void nullmac_generate(unsigned char *blk, int len, unsigned long seq) { }
@@ -175,7 +175,10 @@ static int nullmac_verify(unsigned char *blk, int len, unsigned long seq) { retu
 const static struct ssh_mac ssh_mac_none = {
     nullmac_key, nullmac_key, nullmac_generate, nullmac_verify, "none", 0
 };
-const static struct ssh_mac *macs[] = { &ssh_sha1, &ssh_mac_none };
+const static struct ssh_mac *macs[] = {
+    &ssh_sha1, &ssh_md5, &ssh_mac_none };
+const static struct ssh_mac *buggymacs[] = {
+    &ssh_sha1_buggy, &ssh_md5, &ssh_mac_none };
 
 const static struct ssh_compress ssh_comp_none = {
     "none"
@@ -263,6 +266,13 @@ static struct rdpkt1_state_tag {
     int chunk;
 } rdpkt1_state;
 
+static struct rdpkt2_state_tag {
+    long len, pad, payload, packetlen, maclen;
+    int i;
+    int cipherblk;
+    unsigned long incoming_sequence;
+} rdpkt2_state;
+
 static int ssh_channelcmp(void *av, void *bv) {
     struct ssh_channel *a = (struct ssh_channel *)av;
     struct ssh_channel *b = (struct ssh_channel *)bv;
@@ -312,13 +322,7 @@ static void c_write (char *buf, int len) {
                 fputc(buf[i], stderr);
 	return;
     }
-    while (len--) 
-        c_write1(*buf++);
-}
-
-static void c_writedata (char *buf, int len) {
-    while (len--)
-        c_write1(*buf++);
+    from_backend(1, buf, len);
 }
 
 /*
@@ -382,6 +386,12 @@ next_packet:
 
     if (cipher)
 	cipher->decrypt(pktin.data, st->biglen);
+#if 0
+    debug(("Got packet len=%d pad=%d\r\n", st->len, st->pad));
+    for (st->i = 0; st->i < st->biglen; st->i++)
+        debug(("  %02x", (unsigned char)pktin.data[st->i]));
+    debug(("\r\n"));
+#endif
 
     pktin.type = pktin.data[st->pad];
     pktin.body = pktin.data + st->pad + 1;
@@ -425,29 +435,24 @@ next_packet:
 
 static int ssh2_rdpkt(unsigned char **data, int *datalen)
 {
-    static long len, pad, payload, packetlen, maclen;
-    static int i;
-    static int cipherblk;
-    static unsigned long incoming_sequence = 0;
+    struct rdpkt2_state_tag *st = &rdpkt2_state;
 
     crBegin;
 
 next_packet:
-
     pktin.type = 0;
     pktin.length = 0;
-
-    if (cipher)
-        cipherblk = cipher->blksize;
+    if (sccipher)
+        st->cipherblk = sccipher->blksize;
     else
-        cipherblk = 8;
-    if (cipherblk < 8)
-        cipherblk = 8;
-
-    if (pktin.maxlen < cipherblk) {
-	pktin.maxlen = cipherblk;
-	pktin.data = (pktin.data == NULL ? malloc(cipherblk+APIEXTRA) :
-	              realloc(pktin.data, cipherblk+APIEXTRA));
+        st->cipherblk = 8;
+    if (st->cipherblk < 8)
+        st->cipherblk = 8;
+
+    if (pktin.maxlen < st->cipherblk) {
+	pktin.maxlen = st->cipherblk;
+	pktin.data = (pktin.data == NULL ? malloc(st->cipherblk+APIEXTRA) :
+	              realloc(pktin.data, st->cipherblk+APIEXTRA));
 	if (!pktin.data)
 	    fatalbox("Out of memory");
     }
@@ -456,10 +461,10 @@ next_packet:
      * Acquire and decrypt the first block of the packet. This will
      * contain the length and padding details.
      */
-     for (i = len = 0; i < cipherblk; i++) {
+     for (st->i = st->len = 0; st->i < st->cipherblk; st->i++) {
 	while ((*datalen) == 0)
-	    crReturn(cipherblk-i);
-	pktin.data[i] = *(*data)++;
+	    crReturn(st->cipherblk-st->i);
+	pktin.data[st->i] = *(*data)++;
         (*datalen)--;
     }
 #ifdef FWHACK
@@ -468,32 +473,32 @@ next_packet:
     }
 #endif
     if (sccipher)
-        sccipher->decrypt(pktin.data, cipherblk);
+        sccipher->decrypt(pktin.data, st->cipherblk);
 
     /*
      * Now get the length and padding figures.
      */
-    len = GET_32BIT(pktin.data);
-    pad = pktin.data[4];
+    st->len = GET_32BIT(pktin.data);
+    st->pad = pktin.data[4];
 
     /*
      * This enables us to deduce the payload length.
      */
-    payload = len - pad - 1;
+    st->payload = st->len - st->pad - 1;
 
-    pktin.length = payload + 5;
+    pktin.length = st->payload + 5;
 
     /*
      * So now we can work out the total packet length.
      */
-    packetlen = len + 4;
-    maclen = scmac ? scmac->len : 0;
+    st->packetlen = st->len + 4;
+    st->maclen = scmac ? scmac->len : 0;
 
     /*
      * Adjust memory allocation if packet is too big.
      */
-    if (pktin.maxlen < packetlen+maclen) {
-	pktin.maxlen = packetlen+maclen;
+    if (pktin.maxlen < st->packetlen+st->maclen) {
+	pktin.maxlen = st->packetlen+st->maclen;
 	pktin.data = (pktin.data == NULL ? malloc(pktin.maxlen+APIEXTRA) :
 	              realloc(pktin.data, pktin.maxlen+APIEXTRA));
 	if (!pktin.data)
@@ -503,31 +508,32 @@ next_packet:
     /*
      * Read and decrypt the remainder of the packet.
      */
-    for (i = cipherblk; i < packetlen + maclen; i++) {
+    for (st->i = st->cipherblk; st->i < st->packetlen + st->maclen; st->i++) {
 	while ((*datalen) == 0)
-	    crReturn(packetlen + maclen - i);
-	pktin.data[i] = *(*data)++;
+	    crReturn(st->packetlen + st->maclen - st->i);
+	pktin.data[st->i] = *(*data)++;
         (*datalen)--;
     }
     /* Decrypt everything _except_ the MAC. */
     if (sccipher)
-        sccipher->decrypt(pktin.data + cipherblk, packetlen - cipherblk);
+        sccipher->decrypt(pktin.data + st->cipherblk,
+                          st->packetlen - st->cipherblk);
 
 #if 0
-    debug(("Got packet len=%d pad=%d\r\n", len, pad));
-    for (i = 0; i < packetlen; i++)
-        debug(("  %02x", (unsigned char)pktin.data[i]));
+    debug(("Got packet len=%d pad=%d\r\n", st->len, st->pad));
+    for (st->i = 0; st->i < st->packetlen; st->i++)
+        debug(("  %02x", (unsigned char)pktin.data[st->i]));
     debug(("\r\n"));
 #endif
 
     /*
      * Check the MAC.
      */
-    if (scmac && !scmac->verify(pktin.data, len+4, incoming_sequence)) {
+    if (scmac && !scmac->verify(pktin.data, st->len+4, st->incoming_sequence)) {
 	bombout(("Incorrect MAC received on packet"));
         crReturn(0);
     }
-    incoming_sequence++;               /* whether or not we MACed */
+    st->incoming_sequence++;               /* whether or not we MACed */
 
     pktin.savedpos = 6;
     pktin.type = pktin.data[5];
@@ -593,6 +599,12 @@ static void s_wrpkt(void) {
     PUT_32BIT(pktout.data+biglen, crc);
     PUT_32BIT(pktout.data, len);
 
+#if 0
+    debug(("Sending packet len=%d\r\n", biglen+4));
+    for (i = 0; i < biglen+4; i++)
+        debug(("  %02x", (unsigned char)pktout.data[i]));
+    debug(("\r\n"));
+#endif
     if (cipher)
 	cipher->encrypt(pktout.data+4, biglen);
 
@@ -807,7 +819,7 @@ static int ssh_versioncmp(char *a, char *b) {
  * state.
  */
 #include <stdio.h>
-void sha_string(SHA_State *s, void *str, int len) {
+static void sha_string(SHA_State *s, void *str, int len) {
     unsigned char lenblk[4];
     PUT_32BIT(lenblk, len);
     SHA_Bytes(s, lenblk, 4);
@@ -817,7 +829,7 @@ void sha_string(SHA_State *s, void *str, int len) {
 /*
  * SSH2 packet construction functions.
  */
-void ssh2_pkt_adddata(void *data, int len) {
+static void ssh2_pkt_adddata(void *data, int len) {
     pktout.length += len;
     if (pktout.maxlen < pktout.length) {
         pktout.maxlen = pktout.length + 256;
@@ -828,40 +840,40 @@ void ssh2_pkt_adddata(void *data, int len) {
     }
     memcpy(pktout.data+pktout.length-len, data, len);
 }
-void ssh2_pkt_addbyte(unsigned char byte) {
+static void ssh2_pkt_addbyte(unsigned char byte) {
     ssh2_pkt_adddata(&byte, 1);
 }
-void ssh2_pkt_init(int pkt_type) {
+static void ssh2_pkt_init(int pkt_type) {
     pktout.length = 5;
     ssh2_pkt_addbyte((unsigned char)pkt_type);
 }
-void ssh2_pkt_addbool(unsigned char value) {
+static void ssh2_pkt_addbool(unsigned char value) {
     ssh2_pkt_adddata(&value, 1);
 }
-void ssh2_pkt_adduint32(unsigned long value) {
+static void ssh2_pkt_adduint32(unsigned long value) {
     unsigned char x[4];
     PUT_32BIT(x, value);
     ssh2_pkt_adddata(x, 4);
 }
-void ssh2_pkt_addstring_start(void) {
+static void ssh2_pkt_addstring_start(void) {
     ssh2_pkt_adduint32(0);
     pktout.savedpos = pktout.length;
 }
-void ssh2_pkt_addstring_str(char *data) {
+static void ssh2_pkt_addstring_str(char *data) {
     ssh2_pkt_adddata(data, strlen(data));
     PUT_32BIT(pktout.data + pktout.savedpos - 4,
               pktout.length - pktout.savedpos);
 }
-void ssh2_pkt_addstring_data(char *data, int len) {
+static void ssh2_pkt_addstring_data(char *data, int len) {
     ssh2_pkt_adddata(data, len);
     PUT_32BIT(pktout.data + pktout.savedpos - 4,
               pktout.length - pktout.savedpos);
 }
-void ssh2_pkt_addstring(char *data) {
+static void ssh2_pkt_addstring(char *data) {
     ssh2_pkt_addstring_start();
     ssh2_pkt_addstring_str(data);
 }
-char *ssh2_mpint_fmt(Bignum b, int *len) {
+static char *ssh2_mpint_fmt(Bignum b, int *len) {
     unsigned char *p;
     int i, n = b[0];
     p = malloc(n * 2 + 1);
@@ -879,7 +891,7 @@ char *ssh2_mpint_fmt(Bignum b, int *len) {
     *len = n*2+1-i;
     return p;
 }
-void ssh2_pkt_addmp(Bignum b) {
+static void ssh2_pkt_addmp(Bignum b) {
     unsigned char *p;
     int len;
     p = ssh2_mpint_fmt(b, &len);
@@ -887,7 +899,7 @@ void ssh2_pkt_addmp(Bignum b) {
     ssh2_pkt_addstring_data(p, len);
     free(p);
 }
-void ssh2_pkt_send(void) {
+static void ssh2_pkt_send(void) {
     int cipherblk, maclen, padding, i;
     static unsigned long outgoing_sequence = 0;
 
@@ -935,7 +947,7 @@ void bndebug(char *string, Bignum b) {
 }
 #endif
 
-void sha_mpint(SHA_State *s, Bignum b) {
+static void sha_mpint(SHA_State *s, Bignum b) {
     unsigned char *p;
     int len;
     p = ssh2_mpint_fmt(b, &len);
@@ -946,7 +958,7 @@ void sha_mpint(SHA_State *s, Bignum b) {
 /*
  * SSH2 packet decode functions.
  */
-unsigned long ssh2_pkt_getuint32(void) {
+static unsigned long ssh2_pkt_getuint32(void) {
     unsigned long value;
     if (pktin.length - pktin.savedpos < 4)
         return 0;                      /* arrgh, no way to decline (FIXME?) */
@@ -954,7 +966,7 @@ unsigned long ssh2_pkt_getuint32(void) {
     pktin.savedpos += 4;
     return value;
 }
-void ssh2_pkt_getstring(char **p, int *length) {
+static void ssh2_pkt_getstring(char **p, int *length) {
     *p = NULL;
     if (pktin.length - pktin.savedpos < 4)
         return;
@@ -965,7 +977,7 @@ void ssh2_pkt_getstring(char **p, int *length) {
     *p = pktin.data+pktin.savedpos;
     pktin.savedpos += *length;
 }
-Bignum ssh2_pkt_getmp(void) {
+static Bignum ssh2_pkt_getmp(void) {
     char *p;
     int i, j, length;
     Bignum b;
@@ -1028,6 +1040,8 @@ static int do_ssh_init(void) {
 	    break;
     }
 
+    rdpkt2_state.incoming_sequence = 0;
+
     *vsp = 0;
     sprintf(vlog, "Server version: %s", vstring);
     vlog[strcspn(vlog, "\r\n")] = '\0';
@@ -1511,7 +1525,7 @@ static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
             static unsigned char buffer[32];
 
             tried_publickey = 1;
-            i = loadrsakey(cfg.keyfile, &pubkey, password);
+            i = loadrsakey(cfg.keyfile, &pubkey, NULL, password);
             if (i == 0) {
                 c_write("Couldn't load public key from ", 30);
                 c_write(cfg.keyfile, strlen(cfg.keyfile));
@@ -1654,7 +1668,8 @@ static void ssh1_protocol(unsigned char *in, int inlen, int ispkt) {
 	    if (pktin.type == SSH1_SMSG_STDOUT_DATA ||
                 pktin.type == SSH1_SMSG_STDERR_DATA) {
 		long len = GET_32BIT(pktin.body);
-		c_writedata(pktin.body+4, len);
+		from_backend(pktin.type == SSH1_SMSG_STDERR_DATA,
+			     pktin.body+4, len);
 	    } else if (pktin.type == SSH1_MSG_DISCONNECT) {
                 ssh_state = SSH_STATE_CLOSED;
 		logevent("Received disconnect request");
@@ -1771,7 +1786,7 @@ static void ssh1_protocol(unsigned char *in, int inlen, int ispkt) {
 /*
  * Utility routine for decoding comma-separated strings in KEXINIT.
  */
-int in_commasep_string(char *needle, char *haystack, int haylen) {
+static int in_commasep_string(char *needle, char *haystack, int haylen) {
     int needlen = strlen(needle);
     while (1) {
         /*
@@ -1798,7 +1813,7 @@ int in_commasep_string(char *needle, char *haystack, int haylen) {
 /*
  * SSH2 key creation method.
  */
-void ssh2_mkkey(Bignum K, char *H, char chr, char *keyspace) {
+static void ssh2_mkkey(Bignum K, char *H, char chr, char *keyspace) {
     SHA_State s;
     /* First 20 bytes. */
     SHA_Init(&s);
@@ -1823,6 +1838,8 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
     static int i, len;
     static char *str;
     static Bignum e, f, K;
+    static const struct ssh_mac **maclist;
+    static int nmacs;
     static const struct ssh_cipher *cscipher_tobe = NULL;
     static const struct ssh_cipher *sccipher_tobe = NULL;
     static const struct ssh_mac *csmac_tobe = NULL;
@@ -1853,6 +1870,14 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
         preferred_cipher = &ssh_3des_ssh2;
     }
 
+    /*
+     * Be prepared to work around the buggy MAC problem.
+     */
+    if (cfg.buggymac)
+        maclist = buggymacs, nmacs = lenof(buggymacs);
+    else
+        maclist = macs, nmacs = lenof(macs);
+
     begin_key_exchange:
     /*
      * Construct and send our key exchange packet.
@@ -1892,16 +1917,16 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
     }
     /* List client->server MAC algorithms. */
     ssh2_pkt_addstring_start();
-    for (i = 0; i < lenof(macs); i++) {
-        ssh2_pkt_addstring_str(macs[i]->name);
-        if (i < lenof(macs)-1)
+    for (i = 0; i < nmacs; i++) {
+        ssh2_pkt_addstring_str(maclist[i]->name);
+        if (i < nmacs-1)
             ssh2_pkt_addstring_str(",");
     }
     /* List server->client MAC algorithms. */
     ssh2_pkt_addstring_start();
-    for (i = 0; i < lenof(macs); i++) {
-        ssh2_pkt_addstring_str(macs[i]->name);
-        if (i < lenof(macs)-1)
+    for (i = 0; i < nmacs; i++) {
+        ssh2_pkt_addstring_str(maclist[i]->name);
+        if (i < nmacs-1)
             ssh2_pkt_addstring_str(",");
     }
     /* List client->server compression algorithms. */
@@ -1974,16 +1999,16 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
         }
     }
     ssh2_pkt_getstring(&str, &len);    /* client->server mac */
-    for (i = 0; i < lenof(macs); i++) {
-        if (in_commasep_string(macs[i]->name, str, len)) {
-            csmac_tobe = macs[i];
+    for (i = 0; i < nmacs; i++) {
+        if (in_commasep_string(maclist[i]->name, str, len)) {
+            csmac_tobe = maclist[i];
             break;
         }
     }
     ssh2_pkt_getstring(&str, &len);    /* server->client mac */
-    for (i = 0; i < lenof(macs); i++) {
-        if (in_commasep_string(macs[i]->name, str, len)) {
-            scmac_tobe = macs[i];
+    for (i = 0; i < nmacs; i++) {
+        if (in_commasep_string(maclist[i]->name, str, len)) {
+            scmac_tobe = maclist[i];
             break;
         }
     }
@@ -2270,7 +2295,7 @@ static void do_ssh2_authconn(unsigned char *in, int inlen, int ispkt)
     ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
     ssh2_pkt_addstring("session");
     ssh2_pkt_adduint32(mainchan->localid);
-    ssh2_pkt_adduint32(0x7FFFFFFFUL);  /* our window size */
+    ssh2_pkt_adduint32(0x8000UL);  /* our window size */
     ssh2_pkt_adduint32(0x4000UL);  /* our max pkt size */
     ssh2_pkt_send();
     crWaitUntilV(ispkt);
@@ -2384,7 +2409,8 @@ static void do_ssh2_authconn(unsigned char *in, int inlen, int ispkt)
                     continue;          /* extended but not stderr */
                 ssh2_pkt_getstring(&data, &length);
                 if (data) {
-                    c_writedata(data, length);
+                    from_backend(pktin.type == SSH2_MSG_CHANNEL_EXTENDED_DATA,
+				 data, length);
                     /*
                      * Enlarge the window again at the remote side,
                      * just in case it ever runs down and they fail
@@ -2414,6 +2440,9 @@ static void do_ssh2_authconn(unsigned char *in, int inlen, int ispkt)
                     logevent("All channels closed. Disconnecting");
                     ssh2_pkt_init(SSH2_MSG_DISCONNECT);
                     ssh2_pkt_send();
+                    ssh_state = SSH_STATE_CLOSED;
+                    closesocket(s);
+                    s = INVALID_SOCKET;
                 }
                 continue;              /* remote sends close; ignore (FIXME) */
 	    } else if (pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
@@ -2606,6 +2635,14 @@ static void ssh_special (Telnet_Special code) {
             ssh2_pkt_send();
         }
         logevent("Sent EOF message");
+    } else if (code == TS_PING) {
+        if (ssh_version == 1) {
+            send_packet(SSH1_MSG_IGNORE, PKT_STR, "", PKT_END);
+        } else {
+            ssh2_pkt_init(SSH2_MSG_IGNORE);
+            ssh2_pkt_addstring_start();
+            ssh2_pkt_send();
+        }
     } else {
         /* do nothing */
     }
@@ -2622,5 +2659,6 @@ Backend ssh_backend = {
     ssh_size,
     ssh_special,
     ssh_socket,
-    ssh_sendok
+    ssh_sendok,
+    22
 };