Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

a

XC?hCk�@s�dd
lZdd
l
Z
zdd
lZWney2


d
ZYn0ddlmZ
ddlmZ
ddlmZ
ddlm	Z	
dd�Z
d	Zd
ZdZ
dZGd
d�de�ZGdd�dejej�ZGdd�dej�Zd
S)�N�
)
�	constants)
�	protocols)
�
transports)
�loggercCs"|rtd
�
�
t
��}|
sd|_|S)Nz(Server side SSL needs a valid SSLContextF)�
ValueError�sslZcreate_default_contextZcheck_hostname)�server_side�server_hostname�
sslcontext�r�5/opt/alt/python39/lib64/python3.9/asyncio/sslproto.py�_create_transport_contexts




rZ	UNWRAPPEDZDO_HANDSHAKEZWRAPPEDZSHUTDOWNc@s~eZ
dZd
ZdZddd�
Zedd��
Zedd	��
Zed
d��
Z	edd
��
Z
ddd�
Zddd�
Zdd�Z
ddd�
Zddd�
ZdS)�_SSLPipeaAn 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().
    iNcCsH|
|_||_
||_t|_t��|_t��|_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�_staterZ	MemoryBIO�	_incoming�	_outgoing�_sslobj�
_need_ssldata�
_handshake_cb�_shutdown_cb)�self�contextr	r
rrr
�__init__7s










z_SSLPipe.__init__c


Cs|jS)
z*The SSL context passed to the constructor.)
r�
rrrr
rMsz_SSLPipe.contextc


Cs|jS)
z^The internal ssl.SSLObject instance.

        Return None if the pipe is not wrapped.
        )
rrrrr
�
ssl_objectRsz_SSLPipe.ssl_objectc


Cs|jS)
zgWhether more record level data is needed to complete a handshake
        that is currently in progress.)
rrrrr
�need_ssldataZsz_SSLPipe.need_ssldatac

Cs
|jt
kS)
zj
        Whether a security layer is currently in effect.

        Return False during handshake.
        )r�_WRAPPEDrrrr
�wrapped`sz_SSLPipe.wrappedcCsb|jt
krtd
�
�
|jj|j|j|j|jd�|_	t
|_|
|_|jddd�\}}t
|�
dks^J�
|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 completed)r	r
�T)
�only_handshaker
)rr�RuntimeErrorrZwrap_biorrrrr�
_DO_HANDSHAKEr�feed_ssldata�len�r�callback�ssldata�appdatarrr
�do_handshakeis	





�



z_SSLPipe.do_handshakecCsj|jt
krtd
�
�
|jtkr$td�
�
|jttfvs6J�
t|_|
|_|�d�
\}}|gksf|dg
ksfJ�
|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#)rrr%�	_SHUTDOWNr!r&rr'r)rrr
�shutdown~s	










z_SSLPipe.shutdownc
Cs2|j�
�
|�d
�
\}
}|gks.|d
g
ks.J�
dS)z�Send a potentially "ragged" EOF.

        This method will raise an SSL_ERROR_EOF exception if the EOF is
        unexpected.
        r#N)rZ	write_eofr')rr+r,rrr
�feed_eof�s


z_SSLPipe.feed_eofFc
Cs�
|jt
kr"|
r|
g
}ng}g|fSd
|_|
r8|j�|
�

g}g}z�|jtkrz|j��
t|_|j	rl|�	d�

|rz||fWS|jtkr�|j�
|j�
}|�|�

|s�q�q�nJ|jt
kr�|j��
d|_t
|_|jr�|��
n|jt
kr�|�|j�
��

Wn|tjtjf�
yn
}
zZt|dd�}|tjtjtjfv
�
rN|jtk�
rL|j	�
rL|�	|�

�|tjk|_WYd}~n
d}~00|jj�
r�|�|j�
��

||fS)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)rrrr�writer&rr-r!r�read�max_size�appendr.Zunwraprr�SSLError�CertificateError�getattr�SSL_ERROR_WANT_READ�SSL_ERROR_WANT_WRITE�SSL_ERROR_SYSCALLr�pending)r�datar$r,r+�chunk�exc�	exc_errnorrr
r'�sX


































�



"


z_SSLPipe.feed_ssldatar
c
Cs6
d
|k
rt|
�
k
sn
J�
|j
tkrT|t|
�
krD|
|d�g
}ng}|t|
�
fSg}t|
�
}d|_z(|t|�
kr�||j�||d��
7}Wnjtjy�
}
zPt	|dd�}|j
dkr�tj}|_|tjtj
tjfv
r؂|tjk|_WYd}~n
d}~00|jj�
r|�|j���

|t|�
k�
s.|jr`�
q.q`||fS)aFeed 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
NFr1ZPROTOCOL_IS_SHUTDOWN)r(rr�
memoryviewrrr2rr6r8�reasonr9r1r:r;rr<r5r3)rr=�offsetr+Zviewr?r@rrr
�feed_appdata�s6














�
"




z_SSLPipe.feed_appdata)
N)
N)
N)
F)
r
)�__name__�
__module__�__qualname__�__doc__r4r�propertyrrr r"r-r/r0r'rDrrrr
r#s 













Krc@s�eZ
dZejjZd
d�Zd$dd�
Zdd�Z	dd	�Z
d
d�Zdd
�Ze
jf
dd�
Zdd�Zdd�Zdd�Zd%dd�
Zdd�Zdd�Zedd��
Zdd�Zd d!�Zd"d#�ZdS)&�_SSLProtocolTransportcCs|
|_||_
d
|_dS)NF)�_loop�
_ssl_protocol�_closed)r�loopZssl_protocolrrr
r 
s

z_SSLProtocolTransport.__init__NcCs|j�
|
|�S)
z#Get optional transport information.)rL�_get_extra_info�r�name�defaultrrr
�get_extra_info&
sz$_SSLProtocolTransport.get_extra_infocCs|j�
|
�

dS�
N)rL�_set_app_protocol)r�protocolrrr
�set_protocol*
s
z"_SSLProtocolTransport.set_protocolc


Cs|jj
SrT)rL�
_app_protocolrrrr
�get_protocol-
s
z"_SSLProtocolTransport.get_protocolc


Cs|jSrT)
rMrrrr
�
is_closing0
s
z _SSLProtocolTransport.is_closingc

Csd
|_|j
��
dS)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)rMrL�_start_shutdownrrrr
�close3
s
z_SSLProtocolTransport.closecCs&|js"|
d
|��t
|d�
|��
dS)Nzunclosed transport )
�source)rM�ResourceWarningr\)rZ_warnrrr
�__del__>
s


z_SSLProtocolTransport.__del__c
Cs |jj
}
|
durtd
�
�
|
��S)Nz*SSL transport has not been initialized yet)rL�
_transportr%�
is_reading)rZtrrrr
raC
s



z _SSLProtocolTransport.is_readingc

Cs|jj
��
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)rLr`�
pause_readingrrrr
rbI
sz#_SSLProtocolTransport.pause_readingc

Cs|jj
��
d
S)z�Resume the receiving end.

        Data received will once again be passed to the protocol's
        data_received() method.
        N)rLr`�resume_readingrrrr
rcQ
sz$_SSLProtocolTransport.resume_readingcCs|jj
�|
|�
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)rLr`�set_write_buffer_limits)rZhighZlowrrr
rdY
sz-_SSLProtocolTransport.set_write_buffer_limitsc

Cs|jj
��S)
z,Return the current size of the write buffer.)rLr`�get_write_buffer_sizerrrr
ren
sz+_SSLProtocolTransport.get_write_buffer_sizec

Cs|jj
��S)
z�Get the high and low watermarks for write flow control. 
        Return a tuple (low, high) where low and high are 
        positive number of bytes.)rLr`�get_write_buffer_limitsrrrr
rfr
sz-_SSLProtocolTransport.get_write_buffer_limitsc


Cs
|jj
jSrT)rLr`�_protocol_pausedrrrr
rgx
sz&_SSLProtocolTransport._protocol_pausedcCs<t|
t
ttf�s$td
t|
�
j���
�
|
s,dS|j�|
�

dS)z�Write 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 N)	�
isinstance�bytes�	bytearrayrA�	TypeError�typerErL�_write_appdata�rr=rrr
r2}
s

�

z_SSLProtocolTransport.writec


Csd
S)zAReturn True if this transport supports write_eof(), False if not.Frrrrr
�
can_write_eof�
sz#_SSLProtocolTransport.can_write_eofc

Cs|j�
�
d
|_dS)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.
        TN)rL�_abortrMrrrr
�abort�
s

z_SSLProtocolTransport.abort)
N)NN)rErFrGrZ
_SendfileModeZFALLBACKZ_sendfile_compatiblerrSrWrYrZr\�warnings�warnr_rarbrcrdrerfrIrgr2rorqrrrr
rJ
s&




rJc@s�eZ
dZd
Zd,dd�
Zdd�Zd-d	d
�
Zdd�Zd
d�Zdd�Z	dd�Z
dd�Zdd�Zd.dd�
Z
dd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd/d&d'�
Zd(d)�Zd*d+�ZdS)0�SSLProtocolz�SSL protocol.

    Implementation of SSL on top of a socket using incoming and outgoing
    buffers which are ssl.MemoryBIO objects.
    FNTc		Cs�tdurt
d
�
�
|dur tj}n|dk
r6td|���
�
|sDt||�}||_|rZ|sZ||_nd|_||_t	|d�
|_
t��|_
d|_||_|
|_|�|�

t|j|�|_d|_d|_d|_d|_d|_||_||_dS)Nzstdlib ssl module not availabler
z7ssl_handshake_timeout should be a positive number, got )
rF)rr%rZSSL_HANDSHAKE_TIMEOUTrrrr�_sslcontext�dict�_extra�collections�deque�_write_backlog�_write_buffer_size�_waiterrKrUrJ�_app_transport�_sslpipe�_session_established�
_in_handshake�_in_shutdownr`�_call_connection_made�_ssl_handshake_timeout)	rrN�app_protocolrZwaiterr	r
Zcall_connection_madeZssl_handshake_timeoutrrr
r�
sB





��

�













zSSLProtocol.__init__cCs|
|_t
|
tj�|_dSrT)rXrhrZBufferedProtocol�_app_protocol_is_buffer)rr�rrr
rU�
s

�zSSLProtocol._set_app_protocolcCsD|jdurdS|j�
�s:|
du
r.|j�|
�

n|j�d�

d|_dSrT)r|Z	cancelledZ
set_exceptionZ
set_result�rr?rrr
�_wakeup_waiter�
s







zSSLProtocol._wakeup_waitercCs&|
|_t
|j|j|j�|_|��
d
S)zXCalled when the low-level connection is made.

        Start the SSL handshake.
        N)r`rrurrr~�_start_handshake)r�	transportrrr
�connection_made�
s


�zSSLProtocol.connection_madecCsn|jr d
|_|j
�|jj|
�
n|jdu
r2d|j_d|_d|_t|dd�rT|j	�
�
|�|
�

d|_d|_dS)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).
        FNT�_handshake_timeout_handle)
rrK�	call_soonrX�connection_lostr}rMr`r8r��cancelr�r~r�rrr
r��
s












zSSLProtocol.connection_lostc

Cs|j�
�
d
S)z\Called when the low-level transport's buffer goes over
        the high-water mark.
        N)rX�
pause_writingrrrr
r�szSSLProtocol.pause_writingc

Cs|j�
�
d
S)z^Called when the low-level transport's buffer drains below
        the low-water mark.
        N)rX�resume_writingrrrr
r�szSSLProtocol.resume_writingcCs
|jd
urd
Sz|j�
|
�
\}}WnHttfy:


�Yn2tyj
}
z|�|d�
WYd
}~d
Sd
}~00|D]}|j�|�

qp|D]�}|�
rz&|jr�t	�
|j|�
n|j�|�

WnLttfy�


�Yn6t�
y
}
z|�|d�
WYd
}~
d
Sd
}~00q�|�
�

�
qq�d
S)zXCalled when some SSL data is received.

        The argument is a bytes object.
        NzSSL error in data receivedz/application protocol failed to receive SSL data)r~r'�
SystemExit�KeyboardInterrupt�
BaseException�_fatal_errorr`r2r�rZ_feed_data_to_buffered_protorX�
data_receivedr[)rr=r+r,�
er>Zexrrr
r�s8












�




�
zSSLProtocol.data_receivedc
Cs^zL|j�
�rt�d
|�
|�t�

|js@|j��}
|
r@t�	d�

W|j
��
n|j
��
0dS)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)rK�	get_debugr�debugr��ConnectionResetErrorr�rX�eof_receivedZwarningr`r\)rZ	keep_openrrr
r�2s







zSSLProtocol.eof_receivedcCs4|
|jvr|j|
S|j
du
r,|j
�|
|�S|SdSrT)rwr`rSrPrrr
rOHs







zSSLProtocol._get_extra_infoc

Cs.|jr
dS|j
r|��
nd
|_|�d�

dS)NTr#)r�r�rprmrrrr
r[Ps





zSSLProtocol._start_shutdowncCs.|j�
|
d
f�

|jt|
�
7_|��
dS)Nr
)rzr5r{r(�_process_write_backlogrnrrr
rmYs


zSSLProtocol._write_appdatac

Cs\|j�
�r$t�d
|�
|j��|_nd|_d|_|j�d�

|j�	|j
|j�|_|�
�
dS)Nz%r starts SSL handshakeT)r#r)rKr�rr��time�_handshake_start_timer�rzr5Z
call_laterr��_check_handshake_timeoutr�r�rrrr
r�^s






��zSSLProtocol._start_handshakec
Cs*|jd
ur&d|j
�d�}
|�t|
�
�

dS)NTz$SSL handshake is taking longer than z! seconds: aborting the connection)r�r�r��ConnectionAbortedError)r�msgrrr
r�ms


��z$SSLProtocol._check_handshake_timeoutc
Cs
d
|_|j
��
|jj}z|
du
r&|
�
|��}Wn^ttfyH


�YnHty�
}
z0t	|t
j�rhd}nd}|�||�
WYd}~dSd}~00|j
��r�|j
��|j}t�d||d�
|jj||��|��|d�
|jr�|j�|j�

|��
d|_|j
�|j�

dS)NFz1SSL handshake failed on verifying the certificatezSSL handshake failedz%r: SSL handshake took %.1f msg@�@)�peercert�cipher�compressionrT)r�r�r�r~rZgetpeercertr�r�r�rhrr7r�rKr�r�r�rr�rw�updater�r�r�rXr�r}r�rr�r�)rZ
handshake_excZsslobjr�r?r�Zdtrrr
�_on_handshake_completevs8


















�


z"SSLProtocol._on_handshake_completec

CsP
|jdus|j
durdSz�tt|j�
�
D]�}
|jd
\}}|rR|j
�||�\}}n*|rj|j
�|j�
}d}n|j
�|j	�
}d}|D]}|j�
|�

q�|t|�
kr�||f|jd
<|j
js�J�
|jjr�|j�
�

q�|jd
=|jt|�
8_q(Wn^ttf�
y


�YnFt�
yJ
}
z,|j�
r*|�|�

n|�|d�
WYd}~n
d}~00dS)Nr
rzFatal error on SSL transport)r`r~�ranger(rzrDr-r�r/�	_finalizer2r Z_pausedrcr{r�r�r�r�r�)r�
ir=rCr+r>r?rrr
r��s<







�











z"SSLProtocol._process_write_backlog�Fatal error on transportcCsVt|
t
�r(|j��r@tjd
||dd�
n|j�||
|j|d��

|jrR|j�|
�

dS)Nz%r: %sT)
�exc_info)�messageZ	exceptionr�rV)	rh�OSErrorrKr�rr�Zcall_exception_handlerr`Z_force_close)rr?r�rrr
r��s








�
zSSLProtocol._fatal_errorc

Csd|_|j
du
r|j
��
dSrT)r~r`r\rrrr
r��s


zSSLProtocol._finalizec

Cs0z |jdu
r|j�
�
W|��
n
|��
0dSrT)r`rqr�rrrr
rp�s



zSSLProtocol._abort)FNTN)
N)
N)
r�)rErFrGrHrrUr�r�r�r�r�r�r�rOr[rmr�r�r�r�r�r�rprrrr
rt�
s.


�
.

&
		)+
rt)rxrrr�ImportError�rrr�logrrrr&r!r.�objectrZ_FlowControlMixinZ	TransportrJ�Protocolrtrrrr
�<module>
s(











y
�~