Make our SSH2 maximum packet size into a constant, since it's used in several
[u/mdw/putty] / ssh.c
diff --git a/ssh.c b/ssh.c
index 3ca48c5..cf957b4 100644 (file)
--- a/ssh.c
+++ b/ssh.c
@@ -163,7 +163,7 @@ static const char *const ssh2_disconnect_reasons[] = {
 #define BUG_CHOKES_ON_RSA                        8
 #define BUG_SSH2_RSA_PADDING                    16
 #define BUG_SSH2_DERIVEKEY                       32
-/* 64 was BUG_SSH2_DH_GEX, now spare */
+#define BUG_SSH2_REKEY                           64
 #define BUG_SSH2_PK_SESSIONID                   128
 
 #define translate(x) if (type == x) return #x
@@ -360,6 +360,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
 #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 };
 
@@ -561,7 +562,7 @@ 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);
@@ -642,6 +643,7 @@ struct ssh_tag {
     tree234 *channels;                /* indexed by local id */
     struct ssh_channel *mainchan;      /* primary session channel */
     int exitcode;
+    int close_expected;
 
     tree234 *rportfwds, *portfwds;
 
@@ -772,7 +774,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); \
@@ -1739,8 +1741,7 @@ static void ssh2_pkt_send_noqueue(Ssh ssh, struct Packet *pkt)
     if (!ssh->kex_in_progress &&
        ssh->max_data_size != 0 &&
        ssh->outgoing_data_size > ssh->max_data_size)
-       do_ssh2_transport(ssh, "Initiating key re-exchange "
-                         "(too much data sent)", -1, NULL);
+       do_ssh2_transport(ssh, "too much data sent", -1, NULL);
 
     ssh_free_packet(pkt);
 }
@@ -1830,8 +1831,7 @@ static void ssh_pkt_defersend(Ssh ssh)
     if (!ssh->kex_in_progress &&
        ssh->max_data_size != 0 &&
        ssh->outgoing_data_size > ssh->max_data_size)
-       do_ssh2_transport(ssh, "Initiating key re-exchange "
-                         "(too much data sent)", -1, NULL);
+       do_ssh2_transport(ssh, "too much data sent", -1, NULL);
     ssh->deferred_data_size = 0;
 }
 
@@ -2138,6 +2138,19 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring)
        ssh->remote_bugs |= BUG_SSH2_PK_SESSIONID;
        logevent("We believe remote version has SSH2 public-key-session-ID bug");
     }
+
+    if (ssh->cfg.sshbug_rekey2 == FORCE_ON ||
+       (ssh->cfg.sshbug_rekey2 == AUTO &&
+        (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)))) {
+       /*
+        * These versions have the SSH2 rekey bug.
+        */
+       ssh->remote_bugs |= BUG_SSH2_REKEY;
+       logevent("We believe remote version has SSH2 rekey bug");
+    }
 }
 
 /*
@@ -2357,16 +2370,19 @@ static void ssh_gotdata(Ssh ssh, unsigned char *data, int datalen)
     crFinishV;
 }
 
-static void ssh_do_close(Ssh ssh)
+static int ssh_do_close(Ssh ssh, int notify_exit)
 {
-    int i;
+    int i, ret = 0;
     struct ssh_channel *c;
 
     ssh->state = SSH_STATE_CLOSED;
     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
@@ -2388,20 +2404,29 @@ static void ssh_do_close(Ssh ssh)
            sfree(c);
        }
     }
+
+    return ret;
 }
 
 static int ssh_closing(Plug plug, const char *error_msg, int error_code,
                       int calling_back)
 {
     Ssh ssh = (Ssh) plug;
-    ssh_do_close(ssh);
+    int need_notify = ssh_do_close(ssh, FALSE);
+
+    if (!error_msg && !ssh->close_expected) {
+        error_msg = "Server unexpectedly closed network connection";
+    }
+
     if (error_msg) {
        /* A socket error has occurred. */
        logevent(error_msg);
        connection_fatal(ssh->frontend, "%s", error_msg);
     } else {
-       /* Otherwise, the remote side closed the connection normally. */
+        logevent("Server closed network connection");
     }
+    if (need_notify)
+        notify_remote_exit(ssh->frontend);
     return 0;
 }
 
@@ -2410,7 +2435,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;
@@ -2911,6 +2936,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen,
                     * Terminate.
                     */
                    logevent("No username provided. Abandoning session.");
+                   ssh->close_expected = TRUE;
                     ssh_closing((Plug)ssh, NULL, 0, 0);
                    crStop(1);
                }
@@ -3259,6 +3285,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen,
                            PKT_END);
                logevent("Unable to authenticate");
                connection_fatal(ssh->frontend, "Unable to authenticate");
+               ssh->close_expected = TRUE;
                 ssh_closing((Plug)ssh, NULL, 0, 0);
                crStop(1);
            }
@@ -4311,6 +4338,7 @@ static void ssh1_smsg_exit_status(Ssh ssh, struct Packet *pktin)
      * encrypted packet, we close the session once
      * we've sent EXIT_CONFIRMATION.
      */
+    ssh->close_expected = TRUE;
     ssh_closing((Plug)ssh, NULL, 0, 0);
 }
 
@@ -5307,12 +5335,34 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen,
      */
     while (!((pktin && pktin->type == SSH2_MSG_KEXINIT) ||
             (!pktin && inlen == -1))) {
+        wait_for_rekey:
        crReturn(1);
     }
     if (pktin) {
        logevent("Server initiated key re-exchange");
     } else {
-       logevent((char *)in);
+        /*
+         * Special case: if the server bug is set that doesn't
+         * allow rekeying, we give a different log message and
+         * continue waiting. (If such a server _initiates_ a rekey,
+         * we process it anyway!)
+         */
+        if ((ssh->remote_bugs & BUG_SSH2_REKEY)) {
+            logeventf(ssh, "Server bug prevents key re-exchange (%s)",
+                      (char *)in);
+            /* Reset the counters, so that at least this message doesn't
+             * hit the event log _too_ often. */
+            ssh->outgoing_data_size = 0;
+            ssh->incoming_data_size = 0;
+            if (ssh->cfg.ssh_rekey_time != 0) {
+                ssh->next_rekey =
+                    schedule_timer(ssh->cfg.ssh_rekey_time*60*TICKSPERSEC,
+                                   ssh2_timer, ssh);
+            }
+            goto wait_for_rekey;       /* this is utterly horrid */
+        } else {
+            logeventf(ssh, "Initiating key re-exchange (%s)", (char *)in);
+        }
     }
     goto begin_key_exchange;
 
@@ -5567,6 +5617,7 @@ static void ssh2_msg_channel_close(Ssh ssh, struct Packet *pktin)
        ssh2_pkt_addstring(s->pktout, "en");    /* language tag */
        ssh2_pkt_send_noqueue(ssh, s->pktout);
 #endif
+       ssh->close_expected = TRUE;
        ssh_closing((Plug)ssh, NULL, 0, 0);
     }
 }
@@ -5667,6 +5718,7 @@ static void ssh2_msg_channel_request(Ssh ssh, struct Packet *pktin)
        ssh2_pkt_addstring(pktout, "en");       /* language tag */
        ssh2_pkt_send_noqueue(ssh, pktout);
        connection_fatal(ssh->frontend, "%s", buf);
+       ssh->close_expected = TRUE;
        ssh_closing((Plug)ssh, NULL, 0, 0);
        return;
     }
@@ -5910,7 +5962,7 @@ 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);
     }
 }
@@ -6020,6 +6072,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
                     * Terminate.
                     */
                    logevent("No username provided. Abandoning session.");
+                   ssh->close_expected = TRUE;
                     ssh_closing((Plug)ssh, NULL, 0, 0);
                    crStopV;
                }
@@ -6581,6 +6634,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
                        logevent("Unable to authenticate");
                        connection_fatal(ssh->frontend,
                                         "Unable to authenticate");
+                       ssh->close_expected = TRUE;
                         ssh_closing((Plug)ssh, NULL, 0, 0);
                        crStopV;
                    }
@@ -6779,6 +6833,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
                                   " methods available");
                ssh2_pkt_addstring(s->pktout, "en");    /* language tag */
                ssh2_pkt_send_noqueue(ssh, s->pktout);
+               ssh->close_expected = TRUE;
                 ssh_closing((Plug)ssh, NULL, 0, 0);
                crStopV;
            }
@@ -6814,7 +6869,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) {
@@ -7286,8 +7341,7 @@ static void ssh2_timer(void *ctx, long now)
 
     if (!ssh->kex_in_progress && ssh->cfg.ssh_rekey_time != 0 &&
        now - ssh->next_rekey >= 0) {
-       do_ssh2_transport(ssh, "Initiating key re-exchange (timeout)",
-                         -1, NULL);
+       do_ssh2_transport(ssh, "timeout", -1, NULL);
     }
 }
 
@@ -7302,8 +7356,7 @@ static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen,
        if (!ssh->kex_in_progress &&
            ssh->max_data_size != 0 &&
            ssh->incoming_data_size > ssh->max_data_size)
-           do_ssh2_transport(ssh, "Initiating key re-exchange "
-                             "(too much data received)", -1, NULL);
+           do_ssh2_transport(ssh, "too much data received", -1, NULL);
     }
 
     if (pktin && ssh->packet_dispatch[pktin->type]) {
@@ -7362,6 +7415,7 @@ 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->state = SSH_STATE_PREPACKET;
     ssh->size_needed = FALSE;
     ssh->eof_needed = FALSE;
@@ -7517,7 +7571,7 @@ static void ssh_free(void *handle)
        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);
@@ -7544,7 +7598,7 @@ static void ssh_reconfig(void *handle, Config *cfg)
        long now = GETTICKCOUNT();
 
        if (new_next - now < 0) {
-           rekeying = "Initiating key re-exchange (timeout shortened)";
+           rekeying = "timeout shortened";
        } else {
            ssh->next_rekey = schedule_timer(new_next - now, ssh2_timer, ssh);
        }
@@ -7556,18 +7610,18 @@ static void ssh_reconfig(void *handle, Config *cfg)
        ssh->max_data_size != 0) {
        if (ssh->outgoing_data_size > ssh->max_data_size ||
            ssh->incoming_data_size > ssh->max_data_size)
-           rekeying = "Initiating key re-exchange (data limit lowered)";
+           rekeying = "data limit lowered";
     }
 
     if (ssh->cfg.compression != cfg->compression) {
-       rekeying = "Initiating key re-exchange (compression setting changed)";
+       rekeying = "compression setting changed";
        rekey_mandatory = TRUE;
     }
 
     if (ssh->cfg.ssh2_des_cbc != cfg->ssh2_des_cbc ||
        memcmp(ssh->cfg.ssh_cipherlist, cfg->ssh_cipherlist,
               sizeof(ssh->cfg.ssh_cipherlist))) {
-       rekeying = "Initiating key re-exchange (cipher settings changed)";
+       rekeying = "cipher settings changed";
        rekey_mandatory = TRUE;
     }
 
@@ -7780,8 +7834,7 @@ static void ssh_special(void *handle, Telnet_Special code)
        }
     } else if (code == TS_REKEY) {
        if (!ssh->kex_in_progress && ssh->version == 2) {
-           do_ssh2_transport(ssh, "Initiating key re-exchange at"
-                             " user request", -1, NULL);
+           do_ssh2_transport(ssh, "at user request", -1, NULL);
        }
     } else if (code == TS_BRK) {
        if (ssh->state == SSH_STATE_CLOSED
@@ -7889,7 +7942,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);
        /*