î
j fbc ã
@ s d d l Z d d l Z y d d l Z Wn e k
rB d Z Yn Xd d l m Z d d l m Z d d l m Z d d l m Z d d „ Z
d d
„ Z d Z d Z
d
Z d Z Gd d „ d e ƒ Z Gd d „ d e j e j ƒ Z Gd d „ d e j ƒ Z d S)é Né )Úcompat)Ú protocols)Ú
transports)Úloggerc C s• | r t d ƒ ‚ n t t d ƒ rE t j ƒ } | s‘ d | _ q‘ nL t j t j ƒ } | j t j O_ | j t j O_ | j
ƒ t j | _ | S)Nz(Server side SSL needs a valid SSLContextÚcreate_default_contextF)
Ú
ValueErrorÚhasattrÚsslr Úcheck_hostnameZ
SSLContextZPROTOCOL_SSLv23ZoptionsZ OP_NO_SSLv2Z OP_NO_SSLv3Zset_default_verify_pathsZ
CERT_REQUIREDÚ verify_mode)Ú server_sideÚserver_hostnameÚ
sslcontext© r ú5/opt/alt/python34/lib64/python3.4/asyncio/sslproto.pyÚ_create_transport_context s
r c C s
t t d ƒ S)NÚ MemoryBIO)r r
r r r r Ú_is_sslproto_available$ s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ s» e Z d Z d Z d Z d d d „ Z e d d „ ƒ Z e d d
„ ƒ Z e d d „ ƒ Z e d
d „ ƒ Z
d d d „ Z d d d „ Z d d „ Z
d d d „ Z d d d „ Z d S) Ú_SSLPipea An SSL "Pipe".
An SSL pipe allows you to communicate with an SSL/TLS protocol instance
through memory buffers. It can be used to implement a security layer for an
existing connection where you don't have access to the connection's file
descriptor, or for some reason you don't want to use it.
An SSL pipe can be in "wrapped" and "unwrapped" mode. In unwrapped mode,
data is passed through untransformed. In wrapped mode, application level
data is encrypted to SSL record level data and vice versa. The SSL record
level is the lowest level in the SSL protocol suite and is what travels
as-is over the wire.
An SslPipe initially is in "unwrapped" mode. To start SSL, call
do_handshake(). To shutdown SSL again, call unwrap().
é i Nc C sj | | _ | | _ | | _ t | _ t j ƒ | _ t j ƒ | _ d | _ d | _
d | _ d | _ d S)a•
The *context* argument specifies the ssl.SSLContext to use.
The *server_side* argument indicates whether this is a server side or
client side transport.
The optional *server_hostname* argument can be used to specify the
hostname you are connecting to. You may only specify this parameter if
the _ssl module supports Server Name Indication (SNI).
NF)
Ú_contextÚ _server_sideÚ_server_hostnameÚ
_UNWRAPPEDÚ_stater
r Ú _incomingÚ _outgoingÚ_sslobjÚ
_need_ssldataÚ
_handshake_cbÚ _shutdown_cb)ÚselfÚcontextr
r r r r Ú__init__C s z_SSLPipe.__init__c C s | j S)z*The SSL context passed to the constructor.)r )r" r r r r# Y s z_SSLPipe.contextc C s | j S)z^The internal ssl.SSLObject instance.
Return None if the pipe is not wrapped.
)r )r" r r r Ú
ssl_object^ s z_SSLPipe.ssl_objectc C s | j S)zgWhether more record level data is needed to complete a handshake
that is currently in progress.)r )r" r r r Ú need_ssldataf s z_SSLPipe.need_ssldatac C s
| j t k S)zj
Whether a security layer is currently in effect.
Return False during handshake.
)r Ú_WRAPPED)r" r r r Úwrappedl s z_SSLPipe.wrappedc C s— | j t k r t d ƒ ‚ n | j j | j | j d | j d | j ƒ| _ t
| _ | | _ | j d d d ƒ\ } } t
| ƒ d k s“ t ‚ | S)aL Start the SSL handshake.
Return a list of ssldata. A ssldata element is a list of buffers
The optional *callback* argument can be used to install a callback that
will be called when the handshake is complete. The callback will be
called with None if successful, else an exception instance.
z"handshake in progress or completedr
r ó Úonly_handshakeTr )r r Ú RuntimeErrorr Zwrap_bior r r r r Ú
_DO_HANDSHAKEr Ú feed_ssldataÚlenÚAssertionError)r" ÚcallbackÚssldataÚappdatar r r Ú do_handshakeu s z_SSLPipe.do_handshakec C s£ | j t k r t d ƒ ‚ n | j t k r< t d ƒ ‚ n | j t t f k sW t ‚ t | _ | | _ | j d ƒ \ } } | g k sŸ | d g k sŸ t ‚ | S)a1 Start the SSL shutdown sequence.
Return a list of ssldata. A ssldata element is a list of buffers
The optional *callback* argument can be used to install a callback that
will be called when the shutdown is complete. The callback will be
called without arguments.
zno security layer presentzshutdown in progressr) ) r r r+ Ú _SHUTDOWNr' r, r/ r! r- )r" r0 r1 r2 r r r ÚshutdownŠ s !z_SSLPipe.shutdownc C sG | j j ƒ | j d ƒ \ } } | g k sC | d g k sC t ‚ d S)z†Send a potentially "ragged" EOF.
This method will raise an SSL_ERROR_EOF exception if the EOF is
unexpected.
r) N)r Z write_eofr- r/ )r" r1 r2 r r r Úfeed_eofž s
z_SSLPipe.feed_eofFc C s8 | j t k r1 | r! | g } n g } g | f Sd | _ | rS | j j | ƒ n g } g } y | j t k r³ | j j ƒ t | _ | j r | j d ƒ n | r³ | | f Sn | j t k rø x¢ | j j
| j ƒ } | j | ƒ | sÅ PqÅ qÅ Wno | j t
k r?| j j ƒ d | _ t | _ | j rg| j ƒ qgn( | j t k rg| j | j j
ƒ ƒ n Wnž t j t j f k
r} zr t | d d ƒ t j t j t j f k rá| j t k rÛ| j rÛ| j | ƒ n ‚ n | j t j k | _ WYd d } ~ Xn X| j j r.| j | j j
ƒ ƒ n | | f S)a Feed SSL record level data into the pipe.
The data must be a bytes instance. It is OK to send an empty bytes
instance. This can be used to get ssldata for a handshake initiated by
this endpoint.
Return a (ssldata, appdata) tuple. The ssldata element is a list of
buffers containing SSL data that needs to be sent to the remote SSL.
The appdata element is a list of buffers containing plaintext data that
needs to be forwarded to the application. The appdata list may contain
an empty buffer indicating an SSL "close_notify" alert. This alert must
be acknowledged by calling shutdown().
FNÚerrno)r r r r Úwriter, r r3 r' r ÚreadÚmax_sizeÚappendr4 Zunwrapr! r
ÚSSLErrorÚCertificateErrorÚgetattrÚSSL_ERROR_WANT_READÚSSL_ERROR_WANT_WRITEÚSSL_ERROR_SYSCALLr7 r Úpending)r" Údatar* r2 r1 ÚchunkÚexcr r r r- ¨ sV
( z_SSLPipe.feed_ssldatar c C s£ d | k o t | ƒ k n s( t ‚ | j t k ru | t | ƒ k r_ | | d … g } n g } | t | ƒ f Sg } t | ƒ } xd | _ y9 | t | ƒ k rË | | j j | | d … ƒ 7} n Wn‚ t j k
rP} z_ | j
d k rt j | _ n | j t j t j
t j f k r)‚ n | j t j k | _ WYd d } ~ Xn X| j j rv| j | j j ƒ ƒ n | t | ƒ k s‘| j rŠ PqŠ qŠ W| | f S)a Feed plaintext data into the pipe.
Return an (ssldata, offset) tuple. The ssldata element is a list of
buffers containing record level data that needs to be sent to the
remote SSL instance. The offset is the number of plaintext bytes that
were processed, which may be less than the length of data.
NOTE: In case of short writes, this call MUST be retried with the SAME
buffer passed into the *data* argument (i.e. the id() must be the
same). This is an OpenSSL requirement. A further particularity is that
a short write will always have offset == 0, because the _ssl module
does not enable partial writes. And even though the offset is zero,
there will still be encrypted data in ssldata.
r NFZPROTOCOL_IS_SHUTDOWN)r. r/ r r Ú
memoryviewr r r8 r
r< Úreasonr? r7 r@ rA r rB r; r9 )r" rC Úoffsetr1 ZviewrE r r r Ú feed_appdataò s4 ( ' ( z_SSLPipe.feed_appdatai )Ú__name__Ú
__module__Ú __qualname__Ú__doc__r: r$ Úpropertyr# r% r& r( r3 r5 r6 r- rI r r r r r / s
Jr c @ sµ e Z d Z d d „ Z d d d „ Z d d „ Z d d „ Z e j rW d
d „ Z n d d
„ Z
d d „ Z d d d d „ Z d d „ Z
d d „ Z d d „ Z d d „ Z d S)Ú_SSLProtocolTransportc C s( | | _ | | _ | | _ d | _ d S)NF)Ú_loopÚ
_ssl_protocolÚ
_app_protocolÚ_closed)r" ÚloopZ ssl_protocolÚ app_protocolr r r r$ ( s z _SSLProtocolTransport.__init__Nc C s | j j | | ƒ S)z#Get optional transport information.)rQ Ú_get_extra_info)r" ÚnameÚdefaultr r r Úget_extra_info/ s z$_SSLProtocolTransport.get_extra_infoc C s | j S)N)rS )r" r r r Ú
is_closing3 s z _SSLProtocolTransport.is_closingc C s d | _ | j j ƒ d S)a
Close the transport.
Buffered data will be flushed asynchronously. No more data
will be received. After all buffered data is flushed, the
protocol's connection_lost() method will (eventually) called
with None as its argument.
TN)rS rQ Ú_start_shutdown)r" r r r Úclose6 s z_SSLProtocolTransport.closec C s. | j s* t j d | t ƒ | j ƒ n d S)Nzunclosed transport %r)rS ÚwarningsÚwarnÚResourceWarningr\ )r" r r r Ú__del__E s z _SSLProtocolTransport.__del__c C s | j j j ƒ d S)z”Pause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
N)rQ Ú
_transportÚ
pause_reading)r" r r r rb J s z#_SSLProtocolTransport.pause_readingc C s | j j j ƒ d S)z…Resume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
N)rQ ra Úresume_reading)r" r r r rc R s z$_SSLProtocolTransport.resume_readingc C s | j j j | | ƒ d S)a¦ Set the high- and low-water limits for write flow control.
These two values control when to call the protocol's
pause_writing() and resume_writing() methods. If specified,
the low-water limit must be less than or equal to the
high-water limit. Neither value can be negative.
The defaults are implementation-specific. If only the
high-water limit is given, the low-water limit defaults to an
implementation-specific value less than or equal to the
high-water limit. Setting high to zero forces low to zero as
well, and causes pause_writing() to be called whenever the
buffer becomes non-empty. Setting low to zero causes
resume_writing() to be called only once the buffer is empty.
Use of zero for either limit is generally sub-optimal as it
reduces opportunities for doing I/O and computation
concurrently.
N)rQ ra Úset_write_buffer_limits)r" ZhighZlowr r r rd Z s z-_SSLProtocolTransport.set_write_buffer_limitsc C s | j j j ƒ S)z,Return the current size of the write buffer.)rQ ra Úget_write_buffer_size)r" r r r re o s z+_SSLProtocolTransport.get_write_buffer_sizec C sW t | t t t f ƒ s9 t d j t | ƒ j ƒ ƒ ‚ n | sC d S| j j | ƒ d S)zWrite some data bytes to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
z/data: expecting a bytes-like instance, got {!r}N)
Ú
isinstanceÚbytesÚ bytearrayrF Ú TypeErrorÚformatÚtyperJ rQ Ú_write_appdata)r" rC r r r r8 s s z_SSLProtocolTransport.writec C s d S)zAReturn True if this transport supports write_eof(), False if not.Fr )r" r r r Ú
can_write_eof€ s z#_SSLProtocolTransport.can_write_eofc C s | j j ƒ d S)zÝClose the transport immediately.
Buffered data will be lost. No more data will be received.
The protocol's connection_lost() method will (eventually) be
called with None as its argument.
N)rQ Ú_abort)r" r r r Úabort„ s z_SSLProtocolTransport.abort)rJ rK rL r$ rY rZ r\ r ZPY34r` rb rc rd re r8 rm ro r r r r rO % s
rO c @ sñ e Z d Z d Z d d d d „ Z d d d „ Z d d „ Z d
d „ Z d d
„ Z d d „ Z d d „ Z
d d „ Z d d d „ Z d d „ Z
d d „ Z d d „ Z d d „ Z d d „ Z d d! d" „ Z d# d$ „ Z d% d& „ Z d S)'Ú SSLProtocolz‰SSL protocol.
Implementation of SSL on top of a socket using incoming and outgoing
buffers which are ssl.MemoryBIO objects.
FNc C sø t d k r t d ƒ ‚ n | s3 t | | ƒ } n | | _ | rU | rU | | _ n d | _ | | _ t d | ƒ | _ t j ƒ | _
d | _ | | _ | | _
| | _ t | j
| | j ƒ | _ d | _ d | _ d | _ d | _ d | _ d S)Nz stdlib ssl module not availabler r F)r
r+ r r r Ú _sslcontextÚdictÚ_extraÚ collectionsÚdequeÚ_write_backlogÚ_write_buffer_sizeÚ_waiterrP rR rO Ú_app_transportÚ_sslpipeÚ_session_establishedÚ
_in_handshakeÚ _in_shutdownra )r" rT rU r Zwaiterr
r r r r r$ • s,
zSSLProtocol.__init__c C sa | j d k r d S| j j ƒ sT | d k rA | j j | ƒ qT | j j d ƒ n d | _ d S)N)rx Z cancelledZ
set_exceptionZ
set_result)r" rE r r r Ú_wakeup_waiter¸ s zSSLProtocol._wakeup_waiterc C s5 | | _ t | j | j | j ƒ | _ | j ƒ d S)zXCalled when the low-level connection is made.
Start the SSL handshake.
N)ra r rq r r rz Ú_start_handshake)r" Ú transportr r r Úconnection_made s
zSSLProtocol.connection_madec C sD | j r. d | _ | j j | j j | ƒ n d | _ d | _ d S)zÝCalled when the low-level connection is lost or closed.
The argument is an exception object or None (the latter
meaning a regular EOF is received or the connection was
aborted or closed).
FN)r{ rP Ú call_soonrR Úconnection_lostra ry )r" rE r r r rƒ Í s
zSSLProtocol.connection_lostc C s | j j ƒ d S)z\Called when the low-level transport's buffer goes over
the high-water mark.
N)rR Ú
pause_writing)r" r r r r„ Ú s zSSLProtocol.pause_writingc C s | j j ƒ d S)z^Called when the low-level transport's buffer drains below
the low-water mark.
N)rR Úresume_writing)r" r r r r… à s zSSLProtocol.resume_writingc C sÝ y | j j | ƒ \ } } Wnd t j k
r‚ } zA | j j ƒ rb t j d | | j | j ƒ n | j
ƒ d SWYd d } ~ Xn Xx | D] } | j j | ƒ qŠ Wx2 | D]* } | rÊ | j
j | ƒ q« | j ƒ Pq« Wd S)zXCalled when some SSL data is received.
The argument is a bytes object.
z %r: SSL error %s (reason %s)N)rz r- r
r< rP Ú get_debugr Úwarningr7 rG rn ra r8 rR Ú
data_receivedr[ )r" rC r1 r2 ÚerD r r r rˆ æ s
zSSLProtocol.data_receivedc
C sy zd | j j ƒ r% t j d | ƒ n | j t ƒ | j sc | j j ƒ } | rc t j d ƒ qc n Wd | j
j ƒ Xd S)a Called when the other end of the low-level stream
is half-closed.
If this returns a false value (including None), the transport
will close itself. If it returns a true value, closing the
transport is up to the protocol.
z%r received EOFz?returning true from eof_received() has no effect when using sslN) rP r† r Údebugr~ ÚConnectionResetErrorr| rR Ú eof_receivedr‡ ra r\ )r" Z keep_openr r r rŒ þ s
zSSLProtocol.eof_receivedc C s1 | | j k r | j | S| j j | | ƒ Sd S)N)rs ra rY )r" rW rX r r r rV s zSSLProtocol._get_extra_infoc C s' | j r
d Sd | _ | j d ƒ d S)NTr) )r} rl )r" r r r r[ s zSSLProtocol._start_shutdownc C s9 | j j | d f ƒ | j t | ƒ 7_ | j ƒ d S)Nr )rv r; rw r. Ú_process_write_backlog)r" rC r r r rl s zSSLProtocol._write_appdatac C sm | j j ƒ r4 t j d | ƒ | j j ƒ | _ n d | _ d | _ | j j d ƒ | j j | j
ƒ d S)Nz%r starts SSL handshakeTr) r )r) r ) rP r† r rŠ ÚtimeÚ_handshake_start_timer| rv r; r‚ r )r" r r r r % s z SSLProtocol._start_handshakec C sÛ d | _ | j j } yn | d k r- | ‚ n | j ƒ } t | j d ƒ s‚ | j r‚ | j j t j k r‚ t j
| | j ƒ q‚ n Wn¨ t k
r-} zˆ | j j
ƒ rë t | t j ƒ rÒ t j d | d d ƒqë t j d | d d ƒn | j j ƒ t | t ƒ r| j | ƒ d S‚ WYd d } ~ Xn X| j j
ƒ rm| j j ƒ | j } t j d | | d ƒ n | j j d | d
| j ƒ d | j ƒ d | ƒ | j j | j ƒ | j ƒ d | _ | j j! | j" ƒ d S)
NFr z5%r: SSL handshake failed on verifying the certificateÚexc_infoTz%r: SSL handshake failedz %r: SSL handshake took %.1f msg @@ÚpeercertÚcipherÚ compressionr% )#r| rz r% Z getpeercertr rq r r r
Z CERT_NONEZmatch_hostnameÚ
BaseExceptionrP r† rf r= r r‡ ra r\ Ú Exceptionr~ rŽ r rŠ rs Úupdater’ r“ rR r ry r{ r‚ r )r" Z
handshake_excZsslobjr‘ rE Zdtr r r Ú_on_handshake_complete1 sB
z"SSLProtocol._on_handshake_completec C s® | j d k r d Sy1x*t t | j ƒ ƒ D]} | j d \ } } | ri | j j | | ƒ \ } } n? | r | j j | j ƒ } d } n | j j | j ƒ } d } x | D] } | j j
| ƒ q¯ W| t | ƒ k r | | f | j d <| j j s t ‚ | j j
r | j j ƒ n Pn | j d =| j t | ƒ 8_ q, WWnc t k
r©} zC | j rr| j | ƒ n | j | d ƒ t | t ƒ s—‚ n WYd d } ~ Xn Xd S)Nr r z Fatal error on SSL transport)ra Úranger. rv rz rI r3 r— r5 Ú _finalizer8 r& r/ Z_pausedrc rw r” r| Ú _fatal_errorrf r• )r" ÚirC rH r1 rD rE r r r r d s:
z"SSLProtocol._process_write_backlogzFatal error on transportc C s’ t | t t f ƒ rC | j j ƒ rr t j d | | d d ƒqr n/ | j j i | d 6| d 6| j d 6| d 6ƒ | j rŽ | j j | ƒ n d S)Nz%r: %sr TÚmessageZ exceptionr€ Zprotocol)
rf ÚBrokenPipeErrorr‹ rP r† r rŠ Zcall_exception_handlerra Z _force_close)r" rE rœ r r r rš s
zSSLProtocol._fatal_errorc C s# | j d k r | j j ƒ n d S)N)ra r\ )r" r r r r™ Ÿ s zSSLProtocol._finalizec
C s5 | j d k r1 z | j j ƒ Wd | j ƒ Xn d S)N)ra ro r™ )r" r r r rn £ s zSSLProtocol._abort)rJ rK rL rM r$ r~ r rƒ r„ r… rˆ rŒ rV r[ rl r r— r rš r™ rn r r r r rp Ž s$ "
3 , rp )rt r] r
Ú ImportErrorÚ r r r Úlogr r r r r, r' r4 Úobjectr Z_FlowControlMixinZ TransportrO ZProtocolrp r r r r Ú s&
ö h