PROSAGA码农传奇-安全协议-尝试使用此代码在TLS上运行TLS时，为什么会出现握手失败？

0# 樱花弄๑•ั็•็ | 2019-08-31 10-32

1# 子阳 | 2019-08-31 10-32

2# 哎？小查查 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  
    至少有两个问题
     <code>
 OnionProtocol
 </code>
    ：
  
  <OL>
    <LI>
      该
      
        内
      
       <code>
 TLSMemoryBIOProtocol
 </code>
       变成了
       <code>
 wrappedProtocol
 </code>
      ，什么时候应该是
      
        最
      
      ;
    </LI>
    <LI>
       <code>
 ProtocolWithoutConnectionLost
 </code>
       没有弹出任何
       <code>
 TLSMemoryBIOProtocol
 </code>
      关了
       <code>
 OnionProtocol
 </code>
      堆栈，因为
       <code>
 connectionLost
 </code>
       仅在a之后调用
       <code>
 FileDescriptor
 </code>
      小号
       <code>
 doRead
 </code>
       要么
       <code>
 doWrite
 </code>
       方法返回断开连接的原因。
    </LI>
  </醇>
  
    如果不改变方式，我们就无法解决第一个问题
     <code>
 OnionProtocol
 </code>
     管理它的堆栈，我们无法解决第二个问题，直到我们找到新的堆栈实现。不出所料，正确的设计是Twisted中数据流动方式的直接结果，因此我们将从一些数据流分析开始。
  
  
    Twisted表示与其中一个实例建立的连接
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/internet/tcp.py#L744-L852" rel="noreferrer">
       <code>
 twisted.internet.tcp.Server
 </code>
    </A>
     要么
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/internet/tcp.py#L735-L740" rel="noreferrer">
       <code>
 twisted.internet.tcp.Client
 </code>
    </A>
    。由于我们程序中唯一的交互发生在
    <a href="https://github.com/markrwilliams/onion/blob/6e021eefba5845cb5a8d5b3cb799e417fa707093/stoptls_client.py" rel="noreferrer">
       <code>
 stoptls_client
 </code>
    </A>
    ，我们只会考虑进出数据流
     <code>
 Client
 </code>
     实例。
  
  
    让我们用最小的热身
     <code>
 LineReceiver
 </code>
     在端口9999上回送从本地服务器收到的线路的客户端：
  
   <pre>
 <code>
 from twisted.protocols import basic
from twisted.internet import defer, endpoints, protocol, task

class LineReceiver(basic.LineReceiver):
    def lineReceived(self, line):
        self.sendLine(line)

def main(reactor):
    clientEndpoint = endpoints.clientFromString(
        reactor, "tcp:localhost:9999")
    connected = clientEndpoint.connect(
        protocol.ClientFactory.forProtocol(LineReceiver))
    def waitForever(_):
        return defer.Deferred()
    return connected.addCallback(waitForever)

task.react(main)

</code>
 </pre>
  
    一旦建立连接建立，a
     <code>
 Client
 </code>
     成为我们的
     <code>
 LineReceiver
 </code>
     协议的传输和中介输入和输出：
  
  
    <a href="https://i.stack.imgur.com/gTPRa.png" rel="noreferrer">
      <img src =“https://i.stack.imgur.com/gTPRa.png”alt =“Client and LineReceiver”/>
    </A>
  
  
    来自服务器的新数据导致reactor调用
     <code>
 Client
 </code>
    的
     <code>
 doRead
 </code>
     方法，它反过来传递它收到的东西
     <code>
 LineReceiver
 </code>
    的
     <code>
 dataReceived
 </code>
     方法。最后，
     <code>
 LineReceiver.dataReceived
 </code>
     电话
     <code>
 LineReceiver.lineReceived
 </code>
     当至少有一行可用时。
  
  
    我们的应用程序通过调用将一行数据发送回服务器
     <code>
 LineReceiver.sendLine
 </code>
    。这叫
     <code>
 write
 </code>
     在绑定到协议实例的传输上，这是相同的
     <code>
 Client
 </code>
     处理传入数据的实例。
     <code>
 Client.write
 </code>
     安排反应堆发送数据，同时
     <code>
 Client.doWrite
 </code>
     实际上通过套接字发送数据。
  
  
    我们准备好看看一个人的行为
    <a href="https://github.com/markrwilliams/onion/blob/6e021eefba5845cb5a8d5b3cb799e417fa707093/stoptls_client.py#L25-L39" rel="noreferrer">
       <code>
 OnionClient
 </code>
    </A>
     从不打电话
     <code>
 startTLS
 </code>
    ：
  
  
    <a href="https://i.stack.imgur.com/yP5FC.png" rel="noreferrer">
      <img src =“https://i.stack.imgur.com/yP5FC.png”alt =“没有startTLS的OnionClient”/>
    </A>
  
  
     <code>
 OnionClient
 </code>
    被包裹着
    <a href="https://github.com/markrwilliams/onion/blob/6e021eefba5845cb5a8d5b3cb799e417fa707093/stoptls_transport.py#L22-L50" rel="noreferrer">
       <code>
 OnionProtocol
 </code>
      小号
    </A>
    ，这是我们尝试嵌套TLS的关键。作为的子类
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/policies.py#L39" rel="noreferrer">
       <code>
 twisted.internet.policies.ProtocolWrapper
 </code>
    </A>
    ，一个例子
     <code>
 OnionProtocol
 </code>
     是一种协议传输三明治;它表现为一个
    
      协议
    
     到较低级别的运输和作为
    
      运输
    
     通过一个协议，它通过一个在连接时建立的伪装来包装
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/policies.py#L129" rel="noreferrer">
       <code>
 WrappingFactory
 </code>
    </A>
    。
  
  
    现在，
     <code>
 Client.doRead
 </code>
     电话
     <code>
 OnionProtocol.dataReceived
 </code>
    ，代理数据到
     <code>
 OnionClient
 </code>
    。如
     <code>
 OnionClient
 </code>
    的运输，
     <code>
 OnionProtocol.write
 </code>
     接受要发送的行
     <code>
 OnionClient.sendLine
 </code>
     并代理他们
     <code>
 Client
 </code>
    ， 它的
    
      拥有
    
     运输。这是a之间的正常交互
     <code>
 ProtocolWrapper
 </code>
    ，它的包装协议，以及它自己的传输，所以数据自然流动每个人都没有任何麻烦。
  
  
     <code>
 OnionProtocol.startTLS
 </code>
     有所不同。它试图设置一个新的
     <code>
 ProtocolWrapper
 </code>
      - 恰好是一个
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L115" rel="noreferrer">
       <code>
 TLSMemoryBIOProtocol
 </code>
    </A>
      - 之间
    
      既定
    
     协议传输对。这似乎很容易：a
     <code>
 ProtocolWrapper
 </code>
     将上层协议存储为其
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/policies.py#L54" rel="noreferrer">
       <code>
 wrappedProtocol
 </code>
       属性
    </A>
    ，和
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/policies.py#L113-L114" rel="noreferrer">
      代理
       <code>
 write
 </code>
       和其他属性归结为自己的传输
    </A>
    。
     <code>
 startTLS
 </code>
     应该能够注入新的
     <code>
 TLSMemoryBIOProtocol
 </code>
     包裹
     <code>
 OnionClient
 </code>
     通过修补自己的实例来进入连接
     <code>
 wrappedProtocol
 </code>
     和
     <code>
 transport
 </code>
    ：
  
   <pre>
 <code>
 def startTLS(self):
 ...
 connLost = ProtocolWithoutConnectionLost(self.wrappedProtocol)
 connLost.onion = self
 # Construct a new TLS layer, delivering events and application data to the
 # wrapper just created.
 tlsProtocol = TLSMemoryBIOProtocol(None, connLost, False)

# Push the previous transport and protocol onto the stack so they can be
    # retrieved when this new TLS layer stops.
    self._tlsStack.append((self.transport, self.wrappedProtocol))
    ...
    # Make the new TLS layer the current protocol and transport.
    self.wrappedProtocol = self.transport = tlsProtocol

</code>
 </pre>
  
    这是第一次调用后的数据流
     <code>
 startTLS
 </code>
    ：
  
  
    <a href="https://i.stack.imgur.com/LxhOA.png" rel="noreferrer">
      <img src =“https://i.stack.imgur.com/LxhOA.png”alt =“startTLS one TLSMemoryBIOProtocol，working”/>
    </A>
  
  
    正如所料，新数据传递给了
     <code>
 OnionProtocol.dataReceived
 </code>
     被送到了
     <code>
 TLSMemoryBIOProtocol
 </code>
     存储在
     <code>
 _tlsStack
 </code>
    ，将解密的明文传递给
     <code>
 OnionClient.dataReceived
 </code>
    。
     <code>
 OnionClient.sendLine
 </code>
     也将其数据传递给
     <code>
 TLSMemoryBIOProtocol.write
 </code>
    ，对其进行加密并将生成的密文发送给
     <code>
 OnionProtocol.write
 </code>
     然后
     <code>
 Client.write
 </code>
    。
  
  
    不幸的是，这个方案在第二次调用后失败了
     <code>
 startTLS
 </code>
    。根本原因是这一行：
  
   <pre>
 <code>
 self.wrappedProtocol = self.transport = tlsProtocol

</code>
 </pre>
  
    每次打电话
     <code>
 startTLS
 </code>
     取代了
     <code>
 wrappedProtocol
 </code>
     随着
    
      内
    
     <code>
 TLSMemoryBIOProtocol
 </code>
    ，即使收到的数据
     <code>
 Client.doRead
 </code>
     被加密了
    
      最
    
    ：
  
  
    <a href="https://i.stack.imgur.com/2MbhO.png" rel="noreferrer">
      <img src =“https://i.stack.imgur.com/2MbhO.png”alt =“startTLS两个TLSMemoryBIOProtocols，破解”/>
    </A>
  
  
    该
     <code>
 transport
 </code>
    但是，s是正确嵌套的。
     <code>
 OnionClient.sendLine
 </code>
     只能叫它的运输工具
     <code>
 write
 </code>
     - 那是，
     <code>
 OnionProtocol.write
 </code>
      - 所以
     <code>
 OnionProtocol
 </code>
     应该取代它
     <code>
 transport
 </code>
     与最里面的
     <code>
 TLSMemoryBIOProtocol
 </code>
     确保写入连续嵌套在其他加密层中。
  
  
    因此，解决方案是确保数据流过
    
      第一
    
     <code>
 TLSMemoryBIOProtocol
 </code>
     在...上
     <code>
 _tlsStack
 </code>
     到了
    
      下一个
    
     反过来，以便按照应用的相反顺序剥离每层加密：
  
  
    <a href="https://i.stack.imgur.com/uy2gO.png" rel="noreferrer">
      <img src =“https://i.stack.imgur.com/uy2gO.png”alt =“带有两个TLSMemoryBIOProtocols的startTLS，工作”/>
    </A>
  
  
    代表
     <code>
 _tlsStack
 </code>
     鉴于这一新要求，列表似乎不太自然。幸运的是，线性表示传入的数据流表明了一种新的数据结构：
  
  
    <a href="https://i.stack.imgur.com/JuSus.png" rel="noreferrer">
      <img src =“https://i.stack.imgur.com/JuSus.png”alt =“作为链接列表遍历的传入数据”/>
    </A>
  
  
    传输数据的错误和正确流程都类似于单链表
     <code>
 wrappedProtocol
 </code>
     担任
     <code>
 ProtocolWrapper
 </code>
    下一个链接和
     <code>
 protocol
 </code>
     担任
     <code>
 Client
 </code>
    的。该列表应该从下降
     <code>
 OnionProtocol
 </code>
     并始终以
     <code>
 OnionClient
 </code>
    。发生该错误是因为违反了排序不变量。
  
  
    一个单链表可以很好地将协议推送到堆栈上但是很难将它们弹出，因为它需要从头部向下移动到节点才能删除。当然，每次收到数据时都会发生这种遍历，因此关注的是额外遍历所隐含的复杂性，而不是最坏情况下的时间复杂度。幸运的是，该列表实际上是双重关联的：
  
  
    <a href="https://i.stack.imgur.com/i2p7t.png" rel="noreferrer">
      <img src =“https://i.stack.imgur.com/i2p7t.png”alt =“带有协议和传输的双链表”/>
    </A>
  
  
    该
     <code>
 transport
 </code>
     属性链接每个嵌套协议与其前身，所以
     <code>
 transport.write
 </code>
     在最终通过网络发送数据之前，可以连续降低加密级别。我们有两个哨兵来帮助管理清单：
     <code>
 Client
 </code>
     必须始终在顶部
     <code>
 OnionClient
 </code>
     必须始终在底部。
  
  
    把两者放在一起，我们最终得到这个：
  
   <pre>
 <code>
 from twisted.python.components import proxyForInterface
from twisted.internet.interfaces import ITCPTransport
from twisted.protocols.tls import TLSMemoryBIOFactory, TLSMemoryBIOProtocol
from twisted.protocols.policies import ProtocolWrapper, WrappingFactory

class PopOnDisconnectTransport(proxyForInterface(ITCPTransport)):
    """
    L{TLSMemoryBIOProtocol.loseConnection} shuts down the TLS session
    and calls its own transport's C{loseConnection}.  A zero-length
    read also calls the transport's C{loseConnection}.  This proxy
    uses that behavior to invoke a C{pop} callback when a session has
    ended.  The callback is invoked exactly once because
    C{loseConnection} must be idempotent.
    """
    def __init__(self, pop, **kwargs):
        super(PopOnDisconnectTransport, self).__init__(**kwargs)
        self._pop = pop

def loseConnection(self):
        self._pop()
        self._pop = lambda: None

class OnionProtocol(ProtocolWrapper):
    """
    OnionProtocol is both a transport and a protocol.  As a protocol,
    it can run over any other ITransport.  As a transport, it
    implements stackable TLS.  That is, whatever application traffic
    is generated by the protocol running on top of OnionProtocol can
    be encapsulated in a TLS conversation.  Or, that TLS conversation
    can be encapsulated in another TLS conversation.  Or **that** TLS
    conversation can be encapsulated in yet *another* TLS
    conversation.

Each layer of TLS can use different connection parameters, such as
    keys, ciphers, certificate requirements, etc.  At the remote end
    of this connection, each has to be decrypted separately, starting
    at the outermost and working in.  OnionProtocol can do this
    itself, of course, just as it can encrypt each layer starting with
    the innermost.
    """

def __init__(self, *args, **kwargs):
        ProtocolWrapper.__init__(self, *args, **kwargs)
        # The application level protocol is the sentinel at the tail
        # of the linked list stack of protocol wrappers.  The stack
        # begins at this sentinel.
        self._tailProtocol = self._currentProtocol = self.wrappedProtocol

def startTLS(self, contextFactory, client, bytes=None):
        """
        Add a layer of TLS, with SSL parameters defined by the given
        contextFactory.

If *client* is True, this side of the connection will be an
        SSL client.  Otherwise it will be an SSL server.

If extra bytes which may be (or almost certainly are) part of
        the SSL handshake were received by the protocol running on top
        of OnionProtocol, they must be passed here as the **bytes**
        parameter.
        """
        # The newest TLS session is spliced in between the previous
        # and the application protocol at the tail end of the list.
        tlsProtocol = TLSMemoryBIOProtocol(None, self._tailProtocol, False)
        tlsProtocol.factory = TLSMemoryBIOFactory(contextFactory, client, None)

if self._currentProtocol is self._tailProtocol:
            # This is the first and thus outermost TLS session.  The
            # transport is the immutable sentinel that no startTLS or
            # stopTLS call will move within the linked list stack.
            # The wrappedProtocol will remain this outermost session
            # until it's terminated.
            self.wrappedProtocol = tlsProtocol
            nextTransport = PopOnDisconnectTransport(
                original=self.transport,
                pop=self._pop
            )
            # Store the proxied transport as the list's head sentinel
            # to enable an easy identity check in _pop.
            self._headTransport = nextTransport
        else:
            # This a later TLS session within the stack.  The previous
            # TLS session becomes its transport.
            nextTransport = PopOnDisconnectTransport(
                original=self._currentProtocol,
                pop=self._pop
            )

# Splice the new TLS session into the linked list stack.
        # wrappedProtocol serves as the link, so the protocol at the
        # current position takes our new TLS session as its
        # wrappedProtocol.
        self._currentProtocol.wrappedProtocol = tlsProtocol
        # Move down one position in the linked list.
        self._currentProtocol = tlsProtocol
        # Expose the new, innermost TLS session as the transport to
        # the application protocol.
        self.transport = self._currentProtocol
        # Connect the new TLS session to the previous transport.  The
        # transport attribute also serves as the previous link.
        tlsProtocol.makeConnection(nextTransport)

# Left over bytes are part of the latest handshake.  Pass them
        # on to the innermost TLS session.
        if bytes is not None:
            tlsProtocol.dataReceived(bytes)

def stopTLS(self):
        self.transport.loseConnection()

def _pop(self):
        pop = self._currentProtocol
        previous = pop.transport
        # If the previous link is the head sentinel, we've run out of
        # linked list.  Ensure that the application protocol, stored
        # as the tail sentinel, becomes the wrappedProtocol, and the
        # head sentinel, which is the underlying transport, becomes
        # the transport.
        if previous is self._headTransport:
            self._currentProtocol = self.wrappedProtocol = self._tailProtocol
            self.transport = previous
        else:
            # Splice out a protocol from the linked list stack.  The
            # previous transport is a PopOnDisconnectTransport proxy,
            # so first retrieve proxied object off its original
            # attribute.
            previousProtocol = previous.original
            # The previous protocol's next link becomes the popped
            # protocol's next link
            previousProtocol.wrappedProtocol = pop.wrappedProtocol
            # Move up one position in the linked list.
            self._currentProtocol = previousProtocol
            # Expose the new, innermost TLS session as the transport
            # to the application protocol.
            self.transport = self._currentProtocol

class OnionFactory(WrappingFactory):
    """
    A L{WrappingFactory} that overrides
    L{WrappingFactory.registerProtocol} and
    L{WrappingFactory.unregisterProtocol}.  These methods store in and
    remove from a dictionary L{ProtocolWrapper} instances.  The
    C{transport} patching done as part of the linked-list management
    above causes the instances' hash to change, because the
    C{__hash__} is proxied through to the wrapped transport.  They're
    not essential to this program, so the easiest solution is to make
    them do nothing.
    """
    protocol = OnionProtocol

def registerProtocol(self, protocol):
        pass

def unregisterProtocol(self, protocol):
        pass

</code>
 </pre>
  
    （这也是可用的
    <a href="https://github.com/markrwilliams/onion/blob/6f16e3b15eabee8e0043f1e2034ca7c0099d1163/stoptls_transport.py" rel="noreferrer">
      GitHub上
    </A>
    。）
  
  
    第二个问题的解决方案在于
     <code>
 PopOnDisconnectTransport
 </code>
    。原始代码尝试从堆栈中弹出TLS会话
     <code>
 connectionLost
 </code>
    ，但因为只有一个封闭的文件描述符导致
     <code>
 connectionLost
 </code>
     要调用，它无法删除未关闭底层套接字的已停止的TLS会话。
  
  
    在撰写本文时，
     <code>
 TLSMemoryBIOProtocol
 </code>
     叫它的运输
     <code>
 loseConnection
 </code>
     在两个地方：
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L351" rel="noreferrer">
       <code>
 _shutdownTLS
 </code>
    </A>
     和
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L385" rel="noreferrer">
       <code>
 _tlsShutdownFinished
 </code>
    </A>
    。
     <code>
 _shutdownTLS
 </code>
     在主动关闭时调用（
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L422" rel="noreferrer">
       <code>
 loseConnection
 </code>
    </A>
    ，
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L432" rel="noreferrer">
       <code>
 abortConnection
 </code>
    </A>
    ，
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L620" rel="noreferrer">
       <code>
 unregisterProducer
 </code>
    </A>
     和
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L502" rel="noreferrer">
      后
       <code>
 loseConnection
 </code>
       并且所有挂起的写入都已刷新
    </A>
    ），同时
     <code>
 _tlsShutdownFinished
 </code>
     在被动关闭时调用（
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L239" rel="noreferrer">
      握手失败
    </A>
    ，
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L285" rel="noreferrer">
      空读
    </A>
    ，
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L292" rel="noreferrer">
      读错误
    </A>
    ，和
    <a href="https://github.com/twisted/twisted/blob/twisted-17.9.0/src/twisted/protocols/tls.py#L536" rel="noreferrer">
      写错误
    </A>
    ）。这一切都意味着
    
      都
    
     关闭连接的两侧可以在执行期间从堆栈中弹出TLS会话
     <code>
 loseConnection
 </code>
    。
     <code>
 PopOnDisconnectTransport
 </code>
     这是无意义的，因为
     <code>
 loseConnection
 </code>
     通常是幂等的，并且
     <code>
 TLSMemoryBIOProtocol
 </code>
     当然希望它是。
  
  
    将堆栈管理逻辑放入的缺点
     <code>
 loseConnection
 </code>
     这取决于具体情况
     <code>
 TLSMemoryBIOProtocol
 </code>
    的实施。通用解决方案需要跨越多个Twisted级别的新API。
  
  
    在那之前，我们仍然坚持另一个例子
    <a href="http://www.hyrumslaw.com/" rel="noreferrer">
      Hyrum定律
    </A>
    。
  
</DIV>