Why is there a handshake failure when trying to run TLS over TLS with this code?
Question: I tried to implement a protocol that can run TLS over TLS using
`twisted.protocols.tls`, an interface to OpenSSL using a memory BIO.

I implemented this as a protocol wrapper that mostly looks like a regular TCP
transport, but which has `startTLS` and `stopTLS` methods for adding and
removing a layer of TLS respectively. This works fine for the first layer of
TLS. It also works fine if I run it over a "native" Twisted TLS transport.
However, if I try to add a second TLS layer using the `startTLS` method
provided by this wrapper, there's immediately a handshake error and the
connection ends up in some unknown unusable state.

The wrapper and the two helpers that let it work looks like this:

    
    
    from twisted.python.components import proxyForInterface
    from twisted.internet.error import ConnectionDone
    from twisted.internet.interfaces import ITCPTransport, IProtocol
    from twisted.protocols.tls import TLSMemoryBIOFactory, TLSMemoryBIOProtocol
    from twisted.protocols.policies import ProtocolWrapper, WrappingFactory
    
    class TransportWithoutDisconnection(proxyForInterface(ITCPTransport)):
        """
        A proxy for a normal transport that disables actually closing the connection.
        This is necessary so that when TLSMemoryBIOProtocol notices the SSL EOF it
        doesn't actually close the underlying connection.
    
        All methods except loseConnection are proxied directly to the real transport.
        """
        def loseConnection(self):
            pass
    
    
    class ProtocolWithoutConnectionLost(proxyForInterface(IProtocol)):
        """
        A proxy for a normal protocol which captures clean connection shutdown
        notification and sends it to the TLS stacking code instead of the protocol.
        When TLS is shutdown cleanly, this notification will arrive.  Instead of telling
        the protocol that the entire connection is gone, the notification is used to
        unstack the TLS code in OnionProtocol and hidden from the wrapped protocol.  Any
        other kind of connection shutdown (SSL handshake error, network hiccups, etc) are
        treated as real problems and propagated to the wrapped protocol.
        """
        def connectionLost(self, reason):
            if reason.check(ConnectionDone):
                self.onion._stopped()
            else:
                super(ProtocolWithoutConnectionLost, self).connectionLost(reason)
    
    
    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 makeConnection(self, transport):
            self._tlsStack = []
            ProtocolWrapper.makeConnection(self, transport)
    
    
        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.
            """
            # First, create a wrapper around the application-level protocol
            # (wrappedProtocol) which can catch connectionLost and tell this OnionProtocol 
            # about it.  This is necessary to pop from _tlsStack when the outermost TLS
            # layer stops.
            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)
            tlsProtocol.factory = TLSMemoryBIOFactory(contextFactory, client, None)
    
            # 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))
    
            # Create a transport for the new TLS layer to talk to.  This is a passthrough
            # to the OnionProtocol's current transport, except for capturing loseConnection
            # to avoid really closing the underlying connection.
            transport = TransportWithoutDisconnection(self.transport)
    
            # Make the new TLS layer the current protocol and transport.
            self.wrappedProtocol = self.transport = tlsProtocol
    
            # And connect the new TLS layer to the previous outermost transport.
            self.transport.makeConnection(transport)
    
            # If the application accidentally got some bytes from the TLS handshake, deliver
            # them to the new TLS layer.
            if bytes is not None:
                self.wrappedProtocol.dataReceived(bytes)
    
    
        def stopTLS(self):
            """
            Remove a layer of TLS.
            """
            # Just tell the current TLS layer to shut down.  When it has done so, we'll get
            # notification in *_stopped*.
            self.transport.loseConnection()
    
    
        def _stopped(self):
            # A TLS layer has completely shut down.  Throw it away and move back to the
            # TLS layer it was wrapping (or possibly back to the original non-TLS
            # transport).
            self.transport, self.wrappedProtocol = self._tlsStack.pop()
    

I have simple client and server programs for exercising this, available from
launchpad (`bzr branch lp:~exarkun/+junk/onion`). When I use it to call the
`startTLS` method above twice, with no intervening call to `stopTLS`, this
OpenSSL error comes up:

    
    
    OpenSSL.SSL.Error: [('SSL routines', 'SSL23_GET_SERVER_HELLO', 'unknown protocol')]
    

Why do things go wrong?


Answer: You may need to inform the remote device that you wish to start an environment
and allocate resources for the second layer before you start it up, if that
device has the capabilities.

