航天飞机如何避免TCP对TCP的诅咒？

Question

穿梭索赔案表示它解决了大量的讨论问题 of TCP超过TCP熔毁。

S梭子在本地组装TCP流，在ssh会话上有状态地多路复用它，并在另一端将其反汇编为数据包。所以它永远不会做TCP上的TCP。它只是TCP上的数据，这是安全的。

但是从程序的角度来看，它维护着与目标服务器的TCP连接(读取指数超时)，这与其他TCP会话是分层的，因为SSH还不只是在udp上工作。这看起来很像TCP之上的TCP。

这里的诀窍是什么？这个问题真的被航天飞机解决了吗？

我试着读了源代码，但到目前为止还没有找到答案。

更重要的是，他们究竟是如何做到的？如果一个人想要在最基本的地方重新实现它，你应该在哪里寻找灵感？

Answer 1

sshuttle客户端设置防火墙规则( Linux中的iptables，这就是为什么sshuttle客户端需要根权限)来将某些传出的TCP连接重定向到本地端口(默认为12300)，在启动sshuttle时可以看到这个过程：

firewall manager: starting transproxy.
>> iptables -t nat -N sshuttle-12300
>> iptables -t nat -F sshuttle-12300
>> iptables -t nat -I OUTPUT 1 -j sshuttle-12300
>> iptables -t nat -I PREROUTING 1 -j sshuttle-12300
>> iptables -t nat -A sshuttle-12300 -j RETURN --dest 127.0.0.0/8 -p tcp
>> iptables -t nat -A sshuttle-12300 -j REDIRECT --dest 0.0.0.0/0 -p tcp --to-ports 12300 -m ttl ! --ttl 42

当梭子离开时，删除iptables nat规则

>> iptables -t nat -D OUTPUT -j sshuttle-12300
>> iptables -t nat -D PREROUTING -j sshuttle-12300
>> iptables -t nat -F sshuttle-12300
>> iptables -t nat -X sshuttle-12300

通过到sshuttle服务器的ssh连接获取和复用TCP内容，然后再将其解复用为连接。onaccept_tcpin函数在client.py中执行mux：

def onaccept_tcp(listener, method, mux, handlers):
    global _extra_fd
    try:
        sock, srcip = listener.accept()
    except socket.error as e:
        if e.args[0] in [errno.EMFILE, errno.ENFILE]:
            debug1('Rejected incoming connection: too many open files!\n')
            # free up an fd so we can eat the connection
            os.close(_extra_fd)
            try:
                sock, srcip = listener.accept()
                sock.close()
            finally:
                _extra_fd = os.open('/dev/null', os.O_RDONLY)
            return
        else:
            raise

    dstip = method.get_tcp_dstip(sock)
    debug1('Accept TCP: %s:%r -> %s:%r.\n' % (srcip[0], srcip[1],
                                              dstip[0], dstip[1]))
    if dstip[1] == sock.getsockname()[1] and islocal(dstip[0], sock.family):
        debug1("-- ignored: that's my address!\n")
        sock.close()
        return
    chan = mux.next_channel()
    if not chan:
        log('warning: too many open channels.  Discarded connection.\n')
        sock.close()
        return
    mux.send(chan, ssnet.CMD_TCP_CONNECT, b'%d,%s,%d' %
             (sock.family, dstip[0].encode("ASCII"), dstip[1]))
    outwrap = MuxWrapper(mux, chan)
    handlers.append(Proxy(SockWrapper(sock, sock), outwrap))
    expire_connections(time.time(), mux)

您可以看到数据是如何在ssnet.py中打包的。

我在红袜中看到了同样的策略(我指的是设置防火墙规则)，它的目的是将任何TCP连接重定向到SOCKS或HTTPS代理。

Answer 2

正如声明中所说的，这不是TCP通过TCP协议。

这是TCP over TCP：

First application   
  First end of outer TCP connection  
  First end of inner TCP connection  
   Datagram/packet link  
  Send end of inner TCP connection  
  Second end of outer TCP connection  
Second application  

注意外部TCP连接是如何在内部TCP连接上进行的？

他们就是这么做的：

First application   
 First end of outer TCP connection  
  Outer end of First TCP connection  
  Inner end of First TCP connection  
    Byte stream link  
  Inner end of Second TCP connection  
  Outer end of Second TCP connection  
Second application 

注意没有通过内部TCP连接传输的外部TCP连接？没有TCP通过TCP。

有四种明显的方法可以做到：

1. 诱导应用程序将TCP连接到已分配给系统的IP地址。
2. 将应用程序试图连接到的IP地址分配给系统。
3. NAT到本地系统上运行的进程的出站TCP连接。(jfly回答暗示他们就是这么做的)
4. 使OS将TCP数据包路由到您，并在用户空间中使用TCP的实现来终止它。