File: //usr/local/CyberCP/lib/python3.10/site-packages/paramiko/__pycache__/packet.cpython-310.pyc
o
�h�V � @ s� d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m
Z
ddl m Z m
Z
mZmZmZmZmZ ddlmZ ddlmZmZ ddlmZ d d
� ZG d d � d e�Z d
d� Z G dd� d�Z dS )z
Packet handling
� N)�HMAC)�util)�
linefeed_byte�
cr_byte_value� MSG_NAMES�DEBUG� xffffffff� zero_byte�byte_ord)�u)� SSHException�ProxyCommandFailure)�Messagec C s t | ||��� S �N)r �digest)�key�message� digest_class� r �B/usr/local/CyberCP/lib/python3.10/site-packages/paramiko/packet.py� compute_hmac. s r c @ s e Zd ZdZdS )�NeedRekeyExceptionz1
Exception indicating a rekey is needed.
N)�__name__�
__module__� __qualname__�__doc__r r r r r 2 s r c C s. d }t | j�tu rt| j�dkr| jd }|S �Nr )�type�args�tuple�len)�e�argr r r � first_arg: s
r# c @ s8 e Zd ZdZedd�Zedd�Zedd�Zedd�Zdd� Z e
dd� �Z dd � Z d
d � Z
d d
� Z dBdd�Z dCdd�Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Z d+d,� Z dCd-d.�Z d/d0� Z d1d2� Z d3d4� Z!d5d6� Z"d7d8� Z#d9d:� Z$d;d<� Z%d=d>� Z&d?d@� Z'dAS )D�
Packetizerz9
Implementation of the base SSH packet protocol.
� � c C s� || _ d | _d| _d| _d| _d| _t� | _d| _d| _ d| _
d| _ d| _ d| _
d| _d| _d| _d| _d| _d | _d | _d| _d | _d | _t� | _t� | _d | _d | _d| _ d| _ d| _ d| _ t �!� | _"d| _#t$�$� | _%d | _&d | _'d| _(d| _)d S )NFr � )*�_Packetizer__socket�_Packetizer__logger�_Packetizer__closed�_Packetizer__dump_packets�_Packetizer__need_rekey�_Packetizer__init_count�bytes�_Packetizer__remainder�_initial_kex_done�_Packetizer__sent_bytes�_Packetizer__sent_packets�_Packetizer__received_bytes� _Packetizer__received_packets�$_Packetizer__received_bytes_overflow�&_Packetizer__received_packets_overflow�_Packetizer__block_size_out�_Packetizer__block_size_in�_Packetizer__mac_size_out�_Packetizer__mac_size_in� _Packetizer__block_engine_out� _Packetizer__block_engine_in�_Packetizer__sdctr_out�_Packetizer__mac_engine_out�_Packetizer__mac_engine_in�_Packetizer__mac_key_out�_Packetizer__mac_key_in� _Packetizer__compress_engine_out� _Packetizer__compress_engine_in� _Packetizer__sequence_number_out� _Packetizer__sequence_number_in�_Packetizer__etm_out�_Packetizer__etm_in� threading�RLock�_Packetizer__write_lock� _Packetizer__keepalive_interval�time�_Packetizer__keepalive_last� _Packetizer__keepalive_callback�_Packetizer__timer� _Packetizer__handshake_complete�_Packetizer__timer_expired)�self�socketr r r �__init__Q sL
zPacketizer.__init__c C � | j S r )r* �rR r r r �closed� s zPacketizer.closedc C �
d| _ d S r )rD rV r r r �reset_seqno_out� �
zPacketizer.reset_seqno_outc C rX r )rE rV r r r �reset_seqno_in� rZ zPacketizer.reset_seqno_inc C s
|| _ dS )z?
Set the Python log object to use for logging.
N)r) )rR �logr r r �set_log� s
zPacketizer.set_logFc C sb || _ || _|| _|| _|| _|| _d| _d| _|| _| j dO _ | j dkr/d| _ d| _
dS dS )zd
Switch outbound data cipher.
:param etm: Set encrypt-then-mac from OpenSSH
r � � FN) r; r= r7 r> r9 r@ r1 r2 rF r- r, )rR � block_engine�
block_size�
mac_engine�mac_size�mac_key�sdctr�etmr r r �set_outbound_cipher� s
�z Packetizer.set_outbound_cipherc C sh || _ || _|| _|| _|| _d| _d| _d| _d| _|| _ | j
dO _
| j
dkr2d| _
d| _ dS dS )zc
Switch inbound data cipher.
:param etm: Set encrypt-then-mac from OpenSSH
r r% r_ FN) r< r8 r? r: rA r3 r4 r5 r6 rG r- r, )rR r` ra rb rc rd rf r r r �set_inbound_cipher� s
�z Packetizer.set_inbound_cipherc C �
|| _ d S r )rB �rR �
compressorr r r �set_outbound_compressor� rZ z"Packetizer.set_outbound_compressorc C ri r )rC rj r r r �set_inbound_compressor� rZ z!Packetizer.set_inbound_compressorc C s d| _ | j�� d S �NT)r* r( �closerV r r r ro � s zPacketizer.closec C ri r �r+ )rR �hexdumpr r r � set_hexdump� rZ zPacketizer.set_hexdumpc C rU r rp rV r r r � get_hexdump� � zPacketizer.get_hexdumpc C rU r )r: rV r r r �get_mac_size_in� rt zPacketizer.get_mac_size_inc C rU r )r9 rV r r r �get_mac_size_out� rt zPacketizer.get_mac_size_outc C rU )z�
Returns ``True`` if a new set of keys needs to be negotiated. This
will be triggered during a packet read or write, so it should be
checked after every read or write, or at least after every few.
�r, rV r r r �
need_rekey� s zPacketizer.need_rekeyc C s || _ || _t�� | _dS )z�
Turn on/off the callback keepalive. If ``interval`` seconds pass with
no data read from or written to the socket, the callback will be
executed and the timer will be reset.
N)rK rN rL rM )rR �interval�callbackr r r �
set_keepalive� s zPacketizer.set_keepalivec C rX rn )rQ rV r r r �
read_timer� rZ zPacketizer.read_timerc C s, | j st�t|�| j�| _ | j �� dS dS )z�
Tells `Packetizer` that the handshake process started.
Starts a book keeping timer that can signal a timeout in the
handshake process.
:param float timeout: amount of seconds to wait before timing out
N)rO rH �Timer�floatr| �start)rR �timeoutr r r �start_handshake� s �zPacketizer.start_handshakec C s | j sdS | jr
dS | jS )aR
Checks if the handshake has timed out.
If `start_handshake` wasn't called before the call to this function,
the return value will always be `False`. If the handshake completed
before a timeout was reached, the return value will be `False`
:return: handshake time out status, as a `bool`
F)rO rP rQ rV r r r �handshake_timed_out s
z Packetizer.handshake_timed_outc C s$ | j r| j �� d| _d| _dS dS )zF
Tells `Packetizer` that the handshake has completed.
FTN)rO �cancelrQ rP rV r r r �complete_handshake s
�z Packetizer.complete_handshakec
C s2 t � }t| j�dkr | jd|� }| j|d� | _|t|�8 }|dkr�d}| �� r,t� �z| j�|�}t|�dkr<t� �||7 }|t|�8 }W n1 tjyS d}Y n& tj yx } zt
|�}|t j krgd}n| j
rmt� �� W Y d}~nd}~ww |r�| j
r�t� �|r�t|�dkr�| jr�t� �| �� |dks#|S )a&
Read as close to N bytes as possible, blocking as long as necessary.
:param int n: number of bytes to read
:return: the data read, as a `str`
:raises:
``EOFError`` -- if the socket was closed before all the bytes could
be read
r NFT)r. r r/ r� �EOFErrorr( �recvrS r� �errorr# �errno�EAGAINr* r, r �_check_keepalive)rR �n� check_rekey�out� got_timeout�xr! r" r r r �read_all sF
��� � zPacketizer.read_allc
C s t � � | _d}t|�dkr�d}z| j�|�}W n= tjy# d}Y n2 tjyC } zt|�}|t j
kr7d}nd}W Y d }~nd }~w t yJ � t yT d}Y nw |r_d}| j
r^d}n|dkri|dkrid}|d7 }|dk rtt� �|t|�kr} d S ||d � }t|�dks
d S )Nr FT����
r^ )rL rM r r( �sendrS r� r� r# r� r� r
� Exceptionr* r� )rR r� �#iteration_with_zero_as_return_value� retry_writer� r! r" r r r � write_allN sF
� �� � �#zPacketizer.write_allc C sx | j }t|vr|| �|�7 }t|vs|�t�}||d d� | _ |d|� }t|�dkr8|d tkr8|dd� }t|�S )z�
Read a line from the socket. We assume no data is pending after the
line, so it's okay to attempt large reads.
r^ Nr r� )r/ r �
_read_timeout�indexr r r )rR r� �bufr� r r r �readlinev s �
zPacketizer.readlinec C s� |� � }t|d �}|tv rt| }nd�|�}t|�}| j�� z�| jdur,| �|�}| �|�}| j rH| �
t d�||�� | �
t t �
|d�� | jdurh| jra|dd� | j�|dd� � }n | j�|�}n|}| jdur�t�d| j�}|| jr||n| }|t| j|| j�d| j� 7 }| jd t@ } | dkr�| js�td ��| | _| �|� | j t|�7 _ | j d7 _ | j | j kp�| j | j k}
|
r�| j s�d
} | �
t | �| j | j �� d| _!d| _"| �#� W | j�$� dS W | j�$� dS W | j�$� dS | j�$� w ) zR
Write a block of data using the current cipher, as an SSH block.
r �${:x}Nz Write packet <{}>, length {}zOUT: � �>Ir^ �/Sequence number rolled over during initial kex!z(Rekeying (hit {} packets, {} bytes sent))%�asbytesr
r �formatr rJ �acquirerB �
_build_packetr+ �_logr r �
format_binaryr; rF �update�struct�packrD r r@ r> r9 r r0 r r� r1 r2 �
REKEY_PACKETS� REKEY_BYTESr, r5 r6 �_trigger_rekey�release) rR �data�cmd�cmd_name�orig_len�packetr� �packed�payload�next_seq�
sent_too_much�msgr r r � send_message� sr
�
�
���
�
�
�
�
zPacketizer.send_messagec C s� | j | jdd�}| jrVt�d|dd� �d }|| j d }|dd� | j |dd� }| j | jdd�}t�d| j|�| }t| j || j
�d| j� }t � ||�sTt
d ��|}| jdura| j�|�}| jrn| �tt �|d
�� | jrt|}nPt�d|dd� �d }|dd� }|t|� | j dkr�t
d ��| � || j t|� �} | d|t|� � }| |t|� d� }
| jdur�| j�|�}|| }| jr�| �tt �|d
�� | jdk�r| j�s|
d| j� }t�d| j|�| }t| j || j
�d| j� }t � ||��st
d ��t|d �} |d || � } | j�r | �td
�|| �� | jdu�r+| �| �} t| d d� �}
| j|
_| jd t@ }|dk�rK| j�sKt
d��|| _|| j d }| j |7 _ | j d 7 _ | j �r�| j |7 _ | j d 7 _ | j | j!k�s�| j | j"k�r�t
d��n&| j | j#k�s�| j | j$k�r�d}| �t|�| j | j �� d| _ d| _ | �%� t| d �}|t&v �r�t&| }nd�|�}| j�r�| �td�|t| ��� ||
fS )z�
Only one thread should ever be in this function (no other locking is
done).
:raises: `.SSHException` -- if the packet is mangled
:raises: `.NeedRekeyException` -- if the transport should rekey
T)r� r� Nr� r Fz>IIzMismatched MACzIN: zInvalid packet blockingr^ z"Got payload ({} bytes, {} padding)r� z+Remote transport is ignoring rekey requestsz,Rekeying (hit {} packets, {} bytes received)r� zRead packet <{}>, length {})'r� r8 rG r� �unpackr: r� rE r rA r? r �constant_time_bytes_eqr r< r� r+ r� r r� r r
r� rC r �seqnor r0 r3 r4 r, r5 r6 �REKEY_PACKETS_OVERFLOW_MAX�REKEY_BYTES_OVERFLOW_MAXr� r� r� r )rR �header� packet_size� remainingr� �mac� mac_payload�my_mac�leftoverr� � post_packet�paddingr� r� r� �raw_packet_size�errr� r� r r r � read_message� s� ��
��
�
��
�� ��
�����
�zPacketizer.read_messagec C sJ | j d u rd S tt|�t�r |D ] }| j �||� qd S | j �||� d S r )r) �
issubclassr �listr\ )rR �levelr� �mr r r r� N s
�zPacketizer._logc C sD | j r | jr | jr d S t�� }|| j| j kr | �� || _d S d S r )rK r; r, rL rM rN )rR �nowr r r r� W s ���
�zPacketizer._check_keepalivec C sn t � � } z| j�d�}t|�dkrt� �W |S tjy! Y nw | jr(t� �t � � }|| |kr6t�� �q)NT� r )rL r( r� r r� rS r� r* )rR r� r r� r� r r r r� d s" �� �zPacketizer._read_timeoutc C s� | j }| jrdnd}d| t|�| | }t�dt|�| d |�}||7 }| js/| jd u r7|t| 7 }|S |t� |�7 }|S )Nr� r' r_ z>IBr^ )
r7 rF r r� r� r= r; r �os�urandom)rR r� �bsize�addlenr� r� r r r r� u s �zPacketizer._build_packetc C rX rn rw rV r r r r� � s
zPacketizer._trigger_rekeyN)FF)F)(r r r r �powr� r� r� r� rT �propertyrW rY r[ r] rg rh rl rm ro rr rs ru rv rx r{ r| r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r$ A sR
1
�%
�
0(B
r$ ) r r� r� rS r� rH rL �hmacr �paramikor �paramiko.commonr r r r r r r
�
paramiko.utilr �paramiko.ssh_exceptionr r
�paramiko.messager r r� r r# r$ r r r r �<module> s" $