Your IP : 172.28.240.42
Nc @ s d Z d d l m Z m Z m Z d d l m Z m Z m Z y e e e e Wn7 e k
r Z
e e
d k r n e d n Xd d l
m Z d d l m Z d d l m Z d d l m Z d d
l m Z m Z d d l m Z m Z d d l m Z d d
l m Z d d l m Z d d l m! Z! m" Z" d e# f d YZ$ d e# f d YZ% d e! f d YZ& d e" f d YZ' d S( s
Implementation of a TLS transport (L{ISSLTransport}) as an
L{IProtocol<twisted.internet.interfaces.IProtocol>} layered on top of any
L{ITransport<twisted.internet.interfaces.ITransport>} implementation, based on
U{OpenSSL<http://www.openssl.org>}'s memory BIO features.
L{TLSMemoryBIOFactory} is a L{WrappingFactory} which wraps protocols created by
the factory it wraps with L{TLSMemoryBIOProtocol}. L{TLSMemoryBIOProtocol}
intercedes between the underlying transport and the wrapped protocol to
implement SSL and TLS. Typical usage of this module looks like this::
from twisted.protocols.tls import TLSMemoryBIOFactory
from twisted.internet.protocol import ServerFactory
from twisted.internet.ssl import PrivateCertificate
from twisted.internet import reactor
from someapplication import ApplicationProtocol
serverFactory = ServerFactory()
serverFactory.protocol = ApplicationProtocol
certificate = PrivateCertificate.loadPEM(certPEMData)
contextFactory = certificate.options()
tlsFactory = TLSMemoryBIOFactory(contextFactory, False, serverFactory)
reactor.listenTCP(12345, tlsFactory)
reactor.run()
This API offers somewhat more flexibility than
L{twisted.internet.interfaces.IReactorSSL}; for example, a L{TLSMemoryBIOProtocol}
instance can use another instance of L{TLSMemoryBIOProtocol} as its transport,
yielding TLS over TLS - useful to implement onion routing. It can also be used
to run TLS over unusual transports, such as UNIX sockets and stdio.
i( t Errort ZeroReturnErrort
WantReadError( t TLSv1_METHODt Contextt
Connections3 argument must be an int, or have a fileno() method.s7 twisted.protocols.tls requires pyOpenSSL 0.10 or newer.( t
implements( t Failure( t log( t safe_str( t
ISystemHandlet
ISSLTransport( t
IPushProducert ILoggingContext( t CONNECTION_LOST( t Protocol( t cooperate( t ProtocolWrappert WrappingFactoryt _PullToPushc B s] e Z d Z e e e Z d Z d Z d Z d Z
d Z d Z d Z
RS( s
An adapter that converts a non-streaming to a streaming producer.
Because of limitations of the producer API, this adapter requires the
cooperation of the consumer. When the consumer's C{registerProducer} is
called with a non-streaming producer, it must wrap it with L{_PullToPush}
and then call C{startStreaming} on the resulting object. When the
consumer's C{unregisterProducer} is called, it must call
C{stopStreaming} on the L{_PullToPush} instance.
If the underlying producer throws an exception from C{resumeProducing},
the producer will be unregistered from the consumer.
@ivar _producer: the underling non-streaming producer.
@ivar _consumer: the consumer with which the underlying producer was
registered.
@ivar _finished: C{bool} indicating whether the producer has finished.
@ivar _coopTask: the result of calling L{cooperate}, the task driving the
streaming producer.
c C s | | _ | | _ d S( N( t _producert _consumer( t selft pullProducert consumer( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt __init__[ s c c s x t r y | j j Wnl t j d d t | j f y | j j Wq t j d d t | j f t | _ d SXn Xd Vq Wd S( s
A generator that calls C{resumeProducing} on the underlying producer
forever.
If C{resumeProducing} throws an exception, the producer is
unregistered, which should result in streaming stopping.
s% %s failed, producing will be stopped:s! %s failed to unregister producer:N(
t TrueR t resumeProducingR t errt NoneR R t unregisterProducert _finished( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt _pull` s c C s t | j | _ d S( s
This should be called by the consumer when the producer is registered.
Start streaming data to the consumer.
N( R R t _coopTask( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt startStreaming| s c C s' | j r
d St | _ | j j d S( s
This should be called by the consumer when the producer is unregistered.
Stop streaming data to the consumer.
N( R R R! t stop( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt
stopStreaming s c C s | j j d S( N( R! t pause( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt pauseProducing s c C s | j j d S( N( R! t resume( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR s c C s | j | j j d S( N( R$ R t
stopProducing( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR( s
( t __name__t
__module__t __doc__R R t FalseR R R R" R$ R& R R( ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR > s
t _ProducerMembranec B sB e Z d Z e e e Z d Z d Z d Z d Z
RS( s
Stand-in for producer registered with a L{TLSMemoryBIOProtocol} transport.
Ensures that producer pause/resume events from the undelying transport are
coordinated with pause/resume events from the TLS layer.
@ivar _producer: The application-layer producer.
c C s
| | _ d S( N( R ( R t producer( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR s c C s' | j r
d St | _ | j j d S( sP
C{pauseProducing} the underlying producer, if it's not paused.
N( t _producerPausedR R R& ( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR& s c C s' | j s
d St | _ | j j d S( sM
C{resumeProducing} the underlying producer, if it's paused.
N( R/ R, R R ( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR s c C s | j j d S( s
C{stopProducing} the underlying producer.
There is only a single source for this event, so it's simply passed
on.
N( R R( ( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR( s ( R) R* R+ R R R, R/ R R& R R( ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR- s
t TLSMemoryBIOProtocolc B s e Z d Z e e e d Z e Z e Z
e Z d Z e
d Z d Z d Z d Z d Z d Z d Z d Z d Z d
Z d Z d Z d
Z d Z d Z d Z RS( s
L{TLSMemoryBIOProtocol} is a protocol wrapper which uses OpenSSL via a
memory BIO to encrypt bytes written to it before sending them on to the
underlying transport and decrypts bytes received from the underlying
transport before delivering them to the wrapped protocol.
In addition to producer events from the underlying transport, the need to
wait for reads before a write can proceed means the
L{TLSMemoryBIOProtocol} may also want to pause a producer. Pause/resume
events are therefore merged using the L{_ProducerMembrane}
wrapper. Non-streaming (pull) producers are supported by wrapping them
with L{_PullToPush}.
@ivar _tlsConnection: The L{OpenSSL.SSL.Connection} instance which is
encrypted and decrypting this connection.
@ivar _lostTLSConnection: A flag indicating whether connection loss has
already been dealt with (C{True}) or not (C{False}). TLS disconnection
is distinct from the underlying connection being lost.
@ivar _writeBlockedOnRead: A flag indicating whether further writing must
wait for data to be received (C{True}) or not (C{False}).
@ivar _appSendBuffer: A C{list} of C{str} of application-level (cleartext)
data which is waiting for C{_writeBlockedOnRead} to be reset to
C{False} so it can be passed to and perhaps accepted by
C{_tlsConnection.send}.
@ivar _connectWrapped: A flag indicating whether or not to call
C{makeConnection} on the wrapped protocol. This is for the reactor's
L{twisted.internet.interfaces.ITLSTransport.startTLS} implementation,
since it has a protocol which it has already called C{makeConnection}
on, and which has no interest in a new transport. See #3821.
@ivar _handshakeDone: A flag indicating whether or not the handshake is
known to have completed successfully (C{True}) or not (C{False}). This
is used to control error reporting behavior. If the handshake has not
completed, the underlying L{OpenSSL.SSL.Error} will be passed to the
application's C{connectionLost} method. If it has completed, any
unexpected L{OpenSSL.SSL.Error} will be turned into a
L{ConnectionLost}. This is weird; however, it is simply an attempt at
a faithful re-implementation of the behavior provided by
L{twisted.internet.ssl}.
@ivar _reason: If an unexpected L{OpenSSL.SSL.Error} occurs which causes
the connection to be lost, it is saved here. If appropriate, this may
be used as the reason passed to the application protocol's
C{connectionLost} method.
@ivar _producer: The current producer registered via C{registerProducer},
or C{None} if no producer has been registered or a previous one was
unregistered.
c C s t j | | | | | _ d S( N( R R t _connectWrapped( R t factoryt wrappedProtocolR1 ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR s c C s | j S( si
Return the L{OpenSSL.SSL.Connection} object being used to encrypt and
decrypt this connection.
This is done for the benefit of L{twisted.internet.ssl.Certificate}'s
C{peerFromTransport} and C{hostFromTransport} methods only. A
different system handle may be returned by future versions of this
method.
( t _tlsConnection( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt getHandle s
c C s | j j j } t | d | _ | j j r@ | j j n
| j j g | _ t
j | | | j j | | j
r t j | | n y | j j Wn t k
r | j n Xd S( s
Connect this wrapper to the given transport and initialize the
necessary L{OpenSSL.SSL.Connection} with a memory BIO.
N( R2 t _contextFactoryt
getContextR R R4 t _isClientt set_connect_statet set_accept_statet _appSendBufferR t makeConnectiont registerProtocolR1 R t do_handshakeR t
_flushSendBIO( R t transportt
tlsContext( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR< s
c C s> y | j j d } Wn t k
r) n X| j j | d S( sh
Read any bytes out of the send BIO and write them to the underlying
transport.
i i Ni ( R4 t bio_readR R@ t write( R t bytes( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR? D s
c C s x | j s y | j j d } Wn t k
r6 Pq t k
r] | j | j d q t k
r } | j d d k r | j d d k r t
t } n t
} | j | j | q Xt
| _ t j | | q W| j d S( se
Try to receive any application-level bytes which are now available
because of a previous write into the receive BIO. This will take
care of delivering any application-level bytes which are received to
the protocol, as well as handling of the various exceptions which
can come from trying to get such bytes.
i i i ii s Unexpected EOFNi ( t _lostTLSConnectionR4 t recvR R t _shutdownTLSt _tlsShutdownFinishedR R t argsR R R? R t _handshakeDoneR t dataReceived( R RD t et failure( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt _flushReceiveBIOR s"
&
c C s | j j | | j r t | _ | j } g | _ x | D] } | j | q; W| j r | j r | j d k r | j n | j
d k r | j
j q n | j d S( s
Deliver any received bytes to the receive BIO and then read and deliver
to the application any application-level data which becomes available
as a result of this.
N(
R4 t bio_writet _writeBlockedOnReadR, R; t _writet
disconnectingR. R RG R R RN ( R RD t
appSendBuffer( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRK s
c C s3 | j j } | j | r/ | j j n d S( sQ
Initiate, or reply to, the shutdown handshake of the TLS layer.
N( R4 t shutdownR? R@ t loseConnection( R t shutdownSuccess( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRG s
c C s# | | _ t | _ | j j d S( sl
Called when TLS connection has gone away; tell underlying transport to
disconnect.
N( t _reasonR RE R@ RU ( R t reason( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRH s c C sX | j s, | j j | j t | _ n | j p8 | } d | _ t j | | d S( s
Handle the possible repetition of calls to this method (due to either
the underlying transport going away or due to an error at the TLS
layer) and make sure the base implementation only gets invoked once.
N( RE R4 t bio_shutdownRN R RW R R t connectionLost( R RX ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRZ s
c C s@ | j r
d St | _ | j r< | j d k r< | j n d S( sM
Send a TLS close alert and close the underlying connection.
N( RR R RP R R RG ( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRU s
c C s- | j r | j d k r d S| j | d S( s
Process the given application bytes and send any resulting TLS traffic
which arrives in the send BIO.
If C{loseConnection} was called, subsequent calls to C{write} will
drop the bytes on the floor.
N( RR R R RQ ( R RD ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRC s c C s | j r
d S| } x | r y | j j | } Wnk t k
r~ t | _ | j j | | j d k rz | j j
n Pq t k
r | j t
Pq Xt | _ | j | | } q Wd S( s^
Process the given application bytes and send any resulting TLS traffic
which arrives in the send BIO.
This may be called by C{dataReceived} with bytes that were buffered
before C{loseConnection} was called, which is why this function
doesn't check for disconnection but accepts the bytes regardless.
N( RE R4 t sendR R RP R; t appendR R R& R RH R RJ R? ( R RD t
leftToSendt sent( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRQ s$
c C s | j d j | d S( s}
Write a sequence of application bytes by joining them into one string
and passing them to L{write}.
t N( RC t join( R t iovec( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt
writeSequence s c C s
| j j S( N( R4 t get_peer_certificate( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt getPeerCertificate s c C s[ | s t | | } } n t | } | j j | t | | _ | sW | j n d S( N( R R- R@ t registerProducerR R R" ( R R. t streamingt streamingProducer( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRe s c C sk t | j j t r( | j j j n d | _ t | _ | j j | j rg | j
rg | j n d S( N( t
isinstanceR R R$ R R, R/ R@ R RR RP RG ( R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR + s
N( R) R* R+ R R
R R RW R, RJ RE RP R R R R5 R< R? RN RK RG RH RZ RU RC RQ Rb Rd Re R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR0 s. 5
$ 5 & t TLSMemoryBIOFactoryc B s, e Z d Z e Z e Z d Z d Z RS( s:
L{TLSMemoryBIOFactory} adds TLS to connections.
@ivar _contextFactory: The TLS context factory which will be used to define
certain TLS connection parameters.
@ivar _isClient: A flag which is C{True} if this is a client TLS
connection, C{False} if it is a server TLS connection.
c C s& t j | | | | _ | | _ d S( N( R R R6 R8 ( R t contextFactoryt isClientt wrappedFactory( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyR F s c C s> t j | j r$ | j j } n | j j j } d | f S( s
Annotate the wrapped factory's log prefix with some text indicating TLS
is in use.
@rtype: C{str}
s %s (TLS)( R
t
providedByRl t logPrefixt __class__R) ( R Rn ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRn L s ( R) R* R+ R0 t protocolR, t noisyR Rn ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyRi 8 s
N(( R+ t OpenSSL.SSLR R R R R R R t TypeErrorRL t strt ImportErrort zope.interfaceR t twisted.python.failureR t twisted.pythonR t twisted.python.reflectR t twisted.internet.interfacesR
R R R
t twisted.internet.mainR t twisted.internet.protocolR t twisted.internet.taskR t twisted.protocols.policiesR R t objectR R- R0 Ri ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/protocols/tls.pyt <module>$ s. b0 i