HEX
Server: Apache
System: Linux scp1.abinfocom.com 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64
User: confeduphaar (1010)
PHP: 8.1.33
Disabled: exec,passthru,shell_exec,system
$ pwd: /proc/self/root/lib/python3/dist-packages/twisted/conch/ssh/__pycache__/
Upload Files
File: //proc/self/root/lib/python3/dist-packages/twisted/conch/ssh/__pycache__/transport.cpython-38.pyc
U

s�@g��@s|dZddlmZmZddlZddlZddlZddlZddlm	Z	m
Z
mZmZm
Z
ddlmZddlmZddlmZmZmZddlmZdd	lmZdd
lmZmZddlmZm Z ddl!m"Z"m#Z$m%Z%dd
l&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1dd�Z2dd�Z3Gdd�de4�Z5Gdd�d�Z6dd�Z7Gdd�dej8�Z9Gdd�de9�Z:Gdd�de9�Z;Gdd �d e<�Z=Gd!d"�d"e<�Z>Gd#d$�d$e<�Z?e)�@d%�\ZAZBd&ZCd'ZDd(ZEd)ZFd*ZGd+ZHd,ZId-ZJd.ZKd/ZLd.ZMd0ZNd/ZOd1ZPd2ZQd&ZRd'ZSd(ZTd)ZUd*ZVd+ZWd3ZXd4ZYd5ZZd6Z[d7Z\d8Z]d9Z^d:Z_d;Z`iZaebec��d��D]*\ZeZfee�gd<��r0ee�gd=��s0eeeaef<�q0d>eak�spd?eak�rxehd@��dS)Az�
The lowest level SSH protocol.  This handles the key negotiation, the
encryption and the compression.  The transport layer is described in
RFC 4253.

Maintainer: Paul Swartz
�)�absolute_import�divisionN)�md5�sha1�sha256�sha384�sha512)�UnsupportedAlgorithm)�default_backend)�
algorithms�modes�Cipher)�ec)�__version__)�protocol�defer)�log�	randbytes)�	iterbytes�	_bytesChr�
networkString)�address�keys�_kex)�NS�getNS�MP�getMP�_MPpow�ffs�int_from_bytescCs(|drtd|f��t||d�d�S)a�
    Generate a random number in the range [0, 2 ** bits).

    @type random: L{callable}
    @param random: A callable taking a count of bytes and returning that many
    random bytes.

    @type bits: L{int}
    @param bits: The number of bits in the result.

    @rtype: L{int} or L{long}
    @return: The newly generated random number.

    @raise ValueError: if C{bits} is not a multiple of 8.
    �z!bits (%d) must be a multiple of 8Zbig)�
ValueErrorr )�random�bits�r%�=/usr/lib/python3/dist-packages/twisted/conch/ssh/transport.py�_getRandomNumber*sr'cCs4t||�}d|kr&d|dkrnq|SqdS)a�
    Generate a new value for the private key x.

    From RFC 2631, section 2.2::

        X9.42 requires that the private key x be in the interval
        [2, (q - 2)].  x should be randomly generated in this interval.

    @type random: L{callable}
    @param random: A callable taking a count of bytes and returning that many
    random bytes.

    @type bits: L{int}
    @param bits: The size of the key to generate, in bits.

    @rtype: L{int}
    @return: A suitable 'x' value.
    �N)r')r#r$�xr%r%r&�
_generateX@s
 r*c@seZdZdZdS)�
_MACParamsaP
    L{_MACParams} represents the parameters necessary to compute SSH MAC
    (Message Authenticate Codes).

    L{_MACParams} is a L{tuple} subclass to maintain compatibility with older
    versions of the code.  The elements of a L{_MACParams} are::

        0. The digest object used for the MAC
        1. The inner pad ("ipad") string
        2. The outer pad ("opad") string
        3. The size of the digest produced by the digest object

    L{_MACParams} is also an object lesson in why tuples are a bad type for
    public APIs.

    @ivar key: The HMAC key which will be used.
    N)�__name__�
__module__�__qualname__�__doc__r%r%r%r&r+Zsr+c@seZdZdZejdejfejdejfej	dejfej	dejfej	dejfej
dejfej	dejfej	dejfej	dejfejdejfejdejfej
dejfddejfd�
Ze
eeeedd�Zd	d
�Zdd�Zd
d�Zdd�Zdd�Zdd�Zdd�Zdd�ZdS)�
SSHCiphersa
    SSHCiphers represents all the encryption operations that need to occur
    to encrypt and authenticate the SSH connection.

    @cvar cipherMap: A dictionary mapping SSH encryption names to 3-tuples of
        (<cryptography.hazmat.primitives.interfaces.CipherAlgorithm>,
        <block size>, <cryptography.hazmat.primitives.interfaces.Mode>)
    @cvar macMap: A dictionary mapping SSH MAC names to hash modules.

    @ivar outCipType: the string type of the outgoing cipher.
    @ivar inCipType: the string type of the incoming cipher.
    @ivar outMACType: the string type of the incoming MAC.
    @ivar inMACType: the string type of the incoming MAC.
    @ivar encBlockSize: the block size of the outgoing cipher.
    @ivar decBlockSize: the block size of the incoming cipher.
    @ivar verifyDigestSize: the size of the incoming MAC.
    @ivar outMAC: a tuple of (<hash module>, <inner key>, <outer key>,
        <digest size>) representing the outgoing MAC.
    @ivar inMAc: see outMAC, but for the incoming MAC.
    ��� Nr)
�3des-cbc�blowfish-cbc�
aes256-cbc�
aes192-cbc�
aes128-cbc�cast128-cbc�
aes128-ctr�
aes192-ctr�
aes256-ctr�3des-ctr�blowfish-ctr�cast128-ctr�none)�
hmac-sha2-512�
hmac-sha2-384�
hmac-sha2-256�	hmac-sha1�hmac-md5r@cCs:||_||_||_||_d|_d|_d|_d|_d|_dS)Nr�N�rGr)	�
outCipType�	inCipType�
outMACType�	inMACType�encBlockSize�decBlockSize�verifyDigestSize�outMAC�inMAC)�selfZoutCipZinCipZoutMacZinMacr%r%r&�__init__�szSSHCiphers.__init__cCs�|�|j||�}|��|_|jjd|_|�|j||�}|��|_|jjd|_|�	|j
|�|_|�	|j|�|_
|j
r�|j
d|_dS)a�
        Set up the ciphers and hashes using the given keys,

        @param outIV: the outgoing initialization vector
        @param outKey: the outgoing encryption key
        @param inIV: the incoming initialization vector
        @param inKey: the incoming encryption key
        @param outInteg: the outgoing integrity key
        @param inInteg: the incoming integrity key.
        r!�N)�
_getCipherrH�	encryptor�	algorithm�
block_sizerLrI�	decryptorrM�_getMACrJrOrKrPrN)rQZoutIVZoutKeyZinIVZinKeyZoutIntegZinInteg�or%r%r&�setKeys�s

zSSHCiphers.setKeyscCsL|j|\}}}|dkrt�St||d|��||d|jd��t�d�S)z�
        Creates an initialized cipher object.

        @param cip: the name of the cipher, maps into cipherMap
        @param iv: the initialzation vector
        @param key: the encryption key

        @return: the cipher object.
        Nr!�Zbackend)�	cipherMap�_DummyCipherr
rWr
)rQZcipZiv�key�algorithmClass�keySize�	modeClassr%r%r&rT�s
�zSSHCiphers._getCipherc
Csn|j|}|sdS|�}|j}|j}|d|�d||}|�tj�}|�tj�}t||||f�}	||	_|	S)am
        Gets a 4-tuple representing the message authentication code.
        (<hash module>, <inner hash value>, <outer hash value>,
        <digest size>)

        @type mac: L{bytes}
        @param mac: a key mapping into macMap

        @type key: L{bytes}
        @param key: the MAC key.

        @rtype: L{bytes}
        @return: The MAC components.
        rFN�)	�macMapZdigest_sizerW�	translate�hmacZtrans_36Ztrans_5Cr+r_)
rQ�macr_�modZ
hashObjectZ
digestSizeZ	blockSize�irZ�resultr%r%r&rY�s
zSSHCiphers._getMACcCs|j�|�S)z�
        Encrypt some data.

        @type blocks: L{bytes}
        @param blocks: The data to encrypt.

        @rtype: L{bytes}
        @return: The encrypted data.
        )rU�update�rQZblocksr%r%r&�encrypt�s
zSSHCiphers.encryptcCs|j�|�S)z�
        Decrypt some data.

        @type blocks: L{bytes}
        @param blocks: The data to decrypt.

        @rtype: L{bytes}
        @return: The decrypted data.
        )rXrkrlr%r%r&�decrypts
zSSHCiphers.decryptcCs:|jdsdSt�d|�|}t�|jj||jd���S)aa
        Create a message authentication code (MAC) for the given packet using
        the outgoing MAC values.

        @type seqid: L{int}
        @param seqid: The sequence ID of the outgoing packet.

        @type data: L{bytes}
        @param data: The data to create a MAC for.

        @rtype: L{str}
        @return: The serialized MAC.
        rrG�>L)rO�struct�packrf�HMACr_�digest)rQ�seqid�datar%r%r&�makeMACs
zSSHCiphers.makeMACcCsF|jds|dkSt�d|�|}t�|jj||jd���}||kS)a�
        Verify an incoming MAC using the incoming MAC values.

        @type seqid: L{int}
        @param seqid: The sequence ID of the incoming packet.

        @type data: L{bytes}
        @param data: The packet data to verify.

        @type mac: L{bytes}
        @param mac: The MAC sent with the packet.

        @rtype: L{bool}
        @return: C{True} if the MAC is valid.
        rrGro)rPrprqrfrrr_rs)rQrtrurgZouterr%r%r&�verify's

zSSHCiphers.verify)r,r-r.r/rZ	TripleDESrZCBCZBlowfishZAESZCAST5ZCTRr]rrrrrrdrRr[rTrYrmrnrvrwr%r%r%r&r0os<
��
#

r0cCs�g}ddddddddd	d
ddg}|D]b}tj|\}}}z.t|d
|�|d
|jd�t�d���Wntk
rzYq$X|�|�q$|S)z�
    Build a list of ciphers that are supported by the backend in use.

    @return: a list of supported ciphers.
    @rtype: L{list} of L{str}
    r<r6r;r7r:r8r?r9r>r5r=r4� r!r\)r0r]r
rWr
rUr	�append)�supportedCiphersZcsZcipherr`rarbr%r%r&�_getSupportedCiphers?s.�
�r{c@s�eZdZdZdZde�d�ZdZdedede�	�Z
e�Zd	d
ddd
gZ
e��ZgZeD]$Ze�d�dkrbee�dd�g7Zqbeddg7ZddgZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#e!Z$dZ%dd�Z&dd �Z'd!d"�Z(d#d$�Z)d%d&�Z*d'd(�Z+d)d*�Z,d+d,�Z-d-d.�Z.d/d0�Z/d1d2�Z0e1d3d4��Z2e2j3d5d4��Z2d6d7�Z4d8d9�Z5d:d;�Z6d<d=�Z7d>d?�Z8d@dA�Z9d]dBdC�Z:dDdE�Z;dFdG�Z<dHdI�Z=dJdK�Z>dLdM�Z?dNdO�Z@d^dQdR�ZAd_dSdT�ZBdUdV�ZCdWdX�ZDdYdZ�ZEd[d\�ZFdS)`�SSHTransportBasea�
    Protocol supporting basic SSH functionality: sending/receiving packets
    and message dispatch.  To connect to or run a server, you must use
    SSHClientTransport or SSHServerTransport.

    @ivar protocolVersion: A string representing the version of the SSH
        protocol we support.  Currently defaults to '2.0'.

    @ivar version: A string representing the version of the server or client.
        Currently defaults to 'Twisted'.

    @ivar comment: An optional string giving more information about the
        server or client.

    @ivar supportedCiphers: A list of strings representing the encryption
        algorithms supported, in order from most-preferred to least.

    @ivar supportedMACs: A list of strings representing the message
        authentication codes (hashes) supported, in order from most-preferred
        to least.  Both this and supportedCiphers can include 'none' to use
        no encryption or authentication, but that must be done manually,

    @ivar supportedKeyExchanges: A list of strings representing the
        key exchanges supported, in order from most-preferred to least.

    @ivar supportedPublicKeys:  A list of strings representing the
        public key types supported, in order from most-preferred to least.

    @ivar supportedCompressions: A list of strings representing compression
        types supported, from most-preferred to least.

    @ivar supportedLanguages: A list of strings representing languages
        supported, from most-preferred to least.

    @ivar supportedVersions: A container of strings representing supported ssh
        protocol version numbers.

    @ivar isClient: A boolean indicating whether this is a client or server.

    @ivar gotVersion: A boolean indicating whether we have received the
        version string from the other side.

    @ivar buf: Data we've received but hasn't been parsed into a packet.

    @ivar outgoingPacketSequence: the sequence number of the next packet we
        will send.

    @ivar incomingPacketSequence: the sequence number of the next packet we
        are expecting from the other side.

    @ivar outgoingCompression: an object supporting the .compress(str) and
        .flush() methods, or None if there is no outgoing compression.  Used to
        compress outgoing data.

    @ivar outgoingCompressionType: A string representing the outgoing
        compression type.

    @ivar incomingCompression: an object supporting the .decompress(str)
        method, or None if there is no incoming compression.  Used to
        decompress incoming data.

    @ivar incomingCompressionType: A string representing the incoming
        compression type.

    @ivar ourVersionString: the version string that we sent to the other side.
        Used in the key exchange.

    @ivar otherVersionString: the version string sent by the other side.  Used
        in the key exchange.

    @ivar ourKexInitPayload: the MSG_KEXINIT payload we sent.  Used in the key
        exchange.

    @ivar otherKexInitPayload: the MSG_KEXINIT payload we received.  Used in
        the key exchange

    @ivar sessionID: a string that is unique to this SSH session.  Created as
        part of the key exchange, sessionID is used to generate the various
        encryption and authentication keys.

    @ivar service: an SSHService instance, or None.  If it's set to an object,
        it's the currently running service.

    @ivar kexAlg: the agreed-upon key exchange algorithm.

    @ivar keyAlg: the agreed-upon public key type for the key exchange.

    @ivar currentEncryptions: an SSHCiphers instance.  It represents the
        current encryption and authentication options for the transport.

    @ivar nextEncryptions: an SSHCiphers instance.  Held here until the
        MSG_NEWKEYS messages are exchanged, when nextEncryptions is
        transitioned to currentEncryptions.

    @ivar first: the first bytes of the next packet.  In order to avoid
        decrypting data twice, the first bytes are decrypted and stored until
        the whole packet is available.

    @ivar _keyExchangeState: The current protocol state with respect to key
        exchange.  This is either C{_KEY_EXCHANGE_NONE} if no key exchange is
        in progress (and returns to this value after any key exchange
        completqes), C{_KEY_EXCHANGE_REQUESTED} if this side of the connection
        initiated a key exchange, and C{_KEY_EXCHANGE_PROGRESSING} if the other
        side of the connection initiated a key exchange.  C{_KEY_EXCHANGE_NONE}
        is the initial value (however SSH connections begin with key exchange,
        so it will quickly change to another state).

    @ivar _blockedByKeyExchange: Whenever C{_keyExchangeState} is not
        C{_KEY_EXCHANGE_NONE}, this is a C{list} of pending messages which were
        passed to L{sendPacket} but could not be sent because it is not legal
        to send them while a key exchange is in progress.  When the key
        exchange completes, another attempt is made to send these messages.
    �2.0sTwisted_�asciirG�SSH-�-rxrArBrCrDrEsecdh����ecdsasssh-rsasssh-dssr@�zlibr%)s1.99r}FrN�_KEY_EXCHANGE_NONE�_KEY_EXCHANGE_REQUESTED�_KEY_EXCHANGE_PROGRESSINGcCs0|jr|j��t|d�r"|��t�d�dS)a
        When the underlying connection is closed, stop the running service (if
        any), and log out the avatar (if any).

        @type reason: L{twisted.python.failure.Failure}
        @param reason: The cause of the connection being closed.
        Zavatarzconnection lostN)�service�serviceStopped�hasattrZlogoutFunctionr�msg)rQ�reasonr%r%r&�connectionLosts


zSSHTransportBase.connectionLostcCsD|j�|jd�tdddd�|_|j�dddddd�|��dS)z�
        Called when the connection is made to the other side.  We sent our
        version and the MSG_KEXINIT packet.
        s
r@rGN)�	transport�write�ourVersionStringr0�currentEncryptionsr[�sendKexInit�rQr%r%r&�connectionMades�zSSHTransportBase.connectionMadecCs�|j|jkrtd|jf��d�tt�t�d�td�|j	��td�|j
��td�|j��td�|j��td�|j��td�|j��td�|j
��td�|j
��td�|j��td�|j��dg
�|_|�t|jdd��|j|_g|_dS)a7
        Send a I{KEXINIT} message to initiate key exchange or to respond to a
        key exchange initiated by the peer.

        @raise RuntimeError: If a key exchange has already been started and it
            is not appropriate to send a I{KEXINIT} message at this time.

        @return: L{None}
        z2Cannot send KEXINIT while key exchange state is %rrGr2�,s�N)�_keyExchangeStater��RuntimeError�join�chr�MSG_KEXINITr�secureRandomr�supportedKeyExchanges�supportedPublicKeysrz�
supportedMACs�supportedCompressions�supportedLanguages�ourKexInitPayload�
sendPacketr��_blockedByKeyExchanger�r%r%r&r�#s0
���zSSHTransportBase.sendKexInitcCs^d|krdkr$nn|ttfkSd|kr8dkrFnn
|tfkSd|koXdkSS)a�
        Determine if the given message type may be sent while key exchange is
        in progress.

        @param messageType: The type of message
        @type messageType: L{int}

        @return: C{True} if the given type of message may be sent while key
            exchange is in progress, C{False} if it may not.
        @rtype: L{bool}

        @see: U{http://tools.ietf.org/html/rfc4253#section-7.1}
        r������1)�MSG_SERVICE_REQUEST�MSG_SERVICE_ACCEPTr�)rQ�messageTyper%r%r&�_allowedKeyExchangeMessageTypeEs

z/SSHTransportBase._allowedKeyExchangeMessageTypecCs�|j|jkr*|�|�s*|j�||f�dSt|�|}|jrT|j�|�|j�d�}|j	j
}dt|�}|||}|dkr�||}t�
d||d|�|t�|�}|j	�|�|j	�|j|�}|j�|�|jd7_dS)a�
        Sends a packet.  If it's been set up, compress the data, encrypt it,
        and authenticate it before sending.  If key exchange is in progress and
        the message is not part of key exchange, queue it to be sent later.

        @param messageType: The type of the packet; generally one of the
                            MSG_* values.
        @type messageType: L{int}
        @param payload: The payload for the message.
        @type payload: L{str}
        Nr(���!LBr�)r�r�r�r�ryr��outgoingCompression�compress�flushr�rL�lenrprqrr�rmrv�outgoingPacketSequencer�r�)rQr��payload�bsZ	totalSizeZlenPad�packetZ	encPacketr%r%r&r�\s>


�
���
���zSSHTransportBase.sendPacketc
	Cs�|jj}|jj}t|j�|kr"dSt|d�sD|j�|jd|��}n
|j}|`t�	d|dd��\}}|dkr�|�
ttd�
|���dSt|j�|d|kr�||_dS|d|dkr�|�
ttd	|d||d|f��dS|jdd|�|jd|d�}|_||j�||d��}t|�d|k�rD|�
td
�dS|�r�|jd|�|j|d�}|_|j�|j||��s�|�
td�dS|d|�}	|j�r�z|j�|	�}	Wn"t��|�
td�YdSX|jd
7_|	S)z�
        Try to return a decrypted, authenticated, and decompressed packet
        out of the buffer.  If there is not enough data, return None.

        @rtype: L{str} or L{None}
        @return: The decoded packet, if any.
        N�firstr�r�izbad packet length {}r�rzbad packet mod (%i%%%i == %i)sbad decryptionsbad MACscompression errorr�)r�rMrNr��bufr�rnr�rp�unpack�sendDisconnect�DISCONNECT_PROTOCOL_ERRORr�formatrw�incomingPacketSequence�DISCONNECT_MAC_ERROR�incomingCompression�
decompressr�err�DISCONNECT_COMPRESSION_ERROR)
rQr�Zmsr�Z	packetLenZ
paddingLenZencDatar�ZmacDatar�r%r%r&�	getPacket�sr
�
���(� 
��zSSHTransportBase.getPacketcCs|�td|�dS)z�
        Called when an unsupported version of the ssh protocol is received from
        the remote endpoint.

        @param remoteVersion: remote ssh protocol version which is unsupported
            by us.
        @type remoteVersion: L{str}
        sbad version N)r��)DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED)rQ�
remoteVersionr%r%r&�_unsupportedVersionReceived�s	�z,SSHTransportBase._unsupportedVersionReceivedcCs
|j||_|js�t|j�dkr0|�td�dS|j�d|j�d��dkrNdS|j�d�}|D]j}|�d�r^d|_|�d�|_	|�d	�d
}||j
kr�|�|�dS|�|�}d�
||d
d��|_q^|��}|�rt|dd
��}|�||d
d��|��}q�dS)a
        First, check for the version string (SSH-2.0-*).  After that has been
        received, this method adds data to the buffer, and pulls out any
        packets.

        @type data: L{bytes}
        @param data: The data that was received.
        isKPeer version string longer than 4KB. Preventing a denial of service attack.N�
rr�T�
r�r�r)r��
gotVersionr�r��DISCONNECT_CONNECTION_LOST�find�split�
startswith�rstrip�otherVersionString�supportedVersionsr��indexr�r��ord�dispatchMessage)rQru�lines�pr�rir��
messageNumr%r%r&�dataReceived�s4	�



zSSHTransportBase.dataReceivedcCs�|dkrj|tkrjt|dd�}t|d|fd�}|dk	rD||�q�t�d|�t�t|��|��nB|jr�t�|j|jj||�n$t�d|�t�t|��|��dS)z�
        Send a received message to the appropriate method.

        @type messageNum: L{int}
        @param messageNum: The message number.

        @type payload: L{bytes}
        @param payload: The message payload.
        �2r�Nzssh_%szcouldn't handle %s)	�messages�getattrrr��repr�sendUnimplementedr�ZcallWithLoggerZpacketReceived)rQr�r�r��fr%r%r&r��s 


�z SSHTransportBase.dispatchMessagecCst�|j���S)z�
        Returns an L{SSHTransportAddress} corresponding to the other (peer)
        side of this transport.

        @return: L{SSHTransportAddress} for the peer
        @rtype: L{SSHTransportAddress}
        @since: 12.1
        )r�SSHTransportAddressr��getPeerr�r%r%r&r�s	zSSHTransportBase.getPeercCst�|j���S)z�
        Returns an L{SSHTransportAddress} corresponding to the this side of
        transport.

        @return: L{SSHTransportAddress} for the peer
        @rtype: L{SSHTransportAddress}
        @since: 12.1
        )rr�r��getHostr�r%r%r&r�#s	zSSHTransportBase.getHostcCs|jS)zS
        The key exchange algorithm name agreed between client and server.
        �Z_kexAlgr�r%r%r&�kexAlg/szSSHTransportBase.kexAlgcCs
||_dS)z6
        Set the key exchange algorithm name.
        Nr�)rQ�valuer%r%r&r�7sc
Cs<tt�||_t|dd�d�}|dd�|d}}dd�|D�\
}}}}}	}
}}}
}||
|g}||
|g}|jr|||}}|j|j|j|j|j|j|j	|j	f}|||d|d|d|d|d	|d	f}|jr�||}}t
|d|d�|_t
|d|d�|_t
t
|d	|d	�t
|d
|d
�t
|d|d�t
|d|d��|_t
|d
|d
�|_t
|d|d�|_d|j|j|j|jfk�r�|�td�dSd|jj��k�r�|�td�dSt�d|j|jf�t�d|jj|jj|jf�t�d|jj|jj|jf�|j|jk�r*|j|_n|��|||fS)a�
        Called when we receive a MSG_KEXINIT message.  Payload::
            bytes[16] cookie
            string keyExchangeAlgorithms
            string keyAlgorithms
            string incomingEncryptions
            string outgoingEncryptions
            string incomingAuthentications
            string outgoingAuthentications
            string incomingCompressions
            string outgoingCompressions
            string incomingLanguages
            string outgoingLanguages
            bool firstPacketFollows
            unit32 0 (reserved)

        Starts setting up the key exchange, keys, encryptions, and
        authentications.  Extended by ssh_KEXINIT in SSHServerTransport and
        SSHClientTransport.

        @type packet: L{bytes}
        @param packet: The message data.

        @return: A L{tuple} of negotiated key exchange algorithms, key
        algorithms, and unhandled data, or L{None} if something went wrong.
        r2N�
r�cSsg|]}|�d��qS)r�)r�)�.0�sr%r%r&�
<listcomp>nsz0SSHTransportBase.ssh_KEXINIT.<locals>.<listcomp>rr�r(rSr�r���scouldn't match all kex partszkex alg, key alg: %r %rzoutgoing: %r %r %rzincoming: %r %r %r)r�r��otherKexInitPayloadr�isClientr�r�rzr�r�rr��keyAlgr0�nextEncryptions�outgoingCompressionType�incomingCompressionTyper��DISCONNECT_KEY_EXCHANGE_FAILED�__dict__�valuesrr�rHrJrIrKr�r�r�r�)rQr��kZstrings�rest�kexAlgs�keyAlgsZencCSZencSCZmacCSZmacSCZcompCSZcompSCZlangCSZlangSC�outs�insZserverZclientr%r%r&�ssh_KEXINITMsv�


��
������
zSSHTransportBase.ssh_KEXINITcCsFt�d|dd��d}t|dd��\}}|�||�|j��dS)a<
        Called when we receive a MSG_DISCONNECT message.  Payload::
            long code
            string description

        This means that the other side has disconnected.  Pass the message up
        and disconnect ourselves.

        @type packet: L{bytes}
        @param packet: The message data.
        roNr�r)rpr�r�receiveErrorr��loseConnection)rQr��
reasonCode�description�foor%r%r&�ssh_DISCONNECT�szSSHTransportBase.ssh_DISCONNECTcCsdS)z�
        Called when we receive a MSG_IGNORE message.  No payload.
        This means nothing; we simply return.

        @type packet: L{bytes}
        @param packet: The message data.
        Nr%�rQr�r%r%r&�
ssh_IGNORE�szSSHTransportBase.ssh_IGNOREcCst�d|�\}|�|�dS)z�
        Called when we receive a MSG_UNIMPLEMENTED message.  Payload::
            long packet

        This means that the other side did not implement one of our packets.

        @type packet: L{bytes}
        @param packet: The message data.
        roN)rpr��receiveUnimplemented)rQr��seqnumr%r%r&�ssh_UNIMPLEMENTED�s
z"SSHTransportBase.ssh_UNIMPLEMENTEDcCs>tt|dd���}t|dd�d�\}}}|�|||�dS)a0
        Called when we receive a MSG_DEBUG message.  Payload::
            bool alwaysDisplay
            string message
            string language

        This means the other side has passed along some debugging info.

        @type packet: L{bytes}
        @param packet: The message data.
        rr�Nr()�boolr�r�receiveDebug)rQr��
alwaysDisplay�message�langr�r%r%r&�	ssh_DEBUG�szSSHTransportBase.ssh_DEBUGcCs<t�d|jf�|jr"|j��||_||_|j��dS)z�
        Set our service to service and start it running.  If we were
        running a service previously, stop it first.

        @type service: C{SSHService}
        @param service: The service to attach.
        zstarting service %rN)rr��namer�r�r�ZserviceStarted)rQr�r%r%r&�
setService�s
zSSHTransportBase.setServicecCs$|�tt|�t|�t|��dS)a�
        Send a debug message to the other side.

        @param message: the message to send.
        @type message: L{str}
        @param alwaysDisplay: if True, tell the other side to always
                              display this message.
        @type alwaysDisplay: L{bool}
        @param language: optionally, the language the message is in.
        @type language: L{str}
        N)r��	MSG_DEBUGr�r)rQr	rZlanguager%r%r&�	sendDebug�s�zSSHTransportBase.sendDebugcCs|�tt|��dS)a
        Send a message that will be ignored by the other side.  This is
        useful to fool attacks based on guessing packet sizes in the
        encrypted stream.

        @param message: data to send with the message
        @type message: L{str}
        N)r��
MSG_IGNOREr)rQr	r%r%r&�
sendIgnore�s	zSSHTransportBase.sendIgnorecCs|j}|�tt�d|��dS)zc
        Send a message to the other side that the last packet was not
        understood.
        z!LN)r�r��MSG_UNIMPLEMENTEDrprq�rQrr%r%r&r�sz"SSHTransportBase.sendUnimplementedcCsD|�tt�d|�t|�td��t�d||f�|j��dS)aJ
        Send a disconnect message to the other side and then disconnect.

        @param reason: the reason for the disconnect.  Should be one of the
                       DISCONNECT_* values.
        @type reason: L{int}
        @param desc: a descrption of the reason for the disconnection.
        @type desc: L{str}
        rorGz,Disconnecting with error, code %s
reason: %sN)	r��MSG_DISCONNECTrprqrrr�r�r�)rQr�Zdescr%r%r&r�s
��zSSHTransportBase.sendDisconnectcCsFt�|j�}|||||j�}|��}||||���}||S)a�
        Get one of the keys for authentication/encryption.

        @type c: L{bytes}
        @param c: The letter identifying which key this is.

        @type sharedSecret: L{bytes}
        @param sharedSecret: The shared secret K.

        @type exchangeHash: L{bytes}
        @param exchangeHash: The hash H from key exchange.

        @rtype: L{bytes}
        @return: The derived key.
        )r�getHashProcessorr��	sessionIDrs)rQ�c�sharedSecret�exchangeHashZ
hashProcessorZk1Zk2r%r%r&�_getKeys
zSSHTransportBase._getKeyc	Cs�|js||_|�d||�}|�d||�}|�d||�}|�d||�}|�d||�}|�d||�}|||g}	|||g}
|jr�t�d�|
|	}	}
|j�|	d|	d	|
d|
d	|	d
|
d
�|�td�dS)
a�
        Set up the keys for the connection and sends MSG_NEWKEYS when
        finished,

        @param sharedSecret: a secret string agreed upon using a Diffie-
                             Hellman exchange, so it is only shared between
                             the server and the client.
        @type sharedSecret: L{str}
        @param exchangeHash: A hash of various data known by both sides.
        @type exchangeHash: L{str}
        �A�B�C�D�E�FZREVERSErr�r(rGN)	rrr�rr�r�r[r��MSG_NEWKEYS)rQrrZinitIVCSZinitIVSCZencKeyCSZencKeySCZ
integKeyCSZ
integKeySCr�r�r%r%r&�	_keySetup6s$



�zSSHTransportBase._keySetupcCsnt�d�|j|_|jdkr(t�d�|_|jdkr<t�	�|_
|j|_|j
}d|_
|D]\}}|�||�qTdS)a*
        Called back by a subclass once a I{MSG_NEWKEYS} message has been
        received.  This indicates key exchange has completed and new encryption
        and compression parameters should be adopted.  Any messages which were
        queued during key exchange will also be flushed.
        zNEW KEYSr�r�N)rr�r�r�r��zlibZcompressobjr�r�Z
decompressobjr�r�r�r�r�)rQr�r�r�r%r%r&�_newKeysTs



zSSHTransportBase._newKeys�outcCsP|dkr|jjdkS|dkr(|jjdkS|dkrD|�d�oB|�d�Std��dS)z�
        Check if the connection is encrypted in the given direction.

        @type direction: L{str}
        @param direction: The direction: one of 'out', 'in', or 'both'.

        @rtype: L{bool}
        @return: C{True} if it is encrypted.
        r%r@�in�both�(direction must be "out", "in", or "both"N)r�rHrI�isEncrypted�	TypeError�rQ�	directionr%r%r&r)is
zSSHTransportBase.isEncryptedcCsP|dkr|jjdkS|dkr(|jjdkS|dkrD|�d�oB|�d�Std��dS)a

        Check if the connection is verified/authentication in the given direction.

        @type direction: L{str}
        @param direction: The direction: one of 'out', 'in', or 'both'.

        @rtype: L{bool}
        @return: C{True} if it is verified.
        r%r@r&r'r(N)r�rJrK�
isVerifiedr*r+r%r%r&r-}s
zSSHTransportBase.isVerifiedcCs|�td�dS)zn
        Lose the connection to the other side, sending a
        DISCONNECT_CONNECTION_LOST message.
        suser closed connectionN)r�r�r�r%r%r&r��s�zSSHTransportBase.loseConnectioncCst�d||f�dS)a�
        Called when we receive a disconnect error message from the other
        side.

        @param reasonCode: the reason for the disconnect, one of the
                           DISCONNECT_ values.
        @type reasonCode: L{int}
        @param description: a human-readable description of the
                            disconnection.
        @type description: L{str}
        z$Got remote error, code %s
reason: %sN�rr�)rQr�r�r%r%r&r��s�zSSHTransportBase.receiveErrorcCst�d|f�dS)z�
        Called when we receive an unimplemented packet message from the other
        side.

        @param seqnum: the sequence number that was not understood.
        @type seqnum: L{int}
        z#other side unimplemented packet #%sNr.rr%r%r&r�sz%SSHTransportBase.receiveUnimplementedcCs|rt�d|f�dS)a�
        Called when we receive a debug message from the other side.

        @param alwaysDisplay: if True, this message should always be
                              displayed.
        @type alwaysDisplay: L{bool}
        @param message: the debug message
        @type message: L{str}
        @param lang: optionally the language the message is in.
        @type lang: L{str}
        zRemote Debug Message: %sNr.)rQrr	r
r%r%r&r�szSSHTransportBase.receiveDebug)FrG)r%)r%)Gr,r-r.r/ZprotocolVersion�twisted_version�encode�versionZcomment�stripr�r{rzr�rZgetSupportedKeyExchangesr�r�Zeckeyr��replacer�r�r�r�r�r�r�r�r�r�rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��propertyr��setterr�rrrrr
rrr�r�rr"r$r)r-r�r�rrr%r%r%r&r|Zs�q��	"&=
/

Q

	

r|c@sXeZdZdZdZdZdd�Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�Zdd�Z
dS)�SSHServerTransporta/
    SSHServerTransport implements the server side of the SSH protocol.

    @ivar isClient: since we are never the client, this is always False.

    @ivar ignoreNextPacket: if True, ignore the next key exchange packet.  This
        is set when the client sends a guessed key exchange packet but with
        an incorrect guess.

    @ivar dhGexRequest: the KEX_DH_GEX_REQUEST(_OLD) that the client sent.
        The key generation needs this to be stored.

    @ivar g: the Diffie-Hellman group generator.

    @ivar p: the Diffie-Hellman group prime.
    FrcCs\t�||�}|sdS|\}}}t|dd��rX|d|jdksR|d|jdkrXd|_dS)aM
        Called when we receive a MSG_KEXINIT message.  For a description
        of the packet, see SSHTransportBase.ssh_KEXINIT().  Additionally,
        this method checks if a guessed key exchange packet was sent.  If
        it was sent, and it guessed incorrectly, the next key exchange
        packet MUST be ignored.
        Nrr�T)r|r�r�r�r��ignoreNextPacket)rQr�Zretvalr�r�r�r%r%r&r��s
�zSSHServerTransport.ssh_KEXINITc
Cs�t|�\}}|jj|j}|jj|j}ztjd|jdd�}Wntk
r`t	d��YnXt
�|t��}|�
�}|����}t
j�||��
t��}	ttt�|�t
��|	��d��}
t�|j��}|�t|j��|�t|j��|�t|j��|�t|j��|�t|� ���|�t|��|�t|��|�|
�|�!�}|�"t#t|� ��t|�t|�$|���|�%|
|�dS)a
        Called from L{ssh_KEX_DH_GEX_REQUEST_OLD} to handle
        elliptic curve key exchanges.

        Payload::

            string client Elliptic Curve Diffie-Hellman public key

        Just like L{_ssh_KEXDH_INIT} this message type is also not dispatched
        directly. Extra check to determine if this is really KEX_ECDH_INIT
        is required.

        First we load the host's public/private keys.
        Then we generate the ECDH public/private keypair for the given curve.
        With that we generate the shared secret key.
        Then we compute the hash to sign and send back to the client
        Along with the server's public key and the ECDH public key.

        @type packet: L{bytes}
        @param packet: The message data.

        @return: None.
        r�r�Nz
unused-keyr2)&r�factory�
publicKeysr��privateKeysr�_curveTabler��KeyErrorr	r�generate_private_keyr
�
public_key�public_numbers�encode_point�EllipticCurvePublicNumbers�from_encoded_pointr�int�binascii�hexlify�exchange�ECDHrrrkrr�r�r�r��blobrsr��MSG_KEXDH_REPLY�signr")
rQr�ZpktPubZ
pubHostKeyZprivHostKey�curve�ecPriv�ecPubZencPub�
theirECPubr�hrr%r%r&�_ssh_KEX_ECDH_INIT�sR�����
��z%SSHServerTransport._ssh_KEX_ECDH_INITc	Cs t|�\}}ttjd�}t�|j�\|_|_t	|j||j�}t	|||j�}t
�}|�t|j
��|�t|j��|�t|j��|�t|j��|�t|jj|j����|�t|��|�|�|�|�|��}|�tt|jj|j���|t|jj|j�|���|�||�dS)aW
        Called to handle the beginning of a non-group key exchange.

        Unlike other message types, this is not dispatched automatically.  It
        is called from C{ssh_KEX_DH_GEX_REQUEST_OLD} because an extra check is
        required to determine if this is really a KEXDH_INIT message or if it
        is a KEX_DH_GEX_REQUEST_OLD message.

        The KEXDH_INIT payload::

                integer e (the client's Diffie-Hellman public key)

        We send the KEXDH_REPLY with our host key and signature.

        @type packet: L{bytes}
        @param packet: The message data.
        �N)rr'rr�r�getDHGeneratorAndPrimer��gr�rrrkrr�r�r�r�r8r9r�rHrrsr�rIr:rJr")	rQr��clientDHpublicKeyr��y�serverDHpublicKeyrrOrr%r%r&�_ssh_KEXDH_INIT<s0

���z"SSHServerTransport._ssh_KEXDH_INITcCs�|jrd|_dSt�|j�r&|�|�St�|j�r<|�|�S||_t�	d|�d}|j
�|�\|_|_
|�tt|j
�t|j��dS)a�
        This represents different key exchange methods that share the same
        integer value.  If the message is determined to be a KEXDH_INIT,
        L{_ssh_KEXDH_INIT} is called to handle it. If it is a KEX_ECDH_INIT,
        L{_ssh_KEX_ECDH_INIT} is called.
        Otherwise, for KEX_DH_GEX_REQUEST_OLD payload::

                integer ideal (ideal size for the Diffie-Hellman prime)

            We send the KEX_DH_GEX_GROUP message with the group that is
            closest in size to ideal.

        If we were told to ignore the next key exchange packet by ssh_KEXINIT,
        drop it on the floor and return.

        @type packet: L{bytes}
        @param packet: The message data.
        rNro)r7r�isFixedGroupr�rW�isEllipticCurverP�dhGexRequestrpr�r8�
getDHPrimerSr�r��MSG_KEX_DH_GEX_GROUPr)rQr��idealr%r%r&�ssh_KEX_DH_GEX_REQUEST_OLDes

z-SSHServerTransport.ssh_KEX_DH_GEX_REQUEST_OLDcCs\|jrd|_dS||_t�d|�\}}}|j�|�\|_|_|�t	t
|j�t
|j��dS)a#
        Called when we receive a MSG_KEX_DH_GEX_REQUEST message.  Payload::
            integer minimum
            integer ideal
            integer maximum

        The client is asking for a Diffie-Hellman group between minimum and
        maximum size, and close to ideal if possible.  We reply with a
        MSG_KEX_DH_GEX_GROUP message.

        If we were told to ignore the next key exchange packet by ssh_KEXINIT,
        drop it on the floor and return.

        @type packet: L{bytes}
        @param packet: The message data.
        rNz>3L)r7rZrpr�r8r[rSr�r�r\r)rQr��minr]�maxr%r%r&�ssh_KEX_DH_GEX_REQUEST�sz)SSHServerTransport.ssh_KEX_DH_GEX_REQUESTc
CsJt|�\}}|j��}ttj|�}t|j||j�}t|||j�}t�	|j
��}|�t|j
��|�t|j��|�t|j��|�t|j��|�t|jj|j����|�|j�|�t|j��|�t|j��|�t|��|�|�|�|�|��}	|�tt|jj|j���|t|jj|j�|	���|�||	�dS)a
        Called when we get a MSG_KEX_DH_GEX_INIT message.  Payload::
            integer e (client DH public key)

        We send the MSG_KEX_DH_GEX_REPLY message with our host key and
        signature.

        @type packet: L{bytes}
        @param packet: The message data.
        N)rr��
bit_lengthr'rr�rrSrrr�rkrr�r�r�r�r8r9r�rHrZrrsr��MSG_KEX_DH_GEX_REPLYr:rJr")
rQr�rTr�ZpSizerUrVrrOrr%r%r&�ssh_KEX_DH_GEX_INIT�s6


���z&SSHServerTransport.ssh_KEX_DH_GEX_INITcCs$|dkr|�td�dS|��dS)a
        Called when we get a MSG_NEWKEYS message.  No payload.
        When we get this, the keys have been set on both sides, and we
        start using them to encrypt and authenticate the connection.

        @type packet: L{bytes}
        @param packet: The message data.
        rG�NEWKEYS takes no dataN)r�r�r$rr%r%r&�ssh_NEWKEYS�s	�zSSHServerTransport.ssh_NEWKEYScCsRt|�\}}|j�||�}|s2|�td|�dS|�tt|��|�|��dS)aX
        Called when we get a MSG_SERVICE_REQUEST message.  Payload::
            string serviceName

        The client has requested a service.  If we can start the service,
        start it; otherwise, disconnect with
        DISCONNECT_SERVICE_NOT_AVAILABLE.

        @type packet: L{bytes}
        @param packet: The message data.
        sdon't have service N)	rr8Z
getServicer�� DISCONNECT_SERVICE_NOT_AVAILABLEr�r�rr
)rQr�r�r��clsr%r%r&�ssh_SERVICE_REQUEST�s�z&SSHServerTransport.ssh_SERVICE_REQUESTN)r,r-r.r/r�r7r�rPrWr^rardrfrir%r%r%r&r6�sL)%-r6c@s�eZdZdZdZdZdZdZdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"S)#�SSHClientTransporta)
    SSHClientTransport implements the client side of the SSH protocol.

    @ivar isClient: since we are always the client, this is always True.

    @ivar _gotNewKeys: if we receive a MSG_NEWKEYS message before we are
        ready to transition to the new keys, this is set to True so we
        can transition when the keys are ready locally.

    @ivar x: our Diffie-Hellman private key.

    @ivar e: our Diffie-Hellman public key.

    @ivar g: the Diffie-Hellman group generator.

    @ivar p: the Diffie-Hellman group prime

    @ivar instance: the SSHService object we are requesting.

    @ivar _dhMinimalGroupSize: Minimal acceptable group size advertised by the
        client in MSG_KEX_DH_GEX_REQUEST.
    @type _dhMinimalGroupSize: int

    @ivar _dhMaximalGroupSize: Maximal acceptable group size advertised by the
        client in MSG_KEX_DH_GEX_REQUEST.
    @type _dhMaximalGroupSize: int

    @ivar _dhPreferredGroupSize: Preferred group size advertised by the client
        in MSG_KEX_DH_GEX_REQUEST.
    @type _dhPreferredGroupSize: int
    Tii icCst�|�d|_dS)z{
        Called when the connection is started with the server.  Just sets
        up a private instance variable.
        rN)r|r��_gotNewKeysr�r%r%r&r�#s
z!SSHClientTransport.connectionMadec	Cs�t�||�dkrdSt�|j�rttjd|jdd�|_t�	|jt
��|_|j��|_
|�tt|j
������npt�|j�r�ttjd�|_t�|j�\|_|_t|j|j|j�|_|�t|j�n|�tt� d|j!|j"|j#��dS)a>
        Called when we receive a MSG_KEXINIT message.  For a description
        of the packet, see SSHTransportBase.ssh_KEXINIT().  Additionally,
        this method sends the first key exchange packet.

        If the agreed-upon exchange is ECDH, generate a key pair for the
        corresponding curve and send the public key.

        If the agreed-upon exchange has a fixed prime/generator group,
        generate a public key and send it in a MSG_KEXDH_INIT message.
        Otherwise, ask for a 2048 bit group with a MSG_KEX_DH_GEX_REQUEST
        message.
        Nr�r�rQ�!LLL)$r|r�rrYr�rr;rKrr=r
rLr>rMr��MSG_KEX_DH_GEX_REQUEST_OLDrr?r@rXr*rr�r)rRrSr�r�e�MSG_KEXDH_INIT�MSG_KEX_DH_GEX_REQUESTrprq�_dhMinimalGroupSize�_dhPreferredGroupSize�_dhMaximalGroupSizerr%r%r&r�,s4����zSSHClientTransport.ssh_KEXINITcsp�fdd�}t|d�\}}}}d�dd�tt|����D��}��||�}|�||||�|��fdd��|S)	a�
        Called to handle a reply to a ECDH exchange message(KEX_ECDH_INIT).

        Like the handler for I{KEXDH_INIT}, this message type has an
        overlapping value.  This method is called from C{ssh_KEX_DH_GEX_GROUP}
        if that method detects a non-group key exchange is in progress.

        Payload::

            string serverHostKey
            string server Elliptic Curve Diffie-Hellman public key
            string signature

        We verify the host key and continue if it passes verificiation.
        Otherwise raise an exception and return.

        @type packet: L{bytes}
        @param packet: The message data.

        @return: A deferred firing when key exchange is complete.
        c	s|}tj��j|��t��}ttt�	�j
�t��|��d��}t
��j��}|�t�j��|�t�j��|�t�j��|�t�j��|�t|��|�t�j������|�t|��|�|�|��}tj�|��||�s��td�n�� ||�dS)Nr2�
bad signature)!rrArBrKr>r
rrCrDrErLrFrGrrr�rkrr�r�r�r�rMr?r@rsr�Key�
fromStringrwr�r�r")	�ignored�hostKey�pubKey�	signatureZtheirECHostrNrrOrr�r%r&�_continue_KEX_ECDH_REPLYvsB�����
��zHSSHClientTransport._ssh_KEX_ECDH_REPLY.<locals>._continue_KEX_ECDH_REPLYrS�:cSsg|]}t�|��qSr%�rDrE�r�Zchr%r%r&r��sz:SSHClientTransport._ssh_KEX_ECDH_REPLY.<locals>.<listcomp>cs��td�S�Nsbad host key�r��"DISCONNECT_HOST_KEY_NOT_VERIFIABLE�Zunusedr�r%r&�<lambda>�s�z8SSHClientTransport._ssh_KEX_ECDH_REPLY.<locals>.<lambda>)rr�rrrs�
verifyHostKey�addCallback�
addErrback)rQr�r{rxryrz�fingerprint�dr%r�r&�_ssh_KEX_ECDH_REPLY`s'�
�z&SSHClientTransport._ssh_KEX_ECDH_REPLYcsxt|�\}}t|�\}}t|�\}}d�dd�tt|����D��}��||�}|��j|||�|�	�fdd��|S)a�
        Called to handle a reply to a non-group key exchange message
        (KEXDH_INIT).

        Like the handler for I{KEXDH_INIT}, this message type has an
        overlapping value.  This method is called from C{ssh_KEX_DH_GEX_GROUP}
        if that method detects a non-group key exchange is in progress.

        Payload::

            string serverHostKey
            integer f (server Diffie-Hellman public key)
            string signature

        We verify the host key by calling verifyHostKey, then continue in
        _continueKEXDH_REPLY.

        @type packet: L{bytes}
        @param packet: The message data.

        @return: A deferred firing when key exchange is complete.
        r|cSsg|]}t�|��qSr%r}r~r%r%r&r��sz7SSHClientTransport._ssh_KEXDH_REPLY.<locals>.<listcomp>cs��td�Srr�r�r�r%r&r��s�z5SSHClientTransport._ssh_KEXDH_REPLY.<locals>.<lambda>)
rrr�rrrsr�r��_continueKEXDH_REPLYr��rQr�ryr�rzr�r�r%r�r&�_ssh_KEXDH_REPLY�s
�
�z#SSHClientTransport._ssh_KEXDH_REPLYcCs|t�|j�r|�|�St�|j�r,|�|�St|�\|_}t|�\|_}t	t
jd�|_t
|j|j|j�|_|�t|j�dS)a�
        This handles different messages which share an integer value.

        If the key exchange does not have a fixed prime/generator group,
        we generate a Diffie-Hellman public key and send it in a
        MSG_KEX_DH_GEX_INIT message.

        Payload::
            string g (group generator)
            string p (group prime)

        @type packet: L{bytes}
        @param packet: The message data.
        i@N)rrXr�r�rYr�rr�rSr*rr�r)rrnr��MSG_KEX_DH_GEX_INIT)rQr�r�r%r%r&�ssh_KEX_DH_GEX_GROUP�s

z'SSHClientTransport.ssh_KEX_DH_GEX_GROUPc	Cs�tj�|�}t||j|j�}t�}|�t|j	��|�t|j
��|�t|j��|�t|j��|�t|��|�|j
�|�t|��|�|�|��}|�||�s�|�td�dS|�||�dS)�
        The host key has been verified, so we generate the keys.

        @param ignored: Ignored.

        @param pubKey: the public key blob for the server's public key.
        @type pubKey: L{str}
        @param f: the server's Diffie-Hellman public key.
        @type f: L{long}
        @param signature: the server's signature, verifying that it has the
            correct private key.
        @type signature: L{str}
        rtN)rrurvrr)r�rrkrr�r�r�r�rnrrsrwr�r�r"�	rQrwryr�rzZ	serverKeyrrOrr%r%r&r��s$
�z'SSHClientTransport._continueKEXDH_REPLYcsxt|�\}}t|�\}}t|�\}}d�dd�tt|����D��}��||�}|��j|||�|�	�fdd��|S)a�
        Called when we receive a MSG_KEX_DH_GEX_REPLY message.  Payload::
            string server host key
            integer f (server DH public key)

        We verify the host key by calling verifyHostKey, then continue in
        _continueGEX_REPLY.

        @type packet: L{bytes}
        @param packet: The message data.

        @return: A deferred firing once key exchange is complete.
        r|cSsg|]}t�|��qSr%r})r�rr%r%r&r�sz;SSHClientTransport.ssh_KEX_DH_GEX_REPLY.<locals>.<listcomp>cs��td�Srr�r�r�r%r&r�#s�z9SSHClientTransport.ssh_KEX_DH_GEX_REPLY.<locals>.<lambda>)
rrr�rrrsr�r��_continueGEX_REPLYr�r�r%r�r&�ssh_KEX_DH_GEX_REPLY
s�
�z'SSHClientTransport.ssh_KEX_DH_GEX_REPLYc	Cstj�|�}t||j|j�}t�|j��}|�	t
|j��|�	t
|j��|�	t
|j
��|�	t
|j��|�	t
|��|�	t�d|j|j|j��|�	t|j��|�	t|j��|�	|j�|�	t|��|�	|�|��}|�||�s�|�td�dS|�||�dS)r�rlrtN)rrurvrr)r�rrr�rkrr�r�r�r�rprqrqrrrsrrSrnrsrwr�r�r"r�r%r%r&r�(s4�
�z%SSHClientTransport._continueGEX_REPLYcCs"t�|||�|jr|�d�dS)z3
        See SSHTransportBase._keySetup().
        rGN)r|r"rkrf)rQrrr%r%r&r"QszSSHClientTransport._keySetupcCs>|dkr|�td�dS|jjs*d|_dS|��|��dS)a
        Called when we receive a MSG_NEWKEYS message.  No payload.
        If we've finished setting up our own keys, start using them.
        Otherwise, remember that we've received this message.

        @type packet: L{bytes}
        @param packet: The message data.
        rGreNr�)r�r�r�rLrkr$�connectionSecurerr%r%r&rfZs	�zSSHClientTransport.ssh_NEWKEYScCsH|dkrt�d�n$t|�d}||jjkr8|�td�|�|j�dS)z�
        Called when we receive a MSG_SERVICE_ACCEPT message.  Payload::
            string service name

        Start the service we requested.

        @type packet: L{bytes}
        @param packet: The message data.
        rGz"got SERVICE_ACCEPT without payloadrs.received accept for service we did not requestN)rr�r�instancerr�r�r
)rQr�rr%r%r&�ssh_SERVICE_ACCEPTns
�z%SSHClientTransport.ssh_SERVICE_ACCEPTcCs|�tt|j��||_dS)z�
        Request that a service be run over this transport.

        @type instance: subclass of L{twisted.conch.ssh.service.SSHService}
        @param instance: The service to run.
        N)r�r�rrr�)rQr�r%r%r&�requestService�sz!SSHClientTransport.requestServicecCst�t��S)aa
        Returns a Deferred that gets a callback if it is a valid key, or
        an errback if not.

        @type hostKey: L{bytes}
        @param hostKey: The host key to verify.

        @type fingerprint: L{bytes}
        @param fingerprint: The fingerprint of the key.

        @return: A deferred firing with C{True} if the key is valid.
        )rZfail�NotImplementedError)rQrxr�r%r%r&r��s
z SSHClientTransport.verifyHostKeycCs
t��dS)z�
        Called when the encryption has been set up.  Generally,
        requestService() is called to run another service over the transport.
        N)r�r�r%r%r&r��sz#SSHClientTransport.connectionSecureN)r,r-r.r/r�rqrsrrr�r�r�r�r�r�r�r�r"rfr�r�r�r�r%r%r%r&rj�s&	4M$!)	
rjc@seZdZdZdd�ZdS)�_NullEncryptionContextzH
    An encryption context that does not actually encrypt anything.
    cCs|S)z�
        'Encrypt' new data by doing nothing.

        @type data: L{bytes}
        @param data: The data to 'encrypt'.

        @rtype: L{bytes}
        @return: The 'encrypted' data.
        r%)rQrur%r%r&rk�s
z_NullEncryptionContext.updateN)r,r-r.r/rkr%r%r%r&r��sr�c@seZdZdZdZdS)�_DummyAlgorithmzJ
    An encryption algorithm that does not actually encrypt anything.
    �@N)r,r-r.r/rWr%r%r%r&r��sr�c@s&eZdZdZe�Zdd�Zdd�ZdS)r^z�
    A cipher for the none encryption method.

    @ivar block_size: the block size of the encryption.  In the case of the
    none cipher, this is 8 bytes.
    cCst�S)zN
        Construct a noop encryptor.

        @return: The encryptor.
        �r�r�r%r%r&rU�sz_DummyCipher.encryptorcCst�S)zN
        Construct a noop decryptor.

        @return: The decryptor.
        r�r�r%r%r&rX�sz_DummyCipher.decryptorN)r,r-r.r/r�rVrUrXr%r%r%r&r^�s	r^sdiffie-hellman-group14-sha1r�r(rSr�r�r�r��r���"r3�!r�r!�	r����
��ZMSG_Z
MSG_KEXDH_rorIz7legacy SSH mnemonics should not end up in messages dict)ir/Z
__future__rrrDrfrpr#ZhashlibrrrrrZcryptography.exceptionsr	Zcryptography.hazmat.backendsr
Z&cryptography.hazmat.primitives.ciphersrrr
Z)cryptography.hazmat.primitives.asymmetricrZtwistedrr/Ztwisted.internetrrZtwisted.pythonrrZtwisted.python.compatrrr�rZtwisted.conch.sshrrrZtwisted.conch.ssh.commonrrrrrrr r'r*�tupler+r0r{ZProtocolr|r6rj�objectr�r�r^rRZDH_GENERATORZDH_PRIMErrrrr�r�r�r!rorIrmrpr\r�rcZ&DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECTr�r�ZDISCONNECT_RESERVEDr�r�rgr�r�r�ZDISCONNECT_BY_APPLICATIONZDISCONNECT_TOO_MANY_CONNECTIONSZ!DISCONNECT_AUTH_CANCELLED_BY_USERZ)DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLEZDISCONNECT_ILLEGAL_USER_NAMEr��list�globals�itemsrr�r�r�r%r%r%r&�<module>s�$Qt33��
@ Telegram