code review 11921043: go.crypto/ssh: add workaround for broken port forwarding in

ssh/tcpip.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package ssh
 
 import (
         "errors"
         "fmt"
         "io"
+        "math/rand"
         "net"
+        "strconv"
+        "strings"
         "sync"
         "time"
 )
 
 // Listen requests the remote peer open a listening socket
 // on addr. Incoming connections will be available by calling
 // Accept on the returned net.Listener.
 func (c *ClientConn) Listen(n, addr string) (net.Listener, error) {
         laddr, err := net.ResolveTCPAddr(n, addr)
         if err != nil {
                 return nil, err
         }
         return c.ListenTCP(laddr)
 }
 
 // RFC 4254 7.1
 type channelForwardMsg struct {
         Message   string
         WantReply bool
         raddr     string
         rport     uint32
 }
 
+// Automatic port allocation is broken with OpenSSH before 6.0. See
+// also https://bugzilla.mindrot.org/show_bug.cgi?id=2017.  In
+// particular, OpenSSH 5.9 sends a channelOpenMsg with port number 0,
+// rather than the actual port number. This means you can never open
+// two different listeners with auto allocated ports. We work around
+// this by trying explicit ports until we succeed.
+
+const openSSHPrefix = "OpenSSH_"
+
+// isBrokenOpenSSHVersion returns true if the given version string
+// specifies a version of OpenSSH that is known to have a bug in port
+// forwarding.
+func isBrokenOpenSSHVersion(versionStr string) bool {
+        i := strings.Index(versionStr, openSSHPrefix)
+        if i < 0 {
+                return false
+        }
+        i += len(openSSHPrefix)
+        j := i
+        for ; j < len(versionStr); j++ {
+                if versionStr[j] < '0' || versionStr[j] > '9' {
+                        break
+                }
+        }
+        fmt.Printf("V %q", versionStr[i:j])

[agl1, 2013/07/26 18:38:06]

Looks like debugging - will remove before landing.

+        version, _ := strconv.Atoi(versionStr[i:j])
+        return version < 6
+}
+
+// autoPortListenWorkaround simulates automatic port allocation by
+// trying random ports repeatedly.
+func (c *ClientConn) autoPortListenWorkaround(laddr *net.TCPAddr) (net.Listener, error) {
+        var sshListener net.Listener
+        var err error
+        const tries = 10
+        for i := 0; i < tries; i++ {
+                addr := *laddr
+                addr.Port = 1024 + rand.Intn(60000)
+                sshListener, err = c.ListenTCP(&addr)
+                if err == nil {
+                        laddr.Port = addr.Port
+                        return sshListener, err
+                }
+        }
+        return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %v", tries, err)
+}
+
 // ListenTCP requests the remote peer open a listening socket
 // on laddr. Incoming connections will be available by calling
 // Accept on the returned net.Listener.
 func (c *ClientConn) ListenTCP(laddr *net.TCPAddr) (net.Listener, error) {
+        if laddr.Port == 0 && isBrokenOpenSSHVersion(c.serverVersion) {
+                return c.autoPortListenWorkaround(laddr)
+        }
+
         m := channelForwardMsg{
                 "tcpip-forward",
                 true, // sendGlobalRequest waits for a reply
                 laddr.IP.String(),
                 uint32(laddr.Port),
         }
         // send message
         resp, err := c.sendGlobalRequest(m)
         if err != nil {
                 return nil, err
         }
 
         // If the original port was 0, then the remote side will
         // supply a real port number in the response.
         if laddr.Port == 0 {
                 port, _, ok := parseUint32(resp.Data)
                 if !ok {
                         return nil, errors.New("unable to parse response")
                 }
                 laddr.Port = int(port)
         }
 
         // Register this forward, using the port number we obtained.
-        //
-        // This does not work on OpenSSH < 6.0, which will send a
-        // channelOpenMsg with port number 0, rather than the actual
-        // port number.
         ch := c.forwardList.add(*laddr)
 
         return &tcpListener{laddr, c, ch}, nil
 }
 
 // forwardList stores a mapping between remote
 // forward requests and the tcpListeners.
 type forwardList struct {
         sync.Mutex
         entries []forwardEntry
@@ skipping 215 matching lines @@
 // with Timeout() == true.
 func (t *tcpChanConn) SetReadDeadline(deadline time.Time) error {
         return errors.New("ssh: tcpChan: deadline not supported")
 }
 
 // SetWriteDeadline exists to satisfy the net.Conn interface
 // but is not implemented by this type.  It always returns an error.
 func (t *tcpChanConn) SetWriteDeadline(deadline time.Time) error {
         return errors.New("ssh: tcpChan: deadline not supported")
 }