Implement refreshing the whole dialogue box with dlg_refresh, so that
[u/mdw/putty] / ssh.c
diff --git a/ssh.c b/ssh.c
index 7538b55..ea4771c 100644 (file)
--- a/ssh.c
+++ b/ssh.c
@@ -436,6 +436,8 @@ struct ssh_channel {
     Ssh ssh;                          /* pointer back to main context */
     unsigned remoteid, localid;
     int type;
+    /* True if we opened this channel but server hasn't confirmed. */
+    int halfopen;
     /*
      * In SSH1, this value contains four bits:
      * 
@@ -533,6 +535,7 @@ struct ssh_portfwd {
 
 struct Packet {
     long length;
+    long forcepad; /* Force padding to at least this length */
     int type;
     unsigned long sequence;
     unsigned char *data;
@@ -549,9 +552,9 @@ struct Packet {
     struct logblank_t *blanks;
 };
 
-static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen,
+static void ssh1_protocol(Ssh ssh, void *vin, int inlen,
                          struct Packet *pktin);
-static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen,
+static void ssh2_protocol(Ssh ssh, void *vin, int inlen,
                          struct Packet *pktin);
 static void ssh1_protocol_setup(Ssh ssh);
 static void ssh2_protocol_setup(Ssh ssh);
@@ -567,7 +570,7 @@ static unsigned long ssh_pkt_getuint32(struct Packet *pkt);
 static int ssh2_pkt_getbool(struct Packet *pkt);
 static void ssh_pkt_getstring(struct Packet *pkt, char **p, int *length);
 static void ssh2_timer(void *ctx, long now);
-static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen,
+static int do_ssh2_transport(Ssh ssh, void *vin, int inlen,
                             struct Packet *pktin);
 
 struct rdpkt1_state_tag {
@@ -688,7 +691,7 @@ struct ssh_tag {
     int overall_bufsize;
     int throttled_all;
     int v1_stdout_throttling;
-    int v2_outgoing_sequence;
+    unsigned long v2_outgoing_sequence;
 
     int ssh1_rdpkt_crstate;
     int ssh2_rdpkt_crstate;
@@ -710,7 +713,7 @@ struct ssh_tag {
     /* ssh1 and ssh2 use this for different things, but both use it */
     int protocol_initial_phase_done;
 
-    void (*protocol) (Ssh ssh, unsigned char *in, int inlen,
+    void (*protocol) (Ssh ssh, void *vin, int inlen,
                      struct Packet *pkt);
     struct Packet *(*s_rdpkt) (Ssh ssh, unsigned char **data, int *datalen);
 
@@ -1572,6 +1575,7 @@ static struct Packet *ssh2_pkt_init(int pkt_type)
 {
     struct Packet *pkt = ssh_new_packet();
     pkt->length = 5;
+    pkt->forcepad = 0;
     ssh2_pkt_addbyte(pkt, (unsigned char) pkt_type);
     return pkt;
 }
@@ -1668,12 +1672,17 @@ static int ssh2_pkt_construct(Ssh ssh, struct Packet *pkt)
     /*
      * Add padding. At least four bytes, and must also bring total
      * length (minus MAC) up to a multiple of the block size.
+     * If pkt->forcepad is set, make sure the packet is at least that size
+     * after padding.
      */
     cipherblk = ssh->cscipher ? ssh->cscipher->blksize : 8;  /* block size */
     cipherblk = cipherblk < 8 ? 8 : cipherblk; /* or 8 if blksize < 8 */
     padding = 4;
+    if (pkt->length + padding < pkt->forcepad)
+       padding = pkt->forcepad - pkt->length;
     padding +=
        (cipherblk - (pkt->length + padding) % cipherblk) % cipherblk;
+    assert(padding <= 255);
     maclen = ssh->csmac ? ssh->csmac->len : 0;
     ssh2_pkt_ensure(pkt, pkt->length + padding + maclen);
     pkt->data[4] = padding;
@@ -1791,6 +1800,7 @@ static void ssh2_pkt_send(Ssh ssh, struct Packet *pkt)
        ssh2_pkt_send_noqueue(ssh, pkt);
 }
 
+#if 0 /* disused */
 /*
  * Either queue or defer a packet, depending on whether queueing is
  * set.
@@ -1802,6 +1812,7 @@ static void ssh2_pkt_defer(Ssh ssh, struct Packet *pkt)
     else
        ssh2_pkt_defer_noqueue(ssh, pkt);
 }
+#endif
 
 /*
  * Send the whole deferred data block constructed by
@@ -3556,13 +3567,13 @@ void sshfwd_close(struct ssh_channel *c)
 
     if (c && !c->closes) {
        /*
-        * If the channel's remoteid is -1, we have sent
+        * If halfopen is true, we have sent
         * CHANNEL_OPEN for this channel, but it hasn't even been
         * acknowledged by the server. So we must set a close flag
         * on it now, and then when the server acks the channel
         * open, we can close it then.
         */
-       if (((int)c->remoteid) != -1) {
+       if (!c->halfopen) {
            if (ssh->version == 1) {
                send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE, PKT_INT, c->remoteid,
                            PKT_END);
@@ -4084,6 +4095,7 @@ static void ssh1_smsg_x11_open(Ssh ssh, struct Packet *pktin)
            logevent
                ("Opening X11 forward connection succeeded");
            c->remoteid = remoteid;
+           c->halfopen = FALSE;
            c->localid = alloc_channel_id(ssh);
            c->closes = 0;
            c->v.v1.throttling = 0;
@@ -4112,6 +4124,7 @@ static void ssh1_smsg_agent_open(Ssh ssh, struct Packet *pktin)
        c = snew(struct ssh_channel);
        c->ssh = ssh;
        c->remoteid = remoteid;
+       c->halfopen = FALSE;
        c->localid = alloc_channel_id(ssh);
        c->closes = 0;
        c->v.v1.throttling = 0;
@@ -4169,6 +4182,7 @@ static void ssh1_msg_port_open(Ssh ssh, struct Packet *pktin)
                        PKT_INT, remoteid, PKT_END);
        } else {
            c->remoteid = remoteid;
+           c->halfopen = FALSE;
            c->localid = alloc_channel_id(ssh);
            c->closes = 0;
            c->v.v1.throttling = 0;
@@ -4191,6 +4205,7 @@ static void ssh1_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin)
     c = find234(ssh->channels, &remoteid, ssh_channelfind);
     if (c && c->type == CHAN_SOCKDATA_DORMANT) {
        c->remoteid = localid;
+       c->halfopen = FALSE;
        c->type = CHAN_SOCKDATA;
        c->v.v1.throttling = 0;
        pfd_confirm(c->u.pfd.s);
@@ -4228,7 +4243,7 @@ static void ssh1_msg_channel_close(Ssh ssh, struct Packet *pktin)
     unsigned i = ssh_pkt_getuint32(pktin);
     struct ssh_channel *c;
     c = find234(ssh->channels, &i, ssh_channelfind);
-    if (c && ((int)c->remoteid) != -1) {
+    if (c && !c->halfopen) {
        int closetype;
        closetype =
            (pktin->type == SSH1_MSG_CHANNEL_CLOSE ? 1 : 2);
@@ -4270,7 +4285,7 @@ static void ssh1_msg_channel_data(Ssh ssh, struct Packet *pktin)
     /* Data sent down one of our channels. */
     int i = ssh_pkt_getuint32(pktin);
     char *p;
-    unsigned int len;
+    int len;
     struct ssh_channel *c;
 
     ssh_pkt_getstring(pktin, &p, &len);
@@ -4567,7 +4582,7 @@ static void ssh1_msg_disconnect(Ssh ssh, struct Packet *pktin)
     bombout(("Server sent disconnect message:\n\"%.*s\"", msglen, msg));
 }
 
-void ssh_msg_ignore(Ssh ssh, struct Packet *pktin)
+static void ssh_msg_ignore(Ssh ssh, struct Packet *pktin)
 {
     /* Do nothing, because we're ignoring it! Duhh. */
 }
@@ -4590,9 +4605,10 @@ static void ssh1_protocol_setup(Ssh ssh)
     ssh->packet_dispatch[SSH1_MSG_DEBUG] = ssh1_msg_debug;
 }
 
-static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen,
+static void ssh1_protocol(Ssh ssh, void *vin, int inlen,
                          struct Packet *pktin)
 {
+    unsigned char *in=(unsigned char*)vin;
     if (ssh->state == SSH_STATE_CLOSED)
        return;
 
@@ -4643,6 +4659,28 @@ static int in_commasep_string(char *needle, char *haystack, int haylen)
 }
 
 /*
+ * Similar routine for checking whether we have the first string in a list.
+ */
+static int first_in_commasep_string(char *needle, char *haystack, int haylen)
+{
+    int needlen;
+    if (!needle || !haystack)         /* protect against null pointers */
+       return 0;
+    needlen = strlen(needle);
+    /*
+     * Is it at the start of the string?
+     */
+    if (haylen >= needlen &&       /* haystack is long enough */
+       !memcmp(needle, haystack, needlen) &&   /* initial match */
+       (haylen == needlen || haystack[needlen] == ',')
+       /* either , or EOS follows */
+       )
+       return 1;
+    return 0;
+}
+
+
+/*
  * SSH2 key creation method.
  */
 static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H,
@@ -4670,9 +4708,10 @@ static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H,
 /*
  * Handle the SSH2 transport layer.
  */
-static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen,
+static int do_ssh2_transport(Ssh ssh, void *vin, int inlen,
                             struct Packet *pktin)
 {
+    unsigned char *in = (unsigned char *)vin;
     struct do_ssh2_transport_state {
        int nbits, pbits, warn;
        Bignum p, g, e, f, K;
@@ -4909,7 +4948,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen,
      */
     {
        char *str;
-       int i, j, len;
+       int i, j, len, guessok;
 
        if (pktin->type != SSH2_MSG_KEXINIT) {
            bombout(("expected key exchange packet from server"));
@@ -4948,6 +4987,13 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen,
                     str ? str : "(null)"));
            crStop(0);
        }
+       /*
+        * Note that the server's guess is considered wrong if it doesn't match
+        * the first algorithm in our list, even if it's still the algorithm
+        * we end up using.
+        */
+       guessok =
+           first_in_commasep_string(s->preferred_kex[0]->name, str, len);
        ssh_pkt_getstring(pktin, &str, &len);    /* host key algorithms */
        for (i = 0; i < lenof(hostkey_algs); i++) {
            if (in_commasep_string(hostkey_algs[i]->name, str, len)) {
@@ -4955,6 +5001,8 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen,
                break;
            }
        }
+       guessok = guessok &&
+           first_in_commasep_string(hostkey_algs[0]->name, str, len);
        ssh_pkt_getstring(pktin, &str, &len);    /* client->server cipher */
        s->warn = 0;
        for (i = 0; i < s->n_preferred_ciphers; i++) {
@@ -5047,6 +5095,10 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen,
                break;
            }
        }
+       ssh_pkt_getstring(pktin, &str, &len);  /* client->server language */
+       ssh_pkt_getstring(pktin, &str, &len);  /* server->client language */
+       if (ssh2_pkt_getbool(pktin) && !guessok) /* first_kex_packet_follows */
+           crWaitUntil(pktin);                /* Ignore packet */
     }
 
     /*
@@ -5469,7 +5521,7 @@ static void ssh2_msg_channel_window_adjust(Ssh ssh, struct Packet *pktin)
 static void ssh2_msg_channel_data(Ssh ssh, struct Packet *pktin)
 {
     char *data;
-    unsigned int length;
+    int length;
     unsigned i = ssh_pkt_getuint32(pktin);
     struct ssh_channel *c;
     c = find234(ssh->channels, &i, ssh_channelfind);
@@ -5577,7 +5629,7 @@ static void ssh2_msg_channel_close(Ssh ssh, struct Packet *pktin)
     struct Packet *pktout;
 
     c = find234(ssh->channels, &i, ssh_channelfind);
-    if (!c || ((int)c->remoteid) == -1) {
+    if (!c || c->halfopen) {
        bombout(("Received CHANNEL_CLOSE for %s channel %d\n",
                 c ? "half-open" : "nonexistent", i));
        return;
@@ -5653,6 +5705,7 @@ static void ssh2_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin)
     if (c->type != CHAN_SOCKDATA_DORMANT)
        return;                        /* dunno why they're confirming this */
     c->remoteid = ssh_pkt_getuint32(pktin);
+    c->halfopen = FALSE;
     c->type = CHAN_SOCKDATA;
     c->v.v2.remwindow = ssh_pkt_getuint32(pktin);
     c->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
@@ -5788,7 +5841,7 @@ static void ssh2_msg_channel_request(Ssh ssh, struct Packet *pktin)
        if (q >= 0 && q+4 <= len) { \
            q = q + 4 + GET_32BIT(p+q); \
            if (q >= 0 && q+4 <= len && \
-                   (q = q + 4 + GET_32BIT(p+q)) && q == len) \
+                   ((q = q + 4 + GET_32BIT(p+q))!= 0) && q == len) \
                result = TRUE; \
        } \
     } while(0)
@@ -5960,6 +6013,7 @@ static void ssh2_msg_channel_open(Ssh ssh, struct Packet *pktin)
     }
 
     c->remoteid = remid;
+    c->halfopen = FALSE;
     if (error) {
        pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_FAILURE);
        ssh2_pkt_adduint32(pktout, c->remoteid);
@@ -6756,20 +6810,16 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
                }
            } else if (s->method == AUTH_PASSWORD) {
                /*
-                * We send the password packet lumped tightly together with
-                * an SSH_MSG_IGNORE packet. The IGNORE packet contains a
-                * string long enough to make the total length of the two
-                * packets constant. This should ensure that a passive
-                * listener doing traffic analyis can't work out the length
-                * of the password.
+                * We pad out the password packet to 256 bytes to make
+                * it harder for an attacker to find the length of the
+                * user's password.
                 *
-                * For this to work, we need an assumption about the
-                * maximum length of the password packet. I think 256 is
-                * pretty conservative. Anyone using a password longer than
-                * that probably doesn't have much to worry about from
+                * Anyone using a password longer than 256 bytes
+                * probably doesn't have much to worry about from
                 * people who find out how long their password is!
                 */
                s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
+               s->pktout->forcepad = 256;
                ssh2_pkt_addstring(s->pktout, s->username);
                ssh2_pkt_addstring(s->pktout, "ssh-connection");        /* service requested */
                ssh2_pkt_addstring(s->pktout, "password");
@@ -6778,46 +6828,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
                ssh2_pkt_addstring(s->pktout, s->password);
                memset(s->password, 0, sizeof(s->password));
                end_log_omission(ssh, s->pktout);
-               ssh2_pkt_defer(ssh, s->pktout);
-               /*
-                * We'll include a string that's an exact multiple of the
-                * cipher block size. If the cipher is NULL for some
-                * reason, we don't do this trick at all because we gain
-                * nothing by it.
-                */
-               if (ssh->cscipher) {
-                   int stringlen, i;
-
-                   stringlen = (256 - ssh->deferred_len);
-                   stringlen += ssh->cscipher->blksize - 1;
-                   stringlen -= (stringlen % ssh->cscipher->blksize);
-                   if (ssh->cscomp) {
-                       /*
-                        * Temporarily disable actual compression,
-                        * so we can guarantee to get this string
-                        * exactly the length we want it. The
-                        * compression-disabling routine should
-                        * return an integer indicating how many
-                        * bytes we should adjust our string length
-                        * by.
-                        */
-                       stringlen -= 
-                           ssh->cscomp->disable_compression(ssh->cs_comp_ctx);
-                   }
-                   s->pktout = ssh2_pkt_init(SSH2_MSG_IGNORE);
-                   ssh2_pkt_addstring_start(s->pktout);
-                   for (i = 0; i < stringlen; i++) {
-                       char c = (char) random_byte();
-                       ssh2_pkt_addstring_data(s->pktout, &c, 1);
-                   }
-                   ssh2_pkt_defer(ssh, s->pktout);
-               }
-               ssh_pkt_defersend(ssh);
+               ssh2_pkt_send(ssh, s->pktout);
                logevent("Sent password");
                s->type = AUTH_TYPE_PASSWORD;
            } else if (s->method == AUTH_KEYBOARD_INTERACTIVE) {
                if (s->curr_prompt == 0) {
                    s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_INFO_RESPONSE);
+                   s->pktout->forcepad = 256;
                    ssh2_pkt_adduint32(s->pktout, s->num_prompts);
                }
                if (s->need_pw) {      /* only add pw if we just got one! */
@@ -6901,6 +6918,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
            crStopV;
        }
        ssh->mainchan->remoteid = ssh_pkt_getuint32(pktin);
+       ssh->mainchan->halfopen = FALSE;
        ssh->mainchan->type = CHAN_MAINSESSION;
        ssh->mainchan->closes = 0;
        ssh->mainchan->v.v2.remwindow = ssh_pkt_getuint32(pktin);
@@ -7238,7 +7256,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
 /*
  * Handlers for SSH2 messages that might arrive at any moment.
  */
-void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin)
+static void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin)
 {
     /* log reason code in disconnect message */
     char *buf, *msg;
@@ -7267,7 +7285,7 @@ void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin)
     sfree(buf);
 }
 
-void ssh2_msg_debug(Ssh ssh, struct Packet *pktin)
+static void ssh2_msg_debug(Ssh ssh, struct Packet *pktin)
 {
     /* log the debug message */
     char *buf, *msg;
@@ -7283,7 +7301,7 @@ void ssh2_msg_debug(Ssh ssh, struct Packet *pktin)
     sfree(buf);
 }
 
-void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin)
+static void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin)
 {
     struct Packet *pktout;
     pktout = ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED);
@@ -7364,9 +7382,10 @@ static void ssh2_timer(void *ctx, long now)
     }
 }
 
-static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen,
+static void ssh2_protocol(Ssh ssh, void *vin, int inlen,
                          struct Packet *pktin)
 {
+    unsigned char *in = (unsigned char *)vin;
     if (ssh->state == SSH_STATE_CLOSED)
        return;
 
@@ -7911,7 +7930,7 @@ void *new_sock_channel(void *handle, Socket s)
     c->ssh = ssh;
 
     if (c) {
-       c->remoteid = -1;              /* to be set when open confirmed */
+       c->halfopen = TRUE;
        c->localid = alloc_channel_id(ssh);
        c->closes = 0;
        c->type = CHAN_SOCKDATA_DORMANT;/* identify channel type */